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