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