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