avconv.c

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