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