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