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