git.sesse.net Git - ffmpeg/blob - ffmpeg.c

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