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