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