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