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