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