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