3 * Copyright (c) 2000-2011 The libav developers.
5 * This file is part of Libav.
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.
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.
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
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"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/avfiltergraph.h"
52 # include "libavfilter/vsrc_buffer.h"
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/types.h>
58 #include <sys/resource.h>
59 #elif HAVE_GETPROCESSTIMES
62 #if HAVE_GETPROCESSMEMORYINFO
68 #include <sys/select.h>
75 #include "libavutil/avassert.h"
77 const char program_name[] = "avconv";
78 const int program_birth_year = 2000;
80 /* select an input stream for an output stream */
81 typedef struct StreamMap {
85 int sync_stream_index;
89 * select an input file for an output file
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
97 static const OptionDef options[];
101 static const char *last_asked_format = NULL;
102 static double *ts_scale;
103 static int nb_ts_scale;
105 static AVFormatContext *output_files[MAX_FILES];
106 static AVDictionary *output_opts[MAX_FILES];
107 static int nb_output_files = 0;
109 static StreamMap *stream_maps = NULL;
110 static int nb_stream_maps;
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;
119 static int chapters_input_file = INT_MAX;
121 /* indexed by output file stream index */
122 static int *streamid_map = NULL;
123 static int nb_streamid_map = 0;
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;
148 static char *vfilters = NULL;
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;
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;
166 static int data_disable = 0;
167 static char *data_codec_name = NULL;
168 static unsigned int data_codec_tag = 0;
170 static float mux_preload= 0.5;
171 static float mux_max_delay= 0.7;
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;
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;
199 static int rate_emu = 0;
201 static int audio_volume = 256;
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;
217 static float dts_delta_threshold = 10;
219 static int64_t timer_start;
221 static uint8_t *audio_buf;
222 static uint8_t *audio_out;
223 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
225 static short *samples;
227 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
228 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
229 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
231 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
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 */
242 /* input pts and corresponding output pts
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;
252 AVFrame pict_tmp; /* temporary image for resampling */
253 struct SwsContext *img_resample_ctx; /* for image resampling */
256 int resample_pix_fmt;
257 AVRational frame_rate;
259 float frame_aspect_ratio;
261 /* forced key frames */
262 int64_t *forced_kf_pts;
268 ReSampleContext *resample; /* for audio resampling */
269 int resample_sample_fmt;
270 int resample_channels;
271 int resample_sample_rate;
273 AVAudioConvert *reformat_ctx;
274 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
278 AVFilterContext *output_video_filter;
279 AVFilterContext *input_video_filter;
280 AVFilterBufferRef *picref;
282 AVFilterGraph *graph;
289 static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
290 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
292 typedef struct InputStream {
295 int discard; /* true if stream data should be discarded */
296 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
299 int64_t start; /* time when read started */
300 int64_t next_pts; /* synthetic pts for cases where pkt.pts
302 int64_t pts; /* current pts */
303 PtsCorrectionContext pts_ctx;
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;
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 */
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;
326 static int configure_video_filters(InputStream *ist, OutputStream *ost)
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;
337 ost->graph = avfilter_graph_alloc();
339 if (ist->st->sample_aspect_ratio.num){
340 sample_aspect_ratio = ist->st->sample_aspect_ratio;
342 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
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);
348 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
349 "src", args, NULL, ost->graph);
352 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
353 "out", NULL, &ffsink_ctx, ost->graph);
356 last_filter = ost->input_video_filter;
358 if (codec->width != icodec->width || codec->height != icodec->height) {
359 snprintf(args, 255, "%d:%d:flags=0x%X",
363 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
364 NULL, args, NULL, ost->graph)) < 0)
366 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
368 last_filter = filter;
371 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
372 ost->graph->scale_sws_opts = av_strdup(args);
375 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
376 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
378 outputs->name = av_strdup("in");
379 outputs->filter_ctx = last_filter;
380 outputs->pad_idx = 0;
381 outputs->next = NULL;
383 inputs->name = av_strdup("out");
384 inputs->filter_ctx = ost->output_video_filter;
388 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
390 av_freep(&ost->avfilter);
392 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
396 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
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;
408 #endif /* CONFIG_AVFILTER */
410 static void term_exit(void)
412 av_log(NULL, AV_LOG_QUIET, "");
415 static volatile int received_sigterm = 0;
416 static volatile int received_nb_signals = 0;
419 sigterm_handler(int sig)
421 received_sigterm = sig;
422 received_nb_signals++;
426 static void term_init(void)
428 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
429 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
431 signal(SIGXCPU, sigterm_handler);
435 static int decode_interrupt_cb(void)
437 return received_nb_signals > 1;
440 static int exit_program(int ret)
445 for(i=0;i<nb_output_files;i++) {
446 AVFormatContext *s = output_files[i];
447 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
449 avformat_free_context(s);
450 av_free(output_streams_for_file[i]);
451 av_dict_free(&output_opts[i]);
453 for(i=0;i<nb_input_files;i++) {
454 av_close_input_file(input_files[i].ctx);
456 for (i = 0; i < nb_input_streams; i++)
457 av_dict_free(&input_streams[i].opts);
459 av_free(intra_matrix);
460 av_free(inter_matrix);
464 av_free(vstats_filename);
466 av_free(streamid_map);
467 av_free(stream_maps);
468 av_free(meta_data_maps);
470 av_freep(&input_streams);
471 av_freep(&input_files);
473 av_free(video_codec_name);
474 av_free(audio_codec_name);
475 av_free(subtitle_codec_name);
476 av_free(data_codec_name);
481 allocated_audio_buf_size= allocated_audio_out_size= 0;
488 if (received_sigterm) {
490 "Received signal %d: terminating.\n",
491 (int) received_sigterm);
495 exit(ret); /* not all OS-es handle main() return value */
499 static void assert_avoptions(AVDictionary *m)
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);
508 static void assert_codec_experimental(AVCodecContext *c, int encoder)
510 const char *codec_string = encoder ? "encoder" : "decoder";
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);
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)
528 if (new_size >= INT_MAX / elem_size) {
529 fprintf(stderr, "Array too big.\n");
532 if (*size < new_size) {
533 uint8_t *tmp = av_realloc(array, new_size*elem_size);
535 fprintf(stderr, "Could not alloc buffer.\n");
538 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
545 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
547 if(codec && codec->sample_fmts){
548 const enum AVSampleFormat *p= codec->sample_fmts;
550 if(*p == st->codec->sample_fmt)
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),
558 av_get_sample_fmt_name(codec->sample_fmts[0]));
559 st->codec->sample_fmt = codec->sample_fmts[0];
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.
571 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
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)
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;
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;
592 } else if (*p > enc->sample_fmt) {
593 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
595 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
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;
604 static void choose_sample_rate(AVStream *st, AVCodec *codec)
606 if(codec && codec->supported_samplerates){
607 const int *p= codec->supported_samplerates;
609 int best_dist=INT_MAX;
611 int dist= abs(st->codec->sample_rate - *p);
612 if(dist < best_dist){
618 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
620 st->codec->sample_rate= best;
624 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
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};
636 if(*p == st->codec->pix_fmt)
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,
645 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
646 st->codec->pix_fmt = codec->pix_fmts[0];
651 static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
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;
658 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
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],
667 ost = output_streams_for_file[file_idx][idx] =
668 av_mallocz(sizeof(OutputStream));
670 fprintf(stderr, "Could not alloc output stream\n");
673 ost->file_index = file_idx;
678 ost->opts = filter_codec_opts(codec_opts, codec->id, 1);
680 avcodec_get_context_defaults3(st->codec, codec);
682 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
686 static int read_avserver_streams(AVFormatContext *s, const char *filename)
689 AVFormatContext *ic = NULL;
692 err = avformat_open_input(&ic, filename, NULL, NULL);
695 /* copy stream format */
696 for(i=0;i<ic->nb_streams;i++) {
701 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
702 ost = new_output_stream(s, nb_output_files, codec);
705 // FIXME: a more elegant solution is needed
706 memcpy(st, ic->streams[i], sizeof(AVStream));
708 avcodec_copy_context(st->codec, ic->streams[i]->codec);
710 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
711 if (audio_stream_copy) {
714 choose_sample_fmt(st, codec);
715 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
716 if (video_stream_copy) {
719 choose_pixel_fmt(st, codec);
722 if(st->codec->flags & CODEC_FLAG_BITEXACT)
726 av_close_input_file(ic);
731 get_sync_ipts(const OutputStream *ost)
733 const InputStream *ist = ost->sync_ist;
734 return (double)(ist->pts - start_time)/AV_TIME_BASE;
737 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *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);
748 new_pkt.destruct= av_destruct_packet;
750 fprintf(stderr, "%s failed for stream %d, codec %s",
751 bsfc->filter->name, pkt->stream_index,
752 avctx->codec ? avctx->codec->name : "copy");
762 ret= av_interleaved_write_frame(s, pkt);
764 print_error("av_interleaved_write_frame()", ret);
769 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
771 static void do_audio_out(AVFormatContext *s,
774 unsigned char *buf, int size)
777 int64_t audio_out_size, audio_buf_size;
778 int64_t allocated_for_size= size;
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);
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;
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;
799 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
800 fprintf(stderr, "Buffer sizes too large\n");
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");
811 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
812 ost->audio_resample = 1;
814 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
815 ost->resample_channels != dec->channels ||
816 ost->resample_sample_rate != dec->sample_rate;
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;
828 audio_resample_close(ost->resample);
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,
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);
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));
866 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
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;
875 //FIXME resample delay
876 if(fabs(delta) > 50){
877 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
879 byte_delta= FFMAX(byte_delta, -size);
883 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
888 static uint8_t *input_tmp= NULL;
889 input_tmp= av_realloc(input_tmp, byte_delta + size);
891 if(byte_delta > allocated_for_size - size){
892 allocated_for_size= byte_delta + (int64_t)size;
897 memset(input_tmp, 0, byte_delta);
898 memcpy(input_tmp + byte_delta, buf, size);
902 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
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);
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);
914 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
915 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
917 if (ost->audio_resample) {
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;
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");
941 size_out = len*osize;
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");
951 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
953 frame_bytes = enc->frame_size * osize * enc->channels;
955 while (av_fifo_size(ost->fifo) >= frame_bytes) {
957 av_init_packet(&pkt);
959 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
961 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
963 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
966 fprintf(stderr, "Audio encoding failed\n");
970 pkt.stream_index= ost->index;
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);
978 ost->sync_opts += enc->frame_size;
982 av_init_packet(&pkt);
984 ost->sync_opts += size_out / (osize * enc->channels);
986 /* output a pcm frame */
987 /* determine the size of the coded buffer */
990 size_out = size_out*coded_bps/8;
992 if(size_out > audio_out_size){
993 fprintf(stderr, "Internal error, buffer size too small\n");
997 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
998 ret = avcodec_encode_audio(enc, audio_out, size_out,
1001 fprintf(stderr, "Audio encoding failed\n");
1005 pkt.stream_index= ost->index;
1006 pkt.data= audio_out;
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);
1015 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1017 AVCodecContext *dec;
1018 AVPicture *picture2;
1019 AVPicture picture_tmp;
1022 dec = ist->st->codec;
1024 /* deinterlace : must be done before any resize */
1025 if (do_deinterlace) {
1028 /* create temporary picture */
1029 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1030 buf = av_malloc(size);
1034 picture2 = &picture_tmp;
1035 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
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");
1049 if (picture != picture2)
1050 *picture = *picture2;
1054 /* we begin to correct av delay at this threshold */
1055 #define AV_DELAY_MAX 0.100
1057 static void do_subtitle_out(AVFormatContext *s,
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;
1069 if (pts == AV_NOPTS_VALUE) {
1070 fprintf(stderr, "Subtitle packets must have a pts\n");
1076 enc = ost->st->codec;
1078 if (!subtitle_out) {
1079 subtitle_out = av_malloc(subtitle_out_max_size);
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)
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");
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 */
1112 pkt.pts += 90 * sub->start_display_time;
1114 pkt.pts += 90 * sub->end_display_time;
1116 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1120 static int bit_buffer_size= 1024*256;
1121 static uint8_t *bit_buffer= NULL;
1123 static void do_video_out(AVFormatContext *s,
1126 AVFrame *in_picture,
1127 int *frame_size, float quality)
1129 int nb_frames, i, ret, resample_changed;
1130 AVFrame *final_picture, *formatted_picture;
1131 AVCodecContext *enc, *dec;
1134 enc = ost->st->codec;
1135 dec = ist->st->codec;
1137 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1139 /* by default, we output a single frame */
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
1149 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
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){
1160 fprintf(stderr, "*** drop!\n");
1161 }else if (nb_frames > 1) {
1162 nb_frames_dup += nb_frames - 1;
1164 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1167 ost->sync_opts= lrintf(sync_ipts);
1169 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1173 formatted_picture = in_picture;
1174 final_picture = formatted_picture;
1176 resample_changed = ost->resample_width != dec->width ||
1177 ost->resample_height != dec->height ||
1178 ost->resample_pix_fmt != dec->pix_fmt;
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)
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");
1209 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1210 0, ost->resample_height, final_picture->data, final_picture->linesize);
1214 /* duplicates frame if needed */
1215 for(i=0;i<nb_frames;i++) {
1217 av_init_packet(&pkt);
1218 pkt.stream_index= ost->index;
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
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;
1231 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1232 enc->coded_frame = old_frame;
1234 AVFrame big_picture;
1236 big_picture= *final_picture;
1237 /* better than nothing: use input picture interlaced
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;
1244 big_picture.top_field_first = top_field_first;
1247 /* handles sameq here. This is not correct because it may
1248 not be a global option */
1249 big_picture.quality = quality;
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++;
1261 ret = avcodec_encode_video(enc,
1262 bit_buffer, bit_buffer_size,
1265 fprintf(stderr, "Video encoding failed\n");
1270 pkt.data= bit_buffer;
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);*/
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);
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);
1292 ost->frame_number++;
1296 static double psnr(double d){
1297 return -10.0*log(d)/log(10.0);
1300 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1303 AVCodecContext *enc;
1305 double ti1, bitrate, avg_bitrate;
1307 /* this is executed just the first time do_video_stats is called */
1309 vstats_file = fopen(vstats_filename, "w");
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)));
1323 fprintf(vstats_file,"f_size= %6d ", frame_size);
1324 /* compute pts value */
1325 ti1 = ost->sync_opts * av_q2d(enc->time_base);
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));
1337 static void print_report(AVFormatContext **output_files,
1338 OutputStream **ost_table, int nb_ostreams,
1343 AVFormatContext *oc;
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];
1351 if (!is_last_report) {
1353 /* display the report every 0.5 seconds */
1354 cur_time = av_gettime();
1355 if (last_time == -1) {
1356 last_time = cur_time;
1359 if ((cur_time - last_time) < 500000)
1361 last_time = cur_time;
1365 oc = output_files[0];
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);
1374 for(i=0;i<nb_ostreams;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);
1383 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1384 float t = (av_gettime()-timer_start) / 1000000.0;
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);
1390 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1394 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1397 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1399 if (enc->flags&CODEC_FLAG_PSNR){
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=");
1407 error= enc->error[j];
1408 scale= enc->width*enc->height*255.0*255.0*frame_number;
1410 error= enc->coded_frame->error[j];
1411 scale= enc->width*enc->height*255.0*255.0;
1416 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1418 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1422 /* compute min output value */
1423 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1424 if ((pts < ti1) && (pts > 0))
1430 if (verbose > 0 || is_last_report) {
1431 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
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);
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);
1442 fprintf(stderr, "%s \r", buf);
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",
1454 100.0*(total_size - raw)/raw
1459 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1461 int fill_char = 0x00;
1462 if (sample_fmt == AV_SAMPLE_FMT_U8)
1464 memset(buf, fill_char, size);
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)
1472 AVFormatContext *os;
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;
1482 int frame_available;
1487 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1489 if(ist->next_pts == AV_NOPTS_VALUE)
1490 ist->next_pts= ist->pts;
1494 av_init_packet(&avpkt);
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);
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;
1512 ist->pts= ist->next_pts;
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;
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);
1532 samples= av_malloc(samples_size);
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,
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 */
1548 /* no audio frame */
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);
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;
1563 ret = avcodec_decode_video2(ist->st->codec,
1564 &picture, &got_output, &avpkt);
1565 quality = same_quality ? picture.quality : 0;
1569 /* no picture yet */
1570 goto discard_packet;
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;
1580 buffer_to_free = NULL;
1581 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1583 case AVMEDIA_TYPE_SUBTITLE:
1584 ret = avcodec_decode_subtitle2(ist->st->codec,
1585 &subtitle, &got_output, &avpkt);
1589 goto discard_packet;
1591 subtitle_to_free = &subtitle;
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;
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;
1617 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1618 for (i = 0; i < nb_ostreams; i++) {
1620 if (ost->input_video_filter && ost->source_index == ist_index) {
1622 if (ist->st->sample_aspect_ratio.num)
1623 sar = ist->st->sample_aspect_ratio;
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,
1635 // preprocess audio (volume)
1636 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1637 if (audio_volume != 256) {
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;
1649 /* frame rate emulation */
1651 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1652 int64_t now = av_gettime() - ist->start;
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++) {
1663 if (ost->source_index == ist_index) {
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);
1672 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1674 os = output_files[ost->file_index];
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;
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);
1685 case AVMEDIA_TYPE_VIDEO:
1687 if (ost->picref->video && !ost->frame_aspect_ratio)
1688 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
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);
1695 case AVMEDIA_TYPE_SUBTITLE:
1696 do_subtitle_out(os, ost, ist, &subtitle,
1703 AVFrame avframe; //FIXME/XXX remove this
1705 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1707 av_init_packet(&opkt);
1709 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1710 #if !CONFIG_AVFILTER
1716 /* no reencoding needed : output the packet directly */
1717 /* force the input stream PTS */
1719 avcodec_get_frame_defaults(&avframe);
1720 ost->st->codec->coded_frame= &avframe;
1721 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
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;
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;
1734 opkt.pts= AV_NOPTS_VALUE;
1736 if (pkt->dts == AV_NOPTS_VALUE)
1737 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1739 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1740 opkt.dts -= ost_tb_start_time;
1742 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1743 opkt.flags= pkt->flags;
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
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;
1753 opkt.data = data_buf;
1754 opkt.size = data_size;
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);
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]);
1767 avfilter_unref_buffer(ost->picref);
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;
1784 for(i=0;i<nb_ostreams;i++) {
1786 if (ost->source_index == ist_index) {
1787 AVCodecContext *enc= ost->st->codec;
1788 os = output_files[ost->file_index];
1790 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1792 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1795 if (ost->encoding_needed) {
1799 av_init_packet(&pkt);
1800 pkt.stream_index= ost->index;
1802 switch(ost->st->codec->codec_type) {
1803 case AVMEDIA_TYPE_AUDIO:
1804 fifo_bytes = av_fifo_size(ost->fifo);
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;
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);
1815 int frame_bytes = enc->frame_size*osize*enc->channels;
1816 if (allocated_audio_buf_size < frame_bytes)
1818 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
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;
1827 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1830 fprintf(stderr, "Audio encoding failed\n");
1834 pkt.flags |= AV_PKT_FLAG_KEY;
1836 case AVMEDIA_TYPE_VIDEO:
1837 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1839 fprintf(stderr, "Video encoding failed\n");
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);
1855 pkt.data= bit_buffer;
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);
1869 static void print_sdp(AVFormatContext **avc, int n)
1873 av_sdp_create(avc, n, sdp, sizeof(sdp));
1874 printf("SDP:\n%s\n", sdp);
1878 static int copy_chapters(int infile, int outfile)
1880 AVFormatContext *is = input_files[infile].ctx;
1881 AVFormatContext *os = output_files[outfile];
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);
1892 if (in_ch->end < ts_off)
1894 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1897 out_ch = av_mallocz(sizeof(AVChapter));
1899 return AVERROR(ENOMEM);
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);
1906 if (metadata_chapters_autocopy)
1907 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1910 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1912 return AVERROR(ENOMEM);
1913 os->chapters[os->nb_chapters - 1] = out_ch;
1918 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1919 AVCodecContext *avctx)
1925 for (p = kf; *p; p++)
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");
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);
1942 * The following code is the main loop of the file converter
1944 static int transcode(AVFormatContext **output_files,
1945 int nb_output_files,
1946 InputFile *input_files,
1948 StreamMap *stream_maps, int nb_stream_maps)
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;
1957 uint8_t no_packet[MAX_FILES]={0};
1958 int no_packet_count=0;
1961 for (i = 0; i < nb_input_streams; i++)
1962 input_streams[i].start = av_gettime();
1964 /* output stream init */
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);
1974 nb_ostreams += os->nb_streams;
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);
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;
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);
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);
2003 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
2007 for(k=0;k<nb_output_files;k++) {
2008 os = output_files[k];
2009 for(i=0;i<os->nb_streams;i++,n++) {
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;
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);
2027 int best_nb_frames=-1;
2028 /* get corresponding input stream index : we select the first one with the right type */
2030 for (j = 0; j < nb_input_streams; j++) {
2032 ist = &input_streams[j];
2035 AVFormatContext *f = input_files[ist->file_index].ctx;
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)
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;
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;
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);
2077 ist = &input_streams[ost->source_index];
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;
2085 /* for each output stream, we compute the right encoding parameters */
2086 for(i=0;i<nb_ostreams;i++) {
2088 os = output_files[ost->file_index];
2089 ist = &input_streams[ost->source_index];
2091 codec = ost->st->codec;
2092 icodec = ist->st->codec;
2094 if (metadata_streams_autocopy)
2095 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2096 AV_DICT_DONT_OVERWRITE);
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;
2102 if (ost->st->stream_copy) {
2103 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2105 if (extra_size > INT_MAX)
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;
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;
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)
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);
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");
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;
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};
2164 case AVMEDIA_TYPE_SUBTITLE:
2165 codec->width = icodec->width;
2166 codec->height = icodec->height;
2168 case AVMEDIA_TYPE_DATA:
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);
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;
2185 codec->sample_rate >>= icodec->lowres;
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;
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);
2210 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2211 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2215 if (!codec->width || !codec->height) {
2216 codec->width = icodec->width;
2217 codec->height = icodec->height;
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");
2231 ost->img_resample_ctx = sws_getContext(
2238 ost->sws_flags, NULL, NULL, NULL);
2239 if (ost->img_resample_ctx == NULL) {
2240 fprintf(stderr, "Cannot get resampling context\n");
2244 codec->bits_per_raw_sample= 0;
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;
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];
2259 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2262 if (configure_video_filters(ist, ost)) {
2263 fprintf(stderr, "Error opening filters!\n");
2268 case AVMEDIA_TYPE_SUBTITLE:
2269 ost->encoding_needed = 1;
2270 ist->decoding_needed = 1;
2277 if (ost->encoding_needed &&
2278 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2279 char logfilename[1024];
2282 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2283 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2285 if (codec->flags & CODEC_FLAG_PASS1) {
2286 f = fopen(logfilename, "wb");
2288 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
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);
2299 codec->stats_in = logbuffer;
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);
2310 bit_buffer = av_malloc(bit_buffer_size);
2312 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2314 ret = AVERROR(ENOMEM);
2318 /* open each encoder */
2319 for(i=0;i<nb_ostreams;i++) {
2321 if (ost->encoding_needed) {
2322 AVCodec *codec = ost->enc;
2323 AVCodecContext *dec = input_streams[ost->source_index].st->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);
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);
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;
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);
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;
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;
2360 codec = avcodec_find_decoder(ist->st->codec->codec_id);
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);
2368 /* update requested sample format for the decoder based on the
2369 corresponding encoder sample format */
2370 for (j = 0; j < nb_ostreams; j++) {
2372 if (ost->source_index == i) {
2373 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
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);
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;
2392 for (i = 0; i < nb_input_streams; i++) {
2394 ist = &input_streams[i];
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);
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];
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",\
2412 ret = AVERROR(EINVAL);\
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)
2420 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2421 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2423 files[0] = output_files[out_file_index];
2424 files[1] = input_files[in_file_index].ctx;
2426 for (j = 0; j < 2; j++) {
2427 MetadataMap *map = &meta_data_maps[i][j];
2429 switch (map->type) {
2431 meta[j] = &files[j]->metadata;
2434 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2435 meta[j] = &files[j]->streams[map->index]->metadata;
2438 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2439 meta[j] = &files[j]->chapters[map->index]->metadata;
2442 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2443 meta[j] = &files[j]->programs[map->index]->metadata;
2448 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2451 /* copy global metadata by default */
2452 if (metadata_global_autocopy) {
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);
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);
2467 assert_avoptions(output_opts[i]);
2468 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2474 /* dump the file output parameters - cannot be done before in case
2476 for(i=0;i<nb_output_files;i++) {
2477 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2480 /* dump the stream mapping */
2482 fprintf(stderr, "Stream mapping:\n");
2483 for(i=0;i<nb_ostreams;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,
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");
2499 fprintf(stderr, "%s\n", error);
2504 print_sdp(output_files, nb_output_files);
2508 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2511 timer_start = av_gettime();
2513 for(; received_sigterm == 0;) {
2514 int file_index, ist_index;
2523 /* select the stream that we must read now by looking at the
2524 smallest output pts */
2526 for(i=0;i<nb_ostreams;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])
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) {
2538 if(input_sync ) file_index = ist->file_index;
2540 if(opts < opts_min) {
2542 if(!input_sync) file_index = ist->file_index;
2545 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2550 /* if none, if is finished */
2551 if (file_index < 0) {
2552 if(no_packet_count){
2554 memset(no_packet, 0, sizeof(no_packet));
2561 /* finish if limit size exhausted */
2562 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
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;
2574 input_files[file_index].eof_reached = 1;
2582 memset(no_packet, 0, sizeof(no_packet));
2585 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2586 is->streams[pkt.stream_index]);
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];
2595 goto discard_packet;
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);
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;
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;
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);
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;
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) {
2636 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2637 ist->file_index, ist->st->index);
2640 av_free_packet(&pkt);
2645 av_free_packet(&pkt);
2647 /* dump report by using the output first video and audio streams */
2648 print_report(output_files, ost_table, nb_ostreams, 0);
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);
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);
2667 /* dump report by using the first video and audio streams */
2668 print_report(output_files, ost_table, nb_ostreams, 1);
2670 /* close each encoder */
2671 for(i=0;i<nb_ostreams;i++) {
2673 if (ost->encoding_needed) {
2674 av_freep(&ost->st->codec->stats_in);
2675 avcodec_close(ost->st->codec);
2678 avfilter_graph_free(&ost->graph);
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);
2694 av_freep(&bit_buffer);
2697 for(i=0;i<nb_ostreams;i++) {
2700 if (ost->st->stream_copy)
2701 av_freep(&ost->st->codec->extradata);
2703 fclose(ost->logfile);
2704 ost->logfile = NULL;
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);
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);
2726 static int opt_format(const char *opt, const char *arg)
2728 last_asked_format = arg;
2732 static int opt_video_rc_override_string(const char *opt, const char *arg)
2734 video_rc_override_string = arg;
2738 static int opt_me_threshold(const char *opt, const char *arg)
2740 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2744 static int opt_verbose(const char *opt, const char *arg)
2746 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2750 static int opt_frame_rate(const char *opt, const char *arg)
2752 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2753 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2759 static int opt_frame_crop(const char *opt, const char *arg)
2761 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2762 return AVERROR(EINVAL);
2765 static int opt_frame_size(const char *opt, const char *arg)
2767 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2768 fprintf(stderr, "Incorrect frame size\n");
2769 return AVERROR(EINVAL);
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);
2779 static int opt_frame_pix_fmt(const char *opt, const char *arg)
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);
2794 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2801 p = strchr(arg, ':');
2803 x = strtol(arg, &end, 10);
2805 y = strtol(end+1, &end, 10);
2807 ar = (double)x / (double)y;
2809 ar = strtod(arg, NULL);
2812 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2813 return AVERROR(EINVAL);
2815 frame_aspect_ratio = ar;
2819 static int opt_metadata(const char *opt, const char *arg)
2821 char *mid= strchr(arg, '=');
2824 fprintf(stderr, "Missing =\n");
2829 av_dict_set(&metadata, arg, mid, 0);
2834 static int opt_qscale(const char *opt, const char *arg)
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);
2844 static int opt_top_field_first(const char *opt, const char *arg)
2846 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2850 static int opt_thread_count(const char *opt, const char *arg)
2852 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2855 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2860 static int opt_audio_sample_fmt(const char *opt, const char *arg)
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);
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));
2878 static int opt_audio_rate(const char *opt, const char *arg)
2880 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2884 static int opt_audio_channels(const char *opt, const char *arg)
2886 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2890 static int opt_codec(int *pstream_copy, char **pcodec_name,
2891 int codec_type, const char *arg)
2893 av_freep(pcodec_name);
2894 if (!strcmp(arg, "copy")) {
2897 *pcodec_name = av_strdup(arg);
2902 static int opt_audio_codec(const char *opt, const char *arg)
2904 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2907 static int opt_video_codec(const char *opt, const char *arg)
2909 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2912 static int opt_subtitle_codec(const char *opt, const char *arg)
2914 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2917 static int opt_data_codec(const char *opt, const char *arg)
2919 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2922 static int opt_codec_tag(const char *opt, const char *arg)
2925 uint32_t *codec_tag;
2927 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2928 !strcmp(opt, "vtag") ? &video_codec_tag :
2929 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2933 *codec_tag = strtol(arg, &tail, 0);
2935 *codec_tag = AV_RL32(arg);
2940 static int opt_map(const char *opt, const char *arg)
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];
2948 m->file_index = strtol(arg, &p, 0);
2952 m->stream_index = strtol(p, &p, 0);
2955 m->sync_file_index = strtol(p, &p, 0);
2958 m->sync_stream_index = strtol(p, &p, 0);
2960 m->sync_file_index = m->file_index;
2961 m->sync_stream_index = m->stream_index;
2966 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2977 *index = strtol(++arg, endptr, 0);
2980 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2987 static int opt_map_metadata(const char *opt, const char *arg)
2989 MetadataMap *m, *m1;
2992 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2993 &nb_meta_data_maps, nb_meta_data_maps + 1);
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);
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);
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;
3015 static int opt_input_ts_scale(const char *opt, const char *arg)
3017 unsigned int stream;
3021 stream = strtol(arg, &p, 0);
3024 scale= strtod(p, &p);
3026 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3027 ts_scale[stream] = scale;
3031 static int opt_recording_time(const char *opt, const char *arg)
3033 recording_time = parse_time_or_die(opt, arg, 1);
3037 static int opt_start_time(const char *opt, const char *arg)
3039 start_time = parse_time_or_die(opt, arg, 1);
3043 static int opt_input_ts_offset(const char *opt, const char *arg)
3045 input_ts_offset = parse_time_or_die(opt, arg, 1);
3049 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
3051 const char *codec_string = encoder ? "encoder" : "decoder";
3055 return CODEC_ID_NONE;
3057 avcodec_find_encoder_by_name(name) :
3058 avcodec_find_decoder_by_name(name);
3060 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3063 if(codec->type != type) {
3064 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3070 static int opt_input_file(const char *opt, const char *filename)
3072 AVFormatContext *ic;
3073 AVInputFormat *file_iformat = NULL;
3074 int err, i, ret, rfps, rfps_base;
3077 AVDictionary **opts;
3078 int orig_nb_streams; // number of streams before avformat_find_stream_info
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);
3085 last_asked_format = NULL;
3088 if (!strcmp(filename, "-"))
3091 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3092 !strcmp(filename, "/dev/stdin");
3094 /* get default parameters from command line */
3095 ic = avformat_alloc_context();
3097 print_error(filename, AVERROR(ENOMEM));
3100 if (audio_sample_rate) {
3101 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3102 av_dict_set(&format_opts, "sample_rate", buf, 0);
3104 if (audio_channels) {
3105 snprintf(buf, sizeof(buf), "%d", audio_channels);
3106 av_dict_set(&format_opts, "channels", buf, 0);
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);
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);
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);
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;
3127 /* open the input file with generic libav function */
3128 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3130 print_error(filename, err);
3133 assert_avoptions(format_opts);
3138 for(i=0; i<ic->nb_streams; i++){
3139 ic->streams[i]->discard= AVDISCARD_ALL;
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;
3147 for(j=0; j<p->nb_stream_indexes; j++){
3148 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3153 fprintf(stderr, "Specified program id not found\n");
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;
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);
3172 timestamp = start_time;
3173 /* add the stream start time */
3174 if (ic->start_time != AV_NOPTS_VALUE)
3175 timestamp += ic->start_time;
3177 /* if seeking requested, we execute it */
3178 if (start_time != 0) {
3179 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3181 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3182 filename, (double)timestamp / AV_TIME_BASE);
3184 /* reset seek info */
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;
3194 dec->thread_count = thread_count;
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];
3199 ist->file_index = nb_input_files;
3201 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, 0);
3203 if (i < nb_ts_scale)
3204 ist->ts_scale = ts_scale[i];
3206 switch (dec->codec_type) {
3207 case AVMEDIA_TYPE_AUDIO:
3208 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3210 st->discard= AVDISCARD_ALL;
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;
3217 dec->flags |= CODEC_FLAG_EMU_EDGE;
3218 dec->height >>= dec->lowres;
3219 dec->width >>= dec->lowres;
3222 dec->debug |= FF_DEBUG_MV;
3224 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
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,
3230 (float)rfps / rfps_base, rfps, rfps_base);
3234 st->discard= AVDISCARD_ALL;
3235 else if(video_discard)
3236 st->discard= video_discard;
3238 case AVMEDIA_TYPE_DATA:
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;
3245 case AVMEDIA_TYPE_ATTACHMENT:
3246 case AVMEDIA_TYPE_UNKNOWN:
3253 /* dump the file content */
3255 av_dump_format(ic, nb_input_files, filename, 0);
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);
3262 frame_rate = (AVRational){0, 0};
3263 frame_pix_fmt = PIX_FMT_NONE;
3266 audio_sample_rate = 0;
3268 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3269 av_freep(&ts_scale);
3272 for (i = 0; i < orig_nb_streams; i++)
3273 av_dict_free(&opts[i]);
3275 av_freep(&video_codec_name);
3276 av_freep(&audio_codec_name);
3277 av_freep(&subtitle_codec_name);
3283 static void check_inputs(int *has_video_ptr,
3285 int *has_subtitle_ptr,
3288 int has_video, has_audio, has_subtitle, has_data, i, j;
3289 AVFormatContext *ic;
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:
3304 case AVMEDIA_TYPE_VIDEO:
3307 case AVMEDIA_TYPE_SUBTITLE:
3310 case AVMEDIA_TYPE_DATA:
3311 case AVMEDIA_TYPE_ATTACHMENT:
3312 case AVMEDIA_TYPE_UNKNOWN:
3320 *has_video_ptr = has_video;
3321 *has_audio_ptr = has_audio;
3322 *has_subtitle_ptr = has_subtitle;
3323 *has_data_ptr = has_data;
3326 static void new_video_stream(AVFormatContext *oc, int file_idx)
3330 AVCodecContext *video_enc;
3331 enum CodecID codec_id = CODEC_ID_NONE;
3332 AVCodec *codec= NULL;
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);
3339 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3340 codec = avcodec_find_encoder(codec_id);
3344 ost = new_output_stream(oc, file_idx, codec);
3346 if (!video_stream_copy) {
3347 ost->frame_aspect_ratio = frame_aspect_ratio;
3348 frame_aspect_ratio = 0;
3350 ost->avfilter= vfilters;
3355 ost->bitstream_filters = video_bitstream_filters;
3356 video_bitstream_filters= NULL;
3358 st->codec->thread_count= thread_count;
3360 video_enc = st->codec;
3363 video_enc->codec_tag= video_codec_tag;
3365 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3366 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
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);
3379 ost->frame_rate = frame_rate;
3380 video_enc->codec_id = codec_id;
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;
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;
3395 video_enc->intra_matrix = intra_matrix;
3397 video_enc->inter_matrix = inter_matrix;
3399 p= video_rc_override_string;
3402 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3404 fprintf(stderr, "error parsing rc_override\n");
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;
3413 video_enc->rc_override[i].qscale= q;
3414 video_enc->rc_override[i].quality_factor= 1.0;
3417 video_enc->rc_override[i].qscale= 0;
3418 video_enc->rc_override[i].quality_factor= -q/100.0;
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;
3430 video_enc->flags|= CODEC_FLAG_PSNR;
3435 video_enc->flags |= CODEC_FLAG_PASS1;
3437 video_enc->flags |= CODEC_FLAG_PASS2;
3441 if (forced_key_frames)
3442 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3444 if (video_language) {
3445 av_dict_set(&st->metadata, "language", video_language, 0);
3446 av_freep(&video_language);
3449 /* reset some key parameters */
3451 av_freep(&video_codec_name);
3452 av_freep(&forced_key_frames);
3453 video_stream_copy = 0;
3454 frame_pix_fmt = PIX_FMT_NONE;
3457 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3461 AVCodec *codec= NULL;
3462 AVCodecContext *audio_enc;
3463 enum CodecID codec_id = CODEC_ID_NONE;
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);
3470 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3471 codec = avcodec_find_encoder(codec_id);
3474 ost = new_output_stream(oc, file_idx, codec);
3477 ost->bitstream_filters = audio_bitstream_filters;
3478 audio_bitstream_filters= NULL;
3480 st->codec->thread_count= thread_count;
3482 audio_enc = st->codec;
3483 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3486 audio_enc->codec_tag= audio_codec_tag;
3488 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3489 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3491 if (audio_stream_copy) {
3492 st->stream_copy = 1;
3494 audio_enc->codec_id = codec_id;
3496 if (audio_qscale > QSCALE_NONE) {
3497 audio_enc->flags |= CODEC_FLAG_QSCALE;
3498 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
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;
3507 if (audio_language) {
3508 av_dict_set(&st->metadata, "language", audio_language, 0);
3509 av_freep(&audio_language);
3512 /* reset some key parameters */
3514 av_freep(&audio_codec_name);
3515 audio_stream_copy = 0;
3518 static void new_data_stream(AVFormatContext *oc, int file_idx)
3522 AVCodecContext *data_enc;
3524 ost = new_output_stream(oc, file_idx, NULL);
3526 data_enc = st->codec;
3527 if (!data_stream_copy) {
3528 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3532 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3535 data_enc->codec_tag= data_codec_tag;
3537 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3538 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3540 if (data_stream_copy) {
3541 st->stream_copy = 1;
3545 av_freep(&data_codec_name);
3546 data_stream_copy = 0;
3549 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3553 AVCodec *codec=NULL;
3554 AVCodecContext *subtitle_enc;
3555 enum CodecID codec_id = CODEC_ID_NONE;
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);
3562 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3563 codec = avcodec_find_encoder(codec_id);
3566 ost = new_output_stream(oc, file_idx, codec);
3568 subtitle_enc = st->codec;
3570 ost->bitstream_filters = subtitle_bitstream_filters;
3571 subtitle_bitstream_filters= NULL;
3573 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3575 if(subtitle_codec_tag)
3576 subtitle_enc->codec_tag= subtitle_codec_tag;
3578 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3579 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3581 if (subtitle_stream_copy) {
3582 st->stream_copy = 1;
3584 subtitle_enc->codec_id = codec_id;
3587 if (subtitle_language) {
3588 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3589 av_freep(&subtitle_language);
3592 subtitle_disable = 0;
3593 av_freep(&subtitle_codec_name);
3594 subtitle_stream_copy = 0;
3597 static int opt_new_stream(const char *opt, const char *arg)
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");
3605 oc = output_files[file_idx];
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);
3615 /* arg format is "output-stream-index:streamid-value". */
3616 static int opt_streamid(const char *opt, const char *arg)
3622 av_strlcpy(idx_str, arg, sizeof(idx_str));
3623 p = strchr(idx_str, ':');
3626 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
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);
3637 static void opt_output_file(const char *filename)
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;
3644 if (!strcmp(filename, "-"))
3647 oc = avformat_alloc_context();
3649 print_error(filename, AVERROR(ENOMEM));
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);
3659 last_asked_format = NULL;
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",
3669 oc->oformat = file_oformat;
3670 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
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);
3678 print_error(filename, err);
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 */
3687 /* disable if no corresponding type found */
3688 check_inputs(&input_has_video,
3690 &input_has_subtitle,
3693 if (!input_has_video)
3695 if (!input_has_audio)
3697 if (!input_has_subtitle)
3699 if (!input_has_data)
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;
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);
3713 av_dict_copy(&oc->metadata, metadata, 0);
3714 av_dict_free(&metadata);
3717 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3718 output_files[nb_output_files++] = oc;
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));
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) {
3736 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3738 if (!read_yesno()) {
3739 fprintf(stderr, "Not overwriting - exiting\n");
3744 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3751 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3752 print_error(filename, err);
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;
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;
3772 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3773 chapters_input_file);
3777 if (chapters_input_file >= 0)
3778 copy_chapters(chapters_input_file, nb_output_files - 1);
3780 frame_rate = (AVRational){0, 0};
3783 audio_sample_rate = 0;
3785 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3786 chapters_input_file = INT_MAX;
3788 av_freep(&forced_key_frames);
3793 /* same option as mencoder */
3794 static int opt_pass(const char *opt, const char *arg)
3796 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3800 static int64_t getutime(void)
3803 struct rusage rusage;
3805 getrusage(RUSAGE_SELF, &rusage);
3806 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3807 #elif HAVE_GETPROCESSTIMES
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;
3814 return av_gettime();
3818 static int64_t getmaxrss(void)
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
3826 PROCESS_MEMORY_COUNTERS memcounters;
3827 proc = GetCurrentProcess();
3828 memcounters.cb = sizeof(memcounters);
3829 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3830 return memcounters.PeakPagefileUsage;
3836 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3839 const char *p = str;
3846 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3853 static void opt_inter_matrix(const char *arg)
3855 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3856 parse_matrix_coeffs(inter_matrix, arg);
3859 static void opt_intra_matrix(const char *arg)
3861 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3862 parse_matrix_coeffs(intra_matrix, arg);
3865 static void show_usage(void)
3867 printf("Hyper fast Audio and Video encoder\n");
3868 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3872 static void show_help(void)
3875 AVOutputFormat *oformat = NULL;
3876 AVInputFormat *iformat = NULL;
3878 av_log_set_callback(log_callback_help);
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,
3885 show_help_options(options, "\nVideo options:\n",
3886 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
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,
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,
3900 show_help_options(options, "\nAudio/Video grab options:\n",
3904 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3907 /* individual codec options */
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);
3916 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
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);
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);
3935 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3938 static int opt_target(const char *opt, const char *arg)
3940 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3941 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3943 if(!strncmp(arg, "pal-", 4)) {
3946 } else if(!strncmp(arg, "ntsc-", 5)) {
3949 } else if(!strncmp(arg, "film-", 5)) {
3954 /* Calculate FR via float to avoid int overflow */
3955 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3958 } else if((fr == 29970) || (fr == 23976)) {
3961 /* Try to determine PAL/NTSC by peeking in the input files */
3962 if(nb_input_files) {
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)
3969 fr = c->time_base.den * 1000 / c->time_base.num;
3973 } else if((fr == 29970) || (fr == 23976)) {
3983 if(verbose > 0 && norm != UNKNOWN)
3984 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
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");
3994 if(!strcmp(arg, "vcd")) {
3995 opt_video_codec("vcodec", "mpeg1video");
3996 opt_audio_codec("vcodec", "mp2");
3997 opt_format("f", "vcd");
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");
4003 opt_default("b", "1150000");
4004 opt_default("maxrate", "1150000");
4005 opt_default("minrate", "1150000");
4006 opt_default("bufsize", "327680"); // 40*1024*8;
4008 opt_default("ab", "224000");
4009 audio_sample_rate = 44100;
4012 opt_default("packetsize", "2324");
4013 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
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")) {
4023 opt_video_codec("vcodec", "mpeg2video");
4024 opt_audio_codec("acodec", "mp2");
4025 opt_format("f", "svcd");
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");
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");
4038 opt_default("ab", "224000");
4039 audio_sample_rate = 44100;
4041 opt_default("packetsize", "2324");
4043 } else if(!strcmp(arg, "dvd")) {
4045 opt_video_codec("vcodec", "mpeg2video");
4046 opt_audio_codec("vcodec", "ac3");
4047 opt_format("f", "dvd");
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");
4053 opt_default("b", "6000000");
4054 opt_default("maxrate", "9000000");
4055 opt_default("minrate", "0"); //1500000;
4056 opt_default("bufsize", "1835008"); //224*1024*8;
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
4061 opt_default("ab", "448000");
4062 audio_sample_rate = 48000;
4064 } else if(!strncmp(arg, "dv", 2)) {
4066 opt_format("f", "dv");
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]);
4073 audio_sample_rate = 48000;
4077 fprintf(stderr, "Unknown target: %s\n", arg);
4078 return AVERROR(EINVAL);
4083 static int opt_vstats_file(const char *opt, const char *arg)
4085 av_free (vstats_filename);
4086 vstats_filename=av_strdup (arg);
4090 static int opt_vstats(const char *opt, const char *arg)
4093 time_t today2 = time(NULL);
4094 struct tm *today = localtime(&today2);
4096 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4098 return opt_vstats_file(opt, filename);
4101 static int opt_bsf(const char *opt, const char *arg)
4103 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4104 AVBitStreamFilterContext **bsfp;
4107 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4111 bsfp= *opt == 'v' ? &video_bitstream_filters :
4112 *opt == 'a' ? &audio_bitstream_filters :
4113 &subtitle_bitstream_filters;
4115 bsfp= &(*bsfp)->next;
4122 static int opt_preset(const char *opt, const char *arg)
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;
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);
4136 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4137 if(line[0] == '#' && !e)
4139 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4141 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
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);
4163 static const OptionDef 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*)©_ts}, "copy timestamps" },
4195 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_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*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
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" },
4234 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
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" },
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" },
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" },