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