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