avconv: make -map_chapters accept only the input file index.
[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 loop_input = 0;
147 static int loop_output = AVFMT_NOOUTPUTLOOP;
148 static int qp_hist = 0;
149 #if CONFIG_AVFILTER
150 static char *vfilters = NULL;
151 #endif
152
153 static int intra_only = 0;
154 static int audio_sample_rate = 0;
155 #define QSCALE_NONE -99999
156 static float audio_qscale = QSCALE_NONE;
157 static int audio_disable = 0;
158 static int audio_channels = 0;
159 static char  *audio_codec_name = NULL;
160 static unsigned int audio_codec_tag = 0;
161 static char *audio_language = NULL;
162
163 static int subtitle_disable = 0;
164 static char *subtitle_codec_name = NULL;
165 static char *subtitle_language = NULL;
166 static unsigned int subtitle_codec_tag = 0;
167
168 static int data_disable = 0;
169 static char *data_codec_name = NULL;
170 static unsigned int data_codec_tag = 0;
171
172 static float mux_preload= 0.5;
173 static float mux_max_delay= 0.7;
174
175 static int64_t recording_time = INT64_MAX;
176 static int64_t start_time = 0;
177 static int64_t input_ts_offset = 0;
178 static int file_overwrite = 0;
179 static AVDictionary *metadata;
180 static int do_benchmark = 0;
181 static int do_hex_dump = 0;
182 static int do_pkt_dump = 0;
183 static int do_psnr = 0;
184 static int do_pass = 0;
185 static char *pass_logfilename_prefix = NULL;
186 static int audio_stream_copy = 0;
187 static int video_stream_copy = 0;
188 static int subtitle_stream_copy = 0;
189 static int data_stream_copy = 0;
190 static int video_sync_method= -1;
191 static int audio_sync_method= 0;
192 static float audio_drift_threshold= 0.1;
193 static int copy_ts= 0;
194 static int copy_tb;
195 static int opt_shortest = 0;
196 static char *vstats_filename;
197 static FILE *vstats_file;
198 static int opt_programid = 0;
199 static int copy_initial_nonkeyframes = 0;
200
201 static int rate_emu = 0;
202
203 static int audio_volume = 256;
204
205 static int exit_on_error = 0;
206 static int using_stdin = 0;
207 static int verbose = 1;
208 static int thread_count= 1;
209 static int64_t video_size = 0;
210 static int64_t audio_size = 0;
211 static int64_t extra_size = 0;
212 static int nb_frames_dup = 0;
213 static int nb_frames_drop = 0;
214 static int input_sync;
215 static uint64_t limit_filesize = 0;
216 static int force_fps = 0;
217 static char *forced_key_frames = NULL;
218
219 static float dts_delta_threshold = 10;
220
221 static int64_t timer_start;
222
223 static uint8_t *audio_buf;
224 static uint8_t *audio_out;
225 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
226
227 static short *samples;
228
229 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
230 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
231 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
232
233 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
234
235 struct InputStream;
236
237 typedef struct OutputStream {
238     int file_index;          /* file index */
239     int index;               /* stream index in the output file */
240     int source_index;        /* InputStream index */
241     AVStream *st;            /* stream in the output file */
242     int encoding_needed;     /* true if encoding needed for this stream */
243     int frame_number;
244     /* input pts and corresponding output pts
245        for A/V sync */
246     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
247     struct InputStream *sync_ist; /* input stream to sync against */
248     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
249     AVBitStreamFilterContext *bitstream_filters;
250     AVCodec *enc;
251
252     /* video only */
253     int video_resample;
254     AVFrame pict_tmp;      /* temporary image for resampling */
255     struct SwsContext *img_resample_ctx; /* for image resampling */
256     int resample_height;
257     int resample_width;
258     int resample_pix_fmt;
259     AVRational frame_rate;
260
261     float frame_aspect_ratio;
262
263     /* forced key frames */
264     int64_t *forced_kf_pts;
265     int forced_kf_count;
266     int forced_kf_index;
267
268     /* audio only */
269     int audio_resample;
270     ReSampleContext *resample; /* for audio resampling */
271     int resample_sample_fmt;
272     int resample_channels;
273     int resample_sample_rate;
274     int reformat_pair;
275     AVAudioConvert *reformat_ctx;
276     AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
277     FILE *logfile;
278
279 #if CONFIG_AVFILTER
280     AVFilterContext *output_video_filter;
281     AVFilterContext *input_video_filter;
282     AVFilterBufferRef *picref;
283     char *avfilter;
284     AVFilterGraph *graph;
285 #endif
286
287    int sws_flags;
288    AVDictionary *opts;
289 } OutputStream;
290
291 static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
292 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
293
294 typedef struct InputStream {
295     int file_index;
296     AVStream *st;
297     int discard;             /* true if stream data should be discarded */
298     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
299     AVCodec *dec;
300
301     int64_t       start;     /* time when read started */
302     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
303                                 is not defined */
304     int64_t       pts;       /* current pts */
305     PtsCorrectionContext pts_ctx;
306     double ts_scale;
307     int is_start;            /* is 1 at the start and after a discontinuity */
308     int showed_multi_packet_warning;
309     int is_past_recording_time;
310     AVDictionary *opts;
311 } InputStream;
312
313 typedef struct InputFile {
314     AVFormatContext *ctx;
315     int eof_reached;      /* true if eof reached */
316     int ist_index;        /* index of first stream in ist_table */
317     int buffer_size;      /* current total buffer size */
318     int64_t ts_offset;
319 } InputFile;
320
321 static InputStream *input_streams = NULL;
322 static int         nb_input_streams = 0;
323 static InputFile   *input_files   = NULL;
324 static int         nb_input_files   = 0;
325
326 #if CONFIG_AVFILTER
327
328 static int configure_video_filters(InputStream *ist, OutputStream *ost)
329 {
330     AVFilterContext *last_filter, *filter;
331     /** filter graph containing all filters including input & output */
332     AVCodecContext *codec = ost->st->codec;
333     AVCodecContext *icodec = ist->st->codec;
334     FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
335     AVRational sample_aspect_ratio;
336     char args[255];
337     int ret;
338
339     ost->graph = avfilter_graph_alloc();
340
341     if (ist->st->sample_aspect_ratio.num){
342         sample_aspect_ratio = ist->st->sample_aspect_ratio;
343     }else
344         sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
345
346     snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
347              ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
348              sample_aspect_ratio.num, sample_aspect_ratio.den);
349
350     ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
351                                        "src", args, NULL, ost->graph);
352     if (ret < 0)
353         return ret;
354     ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
355                                        "out", NULL, &ffsink_ctx, ost->graph);
356     if (ret < 0)
357         return ret;
358     last_filter = ost->input_video_filter;
359
360     if (codec->width  != icodec->width || codec->height != icodec->height) {
361         snprintf(args, 255, "%d:%d:flags=0x%X",
362                  codec->width,
363                  codec->height,
364                  ost->sws_flags);
365         if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
366                                                 NULL, args, NULL, ost->graph)) < 0)
367             return ret;
368         if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
369             return ret;
370         last_filter = filter;
371     }
372
373     snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
374     ost->graph->scale_sws_opts = av_strdup(args);
375
376     if (ost->avfilter) {
377         AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
378         AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
379
380         outputs->name    = av_strdup("in");
381         outputs->filter_ctx = last_filter;
382         outputs->pad_idx = 0;
383         outputs->next    = NULL;
384
385         inputs->name    = av_strdup("out");
386         inputs->filter_ctx = ost->output_video_filter;
387         inputs->pad_idx = 0;
388         inputs->next    = NULL;
389
390         if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
391             return ret;
392         av_freep(&ost->avfilter);
393     } else {
394         if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
395             return ret;
396     }
397
398     if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
399         return ret;
400
401     codec->width  = ost->output_video_filter->inputs[0]->w;
402     codec->height = ost->output_video_filter->inputs[0]->h;
403     codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
404         ost->frame_aspect_ratio ? // overriden by the -aspect cli option
405         av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
406         ost->output_video_filter->inputs[0]->sample_aspect_ratio;
407
408     return 0;
409 }
410 #endif /* CONFIG_AVFILTER */
411
412 static void term_exit(void)
413 {
414     av_log(NULL, AV_LOG_QUIET, "");
415 }
416
417 static volatile int received_sigterm = 0;
418 static volatile int received_nb_signals = 0;
419
420 static void
421 sigterm_handler(int sig)
422 {
423     received_sigterm = sig;
424     received_nb_signals++;
425     term_exit();
426 }
427
428 static void term_init(void)
429 {
430     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
431     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
432 #ifdef SIGXCPU
433     signal(SIGXCPU, sigterm_handler);
434 #endif
435 }
436
437 static int decode_interrupt_cb(void)
438 {
439     return received_nb_signals > 1;
440 }
441
442 static int exit_program(int ret)
443 {
444     int i;
445
446     /* close files */
447     for(i=0;i<nb_output_files;i++) {
448         AVFormatContext *s = output_files[i];
449         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
450             avio_close(s->pb);
451         avformat_free_context(s);
452         av_free(output_streams_for_file[i]);
453         av_dict_free(&output_opts[i]);
454     }
455     for(i=0;i<nb_input_files;i++) {
456         av_close_input_file(input_files[i].ctx);
457     }
458     for (i = 0; i < nb_input_streams; i++)
459         av_dict_free(&input_streams[i].opts);
460
461     av_free(intra_matrix);
462     av_free(inter_matrix);
463
464     if (vstats_file)
465         fclose(vstats_file);
466     av_free(vstats_filename);
467
468     av_free(streamid_map);
469     av_free(stream_maps);
470     av_free(meta_data_maps);
471
472     av_freep(&input_streams);
473     av_freep(&input_files);
474
475     av_free(video_codec_name);
476     av_free(audio_codec_name);
477     av_free(subtitle_codec_name);
478     av_free(data_codec_name);
479
480     uninit_opts();
481     av_free(audio_buf);
482     av_free(audio_out);
483     allocated_audio_buf_size= allocated_audio_out_size= 0;
484     av_free(samples);
485
486 #if CONFIG_AVFILTER
487     avfilter_uninit();
488 #endif
489
490     if (received_sigterm) {
491         fprintf(stderr,
492             "Received signal %d: terminating.\n",
493             (int) received_sigterm);
494         exit (255);
495     }
496
497     exit(ret); /* not all OS-es handle main() return value */
498     return ret;
499 }
500
501 static void assert_avoptions(AVDictionary *m)
502 {
503     AVDictionaryEntry *t;
504     if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
505         av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
506         exit_program(1);
507     }
508 }
509
510 static void assert_codec_experimental(AVCodecContext *c, int encoder)
511 {
512     const char *codec_string = encoder ? "encoder" : "decoder";
513     AVCodec *codec;
514     if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
515         c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
516         av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
517                 "results.\nAdd '-strict experimental' if you want to use it.\n",
518                 codec_string, c->codec->name);
519         codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
520         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
521             av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
522                    codec_string, codec->name);
523         exit_program(1);
524     }
525 }
526
527 /* similar to ff_dynarray_add() and av_fast_realloc() */
528 static void *grow_array(void *array, int elem_size, int *size, int new_size)
529 {
530     if (new_size >= INT_MAX / elem_size) {
531         fprintf(stderr, "Array too big.\n");
532         exit_program(1);
533     }
534     if (*size < new_size) {
535         uint8_t *tmp = av_realloc(array, new_size*elem_size);
536         if (!tmp) {
537             fprintf(stderr, "Could not alloc buffer.\n");
538             exit_program(1);
539         }
540         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
541         *size = new_size;
542         return tmp;
543     }
544     return array;
545 }
546
547 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
548 {
549     if(codec && codec->sample_fmts){
550         const enum AVSampleFormat *p= codec->sample_fmts;
551         for(; *p!=-1; p++){
552             if(*p == st->codec->sample_fmt)
553                 break;
554         }
555         if (*p == -1) {
556             av_log(NULL, AV_LOG_WARNING,
557                    "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
558                    av_get_sample_fmt_name(st->codec->sample_fmt),
559                    codec->name,
560                    av_get_sample_fmt_name(codec->sample_fmts[0]));
561             st->codec->sample_fmt = codec->sample_fmts[0];
562         }
563     }
564 }
565
566 /**
567  * Update the requested input sample format based on the output sample format.
568  * This is currently only used to request float output from decoders which
569  * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
570  * Ideally this will be removed in the future when decoders do not do format
571  * conversion and only output in their native format.
572  */
573 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
574                               AVCodecContext *enc)
575 {
576     /* if sample formats match or a decoder sample format has already been
577        requested, just return */
578     if (enc->sample_fmt == dec->sample_fmt ||
579         dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
580         return;
581
582     /* if decoder supports more than one output format */
583     if (dec_codec && dec_codec->sample_fmts &&
584         dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
585         dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
586         const enum AVSampleFormat *p;
587         int min_dec = -1, min_inc = -1;
588
589         /* find a matching sample format in the encoder */
590         for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
591             if (*p == enc->sample_fmt) {
592                 dec->request_sample_fmt = *p;
593                 return;
594             } else if (*p > enc->sample_fmt) {
595                 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
596             } else
597                 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
598         }
599
600         /* if none match, provide the one that matches quality closest */
601         dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
602                                   enc->sample_fmt - min_dec;
603     }
604 }
605
606 static void choose_sample_rate(AVStream *st, AVCodec *codec)
607 {
608     if(codec && codec->supported_samplerates){
609         const int *p= codec->supported_samplerates;
610         int best=0;
611         int best_dist=INT_MAX;
612         for(; *p; p++){
613             int dist= abs(st->codec->sample_rate - *p);
614             if(dist < best_dist){
615                 best_dist= dist;
616                 best= *p;
617             }
618         }
619         if(best_dist){
620             av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
621         }
622         st->codec->sample_rate= best;
623     }
624 }
625
626 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
627 {
628     if(codec && codec->pix_fmts){
629         const enum PixelFormat *p= codec->pix_fmts;
630         if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
631             if(st->codec->codec_id==CODEC_ID_MJPEG){
632                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
633             }else if(st->codec->codec_id==CODEC_ID_LJPEG){
634                 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};
635             }
636         }
637         for(; *p!=-1; p++){
638             if(*p == st->codec->pix_fmt)
639                 break;
640         }
641         if (*p == -1) {
642             if(st->codec->pix_fmt != PIX_FMT_NONE)
643                 av_log(NULL, AV_LOG_WARNING,
644                         "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
645                         av_pix_fmt_descriptors[st->codec->pix_fmt].name,
646                         codec->name,
647                         av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
648             st->codec->pix_fmt = codec->pix_fmts[0];
649         }
650     }
651 }
652
653 static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
654 {
655     OutputStream *ost;
656     AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
657     int idx      = oc->nb_streams - 1;
658
659     if (!st) {
660         av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
661         exit_program(1);
662     }
663
664     output_streams_for_file[file_idx] =
665         grow_array(output_streams_for_file[file_idx],
666                    sizeof(*output_streams_for_file[file_idx]),
667                    &nb_output_streams_for_file[file_idx],
668                    oc->nb_streams);
669     ost = output_streams_for_file[file_idx][idx] =
670         av_mallocz(sizeof(OutputStream));
671     if (!ost) {
672         fprintf(stderr, "Could not alloc output stream\n");
673         exit_program(1);
674     }
675     ost->file_index = file_idx;
676     ost->index = idx;
677     ost->st    = st;
678     ost->enc   = codec;
679     if (codec)
680         ost->opts  = filter_codec_opts(codec_opts, codec->id, 1);
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         if (metadata_streams_autocopy)
2097             av_dict_copy(&ost->st->metadata, ist->st->metadata,
2098                          AV_DICT_DONT_OVERWRITE);
2099
2100         ost->st->disposition = ist->st->disposition;
2101         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2102         codec->chroma_sample_location = icodec->chroma_sample_location;
2103
2104         if (ost->st->stream_copy) {
2105             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2106
2107             if (extra_size > INT_MAX)
2108                 goto fail;
2109
2110             /* if stream_copy is selected, no need to decode or encode */
2111             codec->codec_id = icodec->codec_id;
2112             codec->codec_type = icodec->codec_type;
2113
2114             if(!codec->codec_tag){
2115                 if(   !os->oformat->codec_tag
2116                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2117                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2118                     codec->codec_tag = icodec->codec_tag;
2119             }
2120
2121             codec->bit_rate = icodec->bit_rate;
2122             codec->rc_max_rate    = icodec->rc_max_rate;
2123             codec->rc_buffer_size = icodec->rc_buffer_size;
2124             codec->extradata= av_mallocz(extra_size);
2125             if (!codec->extradata)
2126                 goto fail;
2127             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2128             codec->extradata_size= icodec->extradata_size;
2129             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){
2130                 codec->time_base = icodec->time_base;
2131                 codec->time_base.num *= icodec->ticks_per_frame;
2132                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2133                           codec->time_base.num, codec->time_base.den, INT_MAX);
2134             }else
2135                 codec->time_base = ist->st->time_base;
2136             switch(codec->codec_type) {
2137             case AVMEDIA_TYPE_AUDIO:
2138                 if(audio_volume != 256) {
2139                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2140                     exit_program(1);
2141                 }
2142                 codec->channel_layout = icodec->channel_layout;
2143                 codec->sample_rate = icodec->sample_rate;
2144                 codec->channels = icodec->channels;
2145                 codec->frame_size = icodec->frame_size;
2146                 codec->audio_service_type = icodec->audio_service_type;
2147                 codec->block_align= icodec->block_align;
2148                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2149                     codec->block_align= 0;
2150                 if(codec->codec_id == CODEC_ID_AC3)
2151                     codec->block_align= 0;
2152                 break;
2153             case AVMEDIA_TYPE_VIDEO:
2154                 codec->pix_fmt = icodec->pix_fmt;
2155                 codec->width = icodec->width;
2156                 codec->height = icodec->height;
2157                 codec->has_b_frames = icodec->has_b_frames;
2158                 if (!codec->sample_aspect_ratio.num) {
2159                     codec->sample_aspect_ratio =
2160                     ost->st->sample_aspect_ratio =
2161                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2162                         ist->st->codec->sample_aspect_ratio.num ?
2163                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2164                 }
2165                 break;
2166             case AVMEDIA_TYPE_SUBTITLE:
2167                 codec->width = icodec->width;
2168                 codec->height = icodec->height;
2169                 break;
2170             case AVMEDIA_TYPE_DATA:
2171                 break;
2172             default:
2173                 abort();
2174             }
2175         } else {
2176             if (!ost->enc)
2177                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2178             switch(codec->codec_type) {
2179             case AVMEDIA_TYPE_AUDIO:
2180                 ost->fifo= av_fifo_alloc(1024);
2181                 if(!ost->fifo)
2182                     goto fail;
2183                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2184                 if (!codec->sample_rate) {
2185                     codec->sample_rate = icodec->sample_rate;
2186                     if (icodec->lowres)
2187                         codec->sample_rate >>= icodec->lowres;
2188                 }
2189                 choose_sample_rate(ost->st, ost->enc);
2190                 codec->time_base = (AVRational){1, codec->sample_rate};
2191                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2192                     codec->sample_fmt = icodec->sample_fmt;
2193                 choose_sample_fmt(ost->st, ost->enc);
2194                 if (!codec->channels)
2195                     codec->channels = icodec->channels;
2196                 codec->channel_layout = icodec->channel_layout;
2197                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2198                     codec->channel_layout = 0;
2199                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2200                 icodec->request_channels = codec->channels;
2201                 ist->decoding_needed = 1;
2202                 ost->encoding_needed = 1;
2203                 ost->resample_sample_fmt  = icodec->sample_fmt;
2204                 ost->resample_sample_rate = icodec->sample_rate;
2205                 ost->resample_channels    = icodec->channels;
2206                 break;
2207             case AVMEDIA_TYPE_VIDEO:
2208                 if (codec->pix_fmt == PIX_FMT_NONE)
2209                     codec->pix_fmt = icodec->pix_fmt;
2210                 choose_pixel_fmt(ost->st, ost->enc);
2211
2212                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2213                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2214                     exit_program(1);
2215                 }
2216
2217                 if (!codec->width || !codec->height) {
2218                     codec->width  = icodec->width;
2219                     codec->height = icodec->height;
2220                 }
2221
2222                 ost->video_resample = codec->width   != icodec->width  ||
2223                                       codec->height  != icodec->height ||
2224                                       codec->pix_fmt != icodec->pix_fmt;
2225                 if (ost->video_resample) {
2226 #if !CONFIG_AVFILTER
2227                     avcodec_get_frame_defaults(&ost->pict_tmp);
2228                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2229                                        codec->width, codec->height)) {
2230                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2231                         exit_program(1);
2232                     }
2233                     ost->img_resample_ctx = sws_getContext(
2234                         icodec->width,
2235                         icodec->height,
2236                         icodec->pix_fmt,
2237                         codec->width,
2238                         codec->height,
2239                         codec->pix_fmt,
2240                         ost->sws_flags, NULL, NULL, NULL);
2241                     if (ost->img_resample_ctx == NULL) {
2242                         fprintf(stderr, "Cannot get resampling context\n");
2243                         exit_program(1);
2244                     }
2245 #endif
2246                     codec->bits_per_raw_sample= 0;
2247                 }
2248
2249                 ost->resample_height = icodec->height;
2250                 ost->resample_width  = icodec->width;
2251                 ost->resample_pix_fmt= icodec->pix_fmt;
2252                 ost->encoding_needed = 1;
2253                 ist->decoding_needed = 1;
2254
2255                 if (!ost->frame_rate.num)
2256                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2257                 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2258                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2259                     ost->frame_rate = ost->enc->supported_framerates[idx];
2260                 }
2261                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2262
2263 #if CONFIG_AVFILTER
2264                 if (configure_video_filters(ist, ost)) {
2265                     fprintf(stderr, "Error opening filters!\n");
2266                     exit(1);
2267                 }
2268 #endif
2269                 break;
2270             case AVMEDIA_TYPE_SUBTITLE:
2271                 ost->encoding_needed = 1;
2272                 ist->decoding_needed = 1;
2273                 break;
2274             default:
2275                 abort();
2276                 break;
2277             }
2278             /* two pass mode */
2279             if (ost->encoding_needed &&
2280                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2281                 char logfilename[1024];
2282                 FILE *f;
2283
2284                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2285                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2286                          i);
2287                 if (codec->flags & CODEC_FLAG_PASS1) {
2288                     f = fopen(logfilename, "wb");
2289                     if (!f) {
2290                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2291                         exit_program(1);
2292                     }
2293                     ost->logfile = f;
2294                 } else {
2295                     char  *logbuffer;
2296                     size_t logbuffer_size;
2297                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2298                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2299                         exit_program(1);
2300                     }
2301                     codec->stats_in = logbuffer;
2302                 }
2303             }
2304         }
2305         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2306             int size= codec->width * codec->height;
2307             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2308         }
2309     }
2310
2311     if (!bit_buffer)
2312         bit_buffer = av_malloc(bit_buffer_size);
2313     if (!bit_buffer) {
2314         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2315                 bit_buffer_size);
2316         ret = AVERROR(ENOMEM);
2317         goto fail;
2318     }
2319
2320     /* open each encoder */
2321     for(i=0;i<nb_ostreams;i++) {
2322         ost = ost_table[i];
2323         if (ost->encoding_needed) {
2324             AVCodec *codec = ost->enc;
2325             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2326             if (!codec) {
2327                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2328                          ost->st->codec->codec_id, ost->file_index, ost->index);
2329                 ret = AVERROR(EINVAL);
2330                 goto dump_format;
2331             }
2332             if (dec->subtitle_header) {
2333                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2334                 if (!ost->st->codec->subtitle_header) {
2335                     ret = AVERROR(ENOMEM);
2336                     goto dump_format;
2337                 }
2338                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2339                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2340             }
2341             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2342                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2343                         ost->file_index, ost->index);
2344                 ret = AVERROR(EINVAL);
2345                 goto dump_format;
2346             }
2347             assert_codec_experimental(ost->st->codec, 1);
2348             assert_avoptions(ost->opts);
2349             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2350                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2351                                              "It takes bits/s as argument, not kbits/s\n");
2352             extra_size += ost->st->codec->extradata_size;
2353         }
2354     }
2355
2356     /* open each decoder */
2357     for (i = 0; i < nb_input_streams; i++) {
2358         ist = &input_streams[i];
2359         if (ist->decoding_needed) {
2360             AVCodec *codec = ist->dec;
2361             if (!codec)
2362                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2363             if (!codec) {
2364                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2365                         ist->st->codec->codec_id, ist->file_index, ist->st->index);
2366                 ret = AVERROR(EINVAL);
2367                 goto dump_format;
2368             }
2369
2370             /* update requested sample format for the decoder based on the
2371                corresponding encoder sample format */
2372             for (j = 0; j < nb_ostreams; j++) {
2373                 ost = ost_table[j];
2374                 if (ost->source_index == i) {
2375                     update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2376                     break;
2377                 }
2378             }
2379
2380             if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2381                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2382                         ist->file_index, ist->st->index);
2383                 ret = AVERROR(EINVAL);
2384                 goto dump_format;
2385             }
2386             assert_codec_experimental(ist->st->codec, 0);
2387             assert_avoptions(ost->opts);
2388             //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2389             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2390         }
2391     }
2392
2393     /* init pts */
2394     for (i = 0; i < nb_input_streams; i++) {
2395         AVStream *st;
2396         ist = &input_streams[i];
2397         st= ist->st;
2398         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2399         ist->next_pts = AV_NOPTS_VALUE;
2400         init_pts_correction(&ist->pts_ctx);
2401         ist->is_start = 1;
2402     }
2403
2404     /* set meta data information from input file if required */
2405     for (i=0;i<nb_meta_data_maps;i++) {
2406         AVFormatContext *files[2];
2407         AVDictionary    **meta[2];
2408         int j;
2409
2410 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2411         if ((index) < 0 || (index) >= (nb_elems)) {\
2412             snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2413                      (desc), (index));\
2414             ret = AVERROR(EINVAL);\
2415             goto dump_format;\
2416         }
2417
2418         int out_file_index = meta_data_maps[i][0].file;
2419         int in_file_index = meta_data_maps[i][1].file;
2420         if (in_file_index < 0 || out_file_index < 0)
2421             continue;
2422         METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2423         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2424
2425         files[0] = output_files[out_file_index];
2426         files[1] = input_files[in_file_index].ctx;
2427
2428         for (j = 0; j < 2; j++) {
2429             MetadataMap *map = &meta_data_maps[i][j];
2430
2431             switch (map->type) {
2432             case 'g':
2433                 meta[j] = &files[j]->metadata;
2434                 break;
2435             case 's':
2436                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2437                 meta[j] = &files[j]->streams[map->index]->metadata;
2438                 break;
2439             case 'c':
2440                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2441                 meta[j] = &files[j]->chapters[map->index]->metadata;
2442                 break;
2443             case 'p':
2444                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2445                 meta[j] = &files[j]->programs[map->index]->metadata;
2446                 break;
2447             }
2448         }
2449
2450         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2451     }
2452
2453     /* copy global metadata by default */
2454     if (metadata_global_autocopy) {
2455
2456         for (i = 0; i < nb_output_files; i++)
2457             av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2458                          AV_DICT_DONT_OVERWRITE);
2459     }
2460
2461     /* open files and write file headers */
2462     for(i=0;i<nb_output_files;i++) {
2463         os = output_files[i];
2464         if (avformat_write_header(os, &output_opts[i]) < 0) {
2465             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2466             ret = AVERROR(EINVAL);
2467             goto dump_format;
2468         }
2469         assert_avoptions(output_opts[i]);
2470         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2471             want_sdp = 0;
2472         }
2473     }
2474
2475  dump_format:
2476     /* dump the file output parameters - cannot be done before in case
2477        of stream copy */
2478     for(i=0;i<nb_output_files;i++) {
2479         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2480     }
2481
2482     /* dump the stream mapping */
2483     if (verbose >= 0) {
2484         fprintf(stderr, "Stream mapping:\n");
2485         for(i=0;i<nb_ostreams;i++) {
2486             ost = ost_table[i];
2487             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2488                     input_streams[ost->source_index].file_index,
2489                     input_streams[ost->source_index].st->index,
2490                     ost->file_index,
2491                     ost->index);
2492             if (ost->sync_ist != &input_streams[ost->source_index])
2493                 fprintf(stderr, " [sync #%d.%d]",
2494                         ost->sync_ist->file_index,
2495                         ost->sync_ist->st->index);
2496             fprintf(stderr, "\n");
2497         }
2498     }
2499
2500     if (ret) {
2501         fprintf(stderr, "%s\n", error);
2502         goto fail;
2503     }
2504
2505     if (want_sdp) {
2506         print_sdp(output_files, nb_output_files);
2507     }
2508
2509     if (verbose >= 0)
2510         fprintf(stderr, "Press ctrl-c to stop encoding\n");
2511     term_init();
2512
2513     timer_start = av_gettime();
2514
2515     for(; received_sigterm == 0;) {
2516         int file_index, ist_index;
2517         AVPacket pkt;
2518         double ipts_min;
2519         double opts_min;
2520
2521     redo:
2522         ipts_min= 1e100;
2523         opts_min= 1e100;
2524
2525         /* select the stream that we must read now by looking at the
2526            smallest output pts */
2527         file_index = -1;
2528         for(i=0;i<nb_ostreams;i++) {
2529             double ipts, opts;
2530             ost = ost_table[i];
2531             os = output_files[ost->file_index];
2532             ist = &input_streams[ost->source_index];
2533             if(ist->is_past_recording_time || no_packet[ist->file_index])
2534                 continue;
2535                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2536             ipts = (double)ist->pts;
2537             if (!input_files[ist->file_index].eof_reached){
2538                 if(ipts < ipts_min) {
2539                     ipts_min = ipts;
2540                     if(input_sync ) file_index = ist->file_index;
2541                 }
2542                 if(opts < opts_min) {
2543                     opts_min = opts;
2544                     if(!input_sync) file_index = ist->file_index;
2545                 }
2546             }
2547             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2548                 file_index= -1;
2549                 break;
2550             }
2551         }
2552         /* if none, if is finished */
2553         if (file_index < 0) {
2554             if(no_packet_count){
2555                 no_packet_count=0;
2556                 memset(no_packet, 0, sizeof(no_packet));
2557                 usleep(10000);
2558                 continue;
2559             }
2560             break;
2561         }
2562
2563         /* finish if limit size exhausted */
2564         if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2565             break;
2566
2567         /* read a frame from it and output it in the fifo */
2568         is = input_files[file_index].ctx;
2569         ret= av_read_frame(is, &pkt);
2570         if(ret == AVERROR(EAGAIN)){
2571             no_packet[file_index]=1;
2572             no_packet_count++;
2573             continue;
2574         }
2575         if (ret < 0) {
2576             input_files[file_index].eof_reached = 1;
2577             if (opt_shortest)
2578                 break;
2579             else
2580                 continue;
2581         }
2582
2583         no_packet_count=0;
2584         memset(no_packet, 0, sizeof(no_packet));
2585
2586         if (do_pkt_dump) {
2587             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2588                              is->streams[pkt.stream_index]);
2589         }
2590         /* the following test is needed in case new streams appear
2591            dynamically in stream : we ignore them */
2592         if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2593             goto discard_packet;
2594         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2595         ist = &input_streams[ist_index];
2596         if (ist->discard)
2597             goto discard_packet;
2598
2599         if (pkt.dts != AV_NOPTS_VALUE)
2600             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2601         if (pkt.pts != AV_NOPTS_VALUE)
2602             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2603
2604         if (ist->ts_scale) {
2605             if(pkt.pts != AV_NOPTS_VALUE)
2606                 pkt.pts *= ist->ts_scale;
2607             if(pkt.dts != AV_NOPTS_VALUE)
2608                 pkt.dts *= ist->ts_scale;
2609         }
2610
2611 //        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);
2612         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2613             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2614             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2615             int64_t delta= pkt_dts - ist->next_pts;
2616             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2617                 input_files[ist->file_index].ts_offset -= delta;
2618                 if (verbose > 2)
2619                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2620                             delta, input_files[ist->file_index].ts_offset);
2621                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2622                 if(pkt.pts != AV_NOPTS_VALUE)
2623                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2624             }
2625         }
2626
2627         /* finish if recording time exhausted */
2628         if (recording_time != INT64_MAX &&
2629             av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2630             ist->is_past_recording_time = 1;
2631             goto discard_packet;
2632         }
2633
2634         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2635         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2636
2637             if (verbose >= 0)
2638                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2639                         ist->file_index, ist->st->index);
2640             if (exit_on_error)
2641                 exit_program(1);
2642             av_free_packet(&pkt);
2643             goto redo;
2644         }
2645
2646     discard_packet:
2647         av_free_packet(&pkt);
2648
2649         /* dump report by using the output first video and audio streams */
2650         print_report(output_files, ost_table, nb_ostreams, 0);
2651     }
2652
2653     /* at the end of stream, we must flush the decoder buffers */
2654     for (i = 0; i < nb_input_streams; i++) {
2655         ist = &input_streams[i];
2656         if (ist->decoding_needed) {
2657             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2658         }
2659     }
2660
2661     term_exit();
2662
2663     /* write the trailer if needed and close file */
2664     for(i=0;i<nb_output_files;i++) {
2665         os = output_files[i];
2666         av_write_trailer(os);
2667     }
2668
2669     /* dump report by using the first video and audio streams */
2670     print_report(output_files, ost_table, nb_ostreams, 1);
2671
2672     /* close each encoder */
2673     for(i=0;i<nb_ostreams;i++) {
2674         ost = ost_table[i];
2675         if (ost->encoding_needed) {
2676             av_freep(&ost->st->codec->stats_in);
2677             avcodec_close(ost->st->codec);
2678         }
2679 #if CONFIG_AVFILTER
2680         avfilter_graph_free(&ost->graph);
2681 #endif
2682     }
2683
2684     /* close each decoder */
2685     for (i = 0; i < nb_input_streams; i++) {
2686         ist = &input_streams[i];
2687         if (ist->decoding_needed) {
2688             avcodec_close(ist->st->codec);
2689         }
2690     }
2691
2692     /* finished ! */
2693     ret = 0;
2694
2695  fail:
2696     av_freep(&bit_buffer);
2697
2698     if (ost_table) {
2699         for(i=0;i<nb_ostreams;i++) {
2700             ost = ost_table[i];
2701             if (ost) {
2702                 if (ost->st->stream_copy)
2703                     av_freep(&ost->st->codec->extradata);
2704                 if (ost->logfile) {
2705                     fclose(ost->logfile);
2706                     ost->logfile = NULL;
2707                 }
2708                 av_fifo_free(ost->fifo); /* works even if fifo is not
2709                                              initialized but set to zero */
2710                 av_freep(&ost->st->codec->subtitle_header);
2711                 av_free(ost->pict_tmp.data[0]);
2712                 av_free(ost->forced_kf_pts);
2713                 if (ost->video_resample)
2714                     sws_freeContext(ost->img_resample_ctx);
2715                 if (ost->resample)
2716                     audio_resample_close(ost->resample);
2717                 if (ost->reformat_ctx)
2718                     av_audio_convert_free(ost->reformat_ctx);
2719                 av_dict_free(&ost->opts);
2720                 av_free(ost);
2721             }
2722         }
2723         av_free(ost_table);
2724     }
2725     return ret;
2726 }
2727
2728 static int opt_format(const char *opt, const char *arg)
2729 {
2730     last_asked_format = arg;
2731     return 0;
2732 }
2733
2734 static int opt_video_rc_override_string(const char *opt, const char *arg)
2735 {
2736     video_rc_override_string = arg;
2737     return 0;
2738 }
2739
2740 static int opt_me_threshold(const char *opt, const char *arg)
2741 {
2742     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2743     return 0;
2744 }
2745
2746 static int opt_verbose(const char *opt, const char *arg)
2747 {
2748     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2749     return 0;
2750 }
2751
2752 static int opt_frame_rate(const char *opt, const char *arg)
2753 {
2754     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2755         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2756         exit_program(1);
2757     }
2758     return 0;
2759 }
2760
2761 static int opt_frame_crop(const char *opt, const char *arg)
2762 {
2763     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2764     return AVERROR(EINVAL);
2765 }
2766
2767 static int opt_frame_size(const char *opt, const char *arg)
2768 {
2769     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2770         fprintf(stderr, "Incorrect frame size\n");
2771         return AVERROR(EINVAL);
2772     }
2773     return 0;
2774 }
2775
2776 static int opt_pad(const char *opt, const char *arg) {
2777     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2778     return -1;
2779 }
2780
2781 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2782 {
2783     if (strcmp(arg, "list")) {
2784         frame_pix_fmt = av_get_pix_fmt(arg);
2785         if (frame_pix_fmt == PIX_FMT_NONE) {
2786             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2787             return AVERROR(EINVAL);
2788         }
2789     } else {
2790         show_pix_fmts();
2791         exit_program(0);
2792     }
2793     return 0;
2794 }
2795
2796 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2797 {
2798     int x = 0, y = 0;
2799     double ar = 0;
2800     const char *p;
2801     char *end;
2802
2803     p = strchr(arg, ':');
2804     if (p) {
2805         x = strtol(arg, &end, 10);
2806         if (end == p)
2807             y = strtol(end+1, &end, 10);
2808         if (x > 0 && y > 0)
2809             ar = (double)x / (double)y;
2810     } else
2811         ar = strtod(arg, NULL);
2812
2813     if (!ar) {
2814         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2815         return AVERROR(EINVAL);
2816     }
2817     frame_aspect_ratio = ar;
2818     return 0;
2819 }
2820
2821 static int opt_metadata(const char *opt, const char *arg)
2822 {
2823     char *mid= strchr(arg, '=');
2824
2825     if(!mid){
2826         fprintf(stderr, "Missing =\n");
2827         exit_program(1);
2828     }
2829     *mid++= 0;
2830
2831     av_dict_set(&metadata, arg, mid, 0);
2832
2833     return 0;
2834 }
2835
2836 static int opt_qscale(const char *opt, const char *arg)
2837 {
2838     video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2839     if (video_qscale == 0) {
2840         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2841         return AVERROR(EINVAL);
2842     }
2843     return 0;
2844 }
2845
2846 static int opt_top_field_first(const char *opt, const char *arg)
2847 {
2848     top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2849     return 0;
2850 }
2851
2852 static int opt_thread_count(const char *opt, const char *arg)
2853 {
2854     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2855 #if !HAVE_THREADS
2856     if (verbose >= 0)
2857         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2858 #endif
2859     return 0;
2860 }
2861
2862 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2863 {
2864     if (strcmp(arg, "list")) {
2865         audio_sample_fmt = av_get_sample_fmt(arg);
2866         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2867             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2868             return AVERROR(EINVAL);
2869         }
2870     } else {
2871         int i;
2872         char fmt_str[128];
2873         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2874             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2875         exit_program(0);
2876     }
2877     return 0;
2878 }
2879
2880 static int opt_audio_rate(const char *opt, const char *arg)
2881 {
2882     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2883     return 0;
2884 }
2885
2886 static int opt_audio_channels(const char *opt, const char *arg)
2887 {
2888     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2889     return 0;
2890 }
2891
2892 static int opt_video_channel(const char *opt, const char *arg)
2893 {
2894     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2895     opt_default("channel", arg);
2896     return 0;
2897 }
2898
2899 static int opt_video_standard(const char *opt, const char *arg)
2900 {
2901     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2902     opt_default("standard", arg);
2903     return 0;
2904 }
2905
2906 static int opt_codec(int *pstream_copy, char **pcodec_name,
2907                       int codec_type, const char *arg)
2908 {
2909     av_freep(pcodec_name);
2910     if (!strcmp(arg, "copy")) {
2911         *pstream_copy = 1;
2912     } else {
2913         *pcodec_name = av_strdup(arg);
2914     }
2915     return 0;
2916 }
2917
2918 static int opt_audio_codec(const char *opt, const char *arg)
2919 {
2920     return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2921 }
2922
2923 static int opt_video_codec(const char *opt, const char *arg)
2924 {
2925     return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2926 }
2927
2928 static int opt_subtitle_codec(const char *opt, const char *arg)
2929 {
2930     return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2931 }
2932
2933 static int opt_data_codec(const char *opt, const char *arg)
2934 {
2935     return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2936 }
2937
2938 static int opt_codec_tag(const char *opt, const char *arg)
2939 {
2940     char *tail;
2941     uint32_t *codec_tag;
2942
2943     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2944                 !strcmp(opt, "vtag") ? &video_codec_tag :
2945                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2946     if (!codec_tag)
2947         return -1;
2948
2949     *codec_tag = strtol(arg, &tail, 0);
2950     if (!tail || *tail)
2951         *codec_tag = AV_RL32(arg);
2952
2953     return 0;
2954 }
2955
2956 static int opt_map(const char *opt, const char *arg)
2957 {
2958     StreamMap *m;
2959     char *p;
2960
2961     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2962     m = &stream_maps[nb_stream_maps-1];
2963
2964     m->file_index = strtol(arg, &p, 0);
2965     if (*p)
2966         p++;
2967
2968     m->stream_index = strtol(p, &p, 0);
2969     if (*p) {
2970         p++;
2971         m->sync_file_index = strtol(p, &p, 0);
2972         if (*p)
2973             p++;
2974         m->sync_stream_index = strtol(p, &p, 0);
2975     } else {
2976         m->sync_file_index = m->file_index;
2977         m->sync_stream_index = m->stream_index;
2978     }
2979     return 0;
2980 }
2981
2982 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2983 {
2984     *endptr = arg;
2985     if (*arg == ',') {
2986         *type = *(++arg);
2987         switch (*arg) {
2988         case 'g':
2989             break;
2990         case 's':
2991         case 'c':
2992         case 'p':
2993             *index = strtol(++arg, endptr, 0);
2994             break;
2995         default:
2996             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2997             exit_program(1);
2998         }
2999     } else
3000         *type = 'g';
3001 }
3002
3003 static int opt_map_metadata(const char *opt, const char *arg)
3004 {
3005     MetadataMap *m, *m1;
3006     char *p;
3007
3008     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3009                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
3010
3011     m = &meta_data_maps[nb_meta_data_maps - 1][0];
3012     m->file = strtol(arg, &p, 0);
3013     parse_meta_type(p, &m->type, &m->index, &p);
3014     if (*p)
3015         p++;
3016
3017     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3018     m1->file = strtol(p, &p, 0);
3019     parse_meta_type(p, &m1->type, &m1->index, &p);
3020
3021     if (m->type == 'g' || m1->type == 'g')
3022         metadata_global_autocopy = 0;
3023     if (m->type == 's' || m1->type == 's')
3024         metadata_streams_autocopy = 0;
3025     if (m->type == 'c' || m1->type == 'c')
3026         metadata_chapters_autocopy = 0;
3027
3028     return 0;
3029 }
3030
3031 static int opt_map_meta_data(const char *opt, const char *arg)
3032 {
3033     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3034                     "Use -map_metadata instead.\n");
3035     return opt_map_metadata(opt, arg);
3036 }
3037
3038 static int opt_input_ts_scale(const char *opt, const char *arg)
3039 {
3040     unsigned int stream;
3041     double scale;
3042     char *p;
3043
3044     stream = strtol(arg, &p, 0);
3045     if (*p)
3046         p++;
3047     scale= strtod(p, &p);
3048
3049     ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3050     ts_scale[stream] = scale;
3051     return 0;
3052 }
3053
3054 static int opt_recording_time(const char *opt, const char *arg)
3055 {
3056     recording_time = parse_time_or_die(opt, arg, 1);
3057     return 0;
3058 }
3059
3060 static int opt_start_time(const char *opt, const char *arg)
3061 {
3062     start_time = parse_time_or_die(opt, arg, 1);
3063     return 0;
3064 }
3065
3066 static int opt_recording_timestamp(const char *opt, const char *arg)
3067 {
3068     char buf[128];
3069     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3070     struct tm time = *gmtime((time_t*)&recording_timestamp);
3071     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3072     opt_metadata("metadata", buf);
3073
3074     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3075                                  "tag instead.\n", opt);
3076     return 0;
3077 }
3078
3079 static int opt_input_ts_offset(const char *opt, const char *arg)
3080 {
3081     input_ts_offset = parse_time_or_die(opt, arg, 1);
3082     return 0;
3083 }
3084
3085 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
3086 {
3087     const char *codec_string = encoder ? "encoder" : "decoder";
3088     AVCodec *codec;
3089
3090     if(!name)
3091         return CODEC_ID_NONE;
3092     codec = encoder ?
3093         avcodec_find_encoder_by_name(name) :
3094         avcodec_find_decoder_by_name(name);
3095     if(!codec) {
3096         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3097         exit_program(1);
3098     }
3099     if(codec->type != type) {
3100         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3101         exit_program(1);
3102     }
3103     return codec->id;
3104 }
3105
3106 static int opt_input_file(const char *opt, const char *filename)
3107 {
3108     AVFormatContext *ic;
3109     AVInputFormat *file_iformat = NULL;
3110     int err, i, ret, rfps, rfps_base;
3111     int64_t timestamp;
3112     uint8_t buf[128];
3113     AVDictionary **opts;
3114     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
3115
3116     if (last_asked_format) {
3117         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3118             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3119             exit_program(1);
3120         }
3121         last_asked_format = NULL;
3122     }
3123
3124     if (!strcmp(filename, "-"))
3125         filename = "pipe:";
3126
3127     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3128                     !strcmp(filename, "/dev/stdin");
3129
3130     /* get default parameters from command line */
3131     ic = avformat_alloc_context();
3132     if (!ic) {
3133         print_error(filename, AVERROR(ENOMEM));
3134         exit_program(1);
3135     }
3136     if (audio_sample_rate) {
3137         snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3138         av_dict_set(&format_opts, "sample_rate", buf, 0);
3139     }
3140     if (audio_channels) {
3141         snprintf(buf, sizeof(buf), "%d", audio_channels);
3142         av_dict_set(&format_opts, "channels", buf, 0);
3143     }
3144     if (frame_rate.num) {
3145         snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3146         av_dict_set(&format_opts, "framerate", buf, 0);
3147     }
3148     if (frame_width && frame_height) {
3149         snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3150         av_dict_set(&format_opts, "video_size", buf, 0);
3151     }
3152     if (frame_pix_fmt != PIX_FMT_NONE)
3153         av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3154
3155     ic->video_codec_id   =
3156         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0);
3157     ic->audio_codec_id   =
3158         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0);
3159     ic->subtitle_codec_id=
3160         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3161     ic->flags |= AVFMT_FLAG_NONBLOCK;
3162
3163     /* open the input file with generic libav function */
3164     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3165     if (err < 0) {
3166         print_error(filename, err);
3167         exit_program(1);
3168     }
3169     assert_avoptions(format_opts);
3170
3171     if(opt_programid) {
3172         int i, j;
3173         int found=0;
3174         for(i=0; i<ic->nb_streams; i++){
3175             ic->streams[i]->discard= AVDISCARD_ALL;
3176         }
3177         for(i=0; i<ic->nb_programs; i++){
3178             AVProgram *p= ic->programs[i];
3179             if(p->id != opt_programid){
3180                 p->discard = AVDISCARD_ALL;
3181             }else{
3182                 found=1;
3183                 for(j=0; j<p->nb_stream_indexes; j++){
3184                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3185                 }
3186             }
3187         }
3188         if(!found){
3189             fprintf(stderr, "Specified program id not found\n");
3190             exit_program(1);
3191         }
3192         opt_programid=0;
3193     }
3194
3195     if (loop_input) {
3196         av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3197         ic->loop_input = loop_input;
3198     }
3199
3200     /* Set AVCodecContext options for avformat_find_stream_info */
3201     opts = setup_find_stream_info_opts(ic, codec_opts);
3202     orig_nb_streams = ic->nb_streams;
3203
3204     /* If not enough info to get the stream parameters, we decode the
3205        first frames to get it. (used in mpeg case for example) */
3206     ret = avformat_find_stream_info(ic, opts);
3207     if (ret < 0 && verbose >= 0) {
3208         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3209         av_close_input_file(ic);
3210         exit_program(1);
3211     }
3212
3213     timestamp = start_time;
3214     /* add the stream start time */
3215     if (ic->start_time != AV_NOPTS_VALUE)
3216         timestamp += ic->start_time;
3217
3218     /* if seeking requested, we execute it */
3219     if (start_time != 0) {
3220         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3221         if (ret < 0) {
3222             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3223                     filename, (double)timestamp / AV_TIME_BASE);
3224         }
3225         /* reset seek info */
3226         start_time = 0;
3227     }
3228
3229     /* update the current parameters so that they match the one of the input stream */
3230     for(i=0;i<ic->nb_streams;i++) {
3231         AVStream *st = ic->streams[i];
3232         AVCodecContext *dec = st->codec;
3233         InputStream *ist;
3234
3235         dec->thread_count = thread_count;
3236
3237         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3238         ist = &input_streams[nb_input_streams - 1];
3239         ist->st = st;
3240         ist->file_index = nb_input_files;
3241         ist->discard = 1;
3242         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, 0);
3243
3244         if (i < nb_ts_scale)
3245             ist->ts_scale = ts_scale[i];
3246
3247         switch (dec->codec_type) {
3248         case AVMEDIA_TYPE_AUDIO:
3249             ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3250             if(audio_disable)
3251                 st->discard= AVDISCARD_ALL;
3252             break;
3253         case AVMEDIA_TYPE_VIDEO:
3254             ist->dec = avcodec_find_decoder_by_name(video_codec_name);
3255             rfps      = ic->streams[i]->r_frame_rate.num;
3256             rfps_base = ic->streams[i]->r_frame_rate.den;
3257             if (dec->lowres) {
3258                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3259                 dec->height >>= dec->lowres;
3260                 dec->width  >>= dec->lowres;
3261             }
3262             if(me_threshold)
3263                 dec->debug |= FF_DEBUG_MV;
3264
3265             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3266
3267                 if (verbose >= 0)
3268                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3269                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3270
3271                     (float)rfps / rfps_base, rfps, rfps_base);
3272             }
3273
3274             if(video_disable)
3275                 st->discard= AVDISCARD_ALL;
3276             else if(video_discard)
3277                 st->discard= video_discard;
3278             break;
3279         case AVMEDIA_TYPE_DATA:
3280             break;
3281         case AVMEDIA_TYPE_SUBTITLE:
3282             ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3283             if(subtitle_disable)
3284                 st->discard = AVDISCARD_ALL;
3285             break;
3286         case AVMEDIA_TYPE_ATTACHMENT:
3287         case AVMEDIA_TYPE_UNKNOWN:
3288             break;
3289         default:
3290             abort();
3291         }
3292     }
3293
3294     /* dump the file content */
3295     if (verbose >= 0)
3296         av_dump_format(ic, nb_input_files, filename, 0);
3297
3298     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3299     input_files[nb_input_files - 1].ctx        = ic;
3300     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3301     input_files[nb_input_files - 1].ts_offset  = input_ts_offset - (copy_ts ? 0 : timestamp);
3302
3303     frame_rate    = (AVRational){0, 0};
3304     frame_pix_fmt = PIX_FMT_NONE;
3305     frame_height = 0;
3306     frame_width  = 0;
3307     audio_sample_rate = 0;
3308     audio_channels    = 0;
3309     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3310     av_freep(&ts_scale);
3311     nb_ts_scale = 0;
3312
3313     for (i = 0; i < orig_nb_streams; i++)
3314         av_dict_free(&opts[i]);
3315     av_freep(&opts);
3316     av_freep(&video_codec_name);
3317     av_freep(&audio_codec_name);
3318     av_freep(&subtitle_codec_name);
3319     uninit_opts();
3320     init_opts();
3321     return 0;
3322 }
3323
3324 static void check_inputs(int *has_video_ptr,
3325                          int *has_audio_ptr,
3326                          int *has_subtitle_ptr,
3327                          int *has_data_ptr)
3328 {
3329     int has_video, has_audio, has_subtitle, has_data, i, j;
3330     AVFormatContext *ic;
3331
3332     has_video = 0;
3333     has_audio = 0;
3334     has_subtitle = 0;
3335     has_data = 0;
3336
3337     for(j=0;j<nb_input_files;j++) {
3338         ic = input_files[j].ctx;
3339         for(i=0;i<ic->nb_streams;i++) {
3340             AVCodecContext *enc = ic->streams[i]->codec;
3341             switch(enc->codec_type) {
3342             case AVMEDIA_TYPE_AUDIO:
3343                 has_audio = 1;
3344                 break;
3345             case AVMEDIA_TYPE_VIDEO:
3346                 has_video = 1;
3347                 break;
3348             case AVMEDIA_TYPE_SUBTITLE:
3349                 has_subtitle = 1;
3350                 break;
3351             case AVMEDIA_TYPE_DATA:
3352             case AVMEDIA_TYPE_ATTACHMENT:
3353             case AVMEDIA_TYPE_UNKNOWN:
3354                 has_data = 1;
3355                 break;
3356             default:
3357                 abort();
3358             }
3359         }
3360     }
3361     *has_video_ptr = has_video;
3362     *has_audio_ptr = has_audio;
3363     *has_subtitle_ptr = has_subtitle;
3364     *has_data_ptr = has_data;
3365 }
3366
3367 static void new_video_stream(AVFormatContext *oc, int file_idx)
3368 {
3369     AVStream *st;
3370     OutputStream *ost;
3371     AVCodecContext *video_enc;
3372     enum CodecID codec_id = CODEC_ID_NONE;
3373     AVCodec *codec= NULL;
3374
3375     if(!video_stream_copy){
3376         if (video_codec_name) {
3377             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3378             codec = avcodec_find_encoder_by_name(video_codec_name);
3379         } else {
3380             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3381             codec = avcodec_find_encoder(codec_id);
3382         }
3383     }
3384
3385     ost = new_output_stream(oc, file_idx, codec);
3386     st  = ost->st;
3387     if (!video_stream_copy) {
3388         ost->frame_aspect_ratio = frame_aspect_ratio;
3389         frame_aspect_ratio = 0;
3390 #if CONFIG_AVFILTER
3391         ost->avfilter= vfilters;
3392         vfilters = NULL;
3393 #endif
3394     }
3395
3396     ost->bitstream_filters = video_bitstream_filters;
3397     video_bitstream_filters= NULL;
3398
3399     st->codec->thread_count= thread_count;
3400
3401     video_enc = st->codec;
3402
3403     if(video_codec_tag)
3404         video_enc->codec_tag= video_codec_tag;
3405
3406     if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3407         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3408     }
3409
3410     video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3411     if (video_stream_copy) {
3412         st->stream_copy = 1;
3413         video_enc->sample_aspect_ratio =
3414         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3415     } else {
3416         const char *p;
3417         int i;
3418
3419         if (frame_rate.num)
3420             ost->frame_rate = frame_rate;
3421         video_enc->codec_id = codec_id;
3422
3423         video_enc->width = frame_width;
3424         video_enc->height = frame_height;
3425         video_enc->pix_fmt = frame_pix_fmt;
3426         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3427
3428         if (intra_only)
3429             video_enc->gop_size = 0;
3430         if (video_qscale || same_quality) {
3431             video_enc->flags |= CODEC_FLAG_QSCALE;
3432             video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3433         }
3434
3435         if(intra_matrix)
3436             video_enc->intra_matrix = intra_matrix;
3437         if(inter_matrix)
3438             video_enc->inter_matrix = inter_matrix;
3439
3440         p= video_rc_override_string;
3441         for(i=0; p; i++){
3442             int start, end, q;
3443             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3444             if(e!=3){
3445                 fprintf(stderr, "error parsing rc_override\n");
3446                 exit_program(1);
3447             }
3448             video_enc->rc_override=
3449                 av_realloc(video_enc->rc_override,
3450                            sizeof(RcOverride)*(i+1));
3451             video_enc->rc_override[i].start_frame= start;
3452             video_enc->rc_override[i].end_frame  = end;
3453             if(q>0){
3454                 video_enc->rc_override[i].qscale= q;
3455                 video_enc->rc_override[i].quality_factor= 1.0;
3456             }
3457             else{
3458                 video_enc->rc_override[i].qscale= 0;
3459                 video_enc->rc_override[i].quality_factor= -q/100.0;
3460             }
3461             p= strchr(p, '/');
3462             if(p) p++;
3463         }
3464         video_enc->rc_override_count=i;
3465         if (!video_enc->rc_initial_buffer_occupancy)
3466             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3467         video_enc->me_threshold= me_threshold;
3468         video_enc->intra_dc_precision= intra_dc_precision - 8;
3469
3470         if (do_psnr)
3471             video_enc->flags|= CODEC_FLAG_PSNR;
3472
3473         /* two pass mode */
3474         if (do_pass) {
3475             if (do_pass == 1) {
3476                 video_enc->flags |= CODEC_FLAG_PASS1;
3477             } else {
3478                 video_enc->flags |= CODEC_FLAG_PASS2;
3479             }
3480         }
3481
3482         if (forced_key_frames)
3483             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3484     }
3485     if (video_language) {
3486         av_dict_set(&st->metadata, "language", video_language, 0);
3487         av_freep(&video_language);
3488     }
3489
3490     /* reset some key parameters */
3491     video_disable = 0;
3492     av_freep(&video_codec_name);
3493     av_freep(&forced_key_frames);
3494     video_stream_copy = 0;
3495     frame_pix_fmt = PIX_FMT_NONE;
3496 }
3497
3498 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3499 {
3500     AVStream *st;
3501     OutputStream *ost;
3502     AVCodec *codec= NULL;
3503     AVCodecContext *audio_enc;
3504     enum CodecID codec_id = CODEC_ID_NONE;
3505
3506     if(!audio_stream_copy){
3507         if (audio_codec_name) {
3508             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3509             codec = avcodec_find_encoder_by_name(audio_codec_name);
3510         } else {
3511             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3512             codec = avcodec_find_encoder(codec_id);
3513         }
3514     }
3515     ost = new_output_stream(oc, file_idx, codec);
3516     st  = ost->st;
3517
3518     ost->bitstream_filters = audio_bitstream_filters;
3519     audio_bitstream_filters= NULL;
3520
3521     st->codec->thread_count= thread_count;
3522
3523     audio_enc = st->codec;
3524     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3525
3526     if(audio_codec_tag)
3527         audio_enc->codec_tag= audio_codec_tag;
3528
3529     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3530         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3531     }
3532     if (audio_stream_copy) {
3533         st->stream_copy = 1;
3534     } else {
3535         audio_enc->codec_id = codec_id;
3536
3537         if (audio_qscale > QSCALE_NONE) {
3538             audio_enc->flags |= CODEC_FLAG_QSCALE;
3539             audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3540         }
3541         if (audio_channels)
3542             audio_enc->channels = audio_channels;
3543         if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3544             audio_enc->sample_fmt = audio_sample_fmt;
3545         if (audio_sample_rate)
3546             audio_enc->sample_rate = audio_sample_rate;
3547     }
3548     if (audio_language) {
3549         av_dict_set(&st->metadata, "language", audio_language, 0);
3550         av_freep(&audio_language);
3551     }
3552
3553     /* reset some key parameters */
3554     audio_disable = 0;
3555     av_freep(&audio_codec_name);
3556     audio_stream_copy = 0;
3557 }
3558
3559 static void new_data_stream(AVFormatContext *oc, int file_idx)
3560 {
3561     AVStream *st;
3562     OutputStream *ost;
3563     AVCodecContext *data_enc;
3564
3565     ost = new_output_stream(oc, file_idx, NULL);
3566     st  = ost->st;
3567     data_enc = st->codec;
3568     if (!data_stream_copy) {
3569         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3570         exit_program(1);
3571     }
3572
3573     data_enc->codec_type = AVMEDIA_TYPE_DATA;
3574
3575     if (data_codec_tag)
3576         data_enc->codec_tag= data_codec_tag;
3577
3578     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3579         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3580     }
3581     if (data_stream_copy) {
3582         st->stream_copy = 1;
3583     }
3584
3585     data_disable = 0;
3586     av_freep(&data_codec_name);
3587     data_stream_copy = 0;
3588 }
3589
3590 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3591 {
3592     AVStream *st;
3593     OutputStream *ost;
3594     AVCodec *codec=NULL;
3595     AVCodecContext *subtitle_enc;
3596     enum CodecID codec_id = CODEC_ID_NONE;
3597
3598     if(!subtitle_stream_copy){
3599         if (subtitle_codec_name) {
3600             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3601             codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3602         } else {
3603             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3604             codec = avcodec_find_encoder(codec_id);
3605         }
3606     }
3607     ost = new_output_stream(oc, file_idx, codec);
3608     st  = ost->st;
3609     subtitle_enc = st->codec;
3610
3611     ost->bitstream_filters = subtitle_bitstream_filters;
3612     subtitle_bitstream_filters= NULL;
3613
3614     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3615
3616     if(subtitle_codec_tag)
3617         subtitle_enc->codec_tag= subtitle_codec_tag;
3618
3619     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3620         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3621     }
3622     if (subtitle_stream_copy) {
3623         st->stream_copy = 1;
3624     } else {
3625         subtitle_enc->codec_id = codec_id;
3626     }
3627
3628     if (subtitle_language) {
3629         av_dict_set(&st->metadata, "language", subtitle_language, 0);
3630         av_freep(&subtitle_language);
3631     }
3632
3633     subtitle_disable = 0;
3634     av_freep(&subtitle_codec_name);
3635     subtitle_stream_copy = 0;
3636 }
3637
3638 static int opt_new_stream(const char *opt, const char *arg)
3639 {
3640     AVFormatContext *oc;
3641     int file_idx = nb_output_files - 1;
3642     if (nb_output_files <= 0) {
3643         fprintf(stderr, "At least one output file must be specified\n");
3644         exit_program(1);
3645     }
3646     oc = output_files[file_idx];
3647
3648     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3649     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3650     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3651     else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3652     else av_assert0(0);
3653     return 0;
3654 }
3655
3656 /* arg format is "output-stream-index:streamid-value". */
3657 static int opt_streamid(const char *opt, const char *arg)
3658 {
3659     int idx;
3660     char *p;
3661     char idx_str[16];
3662
3663     av_strlcpy(idx_str, arg, sizeof(idx_str));
3664     p = strchr(idx_str, ':');
3665     if (!p) {
3666         fprintf(stderr,
3667                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3668                 arg, opt);
3669         exit_program(1);
3670     }
3671     *p++ = '\0';
3672     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3673     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3674     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3675     return 0;
3676 }
3677
3678 static void opt_output_file(const char *filename)
3679 {
3680     AVFormatContext *oc;
3681     int i, err, use_video, use_audio, use_subtitle, use_data;
3682     int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3683     AVOutputFormat *file_oformat;
3684
3685     if (!strcmp(filename, "-"))
3686         filename = "pipe:";
3687
3688     oc = avformat_alloc_context();
3689     if (!oc) {
3690         print_error(filename, AVERROR(ENOMEM));
3691         exit_program(1);
3692     }
3693
3694     if (last_asked_format) {
3695         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3696         if (!file_oformat) {
3697             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3698             exit_program(1);
3699         }
3700         last_asked_format = NULL;
3701     } else {
3702         file_oformat = av_guess_format(NULL, filename, NULL);
3703         if (!file_oformat) {
3704             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3705                     filename);
3706             exit_program(1);
3707         }
3708     }
3709
3710     oc->oformat = file_oformat;
3711     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3712
3713     if (!strcmp(file_oformat->name, "ffm") &&
3714         av_strstart(filename, "http:", NULL)) {
3715         /* special case for files sent to avserver: we get the stream
3716            parameters from avserver */
3717         int err = read_avserver_streams(oc, filename);
3718         if (err < 0) {
3719             print_error(filename, err);
3720             exit_program(1);
3721         }
3722     } else {
3723         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3724         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3725         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3726         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 */
3727
3728         /* disable if no corresponding type found */
3729         check_inputs(&input_has_video,
3730                      &input_has_audio,
3731                      &input_has_subtitle,
3732                      &input_has_data);
3733
3734         if (!input_has_video)
3735             use_video = 0;
3736         if (!input_has_audio)
3737             use_audio = 0;
3738         if (!input_has_subtitle)
3739             use_subtitle = 0;
3740         if (!input_has_data)
3741             use_data = 0;
3742
3743         /* manual disable */
3744         if (audio_disable)    use_audio    = 0;
3745         if (video_disable)    use_video    = 0;
3746         if (subtitle_disable) use_subtitle = 0;
3747         if (data_disable)     use_data     = 0;
3748
3749         if (use_video)    new_video_stream(oc, nb_output_files);
3750         if (use_audio)    new_audio_stream(oc, nb_output_files);
3751         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3752         if (use_data)     new_data_stream(oc, nb_output_files);
3753
3754         av_dict_copy(&oc->metadata, metadata, 0);
3755         av_dict_free(&metadata);
3756     }
3757
3758     av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3759     output_files[nb_output_files++] = oc;
3760
3761     /* check filename in case of an image number is expected */
3762     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3763         if (!av_filename_number_test(oc->filename)) {
3764             print_error(oc->filename, AVERROR(EINVAL));
3765             exit_program(1);
3766         }
3767     }
3768
3769     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3770         /* test if it already exists to avoid loosing precious files */
3771         if (!file_overwrite &&
3772             (strchr(filename, ':') == NULL ||
3773              filename[1] == ':' ||
3774              av_strstart(filename, "file:", NULL))) {
3775             if (avio_check(filename, 0) == 0) {
3776                 if (!using_stdin) {
3777                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3778                     fflush(stderr);
3779                     if (!read_yesno()) {
3780                         fprintf(stderr, "Not overwriting - exiting\n");
3781                         exit_program(1);
3782                     }
3783                 }
3784                 else {
3785                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3786                     exit_program(1);
3787                 }
3788             }
3789         }
3790
3791         /* open the file */
3792         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3793             print_error(filename, err);
3794             exit_program(1);
3795         }
3796     }
3797
3798     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3799     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3800     if (loop_output >= 0) {
3801         av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3802         oc->loop_output = loop_output;
3803     }
3804     oc->flags |= AVFMT_FLAG_NONBLOCK;
3805
3806     /* copy chapters */
3807     if (chapters_input_file >= nb_input_files) {
3808         if (chapters_input_file == INT_MAX) {
3809             /* copy chapters from the first input file that has them*/
3810             chapters_input_file = -1;
3811             for (i = 0; i < nb_input_files; i++)
3812                 if (input_files[i].ctx->nb_chapters) {
3813                     chapters_input_file = i;
3814                     break;
3815                 }
3816         } else {
3817             av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3818                    chapters_input_file);
3819             exit_program(1);
3820         }
3821     }
3822     if (chapters_input_file >= 0)
3823         copy_chapters(chapters_input_file, nb_output_files - 1);
3824
3825     frame_rate    = (AVRational){0, 0};
3826     frame_width   = 0;
3827     frame_height  = 0;
3828     audio_sample_rate = 0;
3829     audio_channels    = 0;
3830     audio_sample_fmt  = AV_SAMPLE_FMT_NONE;
3831     chapters_input_file = INT_MAX;
3832
3833     av_freep(&forced_key_frames);
3834     uninit_opts();
3835     init_opts();
3836 }
3837
3838 /* same option as mencoder */
3839 static int opt_pass(const char *opt, const char *arg)
3840 {
3841     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3842     return 0;
3843 }
3844
3845 static int64_t getutime(void)
3846 {
3847 #if HAVE_GETRUSAGE
3848     struct rusage rusage;
3849
3850     getrusage(RUSAGE_SELF, &rusage);
3851     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3852 #elif HAVE_GETPROCESSTIMES
3853     HANDLE proc;
3854     FILETIME c, e, k, u;
3855     proc = GetCurrentProcess();
3856     GetProcessTimes(proc, &c, &e, &k, &u);
3857     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3858 #else
3859     return av_gettime();
3860 #endif
3861 }
3862
3863 static int64_t getmaxrss(void)
3864 {
3865 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3866     struct rusage rusage;
3867     getrusage(RUSAGE_SELF, &rusage);
3868     return (int64_t)rusage.ru_maxrss * 1024;
3869 #elif HAVE_GETPROCESSMEMORYINFO
3870     HANDLE proc;
3871     PROCESS_MEMORY_COUNTERS memcounters;
3872     proc = GetCurrentProcess();
3873     memcounters.cb = sizeof(memcounters);
3874     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3875     return memcounters.PeakPagefileUsage;
3876 #else
3877     return 0;
3878 #endif
3879 }
3880
3881 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3882 {
3883     int i;
3884     const char *p = str;
3885     for(i = 0;; i++) {
3886         dest[i] = atoi(p);
3887         if(i == 63)
3888             break;
3889         p = strchr(p, ',');
3890         if(!p) {
3891             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3892             exit_program(1);
3893         }
3894         p++;
3895     }
3896 }
3897
3898 static void opt_inter_matrix(const char *arg)
3899 {
3900     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3901     parse_matrix_coeffs(inter_matrix, arg);
3902 }
3903
3904 static void opt_intra_matrix(const char *arg)
3905 {
3906     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3907     parse_matrix_coeffs(intra_matrix, arg);
3908 }
3909
3910 static void show_usage(void)
3911 {
3912     printf("Hyper fast Audio and Video encoder\n");
3913     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3914     printf("\n");
3915 }
3916
3917 static void show_help(void)
3918 {
3919     AVCodec *c;
3920     AVOutputFormat *oformat = NULL;
3921     AVInputFormat  *iformat = NULL;
3922
3923     av_log_set_callback(log_callback_help);
3924     show_usage();
3925     show_help_options(options, "Main options:\n",
3926                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3927     show_help_options(options, "\nAdvanced options:\n",
3928                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3929                       OPT_EXPERT);
3930     show_help_options(options, "\nVideo options:\n",
3931                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3932                       OPT_VIDEO);
3933     show_help_options(options, "\nAdvanced Video options:\n",
3934                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3935                       OPT_VIDEO | OPT_EXPERT);
3936     show_help_options(options, "\nAudio options:\n",
3937                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3938                       OPT_AUDIO);
3939     show_help_options(options, "\nAdvanced Audio options:\n",
3940                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3941                       OPT_AUDIO | OPT_EXPERT);
3942     show_help_options(options, "\nSubtitle options:\n",
3943                       OPT_SUBTITLE | OPT_GRAB,
3944                       OPT_SUBTITLE);
3945     show_help_options(options, "\nAudio/Video grab options:\n",
3946                       OPT_GRAB,
3947                       OPT_GRAB);
3948     printf("\n");
3949     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3950     printf("\n");
3951
3952     /* individual codec options */
3953     c = NULL;
3954     while ((c = av_codec_next(c))) {
3955         if (c->priv_class) {
3956             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3957             printf("\n");
3958         }
3959     }
3960
3961     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3962     printf("\n");
3963
3964     /* individual muxer options */
3965     while ((oformat = av_oformat_next(oformat))) {
3966         if (oformat->priv_class) {
3967             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3968             printf("\n");
3969         }
3970     }
3971
3972     /* individual demuxer options */
3973     while ((iformat = av_iformat_next(iformat))) {
3974         if (iformat->priv_class) {
3975             av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3976             printf("\n");
3977         }
3978     }
3979
3980     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3981 }
3982
3983 static int opt_target(const char *opt, const char *arg)
3984 {
3985     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3986     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3987
3988     if(!strncmp(arg, "pal-", 4)) {
3989         norm = PAL;
3990         arg += 4;
3991     } else if(!strncmp(arg, "ntsc-", 5)) {
3992         norm = NTSC;
3993         arg += 5;
3994     } else if(!strncmp(arg, "film-", 5)) {
3995         norm = FILM;
3996         arg += 5;
3997     } else {
3998         int fr;
3999         /* Calculate FR via float to avoid int overflow */
4000         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4001         if(fr == 25000) {
4002             norm = PAL;
4003         } else if((fr == 29970) || (fr == 23976)) {
4004             norm = NTSC;
4005         } else {
4006             /* Try to determine PAL/NTSC by peeking in the input files */
4007             if(nb_input_files) {
4008                 int i, j;
4009                 for (j = 0; j < nb_input_files; j++) {
4010                     for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4011                         AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4012                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4013                             continue;
4014                         fr = c->time_base.den * 1000 / c->time_base.num;
4015                         if(fr == 25000) {
4016                             norm = PAL;
4017                             break;
4018                         } else if((fr == 29970) || (fr == 23976)) {
4019                             norm = NTSC;
4020                             break;
4021                         }
4022                     }
4023                     if(norm != UNKNOWN)
4024                         break;
4025                 }
4026             }
4027         }
4028         if(verbose > 0 && norm != UNKNOWN)
4029             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4030     }
4031
4032     if(norm == UNKNOWN) {
4033         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4034         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4035         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4036         exit_program(1);
4037     }
4038
4039     if(!strcmp(arg, "vcd")) {
4040         opt_video_codec("vcodec", "mpeg1video");
4041         opt_audio_codec("vcodec", "mp2");
4042         opt_format("f", "vcd");
4043
4044         opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4045         opt_frame_rate("r", frame_rates[norm]);
4046         opt_default("g", norm == PAL ? "15" : "18");
4047
4048         opt_default("b", "1150000");
4049         opt_default("maxrate", "1150000");
4050         opt_default("minrate", "1150000");
4051         opt_default("bufsize", "327680"); // 40*1024*8;
4052
4053         opt_default("ab", "224000");
4054         audio_sample_rate = 44100;
4055         audio_channels = 2;
4056
4057         opt_default("packetsize", "2324");
4058         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4059
4060         /* We have to offset the PTS, so that it is consistent with the SCR.
4061            SCR starts at 36000, but the first two packs contain only padding
4062            and the first pack from the other stream, respectively, may also have
4063            been written before.
4064            So the real data starts at SCR 36000+3*1200. */
4065         mux_preload= (36000+3*1200) / 90000.0; //0.44
4066     } else if(!strcmp(arg, "svcd")) {
4067
4068         opt_video_codec("vcodec", "mpeg2video");
4069         opt_audio_codec("acodec", "mp2");
4070         opt_format("f", "svcd");
4071
4072         opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4073         opt_frame_rate("r", frame_rates[norm]);
4074         opt_default("g", norm == PAL ? "15" : "18");
4075
4076         opt_default("b", "2040000");
4077         opt_default("maxrate", "2516000");
4078         opt_default("minrate", "0"); //1145000;
4079         opt_default("bufsize", "1835008"); //224*1024*8;
4080         opt_default("flags", "+scan_offset");
4081
4082
4083         opt_default("ab", "224000");
4084         audio_sample_rate = 44100;
4085
4086         opt_default("packetsize", "2324");
4087
4088     } else if(!strcmp(arg, "dvd")) {
4089
4090         opt_video_codec("vcodec", "mpeg2video");
4091         opt_audio_codec("vcodec", "ac3");
4092         opt_format("f", "dvd");
4093
4094         opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4095         opt_frame_rate("r", frame_rates[norm]);
4096         opt_default("g", norm == PAL ? "15" : "18");
4097
4098         opt_default("b", "6000000");
4099         opt_default("maxrate", "9000000");
4100         opt_default("minrate", "0"); //1500000;
4101         opt_default("bufsize", "1835008"); //224*1024*8;
4102
4103         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4104         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4105
4106         opt_default("ab", "448000");
4107         audio_sample_rate = 48000;
4108
4109     } else if(!strncmp(arg, "dv", 2)) {
4110
4111         opt_format("f", "dv");
4112
4113         opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4114         opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4115                           norm == PAL ? "yuv420p" : "yuv411p");
4116         opt_frame_rate("r", frame_rates[norm]);
4117
4118         audio_sample_rate = 48000;
4119         audio_channels = 2;
4120
4121     } else {
4122         fprintf(stderr, "Unknown target: %s\n", arg);
4123         return AVERROR(EINVAL);
4124     }
4125     return 0;
4126 }
4127
4128 static int opt_vstats_file(const char *opt, const char *arg)
4129 {
4130     av_free (vstats_filename);
4131     vstats_filename=av_strdup (arg);
4132     return 0;
4133 }
4134
4135 static int opt_vstats(const char *opt, const char *arg)
4136 {
4137     char filename[40];
4138     time_t today2 = time(NULL);
4139     struct tm *today = localtime(&today2);
4140
4141     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4142              today->tm_sec);
4143     return opt_vstats_file(opt, filename);
4144 }
4145
4146 static int opt_bsf(const char *opt, const char *arg)
4147 {
4148     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4149     AVBitStreamFilterContext **bsfp;
4150
4151     if(!bsfc){
4152         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4153         exit_program(1);
4154     }
4155
4156     bsfp= *opt == 'v' ? &video_bitstream_filters :
4157           *opt == 'a' ? &audio_bitstream_filters :
4158                         &subtitle_bitstream_filters;
4159     while(*bsfp)
4160         bsfp= &(*bsfp)->next;
4161
4162     *bsfp= bsfc;
4163
4164     return 0;
4165 }
4166
4167 static int opt_preset(const char *opt, const char *arg)
4168 {
4169     FILE *f=NULL;
4170     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4171     char *codec_name = *opt == 'v' ? video_codec_name :
4172                        *opt == 'a' ? audio_codec_name :
4173                                      subtitle_codec_name;
4174
4175     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4176         fprintf(stderr, "File for preset '%s' not found\n", arg);
4177         exit_program(1);
4178     }
4179
4180     while(!feof(f)){
4181         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4182         if(line[0] == '#' && !e)
4183             continue;
4184         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4185         if(e){
4186             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4187             exit_program(1);
4188         }
4189         if(!strcmp(tmp, "acodec")){
4190             opt_audio_codec(tmp, tmp2);
4191         }else if(!strcmp(tmp, "vcodec")){
4192             opt_video_codec(tmp, tmp2);
4193         }else if(!strcmp(tmp, "scodec")){
4194             opt_subtitle_codec(tmp, tmp2);
4195         }else if(!strcmp(tmp, "dcodec")){
4196             opt_data_codec(tmp, tmp2);
4197         }else if(opt_default(tmp, tmp2) < 0){
4198             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4199             exit_program(1);
4200         }
4201     }
4202
4203     fclose(f);
4204
4205     return 0;
4206 }
4207
4208 static const OptionDef options[] = {
4209     /* main options */
4210 #include "cmdutils_common_opts.h"
4211     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4212     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4213     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4214     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4215     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4216       "outfile[,metadata]:infile[,metadata]" },
4217     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4218       "outfile[,metadata]:infile[,metadata]" },
4219     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&chapters_input_file},  "set chapters mapping", "input_file_index" },
4220     { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4221     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4222     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4223     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4224     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4225     { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4226     { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4227     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4228     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4229       "add timings for benchmarking" },
4230     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4231     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4232       "dump each input packet" },
4233     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4234       "when dumping packets, also dump the payload" },
4235     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4236     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4237     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4238     { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4239     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4240     { "threads",  HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4241     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4242     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4243     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4244     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4245     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4246     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4247     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4248     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4249     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4250     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4251
4252     /* video options */
4253     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4254     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4255     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4256     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4257     { "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" },
4258     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4259     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4260     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4261     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4262     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4263     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4264     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4265     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4266     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4267     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4268     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4269     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4270     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4271     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4272     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4273     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4274     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4275       "use same quantizer as source (implies VBR)" },
4276     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4277     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4278     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4279       "deinterlace pictures" },
4280     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4281     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4282     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4283 #if CONFIG_AVFILTER
4284     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4285 #endif
4286     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void