avconv: fix -frames for video encoders with delay.
[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 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 (int 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     FFSinkContext ffsink_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, &ffsink,
574                                        "out", NULL, &ffsink_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     ret = av_interleaved_write_frame(s, pkt);
914     if (ret < 0) {
915         print_error("av_interleaved_write_frame()", ret);
916         exit_program(1);
917     }
918 }
919
920 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
921 {
922     int fill_char = 0x00;
923     if (sample_fmt == AV_SAMPLE_FMT_U8)
924         fill_char = 0x80;
925     memset(buf, fill_char, size);
926 }
927
928 static int encode_audio_frame(AVFormatContext *s, OutputStream *ost,
929                               const uint8_t *buf, int buf_size)
930 {
931     AVCodecContext *enc = ost->st->codec;
932     AVFrame *frame = NULL;
933     AVPacket pkt;
934     int ret, got_packet;
935
936     av_init_packet(&pkt);
937     pkt.data = NULL;
938     pkt.size = 0;
939
940     if (buf) {
941         if (!ost->output_frame) {
942             ost->output_frame = avcodec_alloc_frame();
943             if (!ost->output_frame) {
944                 av_log(NULL, AV_LOG_FATAL, "out-of-memory in encode_audio_frame()\n");
945                 exit_program(1);
946             }
947         }
948         frame = ost->output_frame;
949         if (frame->extended_data != frame->data)
950             av_freep(&frame->extended_data);
951         avcodec_get_frame_defaults(frame);
952
953         frame->nb_samples  = buf_size /
954                              (enc->channels * av_get_bytes_per_sample(enc->sample_fmt));
955         if ((ret = avcodec_fill_audio_frame(frame, enc->channels, enc->sample_fmt,
956                                             buf, buf_size, 1)) < 0) {
957             av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
958             exit_program(1);
959         }
960     }
961
962     got_packet = 0;
963     if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
964         av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
965         exit_program(1);
966     }
967
968     if (got_packet) {
969         pkt.stream_index = ost->index;
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.stream_index = ost->index;
1258         pkt.data = subtitle_out;
1259         pkt.size = subtitle_out_size;
1260         pkt.pts  = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1261         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1262             /* XXX: the pts correction is handled here. Maybe handling
1263                it in the codec would be better */
1264             if (i == 0)
1265                 pkt.pts += 90 * sub->start_display_time;
1266             else
1267                 pkt.pts += 90 * sub->end_display_time;
1268         }
1269         write_frame(s, &pkt, ost);
1270     }
1271 }
1272
1273 static int bit_buffer_size = 1024 * 256;
1274 static uint8_t *bit_buffer = NULL;
1275
1276 #if !CONFIG_AVFILTER
1277 static void do_video_resample(OutputStream *ost,
1278                               InputStream *ist,
1279                               AVFrame *in_picture,
1280                               AVFrame **out_picture)
1281 {
1282     int resample_changed = 0;
1283     *out_picture = in_picture;
1284
1285     resample_changed = ost->resample_width   != in_picture->width  ||
1286                        ost->resample_height  != in_picture->height ||
1287                        ost->resample_pix_fmt != in_picture->format;
1288
1289     if (resample_changed) {
1290         av_log(NULL, AV_LOG_INFO,
1291                "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1292                ist->file_index, ist->st->index,
1293                ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1294                in_picture->width, in_picture->height, av_get_pix_fmt_name(in_picture->format));
1295         if (!ost->video_resample)
1296             ost->video_resample = 1;
1297     }
1298
1299     if (ost->video_resample) {
1300         *out_picture = &ost->pict_tmp;
1301         if (resample_changed) {
1302             /* initialize a new scaler context */
1303             sws_freeContext(ost->img_resample_ctx);
1304             ost->img_resample_ctx = sws_getContext(
1305                 ist->st->codec->width,
1306                 ist->st->codec->height,
1307                 ist->st->codec->pix_fmt,
1308                 ost->st->codec->width,
1309                 ost->st->codec->height,
1310                 ost->st->codec->pix_fmt,
1311                 ost->sws_flags, NULL, NULL, NULL);
1312             if (ost->img_resample_ctx == NULL) {
1313                 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1314                 exit_program(1);
1315             }
1316         }
1317         sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1318               0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1319     }
1320     if (resample_changed) {
1321         ost->resample_width   = in_picture->width;
1322         ost->resample_height  = in_picture->height;
1323         ost->resample_pix_fmt = in_picture->format;
1324     }
1325 }
1326 #endif
1327
1328
1329 static void do_video_out(AVFormatContext *s,
1330                          OutputStream *ost,
1331                          InputStream *ist,
1332                          AVFrame *in_picture,
1333                          int *frame_size, float quality)
1334 {
1335     int nb_frames, i, ret, format_video_sync;
1336     AVFrame *final_picture;
1337     AVCodecContext *enc;
1338     double sync_ipts;
1339
1340     enc = ost->st->codec;
1341
1342     sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1343
1344     /* by default, we output a single frame */
1345     nb_frames = 1;
1346
1347     *frame_size = 0;
1348
1349     format_video_sync = video_sync_method;
1350     if (format_video_sync == VSYNC_AUTO)
1351         format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH :
1352                             (s->oformat->flags & AVFMT_VARIABLE_FPS) ? VSYNC_VFR : VSYNC_CFR;
1353
1354     if (format_video_sync != VSYNC_PASSTHROUGH) {
1355         double vdelta = sync_ipts - ost->sync_opts;
1356         // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1357         if (vdelta < -1.1)
1358             nb_frames = 0;
1359         else if (format_video_sync == VSYNC_VFR) {
1360             if (vdelta <= -0.6) {
1361                 nb_frames = 0;
1362             } else if (vdelta > 0.6)
1363                 ost->sync_opts = lrintf(sync_ipts);
1364         } else if (vdelta > 1.1)
1365             nb_frames = lrintf(vdelta);
1366 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
1367         if (nb_frames == 0) {
1368             ++nb_frames_drop;
1369             av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1370         } else if (nb_frames > 1) {
1371             nb_frames_dup += nb_frames - 1;
1372             av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1373         }
1374     } else
1375         ost->sync_opts = lrintf(sync_ipts);
1376
1377     nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1378     if (nb_frames <= 0)
1379         return;
1380
1381 #if !CONFIG_AVFILTER
1382     do_video_resample(ost, ist, in_picture, &final_picture);
1383 #else
1384     final_picture = in_picture;
1385 #endif
1386
1387     /* duplicates frame if needed */
1388     for (i = 0; i < nb_frames; i++) {
1389         AVPacket pkt;
1390         av_init_packet(&pkt);
1391         pkt.stream_index = ost->index;
1392
1393         if (s->oformat->flags & AVFMT_RAWPICTURE &&
1394             enc->codec->id == CODEC_ID_RAWVIDEO) {
1395             /* raw pictures are written as AVPicture structure to
1396                avoid any copies. We support temporarily the older
1397                method. */
1398             enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1399             enc->coded_frame->top_field_first  = in_picture->top_field_first;
1400             pkt.data   = (uint8_t *)final_picture;
1401             pkt.size   =  sizeof(AVPicture);
1402             pkt.pts    = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1403             pkt.flags |= AV_PKT_FLAG_KEY;
1404
1405             write_frame(s, &pkt, ost);
1406         } else {
1407             AVFrame big_picture;
1408
1409             big_picture = *final_picture;
1410             /* better than nothing: use input picture interlaced
1411                settings */
1412             big_picture.interlaced_frame = in_picture->interlaced_frame;
1413             if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1414                 if (ost->top_field_first == -1)
1415                     big_picture.top_field_first = in_picture->top_field_first;
1416                 else
1417                     big_picture.top_field_first = !!ost->top_field_first;
1418             }
1419
1420             /* handles same_quant here. This is not correct because it may
1421                not be a global option */
1422             big_picture.quality = quality;
1423             if (!enc->me_threshold)
1424                 big_picture.pict_type = 0;
1425 //            big_picture.pts = AV_NOPTS_VALUE;
1426             big_picture.pts = ost->sync_opts;
1427 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1428 // av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1429             if (ost->forced_kf_index < ost->forced_kf_count &&
1430                 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1431                 big_picture.pict_type = AV_PICTURE_TYPE_I;
1432                 ost->forced_kf_index++;
1433             }
1434             ret = avcodec_encode_video(enc,
1435                                        bit_buffer, bit_buffer_size,
1436                                        &big_picture);
1437             if (ret < 0) {
1438                 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1439                 exit_program(1);
1440             }
1441
1442             if (ret > 0) {
1443                 pkt.data = bit_buffer;
1444                 pkt.size = ret;
1445                 if (enc->coded_frame->pts != AV_NOPTS_VALUE)
1446                     pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1447 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1448    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1449    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1450
1451                 if (enc->coded_frame->key_frame)
1452                     pkt.flags |= AV_PKT_FLAG_KEY;
1453                 write_frame(s, &pkt, ost);
1454                 *frame_size = ret;
1455                 video_size += ret;
1456                 // fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1457                 //         enc->frame_number-1, ret, enc->pict_type);
1458                 /* if two pass, output log */
1459                 if (ost->logfile && enc->stats_out) {
1460                     fprintf(ost->logfile, "%s", enc->stats_out);
1461                 }
1462             }
1463         }
1464         ost->sync_opts++;
1465         /*
1466          * For video, number of frames in == number of packets out.
1467          * But there may be reordering, so we can't throw away frames on encoder
1468          * flush, we need to limit them here, before they go into encoder.
1469          */
1470         ost->frame_number++;
1471     }
1472 }
1473
1474 static double psnr(double d)
1475 {
1476     return -10.0 * log(d) / log(10.0);
1477 }
1478
1479 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1480                            int frame_size)
1481 {
1482     AVCodecContext *enc;
1483     int frame_number;
1484     double ti1, bitrate, avg_bitrate;
1485
1486     /* this is executed just the first time do_video_stats is called */
1487     if (!vstats_file) {
1488         vstats_file = fopen(vstats_filename, "w");
1489         if (!vstats_file) {
1490             perror("fopen");
1491             exit_program(1);
1492         }
1493     }
1494
1495     enc = ost->st->codec;
1496     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1497         frame_number = ost->frame_number;
1498         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1499         if (enc->flags&CODEC_FLAG_PSNR)
1500             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1501
1502         fprintf(vstats_file,"f_size= %6d ", frame_size);
1503         /* compute pts value */
1504         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1505         if (ti1 < 0.01)
1506             ti1 = 0.01;
1507
1508         bitrate     = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1509         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1510         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1511                (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1512         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1513     }
1514 }
1515
1516 static void print_report(OutputFile *output_files,
1517                          OutputStream *ost_table, int nb_ostreams,
1518                          int is_last_report, int64_t timer_start)
1519 {
1520     char buf[1024];
1521     OutputStream *ost;
1522     AVFormatContext *oc;
1523     int64_t total_size;
1524     AVCodecContext *enc;
1525     int frame_number, vid, i;
1526     double bitrate, ti1, pts;
1527     static int64_t last_time = -1;
1528     static int qp_histogram[52];
1529
1530     if (!print_stats && !is_last_report)
1531         return;
1532
1533     if (!is_last_report) {
1534         int64_t cur_time;
1535         /* display the report every 0.5 seconds */
1536         cur_time = av_gettime();
1537         if (last_time == -1) {
1538             last_time = cur_time;
1539             return;
1540         }
1541         if ((cur_time - last_time) < 500000)
1542             return;
1543         last_time = cur_time;
1544     }
1545
1546
1547     oc = output_files[0].ctx;
1548
1549     total_size = avio_size(oc->pb);
1550     if (total_size < 0) // FIXME improve avio_size() so it works with non seekable output too
1551         total_size = avio_tell(oc->pb);
1552
1553     buf[0] = '\0';
1554     ti1 = 1e10;
1555     vid = 0;
1556     for (i = 0; i < nb_ostreams; i++) {
1557         float q = -1;
1558         ost = &ost_table[i];
1559         enc = ost->st->codec;
1560         if (!ost->stream_copy && enc->coded_frame)
1561             q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
1562         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1563             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1564         }
1565         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1566             float t = (av_gettime() - timer_start) / 1000000.0;
1567
1568             frame_number = ost->frame_number;
1569             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1570                      frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
1571             if (is_last_report)
1572                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1573             if (qp_hist) {
1574                 int j;
1575                 int qp = lrintf(q);
1576                 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1577                     qp_histogram[qp]++;
1578                 for (j = 0; j < 32; j++)
1579                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
1580             }
1581             if (enc->flags&CODEC_FLAG_PSNR) {
1582                 int j;
1583                 double error, error_sum = 0;
1584                 double scale, scale_sum = 0;
1585                 char type[3] = { 'Y','U','V' };
1586                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1587                 for (j = 0; j < 3; j++) {
1588                     if (is_last_report) {
1589                         error = enc->error[j];
1590                         scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1591                     } else {
1592                         error = enc->coded_frame->error[j];
1593                         scale = enc->width * enc->height * 255.0 * 255.0;
1594                     }
1595                     if (j)
1596                         scale /= 4;
1597                     error_sum += error;
1598                     scale_sum += scale;
1599                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
1600                 }
1601                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1602             }
1603             vid = 1;
1604         }
1605         /* compute min output value */
1606         pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1607         if ((pts < ti1) && (pts > 0))
1608             ti1 = pts;
1609     }
1610     if (ti1 < 0.01)
1611         ti1 = 0.01;
1612
1613     bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1614
1615     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1616             "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1617             (double)total_size / 1024, ti1, bitrate);
1618
1619     if (nb_frames_dup || nb_frames_drop)
1620         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1621                 nb_frames_dup, nb_frames_drop);
1622
1623     av_log(NULL, AV_LOG_INFO, "%s    \r", buf);
1624
1625     fflush(stderr);
1626
1627     if (is_last_report) {
1628         int64_t raw= audio_size + video_size + extra_size;
1629         av_log(NULL, AV_LOG_INFO, "\n");
1630         av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1631                video_size / 1024.0,
1632                audio_size / 1024.0,
1633                extra_size / 1024.0,
1634                100.0 * (total_size - raw) / raw
1635         );
1636     }
1637 }
1638
1639 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1640 {
1641     int i, ret;
1642
1643     for (i = 0; i < nb_ostreams; i++) {
1644         OutputStream   *ost = &ost_table[i];
1645         AVCodecContext *enc = ost->st->codec;
1646         AVFormatContext *os = output_files[ost->file_index].ctx;
1647         int stop_encoding = 0;
1648
1649         if (!ost->encoding_needed)
1650             continue;
1651
1652         if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1653             continue;
1654         if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1655             continue;
1656
1657         for (;;) {
1658             AVPacket pkt;
1659             int fifo_bytes;
1660             av_init_packet(&pkt);
1661             pkt.data = NULL;
1662             pkt.size = 0;
1663
1664             switch (ost->st->codec->codec_type) {
1665             case AVMEDIA_TYPE_AUDIO:
1666                 fifo_bytes = av_fifo_size(ost->fifo);
1667                 if (fifo_bytes > 0) {
1668                     /* encode any samples remaining in fifo */
1669                     int frame_bytes = fifo_bytes;
1670
1671                     av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1672
1673                     /* pad last frame with silence if needed */
1674                     if (!(enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME)) {
1675                         frame_bytes = enc->frame_size * enc->channels *
1676                                       av_get_bytes_per_sample(enc->sample_fmt);
1677                         if (allocated_audio_buf_size < frame_bytes)
1678                             exit_program(1);
1679                         generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1680                     }
1681                     encode_audio_frame(os, ost, audio_buf, frame_bytes);
1682                 } else {
1683                     /* flush encoder with NULL frames until it is done
1684                        returning packets */
1685                     if (encode_audio_frame(os, ost, NULL, 0) == 0) {
1686                         stop_encoding = 1;
1687                         break;
1688                     }
1689                 }
1690                 break;
1691             case AVMEDIA_TYPE_VIDEO:
1692                 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1693                 if (ret < 0) {
1694                     av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1695                     exit_program(1);
1696                 }
1697                 video_size += ret;
1698                 if (enc->coded_frame && enc->coded_frame->key_frame)
1699                     pkt.flags |= AV_PKT_FLAG_KEY;
1700                 if (ost->logfile && enc->stats_out) {
1701                     fprintf(ost->logfile, "%s", enc->stats_out);
1702                 }
1703                 if (ret <= 0) {
1704                     stop_encoding = 1;
1705                     break;
1706                 }
1707                 pkt.stream_index = ost->index;
1708                 pkt.data = bit_buffer;
1709                 pkt.size = ret;
1710                 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1711                     pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1712                 write_frame(os, &pkt, ost);
1713                 break;
1714             default:
1715                 stop_encoding = 1;
1716             }
1717             if (stop_encoding)
1718                 break;
1719         }
1720     }
1721 }
1722
1723 /*
1724  * Check whether a packet from ist should be written into ost at this time
1725  */
1726 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1727 {
1728     OutputFile *of = &output_files[ost->file_index];
1729     int ist_index  = ist - input_streams;
1730
1731     if (ost->source_index != ist_index)
1732         return 0;
1733
1734     if (of->start_time && ist->pts < of->start_time)
1735         return 0;
1736
1737     if (of->recording_time != INT64_MAX &&
1738         av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1739                       (AVRational){ 1, 1000000 }) >= 0) {
1740         ost->is_past_recording_time = 1;
1741         return 0;
1742     }
1743
1744     return 1;
1745 }
1746
1747 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1748 {
1749     OutputFile *of = &output_files[ost->file_index];
1750     int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1751     AVPacket opkt;
1752
1753     av_init_packet(&opkt);
1754
1755     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1756         !ost->copy_initial_nonkeyframes)
1757         return;
1758
1759     /* force the input stream PTS */
1760     if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1761         audio_size += pkt->size;
1762     else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1763         video_size += pkt->size;
1764         ost->sync_opts++;
1765     }
1766
1767     opkt.stream_index = ost->index;
1768     if (pkt->pts != AV_NOPTS_VALUE)
1769         opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1770     else
1771         opkt.pts = AV_NOPTS_VALUE;
1772
1773     if (pkt->dts == AV_NOPTS_VALUE)
1774         opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1775     else
1776         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1777     opkt.dts -= ost_tb_start_time;
1778
1779     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1780     opkt.flags    = pkt->flags;
1781
1782     // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1783     if (  ost->st->codec->codec_id != CODEC_ID_H264
1784        && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1785        && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1786        ) {
1787         if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1788             opkt.destruct = av_destruct_packet;
1789     } else {
1790         opkt.data = pkt->data;
1791         opkt.size = pkt->size;
1792     }
1793
1794     write_frame(of->ctx, &opkt, ost);
1795     ost->st->codec->frame_number++;
1796     av_free_packet(&opkt);
1797 }
1798
1799 static void rate_emu_sleep(InputStream *ist)
1800 {
1801     if (input_files[ist->file_index].rate_emu) {
1802         int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1803         int64_t now = av_gettime() - ist->start;
1804         if (pts > now)
1805             usleep(pts - now);
1806     }
1807 }
1808
1809 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1810 {
1811     AVFrame *decoded_frame;
1812     AVCodecContext *avctx = ist->st->codec;
1813     int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1814     int i, ret;
1815
1816     if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1817         return AVERROR(ENOMEM);
1818     else
1819         avcodec_get_frame_defaults(ist->decoded_frame);
1820     decoded_frame = ist->decoded_frame;
1821
1822     ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1823     if (ret < 0) {
1824         return ret;
1825     }
1826
1827     if (!*got_output) {
1828         /* no audio frame */
1829         return ret;
1830     }
1831
1832     /* if the decoder provides a pts, use it instead of the last packet pts.
1833        the decoder could be delaying output by a packet or more. */
1834     if (decoded_frame->pts != AV_NOPTS_VALUE)
1835         ist->next_pts = decoded_frame->pts;
1836
1837     /* increment next_pts to use for the case where the input stream does not
1838        have timestamps or there are multiple frames in the packet */
1839     ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1840                      avctx->sample_rate;
1841
1842     // preprocess audio (volume)
1843     if (audio_volume != 256) {
1844         int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
1845         void *samples = decoded_frame->data[0];
1846         switch (avctx->sample_fmt) {
1847         case AV_SAMPLE_FMT_U8:
1848         {
1849             uint8_t *volp = samples;
1850             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1851                 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1852                 *volp++ = av_clip_uint8(v);
1853             }
1854             break;
1855         }
1856         case AV_SAMPLE_FMT_S16:
1857         {
1858             int16_t *volp = samples;
1859             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1860                 int v = ((*volp) * audio_volume + 128) >> 8;
1861                 *volp++ = av_clip_int16(v);
1862             }
1863             break;
1864         }
1865         case AV_SAMPLE_FMT_S32:
1866         {
1867             int32_t *volp = samples;
1868             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1869                 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1870                 *volp++ = av_clipl_int32(v);
1871             }
1872             break;
1873         }
1874         case AV_SAMPLE_FMT_FLT:
1875         {
1876             float *volp = samples;
1877             float scale = audio_volume / 256.f;
1878             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1879                 *volp++ *= scale;
1880             }
1881             break;
1882         }
1883         case AV_SAMPLE_FMT_DBL:
1884         {
1885             double *volp = samples;
1886             double scale = audio_volume / 256.;
1887             for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1888                 *volp++ *= scale;
1889             }
1890             break;
1891         }
1892         default:
1893             av_log(NULL, AV_LOG_FATAL,
1894                    "Audio volume adjustment on sample format %s is not supported.\n",
1895                    av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1896             exit_program(1);
1897         }
1898     }
1899
1900     rate_emu_sleep(ist);
1901
1902     for (i = 0; i < nb_output_streams; i++) {
1903         OutputStream *ost = &output_streams[i];
1904
1905         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1906             continue;
1907         do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
1908     }
1909
1910     return ret;
1911 }
1912
1913 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
1914 {
1915     AVFrame *decoded_frame, *filtered_frame = NULL;
1916     void *buffer_to_free = NULL;
1917     int i, ret = 0;
1918     float quality;
1919 #if CONFIG_AVFILTER
1920     int frame_available = 1;
1921 #endif
1922
1923     if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1924         return AVERROR(ENOMEM);
1925     else
1926         avcodec_get_frame_defaults(ist->decoded_frame);
1927     decoded_frame = ist->decoded_frame;
1928     pkt->pts  = *pkt_pts;
1929     pkt->dts  = ist->pts;
1930     *pkt_pts  = AV_NOPTS_VALUE;
1931
1932     ret = avcodec_decode_video2(ist->st->codec,
1933                                 decoded_frame, got_output, pkt);
1934     if (ret < 0)
1935         return ret;
1936
1937     quality = same_quant ? decoded_frame->quality : 0;
1938     if (!*got_output) {
1939         /* no picture yet */
1940         return ret;
1941     }
1942     ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
1943                                                  decoded_frame->pkt_dts);
1944     if (pkt->duration)
1945         ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
1946     else if (ist->st->codec->time_base.num != 0) {
1947         int ticks      = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
1948                                            ist->st->codec->ticks_per_frame;
1949         ist->next_pts += ((int64_t)AV_TIME_BASE *
1950                           ist->st->codec->time_base.num * ticks) /
1951                           ist->st->codec->time_base.den;
1952     }
1953     pkt->size = 0;
1954     pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1955
1956     rate_emu_sleep(ist);
1957
1958     for (i = 0; i < nb_output_streams; i++) {
1959         OutputStream *ost = &output_streams[i];
1960         int frame_size, resample_changed;
1961
1962         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1963             continue;
1964
1965 #if CONFIG_AVFILTER
1966         resample_changed = ost->resample_width   != decoded_frame->width  ||
1967                            ost->resample_height  != decoded_frame->height ||
1968                            ost->resample_pix_fmt != decoded_frame->format;
1969         if (resample_changed) {
1970             av_log(NULL, AV_LOG_INFO,
1971                     "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1972                     ist->file_index, ist->st->index,
1973                     ost->resample_width,  ost->resample_height,  av_get_pix_fmt_name(ost->resample_pix_fmt),
1974                     decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
1975
1976             avfilter_graph_free(&ost->graph);
1977             if (configure_video_filters(ist, ost)) {
1978                 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1979                 exit_program(1);
1980             }
1981
1982             ost->resample_width   = decoded_frame->width;
1983             ost->resample_height  = decoded_frame->height;
1984             ost->resample_pix_fmt = decoded_frame->format;
1985         }
1986
1987         if (ist->st->sample_aspect_ratio.num)
1988             decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1989         if (ist->st->codec->codec->capabilities & CODEC_CAP_DR1) {
1990             FrameBuffer      *buf = decoded_frame->opaque;
1991             AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
1992                                         decoded_frame->data, decoded_frame->linesize,
1993                                         AV_PERM_READ | AV_PERM_PRESERVE,
1994                                         ist->st->codec->width, ist->st->codec->height,
1995                                         ist->st->codec->pix_fmt);
1996
1997             avfilter_copy_frame_props(fb, decoded_frame);
1998             fb->pts                 = ist->pts;
1999             fb->buf->priv           = buf;
2000             fb->buf->free           = filter_release_buffer;
2001
2002             buf->refcount++;
2003             av_buffersrc_buffer(ost->input_video_filter, fb);
2004         } else
2005             av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame,
2006                                      ist->pts, decoded_frame->sample_aspect_ratio);
2007
2008         if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
2009             av_free(buffer_to_free);
2010             return AVERROR(ENOMEM);
2011         } else
2012             avcodec_get_frame_defaults(ist->filtered_frame);
2013         filtered_frame = ist->filtered_frame;
2014
2015         frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
2016         while (frame_available) {
2017             AVRational ist_pts_tb;
2018             if (ost->output_video_filter)
2019                 get_filtered_video_frame(ost->output_video_filter, filtered_frame, &ost->picref, &ist_pts_tb);
2020             if (ost->picref)
2021                 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2022             if (ost->picref->video && !ost->frame_aspect_ratio)
2023                 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
2024 #else
2025             filtered_frame = decoded_frame;
2026 #endif
2027
2028             do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
2029                          same_quant ? quality : ost->st->codec->global_quality);
2030             if (vstats_filename && frame_size)
2031                 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
2032 #if CONFIG_AVFILTER
2033             frame_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
2034             if (ost->picref)
2035                 avfilter_unref_buffer(ost->picref);
2036         }
2037 #endif
2038     }
2039
2040     av_free(buffer_to_free);
2041     return ret;
2042 }
2043
2044 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2045 {
2046     AVSubtitle subtitle;
2047     int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2048                                           &subtitle, got_output, pkt);
2049     if (ret < 0)
2050         return ret;
2051     if (!*got_output)
2052         return ret;
2053
2054     rate_emu_sleep(ist);
2055
2056     for (i = 0; i < nb_output_streams; i++) {
2057         OutputStream *ost = &output_streams[i];
2058
2059         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2060             continue;
2061
2062         do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
2063     }
2064
2065     avsubtitle_free(&subtitle);
2066     return ret;
2067 }
2068
2069 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2070 static int output_packet(InputStream *ist,
2071                          OutputStream *ost_table, int nb_ostreams,
2072                          const AVPacket *pkt)
2073 {
2074     int i;
2075     int got_output;
2076     int64_t pkt_pts = AV_NOPTS_VALUE;
2077     AVPacket avpkt;
2078
2079     if (ist->next_pts == AV_NOPTS_VALUE)
2080         ist->next_pts = ist->pts;
2081
2082     if (pkt == NULL) {
2083         /* EOF handling */
2084         av_init_packet(&avpkt);
2085         avpkt.data = NULL;
2086         avpkt.size = 0;
2087         goto handle_eof;
2088     } else {
2089         avpkt = *pkt;
2090     }
2091
2092     if (pkt->dts != AV_NOPTS_VALUE)
2093         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2094     if (pkt->pts != AV_NOPTS_VALUE)
2095         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2096
2097     // while we have more to decode or while the decoder did output something on EOF
2098     while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2099         int ret = 0;
2100     handle_eof:
2101
2102         ist->pts = ist->next_pts;
2103
2104         if (avpkt.size && avpkt.size != pkt->size) {
2105             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2106                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2107             ist->showed_multi_packet_warning = 1;
2108         }
2109
2110         switch (ist->st->codec->codec_type) {
2111         case AVMEDIA_TYPE_AUDIO:
2112             ret = transcode_audio    (ist, &avpkt, &got_output);
2113             break;
2114         case AVMEDIA_TYPE_VIDEO:
2115             ret = transcode_video    (ist, &avpkt, &got_output, &pkt_pts);
2116             break;
2117         case AVMEDIA_TYPE_SUBTITLE:
2118             ret = transcode_subtitles(ist, &avpkt, &got_output);
2119             break;
2120         default:
2121             return -1;
2122         }
2123
2124         if (ret < 0)
2125             return ret;
2126         // touch data and size only if not EOF
2127         if (pkt) {
2128             avpkt.data += ret;
2129             avpkt.size -= ret;
2130         }
2131         if (!got_output) {
2132             continue;
2133         }
2134     }
2135
2136     /* handle stream copy */
2137     if (!ist->decoding_needed) {
2138         rate_emu_sleep(ist);
2139         ist->pts = ist->next_pts;
2140         switch (ist->st->codec->codec_type) {
2141         case AVMEDIA_TYPE_AUDIO:
2142             ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2143                              ist->st->codec->sample_rate;
2144             break;
2145         case AVMEDIA_TYPE_VIDEO:
2146             if (ist->st->codec->time_base.num != 0) {
2147                 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2148                 ist->next_pts += ((int64_t)AV_TIME_BASE *
2149                                   ist->st->codec->time_base.num * ticks) /
2150                                   ist->st->codec->time_base.den;
2151             }
2152             break;
2153         }
2154     }
2155     for (i = 0; pkt && i < nb_ostreams; i++) {
2156         OutputStream *ost = &ost_table[i];
2157
2158         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2159             continue;
2160
2161         do_streamcopy(ist, ost, pkt);
2162     }
2163
2164     return 0;
2165 }
2166
2167 static void print_sdp(OutputFile *output_files, int n)
2168 {
2169     char sdp[2048];
2170     int i;
2171     AVFormatContext **avc = av_malloc(sizeof(*avc) * n);
2172
2173     if (!avc)
2174         exit_program(1);
2175     for (i = 0; i < n; i++)
2176         avc[i] = output_files[i].ctx;
2177
2178     av_sdp_create(avc, n, sdp, sizeof(sdp));
2179     printf("SDP:\n%s\n", sdp);
2180     fflush(stdout);
2181     av_freep(&avc);
2182 }
2183
2184 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2185                              char *error, int error_len)
2186 {
2187     int i;
2188     InputStream *ist = &input_streams[ist_index];
2189     if (ist->decoding_needed) {
2190         AVCodec *codec = ist->dec;
2191         if (!codec) {
2192             snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
2193                     ist->st->codec->codec_id, ist->file_index, ist->st->index);
2194             return AVERROR(EINVAL);
2195         }
2196
2197         /* update requested sample format for the decoder based on the
2198            corresponding encoder sample format */
2199         for (i = 0; i < nb_output_streams; i++) {
2200             OutputStream *ost = &output_streams[i];
2201             if (ost->source_index == ist_index) {
2202                 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2203                 break;
2204             }
2205         }
2206
2207         if (codec->type == AVMEDIA_TYPE_VIDEO && codec->capabilities & CODEC_CAP_DR1) {
2208             ist->st->codec->get_buffer     = codec_get_buffer;
2209             ist->st->codec->release_buffer = codec_release_buffer;
2210             ist->st->codec->opaque         = ist;
2211         }
2212
2213         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2214             snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2215                     ist->file_index, ist->st->index);
2216             return AVERROR(EINVAL);
2217         }
2218         assert_codec_experimental(ist->st->codec, 0);
2219         assert_avoptions(ist->opts);
2220     }
2221
2222     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;
2223     ist->next_pts = AV_NOPTS_VALUE;
2224     init_pts_correction(&ist->pts_ctx);
2225     ist->is_start = 1;
2226
2227     return 0;
2228 }
2229
2230 static int transcode_init(OutputFile *output_files,
2231                           int nb_output_files,
2232                           InputFile *input_files,
2233                           int nb_input_files)
2234 {
2235     int ret = 0, i, j, k;
2236     AVFormatContext *oc;
2237     AVCodecContext *codec, *icodec;
2238     OutputStream *ost;
2239     InputStream *ist;
2240     char error[1024];
2241     int want_sdp = 1;
2242
2243     /* init framerate emulation */
2244     for (i = 0; i < nb_input_files; i++) {
2245         InputFile *ifile = &input_files[i];
2246         if (ifile->rate_emu)
2247             for (j = 0; j < ifile->nb_streams; j++)
2248                 input_streams[j + ifile->ist_index].start = av_gettime();
2249     }
2250
2251     /* output stream init */
2252     for (i = 0; i < nb_output_files; i++) {
2253         oc = output_files[i].ctx;
2254         if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2255             av_dump_format(oc, i, oc->filename, 1);
2256             av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2257             return AVERROR(EINVAL);
2258         }
2259     }
2260
2261     /* for each output stream, we compute the right encoding parameters */
2262     for (i = 0; i < nb_output_streams; i++) {
2263         ost = &output_streams[i];
2264         oc  = output_files[ost->file_index].ctx;
2265         ist = &input_streams[ost->source_index];
2266
2267         if (ost->attachment_filename)
2268             continue;
2269
2270         codec  = ost->st->codec;
2271         icodec = ist->st->codec;
2272
2273         ost->st->disposition          = ist->st->disposition;
2274         codec->bits_per_raw_sample    = icodec->bits_per_raw_sample;
2275         codec->chroma_sample_location = icodec->chroma_sample_location;
2276
2277         if (ost->stream_copy) {
2278             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2279
2280             if (extra_size > INT_MAX) {
2281                 return AVERROR(EINVAL);
2282             }
2283
2284             /* if stream_copy is selected, no need to decode or encode */
2285             codec->codec_id   = icodec->codec_id;
2286             codec->codec_type = icodec->codec_type;
2287
2288             if (!codec->codec_tag) {
2289                 if (!oc->oformat->codec_tag ||
2290                      av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2291                      av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2292                     codec->codec_tag = icodec->codec_tag;
2293             }
2294
2295             codec->bit_rate       = icodec->bit_rate;
2296             codec->rc_max_rate    = icodec->rc_max_rate;
2297             codec->rc_buffer_size = icodec->rc_buffer_size;
2298             codec->field_order    = icodec->field_order;
2299             codec->extradata      = av_mallocz(extra_size);
2300             if (!codec->extradata) {
2301                 return AVERROR(ENOMEM);
2302             }
2303             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2304             codec->extradata_size = icodec->extradata_size;
2305             if (!copy_tb) {
2306                 codec->time_base      = icodec->time_base;
2307                 codec->time_base.num *= icodec->ticks_per_frame;
2308                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2309                           codec->time_base.num, codec->time_base.den, INT_MAX);
2310             } else
2311                 codec->time_base = ist->st->time_base;
2312
2313             switch (codec->codec_type) {
2314             case AVMEDIA_TYPE_AUDIO:
2315                 if (audio_volume != 256) {
2316                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2317                     exit_program(1);
2318                 }
2319                 codec->channel_layout     = icodec->channel_layout;
2320                 codec->sample_rate        = icodec->sample_rate;
2321                 codec->channels           = icodec->channels;
2322                 codec->frame_size         = icodec->frame_size;
2323                 codec->audio_service_type = icodec->audio_service_type;
2324                 codec->block_align        = icodec->block_align;
2325                 break;
2326             case AVMEDIA_TYPE_VIDEO:
2327                 codec->pix_fmt            = icodec->pix_fmt;
2328                 codec->width              = icodec->width;
2329                 codec->height             = icodec->height;
2330                 codec->has_b_frames       = icodec->has_b_frames;
2331                 if (!codec->sample_aspect_ratio.num) {
2332                     codec->sample_aspect_ratio   =
2333                     ost->st->sample_aspect_ratio =
2334                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2335                         ist->st->codec->sample_aspect_ratio.num ?
2336                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2337                 }
2338                 break;
2339             case AVMEDIA_TYPE_SUBTITLE:
2340                 codec->width  = icodec->width;
2341                 codec->height = icodec->height;
2342                 break;
2343             case AVMEDIA_TYPE_DATA:
2344             case AVMEDIA_TYPE_ATTACHMENT:
2345                 break;
2346             default:
2347                 abort();
2348             }
2349         } else {
2350             if (!ost->enc)
2351                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2352
2353             ist->decoding_needed = 1;
2354             ost->encoding_needed = 1;
2355
2356             switch (codec->codec_type) {
2357             case AVMEDIA_TYPE_AUDIO:
2358                 ost->fifo = av_fifo_alloc(1024);
2359                 if (!ost->fifo) {
2360                     return AVERROR(ENOMEM);
2361                 }
2362                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2363
2364                 if (!codec->sample_rate)
2365                     codec->sample_rate = icodec->sample_rate;
2366                 choose_sample_rate(ost->st, ost->enc);
2367                 codec->time_base = (AVRational){ 1, codec->sample_rate };
2368
2369                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2370                     codec->sample_fmt = icodec->sample_fmt;
2371                 choose_sample_fmt(ost->st, ost->enc);
2372
2373                 if (!codec->channels)
2374                     codec->channels = icodec->channels;
2375                 codec->channel_layout = icodec->channel_layout;
2376                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2377                     codec->channel_layout = 0;
2378
2379                 ost->audio_resample       = codec-> sample_rate != icodec->sample_rate || audio_sync_method > 1;
2380                 icodec->request_channels  = codec-> channels;
2381                 ost->resample_sample_fmt  = icodec->sample_fmt;
2382                 ost->resample_sample_rate = icodec->sample_rate;
2383                 ost->resample_channels    = icodec->channels;
2384                 break;
2385             case AVMEDIA_TYPE_VIDEO:
2386                 if (codec->pix_fmt == PIX_FMT_NONE)
2387                     codec->pix_fmt = icodec->pix_fmt;
2388                 choose_pixel_fmt(ost->st, ost->enc);
2389
2390                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2391                     av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2392                     exit_program(1);
2393                 }
2394
2395                 if (!codec->width || !codec->height) {
2396                     codec->width  = icodec->width;
2397                     codec->height = icodec->height;
2398                 }
2399
2400                 ost->video_resample = codec->width   != icodec->width  ||
2401                                       codec->height  != icodec->height ||
2402                                       codec->pix_fmt != icodec->pix_fmt;
2403                 if (ost->video_resample) {
2404 #if !CONFIG_AVFILTER
2405                     avcodec_get_frame_defaults(&ost->pict_tmp);
2406                     if (avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2407                                        codec->width, codec->height)) {
2408                         av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
2409                         exit_program(1);
2410                     }
2411                     ost->img_resample_ctx = sws_getContext(
2412                         icodec->width,
2413                         icodec->height,
2414                         icodec->pix_fmt,
2415                         codec->width,
2416                         codec->height,
2417                         codec->pix_fmt,
2418                         ost->sws_flags, NULL, NULL, NULL);
2419                     if (ost->img_resample_ctx == NULL) {
2420                         av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
2421                         exit_program(1);
2422                     }
2423 #endif
2424                     codec->bits_per_raw_sample = 0;
2425                 }
2426
2427                 ost->resample_height  = icodec->height;
2428                 ost->resample_width   = icodec->width;
2429                 ost->resample_pix_fmt = icodec->pix_fmt;
2430
2431                 if (!ost->frame_rate.num)
2432                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
2433                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2434                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2435                     ost->frame_rate = ost->enc->supported_framerates[idx];
2436                 }
2437                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2438
2439 #if CONFIG_AVFILTER
2440                 if (configure_video_filters(ist, ost)) {
2441                     av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2442                     exit(1);
2443                 }
2444 #endif
2445                 break;
2446             case AVMEDIA_TYPE_SUBTITLE:
2447                 break;
2448             default:
2449                 abort();
2450                 break;
2451             }
2452             /* two pass mode */
2453             if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2454                 char logfilename[1024];
2455                 FILE *f;
2456
2457                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2458                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2459                          i);
2460                 if (codec->flags & CODEC_FLAG_PASS1) {
2461                     f = fopen(logfilename, "wb");
2462                     if (!f) {
2463                         av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2464                                logfilename, strerror(errno));
2465                         exit_program(1);
2466                     }
2467                     ost->logfile = f;
2468                 } else {
2469                     char  *logbuffer;
2470                     size_t logbuffer_size;
2471                     if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2472                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2473                                logfilename);
2474                         exit_program(1);
2475                     }
2476                     codec->stats_in = logbuffer;
2477                 }
2478             }
2479         }
2480         if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2481             int        size = codec->width * codec->height;
2482             bit_buffer_size = FFMAX(bit_buffer_size, 6 * size + 200);
2483         }
2484     }
2485
2486     if (!bit_buffer)
2487         bit_buffer = av_malloc(bit_buffer_size);
2488     if (!bit_buffer) {
2489         av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2490                bit_buffer_size);
2491         return AVERROR(ENOMEM);
2492     }
2493
2494     /* open each encoder */
2495     for (i = 0; i < nb_output_streams; i++) {
2496         ost = &output_streams[i];
2497         if (ost->encoding_needed) {
2498             AVCodec      *codec = ost->enc;
2499             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2500             if (!codec) {
2501                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d:%d",
2502                          ost->st->codec->codec_id, ost->file_index, ost->index);
2503                 ret = AVERROR(EINVAL);
2504                 goto dump_format;
2505             }
2506             if (dec->subtitle_header) {
2507                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2508                 if (!ost->st->codec->subtitle_header) {
2509                     ret = AVERROR(ENOMEM);
2510                     goto dump_format;
2511                 }
2512                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2513                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2514             }
2515             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2516                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2517                         ost->file_index, ost->index);
2518                 ret = AVERROR(EINVAL);
2519                 goto dump_format;
2520             }
2521             assert_codec_experimental(ost->st->codec, 1);
2522             assert_avoptions(ost->opts);
2523             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2524                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2525                                              "It takes bits/s as argument, not kbits/s\n");
2526             extra_size += ost->st->codec->extradata_size;
2527
2528             if (ost->st->codec->me_threshold)
2529                 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2530         }
2531     }
2532
2533     /* init input streams */
2534     for (i = 0; i < nb_input_streams; i++)
2535         if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2536             goto dump_format;
2537
2538     /* discard unused programs */
2539     for (i = 0; i < nb_input_files; i++) {
2540         InputFile *ifile = &input_files[i];
2541         for (j = 0; j < ifile->ctx->nb_programs; j++) {
2542             AVProgram *p = ifile->ctx->programs[j];
2543             int discard  = AVDISCARD_ALL;
2544
2545             for (k = 0; k < p->nb_stream_indexes; k++)
2546                 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2547                     discard = AVDISCARD_DEFAULT;
2548                     break;
2549                 }
2550             p->discard = discard;
2551         }
2552     }
2553
2554     /* open files and write file headers */
2555     for (i = 0; i < nb_output_files; i++) {
2556         oc = output_files[i].ctx;
2557         oc->interrupt_callback = int_cb;
2558         if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2559             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2560             ret = AVERROR(EINVAL);
2561             goto dump_format;
2562         }
2563         assert_avoptions(output_files[i].opts);
2564         if (strcmp(oc->oformat->name, "rtp")) {
2565             want_sdp = 0;
2566         }
2567     }
2568
2569  dump_format:
2570     /* dump the file output parameters - cannot be done before in case
2571        of stream copy */
2572     for (i = 0; i < nb_output_files; i++) {
2573         av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2574     }
2575
2576     /* dump the stream mapping */
2577     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2578     for (i = 0; i < nb_output_streams; i++) {
2579         ost = &output_streams[i];
2580
2581         if (ost->attachment_filename) {
2582             /* an attached file */
2583             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
2584                    ost->attachment_filename, ost->file_index, ost->index);
2585             continue;
2586         }
2587         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
2588                input_streams[ost->source_index].file_index,
2589                input_streams[ost->source_index].st->index,
2590                ost->file_index,
2591                ost->index);
2592         if (ost->sync_ist != &input_streams[ost->source_index])
2593             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2594                    ost->sync_ist->file_index,
2595                    ost->sync_ist->st->index);
2596         if (ost->stream_copy)
2597             av_log(NULL, AV_LOG_INFO, " (copy)");
2598         else
2599             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2600                    input_streams[ost->source_index].dec->name : "?",
2601                    ost->enc ? ost->enc->name : "?");
2602         av_log(NULL, AV_LOG_INFO, "\n");
2603     }
2604
2605     if (ret) {
2606         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2607         return ret;
2608     }
2609
2610     if (want_sdp) {
2611         print_sdp(output_files, nb_output_files);
2612     }
2613
2614     return 0;
2615 }
2616
2617 /*
2618  * The following code is the main loop of the file converter
2619  */
2620 static int transcode(OutputFile *output_files,
2621                      int nb_output_files,
2622                      InputFile *input_files,
2623                      int nb_input_files)
2624 {
2625     int ret, i;
2626     AVFormatContext *is, *os;
2627     OutputStream *ost;
2628     InputStream *ist;
2629     uint8_t *no_packet;
2630     int no_packet_count = 0;
2631     int64_t timer_start;
2632
2633     if (!(no_packet = av_mallocz(nb_input_files)))
2634         exit_program(1);
2635
2636     ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2637     if (ret < 0)
2638         goto fail;
2639
2640     av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2641     term_init();
2642
2643     timer_start = av_gettime();
2644
2645     for (; received_sigterm == 0;) {
2646         int file_index, ist_index;
2647         AVPacket pkt;
2648         int64_t ipts_min;
2649         double opts_min;
2650
2651         ipts_min = INT64_MAX;
2652         opts_min = 1e100;
2653
2654         /* select the stream that we must read now by looking at the
2655            smallest output pts */
2656         file_index = -1;
2657         for (i = 0; i < nb_output_streams; i++) {
2658             OutputFile *of;
2659             int64_t ipts;
2660             double  opts;
2661             ost = &output_streams[i];
2662             of = &output_files[ost->file_index];
2663             os = output_files[ost->file_index].ctx;
2664             ist = &input_streams[ost->source_index];
2665             if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2666                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2667                 continue;
2668             opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2669             ipts = ist->pts;
2670             if (!input_files[ist->file_index].eof_reached) {
2671                 if (ipts < ipts_min) {
2672                     ipts_min = ipts;
2673                     if (input_sync)
2674                         file_index = ist->file_index;
2675                 }
2676                 if (opts < opts_min) {
2677                     opts_min = opts;
2678                     if (!input_sync) file_index = ist->file_index;
2679                 }
2680             }
2681             if (ost->frame_number >= ost->max_frames) {
2682                 int j;
2683                 for (j = 0; j < of->ctx->nb_streams; j++)
2684                     output_streams[of->ost_index + j].is_past_recording_time = 1;
2685                 continue;
2686             }
2687         }
2688         /* if none, if is finished */
2689         if (file_index < 0) {
2690             if (no_packet_count) {
2691                 no_packet_count = 0;
2692                 memset(no_packet, 0, nb_input_files);
2693                 usleep(10000);
2694                 continue;
2695             }
2696             break;
2697         }
2698
2699         /* read a frame from it and output it in the fifo */
2700         is  = input_files[file_index].ctx;
2701         ret = av_read_frame(is, &pkt);
2702         if (ret == AVERROR(EAGAIN)) {
2703             no_packet[file_index] = 1;
2704             no_packet_count++;
2705             continue;
2706         }
2707         if (ret < 0) {
2708             input_files[file_index].eof_reached = 1;
2709             if (opt_shortest)
2710                 break;
2711             else
2712                 continue;
2713         }
2714
2715         no_packet_count = 0;
2716         memset(no_packet, 0, nb_input_files);
2717
2718         if (do_pkt_dump) {
2719             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2720                              is->streams[pkt.stream_index]);
2721         }
2722         /* the following test is needed in case new streams appear
2723            dynamically in stream : we ignore them */
2724         if (pkt.stream_index >= input_files[file_index].nb_streams)
2725             goto discard_packet;
2726         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2727         ist = &input_streams[ist_index];
2728         if (ist->discard)
2729             goto discard_packet;
2730
2731         if (pkt.dts != AV_NOPTS_VALUE)
2732             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2733         if (pkt.pts != AV_NOPTS_VALUE)
2734             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2735
2736         if (pkt.pts != AV_NOPTS_VALUE)
2737             pkt.pts *= ist->ts_scale;
2738         if (pkt.dts != AV_NOPTS_VALUE)
2739             pkt.dts *= ist->ts_scale;
2740
2741         //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
2742         //        ist->next_pts,
2743         //        pkt.dts, input_files[ist->file_index].ts_offset,
2744         //        ist->st->codec->codec_type);
2745         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2746             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2747             int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2748             int64_t delta   = pkt_dts - ist->next_pts;
2749             if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->pts) && !copy_ts) {
2750                 input_files[ist->file_index].ts_offset -= delta;
2751                 av_log(NULL, AV_LOG_DEBUG,
2752                        "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2753                        delta, input_files[ist->file_index].ts_offset);
2754                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2755                 if (pkt.pts != AV_NOPTS_VALUE)
2756                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2757             }
2758         }
2759
2760         // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2761         if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2762
2763             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2764                    ist->file_index, ist->st->index);
2765             if (exit_on_error)
2766                 exit_program(1);
2767             av_free_packet(&pkt);
2768             continue;
2769         }
2770
2771     discard_packet:
2772         av_free_packet(&pkt);
2773
2774         /* dump report by using the output first video and audio streams */
2775         print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2776     }
2777
2778     /* at the end of stream, we must flush the decoder buffers */
2779     for (i = 0; i < nb_input_streams; i++) {
2780         ist = &input_streams[i];
2781         if (ist->decoding_needed) {
2782             output_packet(ist, output_streams, nb_output_streams, NULL);
2783         }
2784     }
2785     flush_encoders(output_streams, nb_output_streams);
2786
2787     term_exit();
2788
2789     /* write the trailer if needed and close file */
2790     for (i = 0; i < nb_output_files; i++) {
2791         os = output_files[i].ctx;
2792         av_write_trailer(os);
2793     }
2794
2795     /* dump report by using the first video and audio streams */
2796     print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2797
2798     /* close each encoder */
2799     for (i = 0; i < nb_output_streams; i++) {
2800         ost = &output_streams[i];
2801         if (ost->encoding_needed) {
2802             av_freep(&ost->st->codec->stats_in);
2803             avcodec_close(ost->st->codec);
2804         }
2805 #if CONFIG_AVFILTER
2806         avfilter_graph_free(&ost->graph);
2807 #endif
2808     }
2809
2810     /* close each decoder */
2811     for (i = 0; i < nb_input_streams; i++) {
2812         ist = &input_streams[i];
2813         if (ist->decoding_needed) {
2814             avcodec_close(ist->st->codec);
2815         }
2816     }
2817
2818     /* finished ! */
2819     ret = 0;
2820
2821  fail:
2822     av_freep(&bit_buffer);
2823     av_freep(&no_packet);
2824
2825     if (output_streams) {
2826         for (i = 0; i < nb_output_streams; i++) {
2827             ost = &output_streams[i];
2828             if (ost) {
2829                 if (ost->stream_copy)
2830                     av_freep(&ost->st->codec->extradata);
2831                 if (ost->logfile) {
2832                     fclose(ost->logfile);
2833                     ost->logfile = NULL;
2834                 }
2835                 av_fifo_free(ost->fifo); /* works even if fifo is not
2836                                              initialized but set to zero */
2837                 av_freep(&ost->st->codec->subtitle_header);
2838                 av_free(ost->pict_tmp.data[0]);
2839                 av_free(ost->forced_kf_pts);
2840                 if (ost->video_resample)
2841                     sws_freeContext(ost->img_resample_ctx);
2842                 if (ost->resample)
2843                     audio_resample_close(ost->resample);
2844                 if (ost->reformat_ctx)
2845                     av_audio_convert_free(ost->reformat_ctx);
2846                 av_dict_free(&ost->opts);
2847             }
2848         }
2849     }
2850     return ret;
2851 }
2852
2853 static double parse_frame_aspect_ratio(const char *arg)
2854 {
2855     int x = 0, y = 0;
2856     double ar = 0;
2857     const char *p;
2858     char *end;
2859
2860     p = strchr(arg, ':');
2861     if (p) {
2862         x = strtol(arg, &end, 10);
2863         if (end == p)
2864             y = strtol(end + 1, &end, 10);
2865         if (x > 0 && y > 0)
2866             ar = (double)x / (double)y;
2867     } else
2868         ar = strtod(arg, NULL);
2869
2870     if (!ar) {
2871         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2872         exit_program(1);
2873     }
2874     return ar;
2875 }
2876
2877 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2878 {
2879     return parse_option(o, "codec:a", arg, options);
2880 }
2881
2882 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2883 {
2884     return parse_option(o, "codec:v", arg, options);
2885 }
2886
2887 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2888 {
2889     return parse_option(o, "codec:s", arg, options);
2890 }
2891
2892 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2893 {
2894     return parse_option(o, "codec:d", arg, options);
2895 }
2896
2897 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2898 {
2899     StreamMap *m = NULL;
2900     int i, negative = 0, file_idx;
2901     int sync_file_idx = -1, sync_stream_idx;
2902     char *p, *sync;
2903     char *map;
2904
2905     if (*arg == '-') {
2906         negative = 1;
2907         arg++;
2908     }
2909     map = av_strdup(arg);
2910
2911     /* parse sync stream first, just pick first matching stream */
2912     if (sync = strchr(map, ',')) {
2913         *sync = 0;
2914         sync_file_idx = strtol(sync + 1, &sync, 0);
2915         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2916             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2917             exit_program(1);
2918         }
2919         if (*sync)
2920             sync++;
2921         for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2922             if (check_stream_specifier(input_files[sync_file_idx].ctx,
2923                                        input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2924                 sync_stream_idx = i;
2925                 break;
2926             }
2927         if (i == input_files[sync_file_idx].nb_streams) {
2928             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2929                                        "match any streams.\n", arg);
2930             exit_program(1);
2931         }
2932     }
2933
2934
2935     file_idx = strtol(map, &p, 0);
2936     if (file_idx >= nb_input_files || file_idx < 0) {
2937         av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2938         exit_program(1);
2939     }
2940     if (negative)
2941         /* disable some already defined maps */
2942         for (i = 0; i < o->nb_stream_maps; i++) {
2943             m = &o->stream_maps[i];
2944             if (file_idx == m->file_index &&
2945                 check_stream_specifier(input_files[m->file_index].ctx,
2946                                        input_files[m->file_index].ctx->streams[m->stream_index],
2947                                        *p == ':' ? p + 1 : p) > 0)
2948                 m->disabled = 1;
2949         }
2950     else
2951         for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2952             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2953                         *p == ':' ? p + 1 : p) <= 0)
2954                 continue;
2955             o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2956                                         &o->nb_stream_maps, o->nb_stream_maps + 1);
2957             m = &o->stream_maps[o->nb_stream_maps - 1];
2958
2959             m->file_index   = file_idx;
2960             m->stream_index = i;
2961
2962             if (sync_file_idx >= 0) {
2963                 m->sync_file_index   = sync_file_idx;
2964                 m->sync_stream_index = sync_stream_idx;
2965             } else {
2966                 m->sync_file_index   = file_idx;
2967                 m->sync_stream_index = i;
2968             }
2969         }
2970
2971     if (!m) {
2972         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2973         exit_program(1);
2974     }
2975
2976     av_freep(&map);
2977     return 0;
2978 }
2979
2980 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
2981 {
2982     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
2983                                 &o->nb_attachments, o->nb_attachments + 1);
2984     o->attachments[o->nb_attachments - 1] = arg;
2985     return 0;
2986 }
2987
2988 /**
2989  * Parse a metadata specifier in arg.
2990  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
2991  * @param index for type c/p, chapter/program index is written here
2992  * @param stream_spec for type s, the stream specifier is written here
2993  */
2994 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
2995 {
2996     if (*arg) {
2997         *type = *arg;
2998         switch (*arg) {
2999         case 'g':
3000             break;
3001         case 's':
3002             if (*(++arg) && *arg != ':') {
3003                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3004                 exit_program(1);
3005             }
3006             *stream_spec = *arg == ':' ? arg + 1 : "";
3007             break;
3008         case 'c':
3009         case 'p':
3010             if (*(++arg) == ':')
3011                 *index = strtol(++arg, NULL, 0);
3012             break;
3013         default:
3014             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3015             exit_program(1);
3016         }
3017     } else
3018         *type = 'g';
3019 }
3020
3021 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3022 {
3023     AVDictionary **meta_in = NULL;
3024     AVDictionary **meta_out;
3025     int i, ret = 0;
3026     char type_in, type_out;
3027     const char *istream_spec = NULL, *ostream_spec = NULL;
3028     int idx_in = 0, idx_out = 0;
3029
3030     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
3031     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3032
3033     if (type_in == 'g' || type_out == 'g')
3034         o->metadata_global_manual = 1;
3035     if (type_in == 's' || type_out == 's')
3036         o->metadata_streams_manual = 1;
3037     if (type_in == 'c' || type_out == 'c')
3038         o->metadata_chapters_manual = 1;
3039
3040 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3041     if ((index) < 0 || (index) >= (nb_elems)) {\
3042         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3043                 (desc), (index));\
3044         exit_program(1);\
3045     }
3046
3047 #define SET_DICT(type, meta, context, index)\
3048         switch (type) {\
3049         case 'g':\
3050             meta = &context->metadata;\
3051             break;\
3052         case 'c':\
3053             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3054             meta = &context->chapters[index]->metadata;\
3055             break;\
3056         case 'p':\
3057             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3058             meta = &context->programs[index]->metadata;\
3059             break;\
3060         }\
3061
3062     SET_DICT(type_in, meta_in, ic, idx_in);
3063     SET_DICT(type_out, meta_out, oc, idx_out);
3064
3065     /* for input streams choose first matching stream */
3066     if (type_in == 's') {
3067         for (i = 0; i < ic->nb_streams; i++) {
3068             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3069                 meta_in = &ic->streams[i]->metadata;
3070                 break;
3071             } else if (ret < 0)
3072                 exit_program(1);
3073         }
3074         if (!meta_in) {
3075             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
3076             exit_program(1);
3077         }
3078     }
3079
3080     if (type_out == 's') {
3081         for (i = 0; i < oc->nb_streams; i++) {
3082             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3083                 meta_out = &oc->streams[i]->metadata;
3084                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3085             } else if (ret < 0)
3086                 exit_program(1);
3087         }
3088     } else
3089         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3090
3091     return 0;
3092 }
3093
3094 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3095 {
3096     const char *codec_string = encoder ? "encoder" : "decoder";
3097     AVCodec *codec;
3098
3099     codec = encoder ?
3100         avcodec_find_encoder_by_name(name) :
3101         avcodec_find_decoder_by_name(name);
3102     if (!codec) {
3103         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3104         exit_program(1);
3105     }
3106     if (codec->type != type) {
3107         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3108         exit_program(1);
3109     }
3110     return codec;
3111 }
3112
3113 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3114 {
3115     char *codec_name = NULL;
3116
3117     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3118     if (codec_name) {
3119         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3120         st->codec->codec_id = codec->id;
3121         return codec;
3122     } else
3123         return avcodec_find_decoder(st->codec->codec_id);
3124 }
3125
3126 /**
3127  * Add all the streams from the given input file to the global
3128  * list of input streams.
3129  */
3130 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3131 {
3132     int i;
3133
3134     for (i = 0; i < ic->nb_streams; i++) {
3135         AVStream *st = ic->streams[i];
3136         AVCodecContext *dec = st->codec;
3137         InputStream *ist;
3138
3139         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3140         ist = &input_streams[nb_input_streams - 1];
3141         ist->st = st;
3142         ist->file_index = nb_input_files;
3143         ist->discard = 1;
3144         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3145
3146         ist->ts_scale = 1.0;
3147         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3148
3149         ist->dec = choose_decoder(o, ic, st);
3150
3151         switch (dec->codec_type) {
3152         case AVMEDIA_TYPE_AUDIO:
3153             if (o->audio_disable)
3154                 st->discard = AVDISCARD_ALL;
3155             break;
3156         case AVMEDIA_TYPE_VIDEO:
3157             if (dec->lowres) {
3158                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3159                 dec->height >>= dec->lowres;
3160                 dec->width  >>= dec->lowres;
3161             }
3162
3163             if (o->video_disable)
3164                 st->discard = AVDISCARD_ALL;
3165             else if (video_discard)
3166                 st->discard = video_discard;
3167             break;
3168         case AVMEDIA_TYPE_DATA:
3169             break;
3170         case AVMEDIA_TYPE_SUBTITLE:
3171             if (o->subtitle_disable)
3172                 st->discard = AVDISCARD_ALL;
3173             break;
3174         case AVMEDIA_TYPE_ATTACHMENT:
3175         case AVMEDIA_TYPE_UNKNOWN:
3176             break;
3177         default:
3178             abort();
3179         }
3180     }
3181 }
3182
3183 static void assert_file_overwrite(const char *filename)
3184 {
3185     if (!file_overwrite &&
3186         (strchr(filename, ':') == NULL || filename[1] == ':' ||
3187          av_strstart(filename, "file:", NULL))) {
3188         if (avio_check(filename, 0) == 0) {
3189             if (!using_stdin) {
3190                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3191                 fflush(stderr);
3192                 if (!read_yesno()) {
3193                     fprintf(stderr, "Not overwriting - exiting\n");
3194                     exit_program(1);
3195                 }
3196             }
3197             else {
3198                 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3199                 exit_program(1);
3200             }
3201         }
3202     }
3203 }
3204
3205 static void dump_attachment(AVStream *st, const char *filename)
3206 {
3207     int ret;
3208     AVIOContext *out = NULL;
3209     AVDictionaryEntry *e;
3210
3211     if (!st->codec->extradata_size) {
3212         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3213                nb_input_files - 1, st->index);
3214         return;
3215     }
3216     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3217         filename = e->value;
3218     if (!*filename) {
3219         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3220                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3221         exit_program(1);
3222     }
3223
3224     assert_file_overwrite(filename);
3225
3226     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3227         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3228                filename);
3229         exit_program(1);
3230     }
3231
3232     avio_write(out, st->codec->extradata, st->codec->extradata_size);
3233     avio_flush(out);
3234     avio_close(out);
3235 }
3236
3237 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3238 {
3239     AVFormatContext *ic;
3240     AVInputFormat *file_iformat = NULL;
3241     int err, i, ret;
3242     int64_t timestamp;
3243     uint8_t buf[128];
3244     AVDictionary **opts;
3245     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3246
3247     if (o->format) {
3248         if (!(file_iformat = av_find_input_format(o->format))) {
3249             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3250             exit_program(1);
3251         }
3252     }
3253
3254     if (!strcmp(filename, "-"))
3255         filename = "pipe:";
3256
3257     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3258                     !strcmp(filename, "/dev/stdin");
3259
3260     /* get default parameters from command line */
3261     ic = avformat_alloc_context();
3262     if (!ic) {
3263         print_error(filename, AVERROR(ENOMEM));
3264         exit_program(1);
3265     }
3266     if (o->nb_audio_sample_rate) {
3267         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3268         av_dict_set(&format_opts, "sample_rate", buf, 0);
3269     }
3270     if (o->nb_audio_channels) {
3271         snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3272         av_dict_set(&format_opts, "channels", buf, 0);
3273     }
3274     if (o->nb_frame_rates) {
3275         av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3276     }
3277     if (o->nb_frame_sizes) {
3278         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3279     }
3280     if (o->nb_frame_pix_fmts)
3281         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3282
3283     ic->flags |= AVFMT_FLAG_NONBLOCK;
3284     ic->interrupt_callback = int_cb;
3285
3286     /* open the input file with generic libav function */
3287     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3288     if (err < 0) {
3289         print_error(filename, err);
3290         exit_program(1);
3291     }
3292     assert_avoptions(format_opts);
3293
3294     /* apply forced codec ids */
3295     for (i = 0; i < ic->nb_streams; i++)
3296         choose_decoder(o, ic, ic->streams[i]);
3297
3298     /* Set AVCodecContext options for avformat_find_stream_info */
3299     opts = setup_find_stream_info_opts(ic, codec_opts);
3300     orig_nb_streams = ic->nb_streams;
3301
3302     /* If not enough info to get the stream parameters, we decode the
3303        first frames to get it. (used in mpeg case for example) */
3304     ret = avformat_find_stream_info(ic, opts);
3305     if (ret < 0) {
3306         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3307         avformat_close_input(&ic);
3308         exit_program(1);
3309     }
3310
3311     timestamp = o->start_time;
3312     /* add the stream start time */
3313     if (ic->start_time != AV_NOPTS_VALUE)
3314         timestamp += ic->start_time;
3315
3316     /* if seeking requested, we execute it */
3317     if (o->start_time != 0) {
3318         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3319         if (ret < 0) {
3320             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3321                    filename, (double)timestamp / AV_TIME_BASE);
3322         }
3323     }
3324
3325     /* update the current parameters so that they match the one of the input stream */
3326     add_input_streams(o, ic);
3327
3328     /* dump the file content */
3329     av_dump_format(ic, nb_input_files, filename, 0);
3330
3331     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3332     input_files[nb_input_files - 1].ctx        = ic;
3333     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3334     input_files[nb_input_files - 1].ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3335     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3336     input_files[nb_input_files - 1].rate_emu   = o->rate_emu;
3337
3338     for (i = 0; i < o->nb_dump_attachment; i++) {
3339         int j;
3340
3341         for (j = 0; j < ic->nb_streams; j++) {
3342             AVStream *st = ic->streams[j];
3343
3344             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3345                 dump_attachment(st, o->dump_attachment[i].u.str);
3346         }
3347     }
3348
3349     for (i = 0; i < orig_nb_streams; i++)
3350         av_dict_free(&opts[i]);
3351     av_freep(&opts);
3352
3353     reset_options(o);
3354     return 0;
3355 }
3356
3357 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3358                                     AVCodecContext *avctx)
3359 {
3360     char *p;
3361     int n = 1, i;
3362     int64_t t;
3363
3364     for (p = kf; *p; p++)
3365         if (*p == ',')
3366             n++;
3367     ost->forced_kf_count = n;
3368     ost->forced_kf_pts   = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3369     if (!ost->forced_kf_pts) {
3370         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3371         exit_program(1);
3372     }
3373     for (i = 0; i < n; i++) {
3374         p = i ? strchr(p, ',') + 1 : kf;
3375         t = parse_time_or_die("force_key_frames", p, 1);
3376         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3377     }
3378 }
3379
3380 static uint8_t *get_line(AVIOContext *s)
3381 {
3382     AVIOContext *line;
3383     uint8_t *buf;
3384     char c;
3385
3386     if (avio_open_dyn_buf(&line) < 0) {
3387         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3388         exit_program(1);
3389     }
3390
3391     while ((c = avio_r8(s)) && c != '\n')
3392         avio_w8(line, c);
3393     avio_w8(line, 0);
3394     avio_close_dyn_buf(line, &buf);
3395
3396     return buf;
3397 }
3398
3399 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3400 {
3401     int i, ret = 1;
3402     char filename[1000];
3403     const char *base[3] = { getenv("AVCONV_DATADIR"),
3404                             getenv("HOME"),
3405                             AVCONV_DATADIR,
3406                             };
3407
3408     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3409         if (!base[i])
3410             continue;
3411         if (codec_name) {
3412             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3413                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
3414             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3415         }
3416         if (ret) {
3417             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3418                      i != 1 ? "" : "/.avconv", preset_name);
3419             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3420         }
3421     }
3422     return ret;
3423 }
3424
3425 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3426 {
3427     char *codec_name = NULL;
3428
3429     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3430     if (!codec_name) {
3431         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3432                                                   NULL, ost->st->codec->codec_type);
3433         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3434     } else if (!strcmp(codec_name, "copy"))
3435         ost->stream_copy = 1;
3436     else {
3437         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3438         ost->st->codec->codec_id = ost->enc->id;
3439     }
3440 }
3441
3442 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3443 {
3444     OutputStream *ost;
3445     AVStream *st = avformat_new_stream(oc, NULL);
3446     int idx      = oc->nb_streams - 1, ret = 0;
3447     char *bsf = NULL, *next, *codec_tag = NULL;
3448     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3449     double qscale = -1;
3450     char *buf = NULL, *arg = NULL, *preset = NULL;
3451     AVIOContext *s = NULL;
3452
3453     if (!st) {
3454         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3455         exit_program(1);
3456     }
3457
3458     if (oc->nb_streams - 1 < o->nb_streamid_map)
3459         st->id = o->streamid_map[oc->nb_streams - 1];
3460
3461     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3462                                 nb_output_streams + 1);
3463     ost = &output_streams[nb_output_streams - 1];
3464     ost->file_index = nb_output_files;
3465     ost->index      = idx;
3466     ost->st         = st;
3467     st->codec->codec_type = type;
3468     choose_encoder(o, oc, ost);
3469     if (ost->enc) {
3470         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3471     }
3472
3473     avcodec_get_context_defaults3(st->codec, ost->enc);
3474     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3475
3476     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3477     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3478         do  {
3479             buf = get_line(s);
3480             if (!buf[0] || buf[0] == '#') {
3481                 av_free(buf);
3482                 continue;
3483             }
3484             if (!(arg = strchr(buf, '='))) {
3485                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3486                 exit_program(1);
3487             }
3488             *arg++ = 0;
3489             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3490             av_free(buf);
3491         } while (!s->eof_reached);
3492         avio_close(s);
3493     }
3494     if (ret) {
3495         av_log(NULL, AV_LOG_FATAL,
3496                "Preset %s specified for stream %d:%d, but could not be opened.\n",
3497                preset, ost->file_index, ost->index);
3498         exit_program(1);
3499     }
3500
3501     ost->max_frames = INT64_MAX;
3502     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3503
3504     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3505     while (bsf) {
3506         if (next = strchr(bsf, ','))
3507             *next++ = 0;
3508         if (!(bsfc = av_bitstream_filter_init(bsf))) {
3509             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3510             exit_program(1);
3511         }
3512         if (bsfc_prev)
3513             bsfc_prev->next = bsfc;
3514         else
3515             ost->bitstream_filters = bsfc;
3516
3517         bsfc_prev = bsfc;
3518         bsf       = next;
3519     }
3520
3521     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3522     if (codec_tag) {
3523         uint32_t tag = strtol(codec_tag, &next, 0);
3524         if (*next)
3525             tag = AV_RL32(codec_tag);
3526         st->codec->codec_tag = tag;
3527     }
3528
3529     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3530     if (qscale >= 0 || same_quant) {
3531         st->codec->flags |= CODEC_FLAG_QSCALE;
3532         st->codec->global_quality = FF_QP2LAMBDA * qscale;
3533     }
3534
3535     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3536         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3537
3538     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3539     return ost;
3540 }
3541
3542 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3543 {
3544     int i;
3545     const char *p = str;
3546     for (i = 0;; i++) {
3547         dest[i] = atoi(p);
3548         if (i == 63)
3549             break;
3550         p = strchr(p, ',');
3551         if (!p) {
3552             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3553             exit_program(1);
3554         }
3555         p++;
3556     }
3557 }
3558
3559 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3560 {
3561     AVStream *st;
3562     OutputStream *ost;
3563     AVCodecContext *video_enc;
3564
3565     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3566     st  = ost->st;
3567     video_enc = st->codec;
3568
3569     if (!ost->stream_copy) {
3570         const char *p = NULL;
3571         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3572         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3573         char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3574         int i;
3575
3576         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3577         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3578             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3579             exit_program(1);
3580         }
3581
3582         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3583         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3584             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3585             exit_program(1);
3586         }
3587
3588         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3589         if (frame_aspect_ratio)
3590             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3591
3592         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3593         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3594             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3595             exit_program(1);
3596         }
3597         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3598
3599         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3600         if (intra_matrix) {
3601             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3602                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3603                 exit_program(1);
3604             }
3605             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3606         }
3607         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3608         if (inter_matrix) {
3609             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3610                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3611                 exit_program(1);
3612             }
3613             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3614         }
3615
3616         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3617         for (i = 0; p; i++) {
3618             int start, end, q;
3619             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
3620             if (e != 3) {
3621                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3622                 exit_program(1);
3623             }
3624             video_enc->rc_override =
3625                 av_realloc(video_enc->rc_override,
3626                            sizeof(RcOverride) * (i + 1));
3627             video_enc->rc_override[i].start_frame = start;
3628             video_enc->rc_override[i].end_frame   = end;
3629             if (q > 0) {
3630                 video_enc->rc_override[i].qscale         = q;
3631                 video_enc->rc_override[i].quality_factor = 1.0;
3632             }
3633             else {
3634                 video_enc->rc_override[i].qscale         = 0;
3635                 video_enc->rc_override[i].quality_factor = -q/100.0;
3636             }
3637             p = strchr(p, '/');
3638             if (p) p++;
3639         }
3640         video_enc->rc_override_count = i;
3641         if (!video_enc->rc_initial_buffer_occupancy)
3642             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
3643         video_enc->intra_dc_precision = intra_dc_precision - 8;
3644
3645         /* two pass mode */
3646         if (do_pass) {
3647             if (do_pass == 1) {
3648                 video_enc->flags |= CODEC_FLAG_PASS1;
3649             } else {
3650                 video_enc->flags |= CODEC_FLAG_PASS2;
3651             }
3652         }
3653
3654         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3655         if (forced_key_frames)
3656             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3657
3658         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3659
3660         ost->top_field_first = -1;
3661         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3662
3663 #if CONFIG_AVFILTER
3664         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3665         if (filters)
3666             ost->avfilter = av_strdup(filters);
3667 #endif
3668     } else {
3669         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3670     }
3671
3672     return ost;
3673 }
3674
3675 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3676 {
3677     AVStream *st;
3678     OutputStream *ost;
3679     AVCodecContext *audio_enc;
3680
3681     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3682     st  = ost->st;
3683
3684     audio_enc = st->codec;
3685     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3686
3687     if (!ost->stream_copy) {
3688         char *sample_fmt = NULL;
3689
3690         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3691
3692         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3693         if (sample_fmt &&
3694             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3695             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3696             exit_program(1);
3697         }
3698
3699         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3700     }
3701
3702     return ost;
3703 }
3704
3705 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3706 {
3707     OutputStream *ost;
3708
3709     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3710     if (!ost->stream_copy) {
3711         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3712         exit_program(1);
3713     }
3714
3715     return ost;
3716 }
3717
3718 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3719 {
3720     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3721     ost->stream_copy = 1;
3722     return ost;
3723 }
3724
3725 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3726 {
3727     AVStream *st;
3728     OutputStream *ost;
3729     AVCodecContext *subtitle_enc;
3730
3731     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3732     st  = ost->st;
3733     subtitle_enc = st->codec;
3734
3735     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3736
3737     return ost;
3738 }
3739
3740 /* arg format is "output-stream-index:streamid-value". */
3741 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3742 {
3743     int idx;
3744     char *p;
3745     char idx_str[16];
3746
3747     av_strlcpy(idx_str, arg, sizeof(idx_str));
3748     p = strchr(idx_str, ':');
3749     if (!p) {
3750         av_log(NULL, AV_LOG_FATAL,
3751                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3752                arg, opt);
3753         exit_program(1);
3754     }
3755     *p++ = '\0';
3756     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3757     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3758     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3759     return 0;
3760 }
3761
3762 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3763 {
3764     AVFormatContext *is = ifile->ctx;
3765     AVFormatContext *os = ofile->ctx;
3766     int i;
3767
3768     for (i = 0; i < is->nb_chapters; i++) {
3769         AVChapter *in_ch = is->chapters[i], *out_ch;
3770         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3771                                        AV_TIME_BASE_Q, in_ch->time_base);
3772         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3773                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3774
3775
3776         if (in_ch->end < ts_off)
3777             continue;
3778         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3779             break;
3780
3781         out_ch = av_mallocz(sizeof(AVChapter));
3782         if (!out_ch)
3783             return AVERROR(ENOMEM);
3784
3785         out_ch->id        = in_ch->id;
3786         out_ch->time_base = in_ch->time_base;
3787         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3788         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3789
3790         if (copy_metadata)
3791             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3792
3793         os->nb_chapters++;
3794         os->chapters = av_realloc(os->chapters, sizeof(AVChapter) * os->nb_chapters);
3795         if (!os->chapters)
3796             return AVERROR(ENOMEM);
3797         os->chapters[os->nb_chapters - 1] = out_ch;
3798     }
3799     return 0;
3800 }
3801
3802 static void opt_output_file(void *optctx, const char *filename)
3803 {
3804     OptionsContext *o = optctx;
3805     AVFormatContext *oc;
3806     int i, err;
3807     AVOutputFormat *file_oformat;
3808     OutputStream *ost;
3809     InputStream  *ist;
3810
3811     if (!strcmp(filename, "-"))
3812         filename = "pipe:";
3813
3814     oc = avformat_alloc_context();
3815     if (!oc) {
3816         print_error(filename, AVERROR(ENOMEM));
3817         exit_program(1);
3818     }
3819
3820     if (o->format) {
3821         file_oformat = av_guess_format(o->format, NULL, NULL);
3822         if (!file_oformat) {
3823             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
3824             exit_program(1);
3825         }
3826     } else {
3827         file_oformat = av_guess_format(NULL, filename, NULL);
3828         if (!file_oformat) {
3829             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
3830                    filename);
3831             exit_program(1);
3832         }
3833     }
3834
3835     oc->oformat = file_oformat;
3836     oc->interrupt_callback = int_cb;
3837     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3838
3839     if (!o->nb_stream_maps) {
3840         /* pick the "best" stream of each type */
3841 #define NEW_STREAM(type, index)\
3842         if (index >= 0) {\
3843             ost = new_ ## type ## _stream(o, oc);\
3844             ost->source_index = index;\
3845             ost->sync_ist     = &input_streams[index];\
3846             input_streams[index].discard = 0;\
3847         }
3848
3849         /* video: highest resolution */
3850         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3851             int area = 0, idx = -1;
3852             for (i = 0; i < nb_input_streams; i++) {
3853                 ist = &input_streams[i];
3854                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3855                     ist->st->codec->width * ist->st->codec->height > area) {
3856                     area = ist->st->codec->width * ist->st->codec->height;
3857                     idx = i;
3858                 }
3859             }
3860             NEW_STREAM(video, idx);
3861         }
3862
3863         /* audio: most channels */
3864         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3865             int channels = 0, idx = -1;
3866             for (i = 0; i < nb_input_streams; i++) {
3867                 ist = &input_streams[i];
3868                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3869                     ist->st->codec->channels > channels) {
3870                     channels = ist->st->codec->channels;
3871                     idx = i;
3872                 }
3873             }
3874             NEW_STREAM(audio, idx);
3875         }
3876
3877         /* subtitles: pick first */
3878         if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3879             for (i = 0; i < nb_input_streams; i++)
3880                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3881                     NEW_STREAM(subtitle, i);
3882                     break;
3883                 }
3884         }
3885         /* do something with data? */
3886     } else {
3887         for (i = 0; i < o->nb_stream_maps; i++) {
3888             StreamMap *map = &o->stream_maps[i];
3889
3890             if (map->disabled)
3891                 continue;
3892
3893             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3894             switch (ist->st->codec->codec_type) {
3895             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
3896             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
3897             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3898             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
3899             case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3900             default:
3901                 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
3902                        map->file_index, map->stream_index);
3903                 exit_program(1);
3904             }
3905
3906             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3907             ost->sync_ist     = &input_streams[input_files[map->sync_file_index].ist_index +
3908                                            map->sync_stream_index];
3909             ist->discard = 0;
3910         }
3911     }
3912
3913     /* handle attached files */
3914     for (i = 0; i < o->nb_attachments; i++) {
3915         AVIOContext *pb;
3916         uint8_t *attachment;
3917         const char *p;
3918         int64_t len;
3919
3920         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
3921             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
3922                    o->attachments[i]);
3923             exit_program(1);
3924         }
3925         if ((len = avio_size(pb)) <= 0) {
3926             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
3927                    o->attachments[i]);
3928             exit_program(1);
3929         }
3930         if (!(attachment = av_malloc(len))) {
3931             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
3932                    o->attachments[i]);
3933             exit_program(1);
3934         }
3935         avio_read(pb, attachment, len);
3936
3937         ost = new_attachment_stream(o, oc);
3938         ost->stream_copy               = 0;
3939         ost->source_index              = -1;
3940         ost->attachment_filename       = o->attachments[i];
3941         ost->st->codec->extradata      = attachment;
3942         ost->st->codec->extradata_size = len;
3943
3944         p = strrchr(o->attachments[i], '/');
3945         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
3946         avio_close(pb);
3947     }
3948
3949     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3950     output_files[nb_output_files - 1].ctx       = oc;
3951     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3952     output_files[nb_output_files - 1].recording_time = o->recording_time;
3953     output_files[nb_output_files - 1].start_time     = o->start_time;
3954     output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3955     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3956
3957     /* check filename in case of an image number is expected */
3958     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3959         if (!av_filename_number_test(oc->filename)) {
3960             print_error(oc->filename, AVERROR(EINVAL));
3961             exit_program(1);
3962         }
3963     }
3964
3965     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3966         /* test if it already exists to avoid losing precious files */
3967         assert_file_overwrite(filename);
3968
3969         /* open the file */
3970         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
3971                               &oc->interrupt_callback,
3972                               &output_files[nb_output_files - 1].opts)) < 0) {
3973             print_error(filename, err);
3974             exit_program(1);
3975         }
3976     }
3977
3978     if (o->mux_preload) {
3979         uint8_t buf[64];
3980         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
3981         av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
3982     }
3983     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3984     oc->flags |= AVFMT_FLAG_NONBLOCK;
3985
3986     /* copy metadata */
3987     for (i = 0; i < o->nb_metadata_map; i++) {
3988         char *p;
3989         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
3990
3991         if (in_file_index < 0)
3992             continue;
3993         if (in_file_index >= nb_input_files) {
3994             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
3995             exit_program(1);
3996         }
3997         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
3998     }
3999
4000     /* copy chapters */
4001     if (o->chapters_input_file >= nb_input_files) {
4002         if (o->chapters_input_file == INT_MAX) {
4003             /* copy chapters from the first input file that has them*/
4004             o->chapters_input_file = -1;
4005             for (i = 0; i < nb_input_files; i++)
4006                 if (input_files[i].ctx->nb_chapters) {
4007                     o->chapters_input_file = i;
4008                     break;
4009                 }
4010         } else {
4011             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4012                    o->chapters_input_file);
4013             exit_program(1);
4014         }
4015     }
4016     if (o->chapters_input_file >= 0)
4017         copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4018                       !o->metadata_chapters_manual);
4019
4020     /* copy global metadata by default */
4021     if (!o->metadata_global_manual && nb_input_files)
4022         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4023                      AV_DICT_DONT_OVERWRITE);
4024     if (!o->metadata_streams_manual)
4025         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4026             InputStream *ist;
4027             if (output_streams[i].source_index < 0)         /* this is true e.g. for attached files */
4028                 continue;
4029             ist = &input_streams[output_streams[i].source_index];
4030             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4031         }
4032
4033     /* process manually set metadata */
4034     for (i = 0; i < o->nb_metadata; i++) {
4035         AVDictionary **m;
4036         char type, *val;
4037         const char *stream_spec;
4038         int index = 0, j, ret;
4039
4040         val = strchr(o->metadata[i].u.str, '=');
4041         if (!val) {
4042             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4043                    o->metadata[i].u.str);
4044             exit_program(1);
4045         }
4046         *val++ = 0;
4047
4048         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4049         if (type == 's') {
4050             for (j = 0; j < oc->nb_streams; j++) {
4051                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4052                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4053                 } else if (ret < 0)
4054                     exit_program(1);
4055             }
4056             printf("ret %d, stream_spec %s\n", ret, stream_spec);
4057         }
4058         else {
4059             switch (type) {
4060             case 'g':
4061                 m = &oc->metadata;
4062                 break;
4063             case 'c':
4064                 if (index < 0 || index >= oc->nb_chapters) {
4065                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4066                     exit_program(1);
4067                 }
4068                 m = &oc->chapters[index]->metadata;
4069                 break;
4070             default:
4071                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4072                 exit_program(1);
4073             }
4074             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4075         }
4076     }
4077
4078     reset_options(o);
4079 }
4080
4081 /* same option as mencoder */
4082 static int opt_pass(const char *opt, const char *arg)
4083 {
4084     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4085     return 0;
4086 }
4087
4088 static int64_t getutime(void)
4089 {
4090 #if HAVE_GETRUSAGE
4091     struct rusage rusage;
4092
4093     getrusage(RUSAGE_SELF, &rusage);
4094     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4095 #elif HAVE_GETPROCESSTIMES
4096     HANDLE proc;
4097     FILETIME c, e, k, u;
4098     proc = GetCurrentProcess();
4099     GetProcessTimes(proc, &c, &e, &k, &u);
4100     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4101 #else
4102     return av_gettime();
4103 #endif
4104 }
4105
4106 static int64_t getmaxrss(void)
4107 {
4108 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4109     struct rusage rusage;
4110     getrusage(RUSAGE_SELF, &rusage);
4111     return (int64_t)rusage.ru_maxrss * 1024;
4112 #elif HAVE_GETPROCESSMEMORYINFO
4113     HANDLE proc;
4114     PROCESS_MEMORY_COUNTERS memcounters;
4115     proc = GetCurrentProcess();
4116     memcounters.cb = sizeof(memcounters);
4117     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4118     return memcounters.PeakPagefileUsage;
4119 #else
4120     return 0;
4121 #endif
4122 }
4123
4124 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4125 {
4126     return parse_option(o, "q:a", arg, options);
4127 }
4128
4129 static void show_usage(void)
4130 {
4131     printf("Hyper fast Audio and Video encoder\n");
4132     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4133     printf("\n");
4134 }
4135
4136 static void show_help(void)
4137 {
4138     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4139     av_log_set_callback(log_callback_help);
4140     show_usage();
4141     show_help_options(options, "Main options:\n",
4142                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4143     show_help_options(options, "\nAdvanced options:\n",
4144                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4145                       OPT_EXPERT);
4146     show_help_options(options, "\nVideo options:\n",
4147                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4148                       OPT_VIDEO);
4149     show_help_options(options, "\nAdvanced Video options:\n",
4150                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4151                       OPT_VIDEO | OPT_EXPERT);
4152     show_help_options(options, "\nAudio options:\n",
4153                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4154                       OPT_AUDIO);
4155     show_help_options(options, "\nAdvanced Audio options:\n",
4156                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4157                       OPT_AUDIO | OPT_EXPERT);
4158     show_help_options(options, "\nSubtitle options:\n",
4159                       OPT_SUBTITLE | OPT_GRAB,
4160                       OPT_SUBTITLE);
4161     show_help_options(options, "\nAudio/Video grab options:\n",
4162                       OPT_GRAB,
4163                       OPT_GRAB);
4164     printf("\n");
4165     show_help_children(avcodec_get_class(), flags);
4166     show_help_children(avformat_get_class(), flags);
4167     show_help_children(sws_get_class(), flags);
4168 }
4169
4170 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4171 {
4172     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4173     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4174
4175     if (!strncmp(arg, "pal-", 4)) {
4176         norm = PAL;
4177         arg += 4;
4178     } else if (!strncmp(arg, "ntsc-", 5)) {
4179         norm = NTSC;
4180         arg += 5;
4181     } else if (!strncmp(arg, "film-", 5)) {
4182         norm = FILM;
4183         arg += 5;
4184     } else {
4185         /* Try to determine PAL/NTSC by peeking in the input files */
4186         if (nb_input_files) {
4187             int i, j, fr;
4188             for (j = 0; j < nb_input_files; j++) {
4189                 for (i = 0; i < input_files[j].nb_streams; i++) {
4190                     AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4191                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4192                         continue;
4193                     fr = c->time_base.den * 1000 / c->time_base.num;
4194                     if (fr == 25000) {
4195                         norm = PAL;
4196                         break;
4197                     } else if ((fr == 29970) || (fr == 23976)) {
4198                         norm = NTSC;
4199                         break;
4200                     }
4201                 }
4202                 if (norm != UNKNOWN)
4203                     break;
4204             }
4205         }
4206         if (norm != UNKNOWN)
4207             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4208     }
4209
4210     if (norm == UNKNOWN) {
4211         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4212         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4213         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4214         exit_program(1);
4215     }
4216
4217     if (!strcmp(arg, "vcd")) {
4218         opt_video_codec(o, "c:v", "mpeg1video");
4219         opt_audio_codec(o, "c:a", "mp2");
4220         parse_option(o, "f", "vcd", options);
4221
4222         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4223         parse_option(o, "r", frame_rates[norm], options);
4224         opt_default("g", norm == PAL ? "15" : "18");
4225
4226         opt_default("b", "1150000");
4227         opt_default("maxrate", "1150000");
4228         opt_default("minrate", "1150000");
4229         opt_default("bufsize", "327680"); // 40*1024*8;
4230
4231         opt_default("b:a", "224000");
4232         parse_option(o, "ar", "44100", options);
4233         parse_option(o, "ac", "2", options);
4234
4235         opt_default("packetsize", "2324");
4236         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4237
4238         /* We have to offset the PTS, so that it is consistent with the SCR.
4239            SCR starts at 36000, but the first two packs contain only padding
4240            and the first pack from the other stream, respectively, may also have
4241            been written before.
4242            So the real data starts at SCR 36000+3*1200. */
4243         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4244     } else if (!strcmp(arg, "svcd")) {
4245
4246         opt_video_codec(o, "c:v", "mpeg2video");
4247         opt_audio_codec(o, "c:a", "mp2");
4248         parse_option(o, "f", "svcd", options);
4249
4250         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4251         parse_option(o, "r", frame_rates[norm], options);
4252         opt_default("g", norm == PAL ? "15" : "18");
4253
4254         opt_default("b", "2040000");
4255         opt_default("maxrate", "2516000");
4256         opt_default("minrate", "0"); // 1145000;
4257         opt_default("bufsize", "1835008"); // 224*1024*8;
4258         opt_default("flags", "+scan_offset");
4259
4260
4261         opt_default("b:a", "224000");
4262         parse_option(o, "ar", "44100", options);
4263
4264         opt_default("packetsize", "2324");
4265
4266     } else if (!strcmp(arg, "dvd")) {
4267
4268         opt_video_codec(o, "c:v", "mpeg2video");
4269         opt_audio_codec(o, "c:a", "ac3");
4270         parse_option(o, "f", "dvd", options);
4271
4272         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4273         parse_option(o, "r", frame_rates[norm], options);
4274         opt_default("g", norm == PAL ? "15" : "18");
4275
4276         opt_default("b", "6000000");
4277         opt_default("maxrate", "9000000");
4278         opt_default("minrate", "0"); // 1500000;
4279         opt_default("bufsize", "1835008"); // 224*1024*8;
4280
4281         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4282         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4283
4284         opt_default("b:a", "448000");
4285         parse_option(o, "ar", "48000", options);
4286
4287     } else if (!strncmp(arg, "dv", 2)) {
4288
4289         parse_option(o, "f", "dv", options);
4290
4291         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4292         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4293                           norm == PAL ? "yuv420p" : "yuv411p", options);
4294         parse_option(o, "r", frame_rates[norm], options);
4295
4296         parse_option(o, "ar", "48000", options);
4297         parse_option(o, "ac", "2", options);
4298
4299     } else {
4300         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4301         return AVERROR(EINVAL);
4302     }
4303     return 0;
4304 }
4305
4306 static int opt_vstats_file(const char *opt, const char *arg)
4307 {
4308     av_free (vstats_filename);
4309     vstats_filename = av_strdup (arg);
4310     return 0;
4311 }
4312
4313 static int opt_vstats(const char *opt, const char *arg)
4314 {
4315     char filename[40];
4316     time_t today2 = time(NULL);
4317     struct tm *today = localtime(&today2);
4318
4319     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4320              today->tm_sec);
4321     return opt_vstats_file(opt, filename);
4322 }
4323
4324 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4325 {
4326     return parse_option(o, "frames:v", arg, options);
4327 }
4328
4329 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4330 {
4331     return parse_option(o, "frames:a", arg, options);
4332 }
4333
4334 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4335 {
4336     return parse_option(o, "frames:d", arg, options);
4337 }
4338
4339 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4340 {
4341     return parse_option(o, "tag:v", arg, options);
4342 }
4343
4344 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4345 {
4346     return parse_option(o, "tag:a", arg, options);
4347 }
4348
4349 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4350 {
4351     return parse_option(o, "tag:s", arg, options);
4352 }
4353
4354 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4355 {
4356     return parse_option(o, "filter:v", arg, options);
4357 }
4358
4359 static int opt_vsync(const char *opt, const char *arg)
4360 {
4361     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CF