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