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