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