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