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

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