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