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     int resample_changed = 0;
1081     AVCodecContext *dec = ist->st->codec;
1082     *out_picture = in_picture;
1083 #if !CONFIG_AVFILTER
1084     resample_changed = ost->resample_width   != dec->width  ||
1085                        ost->resample_height  != dec->height ||
1086                        ost->resample_pix_fmt != dec->pix_fmt;
1087
1088     if (resample_changed) {
1089         av_log(NULL, AV_LOG_INFO,
1090                "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1091                ist->file_index, ist->st->index,
1092                ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1093                dec->width         , dec->height         , av_get_pix_fmt_name(dec->pix_fmt));
1094         ost->resample_width   = dec->width;
1095         ost->resample_height  = dec->height;
1096         ost->resample_pix_fmt = dec->pix_fmt;
1097     }
1098
1099     ost->video_resample = dec->width   != enc->width  ||
1100                           dec->height  != enc->height ||
1101                           dec->pix_fmt != enc->pix_fmt;
1102
1103     if (ost->video_resample) {
1104         *out_picture = &ost->resample_frame;
1105         if (!ost->img_resample_ctx || resample_changed) {
1106             /* initialize the destination picture */
1107             if (!ost->resample_frame.data[0]) {
1108                 avcodec_get_frame_defaults(&ost->resample_frame);
1109                 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1110                                     enc->width, enc->height)) {
1111                     fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1112                     exit_program(1);
1113                 }
1114             }
1115             /* initialize a new scaler context */
1116             sws_freeContext(ost->img_resample_ctx);
1117             ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1118                                                    enc->width, enc->height, enc->pix_fmt,
1119                                                    ost->sws_flags, NULL, NULL, NULL);
1120             if (ost->img_resample_ctx == NULL) {
1121                 fprintf(stderr, "Cannot get resampling context\n");
1122                 exit_program(1);
1123             }
1124         }
1125         sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1126               0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1127     }
1128 #endif
1129 }
1130
1131
1132 static void do_video_out(AVFormatContext *s,
1133                          OutputStream *ost,
1134                          InputStream *ist,
1135                          AVFrame *in_picture,
1136                          int *frame_size, float quality)
1137 {
1138     int nb_frames, i, ret, format_video_sync;
1139     AVFrame *final_picture;
1140     AVCodecContext *enc, *dec;
1141     double sync_ipts;
1142
1143     enc = ost->st->codec;
1144     dec = ist->st->codec;
1145
1146     sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1147
1148     /* by default, we output a single frame */
1149     nb_frames = 1;
1150
1151     *frame_size = 0;
1152
1153     format_video_sync = video_sync_method;
1154     if (format_video_sync < 0)
1155         format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1156
1157     if (format_video_sync) {
1158         double vdelta = sync_ipts - ost->sync_opts;
1159         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1160         if (vdelta < -1.1)
1161             nb_frames = 0;
1162         else if (format_video_sync == 2) {
1163             if(vdelta<=-0.6){
1164                 nb_frames=0;
1165             }else if(vdelta>0.6)
1166                 ost->sync_opts= lrintf(sync_ipts);
1167         }else if (vdelta > 1.1)
1168             nb_frames = lrintf(vdelta);
1169 //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);
1170         if (nb_frames == 0){
1171             ++nb_frames_drop;
1172             if (verbose>2)
1173                 fprintf(stderr, "*** drop!\n");
1174         }else if (nb_frames > 1) {
1175             nb_frames_dup += nb_frames - 1;
1176             if (verbose>2)
1177                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1178         }
1179     }else
1180         ost->sync_opts= lrintf(sync_ipts);
1181
1182     nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1183     if (nb_frames <= 0)
1184         return;
1185
1186     do_video_resample(ost, ist, in_picture, &final_picture);
1187
1188     /* duplicates frame if needed */
1189     for(i=0;i<nb_frames;i++) {
1190         AVPacket pkt;
1191         av_init_packet(&pkt);
1192         pkt.stream_index= ost->index;
1193
1194         if (s->oformat->flags & AVFMT_RAWPICTURE) {
1195             /* raw pictures are written as AVPicture structure to
1196                avoid any copies. We support temporarily the older
1197                method. */
1198             AVFrame* old_frame = enc->coded_frame;
1199             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1200             pkt.data= (uint8_t *)final_picture;
1201             pkt.size=  sizeof(AVPicture);
1202             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1203             pkt.flags |= AV_PKT_FLAG_KEY;
1204
1205             write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1206             enc->coded_frame = old_frame;
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     int i;
1889     InputStream *ist = &input_streams[ist_index];
1890     if (ist->decoding_needed) {
1891         AVCodec *codec = ist->dec;
1892         if (!codec) {
1893             snprintf(error, sizeof(error), "Decoder (codec %s) not found for input stream #%d.%d",
1894                     avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
1895             return AVERROR(EINVAL);
1896         }
1897         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1898             snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
1899                     ist->file_index, ist->st->index);
1900             return AVERROR(EINVAL);
1901         }
1902         assert_codec_experimental(ist->st->codec, 0);
1903         assert_avoptions(ist->opts);
1904     }
1905
1906     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;
1907     ist->next_pts = AV_NOPTS_VALUE;
1908     ist->is_start = 1;
1909
1910     return 0;
1911 }
1912
1913 static int transcode_init(OutputFile *output_files,
1914                           int nb_output_files,
1915                           InputFile *input_files,
1916                           int nb_input_files)
1917 {
1918     int ret = 0, i;
1919     AVFormatContext *os;
1920     AVCodecContext *codec, *icodec;
1921     OutputStream *ost;
1922     InputStream *ist;
1923     char error[1024];
1924     int want_sdp = 1;
1925
1926     if (rate_emu)
1927         for (i = 0; i < nb_input_streams; i++)
1928             input_streams[i].start = av_gettime();
1929
1930     /* output stream init */
1931     for(i=0;i<nb_output_files;i++) {
1932         os = output_files[i].ctx;
1933         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1934             av_dump_format(os, i, os->filename, 1);
1935             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1936             return AVERROR(EINVAL);
1937         }
1938     }
1939
1940     /* for each output stream, we compute the right encoding parameters */
1941     for (i = 0; i < nb_output_streams; i++) {
1942         ost = &output_streams[i];
1943         os = output_files[ost->file_index].ctx;
1944         ist = &input_streams[ost->source_index];
1945
1946         codec = ost->st->codec;
1947         icodec = ist->st->codec;
1948
1949         ost->st->disposition = ist->st->disposition;
1950         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1951         codec->chroma_sample_location = icodec->chroma_sample_location;
1952
1953         if (ost->st->stream_copy) {
1954             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1955
1956             if (extra_size > INT_MAX) {
1957                 return AVERROR(EINVAL);
1958             }
1959
1960             /* if stream_copy is selected, no need to decode or encode */
1961             codec->codec_id = icodec->codec_id;
1962             codec->codec_type = icodec->codec_type;
1963
1964             if(!codec->codec_tag){
1965                 if(   !os->oformat->codec_tag
1966                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1967                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1968                     codec->codec_tag = icodec->codec_tag;
1969             }
1970
1971             codec->bit_rate = icodec->bit_rate;
1972             codec->rc_max_rate    = icodec->rc_max_rate;
1973             codec->rc_buffer_size = icodec->rc_buffer_size;
1974             codec->extradata= av_mallocz(extra_size);
1975             if (!codec->extradata) {
1976                 return AVERROR(ENOMEM);
1977             }
1978             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1979             codec->extradata_size= icodec->extradata_size;
1980
1981             codec->time_base = ist->st->time_base;
1982             if(!strcmp(os->oformat->name, "avi")) {
1983                 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){
1984                     codec->time_base = icodec->time_base;
1985                     codec->time_base.num *= icodec->ticks_per_frame;
1986                     codec->time_base.den *= 2;
1987                 }
1988             } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
1989                 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){
1990                     codec->time_base = icodec->time_base;
1991                     codec->time_base.num *= icodec->ticks_per_frame;
1992                 }
1993             }
1994             av_reduce(&codec->time_base.num, &codec->time_base.den,
1995                         codec->time_base.num, codec->time_base.den, INT_MAX);
1996
1997             switch(codec->codec_type) {
1998             case AVMEDIA_TYPE_AUDIO:
1999                 if(audio_volume != 256) {
2000                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2001                     exit_program(1);
2002                 }
2003                 codec->channel_layout = icodec->channel_layout;
2004                 codec->sample_rate = icodec->sample_rate;
2005                 codec->channels = icodec->channels;
2006                 codec->frame_size = icodec->frame_size;
2007                 codec->audio_service_type = icodec->audio_service_type;
2008                 codec->block_align= icodec->block_align;
2009                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2010                     codec->block_align= 0;
2011                 if(codec->codec_id == CODEC_ID_AC3)
2012                     codec->block_align= 0;
2013                 break;
2014             case AVMEDIA_TYPE_VIDEO:
2015                 codec->pix_fmt = icodec->pix_fmt;
2016                 codec->width = icodec->width;
2017                 codec->height = icodec->height;
2018                 codec->has_b_frames = icodec->has_b_frames;
2019                 if (!codec->sample_aspect_ratio.num) {
2020                     codec->sample_aspect_ratio =
2021                     ost->st->sample_aspect_ratio =
2022                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2023                         ist->st->codec->sample_aspect_ratio.num ?
2024                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2025                 }
2026                 break;
2027             case AVMEDIA_TYPE_SUBTITLE:
2028                 codec->width = icodec->width;
2029                 codec->height = icodec->height;
2030                 break;
2031             case AVMEDIA_TYPE_DATA:
2032                 break;
2033             default:
2034                 abort();
2035             }
2036         } else {
2037             if (!ost->enc)
2038                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2039             switch(codec->codec_type) {
2040             case AVMEDIA_TYPE_AUDIO:
2041                 ost->fifo= av_fifo_alloc(1024);
2042                 if (!ost->fifo) {
2043                     return AVERROR(ENOMEM);
2044                 }
2045                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2046                 if (!codec->sample_rate) {
2047                     codec->sample_rate = icodec->sample_rate;
2048                 }
2049                 choose_sample_rate(ost->st, ost->enc);
2050                 codec->time_base = (AVRational){1, codec->sample_rate};
2051                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2052                     codec->sample_fmt = icodec->sample_fmt;
2053                 choose_sample_fmt(ost->st, ost->enc);
2054                 if (!codec->channels) {
2055                     codec->channels = icodec->channels;
2056                     codec->channel_layout = icodec->channel_layout;
2057                 }
2058                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2059                     codec->channel_layout = 0;
2060                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2061                 icodec->request_channels = codec->channels;
2062                 ist->decoding_needed = 1;
2063                 ost->encoding_needed = 1;
2064                 ost->resample_sample_fmt  = icodec->sample_fmt;
2065                 ost->resample_sample_rate = icodec->sample_rate;
2066                 ost->resample_channels    = icodec->channels;
2067                 break;
2068             case AVMEDIA_TYPE_VIDEO:
2069                 if (codec->pix_fmt == PIX_FMT_NONE)
2070                     codec->pix_fmt = icodec->pix_fmt;
2071                 choose_pixel_fmt(ost->st, ost->enc);
2072
2073                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2074                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2075                     exit_program(1);
2076                 }
2077
2078                 if (!codec->width || !codec->height) {
2079                     codec->width  = icodec->width;
2080                     codec->height = icodec->height;
2081                 }
2082
2083                 ost->video_resample = codec->width   != icodec->width  ||
2084                                       codec->height  != icodec->height ||
2085                                       codec->pix_fmt != icodec->pix_fmt;
2086                 if (ost->video_resample) {
2087                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2088                 }
2089
2090                 ost->resample_height = icodec->height;
2091                 ost->resample_width  = icodec->width;
2092                 ost->resample_pix_fmt= icodec->pix_fmt;
2093                 ost->encoding_needed = 1;
2094                 ist->decoding_needed = 1;
2095
2096                 if (!ost->frame_rate.num)
2097                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2098                 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2099                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2100                     ost->frame_rate = ost->enc->supported_framerates[idx];
2101                 }
2102                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2103                 if(   av_q2d(codec->time_base) < 0.001 && video_sync_method
2104                    && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2105                     av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2106                                                "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2107                 }
2108
2109 #if CONFIG_AVFILTER
2110                 if (configure_video_filters(ist, ost)) {
2111                     fprintf(stderr, "Error opening filters!\n");
2112                     exit(1);
2113                 }
2114 #endif
2115                 break;
2116             case AVMEDIA_TYPE_SUBTITLE:
2117                 ost->encoding_needed = 1;
2118                 ist->decoding_needed = 1;
2119                 break;
2120             default:
2121                 abort();
2122                 break;
2123             }
2124             /* two pass mode */
2125             if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2126                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2127                 char logfilename[1024];
2128                 FILE *f;
2129
2130                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2131                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2132                          i);
2133                 if (codec->flags & CODEC_FLAG_PASS1) {
2134                     f = fopen(logfilename, "wb");
2135                     if (!f) {
2136                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2137                         exit_program(1);
2138                     }
2139                     ost->logfile = f;
2140                 } else {
2141                     char  *logbuffer;
2142                     size_t logbuffer_size;
2143                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2144                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2145                         exit_program(1);
2146                     }
2147                     codec->stats_in = logbuffer;
2148                 }
2149             }
2150         }
2151         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2152             /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2153             int size= codec->width * codec->height;
2154             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2155         }
2156     }
2157
2158     if (!bit_buffer)
2159         bit_buffer = av_malloc(bit_buffer_size);
2160     if (!bit_buffer) {
2161         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2162                 bit_buffer_size);
2163         return AVERROR(ENOMEM);
2164     }
2165
2166     /* open each encoder */
2167     for (i = 0; i < nb_output_streams; i++) {
2168         ost = &output_streams[i];
2169         if (ost->encoding_needed) {
2170             AVCodec *codec = ost->enc;
2171             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2172             if (!codec) {
2173                 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
2174                          avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2175                 ret = AVERROR(EINVAL);
2176                 goto dump_format;
2177             }
2178             if (dec->subtitle_header) {
2179                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2180                 if (!ost->st->codec->subtitle_header) {
2181                     ret = AVERROR(ENOMEM);
2182                     goto dump_format;
2183                 }
2184                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2185                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2186             }
2187             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2188                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2189                         ost->file_index, ost->index);
2190                 ret = AVERROR(EINVAL);
2191                 goto dump_format;
2192             }
2193             assert_codec_experimental(ost->st->codec, 1);
2194             assert_avoptions(ost->opts);
2195             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2196                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2197                                              "It takes bits/s as argument, not kbits/s\n");
2198             extra_size += ost->st->codec->extradata_size;
2199         }
2200     }
2201
2202     /* init input streams */
2203     for (i = 0; i < nb_input_streams; i++)
2204         if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error)) < 0))
2205             goto dump_format;
2206
2207     /* open files and write file headers */
2208     for (i = 0; i < nb_output_files; i++) {
2209         os = output_files[i].ctx;
2210         if (avformat_write_header(os, &output_files[i].opts) < 0) {
2211             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2212             ret = AVERROR(EINVAL);
2213             goto dump_format;
2214         }
2215 //        assert_avoptions(output_files[i].opts);
2216         if (strcmp(os->oformat->name, "rtp")) {
2217             want_sdp = 0;
2218         }
2219     }
2220
2221  dump_format:
2222     /* dump the file output parameters - cannot be done before in case
2223        of stream copy */
2224     for(i=0;i<nb_output_files;i++) {
2225         av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2226     }
2227
2228     /* dump the stream mapping */
2229     if (verbose >= 0) {
2230         fprintf(stderr, "Stream mapping:\n");
2231         for (i = 0; i < nb_output_streams;i ++) {
2232             ost = &output_streams[i];
2233             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2234                     input_streams[ost->source_index].file_index,
2235                     input_streams[ost->source_index].st->index,
2236                     ost->file_index,
2237                     ost->index);
2238             if (ost->sync_ist != &input_streams[ost->source_index])
2239                 fprintf(stderr, " [sync #%d.%d]",
2240                         ost->sync_ist->file_index,
2241                         ost->sync_ist->st->index);
2242             if (ost->st->stream_copy)
2243                 fprintf(stderr, " (copy)");
2244             else
2245                 fprintf(stderr, " (%s -> %s)", input_streams[ost->source_index].dec ?
2246                         input_streams[ost->source_index].dec->name : "?",
2247                         ost->enc ? ost->enc->name : "?");
2248             fprintf(stderr, "\n");
2249         }
2250     }
2251
2252     if (ret) {
2253         fprintf(stderr, "%s\n", error);
2254         return ret;
2255     }
2256
2257     if (want_sdp) {
2258         print_sdp(output_files, nb_output_files);
2259     }
2260
2261     return 0;
2262 }
2263
2264 /*
2265  * The following code is the main loop of the file converter
2266  */
2267 static int transcode(OutputFile *output_files,
2268                      int nb_output_files,
2269                      InputFile *input_files,
2270                      int nb_input_files)
2271 {
2272     int ret, i;
2273     AVFormatContext *is, *os;
2274     OutputStream *ost;
2275     InputStream *ist;
2276     uint8_t *no_packet;
2277     int no_packet_count=0;
2278     int64_t timer_start;
2279     int key;
2280
2281     if (!(no_packet = av_mallocz(nb_input_files)))
2282         exit_program(1);
2283
2284     ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2285     if (ret < 0)
2286         goto fail;
2287
2288     if (!using_stdin) {
2289         if(verbose >= 0)
2290             fprintf(stderr, "Press [q] to stop, [?] for help\n");
2291         avio_set_interrupt_cb(decode_interrupt_cb);
2292     }
2293     term_init();
2294
2295     timer_start = av_gettime();
2296
2297     for(; received_sigterm == 0;) {
2298         int file_index, ist_index;
2299         AVPacket pkt;
2300         int64_t ipts_min;
2301         double opts_min;
2302
2303         ipts_min= INT64_MAX;
2304         opts_min= 1e100;
2305         /* if 'q' pressed, exits */
2306         if (!using_stdin) {
2307             if (q_pressed)
2308                 break;
2309             /* read_key() returns 0 on EOF */
2310             key = read_key();
2311             if (key == 'q')
2312                 break;
2313             if (key == '+') verbose++;
2314             if (key == '-') verbose--;
2315             if (key == 's') qp_hist     ^= 1;
2316             if (key == 'h'){
2317                 if (do_hex_dump){
2318                     do_hex_dump = do_pkt_dump = 0;
2319                 } else if(do_pkt_dump){
2320                     do_hex_dump = 1;
2321                 } else
2322                     do_pkt_dump = 1;
2323                 av_log_set_level(AV_LOG_DEBUG);
2324             }
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             if (key == 'd' || key == 'D'){
2352                 int debug=0;
2353                 if(key == 'D') {
2354                     debug = input_streams[0].st->codec->debug<<1;
2355                     if(!debug) debug = 1;
2356                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2357                         debug += debug;
2358                 }else
2359                     scanf("%d", &debug);
2360                 for(i=0;i<nb_input_streams;i++) {
2361                     input_streams[i].st->codec->debug = debug;
2362                 }
2363                 for(i=0;i<nb_output_streams;i++) {
2364                     ost = &output_streams[i];
2365                     ost->st->codec->debug = debug;
2366                 }
2367                 if(debug) av_log_set_level(AV_LOG_DEBUG);
2368                 fprintf(stderr,"debug=%d\n", debug);
2369             }
2370             if (key == '?'){
2371                 fprintf(stderr, "key    function\n"
2372                                 "?      show this help\n"
2373                                 "+      increase verbosity\n"
2374                                 "-      decrease verbosity\n"
2375                                 "c      Send command to filtergraph\n"
2376                                 "D      cycle through available debug modes\n"
2377                                 "h      dump packets/hex press to cycle through the 3 states\n"
2378                                 "q      quit\n"
2379                                 "s      Show QP histogram\n"
2380                 );
2381             }
2382         }
2383
2384         /* select the stream that we must read now by looking at the
2385            smallest output pts */
2386         file_index = -1;
2387         for (i = 0; i < nb_output_streams; i++) {
2388             OutputFile *of;
2389             int64_t ipts;
2390             double  opts;
2391             ost = &output_streams[i];
2392             of = &output_files[ost->file_index];
2393             os = output_files[ost->file_index].ctx;
2394             ist = &input_streams[ost->source_index];
2395             if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2396                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2397                 continue;
2398             opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2399             ipts = ist->pts;
2400             if (!input_files[ist->file_index].eof_reached){
2401                 if(ipts < ipts_min) {
2402                     ipts_min = ipts;
2403                     if(input_sync ) file_index = ist->file_index;
2404                 }
2405                 if(opts < opts_min) {
2406                     opts_min = opts;
2407                     if(!input_sync) file_index = ist->file_index;
2408                 }
2409             }
2410             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2411                 file_index= -1;
2412                 break;
2413             }
2414         }
2415         /* if none, if is finished */
2416         if (file_index < 0) {
2417             if(no_packet_count){
2418                 no_packet_count=0;
2419                 memset(no_packet, 0, nb_input_files);
2420                 usleep(10000);
2421                 continue;
2422             }
2423             break;
2424         }
2425
2426         /* read a frame from it and output it in the fifo */
2427         is = input_files[file_index].ctx;
2428         ret= av_read_frame(is, &pkt);
2429         if(ret == AVERROR(EAGAIN)){
2430             no_packet[file_index]=1;
2431             no_packet_count++;
2432             continue;
2433         }
2434         if (ret < 0) {
2435             input_files[file_index].eof_reached = 1;
2436             if (opt_shortest)
2437                 break;
2438             else
2439                 continue;
2440         }
2441
2442         no_packet_count=0;
2443         memset(no_packet, 0, nb_input_files);
2444
2445         if (do_pkt_dump) {
2446             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2447                              is->streams[pkt.stream_index]);
2448         }
2449         /* the following test is needed in case new streams appear
2450            dynamically in stream : we ignore them */
2451         if (pkt.stream_index >= input_files[file_index].nb_streams)
2452             goto discard_packet;
2453         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2454         ist = &input_streams[ist_index];
2455         if (ist->discard)
2456             goto discard_packet;
2457
2458         if (pkt.dts != AV_NOPTS_VALUE)
2459             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2460         if (pkt.pts != AV_NOPTS_VALUE)
2461             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2462
2463         if (ist->ts_scale) {
2464             if(pkt.pts != AV_NOPTS_VALUE)
2465                 pkt.pts *= ist->ts_scale;
2466             if(pkt.dts != AV_NOPTS_VALUE)
2467                 pkt.dts *= ist->ts_scale;
2468         }
2469
2470 //        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);
2471         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2472             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2473             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2474             int64_t delta= pkt_dts - ist->next_pts;
2475             if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2476                 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2477                  ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2478                 pkt_dts+1<ist->pts)&& !copy_ts){
2479                 input_files[ist->file_index].ts_offset -= delta;
2480                 if (verbose > 2)
2481                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2482                             delta, input_files[ist->file_index].ts_offset);
2483                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2484                 if(pkt.pts != AV_NOPTS_VALUE)
2485                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2486             }
2487         }
2488
2489         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2490         if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2491
2492             if (verbose >= 0)
2493                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2494                         ist->file_index, ist->st->index);
2495             if (exit_on_error)
2496                 exit_program(1);
2497             av_free_packet(&pkt);
2498             continue;
2499         }
2500
2501     discard_packet:
2502         av_free_packet(&pkt);
2503
2504         /* dump report by using the output first video and audio streams */
2505         print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2506     }
2507
2508     /* at the end of stream, we must flush the decoder buffers */
2509     for (i = 0; i < nb_input_streams; i++) {
2510         ist = &input_streams[i];
2511         if (ist->decoding_needed) {
2512             output_packet(ist, i, output_streams, nb_output_streams, NULL);
2513         }
2514     }
2515     flush_encoders(output_streams, nb_output_streams);
2516
2517     term_exit();
2518
2519     /* write the trailer if needed and close file */
2520     for(i=0;i<nb_output_files;i++) {
2521         os = output_files[i].ctx;
2522         av_write_trailer(os);
2523     }
2524
2525     /* dump report by using the first video and audio streams */
2526     print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2527
2528     /* close each encoder */
2529     for (i = 0; i < nb_output_streams; i++) {
2530         ost = &output_streams[i];
2531         if (ost->encoding_needed) {
2532             av_freep(&ost->st->codec->stats_in);
2533             avcodec_close(ost->st->codec);
2534         }
2535 #if CONFIG_AVFILTER
2536         avfilter_graph_free(&ost->graph);
2537 #endif
2538     }
2539
2540     /* close each decoder */
2541     for (i = 0; i < nb_input_streams; i++) {
2542         ist = &input_streams[i];
2543         if (ist->decoding_needed) {
2544             avcodec_close(ist->st->codec);
2545         }
2546     }
2547
2548     /* finished ! */
2549     ret = 0;
2550
2551  fail:
2552     av_freep(&bit_buffer);
2553     av_freep(&no_packet);
2554
2555     if (output_streams) {
2556         for (i = 0; i < nb_output_streams; i++) {
2557             ost = &output_streams[i];
2558             if (ost) {
2559                 if (ost->st->stream_copy)
2560                     av_freep(&ost->st->codec->extradata);
2561                 if (ost->logfile) {
2562                     fclose(ost->logfile);
2563                     ost->logfile = NULL;
2564                 }
2565                 av_fifo_free(ost->fifo); /* works even if fifo is not
2566                                              initialized but set to zero */
2567                 av_freep(&ost->st->codec->subtitle_header);
2568                 av_free(ost->resample_frame.data[0]);
2569                 av_free(ost->forced_kf_pts);
2570                 if (ost->video_resample)
2571                     sws_freeContext(ost->img_resample_ctx);
2572                 if (ost->resample)
2573                     audio_resample_close(ost->resample);
2574                 if (ost->reformat_ctx)
2575                     av_audio_convert_free(ost->reformat_ctx);
2576                 av_dict_free(&ost->opts);
2577             }
2578         }
2579     }
2580     return ret;
2581 }
2582
2583 static int opt_format(const char *opt, const char *arg)
2584 {
2585     last_asked_format = arg;
2586     return 0;
2587 }
2588
2589 static int opt_video_rc_override_string(const char *opt, const char *arg)
2590 {
2591     video_rc_override_string = arg;
2592     return 0;
2593 }
2594
2595 static int opt_me_threshold(const char *opt, const char *arg)
2596 {
2597     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2598     return 0;
2599 }
2600
2601 static int opt_verbose(const char *opt, const char *arg)
2602 {
2603     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2604     return 0;
2605 }
2606
2607 static int opt_frame_rate(const char *opt, const char *arg)
2608 {
2609     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2610         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2611         exit_program(1);
2612     }
2613     return 0;
2614 }
2615
2616 static int opt_frame_crop(const char *opt, const char *arg)
2617 {
2618     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2619     return AVERROR(EINVAL);
2620 }
2621
2622 static int opt_frame_size(const char *opt, const char *arg)
2623 {
2624     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2625         fprintf(stderr, "Incorrect frame size\n");
2626         return AVERROR(EINVAL);
2627     }
2628     return 0;
2629 }
2630
2631 static int opt_pad(const char *opt, const char *arg) {
2632     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2633     return -1;
2634 }
2635
2636 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2637 {
2638     if (strcmp(arg, "list")) {
2639         frame_pix_fmt = av_get_pix_fmt(arg);
2640         if (frame_pix_fmt == PIX_FMT_NONE) {
2641             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2642             return AVERROR(EINVAL);
2643         }
2644     } else {
2645         opt_pix_fmts(NULL, NULL);
2646         exit_program(0);
2647     }
2648     return 0;
2649 }
2650
2651 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2652 {
2653     int x = 0, y = 0;
2654     double ar = 0;
2655     const char *p;
2656     char *end;
2657
2658     p = strchr(arg, ':');
2659     if (p) {
2660         x = strtol(arg, &end, 10);
2661         if (end == p)
2662             y = strtol(end+1, &end, 10);
2663         if (x > 0 && y > 0)
2664             ar = (double)x / (double)y;
2665     } else
2666         ar = strtod(arg, NULL);
2667
2668     if (!ar) {
2669         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2670         return AVERROR(EINVAL);
2671     }
2672     frame_aspect_ratio = ar;
2673     return 0;
2674 }
2675
2676 static int opt_metadata(const char *opt, const char *arg)
2677 {
2678     char *mid= strchr(arg, '=');
2679
2680     if(!mid){
2681         fprintf(stderr, "Missing =\n");
2682         exit_program(1);
2683     }
2684     *mid++= 0;
2685
2686     av_dict_set(&metadata, arg, mid, 0);
2687
2688     return 0;
2689 }
2690
2691 static int opt_qscale(const char *opt, const char *arg)
2692 {
2693     video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2694     if (video_qscale <= 0 || video_qscale > 255) {
2695         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2696         return AVERROR(EINVAL);
2697     }
2698     return 0;
2699 }
2700
2701 static int opt_top_field_first(const char *opt, const char *arg)
2702 {
2703     top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2704     return opt_default(opt, arg);
2705 }
2706
2707 static int opt_thread_count(const char *opt, const char *arg)
2708 {
2709     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2710 #if !HAVE_THREADS
2711     if (verbose >= 0)
2712         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2713 #endif
2714     return 0;
2715 }
2716
2717 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2718 {
2719     if (strcmp(arg, "list")) {
2720         audio_sample_fmt = av_get_sample_fmt(arg);
2721         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2722             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2723             return AVERROR(EINVAL);
2724         }
2725     } else {
2726         int i;
2727         char fmt_str[128];
2728         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2729             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2730         exit_program(0);
2731     }
2732     return 0;
2733 }
2734
2735 static int opt_audio_rate(const char *opt, const char *arg)
2736 {
2737     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2738     return 0;
2739 }
2740
2741 static int opt_audio_channels(const char *opt, const char *arg)
2742 {
2743     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2744     return 0;
2745 }
2746
2747 static int opt_video_channel(const char *opt, const char *arg)
2748 {
2749     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2750     return opt_default("channel", arg);
2751 }
2752
2753 static int opt_video_standard(const char *opt, const char *arg)
2754 {
2755     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2756     return opt_default("standard", arg);
2757 }
2758
2759 static int opt_codec(const char *opt, const char *arg)
2760 {
2761     return av_dict_set(&codec_names, opt, arg, 0);
2762 }
2763
2764 static int opt_audio_codec(const char *opt, const char *arg)
2765 {
2766     return opt_codec("codec:a", arg);
2767 }
2768
2769 static int opt_video_codec(const char *opt, const char *arg)
2770 {
2771     return opt_codec("codec:v", arg);
2772 }
2773
2774 static int opt_subtitle_codec(const char *opt, const char *arg)
2775 {
2776     return opt_codec("codec:s", arg);
2777 }
2778
2779 static int opt_data_codec(const char *opt, const char *arg)
2780 {
2781     return opt_codec("codec:d", arg);
2782 }
2783
2784 static int opt_codec_tag(const char *opt, const char *arg)
2785 {
2786     char *tail;
2787     uint32_t *codec_tag;
2788
2789     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2790                 !strcmp(opt, "vtag") ? &video_codec_tag :
2791                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2792     if (!codec_tag)
2793         return -1;
2794
2795     *codec_tag = strtol(arg, &tail, 0);
2796     if (!tail || *tail)
2797         *codec_tag = AV_RL32(arg);
2798
2799     return 0;
2800 }
2801
2802 static int opt_map(const char *opt, const char *arg)
2803 {
2804     StreamMap *m = NULL;
2805     int i, negative = 0, file_idx;
2806     int sync_file_idx = -1, sync_stream_idx;
2807     char *p, *sync;
2808     char *map;
2809
2810     if (*arg == '-') {
2811         negative = 1;
2812         arg++;
2813     }
2814     map = av_strdup(arg);
2815
2816     /* parse sync stream first, just pick first matching stream */
2817     if (sync = strchr(map, ',')) {
2818         *sync = 0;
2819         sync_file_idx = strtol(sync + 1, &sync, 0);
2820         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2821             av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2822             exit_program(1);
2823         }
2824         if (*sync)
2825             sync++;
2826         for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2827             if (check_stream_specifier(input_files[sync_file_idx].ctx,
2828                                        input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2829                 sync_stream_idx = i;
2830                 break;
2831             }
2832         if (i == input_files[sync_file_idx].nb_streams) {
2833             av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2834                                        "match any streams.\n", arg);
2835             exit_program(1);
2836         }
2837     }
2838
2839
2840     file_idx = strtol(map, &p, 0);
2841     if (file_idx >= nb_input_files || file_idx < 0) {
2842         av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2843         exit_program(1);
2844     }
2845     if (negative)
2846         /* disable some already defined maps */
2847         for (i = 0; i < nb_stream_maps; i++) {
2848             m = &stream_maps[i];
2849             if (check_stream_specifier(input_files[m->file_index].ctx,
2850                                        input_files[m->file_index].ctx->streams[m->stream_index],
2851                                        *p == ':' ? p + 1 : p) > 0)
2852                 m->disabled = 1;
2853         }
2854     else
2855         for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2856             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2857                         *p == ':' ? p + 1 : p) <= 0)
2858                 continue;
2859             stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2860             m = &stream_maps[nb_stream_maps - 1];
2861
2862             m->file_index   = file_idx;
2863             m->stream_index = i;
2864
2865             if (sync_file_idx >= 0) {
2866                 m->sync_file_index   = sync_file_idx;
2867                 m->sync_stream_index = sync_stream_idx;
2868             } else {
2869                 m->sync_file_index   = file_idx;
2870                 m->sync_stream_index = i;
2871             }
2872         }
2873
2874     if (!m) {
2875         av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2876         exit_program(1);
2877     }
2878
2879     av_freep(&map);
2880     return 0;
2881 }
2882
2883 static void parse_meta_type(char *arg, char *type, int *index)
2884 {
2885     if (*arg == ':') {
2886         *type = *(++arg);
2887         switch (*arg) {
2888         case 'g':
2889             break;
2890         case 's':
2891         case 'c':
2892         case 'p':
2893             if (*(++arg) == ':')
2894                 *index = strtol(++arg, NULL, 0);
2895             break;
2896         default:
2897             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2898             exit_program(1);
2899         }
2900     } else
2901         *type = 'g';
2902 }
2903
2904 static int opt_map_metadata(const char *opt, const char *arg)
2905 {
2906     MetadataMap *m, *m1;
2907     char *p;
2908
2909     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2910                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
2911
2912     m = &meta_data_maps[nb_meta_data_maps - 1][1];
2913     m->file = strtol(arg, &p, 0);
2914     parse_meta_type(p, &m->type, &m->index);
2915
2916     m1 = &meta_data_maps[nb_meta_data_maps - 1][0];
2917     if (p = strchr(opt, ':'))
2918         parse_meta_type(p, &m1->type, &m1->index);
2919     else
2920         m1->type = 'g';
2921
2922     if (m->type == 'g' || m1->type == 'g')
2923         metadata_global_autocopy = 0;
2924     if (m->type == 's' || m1->type == 's')
2925         metadata_streams_autocopy = 0;
2926     if (m->type == 'c' || m1->type == 'c')
2927         metadata_chapters_autocopy = 0;
2928
2929     return 0;
2930 }
2931
2932 static int opt_map_meta_data(const char *opt, const char *arg)
2933 {
2934     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2935                     "Use -map_metadata instead.\n");
2936     return opt_map_metadata(opt, arg);
2937 }
2938
2939 static int opt_input_ts_scale(const char *opt, const char *arg)
2940 {
2941     return av_dict_set(&ts_scale, opt, arg, 0);
2942 }
2943
2944 static int opt_recording_time(const char *opt, const char *arg)
2945 {
2946     recording_time = parse_time_or_die(opt, arg, 1);
2947     return 0;
2948 }
2949
2950 static int opt_start_time(const char *opt, const char *arg)
2951 {
2952     start_time = parse_time_or_die(opt, arg, 1);
2953     return 0;
2954 }
2955
2956 static int opt_recording_timestamp(const char *opt, const char *arg)
2957 {
2958     char buf[128];
2959     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
2960     struct tm time = *gmtime((time_t*)&recording_timestamp);
2961     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
2962     opt_metadata("metadata", buf);
2963
2964     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
2965                                  "tag instead.\n", opt);
2966     return 0;
2967 }
2968
2969 static int opt_input_ts_offset(const char *opt, const char *arg)
2970 {
2971     input_ts_offset = parse_time_or_die(opt, arg, 1);
2972     return 0;
2973 }
2974
2975 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2976 {
2977     const char *codec_string = encoder ? "encoder" : "decoder";
2978     AVCodec *codec;
2979
2980     if(!name)
2981         return CODEC_ID_NONE;
2982     codec = encoder ?
2983         avcodec_find_encoder_by_name(name) :
2984         avcodec_find_decoder_by_name(name);
2985     if(!codec) {
2986         av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2987         exit_program(1);
2988     }
2989     if(codec->type != type) {
2990         av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2991         exit_program(1);
2992     }
2993     return codec->id;
2994 }
2995
2996 static AVCodec *choose_codec(AVFormatContext *s, AVStream *st, enum AVMediaType type, AVDictionary *codec_names)
2997 {
2998     AVDictionaryEntry *e = NULL;
2999     char *codec_name = NULL;
3000     int ret;
3001
3002     while (e = av_dict_get(codec_names, "", e, AV_DICT_IGNORE_SUFFIX)) {
3003         char *p = strchr(e->key, ':');
3004
3005         if ((ret = check_stream_specifier(s, st, p ? p + 1 : "")) > 0)
3006             codec_name = e->value;
3007         else if (ret < 0)
3008             exit_program(1);
3009     }
3010
3011     if (!codec_name) {
3012         if (s->oformat) {
3013             st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
3014             return avcodec_find_encoder(st->codec->codec_id);
3015         }
3016     } else if (!strcmp(codec_name, "copy"))
3017         st->stream_copy = 1;
3018     else {
3019         st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
3020         return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
3021                             avcodec_find_decoder_by_name(codec_name);
3022     }
3023
3024     return NULL;
3025 }
3026
3027 /**
3028  * Add all the streams from the given input file to the global
3029  * list of input streams.
3030  */
3031 static void add_input_streams(AVFormatContext *ic)
3032 {
3033     int i, rfps, rfps_base, ret;
3034
3035     for (i = 0; i < ic->nb_streams; i++) {
3036         AVStream *st = ic->streams[i];
3037         AVCodecContext *dec = st->codec;
3038         AVDictionaryEntry *e = NULL;
3039         InputStream *ist;
3040         char *scale = NULL;
3041
3042         dec->thread_count = thread_count;
3043
3044         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3045         ist = &input_streams[nb_input_streams - 1];
3046         ist->st = st;
3047         ist->file_index = nb_input_files;
3048         ist->discard = 1;
3049         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3050
3051         while (e = av_dict_get(ts_scale, "", e, AV_DICT_IGNORE_SUFFIX)) {
3052             char *p = strchr(e->key, ':');
3053
3054             if ((ret = check_stream_specifier(ic, st, p ? p + 1 : "")) > 0)
3055                 scale = e->value;
3056             else if (ret < 0)
3057                 exit_program(1);
3058         }
3059         if (scale)
3060             ist->ts_scale = strtod(scale, NULL);
3061
3062         ist->dec = choose_codec(ic, st, dec->codec_type, codec_names);
3063         if (!ist->dec)
3064             ist->dec = avcodec_find_decoder(dec->codec_id);
3065
3066         switch (dec->codec_type) {
3067         case AVMEDIA_TYPE_AUDIO:
3068             if(!ist->dec)
3069                 ist->dec = avcodec_find_decoder(dec->codec_id);
3070             if(audio_disable)
3071                 st->discard= AVDISCARD_ALL;
3072             break;
3073         case AVMEDIA_TYPE_VIDEO:
3074             if(!ist->dec)
3075                 ist->dec = avcodec_find_decoder(dec->codec_id);
3076             rfps      = ic->streams[i]->r_frame_rate.num;
3077             rfps_base = ic->streams[i]->r_frame_rate.den;
3078             if (dec->lowres) {
3079                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3080             }
3081             if(me_threshold)
3082                 dec->debug |= FF_DEBUG_MV;
3083
3084             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3085
3086                 if (verbose >= 0)
3087                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3088                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3089
3090                     (float)rfps / rfps_base, rfps, rfps_base);
3091             }
3092
3093             if(video_disable)
3094                 st->discard= AVDISCARD_ALL;
3095             else if(video_discard)
3096                 st->discard= video_discard;
3097             break;
3098         case AVMEDIA_TYPE_DATA:
3099             break;
3100         case AVMEDIA_TYPE_SUBTITLE:
3101             if(!ist->dec)
3102                 ist->dec = avcodec_find_decoder(dec->codec_id);
3103             if(subtitle_disable)
3104                 st->discard = AVDISCARD_ALL;
3105             break;
3106         case AVMEDIA_TYPE_ATTACHMENT:
3107         case AVMEDIA_TYPE_UNKNOWN:
3108             break;
3109         default:
3110             abort();
3111         }
3112     }
3113 }
3114
3115 static int opt_input_file(const char *opt, const char *filename)
3116 {
3117     AVFormatContext *ic;
3118     AVInputFormat *file_iformat = NULL;
3119     int err, i, ret;
3120     int64_t timestamp;
3121     uint8_t buf[128];
3122     AVDictionary **opts;
3123     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3124
3125     if (last_asked_format) {
3126         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3127             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3128             exit_program(1);
3129         }
3130         last_asked_format = NULL;
3131     }
3132
3133     if (!strcmp(filename, "-"))
3134         filename = "pipe:";
3135
3136     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3137                     !strcmp(filename, "/dev/stdin");
3138
3139     /* get default parameters from command line */
3140     ic = avformat_alloc_context();
3141     if (!ic) {
3142         print_error(filename, AVERROR(ENOMEM));
3143         exit_program(1);
3144     }
3145     if (audio_sample_rate) {
3146         snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3147         av_dict_set(&format_opts, "sample_rate", buf, 0);
3148     }
3149     if (audio_channels) {
3150         snprintf(buf, sizeof(buf), "%d", audio_channels);
3151         av_dict_set(&format_opts, "channels", buf, 0);
3152     }
3153     if (frame_rate.num) {
3154         snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3155         av_dict_set(&format_opts, "framerate", buf, 0);
3156     }
3157     if (frame_width && frame_height) {
3158         snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3159         av_dict_set(&format_opts, "video_size", buf, 0);
3160     }
3161     if (frame_pix_fmt != PIX_FMT_NONE)
3162         av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3163
3164     ic->flags |= AVFMT_FLAG_NONBLOCK;
3165
3166     if (loop_input) {
3167         av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3168         ic->loop_input = loop_input;
3169     }
3170
3171     /* open the input file with generic libav function */
3172     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3173     if (err < 0) {
3174         print_error(filename, err);
3175         exit_program(1);
3176     }
3177     assert_avoptions(format_opts);
3178
3179     if(opt_programid) {
3180         int i, j;
3181         int found=0;
3182         for(i=0; i<ic->nb_streams; i++){
3183             ic->streams[i]->discard= AVDISCARD_ALL;
3184         }
3185         for(i=0; i<ic->nb_programs; i++){
3186             AVProgram *p= ic->programs[i];
3187             if(p->id != opt_programid){
3188                 p->discard = AVDISCARD_ALL;
3189             }else{
3190                 found=1;
3191                 for(j=0; j<p->nb_stream_indexes; j++){
3192                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3193                 }
3194             }
3195         }
3196         if(!found){
3197             fprintf(stderr, "Specified program id not found\n");
3198             exit_program(1);
3199         }
3200         opt_programid=0;
3201     }
3202
3203     /* apply forced codec ids */
3204     for (i = 0; i < ic->nb_streams; i++)
3205         choose_codec(ic, ic->streams[i], ic->streams[i]->codec->codec_type, codec_names);
3206
3207     /* Set AVCodecContext options for avformat_find_stream_info */
3208     opts = setup_find_stream_info_opts(ic, codec_opts);
3209     orig_nb_streams = ic->nb_streams;
3210
3211     /* If not enough info to get the stream parameters, we decode the
3212        first frames to get it. (used in mpeg case for example) */
3213     ret = avformat_find_stream_info(ic, opts);
3214     if (ret < 0 && verbose >= 0) {
3215         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3216         av_close_input_file(ic);
3217         exit_program(1);
3218     }
3219
3220     timestamp = start_time;
3221     /* add the stream start time */
3222     if (ic->start_time != AV_NOPTS_VALUE)
3223         timestamp += ic->start_time;
3224
3225     /* if seeking requested, we execute it */
3226     if (start_time != 0) {
3227         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3228         if (ret < 0) {
3229             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3230                     filename, (double)timestamp / AV_TIME_BASE);
3231         }
3232         /* reset seek info */
3233         start_time = 0;
3234     }
3235
3236     /* update the current parameters so that they match the one of the input stream */
3237     add_input_streams(ic);
3238
3239     /* dump the file content */
3240     if (verbose >= 0)
3241         av_dump_format(ic, nb_input_files, filename, 0);
3242
3243     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3244     input_files[nb_input_files - 1].ctx        = ic;
3245     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3246     input_files[nb_input_files - 1].ts_offset  = input_ts_offset - (copy_ts ? 0 : timestamp);
3247     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3248
3249     top_field_first = -1;
3250     frame_rate    = (AVRational){0, 0};
3251     frame_pix_fmt = PIX_FMT_NONE;
3252     frame_height = 0;
3253     frame_width  = 0;
3254     audio_sample_rate = 0;
3255     audio_channels    = 0;
3256     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3257     av_dict_free(&ts_scale);
3258     input_ts_offset = 0;
3259
3260     for (i = 0; i < orig_nb_streams; i++)
3261         av_dict_free(&opts[i]);
3262     av_freep(&opts);
3263     av_dict_free(&codec_names);
3264     uninit_opts();
3265     init_opts();
3266     return 0;
3267 }
3268
3269 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3270                                     AVCodecContext *avctx)
3271 {
3272     char *p;
3273     int n = 1, i;
3274     int64_t t;
3275
3276     for (p = kf; *p; p++)
3277         if (*p == ',')
3278             n++;
3279     ost->forced_kf_count = n;
3280     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3281     if (!ost->forced_kf_pts) {
3282         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3283         exit_program(1);
3284     }
3285     for (i = 0; i < n; i++) {
3286         p = i ? strchr(p, ',') + 1 : kf;
3287         t = parse_time_or_die("force_key_frames", p, 1);
3288         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3289     }
3290 }
3291
3292 static OutputStream *new_output_stream(AVFormatContext *oc, enum AVMediaType type)
3293 {
3294     OutputStream *ost;
3295     AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3296     int idx      = oc->nb_streams - 1;
3297
3298     if (!st) {
3299         av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3300         exit_program(1);
3301     }
3302
3303     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3304                                 nb_output_streams + 1);
3305     ost = &output_streams[nb_output_streams - 1];
3306     ost->file_index = nb_output_files;
3307     ost->index = idx;
3308     ost->st    = st;
3309     st->codec->codec_type = type;
3310     ost->enc = choose_codec(oc, st, type, codec_names);
3311     if (ost->enc) {
3312         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3313     }
3314
3315     avcodec_get_context_defaults3(st->codec, ost->enc);
3316     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3317
3318     ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3319     return ost;
3320 }
3321
3322 static OutputStream *new_video_stream(AVFormatContext *oc)
3323 {
3324     AVStream *st;
3325     OutputStream *ost;
3326     AVCodecContext *video_enc;
3327
3328     ost = new_output_stream(oc, AVMEDIA_TYPE_VIDEO);
3329     st  = ost->st;
3330     if (!st->stream_copy) {
3331         ost->frame_aspect_ratio = frame_aspect_ratio;
3332         frame_aspect_ratio = 0;
3333 #if CONFIG_AVFILTER
3334         ost->avfilter = vfilters;
3335         vfilters = NULL;
3336 #endif
3337     }
3338
3339     ost->bitstream_filters = video_bitstream_filters;
3340     video_bitstream_filters= NULL;
3341
3342     st->codec->thread_count= thread_count;
3343
3344     video_enc = st->codec;
3345
3346     if(video_codec_tag)
3347         video_enc->codec_tag= video_codec_tag;
3348
3349     if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3350         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3351     }
3352
3353     if (st->stream_copy) {
3354         video_enc->sample_aspect_ratio =
3355         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3356     } else {
3357         const char *p;
3358         int i;
3359
3360         if (frame_rate.num)
3361             ost->frame_rate = frame_rate;
3362
3363         video_enc->width = frame_width;
3364         video_enc->height = frame_height;
3365         video_enc->pix_fmt = frame_pix_fmt;
3366         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3367         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3368
3369         if (intra_only)
3370             video_enc->gop_size = 0;
3371         if (video_qscale || same_quant) {
3372             video_enc->flags |= CODEC_FLAG_QSCALE;
3373             video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3374         }
3375
3376         if(intra_matrix)
3377             video_enc->intra_matrix = intra_matrix;
3378         if(inter_matrix)
3379             video_enc->inter_matrix = inter_matrix;
3380
3381         p= video_rc_override_string;
3382         for(i=0; p; i++){
3383             int start, end, q;
3384             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3385             if(e!=3){
3386                 fprintf(stderr, "error parsing rc_override\n");
3387                 exit_program(1);
3388             }
3389             video_enc->rc_override=
3390                 av_realloc(video_enc->rc_override,
3391                            sizeof(RcOverride)*(i+1));
3392             video_enc->rc_override[i].start_frame= start;
3393             video_enc->rc_override[i].end_frame  = end;
3394             if(q>0){
3395                 video_enc->rc_override[i].qscale= q;
3396                 video_enc->rc_override[i].quality_factor= 1.0;
3397             }
3398             else{
3399                 video_enc->rc_override[i].qscale= 0;
3400                 video_enc->rc_override[i].quality_factor= -q/100.0;
3401             }
3402             p= strchr(p, '/');
3403             if(p) p++;
3404         }
3405         video_enc->rc_override_count=i;
3406         if (!video_enc->rc_initial_buffer_occupancy)
3407             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3408         video_enc->me_threshold= me_threshold;
3409         video_enc->intra_dc_precision= intra_dc_precision - 8;
3410
3411         if (do_psnr)
3412             video_enc->flags|= CODEC_FLAG_PSNR;
3413
3414         /* two pass mode */
3415         if (do_pass) {
3416             if (do_pass == 1) {
3417                 video_enc->flags |= CODEC_FLAG_PASS1;
3418             } else {
3419                 video_enc->flags |= CODEC_FLAG_PASS2;
3420             }
3421         }
3422
3423         if (forced_key_frames)
3424             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3425     }
3426     if (video_language) {
3427         av_dict_set(&st->metadata, "language", video_language, 0);
3428         av_freep(&video_language);
3429     }
3430
3431     /* reset some key parameters */
3432     video_disable = 0;
3433     av_freep(&forced_key_frames);
3434     frame_pix_fmt = PIX_FMT_NONE;
3435     return ost;
3436 }
3437
3438 static OutputStream *new_audio_stream(AVFormatContext *oc)
3439 {
3440     AVStream *st;
3441     OutputStream *ost;
3442     AVCodecContext *audio_enc;
3443
3444     ost = new_output_stream(oc, AVMEDIA_TYPE_AUDIO);
3445     st  = ost->st;
3446
3447     ost->bitstream_filters = audio_bitstream_filters;
3448     audio_bitstream_filters= NULL;
3449
3450     st->codec->thread_count= thread_count;
3451
3452     audio_enc = st->codec;
3453     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3454
3455     if(audio_codec_tag)
3456         audio_enc->codec_tag= audio_codec_tag;
3457
3458     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3459         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3460     }
3461     if (!st->stream_copy) {
3462         if (audio_qscale > QSCALE_NONE) {
3463             audio_enc->flags |= CODEC_FLAG_QSCALE;
3464             audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3465         }
3466         if (audio_channels)
3467             audio_enc->channels = audio_channels;
3468         if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3469             audio_enc->sample_fmt = audio_sample_fmt;
3470         if (audio_sample_rate)
3471             audio_enc->sample_rate = audio_sample_rate;
3472     }
3473     if (audio_language) {
3474         av_dict_set(&st->metadata, "language", audio_language, 0);
3475         av_freep(&audio_language);
3476     }
3477
3478     /* reset some key parameters */
3479     audio_disable = 0;
3480
3481     return ost;
3482 }
3483
3484 static OutputStream *new_data_stream(AVFormatContext *oc)
3485 {
3486     AVStream *st;
3487     OutputStream *ost;
3488     AVCodecContext *data_enc;
3489
3490     ost = new_output_stream(oc, AVMEDIA_TYPE_DATA);
3491     st  = ost->st;
3492     data_enc = st->codec;
3493     if (!st->stream_copy) {
3494         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3495         exit_program(1);
3496     }
3497
3498     if (data_codec_tag)
3499         data_enc->codec_tag= data_codec_tag;
3500
3501     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3502         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3503     }
3504
3505     data_disable = 0;
3506     return ost;
3507 }
3508
3509 static OutputStream *new_subtitle_stream(AVFormatContext *oc)
3510 {
3511     AVStream *st;
3512     OutputStream *ost;
3513     AVCodecContext *subtitle_enc;
3514
3515     ost = new_output_stream(oc, AVMEDIA_TYPE_SUBTITLE);
3516     st  = ost->st;
3517     subtitle_enc = st->codec;
3518
3519     ost->bitstream_filters = subtitle_bitstream_filters;
3520     subtitle_bitstream_filters= NULL;
3521
3522     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3523
3524     if(subtitle_codec_tag)
3525         subtitle_enc->codec_tag= subtitle_codec_tag;
3526
3527     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3528         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3529     }
3530
3531     if (subtitle_language) {
3532         av_dict_set(&st->metadata, "language", subtitle_language, 0);
3533         av_freep(&subtitle_language);
3534     }
3535
3536     subtitle_disable = 0;
3537     return ost;
3538 }
3539
3540 /* arg format is "output-stream-index:streamid-value". */
3541 static int opt_streamid(const char *opt, const char *arg)
3542 {
3543     int idx;
3544     char *p;
3545     char idx_str[16];
3546
3547     av_strlcpy(idx_str, arg, sizeof(idx_str));
3548     p = strchr(idx_str, ':');
3549     if (!p) {
3550         fprintf(stderr,
3551                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3552                 arg, opt);
3553         exit_program(1);
3554     }
3555     *p++ = '\0';
3556     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3557     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3558     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3559     return 0;
3560 }
3561 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
3562 {
3563     int i, err;
3564     AVFormatContext *ic = NULL;
3565
3566     err = avformat_open_input(&ic, filename, NULL, NULL);
3567     if (err < 0)
3568         return err;
3569     /* copy stream format */
3570     for(i=0;i<ic->nb_streams;i++) {
3571         AVStream *st;
3572         OutputStream *ost;
3573         AVCodec *codec;
3574
3575         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3576         ost   = new_output_stream(s, codec->type);
3577         st    = ost->st;
3578
3579         // FIXME: a more elegant solution is needed
3580         memcpy(st, ic->streams[i], sizeof(AVStream));
3581         st->info = av_malloc(sizeof(*st->info));
3582         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3583         avcodec_copy_context(st->codec, ic->streams[i]->codec);
3584
3585         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3586             choose_sample_fmt(st, codec);
3587         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3588             choose_pixel_fmt(st, codec);
3589     }
3590
3591     av_close_input_file(ic);
3592     return 0;
3593 }
3594
3595
3596 static int copy_chapters(int infile, int outfile)
3597 {
3598     AVFormatContext *is = input_files[infile].ctx;
3599     AVFormatContext *os = output_files[outfile].ctx;
3600     int i;
3601
3602     for (i = 0; i < is->nb_chapters; i++) {
3603         AVChapter *in_ch = is->chapters[i], *out_ch;
3604         int64_t ts_off   = av_rescale_q(start_time - input_files[infile].ts_offset,
3605                                       AV_TIME_BASE_Q, in_ch->time_base);
3606         int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
3607                            av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3608
3609
3610         if (in_ch->end < ts_off)
3611             continue;
3612         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3613             break;
3614
3615         out_ch = av_mallocz(sizeof(AVChapter));
3616         if (!out_ch)
3617             return AVERROR(ENOMEM);
3618
3619         out_ch->id        = in_ch->id;
3620         out_ch->time_base = in_ch->time_base;
3621         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3622         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3623
3624         if (metadata_chapters_autocopy)
3625             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3626
3627         os->nb_chapters++;
3628         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3629         if (!os->chapters)
3630             return AVERROR(ENOMEM);
3631         os->chapters[os->nb_chapters - 1] = out_ch;
3632     }
3633     return 0;
3634 }
3635
3636 static int opt_output_file(const char *opt, const char *filename)
3637 {
3638     AVFormatContext *oc;
3639     int i, err;
3640     AVOutputFormat *file_oformat;
3641     OutputStream *ost;
3642     InputStream  *ist;
3643
3644     if (!strcmp(filename, "-"))
3645         filename = "pipe:";
3646
3647     err = avformat_alloc_output_context2(&oc, NULL, last_asked_format, filename);
3648     last_asked_format = NULL;
3649     if (!oc) {
3650         print_error(filename, err);
3651         exit_program(1);
3652     }
3653     file_oformat= oc->oformat;
3654
3655     if (!strcmp(file_oformat->name, "ffm") &&
3656         av_strstart(filename, "http:", NULL)) {
3657         /* special case for files sent to ffserver: we get the stream
3658            parameters from ffserver */
3659         int err = read_ffserver_streams(oc, filename);
3660         if (err < 0) {
3661             print_error(filename, err);
3662             exit_program(1);
3663         }
3664     } else if (!nb_stream_maps) {
3665         /* pick the "best" stream of each type */
3666 #define NEW_STREAM(type, index)\
3667         if (index >= 0) {\
3668             ost = new_ ## type ## _stream(oc);\
3669             ost->source_index = index;\
3670             ost->sync_ist     = &input_streams[index];\
3671             input_streams[index].discard = 0;\
3672         }
3673
3674         /* video: highest resolution */
3675         if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3676             int area = 0, idx = -1;
3677             for (i = 0; i < nb_input_streams; i++) {
3678                 ist = &input_streams[i];
3679                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3680                     ist->st->codec->width * ist->st->codec->height > area) {
3681                     area = ist->st->codec->width * ist->st->codec->height;
3682                     idx = i;
3683                 }
3684             }
3685             NEW_STREAM(video, idx);
3686         }
3687
3688         /* audio: most channels */
3689         if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3690             int channels = 0, idx = -1;
3691             for (i = 0; i < nb_input_streams; i++) {
3692                 ist = &input_streams[i];
3693                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3694                     ist->st->codec->channels > channels) {
3695                     channels = ist->st->codec->channels;
3696                     idx = i;
3697                 }
3698             }
3699             NEW_STREAM(audio, idx);
3700         }
3701
3702         /* subtitles: pick first */
3703         if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3704             for (i = 0; i < nb_input_streams; i++)
3705                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3706                     NEW_STREAM(subtitle, i);
3707                     break;
3708                 }
3709         }
3710         /* do something with data? */
3711     } else {
3712         for (i = 0; i < nb_stream_maps; i++) {
3713             StreamMap *map = &stream_maps[i];
3714
3715             if (map->disabled)
3716                 continue;
3717
3718             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3719             switch (ist->st->codec->codec_type) {
3720             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(oc);    break;
3721             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(oc);    break;
3722             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(oc); break;
3723             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(oc);     break;
3724             default:
3725                 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3726                        map->file_index, map->stream_index);
3727                 exit_program(1);
3728             }
3729
3730             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3731             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3732                                            map->sync_stream_index];
3733             ist->discard = 0;
3734         }
3735     }
3736
3737     av_dict_copy(&oc->metadata, metadata, 0);
3738     av_dict_free(&metadata);
3739
3740
3741     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3742     output_files[nb_output_files - 1].ctx       = oc;
3743     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3744     output_files[nb_output_files - 1].recording_time = recording_time;
3745     output_files[nb_output_files - 1].start_time     = start_time;
3746     output_files[nb_output_files - 1].limit_filesize = limit_filesize;
3747     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3748
3749     /* check filename in case of an image number is expected */
3750     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3751         if (!av_filename_number_test(oc->filename)) {
3752             print_error(oc->filename, AVERROR(EINVAL));
3753             exit_program(1);
3754         }
3755     }
3756
3757     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3758         /* test if it already exists to avoid loosing precious files */
3759         if (!file_overwrite &&
3760             (strchr(filename, ':') == NULL ||
3761              filename[1] == ':' ||
3762              av_strstart(filename, "file:", NULL))) {
3763             if (avio_check(filename, 0) == 0) {
3764                 if (!using_stdin) {
3765                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3766                     fflush(stderr);
3767                     if (!read_yesno()) {
3768                         fprintf(stderr, "Not overwriting - exiting\n");
3769                         exit_program(1);
3770                     }
3771                 }
3772                 else {
3773                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3774                     exit_program(1);
3775                 }
3776             }
3777         }
3778
3779         /* open the file */
3780         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3781             print_error(filename, err);
3782             exit_program(1);
3783         }
3784     }
3785
3786     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3787     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3788
3789     if (loop_output >= 0) {
3790         av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3791         oc->loop_output = loop_output;
3792     }
3793
3794     /* copy chapters */
3795     if (chapters_input_file >= nb_input_files) {
3796         if (chapters_input_file == INT_MAX) {
3797             /* copy chapters from the first input file that has them*/
3798             chapters_input_file = -1;
3799             for (i = 0; i < nb_input_files; i++)
3800                 if (input_files[i].ctx->nb_chapters) {
3801                     chapters_input_file = i;
3802                     break;
3803                 }
3804         } else {
3805             av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3806                    chapters_input_file);
3807             exit_program(1);
3808         }
3809     }
3810     if (chapters_input_file >= 0)
3811         copy_chapters(chapters_input_file, nb_output_files - 1);
3812
3813     /* copy metadata */
3814     for (i = 0; i < nb_meta_data_maps; i++) {
3815         AVFormatContext *files[2];
3816         AVDictionary    **meta[2];
3817         int j;
3818
3819 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3820         if ((index) < 0 || (index) >= (nb_elems)) {\
3821             av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3822                      (desc), (index));\
3823             exit_program(1);\
3824         }
3825
3826         int in_file_index = meta_data_maps[i][1].file;
3827         if (in_file_index < 0)
3828             continue;
3829         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3830
3831         files[0] = oc;
3832         files[1] = input_files[in_file_index].ctx;
3833
3834         for (j = 0; j < 2; j++) {
3835             MetadataMap *map = &meta_data_maps[i][j];
3836
3837             switch (map->type) {
3838             case 'g':
3839                 meta[j] = &files[j]->metadata;
3840                 break;
3841             case 's':
3842                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3843                 meta[j] = &files[j]->streams[map->index]->metadata;
3844                 break;
3845             case 'c':
3846                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3847                 meta[j] = &files[j]->chapters[map->index]->metadata;
3848                 break;
3849             case 'p':
3850                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3851                 meta[j] = &files[j]->programs[map->index]->metadata;
3852                 break;
3853             }
3854         }
3855
3856         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3857     }
3858
3859     /* copy global metadata by default */
3860     if (metadata_global_autocopy && nb_input_files)
3861         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3862                      AV_DICT_DONT_OVERWRITE);
3863     if (metadata_streams_autocopy)
3864         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3865             InputStream *ist = &input_streams[output_streams[i].source_index];
3866             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3867         }
3868
3869     frame_rate    = (AVRational){0, 0};
3870     frame_width   = 0;
3871     frame_height  = 0;
3872     audio_sample_rate = 0;
3873     audio_channels    = 0;
3874     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3875     chapters_input_file = INT_MAX;
3876     recording_time = INT64_MAX;
3877     start_time     = 0;
3878     limit_filesize = UINT64_MAX;
3879
3880     av_freep(&meta_data_maps);
3881     nb_meta_data_maps = 0;
3882     metadata_global_autocopy   = 1;
3883     metadata_streams_autocopy  = 1;
3884     metadata_chapters_autocopy = 1;
3885     av_freep(&stream_maps);
3886     nb_stream_maps = 0;
3887     av_freep(&streamid_map);
3888     nb_streamid_map = 0;
3889
3890     av_dict_free(&codec_names);
3891
3892     av_freep(&forced_key_frames);
3893     uninit_opts();
3894     init_opts();
3895     return 0;
3896 }
3897
3898 /* same option as mencoder */
3899 static int opt_pass(const char *opt, const char *arg)
3900 {
3901     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3902     return 0;
3903 }
3904
3905 static int64_t getutime(void)
3906 {
3907 #if HAVE_GETRUSAGE
3908     struct rusage rusage;
3909
3910     getrusage(RUSAGE_SELF, &rusage);
3911     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3912 #elif HAVE_GETPROCESSTIMES
3913     HANDLE proc;
3914     FILETIME c, e, k, u;
3915     proc = GetCurrentProcess();
3916     GetProcessTimes(proc, &c, &e, &k, &u);
3917     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3918 #else
3919     return av_gettime();
3920 #endif
3921 }
3922
3923 static int64_t getmaxrss(void)
3924 {
3925 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3926     struct rusage rusage;
3927     getrusage(RUSAGE_SELF, &rusage);
3928     return (int64_t)rusage.ru_maxrss * 1024;
3929 #elif HAVE_GETPROCESSMEMORYINFO
3930     HANDLE proc;
3931     PROCESS_MEMORY_COUNTERS memcounters;
3932     proc = GetCurrentProcess();
3933     memcounters.cb = sizeof(memcounters);
3934     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3935     return memcounters.PeakPagefileUsage;
3936 #else
3937     return 0;
3938 #endif
3939 }
3940
3941 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3942 {
3943     int i;
3944     const char *p = str;
3945     for(i = 0;; i++) {
3946         dest[i] = atoi(p);
3947         if(i == 63)
3948             break;
3949         p = strchr(p, ',');
3950         if(!p) {
3951             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3952             exit_program(1);
3953         }
3954         p++;
3955     }
3956 }
3957
3958 static int opt_inter_matrix(const char *opt, const char *arg)
3959 {
3960     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3961     parse_matrix_coeffs(inter_matrix, arg);
3962     return 0;
3963 }
3964
3965 static int opt_intra_matrix(const char *opt, const char *arg)
3966 {
3967     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3968     parse_matrix_coeffs(intra_matrix, arg);
3969     return 0;
3970 }
3971
3972 static void show_usage(void)
3973 {
3974     printf("Hyper fast Audio and Video encoder\n");
3975     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3976     printf("\n");
3977 }
3978
3979 static int opt_help(const char *opt, const char *arg)
3980 {
3981     AVCodec *c;
3982     AVOutputFormat *oformat = NULL;
3983     AVInputFormat  *iformat = NULL;
3984
3985     av_log_set_callback(log_callback_help);
3986     show_usage();
3987     show_help_options(options, "Main options:\n",
3988                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3989     show_help_options(options, "\nAdvanced options:\n",
3990                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3991                       OPT_EXPERT);
3992     show_help_options(options, "\nVideo options:\n",
3993                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3994                       OPT_VIDEO);
3995     show_help_options(options, "\nAdvanced Video options:\n",
3996                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3997                       OPT_VIDEO | OPT_EXPERT);
3998     show_help_options(options, "\nAudio options:\n",
3999                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4000                       OPT_AUDIO);
4001     show_help_options(options, "\nAdvanced Audio options:\n",
4002                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4003                       OPT_AUDIO | OPT_EXPERT);
4004     show_help_options(options, "\nSubtitle options:\n",
4005                       OPT_SUBTITLE | OPT_GRAB,
4006                       OPT_SUBTITLE);
4007     show_help_options(options, "\nAudio/Video grab options:\n",
4008                       OPT_GRAB,
4009                       OPT_GRAB);
4010     printf("\n");
4011     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4012     printf("\n");
4013
4014     /* individual codec options */
4015     c = NULL;
4016     while ((c = av_codec_next(c))) {
4017         if (c->priv_class) {
4018             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4019             printf("\n");
4020         }
4021     }
4022
4023     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4024     printf("\n");
4025
4026     /* individual muxer options */
4027     while ((oformat = av_oformat_next(oformat))) {
4028         if (oformat->priv_class) {
4029             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4030             printf("\n");
4031         }
4032     }
4033
4034     /* individual demuxer options */
4035     while ((iformat = av_iformat_next(iformat))) {
4036         if (iformat->priv_class) {
4037             av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4038             printf("\n");
4039         }
4040     }
4041
4042     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4043     return 0;
4044 }
4045
4046 static int opt_target(const char *opt, const char *arg)
4047 {
4048     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4049     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4050
4051     if(!strncmp(arg, "pal-", 4)) {
4052         norm = PAL;
4053         arg += 4;
4054     } else if(!strncmp(arg, "ntsc-", 5)) {
4055         norm = NTSC;
4056         arg += 5;
4057     } else if(!strncmp(arg, "film-", 5)) {
4058         norm = FILM;
4059         arg += 5;
4060     } else {
4061         int fr;
4062         /* Calculate FR via float to avoid int overflow */
4063         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4064         if(fr == 25000) {
4065             norm = PAL;
4066         } else if((fr == 29970) || (fr == 23976)) {
4067             norm = NTSC;
4068         } else {
4069             /* Try to determine PAL/NTSC by peeking in the input files */
4070             if(nb_input_files) {
4071                 int i, j;
4072                 for (j = 0; j < nb_input_files; j++) {
4073                     for (i = 0; i < input_files[j].nb_streams; i++) {
4074                         AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4075                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4076                             continue;
4077                         fr = c->time_base.den * 1000 / c->time_base.num;
4078                         if(fr == 25000) {
4079                             norm = PAL;
4080                             break;
4081                         } else if((fr == 29970) || (fr == 23976)) {
4082                             norm = NTSC;
4083                             break;
4084                         }
4085                     }
4086                     if(norm != UNKNOWN)
4087                         break;
4088                 }
4089             }
4090         }
4091         if(verbose > 0 && norm != UNKNOWN)
4092             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4093     }
4094
4095     if(norm == UNKNOWN) {
4096         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4097         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4098         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4099         exit_program(1);
4100     }
4101
4102     if(!strcmp(arg, "vcd")) {
4103         opt_codec("c:v", "mpeg1video");
4104         opt_codec("c:a", "mp2");
4105         opt_format("f", "vcd");
4106
4107         opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4108         opt_frame_rate("r", frame_rates[norm]);
4109         opt_default("g", norm == PAL ? "15" : "18");
4110
4111         opt_default("b", "1150000");
4112         opt_default("maxrate", "1150000");
4113         opt_default("minrate", "1150000");
4114         opt_default("bufsize", "327680"); // 40*1024*8;
4115
4116         opt_default("b:a", "224000");
4117         audio_sample_rate = 44100;
4118         audio_channels = 2;
4119
4120         opt_default("packetsize", "2324");
4121         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4122
4123         /* We have to offset the PTS, so that it is consistent with the SCR.
4124            SCR starts at 36000, but the first two packs contain only padding
4125            and the first pack from the other stream, respectively, may also have
4126            been written before.
4127            So the real data starts at SCR 36000+3*1200. */
4128         mux_preload= (36000+3*1200) / 90000.0; //0.44
4129     } else if(!strcmp(arg, "svcd")) {
4130
4131         opt_codec("c:v", "mpeg2video");
4132         opt_codec("c:a", "mp2");
4133         opt_format("f", "svcd");
4134
4135         opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4136         opt_frame_rate("r", frame_rates[norm]);
4137         opt_frame_pix_fmt("pix_fmt", "yuv420p");
4138         opt_default("g", norm == PAL ? "15" : "18");
4139
4140         opt_default("b", "2040000");
4141         opt_default("maxrate", "2516000");
4142         opt_default("minrate", "0"); //1145000;
4143         opt_default("bufsize", "1835008"); //224*1024*8;
4144         opt_default("flags", "+scan_offset");
4145
4146
4147         opt_default("b:a", "224000");
4148         audio_sample_rate = 44100;
4149
4150         opt_default("packetsize", "2324");
4151
4152     } else if(!strcmp(arg, "dvd")) {
4153
4154         opt_codec("c:v", "mpeg2video");
4155         opt_codec("c:a", "ac3");
4156         opt_format("f", "dvd");
4157
4158         opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4159         opt_frame_rate("r", frame_rates[norm]);
4160         opt_frame_pix_fmt("pix_fmt", "yuv420p");
4161         opt_default("g", norm == PAL ? "15" : "18");
4162
4163         opt_default("b", "6000000");
4164         opt_default("maxrate", "9000000");
4165         opt_default("minrate", "0"); //1500000;
4166         opt_default("bufsize", "1835008"); //224*1024*8;
4167
4168         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4169         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4170
4171         opt_default("b:a", "448000");
4172         audio_sample_rate = 48000;
4173
4174     } else if(!strncmp(arg, "dv", 2)) {
4175
4176         opt_format("f", "dv");
4177
4178         opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4179         opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4180                           norm == PAL ? "yuv420p" : "yuv411p");
4181         opt_frame_rate("r", frame_rates[norm]);
4182
4183         audio_sample_rate = 48000;
4184         audio_channels = 2;
4185
4186     } else {
4187         fprintf(stderr, "Unknown target: %s\n", arg);
4188         return AVERROR(EINVAL);
4189     }
4190     return 0;
4191 }
4192
4193 static int opt_vstats_file(const char *opt, const char *arg)
4194 {
4195     av_free (vstats_filename);
4196     vstats_filename=av_strdup (arg);
4197     return 0;
4198 }
4199
4200 static int opt_vstats(const char *opt, const char *arg)
4201 {
4202     char filename[40];
4203     time_t today2 = time(NULL);
4204     struct tm *today = localtime(&today2);
4205
4206     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4207              today->tm_sec);
4208     return opt_vstats_file(opt, filename);
4209 }
4210
4211 static int opt_bsf(const char *opt, const char *arg)
4212 {
4213     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4214     AVBitStreamFilterContext **bsfp;
4215
4216     if(!bsfc){
4217         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4218         exit_program(1);
4219     }
4220
4221     bsfp= *opt == 'v' ? &video_bitstream_filters :
4222           *opt == 'a' ? &audio_bitstream_filters :
4223                         &subtitle_bitstream_filters;
4224     while(*bsfp)
4225         bsfp= &(*bsfp)->next;
4226
4227     *bsfp= bsfc;
4228
4229     return 0;
4230 }
4231
4232 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4233 {
4234 }
4235
4236 static int opt_passlogfile(const char *opt, const char *arg)
4237 {
4238     pass_logfilename_prefix = arg;
4239 #if CONFIG_LIBX264_ENCODER
4240     return opt_default("passlogfile", arg);
4241 #else
4242     return 0;
4243 #endif
4244 }
4245
4246 static const OptionDef options[] = {
4247     /* main options */
4248 #include "cmdutils_common_opts.h"
4249     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4250     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4251     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4252     { "c", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4253     { "codec", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4254     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4255     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4256       "outfile[,metadata]:infile[,metadata]" },
4257     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4258       "outfile[,metadata]:infile[,metadata]" },
4259     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&chapters_input_file},  "set chapters mapping", "input_file_index" },
4260     { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4261     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4262     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4263     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4264     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "scale" },
4265     { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4266     { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4267     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4268     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4269       "add timings for benchmarking" },
4270     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4271     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4272       "dump each input packet" },
4273     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4274       "when dumping packets, also dump the payload" },
4275     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4276     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4277     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4278     { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4279     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4280     { "threads",  HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4281     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4282     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4283     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4284     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4285     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4286     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4287     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4288     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4289     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4290     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4291
4292     /* video options */
4293     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4294     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4295     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4296     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4297     { "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" },
4298     { "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" },
4299     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4300     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4301     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4302     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4303     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4304     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4305     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4306     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4307     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4308     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4309     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4310     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4311     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4312     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4313     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4314     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimation threshold",  "threshold" },
4315     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4316     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4317     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4318     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4319     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4320       "deinterlace pictures" },
4321     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4322     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4323     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4324 #if CONFIG_AVFILTER
4325     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4326 #endif
4327     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4328     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4329     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4330     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4331     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4332     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4333     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4334     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4335     { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4336     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4337
4338     /* audio options */
4339     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4340     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4341     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4342     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4343     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4344     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4345     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4346     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4347     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4348     { "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" },
4349
4350     /* subtitle options */
4351     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4352     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4353     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4354     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4355
4356     /* grab options */
4357     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4358     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4359     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4360
4361     /* muxer options */
4362     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4363     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4364
4365     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4366     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4367     { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4368
4369     /* data codec support */
4370     { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4371
4372     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4373     { NULL, },
4374 };
4375
4376 int main(int argc, char **argv)
4377 {
4378     int64_t ti;
4379
4380     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4381
4382     if(argc>1 && !strcmp(argv[1], "-d")){
4383         run_as_daemon=1;
4384         verbose=-1;
4385         av_log_set_callback(log_callback_null);
4386         argc--;
4387         argv++;
4388     }
4389
4390     avcodec_register_all();
4391 #if CONFIG_AVDEVICE
4392     avdevice_register_all();
4393 #endif
4394 #if CONFIG_AVFILTER
4395     avfilter_register_all();
4396 #endif
4397     av_register_all();
4398
4399 #if HAVE_ISATTY
4400     if(isatty(STDIN_FILENO))
4401         avio_set_interrupt_cb(decode_interrupt_cb);
4402 #endif
4403
4404     init_opts();
4405
4406     if(verbose>=0)
4407         show_banner();
4408
4409     /* parse options */
4410     parse_options(argc, argv, options, opt_output_file);
4411
4412     if(nb_output_files <= 0 && nb_input_files == 0) {
4413         show_usage();
4414         fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4415         exit_program(1);
4416     }
4417
4418     /* file converter / grab */
4419     if (nb_output_files <= 0) {
4420         fprintf(stderr, "At least one output file must be specified\n");
4421         exit_program(1);
4422     }
4423
4424     if (nb_input_files == 0) {
4425         fprintf(stderr, "At least one input file must be specified\n");
4426         exit_program(1);
4427     }
4428
4429     ti = getutime();
4430     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4431         exit_program(1);
4432     ti = getutime() - ti;
4433     if (do_benchmark) {
4434         int maxrss = getmaxrss() / 1024;
4435         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4436     }
4437
4438     return exit_program(0);
4439 }