avconv: get output pixel format from lavfi.
[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     /* a pool of free buffers for decoded data */
183     FrameBuffer *buffer_pool;
184 } InputStream;
185
186 typedef struct InputFile {
187     AVFormatContext *ctx;
188     int eof_reached;      /* true if eof reached */
189     int ist_index;        /* index of first stream in ist_table */
190     int buffer_size;      /* current total buffer size */
191     int64_t ts_offset;
192     int nb_streams;       /* number of stream that avconv is aware of; may be different
193                              from ctx.nb_streams if new streams appear during av_read_frame() */
194     int rate_emu;
195 } InputFile;
196
197 typedef struct OutputStream {
198     int file_index;          /* file index */
199     int index;               /* stream index in the output file */
200     int source_index;        /* InputStream index */
201     AVStream *st;            /* stream in the output file */
202     int encoding_needed;     /* true if encoding needed for this stream */
203     int frame_number;
204     /* input pts and corresponding output pts
205        for A/V sync */
206     // double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
207     struct InputStream *sync_ist; /* input stream to sync against */
208     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
209     /* pts of the first frame encoded for this stream, used for limiting
210      * recording time */
211     int64_t first_pts;
212     AVBitStreamFilterContext *bitstream_filters;
213     AVCodec *enc;
214     int64_t max_frames;
215     AVFrame *output_frame;
216
217     /* video only */
218     int video_resample;
219     int resample_height;
220     int resample_width;
221     int resample_pix_fmt;
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;
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     for (i = 0; i < nb_output_streams; i++) {
1907         OutputStream *ost = output_streams[i];
1908         int frame_size, resample_changed;
1909
1910         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1911             continue;
1912
1913         resample_changed = ost->resample_width   != decoded_frame->width  ||
1914                            ost->resample_height  != decoded_frame->height ||
1915                            ost->resample_pix_fmt != decoded_frame->format;
1916         if (resample_changed) {
1917             av_log(NULL, AV_LOG_INFO,
1918                     "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1919                     ist->file_index, ist->st->index,
1920                     ost->resample_width,  ost->resample_height,  av_get_pix_fmt_name(ost->resample_pix_fmt),
1921                     decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
1922
1923             avfilter_graph_free(&ost->graph);
1924             if (configure_video_filters(ist, ost)) {
1925                 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1926                 exit_program(1);
1927             }
1928
1929             ost->resample_width   = decoded_frame->width;
1930             ost->resample_height  = decoded_frame->height;
1931             ost->resample_pix_fmt = decoded_frame->format;
1932         }
1933
1934         if (ist->st->codec->codec->capabilities & CODEC_CAP_DR1) {
1935             FrameBuffer      *buf = decoded_frame->opaque;
1936             AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
1937                                         decoded_frame->data, decoded_frame->linesize,
1938                                         AV_PERM_READ | AV_PERM_PRESERVE,
1939                                         ist->st->codec->width, ist->st->codec->height,
1940                                         ist->st->codec->pix_fmt);
1941
1942             avfilter_copy_frame_props(fb, decoded_frame);
1943             fb->buf->priv           = buf;
1944             fb->buf->free           = filter_release_buffer;
1945
1946             buf->refcount++;
1947             av_buffersrc_buffer(ost->input_video_filter, fb);
1948         } else
1949             av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame,
1950                                      decoded_frame->pts, decoded_frame->sample_aspect_ratio);
1951
1952         if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
1953             ret = AVERROR(ENOMEM);
1954             goto fail;
1955         } else
1956             avcodec_get_frame_defaults(ist->filtered_frame);
1957         filtered_frame = ist->filtered_frame;
1958
1959         frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1960         while (frame_available) {
1961             AVFilterBufferRef *picref;
1962             AVRational ist_pts_tb;
1963             if ((ret = get_filtered_video_frame(ost->output_video_filter,
1964                                                 filtered_frame, &picref,
1965                                                 &ist_pts_tb)) < 0)
1966                 goto fail;
1967             filtered_frame->pts = av_rescale_q(picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1968             if (!ost->frame_aspect_ratio)
1969                 ost->st->codec->sample_aspect_ratio = picref->video->pixel_aspect;
1970
1971             do_video_out(output_files[ost->file_index]->ctx, ost, filtered_frame, &frame_size,
1972                          same_quant ? quality : ost->st->codec->global_quality);
1973             if (vstats_filename && frame_size)
1974                 do_video_stats(output_files[ost->file_index]->ctx, ost, frame_size);
1975             frame_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1976             avfilter_unref_buffer(picref);
1977         }
1978     }
1979
1980 fail:
1981     av_free(buffer_to_free);
1982     return ret;
1983 }
1984
1985 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
1986 {
1987     AVSubtitle subtitle;
1988     int i, ret = avcodec_decode_subtitle2(ist->st->codec,
1989                                           &subtitle, got_output, pkt);
1990     if (ret < 0)
1991         return ret;
1992     if (!*got_output)
1993         return ret;
1994
1995     rate_emu_sleep(ist);
1996
1997     for (i = 0; i < nb_output_streams; i++) {
1998         OutputStream *ost = output_streams[i];
1999
2000         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2001             continue;
2002
2003         do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2004     }
2005
2006     avsubtitle_free(&subtitle);
2007     return ret;
2008 }
2009
2010 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2011 static int output_packet(InputStream *ist, const AVPacket *pkt)
2012 {
2013     int i;
2014     int got_output;
2015     int64_t pkt_pts = AV_NOPTS_VALUE;
2016     AVPacket avpkt;
2017
2018     if (ist->next_dts == AV_NOPTS_VALUE)
2019         ist->next_dts = ist->last_dts;
2020
2021     if (pkt == NULL) {
2022         /* EOF handling */
2023         av_init_packet(&avpkt);
2024         avpkt.data = NULL;
2025         avpkt.size = 0;
2026         goto handle_eof;
2027     } else {
2028         avpkt = *pkt;
2029     }
2030
2031     if (pkt->dts != AV_NOPTS_VALUE)
2032         ist->next_dts = ist->last_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2033     if (pkt->pts != AV_NOPTS_VALUE)
2034         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2035
2036     // while we have more to decode or while the decoder did output something on EOF
2037     while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2038         int ret = 0;
2039     handle_eof:
2040
2041         ist->last_dts = ist->next_dts;
2042
2043         if (avpkt.size && avpkt.size != pkt->size) {
2044             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2045                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2046             ist->showed_multi_packet_warning = 1;
2047         }
2048
2049         switch (ist->st->codec->codec_type) {
2050         case AVMEDIA_TYPE_AUDIO:
2051             ret = transcode_audio    (ist, &avpkt, &got_output);
2052             break;
2053         case AVMEDIA_TYPE_VIDEO:
2054             ret = transcode_video    (ist, &avpkt, &got_output, &pkt_pts);
2055             if (avpkt.duration)
2056                 ist->next_dts += av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2057             else if (ist->st->r_frame_rate.num)
2058                 ist->next_dts += av_rescale_q(1, (AVRational){ist->st->r_frame_rate.den,
2059                                                               ist->st->r_frame_rate.num},
2060                                               AV_TIME_BASE_Q);
2061             else if (ist->st->codec->time_base.num != 0) {
2062                 int ticks      = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
2063                                                    ist->st->codec->ticks_per_frame;
2064                 ist->next_dts += av_rescale_q(ticks, ist->st->codec->time_base, AV_TIME_BASE_Q);
2065             }
2066             break;
2067         case AVMEDIA_TYPE_SUBTITLE:
2068             ret = transcode_subtitles(ist, &avpkt, &got_output);
2069             break;
2070         default:
2071             return -1;
2072         }
2073
2074         if (ret < 0)
2075             return ret;
2076         // touch data and size only if not EOF
2077         if (pkt) {
2078             avpkt.data += ret;
2079             avpkt.size -= ret;
2080         }
2081         if (!got_output) {
2082             continue;
2083         }
2084     }
2085
2086     /* handle stream copy */
2087     if (!ist->decoding_needed) {
2088         rate_emu_sleep(ist);
2089         ist->last_dts = ist->next_dts;
2090         switch (ist->st->codec->codec_type) {
2091         case AVMEDIA_TYPE_AUDIO:
2092             ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2093                              ist->st->codec->sample_rate;
2094             break;
2095         case AVMEDIA_TYPE_VIDEO:
2096             if (ist->st->codec->time_base.num != 0) {
2097                 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2098                 ist->next_dts += ((int64_t)AV_TIME_BASE *
2099                                   ist->st->codec->time_base.num * ticks) /
2100                                   ist->st->codec->time_base.den;
2101             }
2102             break;
2103         }
2104     }
2105     for (i = 0; pkt && i < nb_output_streams; i++) {
2106         OutputStream *ost = output_streams[i];
2107
2108         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2109             continue;
2110
2111         do_streamcopy(ist, ost, pkt);
2112     }
2113
2114     return 0;
2115 }
2116
2117 static void print_sdp(void)
2118 {
2119     char sdp[2048];
2120     int i;
2121     AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2122
2123     if (!avc)
2124         exit_program(1);
2125     for (i = 0; i < nb_output_files; i++)
2126         avc[i] = output_files[i]->ctx;
2127
2128     av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2129     printf("SDP:\n%s\n", sdp);
2130     fflush(stdout);
2131     av_freep(&avc);
2132 }
2133
2134 static void get_default_channel_layouts(OutputStream *ost, InputStream *ist)
2135 {
2136     char layout_name[256];
2137     AVCodecContext *enc = ost->st->codec;
2138     AVCodecContext *dec = ist->st->codec;
2139
2140     if (!dec->channel_layout) {
2141         if (enc->channel_layout && dec->channels == enc->channels) {
2142             dec->channel_layout = enc->channel_layout;
2143         } else {
2144             dec->channel_layout = av_get_default_channel_layout(dec->channels);
2145
2146             if (!dec->channel_layout) {
2147                 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
2148                        "layout for Input Stream #%d.%d\n", ist->file_index,
2149                        ist->st->index);
2150                 exit_program(1);
2151             }
2152         }
2153         av_get_channel_layout_string(layout_name, sizeof(layout_name),
2154                                      dec->channels, dec->channel_layout);
2155         av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for  Input Stream "
2156                "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
2157     }
2158     if (!enc->channel_layout) {
2159         if (dec->channels == enc->channels) {
2160             enc->channel_layout = dec->channel_layout;
2161             return;
2162         } else {
2163             enc->channel_layout = av_get_default_channel_layout(enc->channels);
2164         }
2165         if (!enc->channel_layout) {
2166             av_log(NULL, AV_LOG_FATAL, "Unable to find default channel layout "
2167                    "for Output Stream #%d.%d\n", ost->file_index,
2168                    ost->st->index);
2169             exit_program(1);
2170         }
2171         av_get_channel_layout_string(layout_name, sizeof(layout_name),
2172                                      enc->channels, enc->channel_layout);
2173         av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Output Stream "
2174                "#%d.%d : %s\n", ost->file_index, ost->st->index, layout_name);
2175     }
2176 }
2177
2178
2179 static int init_input_stream(int ist_index, char *error, int error_len)
2180 {
2181     int i;
2182     InputStream *ist = input_streams[ist_index];
2183     if (ist->decoding_needed) {
2184         AVCodec *codec = ist->dec;
2185         if (!codec) {
2186             snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
2187                     ist->st->codec->codec_id, ist->file_index, ist->st->index);
2188             return AVERROR(EINVAL);
2189         }
2190
2191         /* update requested sample format for the decoder based on the
2192            corresponding encoder sample format */
2193         for (i = 0; i < nb_output_streams; i++) {
2194             OutputStream *ost = output_streams[i];
2195             if (ost->source_index == ist_index) {
2196                 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2197                 break;
2198             }
2199         }
2200
2201         if (codec->type == AVMEDIA_TYPE_VIDEO && codec->capabilities & CODEC_CAP_DR1) {
2202             ist->st->codec->get_buffer     = codec_get_buffer;
2203             ist->st->codec->release_buffer = codec_release_buffer;
2204             ist->st->codec->opaque         = ist;
2205         }
2206
2207         if (!av_dict_get(ist->opts, "threads", NULL, 0))
2208             av_dict_set(&ist->opts, "threads", "auto", 0);
2209         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2210             snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2211                     ist->file_index, ist->st->index);
2212             return AVERROR(EINVAL);
2213         }
2214         assert_codec_experimental(ist->st->codec, 0);
2215         assert_avoptions(ist->opts);
2216
2217         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2218             for (i = 0; i < nb_output_streams; i++) {
2219                 OutputStream *ost = output_streams[i];
2220                 if (ost->source_index == ist_index) {
2221                     if (!ist->st->codec->channel_layout || !ost->st->codec->channel_layout)
2222                         get_default_channel_layouts(ost, ist);
2223                     break;
2224                 }
2225             }
2226         }
2227     }
2228
2229     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;
2230     ist->next_dts = AV_NOPTS_VALUE;
2231     init_pts_correction(&ist->pts_ctx);
2232     ist->is_start = 1;
2233
2234     return 0;
2235 }
2236
2237 static int transcode_init(void)
2238 {
2239     int ret = 0, i, j, k;
2240     AVFormatContext *oc;
2241     AVCodecContext *codec, *icodec;
2242     OutputStream *ost;
2243     InputStream *ist;
2244     char error[1024];
2245     int want_sdp = 1;
2246
2247     /* init framerate emulation */
2248     for (i = 0; i < nb_input_files; i++) {
2249         InputFile *ifile = input_files[i];
2250         if (ifile->rate_emu)
2251             for (j = 0; j < ifile->nb_streams; j++)
2252                 input_streams[j + ifile->ist_index]->start = av_gettime();
2253     }
2254
2255     /* output stream init */
2256     for (i = 0; i < nb_output_files; i++) {
2257         oc = output_files[i]->ctx;
2258         if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2259             av_dump_format(oc, i, oc->filename, 1);
2260             av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2261             return AVERROR(EINVAL);
2262         }
2263     }
2264
2265     /* for each output stream, we compute the right encoding parameters */
2266     for (i = 0; i < nb_output_streams; i++) {
2267         ost = output_streams[i];
2268         oc  = output_files[ost->file_index]->ctx;
2269         ist = input_streams[ost->source_index];
2270
2271         if (ost->attachment_filename)
2272             continue;
2273
2274         codec  = ost->st->codec;
2275         icodec = ist->st->codec;
2276
2277         ost->st->disposition          = ist->st->disposition;
2278         codec->bits_per_raw_sample    = icodec->bits_per_raw_sample;
2279         codec->chroma_sample_location = icodec->chroma_sample_location;
2280
2281         if (ost->stream_copy) {
2282             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2283
2284             if (extra_size > INT_MAX) {
2285                 return AVERROR(EINVAL);
2286             }
2287
2288             /* if stream_copy is selected, no need to decode or encode */
2289             codec->codec_id   = icodec->codec_id;
2290             codec->codec_type = icodec->codec_type;
2291
2292             if (!codec->codec_tag) {
2293                 if (!oc->oformat->codec_tag ||
2294                      av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2295                      av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2296                     codec->codec_tag = icodec->codec_tag;
2297             }
2298
2299             codec->bit_rate       = icodec->bit_rate;
2300             codec->rc_max_rate    = icodec->rc_max_rate;
2301             codec->rc_buffer_size = icodec->rc_buffer_size;
2302             codec->field_order    = icodec->field_order;
2303             codec->extradata      = av_mallocz(extra_size);
2304             if (!codec->extradata) {
2305                 return AVERROR(ENOMEM);
2306             }
2307             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2308             codec->extradata_size = icodec->extradata_size;
2309             if (!copy_tb) {
2310                 codec->time_base      = icodec->time_base;
2311                 codec->time_base.num *= icodec->ticks_per_frame;
2312                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2313                           codec->time_base.num, codec->time_base.den, INT_MAX);
2314             } else
2315                 codec->time_base = ist->st->time_base;
2316
2317             switch (codec->codec_type) {
2318             case AVMEDIA_TYPE_AUDIO:
2319                 if (audio_volume != 256) {
2320                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2321                     exit_program(1);
2322                 }
2323                 codec->channel_layout     = icodec->channel_layout;
2324                 codec->sample_rate        = icodec->sample_rate;
2325                 codec->channels           = icodec->channels;
2326                 codec->frame_size         = icodec->frame_size;
2327                 codec->audio_service_type = icodec->audio_service_type;
2328                 codec->block_align        = icodec->block_align;
2329                 break;
2330             case AVMEDIA_TYPE_VIDEO:
2331                 codec->pix_fmt            = icodec->pix_fmt;
2332                 codec->width              = icodec->width;
2333                 codec->height             = icodec->height;
2334                 codec->has_b_frames       = icodec->has_b_frames;
2335                 if (!codec->sample_aspect_ratio.num) {
2336                     codec->sample_aspect_ratio   =
2337                     ost->st->sample_aspect_ratio =
2338                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2339                         ist->st->codec->sample_aspect_ratio.num ?
2340                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2341                 }
2342                 break;
2343             case AVMEDIA_TYPE_SUBTITLE:
2344                 codec->width  = icodec->width;
2345                 codec->height = icodec->height;
2346                 break;
2347             case AVMEDIA_TYPE_DATA:
2348             case AVMEDIA_TYPE_ATTACHMENT:
2349                 break;
2350             default:
2351                 abort();
2352             }
2353         } else {
2354             if (!ost->enc)
2355                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2356
2357             ist->decoding_needed = 1;
2358             ost->encoding_needed = 1;
2359
2360             switch (codec->codec_type) {
2361             case AVMEDIA_TYPE_AUDIO:
2362                 ost->fifo = av_fifo_alloc(1024);
2363                 if (!ost->fifo) {
2364                     return AVERROR(ENOMEM);
2365                 }
2366                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2367
2368                 if (!codec->sample_rate)
2369                     codec->sample_rate = icodec->sample_rate;
2370                 choose_sample_rate(ost->st, ost->enc);
2371                 codec->time_base = (AVRational){ 1, codec->sample_rate };
2372
2373                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2374                     codec->sample_fmt = icodec->sample_fmt;
2375                 choose_sample_fmt(ost->st, ost->enc);
2376
2377                 if (!codec->channels)
2378                     codec->channels = icodec->channels;
2379                 codec->channel_layout = icodec->channel_layout;
2380                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2381                     codec->channel_layout = 0;
2382
2383                 ost->audio_resample       = codec-> sample_rate != icodec->sample_rate || audio_sync_method > 1;
2384                 icodec->request_channels  = codec-> channels;
2385                 ost->resample_sample_fmt  = icodec->sample_fmt;
2386                 ost->resample_sample_rate = icodec->sample_rate;
2387                 ost->resample_channels    = icodec->channels;
2388                 break;
2389             case AVMEDIA_TYPE_VIDEO:
2390                 if (!codec->width || !codec->height) {
2391                     codec->width  = icodec->width;
2392                     codec->height = icodec->height;
2393                 }
2394
2395                 /*
2396                  * We want CFR output if and only if one of those is true:
2397                  * 1) user specified output framerate with -r
2398                  * 2) user specified -vsync cfr
2399                  * 3) output format is CFR and the user didn't force vsync to
2400                  *    something else than CFR
2401                  *
2402                  * in such a case, set ost->frame_rate
2403                  */
2404                 if (!ost->frame_rate.num &&
2405                     (video_sync_method ==  VSYNC_CFR ||
2406                      (video_sync_method ==  VSYNC_AUTO &&
2407                       !(oc->oformat->flags & (AVFMT_NOTIMESTAMPS | AVFMT_VARIABLE_FPS))))) {
2408                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
2409                     if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2410                         int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2411                         ost->frame_rate = ost->enc->supported_framerates[idx];
2412                     }
2413                 }
2414                 if (ost->frame_rate.num) {
2415                     codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2416                     video_sync_method = VSYNC_CFR;
2417                 } else
2418                     codec->time_base = ist->st->time_base;
2419
2420                 if (configure_video_filters(ist, ost)) {
2421                     av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2422                     exit(1);
2423                 }
2424
2425                 ost->video_resample = codec->width   != icodec->width  ||
2426                                       codec->height  != icodec->height ||
2427                                       codec->pix_fmt != icodec->pix_fmt;
2428                 if (ost->video_resample) {
2429                     codec->bits_per_raw_sample = 0;
2430                 }
2431
2432                 ost->resample_height  = icodec->height;
2433                 ost->resample_width   = icodec->width;
2434                 ost->resample_pix_fmt = icodec->pix_fmt;
2435
2436                 break;
2437             case AVMEDIA_TYPE_SUBTITLE:
2438                 codec->time_base = (AVRational){1, 1000};
2439                 break;
2440             default:
2441                 abort();
2442                 break;
2443             }
2444             /* two pass mode */
2445             if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2446                 char logfilename[1024];
2447                 FILE *f;
2448
2449                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2450                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2451                          i);
2452                 if (!strcmp(ost->enc->name, "libx264")) {
2453                     av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
2454                 } else {
2455                     if (codec->flags & CODEC_FLAG_PASS1) {
2456                         f = fopen(logfilename, "wb");
2457                         if (!f) {
2458                             av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2459                                    logfilename, strerror(errno));
2460                             exit_program(1);
2461                         }
2462                         ost->logfile = f;
2463                     } else {
2464                         char  *logbuffer;
2465                         size_t logbuffer_size;
2466                         if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2467                             av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2468                                    logfilename);
2469                             exit_program(1);
2470                         }
2471                         codec->stats_in = logbuffer;
2472                     }
2473                 }
2474             }
2475         }
2476     }
2477
2478     /* open each encoder */
2479     for (i = 0; i < nb_output_streams; i++) {
2480         ost = output_streams[i];
2481         if (ost->encoding_needed) {
2482             AVCodec      *codec = ost->enc;
2483             AVCodecContext *dec = input_streams[ost->source_index]->st->codec;
2484             if (!codec) {
2485                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d:%d",
2486                          ost->st->codec->codec_id, ost->file_index, ost->index);
2487                 ret = AVERROR(EINVAL);
2488                 goto dump_format;
2489             }
2490             if (dec->subtitle_header) {
2491                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2492                 if (!ost->st->codec->subtitle_header) {
2493                     ret = AVERROR(ENOMEM);
2494                     goto dump_format;
2495                 }
2496                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2497                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2498             }
2499             if (!av_dict_get(ost->opts, "threads", NULL, 0))
2500                 av_dict_set(&ost->opts, "threads", "auto", 0);
2501             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2502                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2503                         ost->file_index, ost->index);
2504                 ret = AVERROR(EINVAL);
2505                 goto dump_format;
2506             }
2507             assert_codec_experimental(ost->st->codec, 1);
2508             assert_avoptions(ost->opts);
2509             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2510                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2511                                              "It takes bits/s as argument, not kbits/s\n");
2512             extra_size += ost->st->codec->extradata_size;
2513
2514             if (ost->st->codec->me_threshold)
2515                 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
2516         }
2517     }
2518
2519     /* init input streams */
2520     for (i = 0; i < nb_input_streams; i++)
2521         if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
2522             goto dump_format;
2523
2524     /* discard unused programs */
2525     for (i = 0; i < nb_input_files; i++) {
2526         InputFile *ifile = input_files[i];
2527         for (j = 0; j < ifile->ctx->nb_programs; j++) {
2528             AVProgram *p = ifile->ctx->programs[j];
2529             int discard  = AVDISCARD_ALL;
2530
2531             for (k = 0; k < p->nb_stream_indexes; k++)
2532                 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
2533                     discard = AVDISCARD_DEFAULT;
2534                     break;
2535                 }
2536             p->discard = discard;
2537         }
2538     }
2539
2540     /* open files and write file headers */
2541     for (i = 0; i < nb_output_files; i++) {
2542         oc = output_files[i]->ctx;
2543         oc->interrupt_callback = int_cb;
2544         if (avformat_write_header(oc, &output_files[i]->opts) < 0) {
2545             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2546             ret = AVERROR(EINVAL);
2547             goto dump_format;
2548         }
2549         assert_avoptions(output_files[i]->opts);
2550         if (strcmp(oc->oformat->name, "rtp")) {
2551             want_sdp = 0;
2552         }
2553     }
2554
2555  dump_format:
2556     /* dump the file output parameters - cannot be done before in case
2557        of stream copy */
2558     for (i = 0; i < nb_output_files; i++) {
2559         av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
2560     }
2561
2562     /* dump the stream mapping */
2563     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2564     for (i = 0; i < nb_output_streams; i++) {
2565         ost = output_streams[i];
2566
2567         if (ost->attachment_filename) {
2568             /* an attached file */
2569             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
2570                    ost->attachment_filename, ost->file_index, ost->index);
2571             continue;
2572         }
2573         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
2574                input_streams[ost->source_index]->file_index,
2575                input_streams[ost->source_index]->st->index,
2576                ost->file_index,
2577                ost->index);
2578         if (ost->sync_ist != input_streams[ost->source_index])
2579             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2580                    ost->sync_ist->file_index,
2581                    ost->sync_ist->st->index);
2582         if (ost->stream_copy)
2583             av_log(NULL, AV_LOG_INFO, " (copy)");
2584         else
2585             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
2586                    input_streams[ost->source_index]->dec->name : "?",
2587                    ost->enc ? ost->enc->name : "?");
2588         av_log(NULL, AV_LOG_INFO, "\n");
2589     }
2590
2591     if (ret) {
2592         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2593         return ret;
2594     }
2595
2596     if (want_sdp) {
2597         print_sdp();
2598     }
2599
2600     return 0;
2601 }
2602
2603 /*
2604  * The following code is the main loop of the file converter
2605  */
2606 static int transcode(void)
2607 {
2608     int ret, i;
2609     AVFormatContext *is, *os;
2610     OutputStream *ost;
2611     InputStream *ist;
2612     uint8_t *no_packet;
2613     int no_packet_count = 0;
2614     int64_t timer_start;
2615
2616     if (!(no_packet = av_mallocz(nb_input_files)))
2617         exit_program(1);
2618
2619     ret = transcode_init();
2620     if (ret < 0)
2621         goto fail;
2622
2623     av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2624     term_init();
2625
2626     timer_start = av_gettime();
2627
2628     for (; received_sigterm == 0;) {
2629         int file_index, ist_index;
2630         AVPacket pkt;
2631         int64_t ipts_min;
2632         double opts_min;
2633
2634         ipts_min = INT64_MAX;
2635         opts_min = 1e100;
2636
2637         /* select the stream that we must read now by looking at the
2638            smallest output pts */
2639         file_index = -1;
2640         for (i = 0; i < nb_output_streams; i++) {
2641             OutputFile *of;
2642             int64_t ipts;
2643             double  opts;
2644             ost = output_streams[i];
2645             of = output_files[ost->file_index];
2646             os = output_files[ost->file_index]->ctx;
2647             ist = input_streams[ost->source_index];
2648             if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2649                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2650                 continue;
2651             opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2652             ipts = ist->last_dts;
2653             if (!input_files[ist->file_index]->eof_reached) {
2654                 if (ipts < ipts_min) {
2655                     ipts_min = ipts;
2656                     if (input_sync)
2657                         file_index = ist->file_index;
2658                 }
2659                 if (opts < opts_min) {
2660                     opts_min = opts;
2661                     if (!input_sync) file_index = ist->file_index;
2662                 }
2663             }
2664             if (ost->frame_number >= ost->max_frames) {
2665                 int j;
2666                 for (j = 0; j < of->ctx->nb_streams; j++)
2667                     output_streams[of->ost_index + j]->is_past_recording_time = 1;
2668                 continue;
2669             }
2670         }
2671         /* if none, if is finished */
2672         if (file_index < 0) {
2673             if (no_packet_count) {
2674                 no_packet_count = 0;
2675                 memset(no_packet, 0, nb_input_files);
2676                 usleep(10000);
2677                 continue;
2678             }
2679             break;
2680         }
2681
2682         /* read a frame from it and output it in the fifo */
2683         is  = input_files[file_index]->ctx;
2684         ret = av_read_frame(is, &pkt);
2685         if (ret == AVERROR(EAGAIN)) {
2686             no_packet[file_index] = 1;
2687             no_packet_count++;
2688             continue;
2689         }
2690         if (ret < 0) {
2691             input_files[file_index]->eof_reached = 1;
2692             if (opt_shortest)
2693                 break;
2694             else
2695                 continue;
2696         }
2697
2698         no_packet_count = 0;
2699         memset(no_packet, 0, nb_input_files);
2700
2701         if (do_pkt_dump) {
2702             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2703                              is->streams[pkt.stream_index]);
2704         }
2705         /* the following test is needed in case new streams appear
2706            dynamically in stream : we ignore them */
2707         if (pkt.stream_index >= input_files[file_index]->nb_streams)
2708             goto discard_packet;
2709         ist_index = input_files[file_index]->ist_index + pkt.stream_index;
2710         ist = input_streams[ist_index];
2711         if (ist->discard)
2712             goto discard_packet;
2713
2714         if (pkt.dts != AV_NOPTS_VALUE)
2715             pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2716         if (pkt.pts != AV_NOPTS_VALUE)
2717             pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2718
2719         if (pkt.pts != AV_NOPTS_VALUE)
2720             pkt.pts *= ist->ts_scale;
2721         if (pkt.dts != AV_NOPTS_VALUE)
2722             pkt.dts *= ist->ts_scale;
2723
2724         //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
2725         //        ist->next_dts,
2726         //        pkt.dts, input_files[ist->file_index].ts_offset,
2727         //        ist->st->codec->codec_type);
2728         if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE
2729             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2730             int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2731             int64_t delta   = pkt_dts - ist->next_dts;
2732             if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->last_dts) && !copy_ts) {
2733                 input_files[ist->file_index]->ts_offset -= delta;
2734                 av_log(NULL, AV_LOG_DEBUG,
2735                        "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2736                        delta, input_files[ist->file_index]->ts_offset);
2737                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2738                 if (pkt.pts != AV_NOPTS_VALUE)
2739                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2740             }
2741         }
2742
2743         // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2744         if (output_packet(ist, &pkt) < 0) {
2745
2746             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2747                    ist->file_index, ist->st->index);
2748             if (exit_on_error)
2749                 exit_program(1);
2750             av_free_packet(&pkt);
2751             continue;
2752         }
2753
2754     discard_packet:
2755         av_free_packet(&pkt);
2756
2757         /* dump report by using the output first video and audio streams */
2758         print_report(0, timer_start);
2759     }
2760
2761     /* at the end of stream, we must flush the decoder buffers */
2762     for (i = 0; i < nb_input_streams; i++) {
2763         ist = input_streams[i];
2764         if (ist->decoding_needed) {
2765             output_packet(ist, NULL);
2766         }
2767     }
2768     flush_encoders();
2769
2770     term_exit();
2771
2772     /* write the trailer if needed and close file */
2773     for (i = 0; i < nb_output_files; i++) {
2774         os = output_files[i]->ctx;
2775         av_write_trailer(os);
2776     }
2777
2778     /* dump report by using the first video and audio streams */
2779     print_report(1, timer_start);
2780
2781     /* close each encoder */
2782     for (i = 0; i < nb_output_streams; i++) {
2783         ost = output_streams[i];
2784         if (ost->encoding_needed) {
2785             av_freep(&ost->st->codec->stats_in);
2786             avcodec_close(ost->st->codec);
2787         }
2788         avfilter_graph_free(&ost->graph);
2789     }
2790
2791     /* close each decoder */
2792     for (i = 0; i < nb_input_streams; i++) {
2793         ist = input_streams[i];
2794         if (ist->decoding_needed) {
2795             avcodec_close(ist->st->codec);
2796         }
2797     }
2798
2799     /* finished ! */
2800     ret = 0;
2801
2802  fail:
2803     av_freep(&no_packet);
2804
2805     if (output_streams) {
2806         for (i = 0; i < nb_output_streams; i++) {
2807             ost = output_streams[i];
2808             if (ost) {
2809                 if (ost->stream_copy)
2810                     av_freep(&ost->st->codec->extradata);
2811                 if (ost->logfile) {
2812                     fclose(ost->logfile);
2813                     ost->logfile = NULL;
2814                 }
2815                 av_fifo_free(ost->fifo); /* works even if fifo is not
2816                                              initialized but set to zero */
2817                 av_freep(&ost->st->codec->subtitle_header);
2818                 av_free(ost->forced_kf_pts);
2819                 if (ost->resample)
2820                     audio_resample_close(ost->resample);
2821                 if (ost->reformat_ctx)
2822                     av_audio_convert_free(ost->reformat_ctx);
2823                 av_dict_free(&ost->opts);
2824             }
2825         }
2826     }
2827     return ret;
2828 }
2829
2830 static double parse_frame_aspect_ratio(const char *arg)
2831 {
2832     int x = 0, y = 0;
2833     double ar = 0;
2834     const char *p;
2835     char *end;
2836
2837     p = strchr(arg, ':');
2838     if (p) {
2839         x = strtol(arg, &end, 10);
2840         if (end == p)
2841             y = strtol(end + 1, &end, 10);
2842         if (x > 0 && y > 0)
2843             ar = (double)x / (double)y;
2844     } else
2845         ar = strtod(arg, NULL);
2846
2847     if (!ar) {
2848         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2849         exit_program(1);
2850     }
2851     return ar;
2852 }
2853
2854 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2855 {
2856     return parse_option(o, "codec:a", arg, options);
2857 }
2858
2859 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2860 {
2861     return parse_option(o, "codec:v", arg, options);
2862 }
2863
2864 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2865 {
2866     return parse_option(o, "codec:s", arg, options);
2867 }
2868
2869 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2870 {
2871     return parse_option(o, "codec:d", arg, options);
2872 }
2873
2874 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2875 {
2876     StreamMap *m = NULL;
2877     int i, negative = 0, file_idx;
2878     int sync_file_idx = -1, sync_stream_idx;
2879     char *p, *sync;
2880     char *map;
2881
2882     if (*arg == '-') {
2883         negative = 1;
2884         arg++;
2885     }
2886     map = av_strdup(arg);
2887
2888     /* parse sync stream first, just pick first matching stream */
2889     if (sync = strchr(map, ',')) {
2890         *sync = 0;
2891         sync_file_idx = strtol(sync + 1, &sync, 0);
2892         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2893             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2894             exit_program(1);
2895         }
2896         if (*sync)
2897             sync++;
2898         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
2899             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
2900                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
2901                 sync_stream_idx = i;
2902                 break;
2903             }
2904         if (i == input_files[sync_file_idx]->nb_streams) {
2905             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2906                                        "match any streams.\n", arg);
2907             exit_program(1);
2908         }
2909     }
2910
2911
2912     file_idx = strtol(map, &p, 0);
2913     if (file_idx >= nb_input_files || file_idx < 0) {
2914         av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2915         exit_program(1);
2916     }
2917     if (negative)
2918         /* disable some already defined maps */
2919         for (i = 0; i < o->nb_stream_maps; i++) {
2920             m = &o->stream_maps[i];
2921             if (file_idx == m->file_index &&
2922                 check_stream_specifier(input_files[m->file_index]->ctx,
2923                                        input_files[m->file_index]->ctx->streams[m->stream_index],
2924                                        *p == ':' ? p + 1 : p) > 0)
2925                 m->disabled = 1;
2926         }
2927     else
2928         for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
2929             if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
2930                         *p == ':' ? p + 1 : p) <= 0)
2931                 continue;
2932             o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2933                                         &o->nb_stream_maps, o->nb_stream_maps + 1);
2934             m = &o->stream_maps[o->nb_stream_maps - 1];
2935
2936             m->file_index   = file_idx;
2937             m->stream_index = i;
2938
2939             if (sync_file_idx >= 0) {
2940                 m->sync_file_index   = sync_file_idx;
2941                 m->sync_stream_index = sync_stream_idx;
2942             } else {
2943                 m->sync_file_index   = file_idx;
2944                 m->sync_stream_index = i;
2945             }
2946         }
2947
2948     if (!m) {
2949         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2950         exit_program(1);
2951     }
2952
2953     av_freep(&map);
2954     return 0;
2955 }
2956
2957 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
2958 {
2959     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
2960                                 &o->nb_attachments, o->nb_attachments + 1);
2961     o->attachments[o->nb_attachments - 1] = arg;
2962     return 0;
2963 }
2964
2965 /**
2966  * Parse a metadata specifier in arg.
2967  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
2968  * @param index for type c/p, chapter/program index is written here
2969  * @param stream_spec for type s, the stream specifier is written here
2970  */
2971 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
2972 {
2973     if (*arg) {
2974         *type = *arg;
2975         switch (*arg) {
2976         case 'g':
2977             break;
2978         case 's':
2979             if (*(++arg) && *arg != ':') {
2980                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
2981                 exit_program(1);
2982             }
2983             *stream_spec = *arg == ':' ? arg + 1 : "";
2984             break;
2985         case 'c':
2986         case 'p':
2987             if (*(++arg) == ':')
2988                 *index = strtol(++arg, NULL, 0);
2989             break;
2990         default:
2991             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2992             exit_program(1);
2993         }
2994     } else
2995         *type = 'g';
2996 }
2997
2998 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
2999 {
3000     AVDictionary **meta_in = NULL;
3001     AVDictionary **meta_out;
3002     int i, ret = 0;
3003     char type_in, type_out;
3004     const char *istream_spec = NULL, *ostream_spec = NULL;
3005     int idx_in = 0, idx_out = 0;
3006
3007     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
3008     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3009
3010     if (type_in == 'g' || type_out == 'g')
3011         o->metadata_global_manual = 1;
3012     if (type_in == 's' || type_out == 's')
3013         o->metadata_streams_manual = 1;
3014     if (type_in == 'c' || type_out == 'c')
3015         o->metadata_chapters_manual = 1;
3016
3017 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3018     if ((index) < 0 || (index) >= (nb_elems)) {\
3019         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3020                 (desc), (index));\
3021         exit_program(1);\
3022     }
3023
3024 #define SET_DICT(type, meta, context, index)\
3025         switch (type) {\
3026         case 'g':\
3027             meta = &context->metadata;\
3028             break;\
3029         case 'c':\
3030             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3031             meta = &context->chapters[index]->metadata;\
3032             break;\
3033         case 'p':\
3034             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3035             meta = &context->programs[index]->metadata;\
3036             break;\
3037         }\
3038
3039     SET_DICT(type_in, meta_in, ic, idx_in);
3040     SET_DICT(type_out, meta_out, oc, idx_out);
3041
3042     /* for input streams choose first matching stream */
3043     if (type_in == 's') {
3044         for (i = 0; i < ic->nb_streams; i++) {
3045             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3046                 meta_in = &ic->streams[i]->metadata;
3047                 break;
3048             } else if (ret < 0)
3049                 exit_program(1);
3050         }
3051         if (!meta_in) {
3052             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
3053             exit_program(1);
3054         }
3055     }
3056
3057     if (type_out == 's') {
3058         for (i = 0; i < oc->nb_streams; i++) {
3059             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3060                 meta_out = &oc->streams[i]->metadata;
3061                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3062             } else if (ret < 0)
3063                 exit_program(1);
3064         }
3065     } else
3066         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3067
3068     return 0;
3069 }
3070
3071 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3072 {
3073     const char *codec_string = encoder ? "encoder" : "decoder";
3074     AVCodec *codec;
3075
3076     codec = encoder ?
3077         avcodec_find_encoder_by_name(name) :
3078         avcodec_find_decoder_by_name(name);
3079     if (!codec) {
3080         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3081         exit_program(1);
3082     }
3083     if (codec->type != type) {
3084         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3085         exit_program(1);
3086     }
3087     return codec;
3088 }
3089
3090 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3091 {
3092     char *codec_name = NULL;
3093
3094     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3095     if (codec_name) {
3096         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3097         st->codec->codec_id = codec->id;
3098         return codec;
3099     } else
3100         return avcodec_find_decoder(st->codec->codec_id);
3101 }
3102
3103 /**
3104  * Add all the streams from the given input file to the global
3105  * list of input streams.
3106  */
3107 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3108 {
3109     int i;
3110
3111     for (i = 0; i < ic->nb_streams; i++) {
3112         AVStream *st = ic->streams[i];
3113         AVCodecContext *dec = st->codec;
3114         InputStream *ist = av_mallocz(sizeof(*ist));
3115
3116         if (!ist)
3117             exit_program(1);
3118
3119         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3120         input_streams[nb_input_streams - 1] = ist;
3121
3122         ist->st = st;
3123         ist->file_index = nb_input_files;
3124         ist->discard = 1;
3125         st->discard  = AVDISCARD_ALL;
3126         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3127
3128         ist->ts_scale = 1.0;
3129         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3130
3131         ist->dec = choose_decoder(o, ic, st);
3132
3133         switch (dec->codec_type) {
3134         case AVMEDIA_TYPE_VIDEO:
3135             if (dec->lowres) {
3136                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3137                 dec->height >>= dec->lowres;
3138                 dec->width  >>= dec->lowres;
3139             }
3140
3141             break;
3142         case AVMEDIA_TYPE_AUDIO:
3143         case AVMEDIA_TYPE_DATA:
3144         case AVMEDIA_TYPE_SUBTITLE:
3145         case AVMEDIA_TYPE_ATTACHMENT:
3146         case AVMEDIA_TYPE_UNKNOWN:
3147             break;
3148         default:
3149             abort();
3150         }
3151     }
3152 }
3153
3154 static void assert_file_overwrite(const char *filename)
3155 {
3156     if (!file_overwrite &&
3157         (strchr(filename, ':') == NULL || filename[1] == ':' ||
3158          av_strstart(filename, "file:", NULL))) {
3159         if (avio_check(filename, 0) == 0) {
3160             if (!using_stdin) {
3161                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3162                 fflush(stderr);
3163                 if (!read_yesno()) {
3164                     fprintf(stderr, "Not overwriting - exiting\n");
3165                     exit_program(1);
3166                 }
3167             }
3168             else {
3169                 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3170                 exit_program(1);
3171             }
3172         }
3173     }
3174 }
3175
3176 static void dump_attachment(AVStream *st, const char *filename)
3177 {
3178     int ret;
3179     AVIOContext *out = NULL;
3180     AVDictionaryEntry *e;
3181
3182     if (!st->codec->extradata_size) {
3183         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3184                nb_input_files - 1, st->index);
3185         return;
3186     }
3187     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3188         filename = e->value;
3189     if (!*filename) {
3190         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3191                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3192         exit_program(1);
3193     }
3194
3195     assert_file_overwrite(filename);
3196
3197     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3198         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3199                filename);
3200         exit_program(1);
3201     }
3202
3203     avio_write(out, st->codec->extradata, st->codec->extradata_size);
3204     avio_flush(out);
3205     avio_close(out);
3206 }
3207
3208 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3209 {
3210     AVFormatContext *ic;
3211     AVInputFormat *file_iformat = NULL;
3212     int err, i, ret;
3213     int64_t timestamp;
3214     uint8_t buf[128];
3215     AVDictionary **opts;
3216     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3217
3218     if (o->format) {
3219         if (!(file_iformat = av_find_input_format(o->format))) {
3220             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3221             exit_program(1);
3222         }
3223     }
3224
3225     if (!strcmp(filename, "-"))
3226         filename = "pipe:";
3227
3228     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3229                     !strcmp(filename, "/dev/stdin");
3230
3231     /* get default parameters from command line */
3232     ic = avformat_alloc_context();
3233     if (!ic) {
3234         print_error(filename, AVERROR(ENOMEM));
3235         exit_program(1);
3236     }
3237     if (o->nb_audio_sample_rate) {
3238         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3239         av_dict_set(&format_opts, "sample_rate", buf, 0);
3240     }
3241     if (o->nb_audio_channels) {
3242         snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3243         av_dict_set(&format_opts, "channels", buf, 0);
3244     }
3245     if (o->nb_frame_rates) {
3246         av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3247     }
3248     if (o->nb_frame_sizes) {
3249         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3250     }
3251     if (o->nb_frame_pix_fmts)
3252         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3253
3254     ic->flags |= AVFMT_FLAG_NONBLOCK;
3255     ic->interrupt_callback = int_cb;
3256
3257     /* open the input file with generic libav function */
3258     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3259     if (err < 0) {
3260         print_error(filename, err);
3261         exit_program(1);
3262     }
3263     assert_avoptions(format_opts);
3264
3265     /* apply forced codec ids */
3266     for (i = 0; i < ic->nb_streams; i++)
3267         choose_decoder(o, ic, ic->streams[i]);
3268
3269     /* Set AVCodecContext options for avformat_find_stream_info */
3270     opts = setup_find_stream_info_opts(ic, codec_opts);
3271     orig_nb_streams = ic->nb_streams;
3272
3273     /* If not enough info to get the stream parameters, we decode the
3274        first frames to get it. (used in mpeg case for example) */
3275     ret = avformat_find_stream_info(ic, opts);
3276     if (ret < 0) {
3277         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3278         avformat_close_input(&ic);
3279         exit_program(1);
3280     }
3281
3282     timestamp = o->start_time;
3283     /* add the stream start time */
3284     if (ic->start_time != AV_NOPTS_VALUE)
3285         timestamp += ic->start_time;
3286
3287     /* if seeking requested, we execute it */
3288     if (o->start_time != 0) {
3289         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3290         if (ret < 0) {
3291             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3292                    filename, (double)timestamp / AV_TIME_BASE);
3293         }
3294     }
3295
3296     /* update the current parameters so that they match the one of the input stream */
3297     add_input_streams(o, ic);
3298
3299     /* dump the file content */
3300     av_dump_format(ic, nb_input_files, filename, 0);
3301
3302     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3303     if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
3304         exit_program(1);
3305
3306     input_files[nb_input_files - 1]->ctx        = ic;
3307     input_files[nb_input_files - 1]->ist_index  = nb_input_streams - ic->nb_streams;
3308     input_files[nb_input_files - 1]->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3309     input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
3310     input_files[nb_input_files - 1]->rate_emu   = o->rate_emu;
3311
3312     for (i = 0; i < o->nb_dump_attachment; i++) {
3313         int j;
3314
3315         for (j = 0; j < ic->nb_streams; j++) {
3316             AVStream *st = ic->streams[j];
3317
3318             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3319                 dump_attachment(st, o->dump_attachment[i].u.str);
3320         }
3321     }
3322
3323     for (i = 0; i < orig_nb_streams; i++)
3324         av_dict_free(&opts[i]);
3325     av_freep(&opts);
3326
3327     reset_options(o);
3328     return 0;
3329 }
3330
3331 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3332                                     AVCodecContext *avctx)
3333 {
3334     char *p;
3335     int n = 1, i;
3336     int64_t t;
3337
3338     for (p = kf; *p; p++)
3339         if (*p == ',')
3340             n++;
3341     ost->forced_kf_count = n;
3342     ost->forced_kf_pts   = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3343     if (!ost->forced_kf_pts) {
3344         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3345         exit_program(1);
3346     }
3347     for (i = 0; i < n; i++) {
3348         p = i ? strchr(p, ',') + 1 : kf;
3349         t = parse_time_or_die("force_key_frames", p, 1);
3350         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3351     }
3352 }
3353
3354 static uint8_t *get_line(AVIOContext *s)
3355 {
3356     AVIOContext *line;
3357     uint8_t *buf;
3358     char c;
3359
3360     if (avio_open_dyn_buf(&line) < 0) {
3361         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3362         exit_program(1);
3363     }
3364
3365     while ((c = avio_r8(s)) && c != '\n')
3366         avio_w8(line, c);
3367     avio_w8(line, 0);
3368     avio_close_dyn_buf(line, &buf);
3369
3370     return buf;
3371 }
3372
3373 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3374 {
3375     int i, ret = 1;
3376     char filename[1000];
3377     const char *base[3] = { getenv("AVCONV_DATADIR"),
3378                             getenv("HOME"),
3379                             AVCONV_DATADIR,
3380                             };
3381
3382     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3383         if (!base[i])
3384             continue;
3385         if (codec_name) {
3386             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3387                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
3388             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3389         }
3390         if (ret) {
3391             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3392                      i != 1 ? "" : "/.avconv", preset_name);
3393             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3394         }
3395     }
3396     return ret;
3397 }
3398
3399 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3400 {
3401     char *codec_name = NULL;
3402
3403     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3404     if (!codec_name) {
3405         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3406                                                   NULL, ost->st->codec->codec_type);
3407         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3408     } else if (!strcmp(codec_name, "copy"))
3409         ost->stream_copy = 1;
3410     else {
3411         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3412         ost->st->codec->codec_id = ost->enc->id;
3413     }
3414 }
3415
3416 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3417 {
3418     OutputStream *ost;
3419     AVStream *st = avformat_new_stream(oc, NULL);
3420     int idx      = oc->nb_streams - 1, ret = 0;
3421     char *bsf = NULL, *next, *codec_tag = NULL;
3422     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3423     double qscale = -1;
3424     char *buf = NULL, *arg = NULL, *preset = NULL;
3425     AVIOContext *s = NULL;
3426
3427     if (!st) {
3428         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3429         exit_program(1);
3430     }
3431
3432     if (oc->nb_streams - 1 < o->nb_streamid_map)
3433         st->id = o->streamid_map[oc->nb_streams - 1];
3434
3435     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3436                                 nb_output_streams + 1);
3437     if (!(ost = av_mallocz(sizeof(*ost))))
3438         exit_program(1);
3439     output_streams[nb_output_streams - 1] = ost;
3440
3441     ost->file_index = nb_output_files;
3442     ost->index      = idx;
3443     ost->st         = st;
3444     st->codec->codec_type = type;
3445     choose_encoder(o, oc, ost);
3446     if (ost->enc) {
3447         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3448     }
3449
3450     avcodec_get_context_defaults3(st->codec, ost->enc);
3451     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3452
3453     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3454     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3455         do  {
3456             buf = get_line(s);
3457             if (!buf[0] || buf[0] == '#') {
3458                 av_free(buf);
3459                 continue;
3460             }
3461             if (!(arg = strchr(buf, '='))) {
3462                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3463                 exit_program(1);
3464             }
3465             *arg++ = 0;
3466             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3467             av_free(buf);
3468         } while (!s->eof_reached);
3469         avio_close(s);
3470     }
3471     if (ret) {
3472         av_log(NULL, AV_LOG_FATAL,
3473                "Preset %s specified for stream %d:%d, but could not be opened.\n",
3474                preset, ost->file_index, ost->index);
3475         exit_program(1);
3476     }
3477
3478     ost->max_frames = INT64_MAX;
3479     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3480
3481     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3482     while (bsf) {
3483         if (next = strchr(bsf, ','))
3484             *next++ = 0;
3485         if (!(bsfc = av_bitstream_filter_init(bsf))) {
3486             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3487             exit_program(1);
3488         }
3489         if (bsfc_prev)
3490             bsfc_prev->next = bsfc;
3491         else
3492             ost->bitstream_filters = bsfc;
3493
3494         bsfc_prev = bsfc;
3495         bsf       = next;
3496     }
3497
3498     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3499     if (codec_tag) {
3500         uint32_t tag = strtol(codec_tag, &next, 0);
3501         if (*next)
3502             tag = AV_RL32(codec_tag);
3503         st->codec->codec_tag = tag;
3504     }
3505
3506     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3507     if (qscale >= 0 || same_quant) {
3508         st->codec->flags |= CODEC_FLAG_QSCALE;
3509         st->codec->global_quality = FF_QP2LAMBDA * qscale;
3510     }
3511
3512     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3513         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3514
3515     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3516
3517     ost->pix_fmts[0] = ost->pix_fmts[1] = PIX_FMT_NONE;
3518
3519     return ost;
3520 }
3521
3522 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3523 {
3524     int i;
3525     const char *p = str;
3526     for (i = 0;; i++) {
3527         dest[i] = atoi(p);
3528         if (i == 63)
3529             break;
3530         p = strchr(p, ',');
3531         if (!p) {
3532             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3533             exit_program(1);
3534         }
3535         p++;
3536     }
3537 }
3538
3539 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3540 {
3541     AVStream *st;
3542     OutputStream *ost;
3543     AVCodecContext *video_enc;
3544
3545     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3546     st  = ost->st;
3547     video_enc = st->codec;
3548
3549     if (!ost->stream_copy) {
3550         const char *p = NULL;
3551         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3552         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3553         char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3554         int i;
3555
3556         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3557         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3558             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3559             exit_program(1);
3560         }
3561
3562         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3563         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3564             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3565             exit_program(1);
3566         }
3567
3568         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3569         if (frame_aspect_ratio)
3570             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3571
3572         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3573         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3574             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3575             exit_program(1);
3576         }
3577         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3578
3579         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3580         if (intra_matrix) {
3581             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3582                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3583                 exit_program(1);
3584             }
3585             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3586         }
3587         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3588         if (inter_matrix) {
3589             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3590                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3591                 exit_program(1);
3592             }
3593             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3594         }
3595
3596         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3597         for (i = 0; p; i++) {
3598             int start, end, q;
3599             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
3600             if (e != 3) {
3601                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3602                 exit_program(1);
3603             }
3604             video_enc->rc_override =
3605                 av_realloc(video_enc->rc_override,
3606                            sizeof(RcOverride) * (i + 1));
3607             video_enc->rc_override[i].start_frame = start;
3608             video_enc->rc_override[i].end_frame   = end;
3609             if (q > 0) {
3610                 video_enc->rc_override[i].qscale         = q;
3611                 video_enc->rc_override[i].quality_factor = 1.0;
3612             }
3613             else {
3614                 video_enc->rc_override[i].qscale         = 0;
3615                 video_enc->rc_override[i].quality_factor = -q/100.0;
3616             }
3617             p = strchr(p, '/');
3618             if (p) p++;
3619         }
3620         video_enc->rc_override_count = i;
3621         if (!video_enc->rc_initial_buffer_occupancy)
3622             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
3623         video_enc->intra_dc_precision = intra_dc_precision - 8;
3624
3625         /* two pass mode */
3626         if (do_pass) {
3627             if (do_pass == 1) {
3628                 video_enc->flags |= CODEC_FLAG_PASS1;
3629             } else {
3630                 video_enc->flags |= CODEC_FLAG_PASS2;
3631             }
3632         }
3633
3634         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3635         if (forced_key_frames)
3636             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3637
3638         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3639
3640         ost->top_field_first = -1;
3641         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3642
3643         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3644         if (filters)
3645             ost->avfilter = av_strdup(filters);
3646     } else {
3647         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3648     }
3649
3650     return ost;
3651 }
3652
3653 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3654 {
3655     AVStream *st;
3656     OutputStream *ost;
3657     AVCodecContext *audio_enc;
3658
3659     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3660     st  = ost->st;
3661
3662     audio_enc = st->codec;
3663     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3664
3665     if (!ost->stream_copy) {
3666         char *sample_fmt = NULL;
3667
3668         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3669
3670         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3671         if (sample_fmt &&
3672             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3673             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3674             exit_program(1);
3675         }
3676
3677         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3678     }
3679
3680     return ost;
3681 }
3682
3683 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3684 {
3685     OutputStream *ost;
3686
3687     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3688     if (!ost->stream_copy) {
3689         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3690         exit_program(1);
3691     }
3692
3693     return ost;
3694 }
3695
3696 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3697 {
3698     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3699     ost->stream_copy = 1;
3700     return ost;
3701 }
3702
3703 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3704 {
3705     AVStream *st;
3706     OutputStream *ost;
3707     AVCodecContext *subtitle_enc;
3708
3709     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3710     st  = ost->st;
3711     subtitle_enc = st->codec;
3712
3713     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3714
3715     return ost;
3716 }
3717
3718 /* arg format is "output-stream-index:streamid-value". */
3719 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3720 {
3721     int idx;
3722     char *p;
3723     char idx_str[16];
3724
3725     av_strlcpy(idx_str, arg, sizeof(idx_str));
3726     p = strchr(idx_str, ':');
3727     if (!p) {
3728         av_log(NULL, AV_LOG_FATAL,
3729                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3730                arg, opt);
3731         exit_program(1);
3732     }
3733     *p++ = '\0';
3734     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3735     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3736     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3737     return 0;
3738 }
3739
3740 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3741 {
3742     AVFormatContext *is = ifile->ctx;
3743     AVFormatContext *os = ofile->ctx;
3744     int i;
3745
3746     for (i = 0; i < is->nb_chapters; i++) {
3747         AVChapter *in_ch = is->chapters[i], *out_ch;
3748         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3749                                        AV_TIME_BASE_Q, in_ch->time_base);
3750         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3751                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3752
3753
3754         if (in_ch->end < ts_off)
3755             continue;
3756         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3757             break;
3758
3759         out_ch = av_mallocz(sizeof(AVChapter));
3760         if (!out_ch)
3761             return AVERROR(ENOMEM);
3762
3763         out_ch->id        = in_ch->id;
3764         out_ch->time_base = in_ch->time_base;
3765         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3766         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3767
3768         if (copy_metadata)
3769             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3770
3771         os->nb_chapters++;
3772         os->chapters = av_realloc(os->chapters, sizeof(AVChapter) * os->nb_chapters);
3773         if (!os->chapters)
3774             return AVERROR(ENOMEM);
3775         os->chapters[os->nb_chapters - 1] = out_ch;
3776     }
3777     return 0;
3778 }
3779
3780 static void opt_output_file(void *optctx, const char *filename)
3781 {
3782     OptionsContext *o = optctx;
3783     AVFormatContext *oc;
3784     int i, err;
3785     AVOutputFormat *file_oformat;
3786     OutputStream *ost;
3787     InputStream  *ist;
3788
3789     if (!strcmp(filename, "-"))
3790         filename = "pipe:";
3791
3792     oc = avformat_alloc_context();
3793     if (!oc) {
3794         print_error(filename, AVERROR(ENOMEM));
3795         exit_program(1);
3796     }
3797
3798     if (o->format) {
3799         file_oformat = av_guess_format(o->format, NULL, NULL);
3800         if (!file_oformat) {
3801             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
3802             exit_program(1);
3803         }
3804     } else {
3805         file_oformat = av_guess_format(NULL, filename, NULL);
3806         if (!file_oformat) {
3807             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
3808                    filename);
3809             exit_program(1);
3810         }
3811     }
3812
3813     oc->oformat = file_oformat;
3814     oc->interrupt_callback = int_cb;
3815     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3816
3817     if (!o->nb_stream_maps) {
3818         /* pick the "best" stream of each type */
3819 #define NEW_STREAM(type, index)\
3820         if (index >= 0) {\
3821             ost = new_ ## type ## _stream(o, oc);\
3822             ost->source_index = index;\
3823             ost->sync_ist     = input_streams[index];\
3824             input_streams[index]->discard = 0;\
3825             input_streams[index]->st->discard = AVDISCARD_NONE;\
3826         }
3827
3828         /* video: highest resolution */
3829         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3830             int area = 0, idx = -1;
3831             for (i = 0; i < nb_input_streams; i++) {
3832                 ist = input_streams[i];
3833                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3834                     ist->st->codec->width * ist->st->codec->height > area) {
3835                     area = ist->st->codec->width * ist->st->codec->height;
3836                     idx = i;
3837                 }
3838             }
3839             NEW_STREAM(video, idx);
3840         }
3841
3842         /* audio: most channels */
3843         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3844             int channels = 0, idx = -1;
3845             for (i = 0; i < nb_input_streams; i++) {
3846                 ist = input_streams[i];
3847                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3848                     ist->st->codec->channels > channels) {
3849                     channels = ist->st->codec->channels;
3850                     idx = i;
3851                 }
3852             }
3853             NEW_STREAM(audio, idx);
3854         }
3855
3856         /* subtitles: pick first */
3857         if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3858             for (i = 0; i < nb_input_streams; i++)
3859                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3860                     NEW_STREAM(subtitle, i);
3861                     break;
3862                 }
3863         }
3864         /* do something with data? */
3865     } else {
3866         for (i = 0; i < o->nb_stream_maps; i++) {
3867             StreamMap *map = &o->stream_maps[i];
3868
3869             if (map->disabled)
3870                 continue;
3871
3872             ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
3873             switch (ist->st->codec->codec_type) {
3874             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
3875             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
3876             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3877             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
3878             case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3879             default:
3880                 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
3881                        map->file_index, map->stream_index);
3882                 exit_program(1);
3883             }
3884
3885             ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
3886             ost->sync_ist     = input_streams[input_files[map->sync_file_index]->ist_index +
3887                                            map->sync_stream_index];
3888             ist->discard = 0;
3889             ist->st->discard = AVDISCARD_NONE;
3890         }
3891     }
3892
3893     /* handle attached files */
3894     for (i = 0; i < o->nb_attachments; i++) {
3895         AVIOContext *pb;
3896         uint8_t *attachment;
3897         const char *p;
3898         int64_t len;
3899
3900         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
3901             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
3902                    o->attachments[i]);
3903             exit_program(1);
3904         }
3905         if ((len = avio_size(pb)) <= 0) {
3906             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
3907                    o->attachments[i]);
3908             exit_program(1);
3909         }
3910         if (!(attachment = av_malloc(len))) {
3911             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
3912                    o->attachments[i]);
3913             exit_program(1);
3914         }
3915         avio_read(pb, attachment, len);
3916
3917         ost = new_attachment_stream(o, oc);
3918         ost->stream_copy               = 0;
3919         ost->source_index              = -1;
3920         ost->attachment_filename       = o->attachments[i];
3921         ost->st->codec->extradata      = attachment;
3922         ost->st->codec->extradata_size = len;
3923
3924         p = strrchr(o->attachments[i], '/');
3925         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
3926         avio_close(pb);
3927     }
3928
3929     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3930     if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
3931         exit_program(1);
3932
3933     output_files[nb_output_files - 1]->ctx            = oc;
3934     output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
3935     output_files[nb_output_files - 1]->recording_time = o->recording_time;
3936     if (o->recording_time != INT64_MAX)
3937         oc->duration = o->recording_time;
3938     output_files[nb_output_files - 1]->start_time     = o->start_time;
3939     output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
3940     av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
3941
3942     /* check filename in case of an image number is expected */
3943     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3944         if (!av_filename_number_test(oc->filename)) {
3945             print_error(oc->filename, AVERROR(EINVAL));
3946             exit_program(1);
3947         }
3948     }
3949
3950     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3951         /* test if it already exists to avoid losing precious files */
3952         assert_file_overwrite(filename);
3953
3954         /* open the file */
3955         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
3956                               &oc->interrupt_callback,
3957                               &output_files[nb_output_files - 1]->opts)) < 0) {
3958             print_error(filename, err);
3959             exit_program(1);
3960         }
3961     }
3962
3963     if (o->mux_preload) {
3964         uint8_t buf[64];
3965         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
3966         av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
3967     }
3968     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3969     oc->flags |= AVFMT_FLAG_NONBLOCK;
3970
3971     /* copy metadata */
3972     for (i = 0; i < o->nb_metadata_map; i++) {
3973         char *p;
3974         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
3975
3976         if (in_file_index < 0)
3977             continue;
3978         if (in_file_index >= nb_input_files) {
3979             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
3980             exit_program(1);
3981         }
3982         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index]->ctx, o);
3983     }
3984
3985     /* copy chapters */
3986     if (o->chapters_input_file >= nb_input_files) {
3987         if (o->chapters_input_file == INT_MAX) {
3988             /* copy chapters from the first input file that has them*/
3989             o->chapters_input_file = -1;
3990             for (i = 0; i < nb_input_files; i++)
3991                 if (input_files[i]->ctx->nb_chapters) {
3992                     o->chapters_input_file = i;
3993                     break;
3994                 }
3995         } else {
3996             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3997                    o->chapters_input_file);
3998             exit_program(1);
3999         }
4000     }
4001     if (o->chapters_input_file >= 0)
4002         copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
4003                       !o->metadata_chapters_manual);
4004
4005     /* copy global metadata by default */
4006     if (!o->metadata_global_manual && nb_input_files)
4007         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
4008                      AV_DICT_DONT_OVERWRITE);
4009     if (!o->metadata_streams_manual)
4010         for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
4011             InputStream *ist;
4012             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
4013                 continue;
4014             ist = input_streams[output_streams[i]->source_index];
4015             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4016         }
4017
4018     /* process manually set metadata */
4019     for (i = 0; i < o->nb_metadata; i++) {
4020         AVDictionary **m;
4021         char type, *val;
4022         const char *stream_spec;
4023         int index = 0, j, ret;
4024
4025         val = strchr(o->metadata[i].u.str, '=');
4026         if (!val) {
4027             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4028                    o->metadata[i].u.str);
4029             exit_program(1);
4030         }
4031         *val++ = 0;
4032
4033         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4034         if (type == 's') {
4035             for (j = 0; j < oc->nb_streams; j++) {
4036                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4037                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4038                 } else if (ret < 0)
4039                     exit_program(1);
4040             }
4041             printf("ret %d, stream_spec %s\n", ret, stream_spec);
4042         }
4043         else {
4044             switch (type) {
4045             case 'g':
4046                 m = &oc->metadata;
4047                 break;
4048             case 'c':
4049                 if (index < 0 || index >= oc->nb_chapters) {
4050                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4051                     exit_program(1);
4052                 }
4053                 m = &oc->chapters[index]->metadata;
4054                 break;
4055             default:
4056                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4057                 exit_program(1);
4058             }
4059             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4060         }
4061     }
4062
4063     reset_options(o);
4064 }
4065
4066 /* same option as mencoder */
4067 static int opt_pass(const char *opt, const char *arg)
4068 {
4069     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4070     return 0;
4071 }
4072
4073 static int64_t getutime(void)
4074 {
4075 #if HAVE_GETRUSAGE
4076     struct rusage rusage;
4077
4078     getrusage(RUSAGE_SELF, &rusage);
4079     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4080 #elif HAVE_GETPROCESSTIMES
4081     HANDLE proc;
4082     FILETIME c, e, k, u;
4083     proc = GetCurrentProcess();
4084     GetProcessTimes(proc, &c, &e, &k, &u);
4085     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4086 #else
4087     return av_gettime();
4088 #endif
4089 }
4090
4091 static int64_t getmaxrss(void)
4092 {
4093 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4094     struct rusage rusage;
4095     getrusage(RUSAGE_SELF, &rusage);
4096     return (int64_t)rusage.ru_maxrss * 1024;
4097 #elif HAVE_GETPROCESSMEMORYINFO
4098     HANDLE proc;
4099     PROCESS_MEMORY_COUNTERS memcounters;
4100     proc = GetCurrentProcess();
4101     memcounters.cb = sizeof(memcounters);
4102     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4103     return memcounters.PeakPagefileUsage;
4104 #else
4105     return 0;
4106 #endif
4107 }
4108
4109 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4110 {
4111     return parse_option(o, "q:a", arg, options);
4112 }
4113
4114 static void show_usage(void)
4115 {
4116     printf("Hyper fast Audio and Video encoder\n");
4117     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4118     printf("\n");
4119 }
4120
4121 static void show_help(void)
4122 {
4123     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4124     av_log_set_callback(log_callback_help);
4125     show_usage();
4126     show_help_options(options, "Main options:\n",
4127                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4128     show_help_options(options, "\nAdvanced options:\n",
4129                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4130                       OPT_EXPERT);
4131     show_help_options(options, "\nVideo options:\n",
4132                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4133                       OPT_VIDEO);
4134     show_help_options(options, "\nAdvanced Video options:\n",
4135                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4136                       OPT_VIDEO | OPT_EXPERT);
4137     show_help_options(options, "\nAudio options:\n",
4138                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4139                       OPT_AUDIO);
4140     show_help_options(options, "\nAdvanced Audio options:\n",
4141                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4142                       OPT_AUDIO | OPT_EXPERT);
4143     show_help_options(options, "\nSubtitle options:\n",
4144                       OPT_SUBTITLE | OPT_GRAB,
4145                       OPT_SUBTITLE);
4146     show_help_options(options, "\nAudio/Video grab options:\n",
4147                       OPT_GRAB,
4148                       OPT_GRAB);
4149     printf("\n");
4150     show_help_children(avcodec_get_class(), flags);
4151     show_help_children(avformat_get_class(), flags);
4152     show_help_children(sws_get_class(), flags);
4153 }
4154
4155 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4156 {
4157     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4158     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4159
4160     if (!strncmp(arg, "pal-", 4)) {
4161         norm = PAL;
4162         arg += 4;
4163     } else if (!strncmp(arg, "ntsc-", 5)) {
4164         norm = NTSC;
4165         arg += 5;
4166     } else if (!strncmp(arg, "film-", 5)) {
4167         norm = FILM;
4168         arg += 5;
4169     } else {
4170         /* Try to determine PAL/NTSC by peeking in the input files */
4171         if (nb_input_files) {
4172             int i, j, fr;
4173             for (j = 0; j < nb_input_files; j++) {
4174                 for (i = 0; i < input_files[j]->nb_streams; i++) {
4175                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
4176                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4177                         continue;
4178                     fr = c->time_base.den * 1000 / c->time_base.num;
4179                     if (fr == 25000) {
4180                         norm = PAL;
4181                         break;
4182                     } else if ((fr == 29970) || (fr == 23976)) {
4183                         norm = NTSC;
4184                         break;
4185                     }
4186                 }
4187                 if (norm != UNKNOWN)
4188                     break;
4189             }
4190         }
4191         if (norm != UNKNOWN)
4192             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4193     }
4194
4195     if (norm == UNKNOWN) {
4196         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4197         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4198         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4199         exit_program(1);
4200     }
4201
4202     if (!strcmp(arg, "vcd")) {
4203         opt_video_codec(o, "c:v", "mpeg1video");
4204         opt_audio_codec(o, "c:a", "mp2");
4205         parse_option(o, "f", "vcd", options);
4206
4207         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4208         parse_option(o, "r", frame_rates[norm], options);
4209         opt_default("g", norm == PAL ? "15" : "18");
4210
4211         opt_default("b", "1150000");
4212         opt_default("maxrate", "1150000");
4213         opt_default("minrate", "1150000");
4214         opt_default("bufsize", "327680"); // 40*1024*8;
4215
4216         opt_default("b:a", "224000");
4217         parse_option(o, "ar", "44100", options);
4218         parse_option(o, "ac", "2", options);
4219
4220         opt_default("packetsize", "2324");
4221         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4222
4223         /* We have to offset the PTS, so that it is consistent with the SCR.
4224            SCR starts at 36000, but the first two packs contain only padding
4225            and the first pack from the other stream, respectively, may also have
4226            been written before.
4227            So the real data starts at SCR 36000+3*1200. */
4228         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4229     } else if (!strcmp(arg, "svcd")) {
4230
4231         opt_video_codec(o, "c:v", "mpeg2video");
4232         opt_audio_codec(o, "c:a", "mp2");
4233         parse_option(o, "f", "svcd", options);
4234
4235         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4236         parse_option(o, "r", frame_rates[norm], options);
4237         opt_default("g", norm == PAL ? "15" : "18");
4238
4239         opt_default("b", "2040000");
4240         opt_default("maxrate", "2516000");
4241         opt_default("minrate", "0"); // 1145000;
4242         opt_default("bufsize", "1835008"); // 224*1024*8;
4243         opt_default("flags", "+scan_offset");
4244
4245
4246         opt_default("b:a", "224000");
4247         parse_option(o, "ar", "44100", options);
4248
4249         opt_default("packetsize", "2324");
4250
4251     } else if (!strcmp(arg, "dvd")) {
4252
4253         opt_video_codec(o, "c:v", "mpeg2video");
4254         opt_audio_codec(o, "c:a", "ac3");
4255         parse_option(o, "f", "dvd", options);
4256
4257         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4258         parse_option(o, "r", frame_rates[norm], options);
4259         opt_default("g", norm == PAL ? "15" : "18");
4260
4261         opt_default("b", "6000000");
4262         opt_default("maxrate", "9000000");
4263         opt_default("minrate", "0"); // 1500000;
4264         opt_default("bufsize", "1835008"); // 224*1024*8;
4265
4266         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4267         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4268
4269         opt_default("b:a", "448000");
4270         parse_option(o, "ar", "48000", options);
4271
4272     } else if (!strncmp(arg, "dv", 2)) {
4273
4274         parse_option(o, "f", "dv", options);
4275
4276         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4277         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4278                           norm == PAL ? "yuv420p" : "yuv411p", options);
4279         parse_option(o, "r", frame_rates[norm], options);
4280
4281         parse_option(o, "ar", "48000", options);
4282         parse_option(o, "ac", "2", options);
4283
4284     } else {
4285         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4286         return AVERROR(EINVAL);
4287     }
4288     return 0;
4289 }
4290
4291 static int opt_vstats_file(const char *opt, const char *arg)
4292 {
4293     av_free (vstats_filename);
4294     vstats_filename = av_strdup (arg);
4295     return 0;
4296 }
4297
4298 static int opt_vstats(const char *opt, const char *arg)
4299 {
4300     char filename[40];
4301     time_t today2 = time(NULL);
4302     struct tm *today = localtime(&today2);
4303
4304     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4305              today->tm_sec);
4306     return opt_vstats_file(opt, filename);
4307 }
4308
4309 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4310 {
4311     return parse_option(o, "frames:v", arg, options);
4312 }
4313
4314 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4315 {
4316     return parse_option(o, "frames:a", arg, options);
4317 }
4318
4319 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4320 {
4321     return parse_option(o, "frames:d", arg, options);
4322 }
4323
4324 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4325 {
4326     return parse_option(o, "tag:v", arg, options);
4327 }
4328
4329 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4330 {
4331     return parse_option(o, "tag:a", arg, options);
4332 }
4333
4334 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4335 {
4336     return parse_option(o, "tag:s", arg, options);
4337 }
4338
4339 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4340 {
4341     return parse_option(o, "filter:v", arg, options);
4342 }
4343
4344 static int opt_vsync(const char *opt, const char *arg)
4345 {
4346     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
4347     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
4348     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
4349
4350     if (video_sync_method == VSYNC_AUTO)
4351         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
4352     return 0;
4353 }
4354
4355 static int opt_deinterlace(const char *opt, const char *arg)
4356 {
4357     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
4358     do_deinterlace = 1;
4359     return 0;
4360 }
4361
4362 static int opt_cpuflags(const char *opt, const char *arg)
4363 {
4364 #define CPUFLAG_MMX2     (AV_CPU_FLAG_MMX      | AV_CPU_FLAG_MMX2)
4365 #define CPUFLAG_3DNOW    (AV_CPU_FLAG_3DNOW    | AV_CPU_FLAG_MMX)
4366 #define CPUFLAG_3DNOWEXT (AV_CPU_FLAG_3DNOWEXT | CPUFLAG_3DNOW)
4367 #define CPUFLAG_SSE      (AV_CPU_FLAG_SSE      | CPUFLAG_MMX2)
4368 #define CPUFLAG_SSE2     (AV_CPU_FLAG_SSE2     | CPUFLAG_SSE)
4369 #define CPUFLAG_SSE2SLOW (AV_CPU_FLAG_SSE2SLOW | CPUFLAG_SSE2)
4370 #define CPUFLAG_SSE3   &n