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