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

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