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