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