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