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