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