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