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