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

   1 /*
   2  * Copyright (c) 2000-2003 Fabrice Bellard
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 /**
  22  * @file
  23  * multimedia converter based on the FFmpeg libraries
  24  */
  25
  26 #include "config.h"
  27 #include <ctype.h>
  28 #include <string.h>
  29 #include <math.h>
  30 #include <stdlib.h>
  31 #include <errno.h>
  32 #include <signal.h>
  33 #include <limits.h>
  34 #include <unistd.h>
  35 #include "libavformat/avformat.h"
  36 #include "libavdevice/avdevice.h"
  37 #include "libswscale/swscale.h"
  38 #include "libavutil/opt.h"
  39 #include "libavutil/audioconvert.h"
  40 #include "libavutil/parseutils.h"
  41 #include "libavutil/samplefmt.h"
  42 #include "libavutil/colorspace.h"
  43 #include "libavutil/fifo.h"
  44 #include "libavutil/intreadwrite.h"
  45 #include "libavutil/dict.h"
  46 #include "libavutil/mathematics.h"
  47 #include "libavutil/pixdesc.h"
  48 #include "libavutil/avstring.h"
  49 #include "libavutil/libm.h"
  50 #include "libavutil/imgutils.h"
  51 #include "libavutil/timestamp.h"
  52 #include "libavformat/os_support.h"
  53 #include "libswresample/swresample.h"
  54
  55 #include "libavformat/ffm.h" // not public API
  56
  57 # include "libavfilter/avcodec.h"
  58 # include "libavfilter/avfilter.h"
  59 # include "libavfilter/avfiltergraph.h"
  60 # include "libavfilter/buffersink.h"
  61 # include "libavfilter/buffersrc.h"
  62 # include "libavfilter/vsrc_buffer.h"
  63
  64 #if HAVE_SYS_RESOURCE_H
  65 #include <sys/types.h>
  66 #include <sys/time.h>
  67 #include <sys/resource.h>
  68 #elif HAVE_GETPROCESSTIMES
  69 #include <windows.h>
  70 #endif
  71 #if HAVE_GETPROCESSMEMORYINFO
  72 #include <windows.h>
  73 #include <psapi.h>
  74 #endif
  75
  76 #if HAVE_SYS_SELECT_H
  77 #include <sys/select.h>
  78 #endif
  79
  80 #if HAVE_TERMIOS_H
  81 #include <fcntl.h>
  82 #include <sys/ioctl.h>
  83 #include <sys/time.h>
  84 #include <termios.h>
  85 #elif HAVE_KBHIT
  86 #include <conio.h>
  87 #endif
  88 #include <time.h>
  89
  90 #include "cmdutils.h"
  91
  92 #include "libavutil/avassert.h"
  93
  94 #define VSYNC_AUTO       -1
  95 #define VSYNC_PASSTHROUGH 0
  96 #define VSYNC_CFR         1
  97 #define VSYNC_VFR         2
  98 #define VSYNC_DROP        0xff
  99
 100 const char program_name[] = "ffmpeg";
 101 const int program_birth_year = 2000;
 102
 103 /* select an input stream for an output stream */
 104 typedef struct StreamMap {
 105     int disabled;           /** 1 is this mapping is disabled by a negative map */
 106     int file_index;
 107     int stream_index;
 108     int sync_file_index;
 109     int sync_stream_index;
 110     char *linklabel;       /** name of an output link, for mapping lavfi outputs */
 111 } StreamMap;
 112
 113 typedef struct {
 114     int  file_idx,  stream_idx,  channel_idx; // input
 115     int ofile_idx, ostream_idx;               // output
 116 } AudioChannelMap;
 117
 118 static const OptionDef options[];
 119
 120 #define MAX_STREAMS 1024    /* arbitrary sanity check value */
 121
 122 static int frame_bits_per_raw_sample = 0;
 123 static int video_discard = 0;
 124 static int same_quant = 0;
 125 static int do_deinterlace = 0;
 126 static int intra_dc_precision = 8;
 127 static int qp_hist = 0;
 128 static int intra_only = 0;
 129 static const char *video_codec_name    = NULL;
 130 static const char *audio_codec_name    = NULL;
 131 static const char *subtitle_codec_name = NULL;
 132
 133 static int file_overwrite = 0;
 134 static int no_file_overwrite = 0;
 135 static int do_benchmark = 0;
 136 static int do_benchmark_all = 0;
 137 static int do_hex_dump = 0;
 138 static int do_pkt_dump = 0;
 139 static int do_psnr = 0;
 140 static int do_pass = 0;
 141 static const char *pass_logfilename_prefix;
 142 static int video_sync_method = VSYNC_AUTO;
 143 static int audio_sync_method = 0;
 144 static float audio_drift_threshold = 0.1;
 145 static int copy_ts = 0;
 146 static int copy_tb = -1;
 147 static int opt_shortest = 0;
 148 static char *vstats_filename;
 149 static FILE *vstats_file;
 150
 151 static int audio_volume = 256;
 152
 153 static int exit_on_error = 0;
 154 static int using_stdin = 0;
 155 static int run_as_daemon  = 0;
 156 static volatile int received_nb_signals = 0;
 157 static int64_t video_size = 0;
 158 static int64_t audio_size = 0;
 159 static int64_t extra_size = 0;
 160 static int nb_frames_dup = 0;
 161 static int nb_frames_drop = 0;
 162 static int input_sync;
 163
 164 static float dts_delta_threshold = 10;
 165 static float dts_error_threshold = 3600*30;
 166
 167 static int print_stats = 1;
 168 static int debug_ts = 0;
 169 static int current_time;
 170
 171 static uint8_t *audio_buf;
 172 static unsigned int allocated_audio_buf_size;
 173 static uint8_t *async_buf;
 174 static unsigned int allocated_async_buf_size;
 175
 176 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
 177
 178 typedef struct InputFilter {
 179     AVFilterContext    *filter;
 180     struct InputStream *ist;
 181     struct FilterGraph *graph;
 182 } InputFilter;
 183
 184 typedef struct OutputFilter {
 185     AVFilterContext     *filter;
 186     struct OutputStream *ost;
 187     struct FilterGraph  *graph;
 188
 189     /* temporary storage until stream maps are processed */
 190     AVFilterInOut       *out_tmp;
 191 } OutputFilter;
 192
 193 typedef struct FilterGraph {
 194     int            index;
 195     const char    *graph_desc;
 196
 197     AVFilterGraph *graph;
 198
 199     InputFilter   **inputs;
 200     int          nb_inputs;
 201     OutputFilter **outputs;
 202     int         nb_outputs;
 203 } FilterGraph;
 204
 205 typedef struct FrameBuffer {
 206     uint8_t *base[4];
 207     uint8_t *data[4];
 208     int  linesize[4];
 209
 210     int h, w;
 211     enum PixelFormat pix_fmt;
 212
 213     int refcount;
 214     struct InputStream *ist;
 215     struct FrameBuffer *next;
 216 } FrameBuffer;
 217
 218 typedef struct InputStream {
 219     int file_index;
 220     AVStream *st;
 221     int discard;             /* true if stream data should be discarded */
 222     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 223     AVCodec *dec;
 224     AVFrame *decoded_frame;
 225
 226     int64_t       start;     /* time when read started */
 227     /* predicted dts of the next packet read for this stream or (when there are
 228      * several frames in a packet) of the next frame in current packet */
 229     int64_t       next_dts;
 230     /* dts of the last packet read for this stream */
 231     int64_t       dts;
 232
 233     int64_t       next_pts;  ///< synthetic pts for the next decode frame
 234     int64_t       pts;       ///< current pts of the decoded frame
 235     double ts_scale;
 236     int is_start;            /* is 1 at the start and after a discontinuity */
 237     int saw_first_ts;
 238     int showed_multi_packet_warning;
 239     AVDictionary *opts;
 240
 241     int resample_height;
 242     int resample_width;
 243     int resample_pix_fmt;
 244
 245     /* a pool of free buffers for decoded data */
 246     FrameBuffer *buffer_pool;
 247     int dr1;
 248
 249     /* decoded data from this stream goes into all those filters
 250      * currently video only */
 251     InputFilter **filters;
 252     int        nb_filters;
 253 } InputStream;
 254
 255 typedef struct InputFile {
 256     AVFormatContext *ctx;
 257     int eof_reached;      /* true if eof reached */
 258     int ist_index;        /* index of first stream in input_streams */
 259     int buffer_size;      /* current total buffer size */
 260     int64_t ts_offset;
 261     int nb_streams;       /* number of stream that ffmpeg is aware of; may be different
 262                              from ctx.nb_streams if new streams appear during av_read_frame() */
 263     int rate_emu;
 264 } InputFile;
 265
 266 typedef struct OutputStream {
 267     int file_index;          /* file index */
 268     int index;               /* stream index in the output file */
 269     int source_index;        /* InputStream index */
 270     AVStream *st;            /* stream in the output file */
 271     int encoding_needed;     /* true if encoding needed for this stream */
 272     int frame_number;
 273     /* input pts and corresponding output pts
 274        for A/V sync */
 275     struct InputStream *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     AVCodec *enc;
 279     int64_t max_frames;
 280     AVFrame *output_frame;
 281     AVFrame *filtered_frame;
 282
 283     /* video only */
 284     AVRational frame_rate;
 285     int force_fps;
 286     int top_field_first;
 287
 288     float frame_aspect_ratio;
 289     float last_quality;
 290
 291     /* forced key frames */
 292     int64_t *forced_kf_pts;
 293     int forced_kf_count;
 294     int forced_kf_index;
 295
 296     /* audio only */
 297     int audio_resample;
 298     int audio_channels_map[SWR_CH_MAX];  ///< list of the channels id to pick from the source stream
 299     int audio_channels_mapped;           ///< number of channels in audio_channels_map
 300     int resample_sample_fmt;
 301     int resample_channels;
 302     uint64_t resample_channel_layout;
 303     int resample_sample_rate;
 304     float rematrix_volume;
 305     AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
 306     FILE *logfile;
 307
 308     SwrContext *swr;
 309
 310     OutputFilter *filter;
 311     char *avfilter;
 312
 313     int64_t sws_flags;
 314     int64_t swr_dither_method;
 315     double swr_dither_scale;
 316     AVDictionary *opts;
 317     int is_past_recording_time;
 318     int stream_copy;
 319     const char *attachment_filename;
 320     int copy_initial_nonkeyframes;
 321
 322     enum PixelFormat pix_fmts[2];
 323 } OutputStream;
 324
 325
 326 #if HAVE_TERMIOS_H
 327
 328 /* init terminal so that we can grab keys */
 329 static struct termios oldtty;
 330 static int restore_tty;
 331 #endif
 332
 333 typedef struct OutputFile {
 334     AVFormatContext *ctx;
 335     AVDictionary *opts;
 336     int ost_index;       /* index of the first stream in output_streams */
 337     int64_t recording_time; /* desired length of the resulting file in microseconds */
 338     int64_t start_time;     /* start time in microseconds */
 339     uint64_t limit_filesize; /* filesize limit expressed in bytes */
 340 } OutputFile;
 341
 342 static InputStream **input_streams = NULL;
 343 static int        nb_input_streams = 0;
 344 static InputFile   **input_files   = NULL;
 345 static int        nb_input_files   = 0;
 346
 347 static OutputStream **output_streams = NULL;
 348 static int         nb_output_streams = 0;
 349 static OutputFile   **output_files   = NULL;
 350 static int         nb_output_files   = 0;
 351
 352 static FilterGraph **filtergraphs;
 353 int               nb_filtergraphs;
 354
 355 typedef struct OptionsContext {
 356     /* input/output options */
 357     int64_t start_time;
 358     const char *format;
 359
 360     SpecifierOpt *codec_names;
 361     int        nb_codec_names;
 362     SpecifierOpt *audio_channels;
 363     int        nb_audio_channels;
 364     SpecifierOpt *audio_sample_rate;
 365     int        nb_audio_sample_rate;
 366     SpecifierOpt *rematrix_volume;
 367     int        nb_rematrix_volume;
 368     SpecifierOpt *frame_rates;
 369     int        nb_frame_rates;
 370     SpecifierOpt *frame_sizes;
 371     int        nb_frame_sizes;
 372     SpecifierOpt *frame_pix_fmts;
 373     int        nb_frame_pix_fmts;
 374
 375     /* input options */
 376     int64_t input_ts_offset;
 377     int rate_emu;
 378
 379     SpecifierOpt *ts_scale;
 380     int        nb_ts_scale;
 381     SpecifierOpt *dump_attachment;
 382     int        nb_dump_attachment;
 383
 384     /* output options */
 385     StreamMap *stream_maps;
 386     int     nb_stream_maps;
 387     AudioChannelMap *audio_channel_maps; ///< one info entry per -map_channel
 388     int           nb_audio_channel_maps; ///< number of (valid) -map_channel settings
 389     int metadata_global_manual;
 390     int metadata_streams_manual;
 391     int metadata_chapters_manual;
 392     const char **attachments;
 393     int       nb_attachments;
 394
 395     int chapters_input_file;
 396
 397     int64_t recording_time;
 398     uint64_t limit_filesize;
 399     float mux_preload;
 400     float mux_max_delay;
 401
 402     int video_disable;
 403     int audio_disable;
 404     int subtitle_disable;
 405     int data_disable;
 406
 407     /* indexed by output file stream index */
 408     int   *streamid_map;
 409     int nb_streamid_map;
 410
 411     SpecifierOpt *metadata;
 412     int        nb_metadata;
 413     SpecifierOpt *max_frames;
 414     int        nb_max_frames;
 415     SpecifierOpt *bitstream_filters;
 416     int        nb_bitstream_filters;
 417     SpecifierOpt *codec_tags;
 418     int        nb_codec_tags;
 419     SpecifierOpt *sample_fmts;
 420     int        nb_sample_fmts;
 421     SpecifierOpt *qscale;
 422     int        nb_qscale;
 423     SpecifierOpt *forced_key_frames;
 424     int        nb_forced_key_frames;
 425     SpecifierOpt *force_fps;
 426     int        nb_force_fps;
 427     SpecifierOpt *frame_aspect_ratios;
 428     int        nb_frame_aspect_ratios;
 429     SpecifierOpt *rc_overrides;
 430     int        nb_rc_overrides;
 431     SpecifierOpt *intra_matrices;
 432     int        nb_intra_matrices;
 433     SpecifierOpt *inter_matrices;
 434     int        nb_inter_matrices;
 435     SpecifierOpt *top_field_first;
 436     int        nb_top_field_first;
 437     SpecifierOpt *metadata_map;
 438     int        nb_metadata_map;
 439     SpecifierOpt *presets;
 440     int        nb_presets;
 441     SpecifierOpt *copy_initial_nonkeyframes;
 442     int        nb_copy_initial_nonkeyframes;
 443     SpecifierOpt *filters;
 444     int        nb_filters;
 445 } OptionsContext;
 446
 447 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
 448 {\
 449     int i, ret;\
 450     for (i = 0; i < o->nb_ ## name; i++) {\
 451         char *spec = o->name[i].specifier;\
 452         if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
 453             outvar = o->name[i].u.type;\
 454         else if (ret < 0)\
 455             exit_program(1);\
 456     }\
 457 }
 458
 459 static int64_t getutime(void)
 460 {
 461 #if HAVE_GETRUSAGE
 462     struct rusage rusage;
 463
 464     getrusage(RUSAGE_SELF, &rusage);
 465     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
 466 #elif HAVE_GETPROCESSTIMES
 467     HANDLE proc;
 468     FILETIME c, e, k, u;
 469     proc = GetCurrentProcess();
 470     GetProcessTimes(proc, &c, &e, &k, &u);
 471     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
 472 #else
 473     return av_gettime();
 474 #endif
 475 }
 476
 477 static void update_benchmark(const char *fmt, ...)
 478 {
 479     if (do_benchmark_all) {
 480         int64_t t = getutime();
 481         va_list va;
 482         char buf[1024];
 483
 484         if (fmt) {
 485             va_start(va, fmt);
 486             vsnprintf(buf, sizeof(buf), fmt, va);
 487             va_end(va);
 488             printf("bench: %8"PRIu64" %s \n", t - current_time, buf);
 489         }
 490         current_time = t;
 491     }
 492 }
 493
 494 static void reset_options(OptionsContext *o, int is_input)
 495 {
 496     const OptionDef *po = options;
 497     OptionsContext bak= *o;
 498     int i;
 499
 500     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
 501     while (po->name) {
 502         void *dst = (uint8_t*)o + po->u.off;
 503
 504         if (po->flags & OPT_SPEC) {
 505             SpecifierOpt **so = dst;
 506             int i, *count = (int*)(so + 1);
 507             for (i = 0; i < *count; i++) {
 508                 av_freep(&(*so)[i].specifier);
 509                 if (po->flags & OPT_STRING)
 510                     av_freep(&(*so)[i].u.str);
 511             }
 512             av_freep(so);
 513             *count = 0;
 514         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
 515             av_freep(dst);
 516         po++;
 517     }
 518
 519     for (i = 0; i < o->nb_stream_maps; i++)
 520         av_freep(&o->stream_maps[i].linklabel);
 521     av_freep(&o->stream_maps);
 522     av_freep(&o->audio_channel_maps);
 523     av_freep(&o->streamid_map);
 524
 525     memset(o, 0, sizeof(*o));
 526
 527     if(is_input) o->recording_time = bak.recording_time;
 528     else         o->recording_time = INT64_MAX;
 529     o->mux_max_delay  = 0.7;
 530     o->limit_filesize = UINT64_MAX;
 531     o->chapters_input_file = INT_MAX;
 532
 533     uninit_opts();
 534     init_opts();
 535 }
 536
 537 static int alloc_buffer(InputStream *ist, AVCodecContext *s, FrameBuffer **pbuf)
 538 {
 539     FrameBuffer  *buf = av_mallocz(sizeof(*buf));
 540     int i, ret;
 541     const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
 542     int h_chroma_shift, v_chroma_shift;
 543     int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
 544     int w = s->width, h = s->height;
 545
 546     if (!buf)
 547         return AVERROR(ENOMEM);
 548
 549     avcodec_align_dimensions(s, &w, &h);
 550
 551     if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
 552         w += 2*edge;
 553         h += 2*edge;
 554     }
 555
 556     if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
 557                               s->pix_fmt, 32)) < 0) {
 558         av_freep(&buf);
 559         return ret;
 560     }
 561     /* XXX this shouldn't be needed, but some tests break without this line
 562      * those decoders are buggy and need to be fixed.
 563      * the following tests fail:
 564      * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
 565      */
 566     memset(buf->base[0], 128, ret);
 567
 568     avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
 569     for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
 570         const int h_shift = i==0 ? 0 : h_chroma_shift;
 571         const int v_shift = i==0 ? 0 : v_chroma_shift;
 572         if ((s->flags & CODEC_FLAG_EMU_EDGE) || !buf->linesize[1] || !buf->base[i])
 573             buf->data[i] = buf->base[i];
 574         else
 575             buf->data[i] = buf->base[i] +
 576                            FFALIGN((buf->linesize[i]*edge >> v_shift) +
 577                                    (pixel_size*edge >> h_shift), 32);
 578     }
 579     buf->w       = s->width;
 580     buf->h       = s->height;
 581     buf->pix_fmt = s->pix_fmt;
 582     buf->ist     = ist;
 583
 584     *pbuf = buf;
 585     return 0;
 586 }
 587
 588 static void free_buffer_pool(InputStream *ist)
 589 {
 590     FrameBuffer *buf = ist->buffer_pool;
 591     while (buf) {
 592         ist->buffer_pool = buf->next;
 593         av_freep(&buf->base[0]);
 594         av_free(buf);
 595         buf = ist->buffer_pool;
 596     }
 597 }
 598
 599 static void unref_buffer(InputStream *ist, FrameBuffer *buf)
 600 {
 601     av_assert0(buf->refcount > 0);
 602     buf->refcount--;
 603     if (!buf->refcount) {
 604         FrameBuffer *tmp;
 605         for(tmp= ist->buffer_pool; tmp; tmp= tmp->next)
 606             av_assert1(tmp != buf);
 607         buf->next = ist->buffer_pool;
 608         ist->buffer_pool = buf;
 609     }
 610 }
 611
 612 static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
 613 {
 614     InputStream *ist = s->opaque;
 615     FrameBuffer *buf;
 616     int ret, i;
 617
 618     if(av_image_check_size(s->width, s->height, 0, s) || s->pix_fmt<0)
 619         return -1;
 620
 621     if (!ist->buffer_pool && (ret = alloc_buffer(ist, s, &ist->buffer_pool)) < 0)
 622         return ret;
 623
 624     buf              = ist->buffer_pool;
 625     ist->buffer_pool = buf->next;
 626     buf->next        = NULL;
 627     if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
 628         av_freep(&buf->base[0]);
 629         av_free(buf);
 630         if ((ret = alloc_buffer(ist, s, &buf)) < 0)
 631             return ret;
 632     }
 633     av_assert0(!buf->refcount);
 634     buf->refcount++;
 635
 636     frame->opaque        = buf;
 637     frame->type          = FF_BUFFER_TYPE_USER;
 638     frame->extended_data = frame->data;
 639     frame->pkt_pts       = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
 640     frame->width         = buf->w;
 641     frame->height        = buf->h;
 642     frame->format        = buf->pix_fmt;
 643     frame->sample_aspect_ratio = s->sample_aspect_ratio;
 644
 645     for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
 646         frame->base[i]     = buf->base[i];  // XXX h264.c uses base though it shouldn't
 647         frame->data[i]     = buf->data[i];
 648         frame->linesize[i] = buf->linesize[i];
 649     }
 650
 651     return 0;
 652 }
 653
 654 static void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
 655 {
 656     InputStream *ist = s->opaque;
 657     FrameBuffer *buf = frame->opaque;
 658     int i;
 659
 660     if(frame->type!=FF_BUFFER_TYPE_USER)
 661         return avcodec_default_release_buffer(s, frame);
 662
 663     for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
 664         frame->data[i] = NULL;
 665
 666     unref_buffer(ist, buf);
 667 }
 668
 669 static void filter_release_buffer(AVFilterBuffer *fb)
 670 {
 671     FrameBuffer *buf = fb->priv;
 672     av_free(fb);
 673     unref_buffer(buf->ist, buf);
 674 }
 675
 676 static enum PixelFormat choose_pixel_fmt(AVStream *st, AVCodec *codec, enum PixelFormat target)
 677 {
 678     if (codec && codec->pix_fmts) {
 679         const enum PixelFormat *p = codec->pix_fmts;
 680         int has_alpha= av_pix_fmt_descriptors[target].nb_components % 2 == 0;
 681         enum PixelFormat best= PIX_FMT_NONE;
 682         if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
 683             if (st->codec->codec_id == CODEC_ID_MJPEG) {
 684                 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
 685             } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
 686                 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
 687                                                  PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
 688             }
 689         }
 690         for (; *p != PIX_FMT_NONE; p++) {
 691             best= avcodec_find_best_pix_fmt2(best, *p, target, has_alpha, NULL);
 692             if (*p == target)
 693                 break;
 694         }
 695         if (*p == PIX_FMT_NONE) {
 696             if (target != PIX_FMT_NONE)
 697                 av_log(NULL, AV_LOG_WARNING,
 698                        "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
 699                        av_pix_fmt_descriptors[target].name,
 700                        codec->name,
 701                        av_pix_fmt_descriptors[best].name);
 702             return best;
 703         }
 704     }
 705     return target;
 706 }
 707
 708 static const enum PixelFormat *choose_pixel_fmts(OutputStream *ost)
 709 {
 710     if (ost->st->codec->pix_fmt != PIX_FMT_NONE) {
 711         ost->pix_fmts[0] = choose_pixel_fmt(ost->st, ost->enc, ost->st->codec->pix_fmt);
 712         return ost->pix_fmts;
 713     } else if (ost->enc->pix_fmts) {
 714         if (ost->st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
 715             if (ost->st->codec->codec_id == CODEC_ID_MJPEG) {
 716                 return (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
 717             } else if (ost->st->codec->codec_id == CODEC_ID_LJPEG) {
 718                 return (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
 719                                                     PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
 720             }
 721         }
 722         return ost->enc->pix_fmts;
 723     } else
 724         return NULL;
 725 }
 726
 727 static int configure_video_filters(FilterGraph *fg)
 728 {
 729     InputStream  *ist = fg->inputs[0]->ist;
 730     OutputStream *ost = fg->outputs[0]->ost;
 731     AVFilterContext *last_filter, *filter;
 732     /** filter graph containing all filters including input & output */
 733     AVCodecContext *codec = ost->st->codec;
 734     enum PixelFormat *pix_fmts = choose_pixel_fmts(ost);
 735     AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
 736     AVRational sample_aspect_ratio;
 737     char args[255];
 738     int ret;
 739
 740     avfilter_graph_free(&fg->graph);
 741     fg->graph = avfilter_graph_alloc();
 742     if (!fg->graph)
 743         return AVERROR(ENOMEM);
 744
 745     if (ist->st->sample_aspect_ratio.num) {
 746         sample_aspect_ratio = ist->st->sample_aspect_ratio;
 747     } else
 748         sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
 749
 750     snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d:flags=%d", ist->st->codec->width,
 751              ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
 752              sample_aspect_ratio.num, sample_aspect_ratio.den, SWS_BILINEAR + ((ist->st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));
 753
 754     ret = avfilter_graph_create_filter(&fg->inputs[0]->filter,
 755                                        avfilter_get_by_name("buffer"),
 756                                        "src", args, NULL, fg->graph);
 757     if (ret < 0)
 758         return ret;
 759
 760 #if FF_API_OLD_VSINK_API
 761     ret = avfilter_graph_create_filter(&fg->outputs[0]->filter, avfilter_get_by_name("buffersink"),
 762                                        "out", NULL, pix_fmts, fg->graph);
 763 #else
 764     buffersink_params->pixel_fmts = pix_fmts;
 765     ret = avfilter_graph_create_filter(&fg->outputs[0]->filter, avfilter_get_by_name("buffersink"),
 766                                        "out", NULL, buffersink_params, fg->graph);
 767 #endif
 768     av_freep(&buffersink_params);
 769
 770     if (ret < 0)
 771         return ret;
 772     last_filter = fg->inputs[0]->filter;
 773
 774     if (codec->width || codec->height) {
 775         snprintf(args, 255, "%d:%d:flags=0x%X",
 776                  codec->width,
 777                  codec->height,
 778                  (unsigned)ost->sws_flags);
 779         if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
 780                                                 NULL, args, NULL, fg->graph)) < 0)
 781             return ret;
 782         if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
 783             return ret;
 784         last_filter = filter;
 785     }
 786
 787     snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
 788     fg->graph->scale_sws_opts = av_strdup(args);
 789
 790     if (ost->avfilter) {
 791         AVFilterInOut *outputs = avfilter_inout_alloc();
 792         AVFilterInOut *inputs  = avfilter_inout_alloc();
 793
 794         outputs->name    = av_strdup("in");
 795         outputs->filter_ctx = last_filter;
 796         outputs->pad_idx = 0;
 797         outputs->next    = NULL;
 798
 799         inputs->name    = av_strdup("out");
 800         inputs->filter_ctx = fg->outputs[0]->filter;
 801         inputs->pad_idx = 0;
 802         inputs->next    = NULL;
 803
 804         if ((ret = avfilter_graph_parse(fg->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
 805             return ret;
 806         av_freep(&ost->avfilter);
 807     } else {
 808         if ((ret = avfilter_link(last_filter, 0, fg->outputs[0]->filter, 0)) < 0)
 809             return ret;
 810     }
 811
 812     if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
 813         return ret;
 814
 815     ost->filter = fg->outputs[0];
 816
 817     return 0;
 818 }
 819
 820 static FilterGraph *init_simple_filtergraph(InputStream *ist, OutputStream *ost)
 821 {
 822     FilterGraph *fg = av_mallocz(sizeof(*fg));
 823
 824     if (!fg)
 825         exit_program(1);
 826     fg->index = nb_filtergraphs;
 827
 828     fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs), &fg->nb_outputs,
 829                              fg->nb_outputs + 1);
 830     if (!(fg->outputs[0] = av_mallocz(sizeof(*fg->outputs[0]))))
 831         exit_program(1);
 832     fg->outputs[0]->ost   = ost;
 833     fg->outputs[0]->graph = fg;
 834
 835     fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs), &fg->nb_inputs,
 836                             fg->nb_inputs + 1);
 837     if (!(fg->inputs[0] = av_mallocz(sizeof(*fg->inputs[0]))))
 838         exit_program(1);
 839     fg->inputs[0]->ist   = ist;
 840     fg->inputs[0]->graph = fg;
 841
 842     ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
 843                               &ist->nb_filters, ist->nb_filters + 1);
 844     ist->filters[ist->nb_filters - 1] = fg->inputs[0];
 845
 846     filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
 847                               &nb_filtergraphs, nb_filtergraphs + 1);
 848     filtergraphs[nb_filtergraphs - 1] = fg;
 849
 850     return fg;
 851 }
 852
 853 static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
 854 {
 855     InputStream *ist;
 856     enum AVMediaType type = in->filter_ctx->input_pads[in->pad_idx].type;
 857     int i;
 858
 859     // TODO: support other filter types
 860     if (type != AVMEDIA_TYPE_VIDEO) {
 861         av_log(NULL, AV_LOG_FATAL, "Only video filters supported currently.\n");
 862         exit_program(1);
 863     }
 864
 865     if (in->name) {
 866         AVFormatContext *s;
 867         AVStream       *st = NULL;
 868         char *p;
 869         int file_idx = strtol(in->name, &p, 0);
 870
 871         if (file_idx < 0 || file_idx >= nb_input_files) {
 872             av_log(NULL, AV_LOG_FATAL, "Invalid file index %d in filtergraph description %s.\n",
 873                    file_idx, fg->graph_desc);
 874             exit_program(1);
 875         }
 876         s = input_files[file_idx]->ctx;
 877
 878         for (i = 0; i < s->nb_streams; i++) {
 879             if (s->streams[i]->codec->codec_type != type)
 880                 continue;
 881             if (check_stream_specifier(s, s->streams[i], *p == ':' ? p + 1 : p) == 1) {
 882                 st = s->streams[i];
 883                 break;
 884             }
 885         }
 886         if (!st) {
 887             av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "
 888                    "matches no streams.\n", p, fg->graph_desc);
 889             exit_program(1);
 890         }
 891         ist = input_streams[input_files[file_idx]->ist_index + st->index];
 892     } else {
 893         /* find the first unused stream of corresponding type */
 894         for (i = 0; i < nb_input_streams; i++) {
 895             ist = input_streams[i];
 896             if (ist->st->codec->codec_type == type && ist->discard)
 897                 break;
 898         }
 899         if (i == nb_input_streams) {
 900             av_log(NULL, AV_LOG_FATAL, "Cannot find a matching stream for "
 901                    "unlabeled input pad %d on filter %s", in->pad_idx,
 902                    in->filter_ctx->name);
 903             exit_program(1);
 904         }
 905     }
 906     ist->discard         = 0;
 907     ist->decoding_needed = 1;
 908     ist->st->discard = AVDISCARD_NONE;
 909
 910     fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs),
 911                             &fg->nb_inputs, fg->nb_inputs + 1);
 912     if (!(fg->inputs[fg->nb_inputs - 1] = av_mallocz(sizeof(*fg->inputs[0]))))
 913         exit_program(1);
 914     fg->inputs[fg->nb_inputs - 1]->ist   = ist;
 915     fg->inputs[fg->nb_inputs - 1]->graph = fg;
 916
 917     ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
 918                               &ist->nb_filters, ist->nb_filters + 1);
 919     ist->filters[ist->nb_filters - 1] = fg->inputs[fg->nb_inputs - 1];
 920 }
 921
 922 static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
 923 {
 924     AVCodecContext *codec = ofilter->ost->st->codec;
 925     AVFilterContext *last_filter = out->filter_ctx;
 926     int pad_idx = out->pad_idx;
 927     int ret;
 928     enum PixelFormat *pix_fmts = choose_pixel_fmts(ofilter->ost);
 929     AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
 930
 931 #if FF_API_OLD_VSINK_API
 932     ret = avfilter_graph_create_filter(&ofilter->filter, avfilter_get_by_name("buffersink"),
 933                                        "out", NULL, pix_fmts, fg->graph);
 934 #else
 935     buffersink_params->pixel_fmts = pix_fmts;
 936     ret = avfilter_graph_create_filter(&ofilter->filter, avfilter_get_by_name("buffersink"),
 937                                        "out", NULL, buffersink_params, fg->graph);
 938 #endif
 939     av_freep(&buffersink_params);
 940
 941     if (ret < 0)
 942         return ret;
 943
 944     if (codec->width || codec->height) {
 945         char args[255];
 946         snprintf(args, sizeof(args), "%d:%d:flags=0x%X",
 947                  codec->width,
 948                  codec->height,
 949                  (unsigned)ofilter->ost->sws_flags);
 950         if ((ret = avfilter_graph_create_filter(&last_filter, avfilter_get_by_name("scale"),
 951                                                 NULL, args, NULL, fg->graph)) < 0)
 952             return ret;
 953         if ((ret = avfilter_link(out->filter_ctx, out->pad_idx, last_filter, 0)) < 0)
 954             return ret;
 955         pad_idx = 0;
 956     }
 957
 958     if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
 959         return ret;
 960
 961     return 0;
 962 }
 963
 964 static int configure_complex_filter(FilterGraph *fg)
 965 {
 966     AVFilterInOut *inputs, *outputs, *cur;
 967     int ret, i, init = !fg->graph;
 968
 969     avfilter_graph_free(&fg->graph);
 970     if (!(fg->graph = avfilter_graph_alloc()))
 971         return AVERROR(ENOMEM);
 972
 973     if ((ret = avfilter_graph_parse2(fg->graph, fg->graph_desc, &inputs, &outputs)) < 0)
 974         return ret;
 975
 976     for (cur = inputs; init && cur; cur = cur->next)
 977         init_input_filter(fg, cur);
 978
 979     for (cur = inputs, i = 0; cur; cur = cur->next, i++) {
 980         InputFilter *ifilter = fg->inputs[i];
 981         InputStream     *ist = ifilter->ist;
 982         AVRational       sar;
 983         char            args[255];
 984
 985         sar = ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
 986                                                  ist->st->codec->sample_aspect_ratio;
 987         snprintf(args, sizeof(args), "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
 988                  ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
 989                  sar.num, sar.den);
 990
 991         if ((ret = avfilter_graph_create_filter(&ifilter->filter,
 992                                                 avfilter_get_by_name("buffer"), cur->name,
 993                                                 args, NULL, fg->graph)) < 0)
 994             return ret;
 995         if ((ret = avfilter_link(ifilter->filter, 0,
 996                                  cur->filter_ctx, cur->pad_idx)) < 0)
 997             return ret;
 998     }
 999     avfilter_inout_free(&inputs);
1000
1001     if (!init) {
1002         /* we already know the mappings between lavfi outputs and output streams,
1003          * so we can finish the setup */
1004         for (cur = outputs, i = 0; cur; cur = cur->next, i++)
1005             configure_output_filter(fg, fg->outputs[i], cur);
1006         avfilter_inout_free(&outputs);
1007
1008         if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
1009             return ret;
1010     } else {
1011         /* wait until output mappings are processed */
1012         for (cur = outputs; cur;) {
1013             fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs),
1014                                      &fg->nb_outputs, fg->nb_outputs + 1);
1015             if (!(fg->outputs[fg->nb_outputs - 1] = av_mallocz(sizeof(*fg->outputs[0]))))
1016                 exit_program(1);
1017             fg->outputs[fg->nb_outputs - 1]->graph   = fg;
1018             fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;
1019             cur = cur->next;
1020             fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;
1021         }
1022     }
1023
1024     return 0;
1025 }
1026
1027 static int configure_complex_filters(void)
1028 {
1029     int i, ret = 0;
1030
1031     for (i = 0; i < nb_filtergraphs; i++)
1032         if (!filtergraphs[i]->graph &&
1033             (ret = configure_complex_filter(filtergraphs[i])) < 0)
1034             return ret;
1035     return 0;
1036 }
1037
1038 static int configure_filtergraph(FilterGraph *fg)
1039 {
1040     return fg->graph_desc ? configure_complex_filter(fg) : configure_video_filters(fg);
1041 }
1042
1043 static int ist_in_filtergraph(FilterGraph *fg, InputStream *ist)
1044 {
1045     int i;
1046     for (i = 0; i < fg->nb_inputs; i++)
1047         if (fg->inputs[i]->ist == ist)
1048             return 1;
1049     return 0;
1050 }
1051
1052 static void term_exit(void)
1053 {
1054     av_log(NULL, AV_LOG_QUIET, "%s", "");
1055 #if HAVE_TERMIOS_H
1056     if(restore_tty)
1057         tcsetattr (0, TCSANOW, &oldtty);
1058 #endif
1059 }
1060
1061 static volatile int received_sigterm = 0;
1062
1063 static void sigterm_handler(int sig)
1064 {
1065     received_sigterm = sig;
1066     received_nb_signals++;
1067     term_exit();
1068     if(received_nb_signals > 3)
1069         exit(123);
1070 }
1071
1072 static void term_init(void)
1073 {
1074 #if HAVE_TERMIOS_H
1075     if(!run_as_daemon){
1076     struct termios tty;
1077
1078     if (tcgetattr (0, &tty) == 0) {
1079     oldtty = tty;
1080     restore_tty = 1;
1081     atexit(term_exit);
1082
1083     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1084                           |INLCR|IGNCR|ICRNL|IXON);
1085     tty.c_oflag |= OPOST;
1086     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1087     tty.c_cflag &= ~(CSIZE|PARENB);
1088     tty.c_cflag |= CS8;
1089     tty.c_cc[VMIN] = 1;
1090     tty.c_cc[VTIME] = 0;
1091
1092     tcsetattr (0, TCSANOW, &tty);
1093     }
1094     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
1095     }
1096 #endif
1097     avformat_network_deinit();
1098
1099     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
1100     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
1101 #ifdef SIGXCPU
1102     signal(SIGXCPU, sigterm_handler);
1103 #endif
1104 }
1105
1106 /* read a key without blocking */
1107 static int read_key(void)
1108 {
1109     unsigned char ch;
1110 #if HAVE_TERMIOS_H
1111     int n = 1;
1112     struct timeval tv;
1113     fd_set rfds;
1114
1115     FD_ZERO(&rfds);
1116     FD_SET(0, &rfds);
1117     tv.tv_sec = 0;
1118     tv.tv_usec = 0;
1119     n = select(1, &rfds, NULL, NULL, &tv);
1120     if (n > 0) {
1121         n = read(0, &ch, 1);
1122         if (n == 1)
1123             return ch;
1124
1125         return n;
1126     }
1127 #elif HAVE_KBHIT
1128 #    if HAVE_PEEKNAMEDPIPE
1129     static int is_pipe;
1130     static HANDLE input_handle;
1131     DWORD dw, nchars;
1132     if(!input_handle){
1133         input_handle = GetStdHandle(STD_INPUT_HANDLE);
1134         is_pipe = !GetConsoleMode(input_handle, &dw);
1135     }
1136
1137     if (stdin->_cnt > 0) {
1138         read(0, &ch, 1);
1139         return ch;
1140     }
1141     if (is_pipe) {
1142         /* When running under a GUI, you will end here. */
1143         if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
1144             return -1;
1145         //Read it
1146         if(nchars != 0) {
1147             read(0, &ch, 1);
1148             return ch;
1149         }else{
1150             return -1;
1151         }
1152     }
1153 #    endif
1154     if(kbhit())
1155         return(getch());
1156 #endif
1157     return -1;
1158 }
1159
1160 static int decode_interrupt_cb(void *ctx)
1161 {
1162     return received_nb_signals > 1;
1163 }
1164
1165 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
1166
1167 void av_noreturn exit_program(int ret)
1168 {
1169     int i, j;
1170
1171     for (i = 0; i < nb_filtergraphs; i++) {
1172         avfilter_graph_free(&filtergraphs[i]->graph);
1173         for (j = 0; j < filtergraphs[i]->nb_inputs; j++)
1174             av_freep(&filtergraphs[i]->inputs[j]);
1175         av_freep(&filtergraphs[i]->inputs);
1176         for (j = 0; j < filtergraphs[i]->nb_outputs; j++)
1177             av_freep(&filtergraphs[i]->outputs[j]);
1178         av_freep(&filtergraphs[i]->outputs);
1179         av_freep(&filtergraphs[i]);
1180     }
1181     av_freep(&filtergraphs);
1182
1183     /* close files */
1184     for (i = 0; i < nb_output_files; i++) {
1185         AVFormatContext *s = output_files[i]->ctx;
1186         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1187             avio_close(s->pb);
1188         avformat_free_context(s);
1189         av_dict_free(&output_files[i]->opts);
1190         av_freep(&output_files[i]);
1191     }
1192     for (i = 0; i < nb_output_streams; i++) {
1193         AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
1194         while (bsfc) {
1195             AVBitStreamFilterContext *next = bsfc->next;
1196             av_bitstream_filter_close(bsfc);
1197             bsfc = next;
1198         }
1199         output_streams[i]->bitstream_filters = NULL;
1200
1201         if (output_streams[i]->output_frame) {
1202             AVFrame *frame = output_streams[i]->output_frame;
1203             if (frame->extended_data != frame->data)
1204                 av_freep(&frame->extended_data);
1205             av_freep(&frame);
1206         }
1207         av_freep(&output_streams[i]->filtered_frame);
1208         av_freep(&output_streams[i]);
1209     }
1210     for (i = 0; i < nb_input_files; i++) {
1211         avformat_close_input(&input_files[i]->ctx);
1212         av_freep(&input_files[i]);
1213     }
1214     for (i = 0; i < nb_input_streams; i++) {
1215         av_freep(&input_streams[i]->decoded_frame);
1216         av_dict_free(&input_streams[i]->opts);
1217         free_buffer_pool(input_streams[i]);
1218         av_freep(&input_streams[i]->filters);
1219         av_freep(&input_streams[i]);
1220     }
1221
1222     if (vstats_file)
1223         fclose(vstats_file);
1224     av_free(vstats_filename);
1225
1226     av_freep(&input_streams);
1227     av_freep(&input_files);
1228     av_freep(&output_streams);
1229     av_freep(&output_files);
1230
1231     uninit_opts();
1232     av_freep(&audio_buf);
1233     allocated_audio_buf_size = 0;
1234     av_freep(&async_buf);
1235     allocated_async_buf_size = 0;
1236
1237     avfilter_uninit();
1238     avformat_network_deinit();
1239
1240     if (received_sigterm) {
1241         av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
1242                (int) received_sigterm);
1243         exit (255);
1244     }
1245
1246     exit(ret); /* not all OS-es handle main() return value */
1247 }
1248
1249 static void assert_avoptions(AVDictionary *m)
1250 {
1251     AVDictionaryEntry *t;
1252     if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1253         av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
1254         exit_program(1);
1255     }
1256 }
1257
1258 static void assert_codec_experimental(AVCodecContext *c, int encoder)
1259 {
1260     const char *codec_string = encoder ? "encoder" : "decoder";
1261     AVCodec *codec;
1262     if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
1263         c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1264         av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
1265                 "results.\nAdd '-strict experimental' if you want to use it.\n",
1266                 codec_string, c->codec->name);
1267         codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
1268         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
1269             av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
1270                    codec_string, codec->name);
1271         exit_program(1);
1272     }
1273 }
1274
1275 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
1276 {
1277     if (codec && codec->sample_fmts) {
1278         const enum AVSampleFormat *p = codec->sample_fmts;
1279         for (; *p != -1; p++) {
1280             if (*p == st->codec->sample_fmt)
1281                 break;
1282         }
1283         if (*p == -1) {
1284             if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
1285                 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
1286             if(av_get_sample_fmt_name(st->codec->sample_fmt))
1287             av_log(NULL, AV_LOG_WARNING,
1288                    "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
1289                    av_get_sample_fmt_name(st->codec->sample_fmt),
1290                    codec->name,
1291                    av_get_sample_fmt_name(codec->sample_fmts[0]));
1292             st->codec->sample_fmt = codec->sample_fmts[0];
1293         }
1294     }
1295 }
1296
1297 static void choose_sample_rate(AVStream *st, AVCodec *codec)
1298 {
1299     if (codec && codec->supported_samplerates) {
1300         const int *p  = codec->supported_samplerates;
1301         int best      = 0;
1302         int best_dist = INT_MAX;
1303         for (; *p; p++) {
1304             int dist = abs(st->codec->sample_rate - *p);
1305             if (dist < best_dist) {
1306                 best_dist = dist;
1307                 best      = *p;
1308             }
1309         }
1310         if (best_dist) {
1311             int i;
1312             const int *sample_rates = codec->supported_samplerates;
1313             av_log(st->codec, AV_LOG_WARNING,
1314                    "Requested sampling rate (%dHz) unsupported, using %dHz instead\n"
1315                    "Available sampling rates for %s:",
1316                    st->codec->sample_rate, best, codec->name);
1317             for (i = 0; sample_rates[i]; i++) {
1318                 if (!sample_rates[i + 1]) av_log(st->codec, AV_LOG_WARNING, " and");
1319                 else if (i)               av_log(st->codec, AV_LOG_WARNING, ",");
1320                 av_log(st->codec, AV_LOG_WARNING, " %d", sample_rates[i]);
1321             }
1322             av_log(st->codec, AV_LOG_WARNING, ".\n");
1323         }
1324         st->codec->sample_rate = best;
1325     }
1326 }
1327
1328 static double
1329 get_sync_ipts(const OutputStream *ost, int64_t pts)
1330 {
1331     OutputFile *of = output_files[ost->file_index];
1332     return (double)(pts - of->start_time) / AV_TIME_BASE;
1333 }
1334
1335 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
1336 {
1337     AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
1338     AVCodecContext          *avctx = ost->st->codec;
1339     int ret;
1340
1341     if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
1342         (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
1343         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1344
1345     /*
1346      * Audio encoders may split the packets --  #frames in != #packets out.
1347      * But there is no reordering, so we can limit the number of output packets
1348      * by simply dropping them here.
1349      * Counting encoded video frames needs to be done separately because of
1350      * reordering, see do_video_out()
1351      */
1352     if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
1353         if (ost->frame_number >= ost->max_frames) {
1354             av_free_packet(pkt);
1355             return;
1356         }
1357         ost->frame_number++;
1358     }
1359
1360     while (bsfc) {
1361         AVPacket new_pkt = *pkt;
1362         int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
1363                                            &new_pkt.data, &new_pkt.size,
1364                                            pkt->data, pkt->size,
1365                                            pkt->flags & AV_PKT_FLAG_KEY);
1366         if (a > 0) {
1367             av_free_packet(pkt);
1368             new_pkt.destruct = av_destruct_packet;
1369         } else if (a < 0) {
1370             av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
1371                    bsfc->filter->name, pkt->stream_index,
1372                    avctx->codec ? avctx->codec->name : "copy");
1373             print_error("", a);
1374             if (exit_on_error)
1375                 exit_program(1);
1376         }
1377         *pkt = new_pkt;
1378
1379         bsfc = bsfc->next;
1380     }
1381
1382     pkt->stream_index = ost->index;
1383     ret = av_interleaved_write_frame(s, pkt);
1384     if (ret < 0) {
1385         print_error("av_interleaved_write_frame()", ret);
1386         exit_program(1);
1387     }
1388 }
1389
1390 static void get_default_channel_layouts(OutputStream *ost, InputStream *ist)
1391 {
1392     char layout_name[256];
1393     AVCodecContext *enc = ost->st->codec;
1394     AVCodecContext *dec = ist->st->codec;
1395
1396     if (dec->channel_layout &&
1397         av_get_channel_layout_nb_channels(dec->channel_layout) != dec->channels) {
1398         av_get_channel_layout_string(layout_name, sizeof(layout_name),
1399                                      dec->channels, dec->channel_layout);
1400         av_log(NULL, AV_LOG_ERROR, "New channel layout (%s) is invalid\n",
1401                layout_name);
1402         dec->channel_layout = 0;
1403     }
1404     if (!dec->channel_layout) {
1405         if (enc->channel_layout && dec->channels == enc->channels) {
1406             dec->channel_layout = enc->channel_layout;
1407         } else {
1408             dec->channel_layout = av_get_default_channel_layout(dec->channels);
1409
1410             if (!dec->channel_layout) {
1411                 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
1412                        "layout for Input Stream #%d.%d\n", ist->file_index,
1413                        ist->st->index);
1414                 exit_program(1);
1415             }
1416         }
1417         av_get_channel_layout_string(layout_name, sizeof(layout_name),
1418                                      dec->channels, dec->channel_layout);
1419         av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for  Input Stream "
1420                "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
1421     }
1422     if (!enc->channel_layout) {
1423         if (dec->channels == enc->channels) {
1424             enc->channel_layout = dec->channel_layout;
1425             return;
1426         } else {
1427             enc->channel_layout = av_get_default_channel_layout(enc->channels);
1428         }
1429         if (!enc->channel_layout) {
1430             av_log(NULL, AV_LOG_FATAL, "Unable to find default channel layout "
1431                    "for Output Stream #%d.%d\n", ost->file_index,
1432                    ost->st->index);
1433             exit_program(1);
1434         }
1435         av_get_channel_layout_string(layout_name, sizeof(layout_name),
1436                                      enc->channels, enc->channel_layout);
1437         av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Output Stream "
1438                "#%d.%d : %s\n", ost->file_index, ost->st->index, layout_name);
1439     }
1440 }
1441
1442 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1443 {
1444     int fill_char = 0x00;
1445     if (sample_fmt == AV_SAMPLE_FMT_U8)
1446         fill_char = 0x80;
1447     memset(buf, fill_char, size);
1448 }
1449
1450 static int encode_audio_frame(AVFormatContext *s, OutputStream *ost,
1451                               const uint8_t *buf, int buf_size)
1452 {
1453     AVCodecContext *enc = ost->st->codec;
1454     AVFrame *frame = NULL;
1455     AVPacket pkt;
1456     int ret, got_packet;
1457
1458     av_init_packet(&pkt);
1459     pkt.data = NULL;
1460     pkt.size = 0;
1461
1462     if (buf && buf_size) {
1463         if (!ost->output_frame) {
1464             ost->output_frame = avcodec_alloc_frame();
1465             if (!ost->output_frame) {
1466                 av_log(NULL, AV_LOG_FATAL, "out-of-memory in encode_audio_frame()\n");
1467                 exit_program(1);
1468             }
1469         }
1470         frame = ost->output_frame;
1471         if (frame->extended_data != frame->data)
1472             av_freep(&frame->extended_data);
1473         avcodec_get_frame_defaults(frame);
1474
1475         frame->nb_samples  = buf_size /
1476                              (enc->channels * av_get_bytes_per_sample(enc->sample_fmt));
1477         if ((ret = avcodec_fill_audio_frame(frame, enc->channels, enc->sample_fmt,
1478                                             buf, buf_size, 1)) < 0) {
1479             av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_fill_audio_frame)\n");
1480             exit_program(1);
1481         }
1482
1483         frame->pts = ost->sync_opts;
1484         ost->sync_opts += frame->nb_samples;
1485     }
1486
1487     got_packet = 0;
1488     update_benchmark(NULL);
1489     if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
1490         av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
1491         exit_program(1);
1492     }
1493     update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
1494
1495     ret = pkt.size;
1496
1497     if (got_packet) {
1498         if (pkt.pts != AV_NOPTS_VALUE)
1499             pkt.pts      = av_rescale_q(pkt.pts,      enc->time_base, ost->st->time_base);
1500         if (pkt.dts != AV_NOPTS_VALUE) {
1501             int64_t max = ost->st->cur_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
1502             pkt.dts      = av_rescale_q(pkt.dts,      enc->time_base, ost->st->time_base);
1503             if (ost->st->cur_dts && ost->st->cur_dts != AV_NOPTS_VALUE &&  max > pkt.dts) {
1504                 av_log(s, max - pkt.dts > 2 ? AV_LOG_WARNING : AV_LOG_DEBUG, "Audio timestamp %"PRId64" < %"PRId64" invalid, cliping\n", pkt.dts, max);
1505                 pkt.pts = pkt.dts = max;
1506             }
1507         }
1508         if (pkt.duration > 0)
1509             pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1510
1511         write_frame(s, &pkt, ost);
1512
1513         audio_size += pkt.size;
1514
1515         av_free_packet(&pkt);
1516     }
1517
1518     if (debug_ts) {
1519         av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
1520                "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1521                av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1522                av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1523     }
1524
1525     return ret;
1526 }
1527
1528 static int alloc_audio_output_buf(AVCodecContext *dec, AVCodecContext *enc,
1529                                   int nb_samples, int *buf_linesize)
1530 {
1531     int64_t audio_buf_samples;
1532     int audio_buf_size;
1533
1534     /* calculate required number of samples to allocate */
1535     audio_buf_samples = ((int64_t)nb_samples * enc->sample_rate + dec->sample_rate) /
1536                         dec->sample_rate;
1537     audio_buf_samples = 4 * audio_buf_samples + 10000; // safety factors for resampling
1538     audio_buf_samples = FFMAX(audio_buf_samples, enc->frame_size);
1539     if (audio_buf_samples > INT_MAX)
1540         return AVERROR(EINVAL);
1541
1542     audio_buf_size = av_samples_get_buffer_size(buf_linesize, enc->channels,
1543                                                 audio_buf_samples,
1544                                                 enc->sample_fmt, 0);
1545     if (audio_buf_size < 0)
1546         return audio_buf_size;
1547
1548     av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
1549     if (!audio_buf)
1550         return AVERROR(ENOMEM);
1551
1552     return 0;
1553 }
1554
1555 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1556                          InputStream *ist, AVFrame *decoded_frame)
1557 {
1558     uint8_t *buftmp;
1559     int64_t size_out;
1560
1561     int frame_bytes, resample_changed, ret;
1562     AVCodecContext *enc = ost->st->codec;
1563     AVCodecContext *dec = ist->st->codec;
1564     int osize = av_get_bytes_per_sample(enc->sample_fmt);
1565     int isize = av_get_bytes_per_sample(dec->sample_fmt);
1566     uint8_t *buf[AV_NUM_DATA_POINTERS];
1567     int size     = decoded_frame->nb_samples * dec->channels * isize;
1568     int planes   = av_sample_fmt_is_planar(dec->sample_fmt) ? dec->channels : 1;
1569     int i;
1570     int out_linesize = 0;
1571     int buf_linesize = decoded_frame->linesize[0];
1572
1573     av_assert0(planes <= AV_NUM_DATA_POINTERS);
1574
1575     for(i=0; i<planes; i++)
1576         buf[i]= decoded_frame->data[i];
1577
1578
1579     get_default_channel_layouts(ost, ist);
1580
1581     if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples, &out_linesize) < 0) {
1582         av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n");
1583         exit_program(1);
1584     }
1585
1586     if (audio_sync_method > 1                      ||
1587         enc->channels       != dec->channels       ||
1588         enc->channel_layout != dec->channel_layout ||
1589         enc->sample_rate    != dec->sample_rate    ||
1590         dec->sample_fmt     != enc->sample_fmt)
1591         ost->audio_resample = 1;
1592
1593     resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
1594                        ost->resample_channels    != dec->channels   ||
1595                        ost->resample_channel_layout != dec->channel_layout ||
1596                        ost->resample_sample_rate != dec->sample_rate;
1597
1598     if ((ost->audio_resample && !ost->swr) || resample_changed || ost->audio_channels_mapped) {
1599
1600         if (resample_changed) {
1601             av_log(NULL, AV_LOG_INFO, "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:0x%"PRIx64" to rate:%d fmt:%s ch:%d chl:0x%"PRIx64"\n",
1602                    ist->file_index, ist->st->index,
1603                    ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt),
1604                    ost->resample_channels, ost->resample_channel_layout,
1605                    dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt),
1606                    dec->channels, dec->channel_layout);
1607             ost->resample_sample_fmt  = dec->sample_fmt;
1608             ost->resample_channels    = dec->channels;
1609             ost->resample_channel_layout = dec->channel_layout;
1610             ost->resample_sample_rate = dec->sample_rate;
1611             swr_free(&ost->swr);
1612         }
1613         /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
1614         if (audio_sync_method <= 1 && !ost->audio_channels_mapped &&
1615             ost->resample_sample_fmt  == enc->sample_fmt &&
1616             ost->resample_channels    == enc->channels   &&
1617             ost->resample_channel_layout == enc->channel_layout &&
1618             ost->resample_sample_rate == enc->sample_rate) {
1619             //ost->swr = NULL;
1620             ost->audio_resample = 0;
1621         } else {
1622             ost->swr = swr_alloc_set_opts(ost->swr,
1623                                           enc->channel_layout, enc->sample_fmt, enc->sample_rate,
1624                                           dec->channel_layout, dec->sample_fmt, dec->sample_rate,
1625                                           0, NULL);
1626             av_opt_set_int(ost->swr, "dither_method", ost->swr_dither_method,0);
1627             av_opt_set_double(ost->swr, "dither_scale", ost->swr_dither_scale,0);
1628             if (ost->audio_channels_mapped)
1629                 swr_set_channel_mapping(ost->swr, ost->audio_channels_map);
1630             av_opt_set_double(ost->swr, "rmvol", ost->rematrix_volume, 0);
1631             if (ost->audio_channels_mapped) {
1632                 av_opt_set_int(ost->swr, "icl", av_get_default_channel_layout(ost->audio_channels_mapped), 0);
1633                 av_opt_set_int(ost->swr, "uch", ost->audio_channels_mapped, 0);
1634             }
1635             if (av_opt_set_int(ost->swr, "ich", dec->channels, 0) < 0) {
1636                 av_log(NULL, AV_LOG_FATAL, "Unsupported number of input channels\n");
1637                 exit_program(1);
1638             }
1639             if (av_opt_set_int(ost->swr, "och", enc->channels, 0) < 0) {
1640                 av_log(NULL, AV_LOG_FATAL, "Unsupported number of output channels\n");
1641                 exit_program(1);
1642             }
1643             if(audio_sync_method>1) av_opt_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE, 0);
1644             if(ost->swr && swr_init(ost->swr) < 0){
1645                 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
1646                 swr_free(&ost->swr);
1647             }
1648
1649             if (!ost->swr) {
1650                 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
1651                         dec->channels, dec->sample_rate,
1652                         enc->channels, enc->sample_rate);
1653                 exit_program(1);
1654             }
1655         }
1656     }
1657
1658     av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1659
1660     if (audio_sync_method > 0) {
1661         double delta = get_sync_ipts(ost, ist->pts) * enc->sample_rate - ost->sync_opts -
1662                        av_fifo_size(ost->fifo) / (enc->channels * osize);
1663         int idelta = delta * dec->sample_rate / enc->sample_rate;
1664         int byte_delta = idelta * isize * dec->channels;
1665
1666         // FIXME resample delay
1667         if (fabs(delta) > 50) {
1668             if (ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate) {
1669                 if (byte_delta < 0) {
1670                     byte_delta = FFMAX(byte_delta, -size);
1671                     size += byte_delta;
1672                     for (i=0; i<planes; i++)
1673                         buf[i]  -= byte_delta/planes;
1674                     av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
1675                            -byte_delta / (isize * dec->channels));
1676                     if (!size)
1677                         return;
1678                     ist->is_start = 0;
1679                 } else {
1680                     av_fast_malloc(&async_buf, &allocated_async_buf_size,
1681                                    byte_delta + size);
1682                     if (!async_buf) {
1683                         av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
1684                         exit_program(1);
1685                     }
1686
1687                     if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples + idelta, &out_linesize) < 0) {
1688                         av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n");
1689                         exit_program(1);
1690                     }
1691                     ist->is_start = 0;
1692
1693                     for (i=0; i<planes; i++) {
1694                         uint8_t *t = async_buf + i*((byte_delta + size)/planes);
1695                         generate_silence(t, dec->sample_fmt, byte_delta/planes);
1696                         memcpy(t + byte_delta/planes, buf[i], size/planes);
1697                         buf[i] = t;
1698                     }
1699                     size += byte_delta;
1700                     buf_linesize = allocated_async_buf_size;
1701                     av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
1702                 }
1703             } else if (audio_sync_method > 1) {
1704                 int comp = av_clip(delta, -audio_sync_method, audio_sync_method);
1705                 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
1706                        delta, comp, enc->sample_rate);
1707 //                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));
1708                 swr_set_compensation(ost->swr, comp, enc->sample_rate);
1709             }
1710         }
1711     } else if (audio_sync_method == 0)
1712         ost->sync_opts = lrintf(get_sync_ipts(ost, ist->pts) * enc->sample_rate) -
1713                                 av_fifo_size(ost->fifo) / (enc->channels * osize); // FIXME wrong
1714
1715     if (ost->audio_resample || ost->audio_channels_mapped) {
1716         buftmp = audio_buf;
1717         size_out = swr_convert(ost->swr, (      uint8_t*[]){buftmp},
1718                                       allocated_audio_buf_size / (enc->channels * osize),
1719                                       buf,
1720                                       size / (dec->channels * isize));
1721         if (size_out < 0) {
1722             av_log(NULL, AV_LOG_FATAL, "swr_convert failed\n");
1723             exit_program(1);
1724         }
1725         size_out = size_out * enc->channels * osize;
1726     } else {
1727         buftmp = buf[0];
1728         size_out = size;
1729     }
1730
1731     av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1732
1733     /* now encode as many frames as possible */
1734     if (!(enc->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {
1735         /* output resampled raw samples */
1736         if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
1737             av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
1738             exit_program(1);
1739         }
1740         av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1741
1742         frame_bytes = enc->frame_size * osize * enc->channels;
1743
1744         while (av_fifo_size(ost->fifo) >= frame_bytes) {
1745             av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1746             encode_audio_frame(s, ost, audio_buf, frame_bytes);
1747         }
1748     } else {
1749         encode_audio_frame(s, ost, buftmp, size_out);
1750     }
1751 }
1752
1753 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1754 {
1755     AVCodecContext *dec;
1756     AVPicture *picture2;
1757     AVPicture picture_tmp;
1758     uint8_t *buf = 0;
1759
1760     dec = ist->st->codec;
1761
1762     /* deinterlace : must be done before any resize */
1763     if (do_deinterlace) {
1764         int size;
1765
1766         /* create temporary picture */
1767         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1768         buf  = av_malloc(size);
1769         if (!buf)
1770             return;
1771
1772         picture2 = &picture_tmp;
1773         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1774
1775         if (avpicture_deinterlace(picture2, picture,
1776                                  dec->pix_fmt, dec->width, dec->height) < 0) {
1777             /* if error, do not deinterlace */
1778             av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1779             av_free(buf);
1780             buf = NULL;
1781             picture2 = picture;
1782         }
1783     } else {
1784         picture2 = picture;
1785     }
1786
1787     if (picture != picture2)
1788         *picture = *picture2;
1789     *bufp = buf;
1790 }
1791
1792 static void do_subtitle_out(AVFormatContext *s,
1793                             OutputStream *ost,
1794                             InputStream *ist,
1795                             AVSubtitle *sub,
1796                             int64_t pts)
1797 {
1798     static uint8_t *subtitle_out = NULL;
1799     int subtitle_out_max_size = 1024 * 1024;
1800     int subtitle_out_size, nb, i;
1801     AVCodecContext *enc;
1802     AVPacket pkt;
1803
1804     if (pts == AV_NOPTS_VALUE) {
1805         av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1806         if (exit_on_error)
1807             exit_program(1);
1808         return;
1809     }
1810
1811     enc = ost->st->codec;
1812
1813     if (!subtitle_out) {
1814         subtitle_out = av_malloc(subtitle_out_max_size);
1815     }
1816
1817     /* Note: DVB subtitle need one packet to draw them and one other
1818        packet to clear them */
1819     /* XXX: signal it in the codec context ? */
1820     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1821         nb = 2;
1822     else
1823         nb = 1;
1824
1825     for (i = 0; i < nb; i++) {
1826         ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
1827
1828         sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1829         // start_display_time is required to be 0
1830         sub->pts               += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1831         sub->end_display_time  -= sub->start_display_time;
1832         sub->start_display_time = 0;
1833         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1834                                                     subtitle_out_max_size, sub);
1835         if (subtitle_out_size < 0) {
1836             av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1837             exit_program(1);
1838         }
1839
1840         av_init_packet(&pkt);
1841         pkt.data = subtitle_out;
1842         pkt.size = subtitle_out_size;
1843         pkt.pts  = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1844         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1845             /* XXX: the pts correction is handled here. Maybe handling
1846                it in the codec would be better */
1847             if (i == 0)
1848                 pkt.pts += 90 * sub->start_display_time;
1849             else
1850                 pkt.pts += 90 * sub->end_display_time;
1851         }
1852         write_frame(s, &pkt, ost);
1853     }
1854 }
1855
1856 static double psnr(double d)
1857 {
1858     return -10.0 * log(d) / log(10.0);
1859 }
1860
1861 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1862                            int frame_size)
1863 {
1864     AVCodecContext *enc;
1865     int frame_number;
1866     double ti1, bitrate, avg_bitrate;
1867
1868     /* this is executed just the first time do_video_stats is called */
1869     if (!vstats_file) {
1870         vstats_file = fopen(vstats_filename, "w");
1871         if (!vstats_file) {
1872             perror("fopen");
1873             exit_program(1);
1874         }
1875     }
1876
1877     enc = ost->st->codec;
1878     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1879         frame_number = ost->frame_number;
1880         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1881         if (enc->flags&CODEC_FLAG_PSNR)
1882             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1883
1884         fprintf(vstats_file,"f_size= %6d ", frame_size);
1885         /* compute pts value */
1886         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1887         if (ti1 < 0.01)
1888             ti1 = 0.01;
1889
1890         bitrate     = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1891         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1892         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1893                (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1894         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1895     }
1896 }
1897
1898
1899 static void do_video_out(AVFormatContext *s, OutputStream *ost,
1900                          AVFrame *in_picture, float quality)
1901 {
1902     int nb_frames, i, ret, format_video_sync;
1903     AVCodecContext *enc;
1904     double sync_ipts, delta;
1905     double duration = 0;
1906     int frame_size = 0;
1907     InputStream *ist = NULL;
1908
1909     if (ost->source_index >= 0)
1910         ist = input_streams[ost->source_index];
1911
1912     enc = ost->st->codec;
1913
1914     if (ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1915         duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1916         if(ist->st->r_frame_rate.num)
1917             duration= FFMAX(duration, 1/av_q2d(ist->st->r_frame_rate));
1918         if(ist->st->avg_frame_rate.num && 0)
1919             duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1920
1921         duration /= av_q2d(enc->time_base);
1922     }
1923
1924     sync_ipts = get_sync_ipts(ost, in_picture->pts) / av_q2d(enc->time_base);
1925     delta = sync_ipts - ost->sync_opts + duration;
1926
1927     /* by default, we output a single frame */
1928     nb_frames = 1;
1929
1930     format_video_sync = video_sync_method;
1931     if (format_video_sync == VSYNC_AUTO)
1932         format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1933
1934     switch (format_video_sync) {
1935     case VSYNC_CFR:
1936         // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1937         if (delta < -1.1)
1938             nb_frames = 0;
1939         else if (delta > 1.1)
1940             nb_frames = lrintf(delta);
1941         break;
1942     case VSYNC_VFR:
1943         if (delta <= -0.6)
1944             nb_frames = 0;
1945         else if (delta > 0.6)
1946             ost->sync_opts = lrintf(sync_ipts);
1947         break;
1948     case VSYNC_DROP:
1949     case VSYNC_PASSTHROUGH:
1950         ost->sync_opts = lrintf(sync_ipts);
1951         break;
1952     default:
1953         av_assert0(0);
1954     }
1955
1956     nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1957     if (nb_frames == 0) {
1958         nb_frames_drop++;
1959         av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1960         return;
1961     } else if (nb_frames > 1) {
1962         nb_frames_dup += nb_frames - 1;
1963         av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1964     }
1965
1966     /* duplicates frame if needed */
1967     for (i = 0; i < nb_frames; i++) {
1968         AVPacket pkt;
1969         av_init_packet(&pkt);
1970         pkt.data = NULL;
1971         pkt.size = 0;
1972
1973         if (s->oformat->flags & AVFMT_RAWPICTURE &&
1974             enc->codec->id == CODEC_ID_RAWVIDEO) {
1975             /* raw pictures are written as AVPicture structure to
1976                avoid any copies. We support temporarily the older
1977                method. */
1978             enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1979             enc->coded_frame->top_field_first  = in_picture->top_field_first;
1980             pkt.data   = (uint8_t *)in_picture;
1981             pkt.size   =  sizeof(AVPicture);
1982             pkt.pts    = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1983             pkt.flags |= AV_PKT_FLAG_KEY;
1984
1985             write_frame(s, &pkt, ost);
1986         } else {
1987             int got_packet;
1988             AVFrame big_picture;
1989
1990             big_picture = *in_picture;
1991             /* better than nothing: use input picture interlaced
1992                settings */
1993             big_picture.interlaced_frame = in_picture->interlaced_frame;
1994             if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1995                 if (ost->top_field_first == -1)
1996                     big_picture.top_field_first = in_picture->top_field_first;
1997                 else
1998                     big_picture.top_field_first = !!ost->top_field_first;
1999             }
2000
2001             /* handles same_quant here. This is not correct because it may
2002                not be a global option */
2003             big_picture.quality = quality;
2004             if (!enc->me_threshold)
2005                 big_picture.pict_type = 0;
2006             big_picture.pts = ost->sync_opts;
2007             if (ost->forced_kf_index < ost->forced_kf_count &&
2008                 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
2009                 big_picture.pict_type = AV_PICTURE_TYPE_I;
2010                 ost->forced_kf_index++;
2011             }
2012             update_benchmark(NULL);
2013             ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
2014             update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
2015             if (ret < 0) {
2016                 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
2017                 exit_program(1);
2018             }
2019
2020             if (got_packet) {
2021                 if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))
2022                     pkt.pts = ost->sync_opts;
2023
2024                 if (pkt.pts != AV_NOPTS_VALUE)
2025                     pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2026                 if (pkt.dts != AV_NOPTS_VALUE)
2027                     pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2028
2029                 if (debug_ts) {
2030                     av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
2031                            "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
2032                            av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
2033                            av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
2034                 }
2035
2036                 write_frame(s, &pkt, ost);
2037                 frame_size = pkt.size;
2038                 video_size += pkt.size;
2039                 av_free_packet(&pkt);
2040
2041                 /* if two pass, output log */
2042                 if (ost->logfile && enc->stats_out) {
2043                     fprintf(ost->logfile, "%s", enc->stats_out);
2044                 }
2045             }
2046         }
2047         ost->sync_opts++;
2048         /*
2049          * For video, number of frames in == number of packets out.
2050          * But there may be reordering, so we can't throw away frames on encoder
2051          * flush, we need to limit them here, before they go into encoder.
2052          */
2053         ost->frame_number++;
2054     }
2055     if (vstats_filename && frame_size)
2056         do_video_stats(output_files[ost->file_index]->ctx, ost, frame_size);
2057 }
2058
2059 /* check for new output on any of the filtergraphs */
2060 static int poll_filters(void)
2061 {
2062     AVFilterBufferRef *picref;
2063     AVFrame *filtered_frame = NULL;
2064     int i, ret, ret_all;
2065     unsigned nb_success, nb_eof;
2066
2067     while (1) {
2068         /* Reap all buffers present in the buffer sinks */
2069         for (i = 0; i < nb_output_streams; i++) {
2070             OutputStream *ost = output_streams[i];
2071             OutputFile    *of = output_files[ost->file_index];
2072
2073             if (!ost->filter || ost->is_past_recording_time)
2074                 continue;
2075
2076             if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
2077                 return AVERROR(ENOMEM);
2078             } else
2079                 avcodec_get_frame_defaults(ost->filtered_frame);
2080             filtered_frame = ost->filtered_frame;
2081
2082             while (1) {
2083                 AVRational ist_pts_tb = ost->filter->filter->inputs[0]->time_base;
2084                 ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref,
2085                                                    AV_BUFFERSINK_FLAG_NO_REQUEST);
2086                 if (ret < 0) {
2087                     if (ret != AVERROR(EAGAIN)) {
2088                         char buf[256];
2089                         av_strerror(ret, buf, sizeof(buf));
2090                         av_log(NULL, AV_LOG_WARNING,
2091                                "Error in av_buffersink_get_buffer_ref(): %s\n", buf);
2092                     }
2093                     break;
2094                 }
2095                 filtered_frame->pts = av_rescale_q(picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2096                 //if (ost->source_index >= 0)
2097                 //    *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
2098
2099                 if (of->start_time && filtered_frame->pts < of->start_time)
2100                     return 0;
2101
2102                 switch (ost->filter->filter->inputs[0]->type) {
2103                 case AVMEDIA_TYPE_VIDEO:
2104                     avfilter_fill_frame_from_video_buffer_ref(filtered_frame, picref);
2105                     if (!ost->frame_aspect_ratio)
2106                         ost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;
2107
2108                     do_video_out(of->ctx, ost, filtered_frame,
2109                                  same_quant ? ost->last_quality :
2110                                               ost->st->codec->global_quality);
2111                     break;
2112                 default:
2113                     // TODO support audio/subtitle filters
2114                     av_assert0(0);
2115                 }
2116
2117                 avfilter_unref_buffer(picref);
2118             }
2119         }
2120         /* Request frames through all the graphs */
2121         ret_all = nb_success = nb_eof = 0;
2122         for (i = 0; i < nb_filtergraphs; i++) {
2123             ret = avfilter_graph_request_oldest(filtergraphs[i]->graph);
2124             if (!ret) {
2125                 nb_success++;
2126             } else if (ret == AVERROR_EOF) {
2127                 nb_eof++;
2128             } else if (ret != AVERROR(EAGAIN)) {
2129                 char buf[256];
2130                 av_strerror(ret, buf, sizeof(buf));
2131                 av_log(NULL, AV_LOG_WARNING,
2132                        "Error in request_frame(): %s\n", buf);
2133                 ret_all = ret;
2134             }
2135         }
2136         if (!nb_success)
2137             break;
2138         /* Try again if anything succeeded */
2139     }
2140     return nb_eof == nb_filtergraphs ? AVERROR_EOF : ret_all;
2141 }
2142
2143 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
2144 {
2145     char buf[1024];
2146     OutputStream *ost;
2147     AVFormatContext *oc;
2148     int64_t total_size;
2149     AVCodecContext *enc;
2150     int frame_number, vid, i;
2151     double bitrate;
2152     int64_t pts = INT64_MAX;
2153     static int64_t last_time = -1;
2154     static int qp_histogram[52];
2155     int hours, mins, secs, us;
2156
2157     if (!print_stats && !is_last_report)
2158         return;
2159
2160     if (!is_last_report) {
2161         if (last_time == -1) {
2162             last_time = cur_time;
2163             return;
2164         }
2165         if ((cur_time - last_time) < 500000)
2166             return;
2167         last_time = cur_time;
2168     }
2169
2170
2171     oc = output_files[0]->ctx;
2172
2173     total_size = avio_size(oc->pb);
2174     if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
2175         total_size = avio_tell(oc->pb);
2176         if (total_size < 0)
2177             total_size = 0;
2178     }
2179
2180     buf[0] = '\0';
2181     vid = 0;
2182     for (i = 0; i < nb_output_streams; i++) {
2183         float q = -1;
2184         ost = output_streams[i];
2185         enc = ost->st->codec;
2186         if (!ost->stream_copy && enc->coded_frame)
2187             q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
2188         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2189             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
2190         }
2191         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2192             float fps, t = (cur_time-timer_start) / 1000000.0;
2193
2194             frame_number = ost->frame_number;
2195             fps = t > 1 ? frame_number / t : 0;
2196             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
2197                      frame_number, fps < 9.95, fps, q);
2198             if (is_last_report)
2199                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
2200             if (qp_hist) {
2201                 int j;
2202                 int qp = lrintf(q);
2203                 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
2204                     qp_histogram[qp]++;
2205                 for (j = 0; j < 32; j++)
2206                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
2207             }
2208             if (enc->flags&CODEC_FLAG_PSNR) {
2209                 int j;
2210                 double error, error_sum = 0;
2211                 double scale, scale_sum = 0;
2212                 char type[3] = { 'Y','U','V' };
2213                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
2214                 for (j = 0; j < 3; j++) {
2215                     if (is_last_report) {
2216                         error = enc->error[j];
2217                         scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
2218                     } else {
2219                         error = enc->coded_frame->error[j];
2220                         scale = enc->width * enc->height * 255.0 * 255.0;
2221                     }
2222                     if (j)
2223                         scale /= 4;
2224                     error_sum += error;
2225                     scale_sum += scale;
2226                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
2227                 }
2228                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
2229             }
2230             vid = 1;
2231         }
2232         /* compute min output value */
2233         pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
2234                                       ost->st->time_base, AV_TIME_BASE_Q));
2235     }
2236
2237     secs = pts / AV_TIME_BASE;
2238     us = pts % AV_TIME_BASE;
2239     mins = secs / 60;
2240     secs %= 60;
2241     hours = mins / 60;
2242     mins %= 60;
2243
2244     bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
2245
2246     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2247              "size=%8.0fkB time=", total_size / 1024.0);
2248     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2249              "%02d:%02d:%02d.%02d ", hours, mins, secs,
2250              (100 * us) / AV_TIME_BASE);
2251     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2252              "bitrate=%6.1fkbits/s", bitrate);
2253
2254     if (nb_frames_dup || nb_frames_drop)
2255         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
2256                 nb_frames_dup, nb_frames_drop);
2257
2258     av_log(NULL, AV_LOG_INFO, "%s    \r", buf);
2259
2260     fflush(stderr);
2261
2262     if (is_last_report) {
2263         int64_t raw= audio_size + video_size + extra_size;
2264         av_log(NULL, AV_LOG_INFO, "\n");
2265         av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
2266                video_size / 1024.0,
2267                audio_size / 1024.0,
2268                extra_size / 1024.0,
2269                100.0 * (total_size - raw) / raw
2270         );
2271         if(video_size + audio_size + extra_size == 0){
2272             av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
2273         }
2274     }
2275 }
2276
2277 static void flush_encoders(void)
2278 {
2279     int i, ret;
2280
2281     for (i = 0; i < nb_output_streams; i++) {
2282         OutputStream   *ost = output_streams[i];
2283         AVCodecContext *enc = ost->st->codec;
2284         AVFormatContext *os = output_files[ost->file_index]->ctx;
2285         int stop_encoding = 0;
2286
2287         if (!ost->encoding_needed)
2288             continue;
2289
2290         if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
2291             continue;
2292         if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
2293             continue;
2294
2295         for (;;) {
2296             AVPacket pkt;
2297             int fifo_bytes, got_packet;
2298             av_init_packet(&pkt);
2299             pkt.data = NULL;
2300             pkt.size = 0;
2301
2302             switch (ost->st->codec->codec_type) {
2303             case AVMEDIA_TYPE_AUDIO:
2304                 fifo_bytes = av_fifo_size(ost->fifo);
2305                 if (fifo_bytes > 0) {
2306                     /* encode any samples remaining in fifo */
2307                     int frame_bytes = fifo_bytes;
2308
2309                     av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
2310
2311                     /* pad last frame with silence if needed */
2312                     if (!(enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME)) {
2313                         frame_bytes = enc->frame_size * enc->channels *
2314                                       av_get_bytes_per_sample(enc->sample_fmt);
2315                         if (allocated_audio_buf_size < frame_bytes)
2316                             exit_program(1);
2317                         generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
2318                     }
2319                     encode_audio_frame(os, ost, audio_buf, frame_bytes);
2320                 } else {
2321                     /* flush encoder with NULL frames until it is done
2322                        returning packets */
2323                     if (encode_audio_frame(os, ost, NULL, 0) == 0) {
2324                         stop_encoding = 1;
2325                         break;
2326                     }
2327                 }
2328                 break;
2329             case AVMEDIA_TYPE_VIDEO:
2330                 update_benchmark(NULL);
2331                 ret = avcodec_encode_video2(enc, &pkt, NULL, &got_packet);
2332                 update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
2333                 if (ret < 0) {
2334                     av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
2335                     exit_program(1);
2336                 }
2337                 video_size += pkt.size;
2338                 if (ost->logfile && enc->stats_out) {
2339                     fprintf(ost->logfile, "%s", enc->stats_out);
2340                 }
2341                 if (!got_packet) {
2342                     stop_encoding = 1;
2343                     break;
2344                 }
2345                 if (pkt.pts != AV_NOPTS_VALUE)
2346                     pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2347                 if (pkt.dts != AV_NOPTS_VALUE)
2348                     pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2349                 write_frame(os, &pkt, ost);
2350                 break;
2351             default:
2352                 stop_encoding = 1;
2353             }
2354             if (stop_encoding)
2355                 break;
2356         }
2357     }
2358 }
2359
2360 /*
2361  * Check whether a packet from ist should be written into ost at this time
2362  */
2363 static int check_output_constraints(InputStream *ist, OutputStream *ost)
2364 {
2365     OutputFile *of = output_files[ost->file_index];
2366     int ist_index  = input_files[ist->file_index]->ist_index + ist->st->index;
2367
2368     if (ost->source_index != ist_index)
2369         return 0;
2370
2371     if (of->start_time && ist->pts < of->start_time)
2372         return 0;
2373
2374     if (of->recording_time != INT64_MAX &&
2375         av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
2376                       (AVRational){ 1, 1000000 }) >= 0) {
2377         ost->is_past_recording_time = 1;
2378         return 0;
2379     }
2380
2381     return 1;
2382 }
2383
2384 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
2385 {
2386     OutputFile *of = output_files[ost->file_index];
2387     int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
2388     AVPicture pict;
2389     AVPacket opkt;
2390
2391     av_init_packet(&opkt);
2392
2393     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2394         !ost->copy_initial_nonkeyframes)
2395         return;
2396
2397     /* force the input stream PTS */
2398     if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2399         audio_size += pkt->size;
2400     else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2401         video_size += pkt->size;
2402         ost->sync_opts++;
2403     }
2404
2405     if (pkt->pts != AV_NOPTS_VALUE)
2406         opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
2407     else
2408         opkt.pts = AV_NOPTS_VALUE;
2409
2410     if (pkt->dts == AV_NOPTS_VALUE)
2411         opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
2412     else
2413         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
2414     opkt.dts -= ost_tb_start_time;
2415
2416     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
2417     opkt.flags    = pkt->flags;
2418
2419     // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
2420     if (  ost->st->codec->codec_id != CODEC_ID_H264
2421        && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
2422        && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
2423        && ost->st->codec->codec_id != CODEC_ID_VC1
2424        ) {
2425         if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
2426             opkt.destruct = av_destruct_packet;
2427     } else {
2428         opkt.data = pkt->data;
2429         opkt.size = pkt->size;
2430     }
2431     if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
2432         /* store AVPicture in AVPacket, as expected by the output format */
2433         avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
2434         opkt.data = (uint8_t *)&pict;
2435         opkt.size = sizeof(AVPicture);
2436         opkt.flags |= AV_PKT_FLAG_KEY;
2437     }
2438
2439     write_frame(of->ctx, &opkt, ost);
2440     ost->st->codec->frame_number++;
2441     av_free_packet(&opkt);
2442 }
2443
2444 static void rate_emu_sleep(InputStream *ist)
2445 {
2446     if (input_files[ist->file_index]->rate_emu) {
2447         int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
2448         int64_t now = av_gettime() - ist->start;
2449         if (pts > now)
2450             usleep(pts - now);
2451     }
2452 }
2453
2454 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
2455 {
2456     AVFrame *decoded_frame;
2457     AVCodecContext *avctx = ist->st->codec;
2458     int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
2459     int i, ret;
2460
2461     if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2462         return AVERROR(ENOMEM);
2463     else
2464         avcodec_get_frame_defaults(ist->decoded_frame);
2465     decoded_frame = ist->decoded_frame;
2466
2467     update_benchmark(NULL);
2468     ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
2469     update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2470     if (ret < 0) {
2471         return ret;
2472     }
2473     if (avctx->sample_rate <= 0) {
2474         av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2475         return AVERROR_INVALIDDATA;
2476     }
2477
2478     if (!*got_output) {
2479         /* no audio frame */
2480         return ret;
2481     }
2482
2483     /* if the decoder provides a pts, use it instead of the last packet pts.
2484        the decoder could be delaying output by a packet or more. */
2485     if (decoded_frame->pts != AV_NOPTS_VALUE)
2486         ist->dts = ist->next_dts = ist->pts = ist->next_pts = decoded_frame->pts;
2487
2488     /* increment next_dts to use for the case where the input stream does not
2489        have timestamps or there are multiple frames in the packet */
2490     ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2491                      avctx->sample_rate;
2492     ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2493                      avctx->sample_rate;
2494
2495
2496     // preprocess audio (volume)
2497     if (audio_volume != 256) {
2498         int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
2499         void *samples = decoded_frame->data[0];
2500         switch (avctx->sample_fmt) {
2501         case AV_SAMPLE_FMT_U8:
2502         {
2503             uint8_t *volp = samples;
2504             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2505                 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
2506                 *volp++ = av_clip_uint8(v);
2507             }
2508             break;
2509         }
2510         case AV_SAMPLE_FMT_S16:
2511         {
2512             int16_t *volp = samples;
2513             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2514                 int v = ((*volp) * audio_volume + 128) >> 8;
2515                 *volp++ = av_clip_int16(v);
2516             }
2517             break;
2518         }
2519         case AV_SAMPLE_FMT_S32:
2520         {
2521             int32_t *volp = samples;
2522             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2523                 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
2524                 *volp++ = av_clipl_int32(v);
2525             }
2526             break;
2527         }
2528         case AV_SAMPLE_FMT_FLT:
2529         {
2530             float *volp = samples;
2531             float scale = audio_volume / 256.f;
2532             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2533                 *volp++ *= scale;
2534             }
2535             break;
2536         }
2537         case AV_SAMPLE_FMT_DBL:
2538         {
2539             double *volp = samples;
2540             double scale = audio_volume / 256.;
2541             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2542                 *volp++ *= scale;
2543             }
2544             break;
2545         }
2546         default:
2547             av_log(NULL, AV_LOG_FATAL,
2548                    "Audio volume adjustment on sample format %s is not supported.\n",
2549                    av_get_sample_fmt_name(ist->st->codec->sample_fmt));
2550             exit_program(1);
2551         }
2552     }
2553
2554     rate_emu_sleep(ist);
2555
2556     for (i = 0; i < nb_output_streams; i++) {
2557         OutputStream *ost = output_streams[i];
2558
2559         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2560             continue;
2561         do_audio_out(output_files[ost->file_index]->ctx, ost, ist, decoded_frame);
2562     }
2563
2564     return ret;
2565 }
2566
2567 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
2568 {
2569     AVFrame *decoded_frame;
2570     void *buffer_to_free = NULL;
2571     int i, ret = 0, resample_changed;
2572     int64_t best_effort_timestamp;
2573     AVRational *frame_sample_aspect;
2574     float quality;
2575
2576     if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2577         return AVERROR(ENOMEM);
2578     else
2579         avcodec_get_frame_defaults(ist->decoded_frame);
2580     decoded_frame = ist->decoded_frame;
2581     pkt->pts  = *pkt_pts;
2582     pkt->dts  = ist->dts;
2583     *pkt_pts  = AV_NOPTS_VALUE;
2584
2585     update_benchmark(NULL);
2586     ret = avcodec_decode_video2(ist->st->codec,
2587                                 decoded_frame, got_output, pkt);
2588     update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2589     if (ret < 0)
2590         return ret;
2591
2592     quality = same_quant ? decoded_frame->quality : 0;
2593     if (!*got_output) {
2594         /* no picture yet */
2595         if (!pkt->size)
2596             for (i = 0; i < ist->nb_filters; i++)
2597                 av_buffersrc_buffer(ist->filters[i]->filter, NULL);
2598         return ret;
2599     }
2600
2601     best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
2602     if(best_effort_timestamp != AV_NOPTS_VALUE)
2603         ist->next_pts = ist->pts = decoded_frame->pts = best_effort_timestamp;
2604
2605     pkt->size = 0;
2606
2607     pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2608
2609     rate_emu_sleep(ist);
2610
2611     if (ist->st->sample_aspect_ratio.num)
2612         decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2613
2614     resample_changed = ist->resample_width   != decoded_frame->width  ||
2615                        ist->resample_height  != decoded_frame->height ||
2616                        ist->resample_pix_fmt != decoded_frame->format;
2617     if (resample_changed) {
2618         av_log(NULL, AV_LOG_INFO,
2619                "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2620                ist->file_index, ist->st->index,
2621                ist->resample_width,  ist->resample_height,  av_get_pix_fmt_name(ist->resample_pix_fmt),
2622                decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2623
2624         ist->resample_width   = decoded_frame->width;
2625         ist->resample_height  = decoded_frame->height;
2626         ist->resample_pix_fmt = decoded_frame->format;
2627
2628         for (i = 0; i < nb_filtergraphs; i++)
2629             if (ist_in_filtergraph(filtergraphs[i], ist) &&
2630                 configure_filtergraph(filtergraphs[i]) < 0) {
2631                 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2632                 exit_program(1);
2633             }
2634     }
2635
2636     frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2637     for (i = 0; i < ist->nb_filters; i++) {
2638         int changed =      ist->st->codec->width   != ist->filters[i]->filter->outputs[0]->w
2639                         || ist->st->codec->height  != ist->filters[i]->filter->outputs[0]->h
2640                         || ist->st->codec->pix_fmt != ist->filters[i]->filter->outputs[0]->format;
2641         // XXX what an ugly hack
2642         if (ist->filters[i]->graph->nb_outputs == 1)
2643             ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
2644
2645         if (!frame_sample_aspect->num)
2646             *frame_sample_aspect = ist->st->sample_aspect_ratio;
2647         if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER && !changed) {
2648             FrameBuffer      *buf = decoded_frame->opaque;
2649             AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2650                                         decoded_frame->data, decoded_frame->linesize,
2651                                         AV_PERM_READ | AV_PERM_PRESERVE,
2652                                         ist->st->codec->width, ist->st->codec->height,
2653                                         ist->st->codec->pix_fmt);
2654
2655             avfilter_copy_frame_props(fb, decoded_frame);
2656             fb->buf->priv           = buf;
2657             fb->buf->free           = filter_release_buffer;
2658
2659             av_assert0(buf->refcount>0);
2660             buf->refcount++;
2661             av_buffersrc_buffer(ist->filters[i]->filter, fb);
2662         } else
2663         if(av_vsrc_buffer_add_frame(ist->filters[i]->filter, decoded_frame,AV_VSRC_BUF_FLAG_OVERWRITE)<0) {
2664             av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2665             exit_program(1);
2666         }
2667
2668     }
2669
2670     av_free(buffer_to_free);
2671     return ret;
2672 }
2673
2674 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2675 {
2676     AVSubtitle subtitle;
2677     int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2678                                           &subtitle, got_output, pkt);
2679     if (ret < 0)
2680         return ret;
2681     if (!*got_output)
2682         return ret;
2683
2684     rate_emu_sleep(ist);
2685
2686     for (i = 0; i < nb_output_streams; i++) {
2687         OutputStream *ost = output_streams[i];
2688
2689         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2690             continue;
2691
2692         do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2693     }
2694
2695     avsubtitle_free(&subtitle);
2696     return ret;
2697 }
2698
2699 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2700 static int output_packet(InputStream *ist, const AVPacket *pkt)
2701 {
2702     int ret = 0, i;
2703     int got_output;
2704     int64_t pkt_pts = AV_NOPTS_VALUE;
2705
2706     AVPacket avpkt;
2707     if (!ist->saw_first_ts) {
2708         ist->dts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
2709         ist->pts = 0;
2710         if (pkt != NULL && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2711             ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2712             ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2713         }
2714         ist->saw_first_ts = 1;
2715     }
2716
2717     if (ist->next_dts == AV_NOPTS_VALUE)
2718         ist->next_dts = ist->dts;
2719     if (ist->next_pts == AV_NOPTS_VALUE)
2720         ist->next_pts = ist->pts;
2721
2722     if (pkt == NULL) {
2723         /* EOF handling */
2724         av_init_packet(&avpkt);
2725         avpkt.data = NULL;
2726         avpkt.size = 0;
2727         goto handle_eof;
2728     } else {
2729         avpkt = *pkt;
2730     }
2731
2732     if (pkt->dts != AV_NOPTS_VALUE) {
2733         ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2734         if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2735             ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2736     }
2737     if(pkt->pts != AV_NOPTS_VALUE)
2738         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2739
2740     // while we have more to decode or while the decoder did output something on EOF
2741     while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2742         int duration;
2743     handle_eof:
2744
2745         ist->pts = ist->next_pts;
2746         ist->dts = ist->next_dts;
2747
2748         if (avpkt.size && avpkt.size != pkt->size) {
2749             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2750                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2751             ist->showed_multi_packet_warning = 1;
2752         }
2753
2754         switch (ist->st->codec->codec_type) {
2755         case AVMEDIA_TYPE_AUDIO:
2756             ret = transcode_audio    (ist, &avpkt, &got_output);
2757             break;
2758         case AVMEDIA_TYPE_VIDEO:
2759             ret = transcode_video    (ist, &avpkt, &got_output, &pkt_pts);
2760             if (avpkt.duration) {
2761                 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2762             } else if(ist->st->codec->time_base.num != 0 && ist->st->codec->time_base.den != 0) {
2763                 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2764                 duration = ((int64_t)AV_TIME_BASE *
2765                                 ist->st->codec->time_base.num * ticks) /
2766                                 ist->st->codec->time_base.den;
2767             } else
2768                 duration = 0;
2769
2770             if(ist->dts != AV_NOPTS_VALUE && duration) {
2771                 ist->next_dts += duration;
2772             }else
2773                 ist->next_dts = AV_NOPTS_VALUE;
2774
2775             if (got_output)
2776                 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2777             break;
2778         case AVMEDIA_TYPE_SUBTITLE:
2779             ret = transcode_subtitles(ist, &avpkt, &got_output);
2780             break;
2781         default:
2782             return -1;
2783         }
2784
2785         if (ret < 0)
2786             return ret;
2787
2788         avpkt.dts=
2789         avpkt.pts= AV_NOPTS_VALUE;
2790
2791         // touch data and size only if not EOF
2792         if (pkt) {
2793             if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2794                 ret = avpkt.size;
2795             avpkt.data += ret;
2796             avpkt.size -= ret;
2797         }
2798         if (!got_output) {
2799             continue;
2800         }
2801     }
2802
2803     /* handle stream copy */
2804     if (!ist->decoding_needed) {
2805         rate_emu_sleep(ist);
2806         ist->dts = ist->next_dts;
2807         switch (ist->st->codec->codec_type) {
2808         case AVMEDIA_TYPE_AUDIO:
2809             ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2810                              ist->st->codec->sample_rate;
2811             break;
2812         case AVMEDIA_TYPE_VIDEO:
2813             if (pkt->duration) {
2814                 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2815             } else if(ist->st->codec->time_base.num != 0) {
2816                 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2817                 ist->next_dts += ((int64_t)AV_TIME_BASE *
2818                                   ist->st->codec->time_base.num * ticks) /
2819                                   ist->st->codec->time_base.den;
2820             }
2821             break;
2822         }
2823         ist->pts = ist->dts;
2824         ist->next_pts = ist->next_dts;
2825     }
2826     for (i = 0; pkt && i < nb_output_streams; i++) {
2827         OutputStream *ost = output_streams[i];
2828
2829         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2830             continue;
2831
2832         do_streamcopy(ist, ost, pkt);
2833     }
2834
2835     return 0;
2836 }
2837
2838 static void print_sdp(void)
2839 {
2840     char sdp[2048];
2841     int i;
2842     AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2843
2844     if (!avc)
2845         exit_program(1);
2846     for (i = 0; i < nb_output_files; i++)
2847         avc[i] = output_files[i]->ctx;
2848
2849     av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2850     printf("SDP:\n%s\n", sdp);
2851     fflush(stdout);
2852     av_freep(&avc);
2853 }
2854
2855 static int init_input_stream(int ist_index, char *error, int error_len)
2856 {
2857     int i;
2858     InputStream *ist = input_streams[ist_index];
2859
2860     if (ist->decoding_needed) {
2861         AVCodec *codec = ist->dec;
2862         if (!codec) {
2863             snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2864                     avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2865             return AVERROR(EINVAL);
2866         }
2867
2868         ist->dr1 = codec->capabilities & CODEC_CAP_DR1;
2869         if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2870             ist->st->codec->get_buffer     = codec_get_buffer;
2871             ist->st->codec->release_buffer = codec_release_buffer;
2872             ist->st->codec->opaque         = ist;
2873         }
2874
2875         if (!av_dict_get(ist->opts, "threads", NULL, 0))
2876             av_dict_set(&ist->opts, "threads", "auto", 0);
2877         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2878             snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2879                     ist->file_index, ist->st->index);
2880             return AVERROR(EINVAL);
2881         }
2882         assert_codec_experimental(ist->st->codec, 0);
2883         assert_avoptions(ist->opts);
2884
2885         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2886             for (i = 0; i < nb_output_streams; i++) {
2887                 OutputStream *ost = output_streams[i];
2888                 if (ost->source_index == ist_index) {
2889                     if (!ist->st->codec->channel_layout || !ost->st->codec->channel_layout)
2890                         get_default_channel_layouts(ost, ist);
2891                     break;
2892                 }
2893             }
2894         }
2895     }
2896
2897     ist->next_pts = AV_NOPTS_VALUE;
2898     ist->next_dts = AV_NOPTS_VALUE;
2899     ist->is_start = 1;
2900
2901     return 0;
2902 }
2903
2904 static InputStream *get_input_stream(OutputStream *ost)
2905 {
2906     if (ost->source_index >= 0)
2907         return input_streams[ost->source_index];
2908
2909     if (ost->filter) {
2910         FilterGraph *fg = ost->filter->graph;
2911         int i;
2912
2913         for (i = 0; i < fg->nb_inputs; i++)
2914             if (fg->inputs[i]->ist->st->codec->codec_type == ost->st->codec->codec_type)
2915                 return fg->inputs[i]->ist;
2916     }
2917
2918     return NULL;
2919 }
2920
2921 static int transcode_init(void)
2922 {
2923     int ret = 0, i, j, k;
2924     AVFormatContext *oc;
2925     AVCodecContext *codec, *icodec;
2926     OutputStream *ost;
2927     InputStream *ist;
2928     char error[1024];
2929     int want_sdp = 1;
2930
2931     /* init framerate emulation */
2932     for (i = 0; i < nb_input_files; i++) {
2933         InputFile *ifile = input_files[i];
2934         if (ifile->rate_emu)
2935             for (j = 0; j < ifile->nb_streams; j++)
2936                 input_streams[j + ifile->ist_index]->start = av_gettime();
2937     }
2938
2939     /* output stream init */
2940     for (i = 0; i < nb_output_files; i++) {
2941         oc = output_files[i]->ctx;
2942         if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2943             av_dump_format(oc, i, oc->filename, 1);
2944             av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2945             return AVERROR(EINVAL);
2946         }
2947     }
2948
2949     /* init complex filtergraphs */
2950     for (i = 0; i < nb_filtergraphs; i++)
2951         if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
2952             return ret;
2953
2954     /* for each output stream, we compute the right encoding parameters */
2955     for (i = 0; i < nb_output_streams; i++) {
2956         ost = output_streams[i];
2957         oc  = output_files[ost->file_index]->ctx;
2958         ist = get_input_stream(ost);
2959
2960         if (ost->attachment_filename)
2961             continue;
2962
2963         codec  = ost->st->codec;
2964
2965         if (ist) {
2966             icodec = ist->st->codec;
2967
2968             ost->st->disposition          = ist->st->disposition;
2969             codec->bits_per_raw_sample    = icodec->bits_per_raw_sample;
2970             codec->chroma_sample_location = icodec->chroma_sample_location;
2971         }
2972
2973         if (ost->stream_copy) {
2974             uint64_t extra_size;
2975
2976             av_assert0(ist && !ost->filter);
2977
2978             extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2979
2980             if (extra_size > INT_MAX) {
2981                 return AVERROR(EINVAL);
2982             }
2983
2984             /* if stream_copy is selected, no need to decode or encode */
2985             codec->codec_id   = icodec->codec_id;
2986             codec->codec_type = icodec->codec_type;
2987
2988             if (!codec->codec_tag) {
2989                 if (!oc->oformat->codec_tag ||
2990                      av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2991                      av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2992                     codec->codec_tag = icodec->codec_tag;
2993             }
2994
2995             codec->bit_rate       = icodec->bit_rate;
2996             codec->rc_max_rate    = icodec->rc_max_rate;
2997             codec->rc_buffer_size = icodec->rc_buffer_size;
2998             codec->field_order    = icodec->field_order;
2999             codec->extradata      = av_mallocz(extra_size);
3000             if (!codec->extradata) {
3001                 return AVERROR(ENOMEM);
3002             }
3003             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
3004             codec->extradata_size= icodec->extradata_size;
3005
3006             codec->time_base = ist->st->time_base;
3007             /*
3008              * Avi is a special case here because it supports variable fps but
3009              * having the fps and timebase differe significantly adds quite some
3010              * overhead
3011              */
3012             if(!strcmp(oc->oformat->name, "avi")) {
3013                 if (   copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
3014                                  && av_q2d(ist->st->time_base) < 1.0/500
3015                     || copy_tb==0){
3016                     codec->time_base = icodec->time_base;
3017                     codec->time_base.num *= icodec->ticks_per_frame;
3018                     codec->time_base.den *= 2;
3019                     codec->ticks_per_frame = 2;
3020                 }
3021             } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
3022                       && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
3023                       && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
3024             ) {
3025                 if(   copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
3026                                 && av_q2d(ist->st->time_base) < 1.0/500
3027                    || copy_tb==0){
3028                     codec->time_base = icodec->time_base;
3029                     codec->time_base.num *= icodec->ticks_per_frame;
3030                 }
3031             }
3032             av_reduce(&codec->time_base.num, &codec->time_base.den,
3033                         codec->time_base.num, codec->time_base.den, INT_MAX);
3034
3035             switch (codec->codec_type) {
3036             case AVMEDIA_TYPE_AUDIO:
3037                 if (audio_volume != 256) {
3038                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
3039                     exit_program(1);
3040                 }
3041                 codec->channel_layout     = icodec->channel_layout;
3042                 codec->sample_rate        = icodec->sample_rate;
3043                 codec->channels           = icodec->channels;
3044                 codec->frame_size         = icodec->frame_size;
3045                 codec->audio_service_type = icodec->audio_service_type;
3046                 codec->block_align        = icodec->block_align;
3047                 break;
3048             case AVMEDIA_TYPE_VIDEO:
3049                 codec->pix_fmt            = icodec->pix_fmt;
3050                 codec->width              = icodec->width;
3051                 codec->height             = icodec->height;
3052                 codec->has_b_frames       = icodec->has_b_frames;
3053                 if (!codec->sample_aspect_ratio.num) {
3054                     codec->sample_aspect_ratio   =
3055                     ost->st->sample_aspect_ratio =
3056                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
3057                         ist->st->codec->sample_aspect_ratio.num ?
3058                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
3059                 }
3060                 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
3061                 break;
3062             case AVMEDIA_TYPE_SUBTITLE:
3063                 codec->width  = icodec->width;
3064                 codec->height = icodec->height;
3065                 break;
3066             case AVMEDIA_TYPE_DATA:
3067             case AVMEDIA_TYPE_ATTACHMENT:
3068                 break;
3069             default:
3070                 abort();
3071             }
3072         } else {
3073             if (!ost->enc)
3074                 ost->enc = avcodec_find_encoder(codec->codec_id);
3075             if (!ost->enc) {
3076                 /* should only happen when a default codec is not present. */
3077                 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
3078                          avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
3079                 ret = AVERROR(EINVAL);
3080                 goto dump_format;
3081             }
3082
3083             if (ist)
3084                 ist->decoding_needed = 1;
3085             ost->encoding_needed = 1;
3086
3087             switch (codec->codec_type) {
3088             case AVMEDIA_TYPE_AUDIO:
3089                 ost->fifo = av_fifo_alloc(1024);
3090                 if (!ost->fifo) {
3091                     return AVERROR(ENOMEM);
3092                 }
3093
3094                 if (!codec->sample_rate)
3095                     codec->sample_rate = icodec->sample_rate;
3096                 choose_sample_rate(ost->st, ost->enc);
3097                 codec->time_base = (AVRational){ 1, codec->sample_rate };
3098
3099                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
3100                     codec->sample_fmt = icodec->sample_fmt;
3101                 choose_sample_fmt(ost->st, ost->enc);
3102
3103                 if (ost->audio_channels_mapped) {
3104                     /* the requested output channel is set to the number of
3105                      * -map_channel only if no -ac are specified */
3106                     if (!codec->channels) {
3107                         codec->channels       = ost->audio_channels_mapped;
3108                         codec->channel_layout = av_get_default_channel_layout(codec->channels);
3109                         if (!codec->channel_layout) {
3110                             av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
3111                             exit_program(1);
3112                         }
3113                     }
3114                     /* fill unused channel mapping with -1 (which means a muted
3115                      * channel in case the number of output channels is bigger
3116                      * than the number of mapped channel) */
3117                     for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
3118                         ost->audio_channels_map[j] = -1;
3119                 } else if (!codec->channels) {
3120                     codec->channels = icodec->channels;
3121                     codec->channel_layout = icodec->channel_layout;
3122                 }
3123                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
3124                     codec->channel_layout = 0;
3125
3126
3127 //                 ost->audio_resample       = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
3128 //                 ost->audio_resample      |=    codec->sample_fmt     != icodec->sample_fmt
3129 //                                             || codec->channel_layout != icodec->channel_layout;
3130                 icodec->request_channels  = codec-> channels;
3131                 ost->resample_sample_fmt  = icodec->sample_fmt;
3132                 ost->resample_sample_rate = icodec->sample_rate;
3133                 ost->resample_channels    = icodec->channels;
3134                 ost->resample_channel_layout = icodec->channel_layout;
3135                 break;
3136             case AVMEDIA_TYPE_VIDEO:
3137                 if (!ost->filter) {
3138                     FilterGraph *fg;
3139                     fg = init_simple_filtergraph(ist, ost);
3140                     if (configure_video_filters(fg)) {
3141                         av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3142                         exit(1);
3143                     }
3144                 }
3145
3146                 if (ist && !ost->frame_rate.num)
3147                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
3148                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3149                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3150                     ost->frame_rate = ost->enc->supported_framerates[idx];
3151                 }
3152                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
3153                 if (   av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3154                    && (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3155                     av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3156                                                "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3157                 }
3158                 for (j = 0; j < ost->forced_kf_count; j++)
3159                     ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3160                                                          AV_TIME_BASE_Q,
3161                                                          codec->time_base);
3162
3163                 codec->width  = ost->filter->filter->inputs[0]->w;
3164                 codec->height = ost->filter->filter->inputs[0]->h;
3165                 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3166                     ost->frame_aspect_ratio ? // overridden by the -aspect cli option
3167                     av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
3168                     ost->filter->filter->inputs[0]->sample_aspect_ratio;
3169                 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
3170
3171                 if (codec->width   != icodec->width  ||
3172                     codec->height  != icodec->height ||
3173                     codec->pix_fmt != icodec->pix_fmt) {
3174                     codec->bits_per_raw_sample = frame_bits_per_raw_sample;
3175                 }
3176
3177                 break;
3178             case AVMEDIA_TYPE_SUBTITLE:
3179                 codec->time_base = (AVRational){1, 1000};
3180                 break;
3181             default:
3182                 abort();
3183                 break;
3184             }
3185             /* two pass mode */
3186             if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
3187                 char logfilename[1024];
3188                 FILE *f;
3189
3190                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
3191                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
3192                          i);
3193                 if (!strcmp(ost->enc->name, "libx264")) {
3194                     av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
3195                 } else {
3196                     if (codec->flags & CODEC_FLAG_PASS2) {
3197                         char  *logbuffer;
3198                         size_t logbuffer_size;
3199                         if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
3200                             av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
3201                                 logfilename);
3202                             exit_program(1);
3203                         }
3204                         codec->stats_in = logbuffer;
3205                     }
3206                     if (codec->flags & CODEC_FLAG_PASS1) {
3207                         f = fopen(logfilename, "wb");
3208                         if (!f) {
3209                             av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
3210                                 logfilename, strerror(errno));
3211                             exit_program(1);
3212                         }
3213                         ost->logfile = f;
3214                     }
3215                 }
3216             }
3217         }
3218     }
3219
3220     /* open each encoder */
3221     for (i = 0; i < nb_output_streams; i++) {
3222         ost = output_streams[i];
3223         if (ost->encoding_needed) {
3224             AVCodec      *codec = ost->enc;
3225             AVCodecContext *dec = NULL;
3226
3227             if ((ist = get_input_stream(ost)))
3228                 dec = ist->st->codec;
3229             if (dec && dec->subtitle_header) {
3230                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
3231                 if (!ost->st->codec->subtitle_header) {
3232                     ret = AVERROR(ENOMEM);
3233                     goto dump_format;
3234                 }
3235                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3236                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
3237             }
3238             if (!av_dict_get(ost->opts, "threads", NULL, 0))
3239                 av_dict_set(&ost->opts, "threads", "auto", 0);
3240             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
3241                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
3242                         ost->file_index, ost->index);
3243                 ret = AVERROR(EINVAL);
3244                 goto dump_format;
3245             }
3246             assert_codec_experimental(ost->st->codec, 1);
3247             assert_avoptions(ost->opts);
3248             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
3249                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3250                                              " It takes bits/s as argument, not kbits/s\n");
3251             extra_size += ost->st->codec->extradata_size;
3252
3253             if (ost->st->codec->me_threshold)
3254                 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
3255         }
3256     }
3257
3258     /* init input streams */
3259     for (i = 0; i < nb_input_streams; i++)
3260         if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
3261             goto dump_format;
3262
3263     /* discard unused programs */
3264     for (i = 0; i < nb_input_files; i++) {
3265         InputFile *ifile = input_files[i];
3266         for (j = 0; j < ifile->ctx->nb_programs; j++) {
3267             AVProgram *p = ifile->ctx->programs[j];
3268             int discard  = AVDISCARD_ALL;
3269
3270             for (k = 0; k < p->nb_stream_indexes; k++)
3271                 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3272                     discard = AVDISCARD_DEFAULT;
3273                     break;
3274                 }
3275             p->discard = discard;
3276         }
3277     }
3278
3279     /* open files and write file headers */
3280     for (i = 0; i < nb_output_files; i++) {
3281         oc = output_files[i]->ctx;
3282         oc->interrupt_callback = int_cb;
3283         if (avformat_write_header(oc, &output_files[i]->opts) < 0) {
3284             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
3285             ret = AVERROR(EINVAL);
3286             goto dump_format;
3287         }
3288 //         assert_avoptions(output_files[i]->opts);
3289         if (strcmp(oc->oformat->name, "rtp")) {
3290             want_sdp = 0;
3291         }
3292     }
3293
3294  dump_format:
3295     /* dump the file output parameters - cannot be done before in case
3296        of stream copy */
3297     for (i = 0; i < nb_output_files; i++) {
3298         av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3299     }
3300
3301     /* dump the stream mapping */
3302     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3303     for (i = 0; i < nb_input_streams; i++) {
3304         ist = input_streams[i];
3305
3306         for (j = 0; j < ist->nb_filters; j++) {
3307             AVFilterLink *link = ist->filters[j]->filter->outputs[0];
3308             if (ist->filters[j]->graph->graph_desc) {
3309                 av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d (%s) -> %s",
3310                        ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3311                        link->dst->filter->name);
3312                 if (link->dst->input_count > 1)
3313                     av_log(NULL, AV_LOG_INFO, ":%s", link->dstpad->name);
3314                 if (nb_filtergraphs > 1)
3315                     av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3316                 av_log(NULL, AV_LOG_INFO, "\n");
3317             }
3318         }
3319     }
3320
3321     for (i = 0; i < nb_output_streams; i++) {
3322         ost = output_streams[i];
3323
3324         if (ost->attachment_filename) {
3325             /* an attached file */
3326             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
3327                    ost->attachment_filename, ost->file_index, ost->index);
3328             continue;
3329         }
3330
3331         if (ost->filter && ost->filter->graph->graph_desc) {
3332             /* output from a complex graph */
3333             AVFilterLink *link = ost->filter->filter->inputs[0];
3334             av_log(NULL, AV_LOG_INFO, "  %s", link->src->filter->name);
3335             if (link->src->output_count > 1)
3336                 av_log(NULL, AV_LOG_INFO, ":%s", link->srcpad->name);
3337             if (nb_filtergraphs > 1)
3338                 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3339
3340             av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3341                    ost->index, ost->enc ? ost->enc->name : "?");
3342             continue;
3343         }
3344
3345         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
3346                input_streams[ost->source_index]->file_index,
3347                input_streams[ost->source_index]->st->index,
3348                ost->file_index,
3349                ost->index);
3350         if (ost->audio_channels_mapped) {
3351             av_log(NULL, AV_LOG_INFO, " [ch:");
3352             for (j = 0; j < ost->audio_channels_mapped; j++)
3353                 if (ost->audio_channels_map[j] == -1)
3354                     av_log(NULL, AV_LOG_INFO, " M");
3355                 else
3356                     av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
3357             av_log(NULL, AV_LOG_INFO, "]");
3358         }
3359         if (ost->sync_ist != input_streams[ost->source_index])
3360             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3361                    ost->sync_ist->file_index,
3362                    ost->sync_ist->st->index);
3363         if (ost->stream_copy)
3364             av_log(NULL, AV_LOG_INFO, " (copy)");
3365         else
3366             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
3367                    input_streams[ost->source_index]->dec->name : "?",
3368                    ost->enc ? ost->enc->name : "?");
3369         av_log(NULL, AV_LOG_INFO, "\n");
3370     }
3371
3372     if (ret) {
3373         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3374         return ret;
3375     }
3376
3377     if (want_sdp) {
3378         print_sdp();
3379     }
3380
3381     return 0;
3382 }
3383
3384 /*
3385  * The following code is the main loop of the file converter
3386  */
3387 static int transcode(void)
3388 {
3389     int ret, i;
3390     AVFormatContext *is, *os;
3391     OutputStream *ost;
3392     InputStream *ist;
3393     uint8_t *no_packet;
3394     int no_packet_count = 0;
3395     int64_t timer_start;
3396     int key;
3397
3398     if (!(no_packet = av_mallocz(nb_input_files)))
3399         exit_program(1);
3400
3401     ret = transcode_init();
3402     if (ret < 0)
3403         goto fail;
3404
3405     if (!using_stdin) {
3406         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
3407     }
3408
3409     timer_start = av_gettime();
3410
3411     for (; received_sigterm == 0;) {
3412         int file_index, ist_index, past_recording_time = 1;
3413         AVPacket pkt;
3414         int64_t ipts_min;
3415         int64_t cur_time= av_gettime();
3416
3417         ipts_min = INT64_MAX;
3418         /* if 'q' pressed, exits */
3419         if (!using_stdin) {
3420             static int64_t last_time;
3421             if (received_nb_signals)
3422                 break;
3423             /* read_key() returns 0 on EOF */
3424             if(cur_time - last_time >= 100000 && !run_as_daemon){
3425                 key =  read_key();
3426                 last_time = cur_time;
3427             }else
3428                 key = -1;
3429             if (key == 'q')
3430                 break;
3431             if (key == '+') av_log_set_level(av_log_get_level()+10);
3432             if (key == '-') av_log_set_level(av_log_get_level()-10);
3433             if (key == 's') qp_hist     ^= 1;
3434             if (key == 'h'){
3435                 if (do_hex_dump){
3436                     do_hex_dump = do_pkt_dump = 0;
3437                 } else if(do_pkt_dump){
3438                     do_hex_dump = 1;
3439                 } else
3440                     do_pkt_dump = 1;
3441                 av_log_set_level(AV_LOG_DEBUG);
3442             }
3443             if (key == 'c' || key == 'C'){
3444                 char buf[4096], target[64], command[256], arg[256] = {0};
3445                 double time;
3446                 int k, n = 0;
3447                 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
3448                 i = 0;
3449                 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3450                     if (k > 0)
3451                         buf[i++] = k;
3452                 buf[i] = 0;
3453                 if (k > 0 &&
3454                     (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3455                     av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3456                            target, time, command, arg);
3457                     for (i = 0; i < nb_filtergraphs; i++) {
3458                         FilterGraph *fg = filtergraphs[i];
3459                         if (fg->graph) {
3460                             if (time < 0) {
3461                                 ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3462                                                                   key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3463                                 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
3464                             } else {
3465                                 ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3466                             }
3467                         }
3468                     }
3469                 } else {
3470                     av_log(NULL, AV_LOG_ERROR,
3471                            "Parse error, at least 3 arguments were expected, "
3472                            "only %d given in string '%s'\n", n, buf);
3473                 }
3474             }
3475             if (key == 'd' || key == 'D'){
3476                 int debug=0;
3477                 if(key == 'D') {
3478                     debug = input_streams[0]->st->codec->debug<<1;
3479                     if(!debug) debug = 1;
3480                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3481                         debug += debug;
3482                 }else
3483                     if(scanf("%d", &debug)!=1)
3484                         fprintf(stderr,"error parsing debug value\n");
3485                 for(i=0;i<nb_input_streams;i++) {
3486                     input_streams[i]->st->codec->debug = debug;
3487                 }
3488                 for(i=0;i<nb_output_streams;i++) {
3489                     ost = output_streams[i];
3490                     ost->st->codec->debug = debug;
3491                 }
3492                 if(debug) av_log_set_level(AV_LOG_DEBUG);
3493                 fprintf(stderr,"debug=%d\n", debug);
3494             }
3495             if (key == '?'){
3496                 fprintf(stderr, "key    function\n"
3497                                 "?      show this help\n"
3498                                 "+      increase verbosity\n"
3499                                 "-      decrease verbosity\n"
3500                                 "c      Send command to filtergraph\n"
3501                                 "D      cycle through available debug modes\n"
3502                                 "h      dump packets/hex press to cycle through the 3 states\n"
3503                                 "q      quit\n"
3504                                 "s      Show QP histogram\n"
3505                 );
3506             }
3507         }
3508
3509         /* check if there's any stream where output is still needed */
3510         for (i = 0; i < nb_output_streams; i++) {
3511             OutputFile *of;
3512             ost = output_streams[i];
3513             of  = output_files[ost->file_index];
3514             os  = output_files[ost->file_index]->ctx;
3515             if (ost->is_past_recording_time ||
3516                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3517                 continue;
3518             if (ost->frame_number >= ost->max_frames) {
3519                 int j;
3520                 for (j = 0; j < of->ctx->nb_streams; j++)
3521                     output_streams[of->ost_index + j]->is_past_recording_time = 1;
3522                 continue;
3523             }
3524             past_recording_time = 0;
3525         }
3526         if (past_recording_time)
3527             break;
3528
3529         /* select the stream that we must read now by looking at the
3530            smallest output pts */
3531         file_index = -1;
3532         for (i = 0; i < nb_input_streams; i++) {
3533             int64_t ipts;
3534             ist = input_streams[i];
3535             ipts = ist->pts;
3536             if (ist->discard || no_packet[ist->file_index])
3537                 continue;
3538             if (!input_files[ist->file_index]->eof_reached) {
3539                 if (ipts < ipts_min) {
3540                     ipts_min = ipts;
3541                     file_index = ist->file_index;
3542                 }
3543             }
3544         }
3545         /* if none, if is finished */
3546         if (file_index < 0) {
3547             if (no_packet_count) {
3548                 no_packet_count = 0;
3549                 memset(no_packet, 0, nb_input_files);
3550                 usleep(10000);
3551                 continue;
3552             }
3553             break;
3554         }
3555
3556         /* read a frame from it and output it in the fifo */
3557         is  = input_files[file_index]->ctx;
3558         ret = av_read_frame(is, &pkt);
3559         if (ret == AVERROR(EAGAIN)) {
3560             no_packet[file_index] = 1;
3561             no_packet_count++;
3562             continue;
3563         }
3564         if (ret < 0) {
3565             input_files[file_index]->eof_reached = 1;
3566
3567             for (i = 0; i < input_files[file_index]->nb_streams; i++) {
3568                 ist = input_streams[input_files[file_index]->ist_index + i];
3569                 if (ist->decoding_needed)
3570                     output_packet(ist, NULL);
3571             }
3572
3573             if (opt_shortest)
3574                 break;
3575             else
3576                 continue;
3577         }
3578
3579         no_packet_count = 0;
3580         memset(no_packet, 0, nb_input_files);
3581
3582         if (do_pkt_dump) {
3583             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3584                              is->streams[pkt.stream_index]);
3585         }
3586         /* the following test is needed in case new streams appear
3587            dynamically in stream : we ignore them */
3588         if (pkt.stream_index >= input_files[file_index]->nb_streams)
3589             goto discard_packet;
3590         ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3591         ist = input_streams[ist_index];
3592         if (ist->discard)
3593             goto discard_packet;
3594
3595         if (pkt.dts != AV_NOPTS_VALUE)
3596             pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3597         if (pkt.pts != AV_NOPTS_VALUE)
3598             pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3599
3600         if (pkt.pts != AV_NOPTS_VALUE)
3601             pkt.pts *= ist->ts_scale;
3602         if (pkt.dts != AV_NOPTS_VALUE)
3603             pkt.dts *= ist->ts_scale;
3604
3605         if (debug_ts) {
3606             av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3607                     "next_pts:%s next_pts_time:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%"PRId64"\n",
3608                     ist_index, av_get_media_type_string(ist->st->codec->codec_type),
3609                     av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &ist->st->time_base),
3610                     av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3611                     av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3612                     input_files[ist->file_index]->ts_offset);
3613         }
3614
3615         if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
3616             int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3617             int64_t delta   = pkt_dts - ist->next_dts;
3618             if (is->iformat->flags & AVFMT_TS_DISCONT) {
3619             if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3620                 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3621                  ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3622                 pkt_dts+1<ist->pts){
3623                 input_files[ist->file_index]->ts_offset -= delta;
3624                 av_log(NULL, AV_LOG_DEBUG,
3625                        "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3626                        delta, input_files[ist->file_index]->ts_offset);
3627                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3628                 if (pkt.pts != AV_NOPTS_VALUE)
3629                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3630             }
3631             } else {
3632                 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3633                     (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3634                      pkt_dts+1<ist->pts){
3635                     av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3636                     pkt.dts = AV_NOPTS_VALUE;
3637                 }
3638                 if (pkt.pts != AV_NOPTS_VALUE){
3639                     int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3640                     delta   = pkt_pts - ist->next_dts;
3641                     if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3642                         (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3643                         pkt_pts+1<ist->pts) {
3644                         av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3645                         pkt.pts = AV_NOPTS_VALUE;
3646                     }
3647                 }
3648             }
3649         }
3650
3651         // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3652         if (output_packet(ist, &pkt) < 0 ||
3653             ((ret = poll_filters()) < 0 && ret != AVERROR_EOF)) {
3654             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3655                    ist->file_index, ist->st->index);
3656             if (exit_on_error)
3657                 exit_program(1);
3658             av_free_packet(&pkt);
3659             continue;
3660         }
3661
3662     discard_packet:
3663         av_free_packet(&pkt);
3664
3665         /* dump report by using the output first video and audio streams */
3666         print_report(0, timer_start, cur_time);
3667     }
3668
3669     /* at the end of stream, we must flush the decoder buffers */
3670     for (i = 0; i < nb_input_streams; i++) {
3671         ist = input_streams[i];
3672         if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3673             output_packet(ist, NULL);
3674         }
3675     }
3676     poll_filters();
3677     flush_encoders();
3678
3679     term_exit();
3680
3681     /* write the trailer if needed and close file */
3682     for (i = 0; i < nb_output_files; i++) {
3683         os = output_files[i]->ctx;
3684         av_write_trailer(os);
3685     }
3686
3687     /* dump report by using the first video and audio streams */
3688     print_report(1, timer_start, av_gettime());
3689
3690     /* close each encoder */
3691     for (i = 0; i < nb_output_streams; i++) {
3692         ost = output_streams[i];
3693         if (ost->encoding_needed) {
3694             av_freep(&ost->st->codec->stats_in);
3695             avcodec_close(ost->st->codec);
3696         }
3697     }
3698
3699     /* close each decoder */
3700     for (i = 0; i < nb_input_streams; i++) {
3701         ist = input_streams[i];
3702         if (ist->decoding_needed) {
3703             avcodec_close(ist->st->codec);
3704         }
3705     }
3706
3707     /* finished ! */
3708     ret = 0;
3709
3710  fail:
3711     av_freep(&no_packet);
3712
3713     if (output_streams) {
3714         for (i = 0; i < nb_output_streams; i++) {
3715             ost = output_streams[i];
3716             if (ost) {
3717                 if (ost->stream_copy)
3718                     av_freep(&ost->st->codec->extradata);
3719                 if (ost->logfile) {
3720                     fclose(ost->logfile);
3721                     ost->logfile = NULL;
3722                 }
3723                 av_fifo_free(ost->fifo); /* works even if fifo is not
3724                                              initialized but set to zero */
3725                 av_freep(&ost->st->codec->subtitle_header);
3726                 av_free(ost->forced_kf_pts);
3727                 swr_free(&ost->swr);
3728                 av_dict_free(&ost->opts);
3729             }
3730         }
3731     }
3732     return ret;
3733 }
3734
3735 static int opt_frame_crop(const char *opt, const char *arg)
3736 {
3737     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3738     return AVERROR(EINVAL);
3739 }
3740
3741 static int opt_pad(const char *opt, const char *arg)
3742 {
3743     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3744     return -1;
3745 }
3746
3747 static int opt_video_channel(const char *opt, const char *arg)
3748 {
3749     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3750     return opt_default("channel", arg);
3751 }
3752
3753 static int opt_video_standard(const char *opt, const char *arg)
3754 {
3755     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3756     return opt_default("standard", arg);
3757 }
3758
3759 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3760 {
3761     audio_codec_name = arg;
3762     return parse_option(o, "codec:a", arg, options);
3763 }
3764
3765 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3766 {
3767     video_codec_name = arg;
3768     return parse_option(o, "codec:v", arg, options);
3769 }
3770
3771 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3772 {
3773     subtitle_codec_name = arg;
3774     return parse_option(o, "codec:s", arg, options);
3775 }
3776
3777 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3778 {
3779     return parse_option(o, "codec:d", arg, options);
3780 }
3781
3782 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3783 {
3784     StreamMap *m = NULL;
3785     int i, negative = 0, file_idx;
3786     int sync_file_idx = -1, sync_stream_idx = 0;
3787     char *p, *sync;
3788     char *map;
3789
3790     if (*arg == '-') {
3791         negative = 1;
3792         arg++;
3793     }
3794     map = av_strdup(arg);
3795
3796     /* parse sync stream first, just pick first matching stream */
3797     if (sync = strchr(map, ',')) {
3798         *sync = 0;
3799         sync_file_idx = strtol(sync + 1, &sync, 0);
3800         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3801             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3802             exit_program(1);
3803         }
3804         if (*sync)
3805             sync++;
3806         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3807             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3808                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3809                 sync_stream_idx = i;
3810                 break;
3811             }
3812         if (i == input_files[sync_file_idx]->nb_streams) {
3813             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3814                                        "match any streams.\n", arg);
3815             exit_program(1);
3816         }
3817     }
3818
3819
3820     if (map[0] == '[') {
3821         /* this mapping refers to lavfi output */
3822         const char *c = map + 1;
3823         o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3824                                     &o->nb_stream_maps, o->nb_stream_maps + 1);
3825         m = &o->stream_maps[o->nb_stream_maps - 1];
3826         m->linklabel = av_get_token(&c, "]");
3827         if (!m->linklabel) {
3828             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3829             exit_program(1);
3830         }
3831     } else {
3832         file_idx = strtol(map, &p, 0);
3833         if (file_idx >= nb_input_files || file_idx < 0) {
3834             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3835             exit_program(1);
3836         }
3837         if (negative)
3838             /* disable some already defined maps */
3839             for (i = 0; i < o->nb_stream_maps; i++) {
3840                 m = &o->stream_maps[i];
3841                 if (file_idx == m->file_index &&
3842                     check_stream_specifier(input_files[m->file_index]->ctx,
3843                                            input_files[m->file_index]->ctx->streams[m->stream_index],
3844                                            *p == ':' ? p + 1 : p) > 0)
3845                     m->disabled = 1;
3846             }
3847         else
3848             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3849                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3850                             *p == ':' ? p + 1 : p) <= 0)
3851                     continue;
3852                 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3853                                             &o->nb_stream_maps, o->nb_stream_maps + 1);
3854                 m = &o->stream_maps[o->nb_stream_maps - 1];
3855
3856                 m->file_index   = file_idx;
3857                 m->stream_index = i;
3858
3859                 if (sync_file_idx >= 0) {
3860                     m->sync_file_index   = sync_file_idx;
3861                     m->sync_stream_index = sync_stream_idx;
3862                 } else {
3863                     m->sync_file_index   = file_idx;
3864                     m->sync_stream_index = i;
3865                 }
3866             }
3867     }
3868
3869     if (!m) {
3870         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3871         exit_program(1);
3872     }
3873
3874     av_freep(&map);
3875     return 0;
3876 }
3877
3878 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3879 {
3880     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3881                                 &o->nb_attachments, o->nb_attachments + 1);
3882     o->attachments[o->nb_attachments - 1] = arg;
3883     return 0;
3884 }
3885
3886 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3887 {
3888     int n;
3889     AVStream *st;
3890     AudioChannelMap *m;
3891
3892     o->audio_channel_maps =
3893         grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3894                    &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3895     m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3896
3897     /* muted channel syntax */
3898     n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3899     if ((n == 1 || n == 3) && m->channel_idx == -1) {
3900         m->file_idx = m->stream_idx = -1;
3901         if (n == 1)
3902             m->ofile_idx = m->ostream_idx = -1;
3903         return 0;
3904     }
3905
3906     /* normal syntax */
3907     n = sscanf(arg, "%d.%d.%d:%d.%d",
3908                &m->file_idx,  &m->stream_idx, &m->channel_idx,
3909                &m->ofile_idx, &m->ostream_idx);
3910
3911     if (n != 3 && n != 5) {
3912         av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3913                "[file.stream.channel|-1][:syncfile:syncstream]\n");
3914         exit_program(1);
3915     }
3916
3917     if (n != 5) // only file.stream.channel specified
3918         m->ofile_idx = m->ostream_idx = -1;
3919
3920     /* check input */
3921     if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3922         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3923                m->file_idx);
3924         exit_program(1);
3925     }
3926     if (m->stream_idx < 0 ||
3927         m->stream_idx >= input_files[m->file_idx]->nb_streams) {
3928         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3929                m->file_idx, m->stream_idx);
3930         exit_program(1);
3931     }
3932     st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
3933     if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3934         av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3935                m->file_idx, m->stream_idx);
3936         exit_program(1);
3937     }
3938     if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3939         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3940                m->file_idx, m->stream_idx, m->channel_idx);
3941         exit_program(1);
3942     }
3943     return 0;
3944 }
3945
3946 /**
3947  * Parse a metadata specifier in arg.
3948  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3949  * @param index for type c/p, chapter/program index is written here
3950  * @param stream_spec for type s, the stream specifier is written here
3951  */
3952 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3953 {
3954     if (*arg) {
3955         *type = *arg;
3956         switch (*arg) {
3957         case 'g':
3958             break;
3959         case 's':
3960             if (*(++arg) && *arg != ':') {
3961                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3962                 exit_program(1);
3963             }
3964             *stream_spec = *arg == ':' ? arg + 1 : "";
3965             break;
3966         case 'c':
3967         case 'p':
3968             if (*(++arg) == ':')
3969                 *index = strtol(++arg, NULL, 0);
3970             break;
3971         default:
3972             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3973             exit_program(1);
3974         }
3975     } else
3976         *type = 'g';
3977 }
3978
3979 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3980 {
3981     AVDictionary **meta_in = NULL;
3982     AVDictionary **meta_out = NULL;
3983     int i, ret = 0;
3984     char type_in, type_out;
3985     const char *istream_spec = NULL, *ostream_spec = NULL;
3986     int idx_in = 0, idx_out = 0;
3987
3988     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
3989     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3990
3991     if (!ic) {
3992         if (type_out == 'g' || !*outspec)
3993             o->metadata_global_manual = 1;
3994         if (type_out == 's' || !*outspec)
3995             o->metadata_streams_manual = 1;
3996         if (type_out == 'c' || !*outspec)
3997             o->metadata_chapters_manual = 1;
3998         return 0;
3999     }
4000
4001     if (type_in == 'g' || type_out == 'g')
4002         o->metadata_global_manual = 1;
4003     if (type_in == 's' || type_out == 's')
4004         o->metadata_streams_manual = 1;
4005     if (type_in == 'c' || type_out == 'c')
4006         o->metadata_chapters_manual = 1;
4007
4008 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
4009     if ((index) < 0 || (index) >= (nb_elems)) {\
4010         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
4011                 (desc), (index));\
4012         exit_program(1);\
4013     }
4014
4015 #define SET_DICT(type, meta, context, index)\
4016         switch (type) {\
4017         case 'g':\
4018             meta = &context->metadata;\
4019             break;\
4020         case 'c':\
4021             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
4022             meta = &context->chapters[index]->metadata;\
4023             break;\
4024         case 'p':\
4025             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
4026             meta = &context->programs[index]->metadata;\
4027             break;\
4028         }\
4029
4030     SET_DICT(type_in, meta_in, ic, idx_in);
4031     SET_DICT(type_out, meta_out, oc, idx_out);
4032
4033     /* for input streams choose first matching stream */
4034     if (type_in == 's') {
4035         for (i = 0; i < ic->nb_streams; i++) {
4036             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
4037                 meta_in = &ic->streams[i]->metadata;
4038                 break;
4039             } else if (ret < 0)
4040                 exit_program(1);
4041         }
4042         if (!meta_in) {
4043             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
4044             exit_program(1);
4045         }
4046     }
4047
4048     if (type_out == 's') {
4049         for (i = 0; i < oc->nb_streams; i++) {
4050             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
4051                 meta_out = &oc->streams[i]->metadata;
4052                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4053             } else if (ret < 0)
4054                 exit_program(1);
4055         }
4056     } else
4057         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4058
4059     return 0;
4060 }
4061
4062 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
4063 {
4064     char buf[128];
4065     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
4066     struct tm time = *gmtime((time_t*)&recording_timestamp);
4067     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
4068     parse_option(o, "metadata", buf, options);
4069
4070     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
4071                                  "tag instead.\n", opt);
4072     return 0;
4073 }
4074
4075 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
4076 {
4077     const char *codec_string = encoder ? "encoder" : "decoder";
4078     AVCodec *codec;
4079
4080     codec = encoder ?
4081         avcodec_find_encoder_by_name(name) :
4082         avcodec_find_decoder_by_name(name);
4083     if (!codec) {
4084         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
4085         exit_program(1);
4086     }
4087     if (codec->type != type) {
4088         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
4089         exit_program(1);
4090     }
4091     return codec;
4092 }
4093
4094 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
4095 {
4096     char *codec_name = NULL;
4097
4098     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
4099     if (codec_name) {
4100         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
4101         st->codec->codec_id = codec->id;
4102         return codec;
4103     } else
4104         return avcodec_find_decoder(st->codec->codec_id);
4105 }
4106
4107 /**
4108  * Add all the streams from the given input file to the global
4109  * list of input streams.
4110  */
4111 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
4112 {
4113     int i;
4114     char *next, *codec_tag = NULL;
4115
4116     for (i = 0; i < ic->nb_streams; i++) {
4117         AVStream *st = ic->streams[i];
4118         AVCodecContext *dec = st->codec;
4119         InputStream *ist = av_mallocz(sizeof(*ist));
4120
4121         if (!ist)
4122             exit_program(1);
4123
4124         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
4125         input_streams[nb_input_streams - 1] = ist;
4126
4127         ist->st = st;
4128         ist->file_index = nb_input_files;
4129         ist->discard = 1;
4130         st->discard  = AVDISCARD_ALL;
4131         ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
4132
4133         ist->ts_scale = 1.0;
4134         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
4135
4136         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
4137         if (codec_tag) {
4138             uint32_t tag = strtol(codec_tag, &next, 0);
4139             if (*next)
4140                 tag = AV_RL32(codec_tag);
4141             st->codec->codec_tag = tag;
4142         }
4143
4144         ist->dec = choose_decoder(o, ic, st);
4145
4146         switch (dec->codec_type) {
4147         case AVMEDIA_TYPE_VIDEO:
4148             if(!ist->dec)
4149                 ist->dec = avcodec_find_decoder(dec->codec_id);
4150             if (dec->lowres) {
4151                 dec->flags |= CODEC_FLAG_EMU_EDGE;
4152             }
4153
4154             ist->resample_height  = dec->height;
4155             ist->resample_width   = dec->width;
4156             ist->resample_pix_fmt = dec->pix_fmt;
4157
4158             break;
4159         case AVMEDIA_TYPE_AUDIO:
4160         case AVMEDIA_TYPE_DATA:
4161         case AVMEDIA_TYPE_SUBTITLE:
4162             if(!ist->dec)
4163                 ist->dec = avcodec_find_decoder(dec->codec_id);
4164             break;
4165         case AVMEDIA_TYPE_ATTACHMENT:
4166         case AVMEDIA_TYPE_UNKNOWN:
4167             break;
4168         default:
4169             abort();
4170         }
4171     }
4172 }
4173
4174 static void assert_file_overwrite(const char *filename)
4175 {
4176     if ((!file_overwrite || no_file_overwrite) &&
4177         (strchr(filename, ':') == NULL || filename[1] == ':' ||
4178          av_strstart(filename, "file:", NULL))) {
4179         if (avio_check(filename, 0) == 0) {
4180             if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
4181                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
4182                 fflush(stderr);
4183                 term_exit();
4184                 signal(SIGINT, SIG_DFL);
4185                 if (!read_yesno()) {
4186                     av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
4187                     exit_program(1);
4188                 }
4189                 term_init();
4190             }
4191             else {
4192                 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
4193                 exit_program(1);
4194             }
4195         }
4196     }
4197 }
4198
4199 static void dump_attachment(AVStream *st, const char *filename)
4200 {
4201     int ret;
4202     AVIOContext *out = NULL;
4203     AVDictionaryEntry *e;
4204
4205     if (!st->codec->extradata_size) {
4206         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
4207                nb_input_files - 1, st->index);
4208         return;
4209     }
4210     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
4211         filename = e->value;
4212     if (!*filename) {
4213         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
4214                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
4215         exit_program(1);
4216     }
4217
4218     assert_file_overwrite(filename);
4219
4220     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
4221         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
4222                filename);
4223         exit_program(1);
4224     }
4225
4226     avio_write(out, st->codec->extradata, st->codec->extradata_size);
4227     avio_flush(out);
4228     avio_close(out);
4229 }
4230
4231 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
4232 {
4233     AVFormatContext *ic;
4234     AVInputFormat *file_iformat = NULL;
4235     int err, i, ret;
4236     int64_t timestamp;
4237     uint8_t buf[128];
4238     AVDictionary **opts;
4239     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
4240
4241     if (o->format) {
4242         if (!(file_iformat = av_find_input_format(o->format))) {
4243             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
4244             exit_program(1);
4245         }
4246     }
4247
4248     if (!strcmp(filename, "-"))
4249         filename = "pipe:";
4250
4251     using_stdin |= !strncmp(filename, "pipe:", 5) ||
4252                     !strcmp(filename, "/dev/stdin");
4253
4254     /* get default parameters from command line */
4255     ic = avformat_alloc_context();
4256     if (!ic) {
4257         print_error(filename, AVERROR(ENOMEM));
4258         exit_program(1);
4259     }
4260     if (o->nb_audio_sample_rate) {
4261         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
4262         av_dict_set(&format_opts, "sample_rate", buf, 0);
4263     }
4264     if (o->nb_audio_channels) {
4265         /* because we set audio_channels based on both the "ac" and
4266          * "channel_layout" options, we need to check that the specified
4267          * demuxer actually has the "channels" option before setting it */
4268         if (file_iformat && file_iformat->priv_class &&
4269             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
4270                         AV_OPT_SEARCH_FAKE_OBJ)) {
4271             snprintf(buf, sizeof(buf), "%d",
4272                      o->audio_channels[o->nb_audio_channels - 1].u.i);
4273             av_dict_set(&format_opts, "channels", buf, 0);
4274         }
4275     }
4276     if (o->nb_frame_rates) {
4277         av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
4278     }
4279     if (o->nb_frame_sizes) {
4280         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
4281     }
4282     if (o->nb_frame_pix_fmts)
4283         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
4284
4285     ic->video_codec_id   = video_codec_name ?
4286         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : CODEC_ID_NONE;
4287     ic->audio_codec_id   = audio_codec_name ?
4288         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : CODEC_ID_NONE;
4289     ic->subtitle_codec_id= subtitle_codec_name ?
4290         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
4291     ic->flags |= AVFMT_FLAG_NONBLOCK;
4292     ic->interrupt_callback = int_cb;
4293
4294     /* open the input file with generic avformat function */
4295     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
4296     if (err < 0) {
4297         print_error(filename, err);
4298         exit_program(1);
4299     }
4300     assert_avoptions(format_opts);
4301
4302     /* apply forced codec ids */
4303     for (i = 0; i < ic->nb_streams; i++)
4304         choose_decoder(o, ic, ic->streams[i]);
4305
4306     /* Set AVCodecContext options for avformat_find_stream_info */
4307     opts = setup_find_stream_info_opts(ic, codec_opts);
4308     orig_nb_streams = ic->nb_streams;
4309
4310     /* If not enough info to get the stream parameters, we decode the
4311        first frames to get it. (used in mpeg case for example) */
4312     ret = avformat_find_stream_info(ic, opts);
4313     if (ret < 0) {
4314         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
4315         avformat_close_input(&ic);
4316         exit_program(1);
4317     }
4318
4319     timestamp = o->start_time;
4320     /* add the stream start time */
4321     if (ic->start_time != AV_NOPTS_VALUE)
4322         timestamp += ic->start_time;
4323
4324     /* if seeking requested, we execute it */
4325     if (o->start_time != 0) {
4326         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
4327         if (ret < 0) {
4328             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
4329                    filename, (double)timestamp / AV_TIME_BASE);
4330         }
4331     }
4332
4333     /* update the current parameters so that they match the one of the input stream */
4334     add_input_streams(o, ic);
4335
4336     /* dump the file content */
4337     av_dump_format(ic, nb_input_files, filename, 0);
4338
4339     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
4340     if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
4341         exit_program(1);
4342
4343     input_files[nb_input_files - 1]->ctx        = ic;
4344     input_files[nb_input_files - 1]->ist_index  = nb_input_streams - ic->nb_streams;
4345     input_files[nb_input_files - 1]->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
4346     input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
4347     input_files[nb_input_files - 1]->rate_emu   = o->rate_emu;
4348
4349     for (i = 0; i < o->nb_dump_attachment; i++) {
4350         int j;
4351
4352         for (j = 0; j < ic->nb_streams; j++) {
4353             AVStream *st = ic->streams[j];
4354
4355             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
4356                 dump_attachment(st, o->dump_attachment[i].u.str);
4357         }
4358     }
4359
4360     for (i = 0; i < orig_nb_streams; i++)
4361         av_dict_free(&opts[i]);
4362     av_freep(&opts);
4363
4364     reset_options(o, 1);
4365     return 0;
4366 }
4367
4368 static void parse_forced_key_frames(char *kf, OutputStream *ost)
4369 {
4370     char *p;
4371     int n = 1, i;
4372
4373     for (p = kf; *p; p++)
4374         if (*p == ',')
4375             n++;
4376     ost->forced_kf_count = n;
4377     ost->forced_kf_pts   = av_malloc(sizeof(*ost->forced_kf_pts) * n);
4378     if (!ost->forced_kf_pts) {
4379         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
4380         exit_program(1);
4381     }
4382     p = kf;
4383     for (i = 0; i < n; i++) {
4384         char *next = strchr(p, ',');
4385         if (next) *next++ = 0;
4386         ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
4387         p = next;
4388     }
4389 }
4390
4391 static uint8_t *get_line(AVIOContext *s)
4392 {
4393     AVIOContext *line;
4394     uint8_t *buf;
4395     char c;
4396
4397     if (avio_open_dyn_buf(&line) < 0) {
4398         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
4399         exit_program(1);
4400     }
4401
4402     while ((c = avio_r8(s)) && c != '\n')
4403         avio_w8(line, c);
4404     avio_w8(line, 0);
4405     avio_close_dyn_buf(line, &buf);
4406
4407     return buf;
4408 }
4409
4410 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
4411 {
4412     int i, ret = 1;
4413     char filename[1000];
4414     const char *base[3] = { getenv("AVCONV_DATADIR"),
4415                             getenv("HOME"),
4416                             AVCONV_DATADIR,
4417                             };
4418
4419     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
4420         if (!base[i])
4421             continue;
4422         if (codec_name) {
4423             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
4424                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
4425             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4426         }
4427         if (ret) {
4428             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
4429                      i != 1 ? "" : "/.avconv", preset_name);
4430             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4431         }
4432     }
4433     return ret;
4434 }
4435
4436 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
4437 {
4438     char *codec_name = NULL;
4439
4440     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
4441     if (!codec_name) {
4442         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
4443                                                   NULL, ost->st->codec->codec_type);
4444         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
4445     } else if (!strcmp(codec_name, "copy"))
4446         ost->stream_copy = 1;
4447     else {
4448         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
4449         ost->st->codec->codec_id = ost->enc->id;
4450     }
4451 }
4452
4453 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
4454 {
4455     OutputStream *ost;
4456     AVStream *st = avformat_new_stream(oc, NULL);
4457     int idx      = oc->nb_streams - 1, ret = 0;
4458     char *bsf = NULL, *next, *codec_tag = NULL;
4459     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
4460     double qscale = -1;
4461     char *buf = NULL, *arg = NULL, *preset = NULL;
4462     AVIOContext *s = NULL;
4463
4464     if (!st) {
4465         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
4466         exit_program(1);
4467     }
4468
4469     if (oc->nb_streams - 1 < o->nb_streamid_map)
4470         st->id = o->streamid_map[oc->nb_streams - 1];
4471
4472     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
4473                                 nb_output_streams + 1);
4474     if (!(ost = av_mallocz(sizeof(*ost))))
4475         exit_program(1);
4476     output_streams[nb_output_streams - 1] = ost;
4477
4478     ost->file_index = nb_output_files;
4479     ost->index      = idx;
4480     ost->st         = st;
4481     st->codec->codec_type = type;
4482     choose_encoder(o, oc, ost);
4483     if (ost->enc) {
4484         ost->opts  = filter_codec_opts(codec_opts, ost->enc, oc, st);
4485     }
4486
4487     avcodec_get_context_defaults3(st->codec, ost->enc);
4488     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
4489
4490     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
4491     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
4492         do  {
4493             buf = get_line(s);
4494             if (!buf[0] || buf[0] == '#') {
4495                 av_free(buf);
4496                 continue;
4497             }
4498             if (!(arg = strchr(buf, '='))) {
4499                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
4500                 exit_program(1);
4501             }
4502             *arg++ = 0;
4503             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
4504             av_free(buf);
4505         } while (!s->eof_reached);
4506         avio_close(s);
4507     }
4508     if (ret) {
4509         av_log(NULL, AV_LOG_FATAL,
4510                "Preset %s specified for stream %d:%d, but could not be opened.\n",
4511                preset, ost->file_index, ost->index);
4512         exit_program(1);
4513     }
4514
4515     ost->max_frames = INT64_MAX;
4516     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
4517
4518     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
4519     while (bsf) {
4520         if (next = strchr(bsf, ','))
4521             *next++ = 0;
4522         if (!(bsfc = av_bitstream_filter_init(bsf))) {
4523             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
4524             exit_program(1);
4525         }
4526         if (bsfc_prev)
4527             bsfc_prev->next = bsfc;
4528         else
4529             ost->bitstream_filters = bsfc;
4530
4531         bsfc_prev = bsfc;
4532         bsf       = next;
4533     }
4534
4535     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
4536     if (codec_tag) {
4537         uint32_t tag = strtol(codec_tag, &next, 0);
4538         if (*next)
4539             tag = AV_RL32(codec_tag);
4540         st->codec->codec_tag = tag;
4541     }
4542
4543     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
4544     if (qscale >= 0 || same_quant) {
4545         st->codec->flags |= CODEC_FLAG_QSCALE;
4546         st->codec->global_quality = FF_QP2LAMBDA * qscale;
4547     }
4548
4549     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
4550         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
4551
4552     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
4553     av_opt_get_int   (swr_opts, "dither_method", 0, &ost->swr_dither_method);
4554     av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
4555
4556     ost->source_index = source_index;
4557     if (source_index >= 0) {
4558         ost->sync_ist = input_streams[source_index];
4559         input_streams[source_index]->discard = 0;
4560         input_streams[source_index]->st->discard = AVDISCARD_NONE;
4561     }
4562
4563     ost->pix_fmts[0] = ost->pix_fmts[1] = PIX_FMT_NONE;
4564
4565     return ost;
4566 }
4567
4568 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4569 {
4570     int i;
4571     const char *p = str;
4572     for (i = 0;; i++) {
4573         dest[i] = atoi(p);
4574         if (i == 63)
4575             break;
4576         p = strchr(p, ',');
4577         if (!p) {
4578             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4579             exit_program(1);
4580         }
4581         p++;
4582     }
4583 }
4584
4585 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4586 {
4587     AVStream *st;
4588     OutputStream *ost;
4589     AVCodecContext *video_enc;
4590
4591     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
4592     st  = ost->st;
4593     video_enc = st->codec;
4594
4595     if (!ost->stream_copy) {
4596         const char *p = NULL;
4597         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
4598         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
4599         char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
4600         int i;
4601
4602         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
4603         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
4604             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
4605             exit_program(1);
4606         }
4607
4608         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
4609         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
4610             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
4611             exit_program(1);
4612         }
4613
4614         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
4615         if (frame_aspect_ratio) {
4616             AVRational q;
4617             if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
4618                 q.num <= 0 || q.den <= 0) {
4619                 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
4620                 exit_program(1);
4621             }
4622             ost->frame_aspect_ratio = av_q2d(q);
4623         }
4624
4625         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4626         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4627         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4628             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4629             exit_program(1);
4630         }
4631         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4632
4633         if (intra_only)
4634             video_enc->gop_size = 0;
4635         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4636         if (intra_matrix) {
4637             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4638                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4639                 exit_program(1);
4640             }
4641             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4642         }
4643         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4644         if (inter_matrix) {
4645             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4646                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4647                 exit_program(1);
4648             }
4649             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4650         }
4651
4652         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4653         for (i = 0; p; i++) {
4654             int start, end, q;
4655             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4656             if (e != 3) {
4657                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4658                 exit_program(1);
4659             }
4660             /* FIXME realloc failure */
4661             video_enc->rc_override =
4662                 av_realloc(video_enc->rc_override,
4663                            sizeof(RcOverride) * (i + 1));
4664             video_enc->rc_override[i].start_frame = start;
4665             video_enc->rc_override[i].end_frame   = end;
4666             if (q > 0) {
4667                 video_enc->rc_override[i].qscale         = q;
4668                 video_enc->rc_override[i].quality_factor = 1.0;
4669             }
4670             else {
4671                 video_enc->rc_override[i].qscale         = 0;
4672                 video_enc->rc_override[i].quality_factor = -q/100.0;
4673             }
4674             p = strchr(p, '/');
4675             if (p) p++;
4676         }
4677         video_enc->rc_override_count = i;
4678         if (!video_enc->rc_initial_buffer_occupancy)
4679             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4680         video_enc->intra_dc_precision = intra_dc_precision - 8;
4681
4682         if (do_psnr)
4683             video_enc->flags|= CODEC_FLAG_PSNR;
4684
4685         /* two pass mode */
4686         if (do_pass) {
4687             if (do_pass & 1) {
4688                 video_enc->flags |= CODEC_FLAG_PASS1;
4689             }
4690             if (do_pass & 2) {
4691                 video_enc->flags |= CODEC_FLAG_PASS2;
4692             }
4693         }
4694
4695         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4696         if (forced_key_frames)
4697             parse_forced_key_frames(forced_key_frames, ost);
4698
4699         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4700
4701         ost->top_field_first = -1;
4702         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4703
4704         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4705         if (filters)
4706             ost->avfilter = av_strdup(filters);
4707     } else {
4708         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4709     }
4710
4711     return ost;
4712 }
4713
4714 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4715 {
4716     int n;
4717     AVStream *st;
4718     OutputStream *ost;
4719     AVCodecContext *audio_enc;
4720
4721     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
4722     st  = ost->st;
4723
4724     audio_enc = st->codec;
4725     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4726
4727     if (!ost->stream_copy) {
4728         char *sample_fmt = NULL;
4729
4730         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4731
4732         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4733         if (sample_fmt &&
4734             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4735             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4736             exit_program(1);
4737         }
4738
4739         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4740
4741         ost->rematrix_volume=1.0;
4742         MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
4743     }
4744
4745     /* check for channel mapping for this audio stream */
4746     for (n = 0; n < o->nb_audio_channel_maps; n++) {
4747         AudioChannelMap *map = &o->audio_channel_maps[n];
4748         InputStream *ist = input_streams[ost->source_index];
4749         if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4750             (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
4751             (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
4752             if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4753                 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4754             else
4755                 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4756                        ost->file_index, ost->st->index);
4757         }
4758     }
4759
4760     return ost;
4761 }
4762
4763 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4764 {
4765     OutputStream *ost;
4766
4767     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
4768     if (!ost->stream_copy) {
4769         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4770         exit_program(1);
4771     }
4772
4773     return ost;
4774 }
4775
4776 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4777 {
4778     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
4779     ost->stream_copy = 1;
4780     return ost;
4781 }
4782
4783 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4784 {
4785     AVStream *st;
4786     OutputStream *ost;
4787     AVCodecContext *subtitle_enc;
4788
4789     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
4790     st  = ost->st;
4791     subtitle_enc = st->codec;
4792
4793     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4794
4795     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
4796
4797     return ost;
4798 }
4799
4800 /* arg format is "output-stream-index:streamid-value". */
4801 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4802 {
4803     int idx;
4804     char *p;
4805     char idx_str[16];
4806
4807     av_strlcpy(idx_str, arg, sizeof(idx_str));
4808     p = strchr(idx_str, ':');
4809     if (!p) {
4810         av_log(NULL, AV_LOG_FATAL,
4811                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4812                arg, opt);
4813         exit_program(1);
4814     }
4815     *p++ = '\0';
4816     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4817     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4818     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4819     return 0;
4820 }
4821
4822 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4823 {
4824     AVFormatContext *is = ifile->ctx;
4825     AVFormatContext *os = ofile->ctx;
4826     int i;
4827
4828     for (i = 0; i < is->nb_chapters; i++) {
4829         AVChapter *in_ch = is->chapters[i], *out_ch;
4830         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
4831                                        AV_TIME_BASE_Q, in_ch->time_base);
4832         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4833                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4834
4835
4836         if (in_ch->end < ts_off)
4837             continue;
4838         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4839             break;
4840
4841         out_ch = av_mallocz(sizeof(AVChapter));
4842         if (!out_ch)
4843             return AVERROR(ENOMEM);
4844
4845         out_ch->id        = in_ch->id;
4846         out_ch->time_base = in_ch->time_base;
4847         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
4848         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
4849
4850         if (copy_metadata)
4851             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4852
4853         os->nb_chapters++;
4854         os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4855         if (!os->chapters)
4856             return AVERROR(ENOMEM);
4857         os->chapters[os->nb_chapters - 1] = out_ch;
4858     }
4859     return 0;
4860 }
4861
4862 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4863 {
4864     int i, err;
4865     AVFormatContext *ic = avformat_alloc_context();
4866
4867     ic->interrupt_callback = int_cb;
4868     err = avformat_open_input(&ic, filename, NULL, NULL);
4869     if (err < 0)
4870         return err;
4871     /* copy stream format */
4872     for(i=0;i<ic->nb_streams;i++) {
4873         AVStream *st;
4874         OutputStream *ost;
4875         AVCodec *codec;
4876         AVCodecContext *avctx;
4877
4878         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4879         ost   = new_output_stream(o, s, codec->type, -1);
4880         st    = ost->st;
4881         avctx = st->codec;
4882         ost->enc = codec;
4883
4884         // FIXME: a more elegant solution is needed
4885         memcpy(st, ic->streams[i], sizeof(AVStream));
4886         st->cur_dts = 0;
4887         st->info = av_malloc(sizeof(*st->info));
4888         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4889         st->codec= avctx;
4890         avcodec_copy_context(st->codec, ic->streams[i]->codec);
4891
4892         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4893             choose_sample_fmt(st, codec);
4894         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4895             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
4896     }
4897
4898     avformat_close_input(&ic);
4899     return 0;
4900 }
4901
4902 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
4903                                AVFormatContext *oc)
4904 {
4905     OutputStream *ost;
4906
4907     if (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type != AVMEDIA_TYPE_VIDEO) {
4908         av_log(NULL, AV_LOG_FATAL, "Only video filters are supported currently.\n");
4909         exit_program(1);
4910     }
4911
4912     ost               = new_video_stream(o, oc, -1);
4913     ost->source_index = -1;
4914     ost->filter       = ofilter;
4915
4916     ofilter->ost      = ost;
4917
4918     if (ost->stream_copy) {
4919         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
4920                "which is fed from a complex filtergraph. Filtering and streamcopy "
4921                "cannot be used together.\n", ost->file_index, ost->index);
4922         exit_program(1);
4923     }
4924
4925     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
4926         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
4927         exit_program(1);
4928     }
4929     avfilter_inout_free(&ofilter->out_tmp);
4930 }
4931
4932 static void opt_output_file(void *optctx, const char *filename)
4933 {
4934     OptionsContext *o = optctx;
4935     AVFormatContext *oc;
4936     int i, j, err;
4937     AVOutputFormat *file_oformat;
4938     OutputStream *ost;
4939     InputStream  *ist;
4940
4941     if (configure_complex_filters() < 0) {
4942         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
4943         exit_program(1);
4944     }
4945
4946     if (!strcmp(filename, "-"))
4947         filename = "pipe:";
4948
4949     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4950     if (!oc) {
4951         print_error(filename, err);
4952         exit_program(1);
4953     }
4954     file_oformat= oc->oformat;
4955     oc->interrupt_callback = int_cb;
4956
4957     /* create streams for all unlabeled output pads */
4958     for (i = 0; i < nb_filtergraphs; i++) {
4959         FilterGraph *fg = filtergraphs[i];
4960         for (j = 0; j < fg->nb_outputs; j++) {
4961             OutputFilter *ofilter = fg->outputs[j];
4962
4963             if (!ofilter->out_tmp || ofilter->out_tmp->name)
4964                 continue;
4965
4966             switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
4967             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
4968             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
4969             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
4970             }
4971             init_output_filter(ofilter, o, oc);
4972         }
4973     }
4974
4975     if (!strcmp(file_oformat->name, "ffm") &&
4976         av_strstart(filename, "http:", NULL)) {
4977         int j;
4978         /* special case for files sent to ffserver: we get the stream
4979            parameters from ffserver */
4980         int err = read_ffserver_streams(o, oc, filename);
4981         if (err < 0) {
4982             print_error(filename, err);
4983             exit_program(1);
4984         }
4985         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4986             ost = output_streams[j];
4987             for (i = 0; i < nb_input_streams; i++) {
4988                 ist = input_streams[i];
4989                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4990                     ost->sync_ist= ist;
4991                     ost->source_index= i;
4992                     ist->discard = 0;
4993                     ist->st->discard = AVDISCARD_NONE;
4994                     break;
4995                 }
4996             }
4997             if(!ost->sync_ist){
4998                 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
4999                 exit_program(1);
5000             }
5001         }
5002     } else if (!o->nb_stream_maps) {
5003         /* pick the "best" stream of each type */
5004
5005         /* video: highest resolution */
5006         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
5007             int area = 0, idx = -1;
5008             for (i = 0; i < nb_input_streams; i++) {
5009                 ist = input_streams[i];
5010                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
5011                     ist->st->codec->width * ist->st->codec->height > area) {
5012                     area = ist->st->codec->width * ist->st->codec->height;
5013                     idx = i;
5014                 }
5015             }
5016             if (idx >= 0)
5017                 new_video_stream(o, oc, idx);
5018         }
5019
5020         /* audio: most channels */
5021         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
5022             int channels = 0, idx = -1;
5023             for (i = 0; i < nb_input_streams; i++) {
5024                 ist = input_streams[i];
5025                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
5026                     ist->st->codec->channels > channels) {
5027                     channels = ist->st->codec->channels;
5028                     idx = i;
5029                 }
5030             }
5031             if (idx >= 0)
5032                 new_audio_stream(o, oc, idx);
5033         }
5034
5035         /* subtitles: pick first */
5036         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
5037             for (i = 0; i < nb_input_streams; i++)
5038                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
5039                     new_subtitle_stream(o, oc, i);
5040                     break;
5041                 }
5042         }
5043         /* do something with data? */
5044     } else {
5045         for (i = 0; i < o->nb_stream_maps; i++) {
5046             StreamMap *map = &o->stream_maps[i];
5047             int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
5048
5049             if (map->disabled)
5050                 continue;
5051
5052             if (map->linklabel) {
5053                 FilterGraph *fg;
5054                 OutputFilter *ofilter = NULL;
5055                 int j, k;
5056
5057                 for (j = 0; j < nb_filtergraphs; j++) {
5058                     fg = filtergraphs[j];
5059                     for (k = 0; k < fg->nb_outputs; k++) {
5060                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
5061                         if (out && !strcmp(out->name, map->linklabel)) {
5062                             ofilter = fg->outputs[k];
5063                             goto loop_end;
5064                         }
5065                     }
5066                 }
5067 loop_end:
5068                 if (!ofilter) {
5069                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
5070                            "in any defined filter graph.\n", map->linklabel);
5071                     exit_program(1);
5072                 }
5073                 init_output_filter(ofilter, o, oc);
5074             } else {
5075                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
5076                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
5077                     continue;
5078                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
5079                     continue;
5080                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
5081                     continue;
5082                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
5083                     continue;
5084
5085                 switch (ist->st->codec->codec_type) {
5086                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
5087                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
5088                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
5089                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
5090                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
5091                 default:
5092                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
5093                         map->file_index, map->stream_index);
5094                     exit_program(1);
5095                 }
5096             }
5097         }
5098     }
5099
5100
5101     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
5102         AVDictionaryEntry *e;
5103         ost = output_streams[i];
5104
5105         if (   ost->stream_copy
5106             && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
5107             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
5108             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
5109                 exit_program(1);
5110     }
5111
5112     /* handle attached files */
5113     for (i = 0; i < o->nb_attachments; i++) {
5114         AVIOContext *pb;
5115         uint8_t *attachment;
5116         const char *p;
5117         int64_t len;
5118
5119         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
5120             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
5121                    o->attachments[i]);
5122             exit_program(1);
5123         }
5124         if ((len = avio_size(pb)) <= 0) {
5125             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
5126                    o->attachments[i]);
5127             exit_program(1);
5128         }
5129         if (!(attachment = av_malloc(len))) {
5130             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
5131                    o->attachments[i]);
5132             exit_program(1);
5133         }
5134         avio_read(pb, attachment, len);
5135
5136         ost = new_attachment_stream(o, oc, -1);
5137         ost->stream_copy               = 0;
5138         ost->attachment_filename       = o->attachments[i];
5139         ost->st->codec->extradata      = attachment;
5140         ost->st->codec->extradata_size = len;
5141
5142         p = strrchr(o->attachments[i], '/');
5143         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
5144         avio_close(pb);
5145     }
5146
5147     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
5148     if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
5149         exit_program(1);
5150
5151     output_files[nb_output_files - 1]->ctx            = oc;
5152     output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
5153     output_files[nb_output_files - 1]->recording_time = o->recording_time;
5154     if (o->recording_time != INT64_MAX)
5155         oc->duration = o->recording_time;
5156     output_files[nb_output_files - 1]->start_time     = o->start_time;
5157     output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
5158     av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
5159
5160     /* check filename in case of an image number is expected */
5161     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5162         if (!av_filename_number_test(oc->filename)) {
5163             print_error(oc->filename, AVERROR(EINVAL));
5164             exit_program(1);
5165         }
5166     }
5167
5168     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
5169         /* test if it already exists to avoid losing precious files */
5170         assert_file_overwrite(filename);
5171
5172         /* open the file */
5173         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
5174                               &oc->interrupt_callback,
5175                               &output_files[nb_output_files - 1]->opts)) < 0) {
5176             print_error(filename, err);
5177             exit_program(1);
5178         }
5179     }
5180
5181     if (o->mux_preload) {
5182         uint8_t buf[64];
5183         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
5184         av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
5185     }
5186     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
5187
5188     /* copy metadata */
5189     for (i = 0; i < o->nb_metadata_map; i++) {
5190         char *p;
5191         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
5192
5193         if (in_file_index >= nb_input_files) {
5194             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
5195             exit_program(1);
5196         }
5197         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
5198     }
5199
5200     /* copy chapters */
5201     if (o->chapters_input_file >= nb_input_files) {
5202         if (o->chapters_input_file == INT_MAX) {
5203             /* copy chapters from the first input file that has them*/
5204             o->chapters_input_file = -1;
5205             for (i = 0; i < nb_input_files; i++)
5206                 if (input_files[i]->ctx->nb_chapters) {
5207                     o->chapters_input_file = i;
5208                     break;
5209                 }
5210         } else {
5211             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
5212                    o->chapters_input_file);
5213             exit_program(1);
5214         }
5215     }
5216     if (o->chapters_input_file >= 0)
5217         copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
5218                       !o->metadata_chapters_manual);
5219
5220     /* copy global metadata by default */
5221     if (!o->metadata_global_manual && nb_input_files){
5222         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
5223                      AV_DICT_DONT_OVERWRITE);
5224         if(o->recording_time != INT64_MAX)
5225             av_dict_set(&oc->metadata, "duration", NULL, 0);
5226     }
5227     if (!o->metadata_streams_manual)
5228         for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
5229             InputStream *ist;
5230             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
5231                 continue;
5232             ist = input_streams[output_streams[i]->source_index];
5233             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
5234         }
5235
5236     /* process manually set metadata */
5237     for (i = 0; i < o->nb_metadata; i++) {
5238         AVDictionary **m;
5239         char type, *val;
5240         const char *stream_spec;
5241         int index = 0, j, ret = 0;
5242
5243         val = strchr(o->metadata[i].u.str, '=');
5244         if (!val) {
5245             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
5246                    o->metadata[i].u.str);
5247             exit_program(1);
5248         }
5249         *val++ = 0;
5250
5251         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
5252         if (type == 's') {
5253             for (j = 0; j < oc->nb_streams; j++) {
5254                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
5255                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
5256                 } else if (ret < 0)
5257                     exit_program(1);
5258             }
5259             printf("ret %d, stream_spec %s\n", ret, stream_spec);
5260         }
5261         else {
5262             switch (type) {
5263             case 'g':
5264                 m = &oc->metadata;
5265                 break;
5266             case 'c':
5267                 if (index < 0 || index >= oc->nb_chapters) {
5268                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
5269                     exit_program(1);
5270                 }
5271                 m = &oc->chapters[index]->metadata;
5272                 break;
5273             default:
5274                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
5275                 exit_program(1);
5276             }
5277             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
5278         }
5279     }
5280
5281     reset_options(o, 0);
5282 }
5283
5284 /* same option as mencoder */
5285 static int opt_pass(const char *opt, const char *arg)
5286 {
5287     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
5288     return 0;
5289 }
5290
5291 static int64_t getmaxrss(void)
5292 {
5293 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
5294     struct rusage rusage;
5295     getrusage(RUSAGE_SELF, &rusage);
5296     return (int64_t)rusage.ru_maxrss * 1024;
5297 #elif HAVE_GETPROCESSMEMORYINFO
5298     HANDLE proc;
5299     PROCESS_MEMORY_COUNTERS memcounters;
5300     proc = GetCurrentProcess();
5301     memcounters.cb = sizeof(memcounters);
5302     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
5303     return memcounters.PeakPagefileUsage;
5304 #else
5305     return 0;
5306 #endif
5307 }
5308
5309 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
5310 {
5311     return parse_option(o, "q:a", arg, options);
5312 }
5313
5314 static void show_usage(void)
5315 {
5316     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
5317     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
5318     av_log(NULL, AV_LOG_INFO, "\n");
5319 }
5320
5321 static int opt_help(const char *opt, const char *arg)
5322 {
5323     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
5324     av_log_set_callback(log_callback_help);
5325     show_usage();
5326     show_help_options(options, "Main options:\n",
5327                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
5328     show_help_options(options, "\nAdvanced options:\n",
5329                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
5330                       OPT_EXPERT);
5331     show_help_options(options, "\nVideo options:\n",
5332                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5333                       OPT_VIDEO);
5334     show_help_options(options, "\nAdvanced Video options:\n",
5335                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5336                       OPT_VIDEO | OPT_EXPERT);
5337     show_help_options(options, "\nAudio options:\n",
5338                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5339                       OPT_AUDIO);
5340     show_help_options(options, "\nAdvanced Audio options:\n",
5341                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5342                       OPT_AUDIO | OPT_EXPERT);
5343     show_help_options(options, "\nSubtitle options:\n",
5344                       OPT_SUBTITLE | OPT_GRAB,
5345                       OPT_SUBTITLE);
5346     show_help_options(options, "\nAudio/Video grab options:\n",
5347                       OPT_GRAB,
5348                       OPT_GRAB);
5349     printf("\n");
5350     show_help_children(avcodec_get_class(), flags);
5351     show_help_children(avformat_get_class(), flags);
5352     show_help_children(sws_get_class(), flags);
5353
5354     return 0;
5355 }
5356
5357 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
5358 {
5359     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
5360     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
5361
5362     if (!strncmp(arg, "pal-", 4)) {
5363         norm = PAL;
5364         arg += 4;
5365     } else if (!strncmp(arg, "ntsc-", 5)) {
5366         norm = NTSC;
5367         arg += 5;
5368     } else if (!strncmp(arg, "film-", 5)) {
5369         norm = FILM;
5370         arg += 5;
5371     } else {
5372         /* Try to determine PAL/NTSC by peeking in the input files */
5373         if (nb_input_files) {
5374             int i, j, fr;
5375             for (j = 0; j < nb_input_files; j++) {
5376                 for (i = 0; i < input_files[j]->nb_streams; i++) {
5377                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
5378                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
5379                         continue;
5380                     fr = c->time_base.den * 1000 / c->time_base.num;
5381                     if (fr == 25000) {
5382                         norm = PAL;
5383                         break;
5384                     } else if ((fr == 29970) || (fr == 23976)) {
5385                         norm = NTSC;
5386                         break;
5387                     }
5388                 }
5389                 if (norm != UNKNOWN)
5390                     break;
5391             }
5392         }
5393         if (norm != UNKNOWN)
5394             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
5395     }
5396
5397     if (norm == UNKNOWN) {
5398         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
5399         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
5400         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
5401         exit_program(1);
5402     }
5403
5404     if (!strcmp(arg, "vcd")) {
5405         opt_video_codec(o, "c:v", "mpeg1video");
5406         opt_audio_codec(o, "c:a", "mp2");
5407         parse_option(o, "f", "vcd", options);
5408
5409         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
5410         parse_option(o, "r", frame_rates[norm], options);
5411         opt_default("g", norm == PAL ? "15" : "18");
5412
5413         opt_default("b:v", "1150000");
5414         opt_default("maxrate", "1150000");
5415         opt_default("minrate", "1150000");
5416         opt_default("bufsize", "327680"); // 40*1024*8;
5417
5418         opt_default("b:a", "224000");
5419         parse_option(o, "ar", "44100", options);
5420         parse_option(o, "ac", "2", options);
5421
5422         opt_default("packetsize", "2324");
5423         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
5424
5425         /* We have to offset the PTS, so that it is consistent with the SCR.
5426            SCR starts at 36000, but the first two packs contain only padding
5427            and the first pack from the other stream, respectively, may also have
5428            been written before.
5429            So the real data starts at SCR 36000+3*1200. */
5430         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
5431     } else if (!strcmp(arg, "svcd")) {
5432
5433         opt_video_codec(o, "c:v", "mpeg2video");
5434         opt_audio_codec(o, "c:a", "mp2");
5435         parse_option(o, "f", "svcd", options);
5436
5437         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
5438         parse_option(o, "r", frame_rates[norm], options);
5439         parse_option(o, "pix_fmt", "yuv420p", options);
5440         opt_default("g", norm == PAL ? "15" : "18");
5441
5442         opt_default("b:v", "2040000");
5443         opt_default("maxrate", "2516000");
5444         opt_default("minrate", "0"); // 1145000;
5445         opt_default("bufsize", "1835008"); // 224*1024*8;
5446         opt_default("scan_offset", "1");
5447
5448
5449         opt_default("b:a", "224000");
5450         parse_option(o, "ar", "44100", options);
5451
5452         opt_default("packetsize", "2324");
5453
5454     } else if (!strcmp(arg, "dvd")) {
5455
5456         opt_video_codec(o, "c:v", "mpeg2video");
5457         opt_audio_codec(o, "c:a", "ac3");
5458         parse_option(o, "f", "dvd", options);
5459
5460         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5461         parse_option(o, "r", frame_rates[norm], options);
5462         parse_option(o, "pix_fmt", "yuv420p", options);
5463         opt_default("g", norm == PAL ? "15" : "18");
5464
5465         opt_default("b:v", "6000000");
5466         opt_default("maxrate", "9000000");
5467         opt_default("minrate", "0"); // 1500000;
5468         opt_default("bufsize", "1835008"); // 224*1024*8;
5469
5470         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
5471         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
5472
5473         opt_default("b:a", "448000");
5474         parse_option(o, "ar", "48000", options);
5475
5476     } else if (!strncmp(arg, "dv", 2)) {
5477
5478         parse_option(o, "f", "dv", options);
5479
5480         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5481         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
5482                           norm == PAL ? "yuv420p" : "yuv411p", options);
5483         parse_option(o, "r", frame_rates[norm], options);
5484
5485         parse_option(o, "ar", "48000", options);
5486         parse_option(o, "ac", "2", options);
5487
5488     } else {
5489         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
5490         return AVERROR(EINVAL);
5491     }
5492     return 0;
5493 }
5494
5495 static int opt_vstats_file(const char *opt, const char *arg)
5496 {
5497     av_free (vstats_filename);
5498     vstats_filename = av_strdup (arg);
5499     return 0;
5500 }
5501
5502 static int opt_vstats(const char *opt, const char *arg)
5503 {
5504     char filename[40];
5505     time_t today2 = time(NULL);
5506     struct tm *today = localtime(&today2);
5507
5508     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
5509              today->tm_sec);
5510     return opt_vstats_file(opt, filename);
5511 }
5512
5513 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
5514 {
5515     return parse_option(o, "frames:v", arg, options);
5516 }
5517
5518 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
5519 {
5520     return parse_option(o, "frames:a", arg, options);
5521 }
5522
5523 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
5524 {
5525     return parse_option(o, "frames:d", arg, options);
5526 }
5527
5528 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
5529 {
5530     FILE *f=NULL;
5531     char filename[1000], tmp[1000], tmp2[1000], line[1000];
5532     const char *codec_name = *opt == 'v' ? video_codec_name :
5533                              *opt == 'a' ? audio_codec_name :
5534                                            subtitle_codec_name;
5535
5536     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
5537         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
5538             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
5539         }else
5540             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
5541         exit_program(1);
5542     }
5543
5544     while(!feof(f)){
5545         int e= fscanf(f, "%999[^\n]\n", line) - 1;
5546         if(line[0] == '#' && !e)
5547             continue;
5548         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
5549         if(e){
5550             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
5551             exit_program(1);
5552         }
5553         if(!strcmp(tmp, "acodec")){
5554             opt_audio_codec(o, tmp, tmp2);
5555         }else if(!strcmp(tmp, "vcodec")){
5556             opt_video_codec(o, tmp, tmp2);
5557         }else if(!strcmp(tmp, "scodec")){
5558             opt_subtitle_codec(o, tmp, tmp2);
5559         }else if(!strcmp(tmp, "dcodec")){
5560             opt_data_codec(o, tmp, tmp2);
5561         }else if(opt_default(tmp, tmp2) < 0){
5562             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
5563             exit_program(1);
5564         }
5565     }
5566
5567     fclose(f);
5568
5569     return 0;
5570 }
5571
5572 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
5573 {
5574 }
5575
5576 static int opt_passlogfile(const char *opt, const char *arg)
5577 {
5578     pass_logfilename_prefix = arg;
5579 #if CONFIG_LIBX264_ENCODER
5580     return opt_default(opt, arg);
5581 #else
5582     return 0;
5583 #endif
5584 }
5585
5586 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
5587 {
5588     char *s = av_asprintf("%s:%c", opt + 1, *opt);
5589     int ret = parse_option(o, s, arg, options);
5590     av_free(s);
5591     return ret;
5592 }
5593
5594 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
5595 {
5596     if(!strcmp(opt, "b")){
5597         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
5598         return parse_option(o, "b:v", arg, options);
5599     }
5600     return opt_default(opt, arg);
5601 }
5602
5603 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
5604 {
5605     char *s;
5606     int ret;
5607     if(!strcmp(opt, "qscale")){
5608         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
5609         return parse_option(o, "q:v", arg, options);
5610     }
5611     s = av_asprintf("q%s", opt + 6);
5612     ret = parse_option(o, s, arg, options);
5613     av_free(s);
5614     return ret;
5615 }
5616
5617 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
5618 {
5619     if(!strcmp(opt, "profile")){
5620         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
5621         return parse_option(o, "profile:v", arg, options);
5622     }
5623     return opt_default(opt, arg);
5624 }
5625
5626 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
5627 {
5628     return parse_option(o, "filter:v", arg, options);
5629 }
5630
5631 static int opt_vsync(const char *opt, const char *arg)
5632 {
5633     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
5634     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
5635     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
5636     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
5637
5638     if (video_sync_method == VSYNC_AUTO)
5639         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
5640     return 0;
5641 }
5642
5643 static int opt_deinterlace(const char *opt, const char *arg)
5644 {
5645     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
5646     do_deinterlace = 1;
5647     return 0;
5648 }
5649
5650 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
5651 {
5652     int idx = locate_option(argc, argv, options, "cpuflags");
5653     if (idx && argv[idx + 1])
5654         opt_cpuflags("cpuflags", argv[idx + 1]);
5655 }
5656
5657 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
5658 {
5659     char layout_str[32];
5660     char *stream_str;
5661     char *ac_str;
5662     int ret, channels, ac_str_size;
5663     uint64_t layout;
5664
5665     layout = av_get_channel_layout(arg);
5666     if (!layout) {
5667         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
5668         return AVERROR(EINVAL);
5669     }
5670     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
5671     ret = opt_default(opt, layout_str);
5672     if (ret < 0)
5673         return ret;
5674
5675     /* set 'ac' option based on channel layout */
5676     channels = av_get_channel_layout_nb_channels(layout);
5677     snprintf(layout_str, sizeof(layout_str), "%d", channels);
5678     stream_str = strchr(opt, ':');
5679     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
5680     ac_str = av_mallocz(ac_str_size);
5681     if (!ac_str)
5682         return AVERROR(ENOMEM);
5683     av_strlcpy(ac_str, "ac", 3);
5684     if (stream_str)
5685         av_strlcat(ac_str, stream_str, ac_str_size);
5686     ret = parse_option(o, ac_str, layout_str, options);
5687     av_free(ac_str);
5688
5689     return ret;
5690 }
5691
5692 static int opt_filter_complex(const char *opt, const char *arg)
5693 {
5694     filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
5695                               &nb_filtergraphs, nb_filtergraphs + 1);
5696     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
5697         return AVERROR(ENOMEM);
5698     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
5699     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
5700     return 0;
5701 }
5702
5703 #define OFFSET(x) offsetof(OptionsContext, x)
5704 static const OptionDef options[] = {
5705     /* main options */
5706 #include "cmdutils_common_opts.h"
5707     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
5708     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
5709     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
5710     { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
5711     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5712     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5713     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
5714     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
5715     { "map_channel", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_channel}, "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
5716     { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
5717       "outfile[,metadata]:infile[,metadata]" },
5718     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
5719     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
5720     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
5721     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
5722     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
5723     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
5724     { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
5725     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
5726     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
5727     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5728       "add timings for benchmarking" },
5729     { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
5730       "add timings for each task" },
5731     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
5732     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
5733       "dump each input packet" },
5734     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
5735       "when dumping packets, also dump the payload" },
5736     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
5737     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
5738     { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
5739     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
5740     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
5741     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
5742     { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying", "mode" },
5743     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
5744     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
5745     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
5746     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
5747     { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
5748     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
5749     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
5750     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
5751     { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
5752     { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
5753     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
5754     { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
5755     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
5756     { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
5757     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
5758     { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
5759
5760     /* video options */
5761     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
5762     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
5763     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
5764     { "aspect", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_aspect_ratios)}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
5765     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
5766     { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
5767     { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5768     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5769     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5770     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5771     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5772     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5773     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5774     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5775     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
5776     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
5777     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
5778     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
5779     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
5780     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
5781     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
5782     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
5783       "use same quantizer as source (implies VBR)" },
5784     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
5785     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
5786     { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
5787       "this option is deprecated, use the yadif filter instead" },
5788     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
5789     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
5790     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
5791     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
5792     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
5793     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
5794     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
5795     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
5796     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
5797     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
5798     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
5799     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
5800     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(forced_key_frames)}, "force key frames at specified timestamps", "timestamps" },
5801     { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5802
5803     /* audio options */
5804     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5805     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5806     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5807     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5808     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5809     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5810     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5811     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5812     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5813     { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
5814     { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
5815
5816     /* subtitle options */
5817     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5818     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5819     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5820
5821     /* grab options */
5822     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5823     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5824     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5825
5826     /* muxer options */
5827     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5828     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
5829
5830     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5831     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5832     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5833
5834     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5835     { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5836     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5837     { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5838     /* data codec support */
5839     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5840     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5841
5842     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5843     { NULL, },
5844 };
5845
5846 int main(int argc, char **argv)
5847 {
5848     OptionsContext o = { 0 };
5849     int64_t ti;
5850
5851     reset_options(&o, 0);
5852
5853     av_log_set_flags(AV_LOG_SKIP_REPEATED);
5854     parse_loglevel(argc, argv, options);
5855
5856     if(argc>1 && !strcmp(argv[1], "-d")){
5857         run_as_daemon=1;
5858         av_log_set_callback(log_callback_null);
5859         argc--;
5860         argv++;
5861     }
5862
5863     avcodec_register_all();
5864 #if CONFIG_AVDEVICE
5865     avdevice_register_all();
5866 #endif
5867     avfilter_register_all();
5868     av_register_all();
5869     avformat_network_init();
5870
5871     show_banner(argc, argv, options);
5872
5873     term_init();
5874
5875     parse_cpuflags(argc, argv, options);
5876
5877     /* parse options */
5878     parse_options(&o, argc, argv, options, opt_output_file);
5879
5880     if (nb_output_files <= 0 && nb_input_files == 0) {
5881         show_usage();
5882         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5883         exit_program(1);
5884     }
5885
5886     /* file converter / grab */
5887     if (nb_output_files <= 0) {
5888         av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5889         exit_program(1);
5890     }
5891
5892     if (nb_input_files == 0) {
5893         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5894         exit_program(1);
5895     }
5896
5897     current_time = ti = getutime();
5898     if (transcode() < 0)
5899         exit_program(1);
5900     ti = getutime() - ti;
5901     if (do_benchmark) {
5902         int maxrss = getmaxrss() / 1024;
5903         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
5904     }
5905
5906     exit_program(0);
5907     return 0;
5908 }