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