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