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