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