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