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