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