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