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