3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg 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 * FFmpeg 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 FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 /* needed for usleep() */
23 #define _XOPEN_SOURCE 600
34 #include "libavformat/avformat.h"
35 #include "libavdevice/avdevice.h"
36 #include "libswscale/swscale.h"
37 #include "libavcodec/opt.h"
38 #include "libavcodec/audioconvert.h"
39 #include "libavcodec/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/avstring.h"
42 #include "libavformat/os_support.h"
44 #if HAVE_SYS_RESOURCE_H
45 #include <sys/types.h>
46 #include <sys/resource.h>
47 #elif HAVE_GETPROCESSTIMES
52 #include <sys/select.h>
57 #include <sys/ioctl.h>
63 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
73 const char program_name
[] = "FFmpeg";
74 const int program_birth_year
= 2000;
76 /* select an input stream for an output stream */
77 typedef struct AVStreamMap
{
81 int sync_stream_index
;
84 /** select an input file for an output file */
85 typedef struct AVMetaDataMap
{
90 static const OptionDef options
[];
94 static char *last_asked_format
= NULL
;
95 static AVFormatContext
*input_files
[MAX_FILES
];
96 static int64_t input_files_ts_offset
[MAX_FILES
];
97 static double input_files_ts_scale
[MAX_FILES
][MAX_STREAMS
];
98 static AVCodec
*input_codecs
[MAX_FILES
*MAX_STREAMS
];
99 static int nb_input_files
= 0;
100 static int nb_icodecs
;
102 static AVFormatContext
*output_files
[MAX_FILES
];
103 static AVCodec
*output_codecs
[MAX_FILES
*MAX_STREAMS
];
104 static int nb_output_files
= 0;
105 static int nb_ocodecs
;
107 static AVStreamMap stream_maps
[MAX_FILES
*MAX_STREAMS
];
108 static int nb_stream_maps
;
110 static AVMetaDataMap meta_data_maps
[MAX_FILES
];
111 static int nb_meta_data_maps
;
113 static int frame_width
= 0;
114 static int frame_height
= 0;
115 static float frame_aspect_ratio
= 0;
116 static enum PixelFormat frame_pix_fmt
= PIX_FMT_NONE
;
117 static enum SampleFormat audio_sample_fmt
= SAMPLE_FMT_NONE
;
118 static int frame_padtop
= 0;
119 static int frame_padbottom
= 0;
120 static int frame_padleft
= 0;
121 static int frame_padright
= 0;
122 static int padcolor
[3] = {16,128,128}; /* default to black */
123 static int frame_topBand
= 0;
124 static int frame_bottomBand
= 0;
125 static int frame_leftBand
= 0;
126 static int frame_rightBand
= 0;
127 static int max_frames
[4] = {INT_MAX
, INT_MAX
, INT_MAX
, INT_MAX
};
128 static AVRational frame_rate
;
129 static float video_qscale
= 0;
130 static uint16_t *intra_matrix
= NULL
;
131 static uint16_t *inter_matrix
= NULL
;
132 static const char *video_rc_override_string
=NULL
;
133 static int video_disable
= 0;
134 static int video_discard
= 0;
135 static char *video_codec_name
= NULL
;
136 static int video_codec_tag
= 0;
137 static int same_quality
= 0;
138 static int do_deinterlace
= 0;
139 static int top_field_first
= -1;
140 static int me_threshold
= 0;
141 static int intra_dc_precision
= 8;
142 static int loop_input
= 0;
143 static int loop_output
= AVFMT_NOOUTPUTLOOP
;
144 static int qp_hist
= 0;
146 static int intra_only
= 0;
147 static int audio_sample_rate
= 44100;
148 static int64_t channel_layout
= 0;
149 #define QSCALE_NONE -99999
150 static float audio_qscale
= QSCALE_NONE
;
151 static int audio_disable
= 0;
152 static int audio_channels
= 1;
153 static char *audio_codec_name
= NULL
;
154 static int audio_codec_tag
= 0;
155 static char *audio_language
= NULL
;
157 static int subtitle_disable
= 0;
158 static char *subtitle_codec_name
= NULL
;
159 static char *subtitle_language
= NULL
;
160 static int subtitle_codec_tag
= 0;
162 static float mux_preload
= 0.5;
163 static float mux_max_delay
= 0.7;
165 static int64_t recording_time
= INT64_MAX
;
166 static int64_t start_time
= 0;
167 static int64_t rec_timestamp
= 0;
168 static int64_t input_ts_offset
= 0;
169 static int file_overwrite
= 0;
170 static int metadata_count
;
171 static AVMetadataTag
*metadata
;
172 static int do_benchmark
= 0;
173 static int do_hex_dump
= 0;
174 static int do_pkt_dump
= 0;
175 static int do_psnr
= 0;
176 static int do_pass
= 0;
177 static char *pass_logfilename_prefix
= NULL
;
178 static int audio_stream_copy
= 0;
179 static int video_stream_copy
= 0;
180 static int subtitle_stream_copy
= 0;
181 static int video_sync_method
= -1;
182 static int audio_sync_method
= 0;
183 static float audio_drift_threshold
= 0.1;
184 static int copy_ts
= 0;
185 static int opt_shortest
= 0;
186 static int video_global_header
= 0;
187 static char *vstats_filename
;
188 static FILE *vstats_file
;
189 static int opt_programid
= 0;
190 static int copy_initial_nonkeyframes
= 0;
192 static int rate_emu
= 0;
194 static int video_channel
= 0;
195 static char *video_standard
;
197 static int audio_volume
= 256;
199 static int exit_on_error
= 0;
200 static int using_stdin
= 0;
201 static int verbose
= 1;
202 static int thread_count
= 1;
203 static int q_pressed
= 0;
204 static int64_t video_size
= 0;
205 static int64_t audio_size
= 0;
206 static int64_t extra_size
= 0;
207 static int nb_frames_dup
= 0;
208 static int nb_frames_drop
= 0;
209 static int input_sync
;
210 static uint64_t limit_filesize
= 0;
211 static int force_fps
= 0;
213 static int pgmyuv_compatibility_hack
=0;
214 static float dts_delta_threshold
= 10;
216 static unsigned int sws_flags
= SWS_BICUBIC
;
218 static int64_t timer_start
;
220 static uint8_t *audio_buf
;
221 static uint8_t *audio_out
;
222 static uint8_t *audio_out2
;
224 static short *samples
;
226 static AVBitStreamFilterContext
*video_bitstream_filters
=NULL
;
227 static AVBitStreamFilterContext
*audio_bitstream_filters
=NULL
;
228 static AVBitStreamFilterContext
*subtitle_bitstream_filters
=NULL
;
229 static AVBitStreamFilterContext
*bitstream_filters
[MAX_FILES
][MAX_STREAMS
];
231 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
233 struct AVInputStream
;
235 typedef struct AVOutputStream
{
236 int file_index
; /* file index */
237 int index
; /* stream index in the output file */
238 int source_index
; /* AVInputStream 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 AVInputStream
*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
249 AVFrame pict_tmp
; /* temporary image for resampling */
250 struct SwsContext
*img_resample_ctx
; /* for image resampling */
253 int resample_pix_fmt
;
255 /* full frame size of first frame */
259 /* cropping area sizes */
266 /* cropping area of first frame */
267 int original_topBand
;
268 int original_bottomBand
;
269 int original_leftBand
;
270 int original_rightBand
;
272 /* padding area sizes */
281 ReSampleContext
*resample
; /* for audio resampling */
283 AVAudioConvert
*reformat_ctx
;
284 AVFifoBuffer
*fifo
; /* for compression: one audio fifo per codec */
288 typedef struct AVInputStream
{
292 int discard
; /* true if stream data should be discarded */
293 int decoding_needed
; /* true if the packets must be decoded in 'raw_fifo' */
294 int64_t sample_index
; /* current sample */
296 int64_t start
; /* time when read started */
297 int64_t next_pts
; /* synthetic pts for cases where pkt.pts
299 int64_t pts
; /* current pts */
300 int is_start
; /* is 1 at the start and after a discontinuity */
303 typedef struct AVInputFile
{
304 int eof_reached
; /* true if eof reached */
305 int ist_index
; /* index of first stream in ist_table */
306 int buffer_size
; /* current total buffer size */
307 int nb_streams
; /* nb streams we are aware of */
312 /* init terminal so that we can grab keys */
313 static struct termios oldtty
;
316 static void term_exit(void)
319 tcsetattr (0, TCSANOW
, &oldtty
);
323 static volatile int received_sigterm
= 0;
326 sigterm_handler(int sig
)
328 received_sigterm
= sig
;
332 static void term_init(void)
340 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
341 |INLCR
|IGNCR
|ICRNL
|IXON
);
342 tty
.c_oflag
|= OPOST
;
343 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
344 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
349 tcsetattr (0, TCSANOW
, &tty
);
350 signal(SIGQUIT
, sigterm_handler
); /* Quit (POSIX). */
353 signal(SIGINT
, sigterm_handler
); /* Interrupt (ANSI). */
354 signal(SIGTERM
, sigterm_handler
); /* Termination (ANSI). */
356 register a function to be called at normal program termination
359 #if CONFIG_BEOS_NETSERVER
360 fcntl(0, F_SETFL
, fcntl(0, F_GETFL
) | O_NONBLOCK
);
364 /* read a key without blocking */
365 static int read_key(void)
370 #if !CONFIG_BEOS_NETSERVER
378 n
= select(1, &rfds
, NULL
, NULL
, &tv
);
394 static int decode_interrupt_cb(void)
396 return q_pressed
|| (q_pressed
= read_key() == 'q');
399 static int av_exit(int ret
)
404 for(i
=0;i
<nb_output_files
;i
++) {
405 /* maybe av_close_output_file ??? */
406 AVFormatContext
*s
= output_files
[i
];
408 if (!(s
->oformat
->flags
& AVFMT_NOFILE
) && s
->pb
)
410 for(j
=0;j
<s
->nb_streams
;j
++) {
411 av_metadata_free(&s
->streams
[j
]->metadata
);
412 av_free(s
->streams
[j
]->codec
);
413 av_free(s
->streams
[j
]);
415 for(j
=0;j
<s
->nb_programs
;j
++) {
416 av_metadata_free(&s
->programs
[j
]->metadata
);
418 for(j
=0;j
<s
->nb_chapters
;j
++) {
419 av_metadata_free(&s
->chapters
[j
]->metadata
);
421 av_metadata_free(&s
->metadata
);
424 for(i
=0;i
<nb_input_files
;i
++)
425 av_close_input_file(input_files
[i
]);
427 av_free(intra_matrix
);
428 av_free(inter_matrix
);
432 av_free(vstats_filename
);
436 av_free(video_codec_name
);
437 av_free(audio_codec_name
);
438 av_free(subtitle_codec_name
);
440 av_free(video_standard
);
442 #if CONFIG_POWERPC_PERF
443 void powerpc_display_perf_report(void);
444 powerpc_display_perf_report();
445 #endif /* CONFIG_POWERPC_PERF */
447 for (i
=0;i
<CODEC_TYPE_NB
;i
++)
448 av_free(avcodec_opts
[i
]);
449 av_free(avformat_opts
);
456 if (received_sigterm
) {
458 "Received signal %d: terminating.\n",
459 (int) received_sigterm
);
463 exit(ret
); /* not all OS-es handle main() return value */
467 static int read_ffserver_streams(AVFormatContext
*s
, const char *filename
)
473 err
= av_open_input_file(&ic
, filename
, NULL
, FFM_PACKET_SIZE
, NULL
);
476 /* copy stream format */
477 s
->nb_streams
= ic
->nb_streams
;
478 for(i
=0;i
<ic
->nb_streams
;i
++) {
481 // FIXME: a more elegant solution is needed
482 st
= av_mallocz(sizeof(AVStream
));
483 memcpy(st
, ic
->streams
[i
], sizeof(AVStream
));
484 st
->codec
= avcodec_alloc_context();
486 print_error(filename
, AVERROR(ENOMEM
));
489 memcpy(st
->codec
, ic
->streams
[i
]->codec
, sizeof(AVCodecContext
));
492 if (st
->codec
->codec_type
== CODEC_TYPE_AUDIO
&& audio_stream_copy
)
494 else if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
&& video_stream_copy
)
497 if(!st
->codec
->thread_count
)
498 st
->codec
->thread_count
= 1;
499 if(st
->codec
->thread_count
>1)
500 avcodec_thread_init(st
->codec
, st
->codec
->thread_count
);
502 if(st
->codec
->flags
& CODEC_FLAG_BITEXACT
)
507 s
->timestamp
= av_gettime();
509 av_close_input_file(ic
);
514 get_sync_ipts(const AVOutputStream
*ost
)
516 const AVInputStream
*ist
= ost
->sync_ist
;
517 return (double)(ist
->pts
- start_time
)/AV_TIME_BASE
;
520 static void write_frame(AVFormatContext
*s
, AVPacket
*pkt
, AVCodecContext
*avctx
, AVBitStreamFilterContext
*bsfc
){
524 AVPacket new_pkt
= *pkt
;
525 int a
= av_bitstream_filter_filter(bsfc
, avctx
, NULL
,
526 &new_pkt
.data
, &new_pkt
.size
,
527 pkt
->data
, pkt
->size
,
528 pkt
->flags
& PKT_FLAG_KEY
);
531 new_pkt
.destruct
= av_destruct_packet
;
533 fprintf(stderr
, "%s failed for stream %d, codec %s",
534 bsfc
->filter
->name
, pkt
->stream_index
,
535 avctx
->codec
? avctx
->codec
->name
: "copy");
545 ret
= av_interleaved_write_frame(s
, pkt
);
547 print_error("av_interleaved_write_frame()", ret
);
552 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
554 static void do_audio_out(AVFormatContext
*s
,
557 unsigned char *buf
, int size
)
560 const int audio_out_size
= 4*MAX_AUDIO_PACKET_SIZE
;
562 int size_out
, frame_bytes
, ret
;
563 AVCodecContext
*enc
= ost
->st
->codec
;
564 AVCodecContext
*dec
= ist
->st
->codec
;
565 int osize
= av_get_bits_per_sample_format(enc
->sample_fmt
)/8;
566 int isize
= av_get_bits_per_sample_format(dec
->sample_fmt
)/8;
568 /* SC: dynamic allocation of buffers */
570 audio_buf
= av_malloc(2*MAX_AUDIO_PACKET_SIZE
);
572 audio_out
= av_malloc(audio_out_size
);
573 if (!audio_buf
|| !audio_out
)
574 return; /* Should signal an error ! */
576 if (enc
->channels
!= dec
->channels
)
577 ost
->audio_resample
= 1;
579 if (ost
->audio_resample
&& !ost
->resample
) {
580 if (dec
->sample_fmt
!= SAMPLE_FMT_S16
)
581 fprintf(stderr
, "Warning, using s16 intermediate sample format for resampling\n");
582 ost
->resample
= av_audio_resample_init(enc
->channels
, dec
->channels
,
583 enc
->sample_rate
, dec
->sample_rate
,
584 enc
->sample_fmt
, dec
->sample_fmt
,
586 if (!ost
->resample
) {
587 fprintf(stderr
, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
588 dec
->channels
, dec
->sample_rate
,
589 enc
->channels
, enc
->sample_rate
);
594 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
595 if (!ost
->audio_resample
&& dec
->sample_fmt
!=enc
->sample_fmt
&&
596 MAKE_SFMT_PAIR(enc
->sample_fmt
,dec
->sample_fmt
)!=ost
->reformat_pair
) {
598 audio_out2
= av_malloc(audio_out_size
);
601 if (ost
->reformat_ctx
)
602 av_audio_convert_free(ost
->reformat_ctx
);
603 ost
->reformat_ctx
= av_audio_convert_alloc(enc
->sample_fmt
, 1,
604 dec
->sample_fmt
, 1, NULL
, 0);
605 if (!ost
->reformat_ctx
) {
606 fprintf(stderr
, "Cannot convert %s sample format to %s sample format\n",
607 avcodec_get_sample_fmt_name(dec
->sample_fmt
),
608 avcodec_get_sample_fmt_name(enc
->sample_fmt
));
611 ost
->reformat_pair
=MAKE_SFMT_PAIR(enc
->sample_fmt
,dec
->sample_fmt
);
614 if(audio_sync_method
){
615 double delta
= get_sync_ipts(ost
) * enc
->sample_rate
- ost
->sync_opts
616 - av_fifo_size(ost
->fifo
)/(ost
->st
->codec
->channels
* 2);
617 double idelta
= delta
*ist
->st
->codec
->sample_rate
/ enc
->sample_rate
;
618 int byte_delta
= ((int)idelta
)*2*ist
->st
->codec
->channels
;
620 //FIXME resample delay
621 if(fabs(delta
) > 50){
622 if(ist
->is_start
|| fabs(delta
) > audio_drift_threshold
*enc
->sample_rate
){
624 byte_delta
= FFMAX(byte_delta
, -size
);
628 fprintf(stderr
, "discarding %d audio samples\n", (int)-delta
);
633 static uint8_t *input_tmp
= NULL
;
634 input_tmp
= av_realloc(input_tmp
, byte_delta
+ size
);
636 if(byte_delta
+ size
<= MAX_AUDIO_PACKET_SIZE
)
639 byte_delta
= MAX_AUDIO_PACKET_SIZE
- size
;
641 memset(input_tmp
, 0, byte_delta
);
642 memcpy(input_tmp
+ byte_delta
, buf
, size
);
646 fprintf(stderr
, "adding %d audio samples of silence\n", (int)delta
);
648 }else if(audio_sync_method
>1){
649 int comp
= av_clip(delta
, -audio_sync_method
, audio_sync_method
);
650 assert(ost
->audio_resample
);
652 fprintf(stderr
, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta
, comp
, enc
->sample_rate
);
653 // 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));
654 av_resample_compensate(*(struct AVResampleContext
**)ost
->resample
, comp
, enc
->sample_rate
);
658 ost
->sync_opts
= lrintf(get_sync_ipts(ost
) * enc
->sample_rate
)
659 - av_fifo_size(ost
->fifo
)/(ost
->st
->codec
->channels
* 2); //FIXME wrong
661 if (ost
->audio_resample
) {
663 size_out
= audio_resample(ost
->resample
,
664 (short *)buftmp
, (short *)buf
,
665 size
/ (ist
->st
->codec
->channels
* isize
));
666 size_out
= size_out
* enc
->channels
* osize
;
672 if (!ost
->audio_resample
&& dec
->sample_fmt
!=enc
->sample_fmt
) {
673 const void *ibuf
[6]= {buftmp
};
674 void *obuf
[6]= {audio_out2
};
675 int istride
[6]= {isize
};
676 int ostride
[6]= {osize
};
677 int len
= size_out
/istride
[0];
678 if (av_audio_convert(ost
->reformat_ctx
, obuf
, ostride
, ibuf
, istride
, len
)<0) {
679 printf("av_audio_convert() failed\n");
685 size_out
= len
*osize
;
688 /* now encode as many frames as possible */
689 if (enc
->frame_size
> 1) {
690 /* output resampled raw samples */
691 if (av_fifo_realloc2(ost
->fifo
, av_fifo_size(ost
->fifo
) + size_out
) < 0) {
692 fprintf(stderr
, "av_fifo_realloc2() failed\n");
695 av_fifo_generic_write(ost
->fifo
, buftmp
, size_out
, NULL
);
697 frame_bytes
= enc
->frame_size
* osize
* enc
->channels
;
699 while (av_fifo_size(ost
->fifo
) >= frame_bytes
) {
701 av_init_packet(&pkt
);
703 av_fifo_generic_read(ost
->fifo
, audio_buf
, frame_bytes
, NULL
);
705 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
707 ret
= avcodec_encode_audio(enc
, audio_out
, audio_out_size
,
710 fprintf(stderr
, "Audio encoding failed\n");
714 pkt
.stream_index
= ost
->index
;
717 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
718 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
719 pkt
.flags
|= PKT_FLAG_KEY
;
720 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
722 ost
->sync_opts
+= enc
->frame_size
;
726 int coded_bps
= av_get_bits_per_sample(enc
->codec
->id
)/8;
727 av_init_packet(&pkt
);
729 ost
->sync_opts
+= size_out
/ (osize
* enc
->channels
);
731 /* output a pcm frame */
732 /* determine the size of the coded buffer */
735 size_out
*= coded_bps
;
737 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
738 ret
= avcodec_encode_audio(enc
, audio_out
, size_out
,
741 fprintf(stderr
, "Audio encoding failed\n");
745 pkt
.stream_index
= ost
->index
;
748 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
749 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
750 pkt
.flags
|= PKT_FLAG_KEY
;
751 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
755 static void pre_process_video_frame(AVInputStream
*ist
, AVPicture
*picture
, void **bufp
)
759 AVPicture picture_tmp
;
762 dec
= ist
->st
->codec
;
764 /* deinterlace : must be done before any resize */
765 if (do_deinterlace
) {
768 /* create temporary picture */
769 size
= avpicture_get_size(dec
->pix_fmt
, dec
->width
, dec
->height
);
770 buf
= av_malloc(size
);
774 picture2
= &picture_tmp
;
775 avpicture_fill(picture2
, buf
, dec
->pix_fmt
, dec
->width
, dec
->height
);
777 if(avpicture_deinterlace(picture2
, picture
,
778 dec
->pix_fmt
, dec
->width
, dec
->height
) < 0) {
779 /* if error, do not deinterlace */
780 fprintf(stderr
, "Deinterlacing failed\n");
789 if (picture
!= picture2
)
790 *picture
= *picture2
;
794 /* we begin to correct av delay at this threshold */
795 #define AV_DELAY_MAX 0.100
797 static void do_subtitle_out(AVFormatContext
*s
,
803 static uint8_t *subtitle_out
= NULL
;
804 int subtitle_out_max_size
= 1024 * 1024;
805 int subtitle_out_size
, nb
, i
;
809 if (pts
== AV_NOPTS_VALUE
) {
810 fprintf(stderr
, "Subtitle packets must have a pts\n");
816 enc
= ost
->st
->codec
;
819 subtitle_out
= av_malloc(subtitle_out_max_size
);
822 /* Note: DVB subtitle need one packet to draw them and one other
823 packet to clear them */
824 /* XXX: signal it in the codec context ? */
825 if (enc
->codec_id
== CODEC_ID_DVB_SUBTITLE
)
830 for(i
= 0; i
< nb
; i
++) {
831 sub
->pts
= av_rescale_q(pts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
832 // start_display_time is required to be 0
833 sub
->pts
+= av_rescale_q(sub
->start_display_time
, (AVRational
){1, 1000}, AV_TIME_BASE_Q
);
834 sub
->end_display_time
-= sub
->start_display_time
;
835 sub
->start_display_time
= 0;
836 subtitle_out_size
= avcodec_encode_subtitle(enc
, subtitle_out
,
837 subtitle_out_max_size
, sub
);
838 if (subtitle_out_size
< 0) {
839 fprintf(stderr
, "Subtitle encoding failed\n");
843 av_init_packet(&pkt
);
844 pkt
.stream_index
= ost
->index
;
845 pkt
.data
= subtitle_out
;
846 pkt
.size
= subtitle_out_size
;
847 pkt
.pts
= av_rescale_q(sub
->pts
, AV_TIME_BASE_Q
, ost
->st
->time_base
);
848 if (enc
->codec_id
== CODEC_ID_DVB_SUBTITLE
) {
849 /* XXX: the pts correction is handled here. Maybe handling
850 it in the codec would be better */
852 pkt
.pts
+= 90 * sub
->start_display_time
;
854 pkt
.pts
+= 90 * sub
->end_display_time
;
856 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
860 static int bit_buffer_size
= 1024*256;
861 static uint8_t *bit_buffer
= NULL
;
863 static void do_video_out(AVFormatContext
*s
,
869 int nb_frames
, i
, ret
;
870 int64_t topBand
, bottomBand
, leftBand
, rightBand
;
871 AVFrame
*final_picture
, *formatted_picture
, *resampling_dst
, *padding_src
;
872 AVFrame picture_crop_temp
, picture_pad_temp
;
873 AVCodecContext
*enc
, *dec
;
875 avcodec_get_frame_defaults(&picture_crop_temp
);
876 avcodec_get_frame_defaults(&picture_pad_temp
);
878 enc
= ost
->st
->codec
;
879 dec
= ist
->st
->codec
;
881 /* by default, we output a single frame */
886 if(video_sync_method
>0 || (video_sync_method
&& av_q2d(enc
->time_base
) > 0.001)){
888 vdelta
= get_sync_ipts(ost
) / av_q2d(enc
->time_base
) - ost
->sync_opts
;
889 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
892 else if (video_sync_method
== 2 || (video_sync_method
<0 && (s
->oformat
->flags
& AVFMT_VARIABLE_FPS
))){
896 ost
->sync_opts
= lrintf(get_sync_ipts(ost
) / av_q2d(enc
->time_base
));
897 }else if (vdelta
> 1.1)
898 nb_frames
= lrintf(vdelta
);
899 //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);
903 fprintf(stderr
, "*** drop!\n");
904 }else if (nb_frames
> 1) {
905 nb_frames_dup
+= nb_frames
;
907 fprintf(stderr
, "*** %d dup!\n", nb_frames
-1);
910 ost
->sync_opts
= lrintf(get_sync_ipts(ost
) / av_q2d(enc
->time_base
));
912 nb_frames
= FFMIN(nb_frames
, max_frames
[CODEC_TYPE_VIDEO
] - ost
->frame_number
);
916 if (ost
->video_crop
) {
917 if (av_picture_crop((AVPicture
*)&picture_crop_temp
, (AVPicture
*)in_picture
, dec
->pix_fmt
, ost
->topBand
, ost
->leftBand
) < 0) {
918 fprintf(stderr
, "error cropping picture\n");
923 formatted_picture
= &picture_crop_temp
;
925 formatted_picture
= in_picture
;
928 final_picture
= formatted_picture
;
929 padding_src
= formatted_picture
;
930 resampling_dst
= &ost
->pict_tmp
;
931 if (ost
->video_pad
) {
932 final_picture
= &ost
->pict_tmp
;
933 if (ost
->video_resample
) {
934 if (av_picture_crop((AVPicture
*)&picture_pad_temp
, (AVPicture
*)final_picture
, enc
->pix_fmt
, ost
->padtop
, ost
->padleft
) < 0) {
935 fprintf(stderr
, "error padding picture\n");
940 resampling_dst
= &picture_pad_temp
;
944 if (ost
->video_resample
) {
946 final_picture
= &ost
->pict_tmp
;
947 if( (ost
->resample_height
!= (ist
->st
->codec
->height
- (ost
->topBand
+ ost
->bottomBand
)))
948 || (ost
->resample_width
!= (ist
->st
->codec
->width
- (ost
->leftBand
+ ost
->rightBand
)))
949 || (ost
->resample_pix_fmt
!= ist
->st
->codec
->pix_fmt
) ) {
951 fprintf(stderr
,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist
->file_index
, ist
->index
, ist
->st
->codec
->width
, ist
->st
->codec
->height
,avcodec_get_pix_fmt_name(ist
->st
->codec
->pix_fmt
));
952 /* keep bands proportional to the frame size */
953 topBand
= ((int64_t)ist
->st
->codec
->height
* ost
->original_topBand
/ ost
->original_height
) & ~1;
954 bottomBand
= ((int64_t)ist
->st
->codec
->height
* ost
->original_bottomBand
/ ost
->original_height
) & ~1;
955 leftBand
= ((int64_t)ist
->st
->codec
->width
* ost
->original_leftBand
/ ost
->original_width
) & ~1;
956 rightBand
= ((int64_t)ist
->st
->codec
->width
* ost
->original_rightBand
/ ost
->original_width
) & ~1;
958 /* sanity check to ensure no bad band sizes sneak in */
959 assert(topBand
<= INT_MAX
&& topBand
>= 0);
960 assert(bottomBand
<= INT_MAX
&& bottomBand
>= 0);
961 assert(leftBand
<= INT_MAX
&& leftBand
>= 0);
962 assert(rightBand
<= INT_MAX
&& rightBand
>= 0);
964 ost
->topBand
= topBand
;
965 ost
->bottomBand
= bottomBand
;
966 ost
->leftBand
= leftBand
;
967 ost
->rightBand
= rightBand
;
969 ost
->resample_height
= ist
->st
->codec
->height
- (ost
->topBand
+ ost
->bottomBand
);
970 ost
->resample_width
= ist
->st
->codec
->width
- (ost
->leftBand
+ ost
->rightBand
);
971 ost
->resample_pix_fmt
= ist
->st
->codec
->pix_fmt
;
973 /* initialize a new scaler context */
974 sws_freeContext(ost
->img_resample_ctx
);
975 sws_flags
= av_get_int(sws_opts
, "sws_flags", NULL
);
976 ost
->img_resample_ctx
= sws_getContext(
977 ist
->st
->codec
->width
- (ost
->leftBand
+ ost
->rightBand
),
978 ist
->st
->codec
->height
- (ost
->topBand
+ ost
->bottomBand
),
979 ist
->st
->codec
->pix_fmt
,
980 ost
->st
->codec
->width
- (ost
->padleft
+ ost
->padright
),
981 ost
->st
->codec
->height
- (ost
->padtop
+ ost
->padbottom
),
982 ost
->st
->codec
->pix_fmt
,
983 sws_flags
, NULL
, NULL
, NULL
);
984 if (ost
->img_resample_ctx
== NULL
) {
985 fprintf(stderr
, "Cannot get resampling context\n");
989 sws_scale(ost
->img_resample_ctx
, formatted_picture
->data
, formatted_picture
->linesize
,
990 0, ost
->resample_height
, resampling_dst
->data
, resampling_dst
->linesize
);
993 if (ost
->video_pad
) {
994 av_picture_pad((AVPicture
*)final_picture
, (AVPicture
*)padding_src
,
995 enc
->height
, enc
->width
, enc
->pix_fmt
,
996 ost
->padtop
, ost
->padbottom
, ost
->padleft
, ost
->padright
, padcolor
);
999 /* duplicates frame if needed */
1000 for(i
=0;i
<nb_frames
;i
++) {
1002 av_init_packet(&pkt
);
1003 pkt
.stream_index
= ost
->index
;
1005 if (s
->oformat
->flags
& AVFMT_RAWPICTURE
) {
1006 /* raw pictures are written as AVPicture structure to
1007 avoid any copies. We support temorarily the older
1009 AVFrame
* old_frame
= enc
->coded_frame
;
1010 enc
->coded_frame
= dec
->coded_frame
; //FIXME/XXX remove this hack
1011 pkt
.data
= (uint8_t *)final_picture
;
1012 pkt
.size
= sizeof(AVPicture
);
1013 pkt
.pts
= av_rescale_q(ost
->sync_opts
, enc
->time_base
, ost
->st
->time_base
);
1014 pkt
.flags
|= PKT_FLAG_KEY
;
1016 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
1017 enc
->coded_frame
= old_frame
;
1019 AVFrame big_picture
;
1021 big_picture
= *final_picture
;
1022 /* better than nothing: use input picture interlaced
1024 big_picture
.interlaced_frame
= in_picture
->interlaced_frame
;
1025 if(avcodec_opts
[CODEC_TYPE_VIDEO
]->flags
& (CODEC_FLAG_INTERLACED_DCT
|CODEC_FLAG_INTERLACED_ME
)){
1026 if(top_field_first
== -1)
1027 big_picture
.top_field_first
= in_picture
->top_field_first
;
1029 big_picture
.top_field_first
= top_field_first
;
1032 /* handles sameq here. This is not correct because it may
1033 not be a global option */
1035 big_picture
.quality
= ist
->st
->quality
;
1037 big_picture
.quality
= ost
->st
->quality
;
1039 big_picture
.pict_type
= 0;
1040 // big_picture.pts = AV_NOPTS_VALUE;
1041 big_picture
.pts
= ost
->sync_opts
;
1042 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1043 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1044 ret
= avcodec_encode_video(enc
,
1045 bit_buffer
, bit_buffer_size
,
1048 fprintf(stderr
, "Video encoding failed\n");
1053 pkt
.data
= bit_buffer
;
1055 if(enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
1056 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
1057 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1058 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1059 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1061 if(enc
->coded_frame
->key_frame
)
1062 pkt
.flags
|= PKT_FLAG_KEY
;
1063 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
1066 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1067 // enc->frame_number-1, ret, enc->pict_type);
1068 /* if two pass, output log */
1069 if (ost
->logfile
&& enc
->stats_out
) {
1070 fprintf(ost
->logfile
, "%s", enc
->stats_out
);
1075 ost
->frame_number
++;
1079 static double psnr(double d
){
1080 return -10.0*log(d
)/log(10.0);
1083 static void do_video_stats(AVFormatContext
*os
, AVOutputStream
*ost
,
1086 AVCodecContext
*enc
;
1088 double ti1
, bitrate
, avg_bitrate
;
1090 /* this is executed just the first time do_video_stats is called */
1092 vstats_file
= fopen(vstats_filename
, "w");
1099 enc
= ost
->st
->codec
;
1100 if (enc
->codec_type
== CODEC_TYPE_VIDEO
) {
1101 frame_number
= ost
->frame_number
;
1102 fprintf(vstats_file
, "frame= %5d q= %2.1f ", frame_number
, enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
);
1103 if (enc
->flags
&CODEC_FLAG_PSNR
)
1104 fprintf(vstats_file
, "PSNR= %6.2f ", psnr(enc
->coded_frame
->error
[0]/(enc
->width
*enc
->height
*255.0*255.0)));
1106 fprintf(vstats_file
,"f_size= %6d ", frame_size
);
1107 /* compute pts value */
1108 ti1
= ost
->sync_opts
* av_q2d(enc
->time_base
);
1112 bitrate
= (frame_size
* 8) / av_q2d(enc
->time_base
) / 1000.0;
1113 avg_bitrate
= (double)(video_size
* 8) / ti1
/ 1000.0;
1114 fprintf(vstats_file
, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1115 (double)video_size
/ 1024, ti1
, bitrate
, avg_bitrate
);
1116 fprintf(vstats_file
,"type= %c\n", av_get_pict_type_char(enc
->coded_frame
->pict_type
));
1120 static void print_report(AVFormatContext
**output_files
,
1121 AVOutputStream
**ost_table
, int nb_ostreams
,
1125 AVOutputStream
*ost
;
1126 AVFormatContext
*oc
;
1128 AVCodecContext
*enc
;
1129 int frame_number
, vid
, i
;
1130 double bitrate
, ti1
, pts
;
1131 static int64_t last_time
= -1;
1132 static int qp_histogram
[52];
1134 if (!is_last_report
) {
1136 /* display the report every 0.5 seconds */
1137 cur_time
= av_gettime();
1138 if (last_time
== -1) {
1139 last_time
= cur_time
;
1142 if ((cur_time
- last_time
) < 500000)
1144 last_time
= cur_time
;
1148 oc
= output_files
[0];
1150 total_size
= url_fsize(oc
->pb
);
1151 if(total_size
<0) // FIXME improve url_fsize() so it works with non seekable output too
1152 total_size
= url_ftell(oc
->pb
);
1157 for(i
=0;i
<nb_ostreams
;i
++) {
1159 enc
= ost
->st
->codec
;
1160 if (vid
&& enc
->codec_type
== CODEC_TYPE_VIDEO
) {
1161 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "q=%2.1f ",
1162 !ost
->st
->stream_copy
?
1163 enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
: -1);
1165 if (!vid
&& enc
->codec_type
== CODEC_TYPE_VIDEO
) {
1166 float t
= (av_gettime()-timer_start
) / 1000000.0;
1168 frame_number
= ost
->frame_number
;
1169 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "frame=%5d fps=%3d q=%3.1f ",
1170 frame_number
, (t
>1)?(int)(frame_number
/t
+0.5) : 0,
1171 !ost
->st
->stream_copy
?
1172 enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
: -1);
1174 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "L");
1177 int qp
= lrintf(enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
);
1178 if(qp
>=0 && qp
<FF_ARRAY_ELEMS(qp_histogram
))
1181 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "%X", (int)lrintf(log(qp_histogram
[j
]+1)/log(2)));
1183 if (enc
->flags
&CODEC_FLAG_PSNR
){
1185 double error
, error_sum
=0;
1186 double scale
, scale_sum
=0;
1187 char type
[3]= {'Y','U','V'};
1188 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "PSNR=");
1191 error
= enc
->error
[j
];
1192 scale
= enc
->width
*enc
->height
*255.0*255.0*frame_number
;
1194 error
= enc
->coded_frame
->error
[j
];
1195 scale
= enc
->width
*enc
->height
*255.0*255.0;
1200 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "%c:%2.2f ", type
[j
], psnr(error
/scale
));
1202 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "*:%2.2f ", psnr(error_sum
/scale_sum
));
1206 /* compute min output value */
1207 pts
= (double)ost
->st
->pts
.val
* av_q2d(ost
->st
->time_base
);
1208 if ((pts
< ti1
) && (pts
> 0))
1214 if (verbose
|| is_last_report
) {
1215 bitrate
= (double)(total_size
* 8) / ti1
/ 1000.0;
1217 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
1218 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1219 (double)total_size
/ 1024, ti1
, bitrate
);
1222 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), " dup=%d drop=%d",
1223 nb_frames_dup
, nb_frames_drop
);
1226 fprintf(stderr
, "%s \r", buf
);
1231 if (is_last_report
&& verbose
>= 0){
1232 int64_t raw
= audio_size
+ video_size
+ extra_size
;
1233 fprintf(stderr
, "\n");
1234 fprintf(stderr
, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1238 100.0*(total_size
- raw
)/raw
1243 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1244 static int output_packet(AVInputStream
*ist
, int ist_index
,
1245 AVOutputStream
**ost_table
, int nb_ostreams
,
1246 const AVPacket
*pkt
)
1248 AVFormatContext
*os
;
1249 AVOutputStream
*ost
;
1252 int data_size
, got_picture
;
1254 void *buffer_to_free
;
1255 static unsigned int samples_size
= 0;
1256 AVSubtitle subtitle
, *subtitle_to_free
;
1259 int bps
= av_get_bits_per_sample_format(ist
->st
->codec
->sample_fmt
)>>3;
1261 if(ist
->next_pts
== AV_NOPTS_VALUE
)
1262 ist
->next_pts
= ist
->pts
;
1266 av_init_packet(&avpkt
);
1274 if(pkt
->dts
!= AV_NOPTS_VALUE
)
1275 ist
->next_pts
= ist
->pts
= av_rescale_q(pkt
->dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
1277 //while we have more to decode or while the decoder did output something on EOF
1278 while (avpkt
.size
> 0 || (!pkt
&& ist
->next_pts
!= ist
->pts
)) {
1280 ist
->pts
= ist
->next_pts
;
1282 if(avpkt
.size
&& avpkt
.size
!= pkt
->size
&&
1283 !(ist
->st
->codec
->codec
->capabilities
& CODEC_CAP_SUBFRAMES
) && verbose
>0)
1284 fprintf(stderr
, "Multiple frames in a packet from stream %d\n", pkt
->stream_index
);
1286 /* decode the packet if needed */
1287 data_buf
= NULL
; /* fail safe */
1289 subtitle_to_free
= NULL
;
1290 if (ist
->decoding_needed
) {
1291 switch(ist
->st
->codec
->codec_type
) {
1292 case CODEC_TYPE_AUDIO
:{
1293 if(pkt
&& samples_size
< FFMAX(pkt
->size
*sizeof(*samples
), AVCODEC_MAX_AUDIO_FRAME_SIZE
)) {
1294 samples_size
= FFMAX(pkt
->size
*sizeof(*samples
), AVCODEC_MAX_AUDIO_FRAME_SIZE
);
1296 samples
= av_malloc(samples_size
);
1298 data_size
= samples_size
;
1299 /* XXX: could avoid copy if PCM 16 bits with same
1300 endianness as CPU */
1301 ret
= avcodec_decode_audio3(ist
->st
->codec
, samples
, &data_size
,
1307 /* Some bug in mpeg audio decoder gives */
1308 /* data_size < 0, it seems they are overflows */
1309 if (data_size
<= 0) {
1310 /* no audio frame */
1313 data_buf
= (uint8_t *)samples
;
1314 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
/bps
* data_size
) /
1315 (ist
->st
->codec
->sample_rate
* ist
->st
->codec
->channels
);
1317 case CODEC_TYPE_VIDEO
:
1318 data_size
= (ist
->st
->codec
->width
* ist
->st
->codec
->height
* 3) / 2;
1319 /* XXX: allocate picture correctly */
1320 avcodec_get_frame_defaults(&picture
);
1322 ret
= avcodec_decode_video2(ist
->st
->codec
,
1323 &picture
, &got_picture
, &avpkt
);
1324 ist
->st
->quality
= picture
.quality
;
1328 /* no picture yet */
1329 goto discard_packet
;
1331 if (ist
->st
->codec
->time_base
.num
!= 0) {
1332 int ticks
= ist
->st
->parser
? ist
->st
->parser
->repeat_pict
+1 : ist
->st
->codec
->ticks_per_frame
;
1333 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
*
1334 ist
->st
->codec
->time_base
.num
* ticks
) /
1335 ist
->st
->codec
->time_base
.den
;
1339 case CODEC_TYPE_SUBTITLE
:
1340 ret
= avcodec_decode_subtitle2(ist
->st
->codec
,
1341 &subtitle
, &got_subtitle
, &avpkt
);
1344 if (!got_subtitle
) {
1345 goto discard_packet
;
1347 subtitle_to_free
= &subtitle
;
1354 switch(ist
->st
->codec
->codec_type
) {
1355 case CODEC_TYPE_AUDIO
:
1356 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
* ist
->st
->codec
->frame_size
) /
1357 ist
->st
->codec
->sample_rate
;
1359 case CODEC_TYPE_VIDEO
:
1360 if (ist
->st
->codec
->time_base
.num
!= 0) {
1361 int ticks
= ist
->st
->parser
? ist
->st
->parser
->repeat_pict
+1 : ist
->st
->codec
->ticks_per_frame
;
1362 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
*
1363 ist
->st
->codec
->time_base
.num
* ticks
) /
1364 ist
->st
->codec
->time_base
.den
;
1368 data_buf
= avpkt
.data
;
1369 data_size
= avpkt
.size
;
1374 buffer_to_free
= NULL
;
1375 if (ist
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
1376 pre_process_video_frame(ist
, (AVPicture
*)&picture
,
1380 // preprocess audio (volume)
1381 if (ist
->st
->codec
->codec_type
== CODEC_TYPE_AUDIO
) {
1382 if (audio_volume
!= 256) {
1385 for(i
=0;i
<(data_size
/ sizeof(short));i
++) {
1386 int v
= ((*volp
) * audio_volume
+ 128) >> 8;
1387 if (v
< -32768) v
= -32768;
1388 if (v
> 32767) v
= 32767;
1394 /* frame rate emulation */
1396 int64_t pts
= av_rescale(ist
->pts
, 1000000, AV_TIME_BASE
);
1397 int64_t now
= av_gettime() - ist
->start
;
1402 /* if output time reached then transcode raw format,
1403 encode packets and output them */
1404 if (start_time
== 0 || ist
->pts
>= start_time
)
1405 for(i
=0;i
<nb_ostreams
;i
++) {
1409 if (ost
->source_index
== ist_index
) {
1410 os
= output_files
[ost
->file_index
];
1412 /* set the input output pts pairs */
1413 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1415 if (ost
->encoding_needed
) {
1416 switch(ost
->st
->codec
->codec_type
) {
1417 case CODEC_TYPE_AUDIO
:
1418 do_audio_out(os
, ost
, ist
, data_buf
, data_size
);
1420 case CODEC_TYPE_VIDEO
:
1421 do_video_out(os
, ost
, ist
, &picture
, &frame_size
);
1422 if (vstats_filename
&& frame_size
)
1423 do_video_stats(os
, ost
, frame_size
);
1425 case CODEC_TYPE_SUBTITLE
:
1426 do_subtitle_out(os
, ost
, ist
, &subtitle
,
1433 AVFrame avframe
; //FIXME/XXX remove this
1435 int64_t ost_tb_start_time
= av_rescale_q(start_time
, AV_TIME_BASE_Q
, ost
->st
->time_base
);
1437 av_init_packet(&opkt
);
1439 if ((!ost
->frame_number
&& !(pkt
->flags
& PKT_FLAG_KEY
)) && !copy_initial_nonkeyframes
)
1442 /* no reencoding needed : output the packet directly */
1443 /* force the input stream PTS */
1445 avcodec_get_frame_defaults(&avframe
);
1446 ost
->st
->codec
->coded_frame
= &avframe
;
1447 avframe
.key_frame
= pkt
->flags
& PKT_FLAG_KEY
;
1449 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_AUDIO
)
1450 audio_size
+= data_size
;
1451 else if (ost
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
1452 video_size
+= data_size
;
1456 opkt
.stream_index
= ost
->index
;
1457 if(pkt
->pts
!= AV_NOPTS_VALUE
)
1458 opkt
.pts
= av_rescale_q(pkt
->pts
, ist
->st
->time_base
, ost
->st
->time_base
) - ost_tb_start_time
;
1460 opkt
.pts
= AV_NOPTS_VALUE
;
1462 if (pkt
->dts
== AV_NOPTS_VALUE
)
1463 opkt
.dts
= av_rescale_q(ist
->pts
, AV_TIME_BASE_Q
, ost
->st
->time_base
);
1465 opkt
.dts
= av_rescale_q(pkt
->dts
, ist
->st
->time_base
, ost
->st
->time_base
);
1466 opkt
.dts
-= ost_tb_start_time
;
1468 opkt
.duration
= av_rescale_q(pkt
->duration
, ist
->st
->time_base
, ost
->st
->time_base
);
1469 opkt
.flags
= pkt
->flags
;
1471 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1472 if(ost
->st
->codec
->codec_id
!= CODEC_ID_H264
) {
1473 if(av_parser_change(ist
->st
->parser
, ost
->st
->codec
, &opkt
.data
, &opkt
.size
, data_buf
, data_size
, pkt
->flags
& PKT_FLAG_KEY
))
1474 opkt
.destruct
= av_destruct_packet
;
1476 opkt
.data
= data_buf
;
1477 opkt
.size
= data_size
;
1480 write_frame(os
, &opkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][opkt
.stream_index
]);
1481 ost
->st
->codec
->frame_number
++;
1482 ost
->frame_number
++;
1483 av_free_packet(&opkt
);
1487 av_free(buffer_to_free
);
1488 /* XXX: allocate the subtitles in the codec ? */
1489 if (subtitle_to_free
) {
1490 if (subtitle_to_free
->rects
!= NULL
) {
1491 for (i
= 0; i
< subtitle_to_free
->num_rects
; i
++) {
1492 av_freep(&subtitle_to_free
->rects
[i
]->pict
.data
[0]);
1493 av_freep(&subtitle_to_free
->rects
[i
]->pict
.data
[1]);
1494 av_freep(&subtitle_to_free
->rects
[i
]);
1496 av_freep(&subtitle_to_free
->rects
);
1498 subtitle_to_free
->num_rects
= 0;
1499 subtitle_to_free
= NULL
;
1506 for(i
=0;i
<nb_ostreams
;i
++) {
1508 if (ost
->source_index
== ist_index
) {
1509 AVCodecContext
*enc
= ost
->st
->codec
;
1510 os
= output_files
[ost
->file_index
];
1512 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_AUDIO
&& enc
->frame_size
<=1)
1514 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
&& (os
->oformat
->flags
& AVFMT_RAWPICTURE
))
1517 if (ost
->encoding_needed
) {
1521 av_init_packet(&pkt
);
1522 pkt
.stream_index
= ost
->index
;
1524 switch(ost
->st
->codec
->codec_type
) {
1525 case CODEC_TYPE_AUDIO
:
1526 fifo_bytes
= av_fifo_size(ost
->fifo
);
1528 /* encode any samples remaining in fifo */
1529 if (fifo_bytes
> 0) {
1530 int osize
= av_get_bits_per_sample_format(enc
->sample_fmt
) >> 3;
1531 int fs_tmp
= enc
->frame_size
;
1533 av_fifo_generic_read(ost
->fifo
, samples
, fifo_bytes
, NULL
);
1534 if (enc
->codec
->capabilities
& CODEC_CAP_SMALL_LAST_FRAME
) {
1535 enc
->frame_size
= fifo_bytes
/ (osize
* enc
->channels
);
1537 int frame_bytes
= enc
->frame_size
*osize
*enc
->channels
;
1538 if (samples_size
< frame_bytes
)
1540 memset((uint8_t*)samples
+fifo_bytes
, 0, frame_bytes
- fifo_bytes
);
1543 ret
= avcodec_encode_audio(enc
, bit_buffer
, bit_buffer_size
, samples
);
1544 pkt
.duration
= av_rescale((int64_t)enc
->frame_size
*ost
->st
->time_base
.den
,
1545 ost
->st
->time_base
.num
, enc
->sample_rate
);
1546 enc
->frame_size
= fs_tmp
;
1549 ret
= avcodec_encode_audio(enc
, bit_buffer
, bit_buffer_size
, NULL
);
1552 fprintf(stderr
, "Audio encoding failed\n");
1556 pkt
.flags
|= PKT_FLAG_KEY
;
1558 case CODEC_TYPE_VIDEO
:
1559 ret
= avcodec_encode_video(enc
, bit_buffer
, bit_buffer_size
, NULL
);
1561 fprintf(stderr
, "Video encoding failed\n");
1565 if(enc
->coded_frame
&& enc
->coded_frame
->key_frame
)
1566 pkt
.flags
|= PKT_FLAG_KEY
;
1567 if (ost
->logfile
&& enc
->stats_out
) {
1568 fprintf(ost
->logfile
, "%s", enc
->stats_out
);
1577 pkt
.data
= bit_buffer
;
1579 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
1580 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
1581 write_frame(os
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
1593 static void print_sdp(AVFormatContext
**avc
, int n
)
1597 avf_sdp_create(avc
, n
, sdp
, sizeof(sdp
));
1598 printf("SDP:\n%s\n", sdp
);
1602 static int stream_index_from_inputs(AVFormatContext
**input_files
,
1604 AVInputFile
*file_table
,
1605 AVInputStream
**ist_table
,
1606 enum CodecType type
,
1610 for(z
=0; z
<nb_input_files
; z
++) {
1611 AVFormatContext
*ic
= input_files
[z
];
1612 for(p
=0; p
<ic
->nb_programs
; p
++) {
1613 AVProgram
*program
= ic
->programs
[p
];
1614 if(program
->id
!= programid
)
1616 for(q
=0; q
<program
->nb_stream_indexes
; q
++) {
1617 int sidx
= program
->stream_index
[q
];
1618 int ris
= file_table
[z
].ist_index
+ sidx
;
1619 if(ist_table
[ris
]->discard
&& ic
->streams
[sidx
]->codec
->codec_type
== type
)
1629 * The following code is the main loop of the file converter
1631 static int av_encode(AVFormatContext
**output_files
,
1632 int nb_output_files
,
1633 AVFormatContext
**input_files
,
1635 AVStreamMap
*stream_maps
, int nb_stream_maps
)
1637 int ret
= 0, i
, j
, k
, n
, nb_istreams
= 0, nb_ostreams
= 0;
1638 AVFormatContext
*is
, *os
;
1639 AVCodecContext
*codec
, *icodec
;
1640 AVOutputStream
*ost
, **ost_table
= NULL
;
1641 AVInputStream
*ist
, **ist_table
= NULL
;
1642 AVInputFile
*file_table
;
1646 uint8_t no_packet
[MAX_FILES
]={0};
1647 int no_packet_count
=0;
1649 file_table
= av_mallocz(nb_input_files
* sizeof(AVInputFile
));
1653 /* input stream init */
1655 for(i
=0;i
<nb_input_files
;i
++) {
1656 is
= input_files
[i
];
1657 file_table
[i
].ist_index
= j
;
1658 file_table
[i
].nb_streams
= is
->nb_streams
;
1659 j
+= is
->nb_streams
;
1663 ist_table
= av_mallocz(nb_istreams
* sizeof(AVInputStream
*));
1667 for(i
=0;i
<nb_istreams
;i
++) {
1668 ist
= av_mallocz(sizeof(AVInputStream
));
1674 for(i
=0;i
<nb_input_files
;i
++) {
1675 is
= input_files
[i
];
1676 for(k
=0;k
<is
->nb_streams
;k
++) {
1677 ist
= ist_table
[j
++];
1678 ist
->st
= is
->streams
[k
];
1679 ist
->file_index
= i
;
1681 ist
->discard
= 1; /* the stream is discarded by default
1685 ist
->start
= av_gettime();
1690 /* output stream init */
1692 for(i
=0;i
<nb_output_files
;i
++) {
1693 os
= output_files
[i
];
1694 if (!os
->nb_streams
) {
1695 dump_format(output_files
[i
], i
, output_files
[i
]->filename
, 1);
1696 fprintf(stderr
, "Output file #%d does not contain any stream\n", i
);
1699 nb_ostreams
+= os
->nb_streams
;
1701 if (nb_stream_maps
> 0 && nb_stream_maps
!= nb_ostreams
) {
1702 fprintf(stderr
, "Number of stream maps must match number of output streams\n");
1706 /* Sanity check the mapping args -- do the input files & streams exist? */
1707 for(i
=0;i
<nb_stream_maps
;i
++) {
1708 int fi
= stream_maps
[i
].file_index
;
1709 int si
= stream_maps
[i
].stream_index
;
1711 if (fi
< 0 || fi
> nb_input_files
- 1 ||
1712 si
< 0 || si
> file_table
[fi
].nb_streams
- 1) {
1713 fprintf(stderr
,"Could not find input stream #%d.%d\n", fi
, si
);
1716 fi
= stream_maps
[i
].sync_file_index
;
1717 si
= stream_maps
[i
].sync_stream_index
;
1718 if (fi
< 0 || fi
> nb_input_files
- 1 ||
1719 si
< 0 || si
> file_table
[fi
].nb_streams
- 1) {
1720 fprintf(stderr
,"Could not find sync stream #%d.%d\n", fi
, si
);
1725 ost_table
= av_mallocz(sizeof(AVOutputStream
*) * nb_ostreams
);
1728 for(i
=0;i
<nb_ostreams
;i
++) {
1729 ost
= av_mallocz(sizeof(AVOutputStream
));
1736 for(k
=0;k
<nb_output_files
;k
++) {
1737 os
= output_files
[k
];
1738 for(i
=0;i
<os
->nb_streams
;i
++,n
++) {
1741 ost
->file_index
= k
;
1743 ost
->st
= os
->streams
[i
];
1744 if (nb_stream_maps
> 0) {
1745 ost
->source_index
= file_table
[stream_maps
[n
].file_index
].ist_index
+
1746 stream_maps
[n
].stream_index
;
1748 /* Sanity check that the stream types match */
1749 if (ist_table
[ost
->source_index
]->st
->codec
->codec_type
!= ost
->st
->codec
->codec_type
) {
1750 int i
= ost
->file_index
;
1751 dump_format(output_files
[i
], i
, output_files
[i
]->filename
, 1);
1752 fprintf(stderr
, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1753 stream_maps
[n
].file_index
, stream_maps
[n
].stream_index
,
1754 ost
->file_index
, ost
->index
);
1761 j
= stream_index_from_inputs(input_files
, nb_input_files
, file_table
, ist_table
, ost
->st
->codec
->codec_type
, opt_programid
);
1763 ost
->source_index
= j
;
1767 /* get corresponding input stream index : we select the first one with the right type */
1769 for(j
=0;j
<nb_istreams
;j
++) {
1772 ist
->st
->codec
->codec_type
== ost
->st
->codec
->codec_type
) {
1773 ost
->source_index
= j
;
1781 if(! opt_programid
) {
1782 /* try again and reuse existing stream */
1783 for(j
=0;j
<nb_istreams
;j
++) {
1785 if (ist
->st
->codec
->codec_type
== ost
->st
->codec
->codec_type
) {
1786 ost
->source_index
= j
;
1792 int i
= ost
->file_index
;
1793 dump_format(output_files
[i
], i
, output_files
[i
]->filename
, 1);
1794 fprintf(stderr
, "Could not find input stream matching output stream #%d.%d\n",
1795 ost
->file_index
, ost
->index
);
1800 ist
= ist_table
[ost
->source_index
];
1802 ost
->sync_ist
= (nb_stream_maps
> 0) ?
1803 ist_table
[file_table
[stream_maps
[n
].sync_file_index
].ist_index
+
1804 stream_maps
[n
].sync_stream_index
] : ist
;
1808 /* for each output stream, we compute the right encoding parameters */
1809 for(i
=0;i
<nb_ostreams
;i
++) {
1810 AVMetadataTag
*lang
;
1812 os
= output_files
[ost
->file_index
];
1813 ist
= ist_table
[ost
->source_index
];
1815 codec
= ost
->st
->codec
;
1816 icodec
= ist
->st
->codec
;
1818 if ((lang
=av_metadata_get(ist
->st
->metadata
, "language", NULL
, 0))
1819 && !av_metadata_get(ost
->st
->metadata
, "language", NULL
, 0))
1820 av_metadata_set(&ost
->st
->metadata
, "language", lang
->value
);
1822 ost
->st
->disposition
= ist
->st
->disposition
;
1823 codec
->bits_per_raw_sample
= icodec
->bits_per_raw_sample
;
1824 codec
->chroma_sample_location
= icodec
->chroma_sample_location
;
1826 if (ost
->st
->stream_copy
) {
1827 /* if stream_copy is selected, no need to decode or encode */
1828 codec
->codec_id
= icodec
->codec_id
;
1829 codec
->codec_type
= icodec
->codec_type
;
1831 if(!codec
->codec_tag
){
1832 if( !os
->oformat
->codec_tag
1833 || av_codec_get_id (os
->oformat
->codec_tag
, icodec
->codec_tag
) > 0
1834 || av_codec_get_tag(os
->oformat
->codec_tag
, icodec
->codec_id
) <= 0)
1835 codec
->codec_tag
= icodec
->codec_tag
;
1838 codec
->bit_rate
= icodec
->bit_rate
;
1839 codec
->extradata
= icodec
->extradata
;
1840 codec
->extradata_size
= icodec
->extradata_size
;
1841 if(av_q2d(icodec
->time_base
)*icodec
->ticks_per_frame
> av_q2d(ist
->st
->time_base
) && av_q2d(ist
->st
->time_base
) < 1.0/1000){
1842 codec
->time_base
= icodec
->time_base
;
1843 codec
->time_base
.num
*= icodec
->ticks_per_frame
;
1845 codec
->time_base
= ist
->st
->time_base
;
1846 switch(codec
->codec_type
) {
1847 case CODEC_TYPE_AUDIO
:
1848 if(audio_volume
!= 256) {
1849 fprintf(stderr
,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1852 codec
->channel_layout
= icodec
->channel_layout
;
1853 codec
->sample_rate
= icodec
->sample_rate
;
1854 codec
->channels
= icodec
->channels
;
1855 codec
->frame_size
= icodec
->frame_size
;
1856 codec
->block_align
= icodec
->block_align
;
1857 if(codec
->block_align
== 1 && codec
->codec_id
== CODEC_ID_MP3
)
1858 codec
->block_align
= 0;
1859 if(codec
->codec_id
== CODEC_ID_AC3
)
1860 codec
->block_align
= 0;
1862 case CODEC_TYPE_VIDEO
:
1863 codec
->pix_fmt
= icodec
->pix_fmt
;
1864 codec
->width
= icodec
->width
;
1865 codec
->height
= icodec
->height
;
1866 codec
->has_b_frames
= icodec
->has_b_frames
;
1868 case CODEC_TYPE_SUBTITLE
:
1869 codec
->width
= icodec
->width
;
1870 codec
->height
= icodec
->height
;
1876 switch(codec
->codec_type
) {
1877 case CODEC_TYPE_AUDIO
:
1878 ost
->fifo
= av_fifo_alloc(1024);
1881 ost
->reformat_pair
= MAKE_SFMT_PAIR(SAMPLE_FMT_NONE
,SAMPLE_FMT_NONE
);
1882 ost
->audio_resample
= codec
->sample_rate
!= icodec
->sample_rate
|| audio_sync_method
> 1;
1883 icodec
->request_channels
= codec
->channels
;
1884 ist
->decoding_needed
= 1;
1885 ost
->encoding_needed
= 1;
1887 case CODEC_TYPE_VIDEO
:
1888 if (ost
->st
->codec
->pix_fmt
== PIX_FMT_NONE
) {
1889 fprintf(stderr
, "Video pixel format is unknown, stream cannot be decoded\n");
1892 ost
->video_crop
= ((frame_leftBand
+ frame_rightBand
+ frame_topBand
+ frame_bottomBand
) != 0);
1893 ost
->video_pad
= ((frame_padleft
+ frame_padright
+ frame_padtop
+ frame_padbottom
) != 0);
1894 ost
->video_resample
= ((codec
->width
!= icodec
->width
-
1895 (frame_leftBand
+ frame_rightBand
) +
1896 (frame_padleft
+ frame_padright
)) ||
1897 (codec
->height
!= icodec
->height
-
1898 (frame_topBand
+ frame_bottomBand
) +
1899 (frame_padtop
+ frame_padbottom
)) ||
1900 (codec
->pix_fmt
!= icodec
->pix_fmt
));
1901 if (ost
->video_crop
) {
1902 ost
->topBand
= ost
->original_topBand
= frame_topBand
;
1903 ost
->bottomBand
= ost
->original_bottomBand
= frame_bottomBand
;
1904 ost
->leftBand
= ost
->original_leftBand
= frame_leftBand
;
1905 ost
->rightBand
= ost
->original_rightBand
= frame_rightBand
;
1907 if (ost
->video_pad
) {
1908 ost
->padtop
= frame_padtop
;
1909 ost
->padleft
= frame_padleft
;
1910 ost
->padbottom
= frame_padbottom
;
1911 ost
->padright
= frame_padright
;
1912 if (!ost
->video_resample
) {
1913 avcodec_get_frame_defaults(&ost
->pict_tmp
);
1914 if(avpicture_alloc((AVPicture
*)&ost
->pict_tmp
, codec
->pix_fmt
,
1915 codec
->width
, codec
->height
))
1919 if (ost
->video_resample
) {
1920 avcodec_get_frame_defaults(&ost
->pict_tmp
);
1921 if(avpicture_alloc((AVPicture
*)&ost
->pict_tmp
, codec
->pix_fmt
,
1922 codec
->width
, codec
->height
)) {
1923 fprintf(stderr
, "Cannot allocate temp picture, check pix fmt\n");
1926 sws_flags
= av_get_int(sws_opts
, "sws_flags", NULL
);
1927 ost
->img_resample_ctx
= sws_getContext(
1928 icodec
->width
- (frame_leftBand
+ frame_rightBand
),
1929 icodec
->height
- (frame_topBand
+ frame_bottomBand
),
1931 codec
->width
- (frame_padleft
+ frame_padright
),
1932 codec
->height
- (frame_padtop
+ frame_padbottom
),
1934 sws_flags
, NULL
, NULL
, NULL
);
1935 if (ost
->img_resample_ctx
== NULL
) {
1936 fprintf(stderr
, "Cannot get resampling context\n");
1940 ost
->original_height
= icodec
->height
;
1941 ost
->original_width
= icodec
->width
;
1943 ost
->resample_height
= icodec
->height
- (frame_topBand
+ frame_bottomBand
);
1944 ost
->resample_width
= icodec
->width
- (frame_leftBand
+ frame_rightBand
);
1945 ost
->resample_pix_fmt
= icodec
->pix_fmt
;
1946 codec
->bits_per_raw_sample
= 0;
1948 ost
->encoding_needed
= 1;
1949 ist
->decoding_needed
= 1;
1951 case CODEC_TYPE_SUBTITLE
:
1952 ost
->encoding_needed
= 1;
1953 ist
->decoding_needed
= 1;
1960 if (ost
->encoding_needed
&&
1961 (codec
->flags
& (CODEC_FLAG_PASS1
| CODEC_FLAG_PASS2
))) {
1962 char logfilename
[1024];
1967 snprintf(logfilename
, sizeof(logfilename
), "%s-%d.log",
1968 pass_logfilename_prefix
? pass_logfilename_prefix
: DEFAULT_PASS_LOGFILENAME_PREFIX
,
1970 if (codec
->flags
& CODEC_FLAG_PASS1
) {
1971 f
= fopen(logfilename
, "w");
1973 fprintf(stderr
, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename
, strerror(errno
));
1978 /* read the log file */
1979 f
= fopen(logfilename
, "r");
1981 fprintf(stderr
, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename
, strerror(errno
));
1984 fseek(f
, 0, SEEK_END
);
1986 fseek(f
, 0, SEEK_SET
);
1987 logbuffer
= av_malloc(size
+ 1);
1989 fprintf(stderr
, "Could not allocate log buffer\n");
1992 size
= fread(logbuffer
, 1, size
, f
);
1994 logbuffer
[size
] = '\0';
1995 codec
->stats_in
= logbuffer
;
1999 if(codec
->codec_type
== CODEC_TYPE_VIDEO
){
2000 int size
= codec
->width
* codec
->height
;
2001 bit_buffer_size
= FFMAX(bit_buffer_size
, 6*size
+ 200);
2006 bit_buffer
= av_malloc(bit_buffer_size
);
2008 fprintf(stderr
, "Cannot allocate %d bytes output buffer\n",
2010 ret
= AVERROR(ENOMEM
);
2014 /* open each encoder */
2015 for(i
=0;i
<nb_ostreams
;i
++) {
2017 if (ost
->encoding_needed
) {
2018 AVCodec
*codec
= output_codecs
[i
];
2020 codec
= avcodec_find_encoder(ost
->st
->codec
->codec_id
);
2022 snprintf(error
, sizeof(error
), "Encoder (codec id %d) not found for output stream #%d.%d",
2023 ost
->st
->codec
->codec_id
, ost
->file_index
, ost
->index
);
2024 ret
= AVERROR(EINVAL
);
2027 if (avcodec_open(ost
->st
->codec
, codec
) < 0) {
2028 snprintf(error
, sizeof(error
), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2029 ost
->file_index
, ost
->index
);
2030 ret
= AVERROR(EINVAL
);
2033 extra_size
+= ost
->st
->codec
->extradata_size
;
2037 /* open each decoder */
2038 for(i
=0;i
<nb_istreams
;i
++) {
2040 if (ist
->decoding_needed
) {
2041 AVCodec
*codec
= input_codecs
[i
];
2043 codec
= avcodec_find_decoder(ist
->st
->codec
->codec_id
);
2045 snprintf(error
, sizeof(error
), "Decoder (codec id %d) not found for input stream #%d.%d",
2046 ist
->st
->codec
->codec_id
, ist
->file_index
, ist
->index
);
2047 ret
= AVERROR(EINVAL
);
2050 if (avcodec_open(ist
->st
->codec
, codec
) < 0) {
2051 snprintf(error
, sizeof(error
), "Error while opening decoder for input stream #%d.%d",
2052 ist
->file_index
, ist
->index
);
2053 ret
= AVERROR(EINVAL
);
2056 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2057 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2062 for(i
=0;i
<nb_istreams
;i
++) {
2065 ist
->next_pts
= AV_NOPTS_VALUE
;
2069 /* set meta data information from input file if required */
2070 for (i
=0;i
<nb_meta_data_maps
;i
++) {
2071 AVFormatContext
*out_file
;
2072 AVFormatContext
*in_file
;
2073 AVMetadataTag
*mtag
;
2075 int out_file_index
= meta_data_maps
[i
].out_file
;
2076 int in_file_index
= meta_data_maps
[i
].in_file
;
2077 if (out_file_index
< 0 || out_file_index
>= nb_output_files
) {
2078 snprintf(error
, sizeof(error
), "Invalid output file index %d map_meta_data(%d,%d)",
2079 out_file_index
, out_file_index
, in_file_index
);
2080 ret
= AVERROR(EINVAL
);
2083 if (in_file_index
< 0 || in_file_index
>= nb_input_files
) {
2084 snprintf(error
, sizeof(error
), "Invalid input file index %d map_meta_data(%d,%d)",
2085 in_file_index
, out_file_index
, in_file_index
);
2086 ret
= AVERROR(EINVAL
);
2090 out_file
= output_files
[out_file_index
];
2091 in_file
= input_files
[in_file_index
];
2095 while((mtag
=av_metadata_get(in_file
->metadata
, "", mtag
, AV_METADATA_IGNORE_SUFFIX
)))
2096 av_metadata_set(&out_file
->metadata
, mtag
->key
, mtag
->value
);
2097 av_metadata_conv(out_file
, out_file
->oformat
->metadata_conv
,
2098 in_file
->iformat
->metadata_conv
);
2101 /* open files and write file headers */
2102 for(i
=0;i
<nb_output_files
;i
++) {
2103 os
= output_files
[i
];
2104 if (av_write_header(os
) < 0) {
2105 snprintf(error
, sizeof(error
), "Could not write header for output file #%d (incorrect codec parameters ?)", i
);
2106 ret
= AVERROR(EINVAL
);
2109 if (strcmp(output_files
[i
]->oformat
->name
, "rtp")) {
2115 /* dump the file output parameters - cannot be done before in case
2117 for(i
=0;i
<nb_output_files
;i
++) {
2118 dump_format(output_files
[i
], i
, output_files
[i
]->filename
, 1);
2121 /* dump the stream mapping */
2123 fprintf(stderr
, "Stream mapping:\n");
2124 for(i
=0;i
<nb_ostreams
;i
++) {
2126 fprintf(stderr
, " Stream #%d.%d -> #%d.%d",
2127 ist_table
[ost
->source_index
]->file_index
,
2128 ist_table
[ost
->source_index
]->index
,
2131 if (ost
->sync_ist
!= ist_table
[ost
->source_index
])
2132 fprintf(stderr
, " [sync #%d.%d]",
2133 ost
->sync_ist
->file_index
,
2134 ost
->sync_ist
->index
);
2135 fprintf(stderr
, "\n");
2140 fprintf(stderr
, "%s\n", error
);
2145 print_sdp(output_files
, nb_output_files
);
2148 if (!using_stdin
&& verbose
>= 0) {
2149 fprintf(stderr
, "Press [q] to stop encoding\n");
2150 url_set_interrupt_cb(decode_interrupt_cb
);
2154 timer_start
= av_gettime();
2156 for(; received_sigterm
== 0;) {
2157 int file_index
, ist_index
;
2165 /* if 'q' pressed, exits */
2169 /* read_key() returns 0 on EOF */
2175 /* select the stream that we must read now by looking at the
2176 smallest output pts */
2178 for(i
=0;i
<nb_ostreams
;i
++) {
2181 os
= output_files
[ost
->file_index
];
2182 ist
= ist_table
[ost
->source_index
];
2183 if(no_packet
[ist
->file_index
])
2185 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
)
2186 opts
= ost
->sync_opts
* av_q2d(ost
->st
->codec
->time_base
);
2188 opts
= ost
->st
->pts
.val
* av_q2d(ost
->st
->time_base
);
2189 ipts
= (double)ist
->pts
;
2190 if (!file_table
[ist
->file_index
].eof_reached
){
2191 if(ipts
< ipts_min
) {
2193 if(input_sync
) file_index
= ist
->file_index
;
2195 if(opts
< opts_min
) {
2197 if(!input_sync
) file_index
= ist
->file_index
;
2200 if(ost
->frame_number
>= max_frames
[ost
->st
->codec
->codec_type
]){
2205 /* if none, if is finished */
2206 if (file_index
< 0) {
2207 if(no_packet_count
){
2209 memset(no_packet
, 0, sizeof(no_packet
));
2216 /* finish if recording time exhausted */
2217 if (opts_min
>= (recording_time
/ 1000000.0))
2220 /* finish if limit size exhausted */
2221 if (limit_filesize
!= 0 && limit_filesize
< url_ftell(output_files
[0]->pb
))
2224 /* read a frame from it and output it in the fifo */
2225 is
= input_files
[file_index
];
2226 ret
= av_read_frame(is
, &pkt
);
2227 if(ret
== AVERROR(EAGAIN
)){
2228 no_packet
[file_index
]=1;
2233 file_table
[file_index
].eof_reached
= 1;
2241 memset(no_packet
, 0, sizeof(no_packet
));
2244 av_pkt_dump_log(NULL
, AV_LOG_DEBUG
, &pkt
, do_hex_dump
);
2246 /* the following test is needed in case new streams appear
2247 dynamically in stream : we ignore them */
2248 if (pkt
.stream_index
>= file_table
[file_index
].nb_streams
)
2249 goto discard_packet
;
2250 ist_index
= file_table
[file_index
].ist_index
+ pkt
.stream_index
;
2251 ist
= ist_table
[ist_index
];
2253 goto discard_packet
;
2255 if (pkt
.dts
!= AV_NOPTS_VALUE
)
2256 pkt
.dts
+= av_rescale_q(input_files_ts_offset
[ist
->file_index
], AV_TIME_BASE_Q
, ist
->st
->time_base
);
2257 if (pkt
.pts
!= AV_NOPTS_VALUE
)
2258 pkt
.pts
+= av_rescale_q(input_files_ts_offset
[ist
->file_index
], AV_TIME_BASE_Q
, ist
->st
->time_base
);
2260 if(input_files_ts_scale
[file_index
][pkt
.stream_index
]){
2261 if(pkt
.pts
!= AV_NOPTS_VALUE
)
2262 pkt
.pts
*= input_files_ts_scale
[file_index
][pkt
.stream_index
];
2263 if(pkt
.dts
!= AV_NOPTS_VALUE
)
2264 pkt
.dts
*= input_files_ts_scale
[file_index
][pkt
.stream_index
];
2267 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2268 if (pkt
.dts
!= AV_NOPTS_VALUE
&& ist
->next_pts
!= AV_NOPTS_VALUE
2269 && (is
->iformat
->flags
& AVFMT_TS_DISCONT
)) {
2270 int64_t pkt_dts
= av_rescale_q(pkt
.dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
2271 int64_t delta
= pkt_dts
- ist
->next_pts
;
2272 if((FFABS(delta
) > 1LL*dts_delta_threshold
*AV_TIME_BASE
|| pkt_dts
+1<ist
->pts
)&& !copy_ts
){
2273 input_files_ts_offset
[ist
->file_index
]-= delta
;
2275 fprintf(stderr
, "timestamp discontinuity %"PRId64
", new offset= %"PRId64
"\n", delta
, input_files_ts_offset
[ist
->file_index
]);
2276 pkt
.dts
-= av_rescale_q(delta
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
2277 if(pkt
.pts
!= AV_NOPTS_VALUE
)
2278 pkt
.pts
-= av_rescale_q(delta
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
2282 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2283 if (output_packet(ist
, ist_index
, ost_table
, nb_ostreams
, &pkt
) < 0) {
2286 fprintf(stderr
, "Error while decoding stream #%d.%d\n",
2287 ist
->file_index
, ist
->index
);
2290 av_free_packet(&pkt
);
2295 av_free_packet(&pkt
);
2297 /* dump report by using the output first video and audio streams */
2298 print_report(output_files
, ost_table
, nb_ostreams
, 0);
2301 /* at the end of stream, we must flush the decoder buffers */
2302 for(i
=0;i
<nb_istreams
;i
++) {
2304 if (ist
->decoding_needed
) {
2305 output_packet(ist
, i
, ost_table
, nb_ostreams
, NULL
);
2311 /* write the trailer if needed and close file */
2312 for(i
=0;i
<nb_output_files
;i
++) {
2313 os
= output_files
[i
];
2314 av_write_trailer(os
);
2317 /* dump report by using the first video and audio streams */
2318 print_report(output_files
, ost_table
, nb_ostreams
, 1);
2320 /* close each encoder */
2321 for(i
=0;i
<nb_ostreams
;i
++) {
2323 if (ost
->encoding_needed
) {
2324 av_freep(&ost
->st
->codec
->stats_in
);
2325 avcodec_close(ost
->st
->codec
);
2329 /* close each decoder */
2330 for(i
=0;i
<nb_istreams
;i
++) {
2332 if (ist
->decoding_needed
) {
2333 avcodec_close(ist
->st
->codec
);
2341 av_freep(&bit_buffer
);
2342 av_free(file_table
);
2345 for(i
=0;i
<nb_istreams
;i
++) {
2352 for(i
=0;i
<nb_ostreams
;i
++) {
2356 fclose(ost
->logfile
);
2357 ost
->logfile
= NULL
;
2359 av_fifo_free(ost
->fifo
); /* works even if fifo is not
2360 initialized but set to zero */
2361 av_free(ost
->pict_tmp
.data
[0]);
2362 if (ost
->video_resample
)
2363 sws_freeContext(ost
->img_resample_ctx
);
2365 audio_resample_close(ost
->resample
);
2366 if (ost
->reformat_ctx
)
2367 av_audio_convert_free(ost
->reformat_ctx
);
2376 static void opt_format(const char *arg
)
2378 /* compatibility stuff for pgmyuv */
2379 if (!strcmp(arg
, "pgmyuv")) {
2380 pgmyuv_compatibility_hack
=1;
2381 // opt_image_format(arg);
2383 fprintf(stderr
, "pgmyuv format is deprecated, use image2\n");
2386 last_asked_format
= arg
;
2389 static void opt_video_rc_override_string(const char *arg
)
2391 video_rc_override_string
= arg
;
2394 static int opt_me_threshold(const char *opt
, const char *arg
)
2396 me_threshold
= parse_number_or_die(opt
, arg
, OPT_INT64
, INT_MIN
, INT_MAX
);
2400 static int opt_verbose(const char *opt
, const char *arg
)
2402 verbose
= parse_number_or_die(opt
, arg
, OPT_INT64
, -10, 10);
2406 static int opt_frame_rate(const char *opt
, const char *arg
)
2408 if (av_parse_video_frame_rate(&frame_rate
, arg
) < 0) {
2409 fprintf(stderr
, "Incorrect value for %s: %s\n", opt
, arg
);
2415 static int opt_bitrate(const char *opt
, const char *arg
)
2417 int codec_type
= opt
[0]=='a' ? CODEC_TYPE_AUDIO
: CODEC_TYPE_VIDEO
;
2419 opt_default(opt
, arg
);
2421 if (av_get_int(avcodec_opts
[codec_type
], "b", NULL
) < 1000)
2422 fprintf(stderr
, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2427 static void opt_frame_crop_top(const char *arg
)
2429 frame_topBand
= atoi(arg
);
2430 if (frame_topBand
< 0) {
2431 fprintf(stderr
, "Incorrect top crop size\n");
2434 if ((frame_topBand
) >= frame_height
){
2435 fprintf(stderr
, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2438 frame_height
-= frame_topBand
;
2441 static void opt_frame_crop_bottom(const char *arg
)
2443 frame_bottomBand
= atoi(arg
);
2444 if (frame_bottomBand
< 0) {
2445 fprintf(stderr
, "Incorrect bottom crop size\n");
2448 if ((frame_bottomBand
) >= frame_height
){
2449 fprintf(stderr
, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2452 frame_height
-= frame_bottomBand
;
2455 static void opt_frame_crop_left(const char *arg
)
2457 frame_leftBand
= atoi(arg
);
2458 if (frame_leftBand
< 0) {
2459 fprintf(stderr
, "Incorrect left crop size\n");
2462 if ((frame_leftBand
) >= frame_width
){
2463 fprintf(stderr
, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2466 frame_width
-= frame_leftBand
;
2469 static void opt_frame_crop_right(const char *arg
)
2471 frame_rightBand
= atoi(arg
);
2472 if (frame_rightBand
< 0) {
2473 fprintf(stderr
, "Incorrect right crop size\n");
2476 if ((frame_rightBand
) >= frame_width
){
2477 fprintf(stderr
, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2480 frame_width
-= frame_rightBand
;
2483 static void opt_frame_size(const char *arg
)
2485 if (av_parse_video_frame_size(&frame_width
, &frame_height
, arg
) < 0) {
2486 fprintf(stderr
, "Incorrect frame size\n");
2489 if ((frame_width
% 2) != 0 || (frame_height
% 2) != 0) {
2490 fprintf(stderr
, "Frame size must be a multiple of 2\n");
2495 static void opt_pad_color(const char *arg
) {
2496 /* Input is expected to be six hex digits similar to
2497 how colors are expressed in html tags (but without the #) */
2498 int rgb
= strtol(arg
, NULL
, 16);
2502 g
= ((rgb
>> 8) & 255);
2505 padcolor
[0] = RGB_TO_Y(r
,g
,b
);
2506 padcolor
[1] = RGB_TO_U(r
,g
,b
,0);
2507 padcolor
[2] = RGB_TO_V(r
,g
,b
,0);
2510 static void opt_frame_pad_top(const char *arg
)
2512 frame_padtop
= atoi(arg
);
2513 if (frame_padtop
< 0) {
2514 fprintf(stderr
, "Incorrect top pad size\n");
2519 static void opt_frame_pad_bottom(const char *arg
)
2521 frame_padbottom
= atoi(arg
);
2522 if (frame_padbottom
< 0) {
2523 fprintf(stderr
, "Incorrect bottom pad size\n");
2529 static void opt_frame_pad_left(const char *arg
)
2531 frame_padleft
= atoi(arg
);
2532 if (frame_padleft
< 0) {
2533 fprintf(stderr
, "Incorrect left pad size\n");
2539 static void opt_frame_pad_right(const char *arg
)
2541 frame_padright
= atoi(arg
);
2542 if (frame_padright
< 0) {
2543 fprintf(stderr
, "Incorrect right pad size\n");
2548 static void list_fmts(void (*get_fmt_string
)(char *buf
, int buf_size
, int fmt
), int nb_fmts
)
2552 for (i
=-1; i
< nb_fmts
; i
++) {
2553 get_fmt_string (fmt_str
, sizeof(fmt_str
), i
);
2554 fprintf(stdout
, "%s\n", fmt_str
);
2558 static void opt_frame_pix_fmt(const char *arg
)
2560 if (strcmp(arg
, "list")) {
2561 frame_pix_fmt
= avcodec_get_pix_fmt(arg
);
2562 if (frame_pix_fmt
== PIX_FMT_NONE
) {
2563 fprintf(stderr
, "Unknown pixel format requested: %s\n", arg
);
2567 list_fmts(avcodec_pix_fmt_string
, PIX_FMT_NB
);
2572 static void opt_frame_aspect_ratio(const char *arg
)
2579 p
= strchr(arg
, ':');
2581 x
= strtol(arg
, &end
, 10);
2583 y
= strtol(end
+1, &end
, 10);
2585 ar
= (double)x
/ (double)y
;
2587 ar
= strtod(arg
, NULL
);
2590 fprintf(stderr
, "Incorrect aspect ratio specification.\n");
2593 frame_aspect_ratio
= ar
;
2596 static int opt_metadata(const char *opt
, const char *arg
)
2598 char *mid
= strchr(arg
, '=');
2601 fprintf(stderr
, "Missing =\n");
2607 metadata
= av_realloc(metadata
, sizeof(*metadata
)*metadata_count
);
2608 metadata
[metadata_count
-1].key
= av_strdup(arg
);
2609 metadata
[metadata_count
-1].value
= av_strdup(mid
);
2614 static void opt_qscale(const char *arg
)
2616 video_qscale
= atof(arg
);
2617 if (video_qscale
<= 0 ||
2618 video_qscale
> 255) {
2619 fprintf(stderr
, "qscale must be > 0.0 and <= 255\n");
2624 static void opt_top_field_first(const char *arg
)
2626 top_field_first
= atoi(arg
);
2629 static int opt_thread_count(const char *opt
, const char *arg
)
2631 thread_count
= parse_number_or_die(opt
, arg
, OPT_INT64
, 0, INT_MAX
);
2634 fprintf(stderr
, "Warning: not compiled with thread support, using thread emulation\n");
2639 static void opt_audio_sample_fmt(const char *arg
)
2641 if (strcmp(arg
, "list"))
2642 audio_sample_fmt
= avcodec_get_sample_fmt(arg
);
2644 list_fmts(avcodec_sample_fmt_string
, SAMPLE_FMT_NB
);
2649 static int opt_audio_rate(const char *opt
, const char *arg
)
2651 audio_sample_rate
= parse_number_or_die(opt
, arg
, OPT_INT64
, 0, INT_MAX
);
2655 static int opt_audio_channels(const char *opt
, const char *arg
)
2657 audio_channels
= parse_number_or_die(opt
, arg
, OPT_INT64
, 0, INT_MAX
);
2661 static void opt_video_channel(const char *arg
)
2663 video_channel
= strtol(arg
, NULL
, 0);
2666 static void opt_video_standard(const char *arg
)
2668 video_standard
= av_strdup(arg
);
2671 static void opt_codec(int *pstream_copy
, char **pcodec_name
,
2672 int codec_type
, const char *arg
)
2674 av_freep(pcodec_name
);
2675 if (!strcmp(arg
, "copy")) {
2678 *pcodec_name
= av_strdup(arg
);
2682 static void opt_audio_codec(const char *arg
)
2684 opt_codec(&audio_stream_copy
, &audio_codec_name
, CODEC_TYPE_AUDIO
, arg
);
2687 static void opt_audio_tag(const char *arg
)
2690 audio_codec_tag
= strtol(arg
, &tail
, 0);
2693 audio_codec_tag
= arg
[0] + (arg
[1]<<8) + (arg
[2]<<16) + (arg
[3]<<24);
2696 static void opt_video_tag(const char *arg
)
2699 video_codec_tag
= strtol(arg
, &tail
, 0);
2702 video_codec_tag
= arg
[0] + (arg
[1]<<8) + (arg
[2]<<16) + (arg
[3]<<24);
2705 static void opt_video_codec(const char *arg
)
2707 opt_codec(&video_stream_copy
, &video_codec_name
, CODEC_TYPE_VIDEO
, arg
);
2710 static void opt_subtitle_codec(const char *arg
)
2712 opt_codec(&subtitle_stream_copy
, &subtitle_codec_name
, CODEC_TYPE_SUBTITLE
, arg
);
2715 static void opt_subtitle_tag(const char *arg
)
2718 subtitle_codec_tag
= strtol(arg
, &tail
, 0);
2721 subtitle_codec_tag
= arg
[0] + (arg
[1]<<8) + (arg
[2]<<16) + (arg
[3]<<24);
2724 static void opt_map(const char *arg
)
2729 m
= &stream_maps
[nb_stream_maps
++];
2731 m
->file_index
= strtol(arg
, &p
, 0);
2735 m
->stream_index
= strtol(p
, &p
, 0);
2738 m
->sync_file_index
= strtol(p
, &p
, 0);
2741 m
->sync_stream_index
= strtol(p
, &p
, 0);
2743 m
->sync_file_index
= m
->file_index
;
2744 m
->sync_stream_index
= m
->stream_index
;
2748 static void opt_map_meta_data(const char *arg
)
2753 m
= &meta_data_maps
[nb_meta_data_maps
++];
2755 m
->out_file
= strtol(arg
, &p
, 0);
2759 m
->in_file
= strtol(p
, &p
, 0);
2762 static void opt_input_ts_scale(const char *arg
)
2764 unsigned int stream
;
2768 stream
= strtol(arg
, &p
, 0);
2771 scale
= strtod(p
, &p
);
2773 if(stream
>= MAX_STREAMS
)
2776 input_files_ts_scale
[nb_input_files
][stream
]= scale
;
2779 static int opt_recording_time(const char *opt
, const char *arg
)
2781 recording_time
= parse_time_or_die(opt
, arg
, 1);
2785 static int opt_start_time(const char *opt
, const char *arg
)
2787 start_time
= parse_time_or_die(opt
, arg
, 1);
2791 static int opt_rec_timestamp(const char *opt
, const char *arg
)
2793 rec_timestamp
= parse_time_or_die(opt
, arg
, 0) / 1000000;
2797 static int opt_input_ts_offset(const char *opt
, const char *arg
)
2799 input_ts_offset
= parse_time_or_die(opt
, arg
, 1);
2803 static enum CodecID
find_codec_or_die(const char *name
, int type
, int encoder
)
2805 const char *codec_string
= encoder
? "encoder" : "decoder";
2809 return CODEC_ID_NONE
;
2811 avcodec_find_encoder_by_name(name
) :
2812 avcodec_find_decoder_by_name(name
);
2814 fprintf(stderr
, "Unknown %s '%s'\n", codec_string
, name
);
2817 if(codec
->type
!= type
) {
2818 fprintf(stderr
, "Invalid %s type '%s'\n", codec_string
, name
);
2824 static void opt_input_file(const char *filename
)
2826 AVFormatContext
*ic
;
2827 AVFormatParameters params
, *ap
= ¶ms
;
2828 AVInputFormat
*file_iformat
= NULL
;
2829 int err
, i
, ret
, rfps
, rfps_base
;
2832 if (last_asked_format
) {
2833 file_iformat
= av_find_input_format(last_asked_format
);
2834 last_asked_format
= NULL
;
2837 if (!strcmp(filename
, "-"))
2840 using_stdin
|= !strncmp(filename
, "pipe:", 5) ||
2841 !strcmp(filename
, "/dev/stdin");
2843 /* get default parameters from command line */
2844 ic
= avformat_alloc_context();
2846 print_error(filename
, AVERROR(ENOMEM
));
2850 memset(ap
, 0, sizeof(*ap
));
2851 ap
->prealloced_context
= 1;
2852 ap
->sample_rate
= audio_sample_rate
;
2853 ap
->channels
= audio_channels
;
2854 ap
->time_base
.den
= frame_rate
.num
;
2855 ap
->time_base
.num
= frame_rate
.den
;
2856 ap
->width
= frame_width
+ frame_padleft
+ frame_padright
;
2857 ap
->height
= frame_height
+ frame_padtop
+ frame_padbottom
;
2858 ap
->pix_fmt
= frame_pix_fmt
;
2859 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2860 ap
->channel
= video_channel
;
2861 ap
->standard
= video_standard
;
2862 ap
->video_codec_id
= find_codec_or_die(video_codec_name
, CODEC_TYPE_VIDEO
, 0);
2863 ap
->audio_codec_id
= find_codec_or_die(audio_codec_name
, CODEC_TYPE_AUDIO
, 0);
2864 if(pgmyuv_compatibility_hack
)
2865 ap
->video_codec_id
= CODEC_ID_PGMYUV
;
2867 set_context_opts(ic
, avformat_opts
, AV_OPT_FLAG_DECODING_PARAM
);
2869 ic
->video_codec_id
= find_codec_or_die(video_codec_name
, CODEC_TYPE_VIDEO
, 0);
2870 ic
->audio_codec_id
= find_codec_or_die(audio_codec_name
, CODEC_TYPE_AUDIO
, 0);
2871 ic
->subtitle_codec_id
= find_codec_or_die(subtitle_codec_name
, CODEC_TYPE_SUBTITLE
, 0);
2872 ic
->flags
|= AVFMT_FLAG_NONBLOCK
;
2874 /* open the input file with generic libav function */
2875 err
= av_open_input_file(&ic
, filename
, file_iformat
, 0, ap
);
2877 print_error(filename
, err
);
2882 for(i
=0; i
<ic
->nb_programs
; i
++)
2883 if(ic
->programs
[i
]->id
!= opt_programid
)
2884 ic
->programs
[i
]->discard
= AVDISCARD_ALL
;
2887 ic
->loop_input
= loop_input
;
2889 /* If not enough info to get the stream parameters, we decode the
2890 first frames to get it. (used in mpeg case for example) */
2891 ret
= av_find_stream_info(ic
);
2892 if (ret
< 0 && verbose
>= 0) {
2893 fprintf(stderr
, "%s: could not find codec parameters\n", filename
);
2897 timestamp
= start_time
;
2898 /* add the stream start time */
2899 if (ic
->start_time
!= AV_NOPTS_VALUE
)
2900 timestamp
+= ic
->start_time
;
2902 /* if seeking requested, we execute it */
2903 if (start_time
!= 0) {
2904 ret
= av_seek_frame(ic
, -1, timestamp
, AVSEEK_FLAG_BACKWARD
);
2906 fprintf(stderr
, "%s: could not seek to position %0.3f\n",
2907 filename
, (double)timestamp
/ AV_TIME_BASE
);
2909 /* reset seek info */
2913 /* update the current parameters so that they match the one of the input stream */
2914 for(i
=0;i
<ic
->nb_streams
;i
++) {
2915 AVCodecContext
*enc
= ic
->streams
[i
]->codec
;
2917 avcodec_thread_init(enc
, thread_count
);
2918 enc
->thread_count
= thread_count
;
2919 switch(enc
->codec_type
) {
2920 case CODEC_TYPE_AUDIO
:
2921 set_context_opts(enc
, avcodec_opts
[CODEC_TYPE_AUDIO
], AV_OPT_FLAG_AUDIO_PARAM
| AV_OPT_FLAG_DECODING_PARAM
);
2922 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2923 channel_layout
= enc
->channel_layout
;
2924 audio_channels
= enc
->channels
;
2925 audio_sample_rate
= enc
->sample_rate
;
2926 audio_sample_fmt
= enc
->sample_fmt
;
2927 input_codecs
[nb_icodecs
++] = avcodec_find_decoder_by_name(audio_codec_name
);
2929 ic
->streams
[i
]->discard
= AVDISCARD_ALL
;
2931 case CODEC_TYPE_VIDEO
:
2932 set_context_opts(enc
, avcodec_opts
[CODEC_TYPE_VIDEO
], AV_OPT_FLAG_VIDEO_PARAM
| AV_OPT_FLAG_DECODING_PARAM
);
2933 frame_height
= enc
->height
;
2934 frame_width
= enc
->width
;
2935 if(ic
->streams
[i
]->sample_aspect_ratio
.num
)
2936 frame_aspect_ratio
=av_q2d(ic
->streams
[i
]->sample_aspect_ratio
);
2938 frame_aspect_ratio
=av_q2d(enc
->sample_aspect_ratio
);
2939 frame_aspect_ratio
*= (float) enc
->width
/ enc
->height
;
2940 frame_pix_fmt
= enc
->pix_fmt
;
2941 rfps
= ic
->streams
[i
]->r_frame_rate
.num
;
2942 rfps_base
= ic
->streams
[i
]->r_frame_rate
.den
;
2943 if(enc
->lowres
) enc
->flags
|= CODEC_FLAG_EMU_EDGE
;
2945 enc
->debug
|= FF_DEBUG_MV
;
2947 if (enc
->time_base
.den
!= rfps
|| enc
->time_base
.num
!= rfps_base
) {
2950 fprintf(stderr
,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2951 i
, (float)enc
->time_base
.den
/ enc
->time_base
.num
, enc
->time_base
.den
, enc
->time_base
.num
,
2953 (float)rfps
/ rfps_base
, rfps
, rfps_base
);
2955 /* update the current frame rate to match the stream frame rate */
2956 frame_rate
.num
= rfps
;
2957 frame_rate
.den
= rfps_base
;
2959 input_codecs
[nb_icodecs
++] = avcodec_find_decoder_by_name(video_codec_name
);
2961 ic
->streams
[i
]->discard
= AVDISCARD_ALL
;
2962 else if(video_discard
)
2963 ic
->streams
[i
]->discard
= video_discard
;
2965 case CODEC_TYPE_DATA
:
2967 case CODEC_TYPE_SUBTITLE
:
2968 input_codecs
[nb_icodecs
++] = avcodec_find_decoder_by_name(subtitle_codec_name
);
2969 if(subtitle_disable
)
2970 ic
->streams
[i
]->discard
= AVDISCARD_ALL
;
2972 case CODEC_TYPE_ATTACHMENT
:
2973 case CODEC_TYPE_UNKNOWN
:
2981 input_files
[nb_input_files
] = ic
;
2982 input_files_ts_offset
[nb_input_files
] = input_ts_offset
- (copy_ts
? 0 : timestamp
);
2983 /* dump the file content */
2985 dump_format(ic
, nb_input_files
, filename
, 0);
2991 av_freep(&video_codec_name
);
2992 av_freep(&audio_codec_name
);
2993 av_freep(&subtitle_codec_name
);
2996 static void check_audio_video_sub_inputs(int *has_video_ptr
, int *has_audio_ptr
,
2997 int *has_subtitle_ptr
)
2999 int has_video
, has_audio
, has_subtitle
, i
, j
;
3000 AVFormatContext
*ic
;
3005 for(j
=0;j
<nb_input_files
;j
++) {
3006 ic
= input_files
[j
];
3007 for(i
=0;i
<ic
->nb_streams
;i
++) {
3008 AVCodecContext
*enc
= ic
->streams
[i
]->codec
;
3009 switch(enc
->codec_type
) {
3010 case CODEC_TYPE_AUDIO
:
3013 case CODEC_TYPE_VIDEO
:
3016 case CODEC_TYPE_SUBTITLE
:
3019 case CODEC_TYPE_DATA
:
3020 case CODEC_TYPE_ATTACHMENT
:
3021 case CODEC_TYPE_UNKNOWN
:
3028 *has_video_ptr
= has_video
;
3029 *has_audio_ptr
= has_audio
;
3030 *has_subtitle_ptr
= has_subtitle
;
3033 static void new_video_stream(AVFormatContext
*oc
)
3036 AVCodecContext
*video_enc
;
3037 enum CodecID codec_id
;
3039 st
= av_new_stream(oc
, oc
->nb_streams
);
3041 fprintf(stderr
, "Could not alloc stream\n");
3044 avcodec_get_context_defaults2(st
->codec
, CODEC_TYPE_VIDEO
);
3045 bitstream_filters
[nb_output_files
][oc
->nb_streams
- 1]= video_bitstream_filters
;
3046 video_bitstream_filters
= NULL
;
3049 avcodec_thread_init(st
->codec
, thread_count
);
3051 video_enc
= st
->codec
;
3054 video_enc
->codec_tag
= video_codec_tag
;
3056 if( (video_global_header
&1)
3057 || (video_global_header
==0 && (oc
->oformat
->flags
& AVFMT_GLOBALHEADER
))){
3058 video_enc
->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
3059 avcodec_opts
[CODEC_TYPE_VIDEO
]->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
3061 if(video_global_header
&2){
3062 video_enc
->flags2
|= CODEC_FLAG2_LOCAL_HEADER
;
3063 avcodec_opts
[CODEC_TYPE_VIDEO
]->flags2
|= CODEC_FLAG2_LOCAL_HEADER
;
3066 if (video_stream_copy
) {
3067 st
->stream_copy
= 1;
3068 video_enc
->codec_type
= CODEC_TYPE_VIDEO
;
3069 video_enc
->sample_aspect_ratio
=
3070 st
->sample_aspect_ratio
= av_d2q(frame_aspect_ratio
*frame_height
/frame_width
, 255);
3075 AVRational fps
= frame_rate
.num
? frame_rate
: (AVRational
){25,1};
3077 if (video_codec_name
) {
3078 codec_id
= find_codec_or_die(video_codec_name
, CODEC_TYPE_VIDEO
, 1);
3079 codec
= avcodec_find_encoder_by_name(video_codec_name
);
3080 output_codecs
[nb_ocodecs
] = codec
;
3082 codec_id
= av_guess_codec(oc
->oformat
, NULL
, oc
->filename
, NULL
, CODEC_TYPE_VIDEO
);
3083 codec
= avcodec_find_encoder(codec_id
);
3086 video_enc
->codec_id
= codec_id
;
3088 set_context_opts(video_enc
, avcodec_opts
[CODEC_TYPE_VIDEO
], AV_OPT_FLAG_VIDEO_PARAM
| AV_OPT_FLAG_ENCODING_PARAM
);
3090 if (codec
&& codec
->supported_framerates
&& !force_fps
)
3091 fps
= codec
->supported_framerates
[av_find_nearest_q_idx(fps
, codec
->supported_framerates
)];
3092 video_enc
->time_base
.den
= fps
.num
;
3093 video_enc
->time_base
.num
= fps
.den
;
3095 video_enc
->width
= frame_width
+ frame_padright
+ frame_padleft
;
3096 video_enc
->height
= frame_height
+ frame_padtop
+ frame_padbottom
;
3097 video_enc
->sample_aspect_ratio
= av_d2q(frame_aspect_ratio
*video_enc
->height
/video_enc
->width
, 255);
3098 video_enc
->pix_fmt
= frame_pix_fmt
;
3099 st
->sample_aspect_ratio
= video_enc
->sample_aspect_ratio
;
3101 if(codec
&& codec
->pix_fmts
){
3102 const enum PixelFormat
*p
= codec
->pix_fmts
;
3104 if(*p
== video_enc
->pix_fmt
)
3108 video_enc
->pix_fmt
= codec
->pix_fmts
[0];
3112 video_enc
->gop_size
= 0;
3113 if (video_qscale
|| same_quality
) {
3114 video_enc
->flags
|= CODEC_FLAG_QSCALE
;
3115 video_enc
->global_quality
=
3116 st
->quality
= FF_QP2LAMBDA
* video_qscale
;
3120 video_enc
->intra_matrix
= intra_matrix
;
3122 video_enc
->inter_matrix
= inter_matrix
;
3124 video_enc
->thread_count
= thread_count
;
3125 p
= video_rc_override_string
;
3128 int e
=sscanf(p
, "%d,%d,%d", &start
, &end
, &q
);
3130 fprintf(stderr
, "error parsing rc_override\n");
3133 video_enc
->rc_override
=
3134 av_realloc(video_enc
->rc_override
,
3135 sizeof(RcOverride
)*(i
+1));
3136 video_enc
->rc_override
[i
].start_frame
= start
;
3137 video_enc
->rc_override
[i
].end_frame
= end
;
3139 video_enc
->rc_override
[i
].qscale
= q
;
3140 video_enc
->rc_override
[i
].quality_factor
= 1.0;
3143 video_enc
->rc_override
[i
].qscale
= 0;
3144 video_enc
->rc_override
[i
].quality_factor
= -q
/100.0;
3149 video_enc
->rc_override_count
=i
;
3150 if (!video_enc
->rc_initial_buffer_occupancy
)
3151 video_enc
->rc_initial_buffer_occupancy
= video_enc
->rc_buffer_size
*3/4;
3152 video_enc
->me_threshold
= me_threshold
;
3153 video_enc
->intra_dc_precision
= intra_dc_precision
- 8;
3156 video_enc
->flags
|= CODEC_FLAG_PSNR
;
3161 video_enc
->flags
|= CODEC_FLAG_PASS1
;
3163 video_enc
->flags
|= CODEC_FLAG_PASS2
;
3169 /* reset some key parameters */
3171 av_freep(&video_codec_name
);
3172 video_stream_copy
= 0;
3175 static void new_audio_stream(AVFormatContext
*oc
)
3178 AVCodecContext
*audio_enc
;
3179 enum CodecID codec_id
;
3181 st
= av_new_stream(oc
, oc
->nb_streams
);
3183 fprintf(stderr
, "Could not alloc stream\n");
3186 avcodec_get_context_defaults2(st
->codec
, CODEC_TYPE_AUDIO
);
3188 bitstream_filters
[nb_output_files
][oc
->nb_streams
- 1]= audio_bitstream_filters
;
3189 audio_bitstream_filters
= NULL
;
3192 avcodec_thread_init(st
->codec
, thread_count
);
3194 audio_enc
= st
->codec
;
3195 audio_enc
->codec_type
= CODEC_TYPE_AUDIO
;
3198 audio_enc
->codec_tag
= audio_codec_tag
;
3200 if (oc
->oformat
->flags
& AVFMT_GLOBALHEADER
) {
3201 audio_enc
->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
3202 avcodec_opts
[CODEC_TYPE_AUDIO
]->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
3204 if (audio_stream_copy
) {
3205 st
->stream_copy
= 1;
3206 audio_enc
->channels
= audio_channels
;
3210 set_context_opts(audio_enc
, avcodec_opts
[CODEC_TYPE_AUDIO
], AV_OPT_FLAG_AUDIO_PARAM
| AV_OPT_FLAG_ENCODING_PARAM
);
3212 if (audio_codec_name
) {
3213 codec_id
= find_codec_or_die(audio_codec_name
, CODEC_TYPE_AUDIO
, 1);
3214 codec
= avcodec_find_encoder_by_name(audio_codec_name
);
3215 output_codecs
[nb_ocodecs
] = codec
;
3217 codec_id
= av_guess_codec(oc
->oformat
, NULL
, oc
->filename
, NULL
, CODEC_TYPE_AUDIO
);
3218 codec
= avcodec_find_encoder(codec_id
);
3220 audio_enc
->codec_id
= codec_id
;
3222 if (audio_qscale
> QSCALE_NONE
) {
3223 audio_enc
->flags
|= CODEC_FLAG_QSCALE
;
3224 audio_enc
->global_quality
= st
->quality
= FF_QP2LAMBDA
* audio_qscale
;
3226 audio_enc
->thread_count
= thread_count
;
3227 audio_enc
->channels
= audio_channels
;
3228 audio_enc
->sample_fmt
= audio_sample_fmt
;
3229 audio_enc
->channel_layout
= channel_layout
;
3230 if (avcodec_channel_layout_num_channels(channel_layout
) != audio_channels
)
3231 audio_enc
->channel_layout
= 0;
3233 if(codec
&& codec
->sample_fmts
){
3234 const enum SampleFormat
*p
= codec
->sample_fmts
;
3236 if(*p
== audio_enc
->sample_fmt
)
3240 audio_enc
->sample_fmt
= codec
->sample_fmts
[0];
3244 audio_enc
->sample_rate
= audio_sample_rate
;
3245 audio_enc
->time_base
= (AVRational
){1, audio_sample_rate
};
3246 if (audio_language
) {
3247 av_metadata_set(&st
->metadata
, "language", audio_language
);
3248 av_free(audio_language
);
3249 audio_language
= NULL
;
3252 /* reset some key parameters */
3254 av_freep(&audio_codec_name
);
3255 audio_stream_copy
= 0;
3258 static void new_subtitle_stream(AVFormatContext
*oc
)
3261 AVCodecContext
*subtitle_enc
;
3263 st
= av_new_stream(oc
, oc
->nb_streams
);
3265 fprintf(stderr
, "Could not alloc stream\n");
3268 avcodec_get_context_defaults2(st
->codec
, CODEC_TYPE_SUBTITLE
);
3270 bitstream_filters
[nb_output_files
][oc
->nb_streams
- 1]= subtitle_bitstream_filters
;
3271 subtitle_bitstream_filters
= NULL
;
3273 subtitle_enc
= st
->codec
;
3274 subtitle_enc
->codec_type
= CODEC_TYPE_SUBTITLE
;
3276 if(subtitle_codec_tag
)
3277 subtitle_enc
->codec_tag
= subtitle_codec_tag
;
3279 if (subtitle_stream_copy
) {
3280 st
->stream_copy
= 1;
3282 set_context_opts(avcodec_opts
[CODEC_TYPE_SUBTITLE
], subtitle_enc
, AV_OPT_FLAG_SUBTITLE_PARAM
| AV_OPT_FLAG_ENCODING_PARAM
);
3283 subtitle_enc
->codec_id
= find_codec_or_die(subtitle_codec_name
, CODEC_TYPE_SUBTITLE
, 1);
3284 output_codecs
[nb_ocodecs
] = avcodec_find_encoder_by_name(subtitle_codec_name
);
3288 if (subtitle_language
) {
3289 av_metadata_set(&st
->metadata
, "language", subtitle_language
);
3290 av_free(subtitle_language
);
3291 subtitle_language
= NULL
;
3294 subtitle_disable
= 0;
3295 av_freep(&subtitle_codec_name
);
3296 subtitle_stream_copy
= 0;
3299 static void opt_new_audio_stream(void)
3301 AVFormatContext
*oc
;
3302 if (nb_output_files
<= 0) {
3303 fprintf(stderr
, "At least one output file must be specified\n");
3306 oc
= output_files
[nb_output_files
- 1];
3307 new_audio_stream(oc
);
3310 static void opt_new_video_stream(void)
3312 AVFormatContext
*oc
;
3313 if (nb_output_files
<= 0) {
3314 fprintf(stderr
, "At least one output file must be specified\n");
3317 oc
= output_files
[nb_output_files
- 1];
3318 new_video_stream(oc
);
3321 static void opt_new_subtitle_stream(void)
3323 AVFormatContext
*oc
;
3324 if (nb_output_files
<= 0) {
3325 fprintf(stderr
, "At least one output file must be specified\n");
3328 oc
= output_files
[nb_output_files
- 1];
3329 new_subtitle_stream(oc
);
3332 static void opt_output_file(const char *filename
)
3334 AVFormatContext
*oc
;
3335 int use_video
, use_audio
, use_subtitle
;
3336 int input_has_video
, input_has_audio
, input_has_subtitle
;
3337 AVFormatParameters params
, *ap
= ¶ms
;
3338 AVOutputFormat
*file_oformat
;
3340 if (!strcmp(filename
, "-"))
3343 oc
= avformat_alloc_context();
3345 print_error(filename
, AVERROR(ENOMEM
));
3349 if (last_asked_format
) {
3350 file_oformat
= guess_format(last_asked_format
, NULL
, NULL
);
3351 if (!file_oformat
) {
3352 fprintf(stderr
, "Requested output format '%s' is not a suitable output format\n", last_asked_format
);
3355 last_asked_format
= NULL
;
3357 file_oformat
= guess_format(NULL
, filename
, NULL
);
3358 if (!file_oformat
) {
3359 fprintf(stderr
, "Unable to find a suitable output format for '%s'\n",
3365 oc
->oformat
= file_oformat
;
3366 av_strlcpy(oc
->filename
, filename
, sizeof(oc
->filename
));
3368 if (!strcmp(file_oformat
->name
, "ffm") &&
3369 av_strstart(filename
, "http:", NULL
)) {
3370 /* special case for files sent to ffserver: we get the stream
3371 parameters from ffserver */
3372 int err
= read_ffserver_streams(oc
, filename
);
3374 print_error(filename
, err
);
3378 use_video
= file_oformat
->video_codec
!= CODEC_ID_NONE
|| video_stream_copy
|| video_codec_name
;
3379 use_audio
= file_oformat
->audio_codec
!= CODEC_ID_NONE
|| audio_stream_copy
|| audio_codec_name
;
3380 use_subtitle
= file_oformat
->subtitle_codec
!= CODEC_ID_NONE
|| subtitle_stream_copy
|| subtitle_codec_name
;
3382 /* disable if no corresponding type found and at least one
3384 if (nb_input_files
> 0) {
3385 check_audio_video_sub_inputs(&input_has_video
, &input_has_audio
,
3386 &input_has_subtitle
);
3387 if (!input_has_video
)
3389 if (!input_has_audio
)
3391 if (!input_has_subtitle
)
3395 /* manual disable */
3396 if (audio_disable
) {
3399 if (video_disable
) {
3402 if (subtitle_disable
) {
3407 new_video_stream(oc
);
3411 new_audio_stream(oc
);
3415 new_subtitle_stream(oc
);
3418 oc
->timestamp
= rec_timestamp
;
3420 for(; metadata_count
>0; metadata_count
--){
3421 av_metadata_set(&oc
->metadata
, metadata
[metadata_count
-1].key
,
3422 metadata
[metadata_count
-1].value
);
3424 av_metadata_conv(oc
, oc
->oformat
->metadata_conv
, NULL
);
3427 output_files
[nb_output_files
++] = oc
;
3429 /* check filename in case of an image number is expected */
3430 if (oc
->oformat
->flags
& AVFMT_NEEDNUMBER
) {
3431 if (!av_filename_number_test(oc
->filename
)) {
3432 print_error(oc
->filename
, AVERROR_NUMEXPECTED
);
3437 if (!(oc
->oformat
->flags
& AVFMT_NOFILE
)) {
3438 /* test if it already exists to avoid loosing precious files */
3439 if (!file_overwrite
&&
3440 (strchr(filename
, ':') == NULL
||
3441 filename
[1] == ':' ||
3442 av_strstart(filename
, "file:", NULL
))) {
3443 if (url_exist(filename
)) {
3445 fprintf(stderr
,"File '%s' already exists. Overwrite ? [y/N] ", filename
);
3447 if (!read_yesno()) {
3448 fprintf(stderr
, "Not overwriting - exiting\n");
3453 fprintf(stderr
,"File '%s' already exists. Exiting.\n", filename
);
3460 if (url_fopen(&oc
->pb
, filename
, URL_WRONLY
) < 0) {
3461 fprintf(stderr
, "Could not open '%s'\n", filename
);
3466 memset(ap
, 0, sizeof(*ap
));
3467 if (av_set_parameters(oc
, ap
) < 0) {
3468 fprintf(stderr
, "%s: Invalid encoding parameters\n",
3473 oc
->preload
= (int)(mux_preload
*AV_TIME_BASE
);
3474 oc
->max_delay
= (int)(mux_max_delay
*AV_TIME_BASE
);
3475 oc
->loop_output
= loop_output
;
3476 oc
->flags
|= AVFMT_FLAG_NONBLOCK
;
3478 set_context_opts(oc
, avformat_opts
, AV_OPT_FLAG_ENCODING_PARAM
);
3481 /* same option as mencoder */
3482 static void opt_pass(const char *pass_str
)
3485 pass
= atoi(pass_str
);
3486 if (pass
!= 1 && pass
!= 2) {
3487 fprintf(stderr
, "pass number can be only 1 or 2\n");
3493 static int64_t getutime(void)
3496 struct rusage rusage
;
3498 getrusage(RUSAGE_SELF
, &rusage
);
3499 return (rusage
.ru_utime
.tv_sec
* 1000000LL) + rusage
.ru_utime
.tv_usec
;
3500 #elif HAVE_GETPROCESSTIMES
3502 FILETIME c
, e
, k
, u
;
3503 proc
= GetCurrentProcess();
3504 GetProcessTimes(proc
, &c
, &e
, &k
, &u
);
3505 return ((int64_t) u
.dwHighDateTime
<< 32 | u
.dwLowDateTime
) / 10;
3507 return av_gettime();
3511 static void parse_matrix_coeffs(uint16_t *dest
, const char *str
)
3514 const char *p
= str
;
3521 fprintf(stderr
, "Syntax error in matrix \"%s\" at coeff %d\n", str
, i
);
3528 static void opt_inter_matrix(const char *arg
)
3530 inter_matrix
= av_mallocz(sizeof(uint16_t) * 64);
3531 parse_matrix_coeffs(inter_matrix
, arg
);
3534 static void opt_intra_matrix(const char *arg
)
3536 intra_matrix
= av_mallocz(sizeof(uint16_t) * 64);
3537 parse_matrix_coeffs(intra_matrix
, arg
);
3541 * Trivial log callback.
3542 * Only suitable for show_help and similar since it lacks prefix handling.
3544 static void log_callback_help(void* ptr
, int level
, const char* fmt
, va_list vl
)
3546 vfprintf(stdout
, fmt
, vl
);
3549 static void show_help(void)
3551 av_log_set_callback(log_callback_help
);
3552 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3553 "Hyper fast Audio and Video encoder\n");
3555 show_help_options(options
, "Main options:\n",
3556 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_SUBTITLE
| OPT_GRAB
, 0);
3557 show_help_options(options
, "\nAdvanced options:\n",
3558 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_SUBTITLE
| OPT_GRAB
,
3560 show_help_options(options
, "\nVideo options:\n",
3561 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_GRAB
,
3563 show_help_options(options
, "\nAdvanced Video options:\n",
3564 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_GRAB
,
3565 OPT_VIDEO
| OPT_EXPERT
);
3566 show_help_options(options
, "\nAudio options:\n",
3567 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_GRAB
,
3569 show_help_options(options
, "\nAdvanced Audio options:\n",
3570 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_GRAB
,
3571 OPT_AUDIO
| OPT_EXPERT
);
3572 show_help_options(options
, "\nSubtitle options:\n",
3573 OPT_SUBTITLE
| OPT_GRAB
,
3575 show_help_options(options
, "\nAudio/Video grab options:\n",
3579 av_opt_show(avcodec_opts
[0], NULL
);
3581 av_opt_show(avformat_opts
, NULL
);
3583 av_opt_show(sws_opts
, NULL
);
3586 static void opt_target(const char *arg
)
3589 static const char *const frame_rates
[] = {"25", "30000/1001", "24000/1001"};
3591 if(!strncmp(arg
, "pal-", 4)) {
3594 } else if(!strncmp(arg
, "ntsc-", 5)) {
3597 } else if(!strncmp(arg
, "film-", 5)) {
3602 /* Calculate FR via float to avoid int overflow */
3603 fr
= (int)(frame_rate
.num
* 1000.0 / frame_rate
.den
);
3606 } else if((fr
== 29970) || (fr
== 23976)) {
3609 /* Try to determine PAL/NTSC by peeking in the input files */
3610 if(nb_input_files
) {
3612 for(j
= 0; j
< nb_input_files
; j
++) {
3613 for(i
= 0; i
< input_files
[j
]->nb_streams
; i
++) {
3614 AVCodecContext
*c
= input_files
[j
]->streams
[i
]->codec
;
3615 if(c
->codec_type
!= CODEC_TYPE_VIDEO
)
3617 fr
= c
->time_base
.den
* 1000 / c
->time_base
.num
;
3621 } else if((fr
== 29970) || (fr
== 23976)) {
3631 if(verbose
&& norm
>= 0)
3632 fprintf(stderr
, "Assuming %s for target.\n", norm
? "NTSC" : "PAL");
3636 fprintf(stderr
, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3637 fprintf(stderr
, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3638 fprintf(stderr
, "or set a framerate with \"-r xxx\".\n");
3642 if(!strcmp(arg
, "vcd")) {
3644 opt_video_codec("mpeg1video");
3645 opt_audio_codec("mp2");
3648 opt_frame_size(norm
? "352x240" : "352x288");
3649 opt_frame_rate(NULL
, frame_rates
[norm
]);
3650 opt_default("g", norm
? "18" : "15");
3652 opt_default("b", "1150000");
3653 opt_default("maxrate", "1150000");
3654 opt_default("minrate", "1150000");
3655 opt_default("bufsize", "327680"); // 40*1024*8;
3657 opt_default("ab", "224000");
3658 audio_sample_rate
= 44100;
3661 opt_default("packetsize", "2324");
3662 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3664 /* We have to offset the PTS, so that it is consistent with the SCR.
3665 SCR starts at 36000, but the first two packs contain only padding
3666 and the first pack from the other stream, respectively, may also have
3667 been written before.
3668 So the real data starts at SCR 36000+3*1200. */
3669 mux_preload
= (36000+3*1200) / 90000.0; //0.44
3670 } else if(!strcmp(arg
, "svcd")) {
3672 opt_video_codec("mpeg2video");
3673 opt_audio_codec("mp2");
3676 opt_frame_size(norm
? "480x480" : "480x576");
3677 opt_frame_rate(NULL
, frame_rates
[norm
]);
3678 opt_default("g", norm
? "18" : "15");
3680 opt_default("b", "2040000");
3681 opt_default("maxrate", "2516000");
3682 opt_default("minrate", "0"); //1145000;
3683 opt_default("bufsize", "1835008"); //224*1024*8;
3684 opt_default("flags", "+scan_offset");
3687 opt_default("ab", "224000");
3688 audio_sample_rate
= 44100;
3690 opt_default("packetsize", "2324");
3692 } else if(!strcmp(arg
, "dvd")) {
3694 opt_video_codec("mpeg2video");
3695 opt_audio_codec("ac3");
3698 opt_frame_size(norm
? "720x480" : "720x576");
3699 opt_frame_rate(NULL
, frame_rates
[norm
]);
3700 opt_default("g", norm
? "18" : "15");
3702 opt_default("b", "6000000");
3703 opt_default("maxrate", "9000000");
3704 opt_default("minrate", "0"); //1500000;
3705 opt_default("bufsize", "1835008"); //224*1024*8;
3707 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3708 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3710 opt_default("ab", "448000");
3711 audio_sample_rate
= 48000;
3713 } else if(!strncmp(arg
, "dv", 2)) {
3717 opt_frame_size(norm
? "720x480" : "720x576");
3718 opt_frame_pix_fmt(!strncmp(arg
, "dv50", 4) ? "yuv422p" :
3719 (norm
? "yuv411p" : "yuv420p"));
3720 opt_frame_rate(NULL
, frame_rates
[norm
]);
3722 audio_sample_rate
= 48000;
3726 fprintf(stderr
, "Unknown target: %s\n", arg
);
3731 static void opt_vstats_file (const char *arg
)
3733 av_free (vstats_filename
);
3734 vstats_filename
=av_strdup (arg
);
3737 static void opt_vstats (void)
3740 time_t today2
= time(NULL
);
3741 struct tm
*today
= localtime(&today2
);
3743 snprintf(filename
, sizeof(filename
), "vstats_%02d%02d%02d.log", today
->tm_hour
, today
->tm_min
,
3745 opt_vstats_file(filename
);
3748 static int opt_bsf(const char *opt
, const char *arg
)
3750 AVBitStreamFilterContext
*bsfc
= av_bitstream_filter_init(arg
); //FIXME split name and args for filter at '='
3751 AVBitStreamFilterContext
**bsfp
;
3754 fprintf(stderr
, "Unknown bitstream filter %s\n", arg
);
3758 bsfp
= *opt
== 'v' ? &video_bitstream_filters
:
3759 *opt
== 'a' ? &audio_bitstream_filters
:
3760 &subtitle_bitstream_filters
;
3762 bsfp
= &(*bsfp
)->next
;
3769 static int opt_preset(const char *opt
, const char *arg
)
3772 char filename
[1000], tmp
[1000], tmp2
[1000], line
[1000];
3774 const char *base
[2]= { getenv("HOME"),
3779 for(i
=!base
[0]; i
<2 && !f
; i
++){
3780 snprintf(filename
, sizeof(filename
), "%s%s/%s.ffpreset", base
[i
], i
? "" : "/.ffmpeg", arg
);
3781 f
= fopen(filename
, "r");
3783 char *codec_name
= *opt
== 'v' ? video_codec_name
:
3784 *opt
== 'a' ? audio_codec_name
:
3785 subtitle_codec_name
;
3786 snprintf(filename
, sizeof(filename
), "%s%s/%s-%s.ffpreset", base
[i
], i
? "" : "/.ffmpeg", codec_name
, arg
);
3787 f
= fopen(filename
, "r");
3791 av_strlcpy(filename
, arg
, sizeof(filename
));
3792 f
= fopen(filename
, "r");
3796 fprintf(stderr
, "File for preset '%s' not found\n", arg
);
3801 int e
= fscanf(f
, "%999[^\n]\n", line
) - 1;
3802 if(line
[0] == '#' && !e
)
3804 e
|= sscanf(line
, "%999[^=]=%999[^\n]\n", tmp
, tmp2
) - 2;
3806 fprintf(stderr
, "%s: Invalid syntax: '%s'\n", filename
, line
);
3809 if(!strcmp(tmp
, "acodec")){
3810 opt_audio_codec(tmp2
);
3811 }else if(!strcmp(tmp
, "vcodec")){
3812 opt_video_codec(tmp2
);
3813 }else if(!strcmp(tmp
, "scodec")){
3814 opt_subtitle_codec(tmp2
);
3815 }else if(opt_default(tmp
, tmp2
) < 0){
3816 fprintf(stderr
, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename
, line
, tmp
, tmp2
);
3826 static const OptionDef options
[] = {
3828 { "L", OPT_EXIT
, {(void*)show_license
}, "show license" },
3829 { "h", OPT_EXIT
, {(void*)show_help
}, "show help" },
3830 { "version", OPT_EXIT
, {(void*)show_version
}, "show version" },
3831 { "formats", OPT_EXIT
, {(void*)show_formats
}, "show available formats, codecs, protocols, ..." },
3832 { "f", HAS_ARG
, {(void*)opt_format
}, "force format", "fmt" },
3833 { "i", HAS_ARG
, {(void*)opt_input_file
}, "input file name", "filename" },
3834 { "y", OPT_BOOL
, {(void*)&file_overwrite
}, "overwrite output files" },
3835 { "map", HAS_ARG
| OPT_EXPERT
, {(void*)opt_map
}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3836 { "map_meta_data", HAS_ARG
| OPT_EXPERT
, {(void*)opt_map_meta_data
}, "set meta data information of outfile from infile", "outfile:infile" },
3837 { "t", OPT_FUNC2
| HAS_ARG
, {(void*)opt_recording_time
}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3838 { "fs", HAS_ARG
| OPT_INT64
, {(void*)&limit_filesize
}, "set the limit file size in bytes", "limit_size" }, //
3839 { "ss", OPT_FUNC2
| HAS_ARG
, {(void*)opt_start_time
}, "set the start time offset", "time_off" },
3840 { "itsoffset", OPT_FUNC2
| HAS_ARG
, {(void*)opt_input_ts_offset
}, "set the input ts offset", "time_off" },
3841 { "itsscale", HAS_ARG
, {(void*)opt_input_ts_scale
}, "set the input ts scale", "stream:scale" },
3842 { "timestamp", OPT_FUNC2
| HAS_ARG
, {(void*)opt_rec_timestamp
}, "set the timestamp ('now' to set the current time)", "time" },
3843 { "metadata", OPT_FUNC2
| HAS_ARG
, {(void*)opt_metadata
}, "add metadata", "string=string" },
3844 { "dframes", OPT_INT
| HAS_ARG
, {(void*)&max_frames
[CODEC_TYPE_DATA
]}, "set the number of data frames to record", "number" },
3845 { "benchmark", OPT_BOOL
| OPT_EXPERT
, {(void*)&do_benchmark
},
3846 "add timings for benchmarking" },
3847 { "dump", OPT_BOOL
| OPT_EXPERT
, {(void*)&do_pkt_dump
},
3848 "dump each input packet" },
3849 { "hex", OPT_BOOL
| OPT_EXPERT
, {(void*)&do_hex_dump
},
3850 "when dumping packets, also dump the payload" },
3851 { "re", OPT_BOOL
| OPT_EXPERT
, {(void*)&rate_emu
}, "read input at native frame rate", "" },
3852 { "loop_input", OPT_BOOL
| OPT_EXPERT
, {(void*)&loop_input
}, "loop (current only works with images)" },
3853 { "loop_output", HAS_ARG
| OPT_INT
| OPT_EXPERT
, {(void*)&loop_output
}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
3854 { "v", HAS_ARG
| OPT_FUNC2
, {(void*)opt_verbose
}, "set ffmpeg verbosity level", "number" },
3855 { "loglevel", HAS_ARG
| OPT_FUNC2
, {(void*)opt_loglevel
}, "set libav* logging level", "loglevel" },
3856 { "target", HAS_ARG
, {(void*)opt_target
}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3857 { "threads", OPT_FUNC2
| HAS_ARG
| OPT_EXPERT
, {(void*)opt_thread_count
}, "thread count", "count" },
3858 { "vsync", HAS_ARG
| OPT_INT
| OPT_EXPERT
, {(void*)&video_sync_method
}, "video sync method", "" },
3859 { "async", HAS_ARG
| OPT_INT
| OPT_EXPERT
, {(void*)&audio_sync_method
}, "audio sync method", "" },
3860 { "adrift_threshold", HAS_ARG
| OPT_FLOAT
| OPT_EXPERT
, {(void*)&audio_drift_threshold
}, "audio drift threshold", "threshold" },
3861 { "vglobal", HAS_ARG
| OPT_INT
| OPT_EXPERT
, {(void*)&video_global_header
}, "video global header storage type", "" },
3862 { "copyts", OPT_BOOL
| OPT_EXPERT
, {(void*)©_ts
}, "copy timestamps" },
3863 { "shortest", OPT_BOOL
| OPT_EXPERT
, {(void*)&opt_shortest
}, "finish encoding within shortest input" }, //
3864 { "dts_delta_threshold", HAS_ARG
| OPT_FLOAT
| OPT_EXPERT
, {(void*)&dts_delta_threshold
}, "timestamp discontinuity delta threshold", "threshold" },
3865 { "programid", HAS_ARG
| OPT_INT
| OPT_EXPERT
, {(void*)&opt_programid
}, "desired program number", "" },
3866 { "xerror", OPT_BOOL
, {(void*)&exit_on_error
}, "exit on error", "error" },
3867 { "copyinkf", OPT_BOOL
| OPT_EXPERT
, {(void*)©_initial_nonkeyframes
}, "copy initial non-keyframes" },
3870 { "b", OPT_FUNC2
| HAS_ARG
| OPT_VIDEO
, {(void*)opt_bitrate
}, "set bitrate (in bits/s)", "bitrate" },
3871 { "vb", OPT_FUNC2
| HAS_ARG
| OPT_VIDEO
, {(void*)opt_bitrate
}, "set bitrate (in bits/s)", "bitrate" },
3872 { "vframes", OPT_INT
| HAS_ARG
| OPT_VIDEO
, {(void*)&max_frames
[CODEC_TYPE_VIDEO
]}, "set the number of video frames to record", "number" },
3873 { "r", OPT_FUNC2
| HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_rate
}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3874 { "s", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_size
}, "set frame size (WxH or abbreviation)", "size" },
3875 { "aspect", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_aspect_ratio
}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3876 { "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" },
3877 { "croptop", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_crop_top
}, "set top crop band size (in pixels)", "size" },
3878 { "cropbottom", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_crop_bottom
}, "set bottom crop band size (in pixels)", "size" },
3879 { "cropleft", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_crop_left
}, "set left crop band size (in pixels)", "size" },
3880 { "cropright", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_crop_right
}, "set right crop band size (in pixels)", "size" },
3881 { "padtop", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_pad_top
}, "set top pad band size (in pixels)", "size" },
3882 { "padbottom", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_pad_bottom
}, "set bottom pad band size (in pixels)", "size" },
3883 { "padleft", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_pad_left
}, "set left pad band size (in pixels)", "size" },
3884 { "padright", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_pad_right
}, "set right pad band size (in pixels)", "size" },
3885 { "padcolor", HAS_ARG
| OPT_VIDEO
, {(void*)opt_pad_color
}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3886 { "intra", OPT_BOOL
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&intra_only
}, "use only intra frames"},
3887 { "vn", OPT_BOOL
| OPT_VIDEO
, {(void*)&video_disable
}, "disable video" },
3888 { "vdt", OPT_INT
| HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&video_discard
}, "discard threshold", "n" },
3889 { "qscale", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_qscale
}, "use fixed video quantizer scale (VBR)", "q" },
3890 { "rc_override", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_video_rc_override_string
}, "rate control override for specific intervals", "override" },
3891 { "vcodec", HAS_ARG
| OPT_VIDEO
, {(void*)opt_video_codec
}, "force video codec ('copy' to copy stream)", "codec" },
3892 { "me_threshold", HAS_ARG
| OPT_FUNC2
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_me_threshold
}, "motion estimaton threshold", "threshold" },
3893 { "sameq", OPT_BOOL
| OPT_VIDEO
, {(void*)&same_quality
},
3894 "use same video quality as source (implies VBR)" },
3895 { "pass", HAS_ARG
| OPT_VIDEO
, {(void*)&opt_pass
}, "select the pass number (1 or 2)", "n" },
3896 { "passlogfile", HAS_ARG
| OPT_STRING
| OPT_VIDEO
, {(void*)&pass_logfilename_prefix
}, "select two pass log file name prefix", "prefix" },
3897 { "deinterlace", OPT_BOOL
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&do_deinterlace
},
3898 "deinterlace pictures" },
3899 { "psnr", OPT_BOOL
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&do_psnr
}, "calculate PSNR of compressed frames" },
3900 { "vstats", OPT_EXPERT
| OPT_VIDEO
, {(void*)&opt_vstats
}, "dump video coding statistics to file" },
3901 { "vstats_file", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_vstats_file
}, "dump video coding statistics to file", "file" },
3902 { "intra_matrix", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_intra_matrix
}, "specify intra matrix coeffs", "matrix" },
3903 { "inter_matrix", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_inter_matrix
}, "specify inter matrix coeffs", "matrix" },
3904 { "top", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_top_field_first
}, "top=1/bottom=0/auto=-1 field first", "" },
3905 { "dc", OPT_INT
| HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&intra_dc_precision
}, "intra_dc_precision", "precision" },
3906 { "vtag", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_video_tag
}, "force video tag/fourcc", "fourcc/tag" },
3907 { "newvideo", OPT_VIDEO
, {(void*)opt_new_video_stream
}, "add a new video stream to the current output stream" },
3908 { "qphist", OPT_BOOL
| OPT_EXPERT
| OPT_VIDEO
, { (void *)&qp_hist
}, "show QP histogram" },
3909 { "force_fps", OPT_BOOL
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&force_fps
}, "force the selected framerate, disable the best supported framerate selection" },
3912 { "ab", OPT_FUNC2
| HAS_ARG
| OPT_AUDIO
, {(void*)opt_bitrate
}, "set bitrate (in bits/s)", "bitrate" },
3913 { "aframes", OPT_INT
| HAS_ARG
| OPT_AUDIO
, {(void*)&max_frames
[CODEC_TYPE_AUDIO
]}, "set the number of audio frames to record", "number" },
3914 { "aq", OPT_FLOAT
| HAS_ARG
| OPT_AUDIO
, {(void*)&audio_qscale
}, "set audio quality (codec-specific)", "quality", },
3915 { "ar", HAS_ARG
| OPT_FUNC2
| OPT_AUDIO
, {(void*)opt_audio_rate
}, "set audio sampling rate (in Hz)", "rate" },
3916 { "ac", HAS_ARG
| OPT_FUNC2
| OPT_AUDIO
, {(void*)opt_audio_channels
}, "set number of audio channels", "channels" },
3917 { "an", OPT_BOOL
| OPT_AUDIO
, {(void*)&audio_disable
}, "disable audio" },
3918 { "acodec", HAS_ARG
| OPT_AUDIO
, {(void*)opt_audio_codec
}, "force audio codec ('copy' to copy stream)", "codec" },
3919 { "atag", HAS_ARG
| OPT_EXPERT
| OPT_AUDIO
, {(void*)opt_audio_tag
}, "force audio tag/fourcc", "fourcc/tag" },
3920 { "vol", OPT_INT
| HAS_ARG
| OPT_AUDIO
, {(void*)&audio_volume
}, "change audio volume (256=normal)" , "volume" }, //
3921 { "newaudio", OPT_AUDIO
, {(void*)opt_new_audio_stream
}, "add a new audio stream to the current output stream" },
3922 { "alang", HAS_ARG
| OPT_STRING
| OPT_AUDIO
, {(void *)&audio_language
}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3923 { "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" },
3925 /* subtitle options */
3926 { "sn", OPT_BOOL
| OPT_SUBTITLE
, {(void*)&subtitle_disable
}, "disable subtitle" },
3927 { "scodec", HAS_ARG
| OPT_SUBTITLE
, {(void*)opt_subtitle_codec
}, "force subtitle codec ('copy' to copy stream)", "codec" },
3928 { "newsubtitle", OPT_SUBTITLE
, {(void*)opt_new_subtitle_stream
}, "add a new subtitle stream to the current output stream" },
3929 { "slang", HAS_ARG
| OPT_STRING
| OPT_SUBTITLE
, {(void *)&subtitle_language
}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3930 { "stag", HAS_ARG
| OPT_EXPERT
| OPT_SUBTITLE
, {(void*)opt_subtitle_tag
}, "force subtitle tag/fourcc", "fourcc/tag" },
3933 { "vc", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
| OPT_GRAB
, {(void*)opt_video_channel
}, "set video grab channel (DV1394 only)", "channel" },
3934 { "tvstd", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
| OPT_GRAB
, {(void*)opt_video_standard
}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3935 { "isync", OPT_BOOL
| OPT_EXPERT
| OPT_GRAB
, {(void*)&input_sync
}, "sync read on input", "" },
3938 { "muxdelay", OPT_FLOAT
| HAS_ARG
| OPT_EXPERT
, {(void*)&mux_max_delay
}, "set the maximum demux-decode delay", "seconds" },
3939 { "muxpreload", OPT_FLOAT
| HAS_ARG
| OPT_EXPERT
, {(void*)&mux_preload
}, "set the initial demux-decode delay", "seconds" },
3941 { "absf", OPT_FUNC2
| HAS_ARG
| OPT_AUDIO
| OPT_EXPERT
, {(void*)opt_bsf
}, "", "bitstream_filter" },
3942 { "vbsf", OPT_FUNC2
| HAS_ARG
| OPT_VIDEO
| OPT_EXPERT
, {(void*)opt_bsf
}, "", "bitstream_filter" },
3943 { "sbsf", OPT_FUNC2
| HAS_ARG
| OPT_SUBTITLE
| OPT_EXPERT
, {(void*)opt_bsf
}, "", "bitstream_filter" },
3945 { "apre", OPT_FUNC2
| HAS_ARG
| OPT_AUDIO
| OPT_EXPERT
, {(void*)opt_preset
}, "set the audio options to the indicated preset", "preset" },
3946 { "vpre", OPT_FUNC2
| HAS_ARG
| OPT_VIDEO
| OPT_EXPERT
, {(void*)opt_preset
}, "set the video options to the indicated preset", "preset" },
3947 { "spre", OPT_FUNC2
| HAS_ARG
| OPT_SUBTITLE
| OPT_EXPERT
, {(void*)opt_preset
}, "set the subtitle options to the indicated preset", "preset" },
3948 { "fpre", OPT_FUNC2
| HAS_ARG
| OPT_EXPERT
, {(void*)opt_preset
}, "set options to the indicated preset file", "filename" },
3950 { "default", OPT_FUNC2
| HAS_ARG
| OPT_AUDIO
| OPT_VIDEO
| OPT_EXPERT
, {(void*)opt_default
}, "generic catch all option", "" },
3954 int main(int argc
, char **argv
)
3959 avcodec_register_all();
3960 avdevice_register_all();
3964 if(isatty(STDIN_FILENO
))
3965 url_set_interrupt_cb(decode_interrupt_cb
);
3968 for(i
=0; i
<CODEC_TYPE_NB
; i
++){
3969 avcodec_opts
[i
]= avcodec_alloc_context2(i
);
3971 avformat_opts
= avformat_alloc_context();
3972 sws_opts
= sws_getContext(16,16,0, 16,16,0, sws_flags
, NULL
,NULL
,NULL
);
3977 parse_options(argc
, argv
, options
, opt_output_file
);
3979 /* file converter / grab */
3980 if (nb_output_files
<= 0) {
3981 fprintf(stderr
, "At least one output file must be specified\n");
3985 if (nb_input_files
== 0) {
3986 fprintf(stderr
, "At least one input file must be specified\n");
3991 if (av_encode(output_files
, nb_output_files
, input_files
, nb_input_files
,
3992 stream_maps
, nb_stream_maps
) < 0)
3994 ti
= getutime() - ti
;
3996 printf("bench: utime=%0.3fs\n", ti
/ 1000000.0);