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