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

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