Fix warnings:
[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         AVMetadataTag *t = NULL;
1866         int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1867                                       AV_TIME_BASE_Q, in_ch->time_base);
1868         int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1869                            av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1870
1871
1872         if (in_ch->end < ts_off)
1873             continue;
1874         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1875             break;
1876
1877         out_ch = av_mallocz(sizeof(AVChapter));
1878         if (!out_ch)
1879             return AVERROR(ENOMEM);
1880
1881         out_ch->id        = in_ch->id;
1882         out_ch->time_base = in_ch->time_base;
1883         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1884         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1885
1886         if (metadata_chapters_autocopy)
1887             while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1888                 av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1889
1890         os->nb_chapters++;
1891         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1892         if (!os->chapters)
1893             return AVERROR(ENOMEM);
1894         os->chapters[os->nb_chapters - 1] = out_ch;
1895     }
1896     return 0;
1897 }
1898
1899 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1900                                     AVCodecContext *avctx)
1901 {
1902     char *p;
1903     int n = 1, i;
1904     int64_t t;
1905
1906     for (p = kf; *p; p++)
1907         if (*p == ',')
1908             n++;
1909     ost->forced_kf_count = n;
1910     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1911     if (!ost->forced_kf_pts) {
1912         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1913         ffmpeg_exit(1);
1914     }
1915     for (i = 0; i < n; i++) {
1916         p = i ? strchr(p, ',') + 1 : kf;
1917         t = parse_time_or_die("force_key_frames", p, 1);
1918         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1919     }
1920 }
1921
1922 /*
1923  * The following code is the main loop of the file converter
1924  */
1925 static int transcode(AVFormatContext **output_files,
1926                      int nb_output_files,
1927                      AVFormatContext **input_files,
1928                      int nb_input_files,
1929                      AVStreamMap *stream_maps, int nb_stream_maps)
1930 {
1931     int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1932     AVFormatContext *is, *os;
1933     AVCodecContext *codec, *icodec;
1934     AVOutputStream *ost, **ost_table = NULL;
1935     AVInputStream *ist, **ist_table = NULL;
1936     AVInputFile *file_table;
1937     char error[1024];
1938     int key;
1939     int want_sdp = 1;
1940     uint8_t no_packet[MAX_FILES]={0};
1941     int no_packet_count=0;
1942
1943     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1944     if (!file_table)
1945         goto fail;
1946
1947     /* input stream init */
1948     j = 0;
1949     for(i=0;i<nb_input_files;i++) {
1950         is = input_files[i];
1951         file_table[i].ist_index = j;
1952         file_table[i].nb_streams = is->nb_streams;
1953         j += is->nb_streams;
1954     }
1955     nb_istreams = j;
1956
1957     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1958     if (!ist_table)
1959         goto fail;
1960
1961     for(i=0;i<nb_istreams;i++) {
1962         ist = av_mallocz(sizeof(AVInputStream));
1963         if (!ist)
1964             goto fail;
1965         ist_table[i] = ist;
1966     }
1967     j = 0;
1968     for(i=0;i<nb_input_files;i++) {
1969         is = input_files[i];
1970         for(k=0;k<is->nb_streams;k++) {
1971             ist = ist_table[j++];
1972             ist->st = is->streams[k];
1973             ist->file_index = i;
1974             ist->index = k;
1975             ist->discard = 1; /* the stream is discarded by default
1976                                  (changed later) */
1977
1978             if (rate_emu) {
1979                 ist->start = av_gettime();
1980             }
1981         }
1982     }
1983
1984     /* output stream init */
1985     nb_ostreams = 0;
1986     for(i=0;i<nb_output_files;i++) {
1987         os = output_files[i];
1988         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1989             dump_format(output_files[i], i, output_files[i]->filename, 1);
1990             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1991             ret = AVERROR(EINVAL);
1992             goto fail;
1993         }
1994         nb_ostreams += os->nb_streams;
1995     }
1996     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1997         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1998         ret = AVERROR(EINVAL);
1999         goto fail;
2000     }
2001
2002     /* Sanity check the mapping args -- do the input files & streams exist? */
2003     for(i=0;i<nb_stream_maps;i++) {
2004         int fi = stream_maps[i].file_index;
2005         int si = stream_maps[i].stream_index;
2006
2007         if (fi < 0 || fi > nb_input_files - 1 ||
2008             si < 0 || si > file_table[fi].nb_streams - 1) {
2009             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2010             ret = AVERROR(EINVAL);
2011             goto fail;
2012         }
2013         fi = stream_maps[i].sync_file_index;
2014         si = stream_maps[i].sync_stream_index;
2015         if (fi < 0 || fi > nb_input_files - 1 ||
2016             si < 0 || si > file_table[fi].nb_streams - 1) {
2017             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2018             ret = AVERROR(EINVAL);
2019             goto fail;
2020         }
2021     }
2022
2023     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2024     if (!ost_table)
2025         goto fail;
2026     n = 0;
2027     for(k=0;k<nb_output_files;k++) {
2028         os = output_files[k];
2029         for(i=0;i<os->nb_streams;i++,n++) {
2030             int found;
2031             ost = ost_table[n] = output_streams_for_file[k][i];
2032             ost->st = os->streams[i];
2033             if (nb_stream_maps > 0) {
2034                 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2035                     stream_maps[n].stream_index;
2036
2037                 /* Sanity check that the stream types match */
2038                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2039                     int i= ost->file_index;
2040                     dump_format(output_files[i], i, output_files[i]->filename, 1);
2041                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2042                         stream_maps[n].file_index, stream_maps[n].stream_index,
2043                         ost->file_index, ost->index);
2044                     ffmpeg_exit(1);
2045                 }
2046
2047             } else {
2048                 int best_nb_frames=-1;
2049                 /* get corresponding input stream index : we select the first one with the right type */
2050                 found = 0;
2051                 for(j=0;j<nb_istreams;j++) {
2052                     int skip=0;
2053                     ist = ist_table[j];
2054                     if(opt_programid){
2055                         int pi,si;
2056                         AVFormatContext *f= input_files[ ist->file_index ];
2057                         skip=1;
2058                         for(pi=0; pi<f->nb_programs; pi++){
2059                             AVProgram *p= f->programs[pi];
2060                             if(p->id == opt_programid)
2061                                 for(si=0; si<p->nb_stream_indexes; si++){
2062                                     if(f->streams[ p->stream_index[si] ] == ist->st)
2063                                         skip=0;
2064                                 }
2065                         }
2066                     }
2067                     if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2068                         ist->st->codec->codec_type == ost->st->codec->codec_type) {
2069                         if(best_nb_frames < ist->st->codec_info_nb_frames){
2070                             best_nb_frames= ist->st->codec_info_nb_frames;
2071                             ost->source_index = j;
2072                             found = 1;
2073                         }
2074                     }
2075                 }
2076
2077                 if (!found) {
2078                     if(! opt_programid) {
2079                         /* try again and reuse existing stream */
2080                         for(j=0;j<nb_istreams;j++) {
2081                             ist = ist_table[j];
2082                             if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2083                                 && ist->st->discard != AVDISCARD_ALL) {
2084                                 ost->source_index = j;
2085                                 found = 1;
2086                             }
2087                         }
2088                     }
2089                     if (!found) {
2090                         int i= ost->file_index;
2091                         dump_format(output_files[i], i, output_files[i]->filename, 1);
2092                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2093                                 ost->file_index, ost->index);
2094                         ffmpeg_exit(1);
2095                     }
2096                 }
2097             }
2098             ist = ist_table[ost->source_index];
2099             ist->discard = 0;
2100             ost->sync_ist = (nb_stream_maps > 0) ?
2101                 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2102                          stream_maps[n].sync_stream_index] : ist;
2103         }
2104     }
2105
2106     /* for each output stream, we compute the right encoding parameters */
2107     for(i=0;i<nb_ostreams;i++) {
2108         AVMetadataTag *t = NULL;
2109         ost = ost_table[i];
2110         os = output_files[ost->file_index];
2111         ist = ist_table[ost->source_index];
2112
2113         codec = ost->st->codec;
2114         icodec = ist->st->codec;
2115
2116         if (metadata_streams_autocopy)
2117             while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2118                 av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2119             }
2120
2121         ost->st->disposition = ist->st->disposition;
2122         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2123         codec->chroma_sample_location = icodec->chroma_sample_location;
2124
2125         if (ost->st->stream_copy) {
2126             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2127
2128             if (extra_size > INT_MAX)
2129                 goto fail;
2130
2131             /* if stream_copy is selected, no need to decode or encode */
2132             codec->codec_id = icodec->codec_id;
2133             codec->codec_type = icodec->codec_type;
2134
2135             if(!codec->codec_tag){
2136                 if(   !os->oformat->codec_tag
2137                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2138                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2139                     codec->codec_tag = icodec->codec_tag;
2140             }
2141
2142             codec->bit_rate = icodec->bit_rate;
2143             codec->rc_max_rate    = icodec->rc_max_rate;
2144             codec->rc_buffer_size = icodec->rc_buffer_size;
2145             codec->extradata= av_mallocz(extra_size);
2146             if (!codec->extradata)
2147                 goto fail;
2148             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2149             codec->extradata_size= icodec->extradata_size;
2150             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){
2151                 codec->time_base = icodec->time_base;
2152                 codec->time_base.num *= icodec->ticks_per_frame;
2153                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2154                           codec->time_base.num, codec->time_base.den, INT_MAX);
2155             }else
2156                 codec->time_base = ist->st->time_base;
2157             switch(codec->codec_type) {
2158             case AVMEDIA_TYPE_AUDIO:
2159                 if(audio_volume != 256) {
2160                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2161                     ffmpeg_exit(1);
2162                 }
2163                 codec->channel_layout = icodec->channel_layout;
2164                 codec->sample_rate = icodec->sample_rate;
2165                 codec->channels = icodec->channels;
2166                 codec->frame_size = icodec->frame_size;
2167                 codec->block_align= icodec->block_align;
2168                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2169                     codec->block_align= 0;
2170                 if(codec->codec_id == CODEC_ID_AC3)
2171                     codec->block_align= 0;
2172                 break;
2173             case AVMEDIA_TYPE_VIDEO:
2174                 codec->pix_fmt = icodec->pix_fmt;
2175                 codec->width = icodec->width;
2176                 codec->height = icodec->height;
2177                 codec->has_b_frames = icodec->has_b_frames;
2178                 break;
2179             case AVMEDIA_TYPE_SUBTITLE:
2180                 codec->width = icodec->width;
2181                 codec->height = icodec->height;
2182                 break;
2183             default:
2184                 abort();
2185             }
2186         } else {
2187             switch(codec->codec_type) {
2188             case AVMEDIA_TYPE_AUDIO:
2189                 ost->fifo= av_fifo_alloc(1024);
2190                 if(!ost->fifo)
2191                     goto fail;
2192                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2193                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2194                 icodec->request_channels = codec->channels;
2195                 ist->decoding_needed = 1;
2196                 ost->encoding_needed = 1;
2197                 ost->resample_sample_fmt  = icodec->sample_fmt;
2198                 ost->resample_sample_rate = icodec->sample_rate;
2199                 ost->resample_channels    = icodec->channels;
2200                 break;
2201             case AVMEDIA_TYPE_VIDEO:
2202                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2203                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2204                     ffmpeg_exit(1);
2205                 }
2206                 ost->video_resample = (codec->width != icodec->width   ||
2207                                        codec->height != icodec->height ||
2208                         (codec->pix_fmt != icodec->pix_fmt));
2209                 if (ost->video_resample) {
2210                     avcodec_get_frame_defaults(&ost->pict_tmp);
2211                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2212                                          codec->width, codec->height)) {
2213                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2214                         ffmpeg_exit(1);
2215                     }
2216                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2217                     ost->img_resample_ctx = sws_getContext(
2218                         icodec->width,
2219                         icodec->height,
2220                             icodec->pix_fmt,
2221                             codec->width,
2222                             codec->height,
2223                             codec->pix_fmt,
2224                             sws_flags, NULL, NULL, NULL);
2225                     if (ost->img_resample_ctx == NULL) {
2226                         fprintf(stderr, "Cannot get resampling context\n");
2227                         ffmpeg_exit(1);
2228                     }
2229
2230 #if !CONFIG_AVFILTER
2231                     ost->original_height = icodec->height;
2232                     ost->original_width  = icodec->width;
2233 #endif
2234                     codec->bits_per_raw_sample= 0;
2235                 }
2236                 ost->resample_height = icodec->height;
2237                 ost->resample_width  = icodec->width;
2238                 ost->resample_pix_fmt= icodec->pix_fmt;
2239                 ost->encoding_needed = 1;
2240                 ist->decoding_needed = 1;
2241
2242 #if CONFIG_AVFILTER
2243                 if (configure_filters(ist, ost)) {
2244                     fprintf(stderr, "Error opening filters!\n");
2245                     exit(1);
2246                 }
2247 #endif
2248                 break;
2249             case AVMEDIA_TYPE_SUBTITLE:
2250                 ost->encoding_needed = 1;
2251                 ist->decoding_needed = 1;
2252                 break;
2253             default:
2254                 abort();
2255                 break;
2256             }
2257             /* two pass mode */
2258             if (ost->encoding_needed &&
2259                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2260                 char logfilename[1024];
2261                 FILE *f;
2262
2263                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2264                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2265                          i);
2266                 if (codec->flags & CODEC_FLAG_PASS1) {
2267                     f = fopen(logfilename, "wb");
2268                     if (!f) {
2269                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2270                         ffmpeg_exit(1);
2271                     }
2272                     ost->logfile = f;
2273                 } else {
2274                     char  *logbuffer;
2275                     size_t logbuffer_size;
2276                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2277                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2278                         ffmpeg_exit(1);
2279                     }
2280                     codec->stats_in = logbuffer;
2281                 }
2282             }
2283         }
2284         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2285             int size= codec->width * codec->height;
2286             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2287         }
2288     }
2289
2290     if (!bit_buffer)
2291         bit_buffer = av_malloc(bit_buffer_size);
2292     if (!bit_buffer) {
2293         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2294                 bit_buffer_size);
2295         ret = AVERROR(ENOMEM);
2296         goto fail;
2297     }
2298
2299     /* open each encoder */
2300     for(i=0;i<nb_ostreams;i++) {
2301         ost = ost_table[i];
2302         if (ost->encoding_needed) {
2303             AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2304             AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2305             if (!codec)
2306                 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2307             if (!codec) {
2308                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2309                          ost->st->codec->codec_id, ost->file_index, ost->index);
2310                 ret = AVERROR(EINVAL);
2311                 goto dump_format;
2312             }
2313             if (dec->subtitle_header) {
2314                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2315                 if (!ost->st->codec->subtitle_header) {
2316                     ret = AVERROR(ENOMEM);
2317                     goto dump_format;
2318                 }
2319                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2320                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2321             }
2322             if (avcodec_open(ost->st->codec, codec) < 0) {
2323                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2324                         ost->file_index, ost->index);
2325                 ret = AVERROR(EINVAL);
2326                 goto dump_format;
2327             }
2328             extra_size += ost->st->codec->extradata_size;
2329         }
2330     }
2331
2332     /* open each decoder */
2333     for(i=0;i<nb_istreams;i++) {
2334         ist = ist_table[i];
2335         if (ist->decoding_needed) {
2336             AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2337             if (!codec)
2338                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2339             if (!codec) {
2340                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2341                         ist->st->codec->codec_id, ist->file_index, ist->index);
2342                 ret = AVERROR(EINVAL);
2343                 goto dump_format;
2344             }
2345             if (avcodec_open(ist->st->codec, codec) < 0) {
2346                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2347                         ist->file_index, ist->index);
2348                 ret = AVERROR(EINVAL);
2349                 goto dump_format;
2350             }
2351             //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2352             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2353         }
2354     }
2355
2356     /* init pts */
2357     for(i=0;i<nb_istreams;i++) {
2358         AVStream *st;
2359         ist = ist_table[i];
2360         st= ist->st;
2361         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2362         ist->next_pts = AV_NOPTS_VALUE;
2363         init_pts_correction(&ist->pts_ctx);
2364         ist->is_start = 1;
2365     }
2366
2367     /* set meta data information from input file if required */
2368     for (i=0;i<nb_meta_data_maps;i++) {
2369         AVFormatContext *files[2];
2370         AVMetadata      **meta[2];
2371         AVMetadataTag *mtag;
2372         int j;
2373
2374 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2375         if ((index) < 0 || (index) >= (nb_elems)) {\
2376             snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2377                      (desc), (index));\
2378             ret = AVERROR(EINVAL);\
2379             goto dump_format;\
2380         }
2381
2382         int out_file_index = meta_data_maps[i][0].file;
2383         int in_file_index = meta_data_maps[i][1].file;
2384         if (in_file_index < 0 || out_file_index < 0)
2385             continue;
2386         METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2387         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2388
2389         files[0] = output_files[out_file_index];
2390         files[1] = input_files[in_file_index];
2391
2392         for (j = 0; j < 2; j++) {
2393             AVMetaDataMap *map = &meta_data_maps[i][j];
2394
2395             switch (map->type) {
2396             case 'g':
2397                 meta[j] = &files[j]->metadata;
2398                 break;
2399             case 's':
2400                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2401                 meta[j] = &files[j]->streams[map->index]->metadata;
2402                 break;
2403             case 'c':
2404                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2405                 meta[j] = &files[j]->chapters[map->index]->metadata;
2406                 break;
2407             case 'p':
2408                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2409                 meta[j] = &files[j]->programs[map->index]->metadata;
2410                 break;
2411             }
2412         }
2413
2414         mtag=NULL;
2415         while((mtag=av_metadata_get(*meta[1], "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2416             av_metadata_set2(meta[0], mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2417     }
2418
2419     /* copy global metadata by default */
2420     if (metadata_global_autocopy) {
2421         AVMetadataTag *t = NULL;
2422
2423         while ((t = av_metadata_get(input_files[0]->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
2424             for (i = 0; i < nb_output_files; i++)
2425                 av_metadata_set2(&output_files[i]->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2426     }
2427
2428     /* copy chapters according to chapter maps */
2429     for (i = 0; i < nb_chapter_maps; i++) {
2430         int infile  = chapter_maps[i].in_file;
2431         int outfile = chapter_maps[i].out_file;
2432
2433         if (infile < 0 || outfile < 0)
2434             continue;
2435         if (infile >= nb_input_files) {
2436             snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2437             ret = AVERROR(EINVAL);
2438             goto dump_format;
2439         }
2440         if (outfile >= nb_output_files) {
2441             snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2442             ret = AVERROR(EINVAL);
2443             goto dump_format;
2444         }
2445         copy_chapters(infile, outfile);
2446     }
2447
2448     /* copy chapters from the first input file that has them*/
2449     if (!nb_chapter_maps)
2450         for (i = 0; i < nb_input_files; i++) {
2451             if (!input_files[i]->nb_chapters)
2452                 continue;
2453
2454             for (j = 0; j < nb_output_files; j++)
2455                 if ((ret = copy_chapters(i, j)) < 0)
2456                     goto dump_format;
2457             break;
2458         }
2459
2460     /* open files and write file headers */
2461     for(i=0;i<nb_output_files;i++) {
2462         os = output_files[i];
2463         if (av_write_header(os) < 0) {
2464             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2465             ret = AVERROR(EINVAL);
2466             goto dump_format;
2467         }
2468         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2469             want_sdp = 0;
2470         }
2471     }
2472
2473  dump_format:
2474     /* dump the file output parameters - cannot be done before in case
2475        of stream copy */
2476     for(i=0;i<nb_output_files;i++) {
2477         dump_format(output_files[i], i, output_files[i]->filename, 1);
2478     }
2479
2480     /* dump the stream mapping */
2481     if (verbose >= 0) {
2482         fprintf(stderr, "Stream mapping:\n");
2483         for(i=0;i<nb_ostreams;i++) {
2484             ost = ost_table[i];
2485             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2486                     ist_table[ost->source_index]->file_index,
2487                     ist_table[ost->source_index]->index,
2488                     ost->file_index,
2489                     ost->index);
2490             if (ost->sync_ist != ist_table[ost->source_index])
2491                 fprintf(stderr, " [sync #%d.%d]",
2492                         ost->sync_ist->file_index,
2493                         ost->sync_ist->index);
2494             fprintf(stderr, "\n");
2495         }
2496     }
2497
2498     if (ret) {
2499         fprintf(stderr, "%s\n", error);
2500         goto fail;
2501     }
2502
2503     if (want_sdp) {
2504         print_sdp(output_files, nb_output_files);
2505     }
2506
2507     if (!using_stdin && verbose >= 0) {
2508         fprintf(stderr, "Press [q] to stop encoding\n");
2509         url_set_interrupt_cb(decode_interrupt_cb);
2510     }
2511     term_init();
2512
2513     timer_start = av_gettime();
2514
2515     for(; received_sigterm == 0;) {
2516         int file_index, ist_index;
2517         AVPacket pkt;
2518         double ipts_min;
2519         double opts_min;
2520
2521     redo:
2522         ipts_min= 1e100;
2523         opts_min= 1e100;
2524         /* if 'q' pressed, exits */
2525         if (!using_stdin) {
2526             if (q_pressed)
2527                 break;
2528             /* read_key() returns 0 on EOF */
2529             key = read_key();
2530             if (key == 'q')
2531                 break;
2532         }
2533
2534         /* select the stream that we must read now by looking at the
2535            smallest output pts */
2536         file_index = -1;
2537         for(i=0;i<nb_ostreams;i++) {
2538             double ipts, opts;
2539             ost = ost_table[i];
2540             os = output_files[ost->file_index];
2541             ist = ist_table[ost->source_index];
2542             if(ist->is_past_recording_time || no_packet[ist->file_index])
2543                 continue;
2544                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2545             ipts = (double)ist->pts;
2546             if (!file_table[ist->file_index].eof_reached){
2547                 if(ipts < ipts_min) {
2548                     ipts_min = ipts;
2549                     if(input_sync ) file_index = ist->file_index;
2550                 }
2551                 if(opts < opts_min) {
2552                     opts_min = opts;
2553                     if(!input_sync) file_index = ist->file_index;
2554                 }
2555             }
2556             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2557                 file_index= -1;
2558                 break;
2559             }
2560         }
2561         /* if none, if is finished */
2562         if (file_index < 0) {
2563             if(no_packet_count){
2564                 no_packet_count=0;
2565                 memset(no_packet, 0, sizeof(no_packet));
2566                 usleep(10000);
2567                 continue;
2568             }
2569             break;
2570         }
2571
2572         /* finish if limit size exhausted */
2573         if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2574             break;
2575
2576         /* read a frame from it and output it in the fifo */
2577         is = input_files[file_index];
2578         ret= av_read_frame(is, &pkt);
2579         if(ret == AVERROR(EAGAIN)){
2580             no_packet[file_index]=1;
2581             no_packet_count++;
2582             continue;
2583         }
2584         if (ret < 0) {
2585             file_table[file_index].eof_reached = 1;
2586             if (opt_shortest)
2587                 break;
2588             else
2589                 continue;
2590         }
2591
2592         no_packet_count=0;
2593         memset(no_packet, 0, sizeof(no_packet));
2594
2595         if (do_pkt_dump) {
2596             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2597         }
2598         /* the following test is needed in case new streams appear
2599            dynamically in stream : we ignore them */
2600         if (pkt.stream_index >= file_table[file_index].nb_streams)
2601             goto discard_packet;
2602         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2603         ist = ist_table[ist_index];
2604         if (ist->discard)
2605             goto discard_packet;
2606
2607         if (pkt.dts != AV_NOPTS_VALUE)
2608             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2609         if (pkt.pts != AV_NOPTS_VALUE)
2610             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2611
2612         if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2613             && input_files_ts_scale[file_index][pkt.stream_index]){
2614             if(pkt.pts != AV_NOPTS_VALUE)
2615                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2616             if(pkt.dts != AV_NOPTS_VALUE)
2617                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2618         }
2619
2620 //        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);
2621         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2622             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2623             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2624             int64_t delta= pkt_dts - ist->next_pts;
2625             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2626                 input_files_ts_offset[ist->file_index]-= delta;
2627                 if (verbose > 2)
2628                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2629                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2630                 if(pkt.pts != AV_NOPTS_VALUE)
2631                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2632             }
2633         }
2634
2635         /* finish if recording time exhausted */
2636         if (recording_time != INT64_MAX &&
2637             av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2638             ist->is_past_recording_time = 1;
2639             goto discard_packet;
2640         }
2641
2642         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2643         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2644
2645             if (verbose >= 0)
2646                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2647                         ist->file_index, ist->index);
2648             if (exit_on_error)
2649                 ffmpeg_exit(1);
2650             av_free_packet(&pkt);
2651             goto redo;
2652         }
2653
2654     discard_packet:
2655         av_free_packet(&pkt);
2656
2657         /* dump report by using the output first video and audio streams */
2658         print_report(output_files, ost_table, nb_ostreams, 0);
2659     }
2660
2661     /* at the end of stream, we must flush the decoder buffers */
2662     for(i=0;i<nb_istreams;i++) {
2663         ist = ist_table[i];
2664         if (ist->decoding_needed) {
2665             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2666         }
2667     }
2668
2669     term_exit();
2670
2671     /* write the trailer if needed and close file */
2672     for(i=0;i<nb_output_files;i++) {
2673         os = output_files[i];
2674         av_write_trailer(os);
2675     }
2676
2677     /* dump report by using the first video and audio streams */
2678     print_report(output_files, ost_table, nb_ostreams, 1);
2679
2680     /* close each encoder */
2681     for(i=0;i<nb_ostreams;i++) {
2682         ost = ost_table[i];
2683         if (ost->encoding_needed) {
2684             av_freep(&ost->st->codec->stats_in);
2685             avcodec_close(ost->st->codec);
2686         }
2687     }
2688
2689     /* close each decoder */
2690     for(i=0;i<nb_istreams;i++) {
2691         ist = ist_table[i];
2692         if (ist->decoding_needed) {
2693             avcodec_close(ist->st->codec);
2694         }
2695     }
2696 #if CONFIG_AVFILTER
2697     if (graph) {
2698         avfilter_graph_free(graph);
2699         av_freep(&graph);
2700     }
2701 #endif
2702
2703     /* finished ! */
2704     ret = 0;
2705
2706  fail:
2707     av_freep(&bit_buffer);
2708     av_free(file_table);
2709
2710     if (ist_table) {
2711         for(i=0;i<nb_istreams;i++) {
2712             ist = ist_table[i];
2713             av_free(ist);
2714         }
2715         av_free(ist_table);
2716     }
2717     if (ost_table) {
2718         for(i=0;i<nb_ostreams;i++) {
2719             ost = ost_table[i];
2720             if (ost) {
2721                 if (ost->st->stream_copy)
2722                     av_freep(&ost->st->codec->extradata);
2723                 if (ost->logfile) {
2724                     fclose(ost->logfile);
2725                     ost->logfile = NULL;
2726                 }
2727                 av_fifo_free(ost->fifo); /* works even if fifo is not
2728                                              initialized but set to zero */
2729                 av_freep(&ost->st->codec->subtitle_header);
2730                 av_free(ost->pict_tmp.data[0]);
2731                 av_free(ost->forced_kf_pts);
2732                 if (ost->video_resample)
2733                     sws_freeContext(ost->img_resample_ctx);
2734                 if (ost->resample)
2735                     audio_resample_close(ost->resample);
2736                 if (ost->reformat_ctx)
2737                     av_audio_convert_free(ost->reformat_ctx);
2738                 av_free(ost);
2739             }
2740         }
2741         av_free(ost_table);
2742     }
2743     return ret;
2744 }
2745
2746 static void opt_format(const char *arg)
2747 {
2748     last_asked_format = arg;
2749 }
2750
2751 static void opt_video_rc_override_string(const char *arg)
2752 {
2753     video_rc_override_string = arg;
2754 }
2755
2756 static int opt_me_threshold(const char *opt, const char *arg)
2757 {
2758     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2759     return 0;
2760 }
2761
2762 static int opt_verbose(const char *opt, const char *arg)
2763 {
2764     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2765     return 0;
2766 }
2767
2768 static int opt_frame_rate(const char *opt, const char *arg)
2769 {
2770     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2771         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2772         ffmpeg_exit(1);
2773     }
2774     return 0;
2775 }
2776
2777 static int opt_bitrate(const char *opt, const char *arg)
2778 {
2779     int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2780
2781     opt_default(opt, arg);
2782
2783     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2784         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2785
2786     return 0;
2787 }
2788
2789 static int opt_frame_crop(const char *opt, const char *arg)
2790 {
2791     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2792     return AVERROR(EINVAL);
2793 }
2794
2795 static void opt_frame_size(const char *arg)
2796 {
2797     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2798         fprintf(stderr, "Incorrect frame size\n");
2799         ffmpeg_exit(1);
2800     }
2801 }
2802
2803 static int opt_pad(const char *opt, const char *arg) {
2804     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2805     return -1;
2806 }
2807
2808 static void opt_frame_pix_fmt(const char *arg)
2809 {
2810     if (strcmp(arg, "list")) {
2811         frame_pix_fmt = av_get_pix_fmt(arg);
2812         if (frame_pix_fmt == PIX_FMT_NONE) {
2813             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2814             ffmpeg_exit(1);
2815         }
2816     } else {
2817         show_pix_fmts();
2818         ffmpeg_exit(0);
2819     }
2820 }
2821
2822 static void opt_frame_aspect_ratio(const char *arg)
2823 {
2824     int x = 0, y = 0;
2825     double ar = 0;
2826     const char *p;
2827     char *end;
2828
2829     p = strchr(arg, ':');
2830     if (p) {
2831         x = strtol(arg, &end, 10);
2832         if (end == p)
2833             y = strtol(end+1, &end, 10);
2834         if (x > 0 && y > 0)
2835             ar = (double)x / (double)y;
2836     } else
2837         ar = strtod(arg, NULL);
2838
2839     if (!ar) {
2840         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2841         ffmpeg_exit(1);
2842     }
2843     frame_aspect_ratio = ar;
2844 }
2845
2846 static int opt_metadata(const char *opt, const char *arg)
2847 {
2848     char *mid= strchr(arg, '=');
2849
2850     if(!mid){
2851         fprintf(stderr, "Missing =\n");
2852         ffmpeg_exit(1);
2853     }
2854     *mid++= 0;
2855
2856     av_metadata_set2(&metadata, arg, mid, 0);
2857
2858     return 0;
2859 }
2860
2861 static void opt_qscale(const char *arg)
2862 {
2863     video_qscale = atof(arg);
2864     if (video_qscale <= 0 ||
2865         video_qscale > 255) {
2866         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2867         ffmpeg_exit(1);
2868     }
2869 }
2870
2871 static void opt_top_field_first(const char *arg)
2872 {
2873     top_field_first= atoi(arg);
2874 }
2875
2876 static int opt_thread_count(const char *opt, const char *arg)
2877 {
2878     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2879 #if !HAVE_THREADS
2880     if (verbose >= 0)
2881         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2882 #endif
2883     return 0;
2884 }
2885
2886 static void opt_audio_sample_fmt(const char *arg)
2887 {
2888     if (strcmp(arg, "list"))
2889         audio_sample_fmt = av_get_sample_fmt(arg);
2890     else {
2891         list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2892         ffmpeg_exit(0);
2893     }
2894 }
2895
2896 static int opt_audio_rate(const char *opt, const char *arg)
2897 {
2898     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2899     return 0;
2900 }
2901
2902 static int opt_audio_channels(const char *opt, const char *arg)
2903 {
2904     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2905     return 0;
2906 }
2907
2908 static void opt_video_channel(const char *arg)
2909 {
2910     video_channel = strtol(arg, NULL, 0);
2911 }
2912
2913 static void opt_video_standard(const char *arg)
2914 {
2915     video_standard = av_strdup(arg);
2916 }
2917
2918 static void opt_codec(int *pstream_copy, char **pcodec_name,
2919                       int codec_type, const char *arg)
2920 {
2921     av_freep(pcodec_name);
2922     if (!strcmp(arg, "copy")) {
2923         *pstream_copy = 1;
2924     } else {
2925         *pcodec_name = av_strdup(arg);
2926     }
2927 }
2928
2929 static void opt_audio_codec(const char *arg)
2930 {
2931     opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2932 }
2933
2934 static void opt_video_codec(const char *arg)
2935 {
2936     opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2937 }
2938
2939 static void opt_subtitle_codec(const char *arg)
2940 {
2941     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2942 }
2943
2944 static int opt_codec_tag(const char *opt, const char *arg)
2945 {
2946     char *tail;
2947     uint32_t *codec_tag;
2948
2949     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2950                 !strcmp(opt, "vtag") ? &video_codec_tag :
2951                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2952     if (!codec_tag)
2953         return -1;
2954
2955     *codec_tag = strtol(arg, &tail, 0);
2956     if (!tail || *tail)
2957         *codec_tag = AV_RL32(arg);
2958
2959     return 0;
2960 }
2961
2962 static void opt_map(const char *arg)
2963 {
2964     AVStreamMap *m;
2965     char *p;
2966
2967     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2968     m = &stream_maps[nb_stream_maps-1];
2969
2970     m->file_index = strtol(arg, &p, 0);
2971     if (*p)
2972         p++;
2973
2974     m->stream_index = strtol(p, &p, 0);
2975     if (*p) {
2976         p++;
2977         m->sync_file_index = strtol(p, &p, 0);
2978         if (*p)
2979             p++;
2980         m->sync_stream_index = strtol(p, &p, 0);
2981     } else {
2982         m->sync_file_index = m->file_index;
2983         m->sync_stream_index = m->stream_index;
2984     }
2985 }
2986
2987 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2988 {
2989     *endptr = arg;
2990     if (*arg == ',') {
2991         *type = *(++arg);
2992         switch (*arg) {
2993         case 'g':
2994             break;
2995         case 's':
2996         case 'c':
2997         case 'p':
2998             *index = strtol(++arg, endptr, 0);
2999             break;
3000         default:
3001             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3002             ffmpeg_exit(1);
3003         }
3004     } else
3005         *type = 'g';
3006 }
3007
3008 static void opt_map_meta_data(const char *arg)
3009 {
3010     AVMetaDataMap *m, *m1;
3011     char *p;
3012
3013     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3014                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
3015
3016     m = &meta_data_maps[nb_meta_data_maps - 1][0];
3017     m->file = strtol(arg, &p, 0);
3018     parse_meta_type(p, &m->type, &m->index, &p);
3019     if (*p)
3020         p++;
3021
3022     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3023     m1->file = strtol(p, &p, 0);
3024     parse_meta_type(p, &m1->type, &m1->index, &p);
3025
3026     if (m->type == 'g' || m1->type == 'g')
3027         metadata_global_autocopy = 0;
3028     if (m->type == 's' || m1->type == 's')
3029         metadata_streams_autocopy = 0;
3030     if (m->type == 'c' || m1->type == 'c')
3031         metadata_chapters_autocopy = 0;
3032 }
3033
3034 static void opt_map_chapters(const char *arg)
3035 {
3036     AVChapterMap *c;
3037     char *p;
3038
3039     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3040                               nb_chapter_maps + 1);
3041     c = &chapter_maps[nb_chapter_maps - 1];
3042     c->out_file = strtol(arg, &p, 0);
3043     if (*p)
3044         p++;
3045
3046     c->in_file = strtol(p, &p, 0);
3047 }
3048
3049 static void opt_input_ts_scale(const char *arg)
3050 {
3051     unsigned int stream;
3052     double scale;
3053     char *p;
3054
3055     stream = strtol(arg, &p, 0);
3056     if (*p)
3057         p++;
3058     scale= strtod(p, &p);
3059
3060     if(stream >= MAX_STREAMS)
3061         ffmpeg_exit(1);
3062
3063     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);
3064     input_files_ts_scale[nb_input_files][stream]= scale;
3065 }
3066
3067 static int opt_recording_time(const char *opt, const char *arg)
3068 {
3069     recording_time = parse_time_or_die(opt, arg, 1);
3070     return 0;
3071 }
3072
3073 static int opt_start_time(const char *opt, const char *arg)
3074 {
3075     start_time = parse_time_or_die(opt, arg, 1);
3076     return 0;
3077 }
3078
3079 static int opt_recording_timestamp(const char *opt, const char *arg)
3080 {
3081     recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3082     return 0;
3083 }
3084
3085 static int opt_input_ts_offset(const char *opt, const char *arg)
3086 {
3087     input_ts_offset = parse_time_or_die(opt, arg, 1);
3088     return 0;
3089 }
3090
3091 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3092 {
3093     const char *codec_string = encoder ? "encoder" : "decoder";
3094     AVCodec *codec;
3095
3096     if(!name)
3097         return CODEC_ID_NONE;
3098     codec = encoder ?
3099         avcodec_find_encoder_by_name(name) :
3100         avcodec_find_decoder_by_name(name);
3101     if(!codec) {
3102         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3103         ffmpeg_exit(1);
3104     }
3105     if(codec->type != type) {
3106         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3107         ffmpeg_exit(1);
3108     }
3109     if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3110        strict > FF_COMPLIANCE_EXPERIMENTAL) {
3111         fprintf(stderr, "%s '%s' is experimental and might produce bad "
3112                 "results.\nAdd '-strict experimental' if you want to use it.\n",
3113                 codec_string, codec->name);
3114         codec = encoder ?
3115             avcodec_find_encoder(codec->id) :
3116             avcodec_find_decoder(codec->id);
3117         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3118             fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3119                     codec_string, codec->name);
3120         ffmpeg_exit(1);
3121     }
3122     return codec->id;
3123 }
3124
3125 static void opt_input_file(const char *filename)
3126 {
3127     AVFormatContext *ic;
3128     AVFormatParameters params, *ap = &params;
3129     AVInputFormat *file_iformat = NULL;
3130     int err, i, ret, rfps, rfps_base;
3131     int64_t timestamp;
3132
3133     if (last_asked_format) {
3134         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3135             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3136             ffmpeg_exit(1);
3137         }
3138         last_asked_format = NULL;
3139     }
3140
3141     if (!strcmp(filename, "-"))
3142         filename = "pipe:";
3143
3144     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3145                     !strcmp(filename, "/dev/stdin");
3146
3147     /* get default parameters from command line */
3148     ic = avformat_alloc_context();
3149     if (!ic) {
3150         print_error(filename, AVERROR(ENOMEM));
3151         ffmpeg_exit(1);
3152     }
3153
3154     memset(ap, 0, sizeof(*ap));
3155     ap->prealloced_context = 1;
3156     ap->sample_rate = audio_sample_rate;
3157     ap->channels = audio_channels;
3158     ap->time_base.den = frame_rate.num;
3159     ap->time_base.num = frame_rate.den;
3160     ap->width = frame_width;
3161     ap->height = frame_height;
3162     ap->pix_fmt = frame_pix_fmt;
3163    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3164     ap->channel = video_channel;
3165     ap->standard = video_standard;
3166
3167     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3168
3169     ic->video_codec_id   =
3170         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3171                           avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3172     ic->audio_codec_id   =
3173         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3174                           avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3175     ic->subtitle_codec_id=
3176         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3177                           avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3178     ic->flags |= AVFMT_FLAG_NONBLOCK;
3179
3180     /* open the input file with generic libav function */
3181     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3182     if (err < 0) {
3183         print_error(filename, err);
3184         ffmpeg_exit(1);
3185     }
3186     if(opt_programid) {
3187         int i, j;
3188         int found=0;
3189         for(i=0; i<ic->nb_streams; i++){
3190             ic->streams[i]->discard= AVDISCARD_ALL;
3191         }
3192         for(i=0; i<ic->nb_programs; i++){
3193             AVProgram *p= ic->programs[i];
3194             if(p->id != opt_programid){
3195                 p->discard = AVDISCARD_ALL;
3196             }else{
3197                 found=1;
3198                 for(j=0; j<p->nb_stream_indexes; j++){
3199                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3200                 }
3201             }
3202         }
3203         if(!found){
3204             fprintf(stderr, "Specified program id not found\n");
3205             ffmpeg_exit(1);
3206         }
3207         opt_programid=0;
3208     }
3209
3210     ic->loop_input = loop_input;
3211
3212     /* If not enough info to get the stream parameters, we decode the
3213        first frames to get it. (used in mpeg case for example) */
3214     ret = av_find_stream_info(ic);
3215     if (ret < 0 && verbose >= 0) {
3216         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3217         av_close_input_file(ic);
3218         ffmpeg_exit(1);
3219     }
3220
3221     timestamp = start_time;
3222     /* add the stream start time */
3223     if (ic->start_time != AV_NOPTS_VALUE)
3224         timestamp += ic->start_time;
3225
3226     /* if seeking requested, we execute it */
3227     if (start_time != 0) {
3228         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3229         if (ret < 0) {
3230             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3231                     filename, (double)timestamp / AV_TIME_BASE);
3232         }
3233         /* reset seek info */
3234         start_time = 0;
3235     }
3236
3237     /* update the current parameters so that they match the one of the input stream */
3238     for(i=0;i<ic->nb_streams;i++) {
3239         AVStream *st = ic->streams[i];
3240         AVCodecContext *dec = st->codec;
3241         avcodec_thread_init(dec, thread_count);
3242         input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3243         switch (dec->codec_type) {
3244         case AVMEDIA_TYPE_AUDIO:
3245             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3246             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]);
3247             //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3248             channel_layout    = dec->channel_layout;
3249             audio_channels    = dec->channels;
3250             audio_sample_rate = dec->sample_rate;
3251             audio_sample_fmt  = dec->sample_fmt;
3252             if(audio_disable)
3253                 st->discard= AVDISCARD_ALL;
3254             /* Note that av_find_stream_info can add more streams, and we
3255              * currently have no chance of setting up lowres decoding
3256              * early enough for them. */
3257             if (dec->lowres)
3258                 audio_sample_rate >>= dec->lowres;
3259             break;
3260         case AVMEDIA_TYPE_VIDEO:
3261             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3262             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]);
3263             frame_height = dec->height;
3264             frame_width  = dec->width;
3265             if(ic->streams[i]->sample_aspect_ratio.num)
3266                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3267             else
3268                 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3269             frame_aspect_ratio *= (float) dec->width / dec->height;
3270             frame_pix_fmt = dec->pix_fmt;
3271             rfps      = ic->streams[i]->r_frame_rate.num;
3272             rfps_base = ic->streams[i]->r_frame_rate.den;
3273             if (dec->lowres) {
3274                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3275                 frame_height >>= dec->lowres;
3276                 frame_width  >>= dec->lowres;
3277                 dec->height = frame_height;
3278                 dec->width  = frame_width;
3279             }
3280             if(me_threshold)
3281                 dec->debug |= FF_DEBUG_MV;
3282
3283             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3284
3285                 if (verbose >= 0)
3286                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3287                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3288
3289                     (float)rfps / rfps_base, rfps, rfps_base);
3290             }
3291             /* update the current frame rate to match the stream frame rate */
3292             frame_rate.num = rfps;
3293             frame_rate.den = rfps_base;
3294
3295             if(video_disable)
3296                 st->discard= AVDISCARD_ALL;
3297             else if(video_discard)
3298                 st->discard= video_discard;
3299             break;
3300         case AVMEDIA_TYPE_DATA:
3301             break;
3302         case AVMEDIA_TYPE_SUBTITLE:
3303             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3304             if(subtitle_disable)
3305                 st->discard = AVDISCARD_ALL;
3306             break;
3307         case AVMEDIA_TYPE_ATTACHMENT:
3308         case AVMEDIA_TYPE_UNKNOWN:
3309             break;
3310         default:
3311             abort();
3312         }
3313     }
3314
3315     input_files[nb_input_files] = ic;
3316     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3317     /* dump the file content */
3318     if (verbose >= 0)
3319         dump_format(ic, nb_input_files, filename, 0);
3320
3321     nb_input_files++;
3322
3323     video_channel = 0;
3324
3325     av_freep(&video_codec_name);
3326     av_freep(&audio_codec_name);
3327     av_freep(&subtitle_codec_name);
3328 }
3329
3330 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3331                                          int *has_subtitle_ptr)
3332 {
3333     int has_video, has_audio, has_subtitle, i, j;
3334     AVFormatContext *ic;
3335
3336     has_video = 0;
3337     has_audio = 0;
3338     has_subtitle = 0;
3339     for(j=0;j<nb_input_files;j++) {
3340         ic = input_files[j];
3341         for(i=0;i<ic->nb_streams;i++) {
3342             AVCodecContext *enc = ic->streams[i]->codec;
3343             switch(enc->codec_type) {
3344             case AVMEDIA_TYPE_AUDIO:
3345                 has_audio = 1;
3346                 break;
3347             case AVMEDIA_TYPE_VIDEO:
3348                 has_video = 1;
3349                 break;
3350             case AVMEDIA_TYPE_SUBTITLE:
3351                 has_subtitle = 1;
3352                 break;
3353             case AVMEDIA_TYPE_DATA:
3354             case AVMEDIA_TYPE_ATTACHMENT:
3355             case AVMEDIA_TYPE_UNKNOWN:
3356                 break;
3357             default:
3358                 abort();
3359             }
3360         }
3361     }
3362     *has_video_ptr = has_video;
3363     *has_audio_ptr = has_audio;
3364     *has_subtitle_ptr = has_subtitle;
3365 }
3366
3367 static void new_video_stream(AVFormatContext *oc, int file_idx)
3368 {
3369     AVStream *st;
3370     AVOutputStream *ost;
3371     AVCodecContext *video_enc;
3372     enum CodecID codec_id = CODEC_ID_NONE;
3373     AVCodec *codec= NULL;
3374
3375     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3376     if (!st) {
3377         fprintf(stderr, "Could not alloc stream\n");
3378         ffmpeg_exit(1);
3379     }
3380     ost = new_output_stream(oc, file_idx);
3381
3382     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3383     if(!video_stream_copy){
3384         if (video_codec_name) {
3385             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3386                                          avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3387             codec = avcodec_find_encoder_by_name(video_codec_name);
3388             output_codecs[nb_output_codecs-1] = codec;
3389         } else {
3390             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3391             codec = avcodec_find_encoder(codec_id);
3392         }
3393     }
3394
3395     avcodec_get_context_defaults3(st->codec, codec);
3396     ost->bitstream_filters = video_bitstream_filters;
3397     video_bitstream_filters= NULL;
3398
3399     avcodec_thread_init(st->codec, thread_count);
3400
3401     video_enc = st->codec;
3402
3403     if(video_codec_tag)
3404         video_enc->codec_tag= video_codec_tag;
3405
3406     if(   (video_global_header&1)
3407        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3408         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3409         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3410     }
3411     if(video_global_header&2){
3412         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3413         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3414     }
3415
3416     if (video_stream_copy) {
3417         st->stream_copy = 1;
3418         video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3419         video_enc->sample_aspect_ratio =
3420         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3421     } else {
3422         const char *p;
3423         int i;
3424         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3425
3426         video_enc->codec_id = codec_id;
3427         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3428
3429         if (codec && codec->supported_framerates && !force_fps)
3430             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3431         video_enc->time_base.den = fps.num;
3432         video_enc->time_base.num = fps.den;
3433
3434         video_enc->width = frame_width;
3435         video_enc->height = frame_height;
3436         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3437         video_enc->pix_fmt = frame_pix_fmt;
3438         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3439
3440         choose_pixel_fmt(st, codec);
3441
3442         if (intra_only)
3443             video_enc->gop_size = 0;
3444         if (video_qscale || same_quality) {
3445             video_enc->flags |= CODEC_FLAG_QSCALE;
3446             video_enc->global_quality=
3447                 st->quality = FF_QP2LAMBDA * video_qscale;
3448         }
3449
3450         if(intra_matrix)
3451             video_enc->intra_matrix = intra_matrix;
3452         if(inter_matrix)
3453             video_enc->inter_matrix = inter_matrix;
3454
3455         p= video_rc_override_string;
3456         for(i=0; p; i++){
3457             int start, end, q;
3458             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3459             if(e!=3){
3460                 fprintf(stderr, "error parsing rc_override\n");
3461                 ffmpeg_exit(1);
3462             }
3463             video_enc->rc_override=
3464                 av_realloc(video_enc->rc_override,
3465                            sizeof(RcOverride)*(i+1));
3466             video_enc->rc_override[i].start_frame= start;
3467             video_enc->rc_override[i].end_frame  = end;
3468             if(q>0){
3469                 video_enc->rc_override[i].qscale= q;
3470                 video_enc->rc_override[i].quality_factor= 1.0;
3471             }
3472             else{
3473                 video_enc->rc_override[i].qscale= 0;
3474                 video_enc->rc_override[i].quality_factor= -q/100.0;
3475             }
3476             p= strchr(p, '/');
3477             if(p) p++;
3478         }
3479         video_enc->rc_override_count=i;
3480         if (!video_enc->rc_initial_buffer_occupancy)
3481             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3482         video_enc->me_threshold= me_threshold;
3483         video_enc->intra_dc_precision= intra_dc_precision - 8;
3484
3485         if (do_psnr)
3486             video_enc->flags|= CODEC_FLAG_PSNR;
3487
3488         /* two pass mode */
3489         if (do_pass) {
3490             if (do_pass == 1) {
3491                 video_enc->flags |= CODEC_FLAG_PASS1;
3492             } else {
3493                 video_enc->flags |= CODEC_FLAG_PASS2;
3494             }
3495         }
3496
3497         if (forced_key_frames)
3498             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3499     }
3500     if (video_language) {
3501         av_metadata_set2(&st->metadata, "language", video_language, 0);
3502         av_freep(&video_language);
3503     }
3504
3505     /* reset some key parameters */
3506     video_disable = 0;
3507     av_freep(&video_codec_name);
3508     av_freep(&forced_key_frames);
3509     video_stream_copy = 0;
3510     frame_pix_fmt = PIX_FMT_NONE;
3511 }
3512
3513 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3514 {
3515     AVStream *st;
3516     AVOutputStream *ost;
3517     AVCodec *codec= NULL;
3518     AVCodecContext *audio_enc;
3519     enum CodecID codec_id = CODEC_ID_NONE;
3520
3521     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3522     if (!st) {
3523         fprintf(stderr, "Could not alloc stream\n");
3524         ffmpeg_exit(1);
3525     }
3526     ost = new_output_stream(oc, file_idx);
3527
3528     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3529     if(!audio_stream_copy){
3530         if (audio_codec_name) {
3531             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3532                                          avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3533             codec = avcodec_find_encoder_by_name(audio_codec_name);
3534             output_codecs[nb_output_codecs-1] = codec;
3535         } else {
3536             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3537             codec = avcodec_find_encoder(codec_id);
3538         }
3539     }
3540
3541     avcodec_get_context_defaults3(st->codec, codec);
3542
3543     ost->bitstream_filters = audio_bitstream_filters;
3544     audio_bitstream_filters= NULL;
3545
3546     avcodec_thread_init(st->codec, thread_count);
3547
3548     audio_enc = st->codec;
3549     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3550
3551     if(audio_codec_tag)
3552         audio_enc->codec_tag= audio_codec_tag;
3553
3554     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3555         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3556         avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3557     }
3558     if (audio_stream_copy) {
3559         st->stream_copy = 1;
3560         audio_enc->channels = audio_channels;
3561         audio_enc->sample_rate = audio_sample_rate;
3562     } else {
3563         audio_enc->codec_id = codec_id;
3564         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3565
3566         if (audio_qscale > QSCALE_NONE) {
3567             audio_enc->flags |= CODEC_FLAG_QSCALE;
3568             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3569         }
3570         audio_enc->channels = audio_channels;
3571         audio_enc->sample_fmt = audio_sample_fmt;
3572         audio_enc->sample_rate = audio_sample_rate;
3573         audio_enc->channel_layout = channel_layout;
3574         if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3575             audio_enc->channel_layout = 0;
3576         choose_sample_fmt(st, codec);
3577         choose_sample_rate(st, codec);
3578     }
3579     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3580     if (audio_language) {
3581         av_metadata_set2(&st->metadata, "language", audio_language, 0);
3582         av_freep(&audio_language);
3583     }
3584
3585     /* reset some key parameters */
3586     audio_disable = 0;
3587     av_freep(&audio_codec_name);
3588     audio_stream_copy = 0;
3589 }
3590
3591 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3592 {
3593     AVStream *st;
3594     AVOutputStream *ost;
3595     AVCodec *codec=NULL;
3596     AVCodecContext *subtitle_enc;
3597     enum CodecID codec_id = CODEC_ID_NONE;
3598
3599     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3600     if (!st) {
3601         fprintf(stderr, "Could not alloc stream\n");
3602         ffmpeg_exit(1);
3603     }
3604     ost = new_output_stream(oc, file_idx);
3605     subtitle_enc = st->codec;
3606     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3607     if(!subtitle_stream_copy){
3608         if (subtitle_codec_name) {
3609             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3610                                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3611             codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3612         } else {
3613             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3614             codec = avcodec_find_encoder(codec_id);
3615         }
3616     }
3617     avcodec_get_context_defaults3(st->codec, codec);
3618
3619     ost->bitstream_filters = subtitle_bitstream_filters;
3620     subtitle_bitstream_filters= NULL;
3621
3622     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3623
3624     if(subtitle_codec_tag)
3625         subtitle_enc->codec_tag= subtitle_codec_tag;
3626
3627     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3628         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3629         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3630     }
3631     if (subtitle_stream_copy) {
3632         st->stream_copy = 1;
3633     } else {
3634         subtitle_enc->codec_id = codec_id;
3635         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3636     }
3637
3638     if (subtitle_language) {
3639         av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3640         av_freep(&subtitle_language);
3641     }
3642
3643     subtitle_disable = 0;
3644     av_freep(&subtitle_codec_name);
3645     subtitle_stream_copy = 0;
3646 }
3647
3648 static int opt_new_stream(const char *opt, const char *arg)
3649 {
3650     AVFormatContext *oc;
3651     int file_idx = nb_output_files - 1;
3652     if (nb_output_files <= 0) {
3653         fprintf(stderr, "At least one output file must be specified\n");
3654         ffmpeg_exit(1);
3655     }
3656     oc = output_files[file_idx];
3657
3658     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3659     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3660     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3661     else av_assert0(0);
3662     return 0;
3663 }
3664
3665 /* arg format is "output-stream-index:streamid-value". */
3666 static int opt_streamid(const char *opt, const char *arg)
3667 {
3668     int idx;
3669     char *p;
3670     char idx_str[16];
3671
3672     strncpy(idx_str, arg, sizeof(idx_str));
3673     idx_str[sizeof(idx_str)-1] = '\0';
3674     p = strchr(idx_str, ':');
3675     if (!p) {
3676         fprintf(stderr,
3677                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3678                 arg, opt);
3679         ffmpeg_exit(1);
3680     }
3681     *p++ = '\0';
3682     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3683     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3684     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3685     return 0;
3686 }
3687
3688 static void opt_output_file(const char *filename)
3689 {
3690     AVFormatContext *oc;
3691     int err, use_video, use_audio, use_subtitle;
3692     int input_has_video, input_has_audio, input_has_subtitle;
3693     AVFormatParameters params, *ap = &params;
3694     AVOutputFormat *file_oformat;
3695     AVMetadataTag *tag = NULL;
3696
3697     if (!strcmp(filename, "-"))
3698         filename = "pipe:";
3699
3700     oc = avformat_alloc_context();
3701     if (!oc) {
3702         print_error(filename, AVERROR(ENOMEM));
3703         ffmpeg_exit(1);
3704     }
3705
3706     if (last_asked_format) {
3707         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3708         if (!file_oformat) {
3709             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3710             ffmpeg_exit(1);
3711         }
3712         last_asked_format = NULL;
3713     } else {
3714         file_oformat = av_guess_format(NULL, filename, NULL);
3715         if (!file_oformat) {
3716             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3717                     filename);
3718             ffmpeg_exit(1);
3719         }
3720     }
3721
3722     oc->oformat = file_oformat;
3723     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3724
3725     if (!strcmp(file_oformat->name, "ffm") &&
3726         av_strstart(filename, "http:", NULL)) {
3727         /* special case for files sent to ffserver: we get the stream
3728            parameters from ffserver */
3729         int err = read_ffserver_streams(oc, filename);
3730         if (err < 0) {
3731             print_error(filename, err);
3732             ffmpeg_exit(1);
3733         }
3734     } else {
3735         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3736         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3737         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3738
3739         /* disable if no corresponding type found and at least one
3740            input file */
3741         if (nb_input_files > 0) {
3742             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3743                                          &input_has_subtitle);
3744             if (!input_has_video)
3745                 use_video = 0;
3746             if (!input_has_audio)
3747                 use_audio = 0;
3748             if (!input_has_subtitle)
3749                 use_subtitle = 0;
3750         }
3751
3752         /* manual disable */
3753         if (audio_disable)    use_audio    = 0;
3754         if (video_disable)    use_video    = 0;
3755         if (subtitle_disable) use_subtitle = 0;
3756
3757         if (use_video)    new_video_stream(oc, nb_output_files);
3758         if (use_audio)    new_audio_stream(oc, nb_output_files);
3759         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3760
3761         oc->timestamp = recording_timestamp;
3762
3763         while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
3764             av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);
3765         av_metadata_free(&metadata);
3766     }
3767
3768     output_files[nb_output_files++] = oc;
3769
3770     /* check filename in case of an image number is expected */
3771     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3772         if (!av_filename_number_test(oc->filename)) {
3773             print_error(oc->filename, AVERROR_NUMEXPECTED);
3774             ffmpeg_exit(1);
3775         }
3776     }
3777
3778     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3779         /* test if it already exists to avoid loosing precious files */
3780         if (!file_overwrite &&
3781             (strchr(filename, ':') == NULL ||
3782              filename[1] == ':' ||
3783              av_strstart(filename, "file:", NULL))) {
3784             if (url_exist(filename)) {
3785                 if (!using_stdin) {
3786                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3787                     fflush(stderr);
3788                     if (!read_yesno()) {
3789                         fprintf(stderr, "Not overwriting - exiting\n");
3790                         ffmpeg_exit(1);
3791                     }
3792                 }
3793                 else {
3794                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3795                     ffmpeg_exit(1);
3796                 }
3797             }
3798         }
3799
3800         /* open the file */
3801         if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3802             print_error(filename, err);
3803             ffmpeg_exit(1);
3804         }
3805     }
3806
3807     memset(ap, 0, sizeof(*ap));
3808     if (av_set_parameters(oc, ap) < 0) {
3809         fprintf(stderr, "%s: Invalid encoding parameters\n",
3810                 oc->filename);
3811         ffmpeg_exit(1);
3812     }
3813
3814     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3815     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3816     oc->loop_output = loop_output;
3817     oc->flags |= AVFMT_FLAG_NONBLOCK;
3818
3819     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3820
3821     nb_streamid_map = 0;
3822     av_freep(&forced_key_frames);
3823 }
3824
3825 /* same option as mencoder */
3826 static void opt_pass(const char *pass_str)
3827 {
3828     int pass;
3829     pass = atoi(pass_str);
3830     if (pass != 1 && pass != 2) {
3831         fprintf(stderr, "pass number can be only 1 or 2\n");
3832         ffmpeg_exit(1);
3833     }
3834     do_pass = pass;
3835 }
3836
3837 static int64_t getutime(void)
3838 {
3839 #if HAVE_GETRUSAGE
3840     struct rusage rusage;
3841
3842     getrusage(RUSAGE_SELF, &rusage);
3843     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3844 #elif HAVE_GETPROCESSTIMES
3845     HANDLE proc;
3846     FILETIME c, e, k, u;
3847     proc = GetCurrentProcess();
3848     GetProcessTimes(proc, &c, &e, &k, &u);
3849     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3850 #else
3851     return av_gettime();
3852 #endif
3853 }
3854
3855 static int64_t getmaxrss(void)
3856 {
3857 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3858     struct rusage rusage;
3859     getrusage(RUSAGE_SELF, &rusage);
3860     return (int64_t)rusage.ru_maxrss * 1024;
3861 #elif HAVE_GETPROCESSMEMORYINFO
3862     HANDLE proc;
3863     PROCESS_MEMORY_COUNTERS memcounters;
3864     proc = GetCurrentProcess();
3865     memcounters.cb = sizeof(memcounters);
3866     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3867     return memcounters.PeakPagefileUsage;
3868 #else
3869     return 0;
3870 #endif
3871 }
3872
3873 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3874 {
3875     int i;
3876     const char *p = str;
3877     for(i = 0;; i++) {
3878         dest[i] = atoi(p);
3879         if(i == 63)
3880             break;
3881         p = strchr(p, ',');
3882         if(!p) {
3883             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3884             ffmpeg_exit(1);
3885         }
3886         p++;
3887     }
3888 }
3889
3890 static void opt_inter_matrix(const char *arg)
3891 {
3892     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3893     parse_matrix_coeffs(inter_matrix, arg);
3894 }
3895
3896 static void opt_intra_matrix(const char *arg)
3897 {
3898     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3899     parse_matrix_coeffs(intra_matrix, arg);
3900 }
3901
3902 static void show_usage(void)
3903 {
3904     printf("Hyper fast Audio and Video encoder\n");
3905     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3906     printf("\n");
3907 }
3908
3909 static void show_help(void)
3910 {
3911     AVCodec *c;
3912     AVOutputFormat *oformat = NULL;
3913
3914     av_log_set_callback(log_callback_help);
3915     show_usage();
3916     show_help_options(options, "Main options:\n",
3917                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3918     show_help_options(options, "\nAdvanced options:\n",
3919                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3920                       OPT_EXPERT);
3921     show_help_options(options, "\nVideo options:\n",
3922                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3923                       OPT_VIDEO);
3924     show_help_options(options, "\nAdvanced Video options:\n",
3925                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3926                       OPT_VIDEO | OPT_EXPERT);
3927     show_help_options(options, "\nAudio options:\n",
3928                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3929                       OPT_AUDIO);
3930     show_help_options(options, "\nAdvanced Audio options:\n",
3931                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3932                       OPT_AUDIO | OPT_EXPERT);
3933     show_help_options(options, "\nSubtitle options:\n",
3934                       OPT_SUBTITLE | OPT_GRAB,
3935                       OPT_SUBTITLE);
3936     show_help_options(options, "\nAudio/Video grab options:\n",
3937                       OPT_GRAB,
3938                       OPT_GRAB);
3939     printf("\n");
3940     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3941     printf("\n");
3942
3943     /* individual codec options */
3944     c = NULL;
3945     while ((c = av_codec_next(c))) {
3946         if (c->priv_class) {
3947             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3948             printf("\n");
3949         }
3950     }
3951
3952     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3953     printf("\n");
3954
3955     /* individual muxer options */
3956     while ((oformat = av_oformat_next(oformat))) {
3957         if (oformat->priv_class) {
3958             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3959             printf("\n");
3960         }
3961     }
3962
3963     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3964 }
3965
3966 static void opt_target(const char *arg)
3967 {
3968     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3969     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3970
3971     if(!strncmp(arg, "pal-", 4)) {
3972         norm = PAL;
3973         arg += 4;
3974     } else if(!strncmp(arg, "ntsc-", 5)) {
3975         norm = NTSC;
3976         arg += 5;
3977     } else if(!strncmp(arg, "film-", 5)) {
3978         norm = FILM;
3979         arg += 5;
3980     } else {
3981         int fr;
3982         /* Calculate FR via float to avoid int overflow */
3983         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3984         if(fr == 25000) {
3985             norm = PAL;
3986         } else if((fr == 29970) || (fr == 23976)) {
3987             norm = NTSC;
3988         } else {
3989             /* Try to determine PAL/NTSC by peeking in the input files */
3990             if(nb_input_files) {
3991                 int i, j;
3992                 for(j = 0; j < nb_input_files; j++) {
3993                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3994                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3995                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3996                             continue;
3997                         fr = c->time_base.den * 1000 / c->time_base.num;
3998                         if(fr == 25000) {
3999                             norm = PAL;
4000                             break;
4001                         } else if((fr == 29970) || (fr == 23976)) {
4002                             norm = NTSC;
4003                             break;
4004                         }
4005                     }
4006                     if(norm != UNKNOWN)
4007                         break;
4008                 }
4009             }
4010         }
4011         if(verbose && norm != UNKNOWN)
4012             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4013     }
4014
4015     if(norm == UNKNOWN) {
4016         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4017         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4018         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4019         ffmpeg_exit(1);
4020     }
4021
4022     if(!strcmp(arg, "vcd")) {
4023
4024         opt_video_codec("mpeg1video");
4025         opt_audio_codec("mp2");
4026         opt_format("vcd");
4027
4028         opt_frame_size(norm == PAL ? "352x288" : "352x240");
4029         opt_frame_rate(NULL, frame_rates[norm]);
4030         opt_default("g", norm == PAL ? "15" : "18");
4031
4032         opt_default("b", "1150000");
4033         opt_default("maxrate", "1150000");
4034         opt_default("minrate", "1150000");
4035         opt_default("bufsize", "327680"); // 40*1024*8;
4036
4037         opt_default("ab", "224000");
4038         audio_sample_rate = 44100;
4039         audio_channels = 2;
4040
4041         opt_default("packetsize", "2324");
4042         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4043
4044         /* We have to offset the PTS, so that it is consistent with the SCR.
4045            SCR starts at 36000, but the first two packs contain only padding
4046            and the first pack from the other stream, respectively, may also have
4047            been written before.
4048            So the real data starts at SCR 36000+3*1200. */
4049         mux_preload= (36000+3*1200) / 90000.0; //0.44
4050     } else if(!strcmp(arg, "svcd")) {
4051
4052         opt_video_codec("mpeg2video");
4053         opt_audio_codec("mp2");
4054         opt_format("svcd");
4055
4056         opt_frame_size(norm == PAL ? "480x576" : "480x480");
4057         opt_frame_rate(NULL, frame_rates[norm]);
4058         opt_default("g", norm == PAL ? "15" : "18");
4059
4060         opt_default("b", "2040000");
4061         opt_default("maxrate", "2516000");
4062         opt_default("minrate", "0"); //1145000;
4063         opt_default("bufsize", "1835008"); //224*1024*8;
4064         opt_default("flags", "+scan_offset");
4065
4066
4067         opt_default("ab", "224000");
4068         audio_sample_rate = 44100;
4069
4070         opt_default("packetsize", "2324");
4071
4072     } else if(!strcmp(arg, "dvd")) {
4073
4074         opt_video_codec("mpeg2video");
4075         opt_audio_codec("ac3");
4076         opt_format("dvd");
4077
4078         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4079         opt_frame_rate(NULL, frame_rates[norm]);
4080         opt_default("g", norm == PAL ? "15" : "18");
4081
4082         opt_default("b", "6000000");
4083         opt_default("maxrate", "9000000");
4084         opt_default("minrate", "0"); //1500000;
4085         opt_default("bufsize", "1835008"); //224*1024*8;
4086
4087         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4088         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4089
4090         opt_default("ab", "448000");
4091         audio_sample_rate = 48000;
4092
4093     } else if(!strncmp(arg, "dv", 2)) {
4094
4095         opt_format("dv");
4096
4097         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4098         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4099                           (norm == PAL ? "yuv420p" : "yuv411p"));
4100         opt_frame_rate(NULL, frame_rates[norm]);
4101
4102         audio_sample_rate = 48000;
4103         audio_channels = 2;
4104
4105     } else {
4106         fprintf(stderr, "Unknown target: %s\n", arg);
4107         ffmpeg_exit(1);
4108     }
4109 }
4110
4111 static void opt_vstats_file (const char *arg)
4112 {
4113     av_free (vstats_filename);
4114     vstats_filename=av_strdup (arg);
4115 }
4116
4117 static void opt_vstats (void)
4118 {
4119     char filename[40];
4120     time_t today2 = time(NULL);
4121     struct tm *today = localtime(&today2);
4122
4123     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4124              today->tm_sec);
4125     opt_vstats_file(filename);
4126 }
4127
4128 static int opt_bsf(const char *opt, const char *arg)
4129 {
4130     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4131     AVBitStreamFilterContext **bsfp;
4132
4133     if(!bsfc){
4134         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4135         ffmpeg_exit(1);
4136     }
4137
4138     bsfp= *opt == 'v' ? &video_bitstream_filters :
4139           *opt == 'a' ? &audio_bitstream_filters :
4140                         &subtitle_bitstream_filters;
4141     while(*bsfp)
4142         bsfp= &(*bsfp)->next;
4143
4144     *bsfp= bsfc;
4145
4146     return 0;
4147 }
4148
4149 static int opt_preset(const char *opt, const char *arg)
4150 {
4151     FILE *f=NULL;
4152     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4153     char *codec_name = *opt == 'v' ? video_codec_name :
4154                        *opt == 'a' ? audio_codec_name :
4155                                      subtitle_codec_name;
4156
4157     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4158         fprintf(stderr, "File for preset '%s' not found\n", arg);
4159         ffmpeg_exit(1);
4160     }
4161
4162     while(!feof(f)){
4163         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4164         if(line[0] == '#' && !e)
4165             continue;
4166         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4167         if(e){
4168             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4169             ffmpeg_exit(1);
4170         }
4171         if(!strcmp(tmp, "acodec")){
4172             opt_audio_codec(tmp2);
4173         }else if(!strcmp(tmp, "vcodec")){
4174             opt_video_codec(tmp2);
4175         }else if(!strcmp(tmp, "scodec")){
4176             opt_subtitle_codec(tmp2);
4177         }else if(opt_default(tmp, tmp2) < 0){
4178             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4179             ffmpeg_exit(1);
4180         }
4181     }
4182
4183     fclose(f);
4184
4185     return 0;
4186 }
4187
4188 static const OptionDef options[] = {
4189     /* main options */
4190 #include "cmdutils_common_opts.h"
4191     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4192     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4193     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4194     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4195     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile[,metadata]:infile[,metadata]" },
4196     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4197     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4198     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4199     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4200     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4201     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4202     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4203     { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4204     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4205     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4206       "add timings for benchmarking" },
4207     { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4208     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4209       "dump each input packet" },
4210     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4211       "when dumping packets, also dump the payload" },
4212     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4213     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4214     { "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)", "" },
4215     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4216     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4217     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4218     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4219     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4220     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4221     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4222     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4223     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4224     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4225     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4226     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4227     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4228
4229     /* video options */
4230     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4231     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4232     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4233     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4234     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4235     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4236     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
4237     { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4238     { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4239     { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4240     { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4241     { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4242     { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4243     { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4244     { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4245     { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4246     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4247     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4248     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4249     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4250     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4251     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4252     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4253     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4254       "use same video quality as source (implies VBR)" },
4255     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4256     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4257     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4258       "deinterlace pictures" },
4259     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4260     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4261     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4262 #if CONFIG_AVFILTER
4263     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4264 #endif
4265     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4266     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4267     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4268     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4269     { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4270     { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4271     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4272     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4273     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4274     { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4275     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4276
4277     /* audio options */
4278     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4279     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4280     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4281     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4282     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4283     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4284     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4285     { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4286     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4287     { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4288     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4289     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
4290
4291     /* subtitle options */
4292     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4293     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4294     { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },