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