ffmpeg.c

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