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