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