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