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 "libavformat/framehook.h"
38 #include "libavcodec/opt.h"
39 #include "libavcodec/audioconvert.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 AVFormatContext
*input_files
[MAX_FILES
];
95 static int64_t input_files_ts_offset
[MAX_FILES
];
96 static double input_files_ts_scale
[MAX_FILES
][MAX_STREAMS
];
97 static AVCodec
*input_codecs
[MAX_FILES
*MAX_STREAMS
];
98 static int nb_input_files
= 0;
99 static int nb_icodecs
;
101 static AVFormatContext
*output_files
[MAX_FILES
];
102 static AVCodec
*output_codecs
[MAX_FILES
*MAX_STREAMS
];
103 static int nb_output_files
= 0;
104 static int nb_ocodecs
;
106 static AVStreamMap stream_maps
[MAX_FILES
*MAX_STREAMS
];
107 static int nb_stream_maps
;
109 static AVMetaDataMap meta_data_maps
[MAX_FILES
];
110 static int nb_meta_data_maps
;
112 static AVInputFormat
*file_iformat
;
113 static AVOutputFormat
*file_oformat
;
114 static int frame_width
= 0;
115 static int frame_height
= 0;
116 static float frame_aspect_ratio
= 0;
117 static enum PixelFormat frame_pix_fmt
= PIX_FMT_NONE
;
118 static enum SampleFormat audio_sample_fmt
= SAMPLE_FMT_NONE
;
119 static int frame_padtop
= 0;
120 static int frame_padbottom
= 0;
121 static int frame_padleft
= 0;
122 static int frame_padright
= 0;
123 static int padcolor
[3] = {16,128,128}; /* default to black */
124 static int frame_topBand
= 0;
125 static int frame_bottomBand
= 0;
126 static int frame_leftBand
= 0;
127 static int frame_rightBand
= 0;
128 static int max_frames
[4] = {INT_MAX
, INT_MAX
, INT_MAX
, INT_MAX
};
129 static AVRational frame_rate
;
130 static float video_qscale
= 0;
131 static uint16_t *intra_matrix
= NULL
;
132 static uint16_t *inter_matrix
= NULL
;
133 #if 0 //experimental, (can be removed)
134 static float video_rc_qsquish
=1.0;
135 static float video_rc_qmod_amp
=0;
136 static int video_rc_qmod_freq
=0;
138 static const char *video_rc_override_string
=NULL
;
139 static int video_disable
= 0;
140 static int video_discard
= 0;
141 static char *video_codec_name
= NULL
;
142 static int video_codec_tag
= 0;
143 static int same_quality
= 0;
144 static int do_deinterlace
= 0;
145 static int top_field_first
= -1;
146 static int me_threshold
= 0;
147 static int intra_dc_precision
= 8;
148 static int loop_input
= 0;
149 static int loop_output
= AVFMT_NOOUTPUTLOOP
;
150 static int qp_hist
= 0;
152 static int intra_only
= 0;
153 static int audio_sample_rate
= 44100;
154 static int64_t channel_layout
= 0;
155 #define QSCALE_NONE -99999
156 static float audio_qscale
= QSCALE_NONE
;
157 static int audio_disable
= 0;
158 static int audio_channels
= 1;
159 static char *audio_codec_name
= NULL
;
160 static int audio_codec_tag
= 0;
161 static char *audio_language
= NULL
;
163 static int subtitle_disable
= 0;
164 static char *subtitle_codec_name
= NULL
;
165 static char *subtitle_language
= NULL
;
167 static float mux_preload
= 0.5;
168 static float mux_max_delay
= 0.7;
170 static int64_t recording_time
= INT64_MAX
;
171 static int64_t start_time
= 0;
172 static int64_t rec_timestamp
= 0;
173 static int64_t input_ts_offset
= 0;
174 static int file_overwrite
= 0;
175 static char *str_title
= NULL
;
176 static char *str_author
= NULL
;
177 static char *str_copyright
= NULL
;
178 static char *str_comment
= NULL
;
179 static char *str_genre
= NULL
;
180 static char *str_album
= NULL
;
181 static int do_benchmark
= 0;
182 static int do_hex_dump
= 0;
183 static int do_pkt_dump
= 0;
184 static int do_psnr
= 0;
185 static int do_pass
= 0;
186 static char *pass_logfilename_prefix
= NULL
;
187 static int audio_stream_copy
= 0;
188 static int video_stream_copy
= 0;
189 static int subtitle_stream_copy
= 0;
190 static int video_sync_method
= -1;
191 static int audio_sync_method
= 0;
192 static float audio_drift_threshold
= 0.1;
193 static int copy_ts
= 0;
194 static int opt_shortest
= 0;
195 static int video_global_header
= 0;
196 static char *vstats_filename
;
197 static FILE *vstats_file
;
198 static int opt_programid
= 0;
199 static int copy_initial_nonkeyframes
= 0;
201 static int rate_emu
= 0;
203 static int video_channel
= 0;
204 static char *video_standard
;
206 static int audio_volume
= 256;
208 static int exit_on_error
= 0;
209 static int using_stdin
= 0;
210 static int using_vhook
= 0;
211 static int verbose
= 1;
212 static int thread_count
= 1;
213 static int q_pressed
= 0;
214 static int64_t video_size
= 0;
215 static int64_t audio_size
= 0;
216 static int64_t extra_size
= 0;
217 static int nb_frames_dup
= 0;
218 static int nb_frames_drop
= 0;
219 static int input_sync
;
220 static uint64_t limit_filesize
= 0;
221 static int force_fps
= 0;
223 static int pgmyuv_compatibility_hack
=0;
224 static float dts_delta_threshold
= 10;
226 static unsigned int sws_flags
= SWS_BICUBIC
;
228 static int64_t timer_start
;
230 static AVBitStreamFilterContext
*video_bitstream_filters
=NULL
;
231 static AVBitStreamFilterContext
*audio_bitstream_filters
=NULL
;
232 static AVBitStreamFilterContext
*subtitle_bitstream_filters
=NULL
;
233 static AVBitStreamFilterContext
*bitstream_filters
[MAX_FILES
][MAX_STREAMS
];
235 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
237 struct AVInputStream
;
239 typedef struct AVOutputStream
{
240 int file_index
; /* file index */
241 int index
; /* stream index in the output file */
242 int source_index
; /* AVInputStream index */
243 AVStream
*st
; /* stream in the output file */
244 int encoding_needed
; /* true if encoding needed for this stream */
246 /* input pts and corresponding output pts
248 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
249 struct AVInputStream
*sync_ist
; /* input stream to sync against */
250 int64_t sync_opts
; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
253 AVFrame pict_tmp
; /* temporary image for resampling */
254 struct SwsContext
*img_resample_ctx
; /* for image resampling */
258 int topBand
; /* cropping area sizes */
262 int padtop
; /* padding area sizes */
269 ReSampleContext
*resample
; /* for audio resampling */
271 AVAudioConvert
*reformat_ctx
;
272 AVFifoBuffer fifo
; /* for compression: one audio fifo per codec */
276 typedef struct AVInputStream
{
280 int discard
; /* true if stream data should be discarded */
281 int decoding_needed
; /* true if the packets must be decoded in 'raw_fifo' */
282 int64_t sample_index
; /* current sample */
284 int64_t start
; /* time when read started */
285 int64_t next_pts
; /* synthetic pts for cases where pkt.pts
287 int64_t pts
; /* current pts */
288 int is_start
; /* is 1 at the start and after a discontinuity */
291 typedef struct AVInputFile
{
292 int eof_reached
; /* true if eof reached */
293 int ist_index
; /* index of first stream in ist_table */
294 int buffer_size
; /* current total buffer size */
295 int nb_streams
; /* nb streams we are aware of */
300 /* init terminal so that we can grab keys */
301 static struct termios oldtty
;
304 static void term_exit(void)
307 tcsetattr (0, TCSANOW
, &oldtty
);
311 static volatile sig_atomic_t received_sigterm
= 0;
314 sigterm_handler(int sig
)
316 received_sigterm
= sig
;
320 static void term_init(void)
328 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
329 |INLCR
|IGNCR
|ICRNL
|IXON
);
330 tty
.c_oflag
|= OPOST
;
331 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
332 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
337 tcsetattr (0, TCSANOW
, &tty
);
338 signal(SIGQUIT
, sigterm_handler
); /* Quit (POSIX). */
341 signal(SIGINT
, sigterm_handler
); /* Interrupt (ANSI). */
342 signal(SIGTERM
, sigterm_handler
); /* Termination (ANSI). */
344 register a function to be called at normal program termination
347 #if CONFIG_BEOS_NETSERVER
348 fcntl(0, F_SETFL
, fcntl(0, F_GETFL
) | O_NONBLOCK
);
352 /* read a key without blocking */
353 static int read_key(void)
358 #if !CONFIG_BEOS_NETSERVER
366 n
= select(1, &rfds
, NULL
, NULL
, &tv
);
382 static int decode_interrupt_cb(void)
384 return q_pressed
|| (q_pressed
= read_key() == 'q');
387 static int av_exit(int ret
)
392 for(i
=0;i
<nb_output_files
;i
++) {
393 /* maybe av_close_output_file ??? */
394 AVFormatContext
*s
= output_files
[i
];
396 if (!(s
->oformat
->flags
& AVFMT_NOFILE
) && s
->pb
)
398 for(j
=0;j
<s
->nb_streams
;j
++) {
399 av_metadata_free(&s
->streams
[j
]->metadata
);
400 av_free(s
->streams
[j
]->codec
);
401 av_free(s
->streams
[j
]);
403 for(j
=0;j
<s
->nb_programs
;j
++) {
404 av_metadata_free(&s
->programs
[j
]->metadata
);
406 for(j
=0;j
<s
->nb_chapters
;j
++) {
407 av_metadata_free(&s
->chapters
[j
]->metadata
);
409 av_metadata_free(&s
->metadata
);
412 for(i
=0;i
<nb_input_files
;i
++)
413 av_close_input_file(input_files
[i
]);
415 av_free(intra_matrix
);
416 av_free(inter_matrix
);
420 av_free(vstats_filename
);
424 av_free(video_codec_name
);
425 av_free(audio_codec_name
);
426 av_free(subtitle_codec_name
);
428 av_free(video_standard
);
430 #if CONFIG_POWERPC_PERF
431 void powerpc_display_perf_report(void);
432 powerpc_display_perf_report();
433 #endif /* CONFIG_POWERPC_PERF */
435 if (received_sigterm
) {
437 "Received signal %d: terminating.\n",
438 (int) received_sigterm
);
442 exit(ret
); /* not all OS-es handle main() return value */
446 static int read_ffserver_streams(AVFormatContext
*s
, const char *filename
)
452 err
= av_open_input_file(&ic
, filename
, NULL
, FFM_PACKET_SIZE
, NULL
);
455 /* copy stream format */
456 s
->nb_streams
= ic
->nb_streams
;
457 for(i
=0;i
<ic
->nb_streams
;i
++) {
460 // FIXME: a more elegant solution is needed
461 st
= av_mallocz(sizeof(AVStream
));
462 memcpy(st
, ic
->streams
[i
], sizeof(AVStream
));
463 st
->codec
= avcodec_alloc_context();
464 memcpy(st
->codec
, ic
->streams
[i
]->codec
, sizeof(AVCodecContext
));
467 if (st
->codec
->codec_type
== CODEC_TYPE_AUDIO
&& audio_stream_copy
)
469 else if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
&& video_stream_copy
)
472 if(!st
->codec
->thread_count
)
473 st
->codec
->thread_count
= 1;
474 if(st
->codec
->thread_count
>1)
475 avcodec_thread_init(st
->codec
, st
->codec
->thread_count
);
477 if(st
->codec
->flags
& CODEC_FLAG_BITEXACT
)
482 s
->timestamp
= av_gettime();
484 av_close_input_file(ic
);
489 get_sync_ipts(const AVOutputStream
*ost
)
491 const AVInputStream
*ist
= ost
->sync_ist
;
492 return (double)(ist
->pts
- start_time
)/AV_TIME_BASE
;
495 static void write_frame(AVFormatContext
*s
, AVPacket
*pkt
, AVCodecContext
*avctx
, AVBitStreamFilterContext
*bsfc
){
499 AVPacket new_pkt
= *pkt
;
500 int a
= av_bitstream_filter_filter(bsfc
, avctx
, NULL
,
501 &new_pkt
.data
, &new_pkt
.size
,
502 pkt
->data
, pkt
->size
,
503 pkt
->flags
& PKT_FLAG_KEY
);
506 new_pkt
.destruct
= av_destruct_packet
;
508 fprintf(stderr
, "%s failed for stream %d, codec %s",
509 bsfc
->filter
->name
, pkt
->stream_index
,
510 avctx
->codec
? avctx
->codec
->name
: "copy");
520 ret
= av_interleaved_write_frame(s
, pkt
);
522 print_error("av_interleaved_write_frame()", ret
);
527 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
529 static void do_audio_out(AVFormatContext
*s
,
532 unsigned char *buf
, int size
)
535 static uint8_t *audio_buf
= NULL
;
536 static uint8_t *audio_out
= NULL
;
537 static uint8_t *audio_out2
= NULL
;
538 const int audio_out_size
= 4*MAX_AUDIO_PACKET_SIZE
;
540 int size_out
, frame_bytes
, ret
;
541 AVCodecContext
*enc
= ost
->st
->codec
;
542 AVCodecContext
*dec
= ist
->st
->codec
;
543 int osize
= av_get_bits_per_sample_format(enc
->sample_fmt
)/8;
544 int isize
= av_get_bits_per_sample_format(dec
->sample_fmt
)/8;
546 /* SC: dynamic allocation of buffers */
548 audio_buf
= av_malloc(2*MAX_AUDIO_PACKET_SIZE
);
550 audio_out
= av_malloc(audio_out_size
);
551 if (!audio_buf
|| !audio_out
)
552 return; /* Should signal an error ! */
554 if (enc
->channels
!= dec
->channels
)
555 ost
->audio_resample
= 1;
557 if (ost
->audio_resample
&& !ost
->resample
) {
558 if (dec
->sample_fmt
!= SAMPLE_FMT_S16
)
559 fprintf(stderr
, "Warning, using s16 intermediate sample format for resampling\n");
560 ost
->resample
= av_audio_resample_init(enc
->channels
, dec
->channels
,
561 enc
->sample_rate
, dec
->sample_rate
,
562 enc
->sample_fmt
, dec
->sample_fmt
,
564 if (!ost
->resample
) {
565 fprintf(stderr
, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
566 dec
->channels
, dec
->sample_rate
,
567 enc
->channels
, enc
->sample_rate
);
572 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
573 if (!ost
->audio_resample
&& dec
->sample_fmt
!=enc
->sample_fmt
&&
574 MAKE_SFMT_PAIR(enc
->sample_fmt
,dec
->sample_fmt
)!=ost
->reformat_pair
) {
576 audio_out2
= av_malloc(audio_out_size
);
579 if (ost
->reformat_ctx
)
580 av_audio_convert_free(ost
->reformat_ctx
);
581 ost
->reformat_ctx
= av_audio_convert_alloc(enc
->sample_fmt
, 1,
582 dec
->sample_fmt
, 1, NULL
, 0);
583 if (!ost
->reformat_ctx
) {
584 fprintf(stderr
, "Cannot convert %s sample format to %s sample format\n",
585 avcodec_get_sample_fmt_name(dec
->sample_fmt
),
586 avcodec_get_sample_fmt_name(enc
->sample_fmt
));
589 ost
->reformat_pair
=MAKE_SFMT_PAIR(enc
->sample_fmt
,dec
->sample_fmt
);
592 if(audio_sync_method
){
593 double delta
= get_sync_ipts(ost
) * enc
->sample_rate
- ost
->sync_opts
594 - av_fifo_size(&ost
->fifo
)/(ost
->st
->codec
->channels
* 2);
595 double idelta
= delta
*ist
->st
->codec
->sample_rate
/ enc
->sample_rate
;
596 int byte_delta
= ((int)idelta
)*2*ist
->st
->codec
->channels
;
598 //FIXME resample delay
599 if(fabs(delta
) > 50){
600 if(ist
->is_start
|| fabs(delta
) > audio_drift_threshold
*enc
->sample_rate
){
602 byte_delta
= FFMAX(byte_delta
, -size
);
606 fprintf(stderr
, "discarding %d audio samples\n", (int)-delta
);
611 static uint8_t *input_tmp
= NULL
;
612 input_tmp
= av_realloc(input_tmp
, byte_delta
+ size
);
614 if(byte_delta
+ size
<= MAX_AUDIO_PACKET_SIZE
)
617 byte_delta
= MAX_AUDIO_PACKET_SIZE
- size
;
619 memset(input_tmp
, 0, byte_delta
);
620 memcpy(input_tmp
+ byte_delta
, buf
, size
);
624 fprintf(stderr
, "adding %d audio samples of silence\n", (int)delta
);
626 }else if(audio_sync_method
>1){
627 int comp
= av_clip(delta
, -audio_sync_method
, audio_sync_method
);
628 assert(ost
->audio_resample
);
630 fprintf(stderr
, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta
, comp
, enc
->sample_rate
);
631 // 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));
632 av_resample_compensate(*(struct AVResampleContext
**)ost
->resample
, comp
, enc
->sample_rate
);
636 ost
->sync_opts
= lrintf(get_sync_ipts(ost
) * enc
->sample_rate
)
637 - av_fifo_size(&ost
->fifo
)/(ost
->st
->codec
->channels
* 2); //FIXME wrong
639 if (ost
->audio_resample
) {
641 size_out
= audio_resample(ost
->resample
,
642 (short *)buftmp
, (short *)buf
,
643 size
/ (ist
->st
->codec
->channels
* isize
));
644 size_out
= size_out
* enc
->channels
* osize
;
650 if (!ost
->audio_resample
&& dec
->sample_fmt
!=enc
->sample_fmt
) {
651 const void *ibuf
[6]= {buftmp
};
652 void *obuf
[6]= {audio_out2
};
653 int istride
[6]= {isize
};
654 int ostride
[6]= {osize
};
655 int len
= size_out
/istride
[0];
656 if (av_audio_convert(ost
->reformat_ctx
, obuf
, ostride
, ibuf
, istride
, len
)<0) {
657 printf("av_audio_convert() failed\n");
663 size_out
= len
*osize
;
666 /* now encode as many frames as possible */
667 if (enc
->frame_size
> 1) {
668 /* output resampled raw samples */
669 if (av_fifo_realloc2(&ost
->fifo
, av_fifo_size(&ost
->fifo
) + size_out
) < 0) {
670 fprintf(stderr
, "av_fifo_realloc2() failed\n");
673 av_fifo_generic_write(&ost
->fifo
, buftmp
, size_out
, NULL
);
675 frame_bytes
= enc
->frame_size
* osize
* enc
->channels
;
677 while (av_fifo_size(&ost
->fifo
) >= frame_bytes
) {
679 av_init_packet(&pkt
);
681 av_fifo_read(&ost
->fifo
, audio_buf
, frame_bytes
);
683 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
685 ret
= avcodec_encode_audio(enc
, audio_out
, audio_out_size
,
688 fprintf(stderr
, "Audio encoding failed\n");
692 pkt
.stream_index
= ost
->index
;
695 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
696 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
697 pkt
.flags
|= PKT_FLAG_KEY
;
698 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
700 ost
->sync_opts
+= enc
->frame_size
;
704 int coded_bps
= av_get_bits_per_sample(enc
->codec
->id
)/8;
705 av_init_packet(&pkt
);
707 ost
->sync_opts
+= size_out
/ (osize
* enc
->channels
);
709 /* output a pcm frame */
710 /* determine the size of the coded buffer */
713 size_out
*= coded_bps
;
715 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
716 ret
= avcodec_encode_audio(enc
, audio_out
, size_out
,
719 fprintf(stderr
, "Audio encoding failed\n");
723 pkt
.stream_index
= ost
->index
;
726 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
727 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
728 pkt
.flags
|= PKT_FLAG_KEY
;
729 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
733 static void pre_process_video_frame(AVInputStream
*ist
, AVPicture
*picture
, void **bufp
)
737 AVPicture picture_tmp
;
740 dec
= ist
->st
->codec
;
742 /* deinterlace : must be done before any resize */
743 if (do_deinterlace
|| using_vhook
) {
746 /* create temporary picture */
747 size
= avpicture_get_size(dec
->pix_fmt
, dec
->width
, dec
->height
);
748 buf
= av_malloc(size
);
752 picture2
= &picture_tmp
;
753 avpicture_fill(picture2
, buf
, dec
->pix_fmt
, dec
->width
, dec
->height
);
756 if(avpicture_deinterlace(picture2
, picture
,
757 dec
->pix_fmt
, dec
->width
, dec
->height
) < 0) {
758 /* if error, do not deinterlace */
759 fprintf(stderr
, "Deinterlacing failed\n");
765 av_picture_copy(picture2
, picture
, dec
->pix_fmt
, dec
->width
, dec
->height
);
772 frame_hook_process(picture2
, dec
->pix_fmt
, dec
->width
, dec
->height
,
773 1000000 * ist
->pts
/ AV_TIME_BASE
);
775 if (picture
!= picture2
)
776 *picture
= *picture2
;
780 /* we begin to correct av delay at this threshold */
781 #define AV_DELAY_MAX 0.100
783 static void do_subtitle_out(AVFormatContext
*s
,
789 static uint8_t *subtitle_out
= NULL
;
790 int subtitle_out_max_size
= 65536;
791 int subtitle_out_size
, nb
, i
;
795 if (pts
== AV_NOPTS_VALUE
) {
796 fprintf(stderr
, "Subtitle packets must have a pts\n");
802 enc
= ost
->st
->codec
;
805 subtitle_out
= av_malloc(subtitle_out_max_size
);
808 /* Note: DVB subtitle need one packet to draw them and one other
809 packet to clear them */
810 /* XXX: signal it in the codec context ? */
811 if (enc
->codec_id
== CODEC_ID_DVB_SUBTITLE
)
816 for(i
= 0; i
< nb
; i
++) {
817 subtitle_out_size
= avcodec_encode_subtitle(enc
, subtitle_out
,
818 subtitle_out_max_size
, sub
);
820 av_init_packet(&pkt
);
821 pkt
.stream_index
= ost
->index
;
822 pkt
.data
= subtitle_out
;
823 pkt
.size
= subtitle_out_size
;
824 pkt
.pts
= av_rescale_q(pts
, ist
->st
->time_base
, ost
->st
->time_base
);
825 if (enc
->codec_id
== CODEC_ID_DVB_SUBTITLE
) {
826 /* XXX: the pts correction is handled here. Maybe handling
827 it in the codec would be better */
829 pkt
.pts
+= 90 * sub
->start_display_time
;
831 pkt
.pts
+= 90 * sub
->end_display_time
;
833 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
837 static int bit_buffer_size
= 1024*256;
838 static uint8_t *bit_buffer
= NULL
;
840 static void do_video_out(AVFormatContext
*s
,
846 int nb_frames
, i
, ret
;
847 AVFrame
*final_picture
, *formatted_picture
, *resampling_dst
, *padding_src
;
848 AVFrame picture_crop_temp
, picture_pad_temp
;
849 AVCodecContext
*enc
, *dec
;
851 avcodec_get_frame_defaults(&picture_crop_temp
);
852 avcodec_get_frame_defaults(&picture_pad_temp
);
854 enc
= ost
->st
->codec
;
855 dec
= ist
->st
->codec
;
857 /* by default, we output a single frame */
862 if(video_sync_method
>0 || (video_sync_method
&& av_q2d(enc
->time_base
) > 0.001)){
864 vdelta
= get_sync_ipts(ost
) / av_q2d(enc
->time_base
) - ost
->sync_opts
;
865 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
868 else if (video_sync_method
== 2 || (video_sync_method
<0 && (s
->oformat
->flags
& AVFMT_VARIABLE_FPS
))){
872 ost
->sync_opts
= lrintf(get_sync_ipts(ost
) / av_q2d(enc
->time_base
));
873 }else if (vdelta
> 1.1)
874 nb_frames
= lrintf(vdelta
);
875 //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);
879 fprintf(stderr
, "*** drop!\n");
880 }else if (nb_frames
> 1) {
881 nb_frames_dup
+= nb_frames
;
883 fprintf(stderr
, "*** %d dup!\n", nb_frames
-1);
886 ost
->sync_opts
= lrintf(get_sync_ipts(ost
) / av_q2d(enc
->time_base
));
888 nb_frames
= FFMIN(nb_frames
, max_frames
[CODEC_TYPE_VIDEO
] - ost
->frame_number
);
892 if (ost
->video_crop
) {
893 if (av_picture_crop((AVPicture
*)&picture_crop_temp
, (AVPicture
*)in_picture
, dec
->pix_fmt
, ost
->topBand
, ost
->leftBand
) < 0) {
894 fprintf(stderr
, "error cropping picture\n");
899 formatted_picture
= &picture_crop_temp
;
901 formatted_picture
= in_picture
;
904 final_picture
= formatted_picture
;
905 padding_src
= formatted_picture
;
906 resampling_dst
= &ost
->pict_tmp
;
907 if (ost
->video_pad
) {
908 final_picture
= &ost
->pict_tmp
;
909 if (ost
->video_resample
) {
910 if (av_picture_crop((AVPicture
*)&picture_pad_temp
, (AVPicture
*)final_picture
, enc
->pix_fmt
, ost
->padtop
, ost
->padleft
) < 0) {
911 fprintf(stderr
, "error padding picture\n");
916 resampling_dst
= &picture_pad_temp
;
920 if (ost
->video_resample
) {
922 final_picture
= &ost
->pict_tmp
;
923 sws_scale(ost
->img_resample_ctx
, formatted_picture
->data
, formatted_picture
->linesize
,
924 0, ost
->resample_height
, resampling_dst
->data
, resampling_dst
->linesize
);
927 if (ost
->video_pad
) {
928 av_picture_pad((AVPicture
*)final_picture
, (AVPicture
*)padding_src
,
929 enc
->height
, enc
->width
, enc
->pix_fmt
,
930 ost
->padtop
, ost
->padbottom
, ost
->padleft
, ost
->padright
, padcolor
);
933 /* duplicates frame if needed */
934 for(i
=0;i
<nb_frames
;i
++) {
936 av_init_packet(&pkt
);
937 pkt
.stream_index
= ost
->index
;
939 if (s
->oformat
->flags
& AVFMT_RAWPICTURE
) {
940 /* raw pictures are written as AVPicture structure to
941 avoid any copies. We support temorarily the older
943 AVFrame
* old_frame
= enc
->coded_frame
;
944 enc
->coded_frame
= dec
->coded_frame
; //FIXME/XXX remove this hack
945 pkt
.data
= (uint8_t *)final_picture
;
946 pkt
.size
= sizeof(AVPicture
);
947 pkt
.pts
= av_rescale_q(ost
->sync_opts
, enc
->time_base
, ost
->st
->time_base
);
948 pkt
.flags
|= PKT_FLAG_KEY
;
950 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
951 enc
->coded_frame
= old_frame
;
955 big_picture
= *final_picture
;
956 /* better than nothing: use input picture interlaced
958 big_picture
.interlaced_frame
= in_picture
->interlaced_frame
;
959 if(avctx_opts
[CODEC_TYPE_VIDEO
]->flags
& (CODEC_FLAG_INTERLACED_DCT
|CODEC_FLAG_INTERLACED_ME
)){
960 if(top_field_first
== -1)
961 big_picture
.top_field_first
= in_picture
->top_field_first
;
963 big_picture
.top_field_first
= top_field_first
;
966 /* handles sameq here. This is not correct because it may
967 not be a global option */
969 big_picture
.quality
= ist
->st
->quality
;
971 big_picture
.quality
= ost
->st
->quality
;
973 big_picture
.pict_type
= 0;
974 // big_picture.pts = AV_NOPTS_VALUE;
975 big_picture
.pts
= ost
->sync_opts
;
976 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
977 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
978 ret
= avcodec_encode_video(enc
,
979 bit_buffer
, bit_buffer_size
,
982 fprintf(stderr
, "Video encoding failed\n");
985 //enc->frame_number = enc->real_pict_num;
987 pkt
.data
= bit_buffer
;
989 if(enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
990 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
991 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
992 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
993 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
995 if(enc
->coded_frame
->key_frame
)
996 pkt
.flags
|= PKT_FLAG_KEY
;
997 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
1000 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
1001 // enc->frame_number-1, enc->real_pict_num, ret,
1003 /* if two pass, output log */
1004 if (ost
->logfile
&& enc
->stats_out
) {
1005 fprintf(ost
->logfile
, "%s", enc
->stats_out
);
1010 ost
->frame_number
++;
1014 static double psnr(double d
){
1015 return -10.0*log(d
)/log(10.0);
1018 static void do_video_stats(AVFormatContext
*os
, AVOutputStream
*ost
,
1021 AVCodecContext
*enc
;
1023 double ti1
, bitrate
, avg_bitrate
;
1025 /* this is executed just the first time do_video_stats is called */
1027 vstats_file
= fopen(vstats_filename
, "w");
1034 enc
= ost
->st
->codec
;
1035 if (enc
->codec_type
== CODEC_TYPE_VIDEO
) {
1036 frame_number
= ost
->frame_number
;
1037 fprintf(vstats_file
, "frame= %5d q= %2.1f ", frame_number
, enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
);
1038 if (enc
->flags
&CODEC_FLAG_PSNR
)
1039 fprintf(vstats_file
, "PSNR= %6.2f ", psnr(enc
->coded_frame
->error
[0]/(enc
->width
*enc
->height
*255.0*255.0)));
1041 fprintf(vstats_file
,"f_size= %6d ", frame_size
);
1042 /* compute pts value */
1043 ti1
= ost
->sync_opts
* av_q2d(enc
->time_base
);
1047 bitrate
= (frame_size
* 8) / av_q2d(enc
->time_base
) / 1000.0;
1048 avg_bitrate
= (double)(video_size
* 8) / ti1
/ 1000.0;
1049 fprintf(vstats_file
, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1050 (double)video_size
/ 1024, ti1
, bitrate
, avg_bitrate
);
1051 fprintf(vstats_file
,"type= %c\n", av_get_pict_type_char(enc
->coded_frame
->pict_type
));
1055 static void print_report(AVFormatContext
**output_files
,
1056 AVOutputStream
**ost_table
, int nb_ostreams
,
1060 AVOutputStream
*ost
;
1061 AVFormatContext
*oc
, *os
;
1063 AVCodecContext
*enc
;
1064 int frame_number
, vid
, i
;
1065 double bitrate
, ti1
, pts
;
1066 static int64_t last_time
= -1;
1067 static int qp_histogram
[52];
1069 if (!is_last_report
) {
1071 /* display the report every 0.5 seconds */
1072 cur_time
= av_gettime();
1073 if (last_time
== -1) {
1074 last_time
= cur_time
;
1077 if ((cur_time
- last_time
) < 500000)
1079 last_time
= cur_time
;
1083 oc
= output_files
[0];
1085 total_size
= url_fsize(oc
->pb
);
1086 if(total_size
<0) // FIXME improve url_fsize() so it works with non seekable output too
1087 total_size
= url_ftell(oc
->pb
);
1092 for(i
=0;i
<nb_ostreams
;i
++) {
1094 os
= output_files
[ost
->file_index
];
1095 enc
= ost
->st
->codec
;
1096 if (vid
&& enc
->codec_type
== CODEC_TYPE_VIDEO
) {
1097 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "q=%2.1f ",
1098 !ost
->st
->stream_copy
?
1099 enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
: -1);
1101 if (!vid
&& enc
->codec_type
== CODEC_TYPE_VIDEO
) {
1102 float t
= (av_gettime()-timer_start
) / 1000000.0;
1104 frame_number
= ost
->frame_number
;
1105 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "frame=%5d fps=%3d q=%3.1f ",
1106 frame_number
, (t
>1)?(int)(frame_number
/t
+0.5) : 0,
1107 !ost
->st
->stream_copy
?
1108 enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
: -1);
1110 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "L");
1113 int qp
= lrintf(enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
);
1114 if(qp
>=0 && qp
<FF_ARRAY_ELEMS(qp_histogram
))
1117 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "%X", (int)lrintf(log(qp_histogram
[j
]+1)/log(2)));
1119 if (enc
->flags
&CODEC_FLAG_PSNR
){
1121 double error
, error_sum
=0;
1122 double scale
, scale_sum
=0;
1123 char type
[3]= {'Y','U','V'};
1124 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "PSNR=");
1127 error
= enc
->error
[j
];
1128 scale
= enc
->width
*enc
->height
*255.0*255.0*frame_number
;
1130 error
= enc
->coded_frame
->error
[j
];
1131 scale
= enc
->width
*enc
->height
*255.0*255.0;
1136 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "%c:%2.2f ", type
[j
], psnr(error
/scale
));
1138 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "*:%2.2f ", psnr(error_sum
/scale_sum
));
1142 /* compute min output value */
1143 pts
= (double)ost
->st
->pts
.val
* av_q2d(ost
->st
->time_base
);
1144 if ((pts
< ti1
) && (pts
> 0))
1150 if (verbose
|| is_last_report
) {
1151 bitrate
= (double)(total_size
* 8) / ti1
/ 1000.0;
1153 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
1154 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1155 (double)total_size
/ 1024, ti1
, bitrate
);
1158 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), " dup=%d drop=%d",
1159 nb_frames_dup
, nb_frames_drop
);
1162 fprintf(stderr
, "%s \r", buf
);
1167 if (is_last_report
&& verbose
>= 0){
1168 int64_t raw
= audio_size
+ video_size
+ extra_size
;
1169 fprintf(stderr
, "\n");
1170 fprintf(stderr
, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1174 100.0*(total_size
- raw
)/raw
1179 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1180 static int output_packet(AVInputStream
*ist
, int ist_index
,
1181 AVOutputStream
**ost_table
, int nb_ostreams
,
1182 const AVPacket
*pkt
)
1184 AVFormatContext
*os
;
1185 AVOutputStream
*ost
;
1189 int data_size
, got_picture
;
1191 void *buffer_to_free
;
1192 static unsigned int samples_size
= 0;
1193 static short *samples
= NULL
;
1194 AVSubtitle subtitle
, *subtitle_to_free
;
1197 if(ist
->next_pts
== AV_NOPTS_VALUE
)
1198 ist
->next_pts
= ist
->pts
;
1207 if(pkt
->dts
!= AV_NOPTS_VALUE
)
1208 ist
->next_pts
= ist
->pts
= av_rescale_q(pkt
->dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
1213 //while we have more to decode or while the decoder did output something on EOF
1214 while (len
> 0 || (!pkt
&& ist
->next_pts
!= ist
->pts
)) {
1216 ist
->pts
= ist
->next_pts
;
1218 if(len
&& len
!= pkt
->size
&& verbose
>0)
1219 fprintf(stderr
, "Multiple frames in a packet from stream %d\n", pkt
->stream_index
);
1221 /* decode the packet if needed */
1222 data_buf
= NULL
; /* fail safe */
1224 subtitle_to_free
= NULL
;
1225 if (ist
->decoding_needed
) {
1226 switch(ist
->st
->codec
->codec_type
) {
1227 case CODEC_TYPE_AUDIO
:{
1228 if(pkt
&& samples_size
< FFMAX(pkt
->size
*sizeof(*samples
), AVCODEC_MAX_AUDIO_FRAME_SIZE
)) {
1229 samples_size
= FFMAX(pkt
->size
*sizeof(*samples
), AVCODEC_MAX_AUDIO_FRAME_SIZE
);
1231 samples
= av_malloc(samples_size
);
1233 data_size
= samples_size
;
1234 /* XXX: could avoid copy if PCM 16 bits with same
1235 endianness as CPU */
1236 ret
= avcodec_decode_audio2(ist
->st
->codec
, samples
, &data_size
,
1242 /* Some bug in mpeg audio decoder gives */
1243 /* data_size < 0, it seems they are overflows */
1244 if (data_size
<= 0) {
1245 /* no audio frame */
1248 data_buf
= (uint8_t *)samples
;
1249 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
/2 * data_size
) /
1250 (ist
->st
->codec
->sample_rate
* ist
->st
->codec
->channels
);
1252 case CODEC_TYPE_VIDEO
:
1253 data_size
= (ist
->st
->codec
->width
* ist
->st
->codec
->height
* 3) / 2;
1254 /* XXX: allocate picture correctly */
1255 avcodec_get_frame_defaults(&picture
);
1257 ret
= avcodec_decode_video(ist
->st
->codec
,
1258 &picture
, &got_picture
, ptr
, len
);
1259 ist
->st
->quality
= picture
.quality
;
1263 /* no picture yet */
1264 goto discard_packet
;
1266 if (ist
->st
->codec
->time_base
.num
!= 0) {
1267 int ticks
= ist
->st
->parser
? ist
->st
->parser
->repeat_pict
+1 : ist
->st
->codec
->ticks_per_frame
;
1268 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
*
1269 ist
->st
->codec
->time_base
.num
* ticks
) /
1270 ist
->st
->codec
->time_base
.den
;
1274 case CODEC_TYPE_SUBTITLE
:
1275 ret
= avcodec_decode_subtitle(ist
->st
->codec
,
1276 &subtitle
, &got_subtitle
, ptr
, len
);
1279 if (!got_subtitle
) {
1280 goto discard_packet
;
1282 subtitle_to_free
= &subtitle
;
1289 switch(ist
->st
->codec
->codec_type
) {
1290 case CODEC_TYPE_AUDIO
:
1291 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
* ist
->st
->codec
->frame_size
) /
1292 ist
->st
->codec
->sample_rate
;
1294 case CODEC_TYPE_VIDEO
:
1295 if (ist
->st
->codec
->time_base
.num
!= 0) {
1296 int ticks
= ist
->st
->parser
? ist
->st
->parser
->repeat_pict
+1 : ist
->st
->codec
->ticks_per_frame
;
1297 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
*
1298 ist
->st
->codec
->time_base
.num
* ticks
) /
1299 ist
->st
->codec
->time_base
.den
;
1309 buffer_to_free
= NULL
;
1310 if (ist
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
1311 pre_process_video_frame(ist
, (AVPicture
*)&picture
,
1315 // preprocess audio (volume)
1316 if (ist
->st
->codec
->codec_type
== CODEC_TYPE_AUDIO
) {
1317 if (audio_volume
!= 256) {
1320 for(i
=0;i
<(data_size
/ sizeof(short));i
++) {
1321 int v
= ((*volp
) * audio_volume
+ 128) >> 8;
1322 if (v
< -32768) v
= -32768;
1323 if (v
> 32767) v
= 32767;
1329 /* frame rate emulation */
1331 int64_t pts
= av_rescale(ist
->pts
, 1000000, AV_TIME_BASE
);
1332 int64_t now
= av_gettime() - ist
->start
;
1337 /* if output time reached then transcode raw format,
1338 encode packets and output them */
1339 if (start_time
== 0 || ist
->pts
>= start_time
)
1340 for(i
=0;i
<nb_ostreams
;i
++) {
1344 if (ost
->source_index
== ist_index
) {
1345 os
= output_files
[ost
->file_index
];
1348 printf("%d: got pts=%0.3f %0.3f\n", i
,
1349 (double)pkt
->pts
/ AV_TIME_BASE
,
1350 ((double)ist
->pts
/ AV_TIME_BASE
) -
1351 ((double)ost
->st
->pts
.val
* ost
->st
->time_base
.num
/ ost
->st
->time_base
.den
));
1353 /* set the input output pts pairs */
1354 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1356 if (ost
->encoding_needed
) {
1357 switch(ost
->st
->codec
->codec_type
) {
1358 case CODEC_TYPE_AUDIO
:
1359 do_audio_out(os
, ost
, ist
, data_buf
, data_size
);
1361 case CODEC_TYPE_VIDEO
:
1362 do_video_out(os
, ost
, ist
, &picture
, &frame_size
);
1363 if (vstats_filename
&& frame_size
)
1364 do_video_stats(os
, ost
, frame_size
);
1366 case CODEC_TYPE_SUBTITLE
:
1367 do_subtitle_out(os
, ost
, ist
, &subtitle
,
1374 AVFrame avframe
; //FIXME/XXX remove this
1376 av_init_packet(&opkt
);
1378 if ((!ost
->frame_number
&& !(pkt
->flags
& PKT_FLAG_KEY
)) && !copy_initial_nonkeyframes
)
1381 /* no reencoding needed : output the packet directly */
1382 /* force the input stream PTS */
1384 avcodec_get_frame_defaults(&avframe
);
1385 ost
->st
->codec
->coded_frame
= &avframe
;
1386 avframe
.key_frame
= pkt
->flags
& PKT_FLAG_KEY
;
1388 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_AUDIO
)
1389 audio_size
+= data_size
;
1390 else if (ost
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
1391 video_size
+= data_size
;
1395 opkt
.stream_index
= ost
->index
;
1396 if(pkt
->pts
!= AV_NOPTS_VALUE
)
1397 opkt
.pts
= av_rescale_q(pkt
->pts
, ist
->st
->time_base
, ost
->st
->time_base
);
1399 opkt
.pts
= AV_NOPTS_VALUE
;
1401 if (pkt
->dts
== AV_NOPTS_VALUE
)
1402 opkt
.dts
= av_rescale_q(ist
->pts
, AV_TIME_BASE_Q
, ost
->st
->time_base
);
1404 opkt
.dts
= av_rescale_q(pkt
->dts
, ist
->st
->time_base
, ost
->st
->time_base
);
1406 opkt
.duration
= av_rescale_q(pkt
->duration
, ist
->st
->time_base
, ost
->st
->time_base
);
1407 opkt
.flags
= pkt
->flags
;
1409 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1410 if(av_parser_change(ist
->st
->parser
, ost
->st
->codec
, &opkt
.data
, &opkt
.size
, data_buf
, data_size
, pkt
->flags
& PKT_FLAG_KEY
))
1411 opkt
.destruct
= av_destruct_packet
;
1413 write_frame(os
, &opkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][opkt
.stream_index
]);
1414 ost
->st
->codec
->frame_number
++;
1415 ost
->frame_number
++;
1416 av_free_packet(&opkt
);
1420 av_free(buffer_to_free
);
1421 /* XXX: allocate the subtitles in the codec ? */
1422 if (subtitle_to_free
) {
1423 if (subtitle_to_free
->rects
!= NULL
) {
1424 for (i
= 0; i
< subtitle_to_free
->num_rects
; i
++) {
1425 av_freep(&subtitle_to_free
->rects
[i
]->pict
.data
[0]);
1426 av_freep(&subtitle_to_free
->rects
[i
]->pict
.data
[1]);
1427 av_freep(&subtitle_to_free
->rects
[i
]);
1429 av_freep(&subtitle_to_free
->rects
);
1431 subtitle_to_free
->num_rects
= 0;
1432 subtitle_to_free
= NULL
;
1439 for(i
=0;i
<nb_ostreams
;i
++) {
1441 if (ost
->source_index
== ist_index
) {
1442 AVCodecContext
*enc
= ost
->st
->codec
;
1443 os
= output_files
[ost
->file_index
];
1445 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_AUDIO
&& enc
->frame_size
<=1)
1447 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
&& (os
->oformat
->flags
& AVFMT_RAWPICTURE
))
1450 if (ost
->encoding_needed
) {
1454 av_init_packet(&pkt
);
1455 pkt
.stream_index
= ost
->index
;
1457 switch(ost
->st
->codec
->codec_type
) {
1458 case CODEC_TYPE_AUDIO
:
1459 fifo_bytes
= av_fifo_size(&ost
->fifo
);
1461 /* encode any samples remaining in fifo */
1462 if(fifo_bytes
> 0 && enc
->codec
->capabilities
& CODEC_CAP_SMALL_LAST_FRAME
) {
1463 int fs_tmp
= enc
->frame_size
;
1464 enc
->frame_size
= fifo_bytes
/ (2 * enc
->channels
);
1465 av_fifo_read(&ost
->fifo
, (uint8_t *)samples
, fifo_bytes
);
1466 ret
= avcodec_encode_audio(enc
, bit_buffer
, bit_buffer_size
, samples
);
1467 enc
->frame_size
= fs_tmp
;
1470 ret
= avcodec_encode_audio(enc
, bit_buffer
, bit_buffer_size
, NULL
);
1473 fprintf(stderr
, "Audio encoding failed\n");
1477 pkt
.flags
|= PKT_FLAG_KEY
;
1479 case CODEC_TYPE_VIDEO
:
1480 ret
= avcodec_encode_video(enc
, bit_buffer
, bit_buffer_size
, NULL
);
1482 fprintf(stderr
, "Video encoding failed\n");
1486 if(enc
->coded_frame
&& enc
->coded_frame
->key_frame
)
1487 pkt
.flags
|= PKT_FLAG_KEY
;
1488 if (ost
->logfile
&& enc
->stats_out
) {
1489 fprintf(ost
->logfile
, "%s", enc
->stats_out
);
1498 pkt
.data
= bit_buffer
;
1500 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
1501 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
1502 write_frame(os
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
1514 static void print_sdp(AVFormatContext
**avc
, int n
)
1518 avf_sdp_create(avc
, n
, sdp
, sizeof(sdp
));
1519 printf("SDP:\n%s\n", sdp
);
1523 static int stream_index_from_inputs(AVFormatContext
**input_files
,
1525 AVInputFile
*file_table
,
1526 AVInputStream
**ist_table
,
1527 enum CodecType type
,
1531 for(z
=0; z
<nb_input_files
; z
++) {
1532 AVFormatContext
*ic
= input_files
[z
];
1533 for(p
=0; p
<ic
->nb_programs
; p
++) {
1534 AVProgram
*program
= ic
->programs
[p
];
1535 if(program
->id
!= programid
)
1537 for(q
=0; q
<program
->nb_stream_indexes
; q
++) {
1538 int sidx
= program
->stream_index
[q
];
1539 int ris
= file_table
[z
].ist_index
+ sidx
;
1540 if(ist_table
[ris
]->discard
&& ic
->streams
[sidx
]->codec
->codec_type
== type
)
1550 * The following code is the main loop of the file converter
1552 static int av_encode(AVFormatContext
**output_files
,
1553 int nb_output_files
,
1554 AVFormatContext
**input_files
,
1556 AVStreamMap
*stream_maps
, int nb_stream_maps
)
1558 int ret
, i
, j
, k
, n
, nb_istreams
= 0, nb_ostreams
= 0;
1559 AVFormatContext
*is
, *os
;
1560 AVCodecContext
*codec
, *icodec
;
1561 AVOutputStream
*ost
, **ost_table
= NULL
;
1562 AVInputStream
*ist
, **ist_table
= NULL
;
1563 AVInputFile
*file_table
;
1567 file_table
= av_mallocz(nb_input_files
* sizeof(AVInputFile
));
1571 /* input stream init */
1573 for(i
=0;i
<nb_input_files
;i
++) {
1574 is
= input_files
[i
];
1575 file_table
[i
].ist_index
= j
;
1576 file_table
[i
].nb_streams
= is
->nb_streams
;
1577 j
+= is
->nb_streams
;
1581 ist_table
= av_mallocz(nb_istreams
* sizeof(AVInputStream
*));
1585 for(i
=0;i
<nb_istreams
;i
++) {
1586 ist
= av_mallocz(sizeof(AVInputStream
));
1592 for(i
=0;i
<nb_input_files
;i
++) {
1593 is
= input_files
[i
];
1594 for(k
=0;k
<is
->nb_streams
;k
++) {
1595 ist
= ist_table
[j
++];
1596 ist
->st
= is
->streams
[k
];
1597 ist
->file_index
= i
;
1599 ist
->discard
= 1; /* the stream is discarded by default
1603 ist
->start
= av_gettime();
1608 /* output stream init */
1610 for(i
=0;i
<nb_output_files
;i
++) {
1611 os
= output_files
[i
];
1612 if (!os
->nb_streams
) {
1613 dump_format(output_files
[i
], i
, output_files
[i
]->filename
, 1);
1614 fprintf(stderr
, "Output file #%d does not contain any stream\n", i
);
1617 nb_ostreams
+= os
->nb_streams
;
1619 if (nb_stream_maps
> 0 && nb_stream_maps
!= nb_ostreams
) {
1620 fprintf(stderr
, "Number of stream maps must match number of output streams\n");
1624 /* Sanity check the mapping args -- do the input files & streams exist? */
1625 for(i
=0;i
<nb_stream_maps
;i
++) {
1626 int fi
= stream_maps
[i
].file_index
;
1627 int si
= stream_maps
[i
].stream_index
;
1629 if (fi
< 0 || fi
> nb_input_files
- 1 ||
1630 si
< 0 || si
> file_table
[fi
].nb_streams
- 1) {
1631 fprintf(stderr
,"Could not find input stream #%d.%d\n", fi
, si
);
1634 fi
= stream_maps
[i
].sync_file_index
;
1635 si
= stream_maps
[i
].sync_stream_index
;
1636 if (fi
< 0 || fi
> nb_input_files
- 1 ||
1637 si
< 0 || si
> file_table
[fi
].nb_streams
- 1) {
1638 fprintf(stderr
,"Could not find sync stream #%d.%d\n", fi
, si
);
1643 ost_table
= av_mallocz(sizeof(AVOutputStream
*) * nb_ostreams
);
1646 for(i
=0;i
<nb_ostreams
;i
++) {
1647 ost
= av_mallocz(sizeof(AVOutputStream
));
1654 for(k
=0;k
<nb_output_files
;k
++) {
1655 os
= output_files
[k
];
1656 for(i
=0;i
<os
->nb_streams
;i
++,n
++) {
1659 ost
->file_index
= k
;
1661 ost
->st
= os
->streams
[i
];
1662 if (nb_stream_maps
> 0) {
1663 ost
->source_index
= file_table
[stream_maps
[n
].file_index
].ist_index
+
1664 stream_maps
[n
].stream_index
;
1666 /* Sanity check that the stream types match */
1667 if (ist_table
[ost
->source_index
]->st
->codec
->codec_type
!= ost
->st
->codec
->codec_type
) {
1668 int i
= ost
->file_index
;
1669 dump_format(output_files
[i
], i
, output_files
[i
]->filename
, 1);
1670 fprintf(stderr
, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1671 stream_maps
[n
].file_index
, stream_maps
[n
].stream_index
,
1672 ost
->file_index
, ost
->index
);
1679 j
= stream_index_from_inputs(input_files
, nb_input_files
, file_table
, ist_table
, ost
->st
->codec
->codec_type
, opt_programid
);
1681 ost
->source_index
= j
;
1685 /* get corresponding input stream index : we select the first one with the right type */
1687 for(j
=0;j
<nb_istreams
;j
++) {
1690 ist
->st
->codec
->codec_type
== ost
->st
->codec
->codec_type
) {
1691 ost
->source_index
= j
;
1699 if(! opt_programid
) {
1700 /* try again and reuse existing stream */
1701 for(j
=0;j
<nb_istreams
;j
++) {
1703 if (ist
->st
->codec
->codec_type
== ost
->st
->codec
->codec_type
) {
1704 ost
->source_index
= j
;
1710 int i
= ost
->file_index
;
1711 dump_format(output_files
[i
], i
, output_files
[i
]->filename
, 1);
1712 fprintf(stderr
, "Could not find input stream matching output stream #%d.%d\n",
1713 ost
->file_index
, ost
->index
);
1718 ist
= ist_table
[ost
->source_index
];
1720 ost
->sync_ist
= (nb_stream_maps
> 0) ?
1721 ist_table
[file_table
[stream_maps
[n
].sync_file_index
].ist_index
+
1722 stream_maps
[n
].sync_stream_index
] : ist
;
1726 /* for each output stream, we compute the right encoding parameters */
1727 for(i
=0;i
<nb_ostreams
;i
++) {
1729 os
= output_files
[ost
->file_index
];
1730 ist
= ist_table
[ost
->source_index
];
1732 codec
= ost
->st
->codec
;
1733 icodec
= ist
->st
->codec
;
1735 if (!ost
->st
->language
[0])
1736 av_strlcpy(ost
->st
->language
, ist
->st
->language
,
1737 sizeof(ost
->st
->language
));
1739 ost
->st
->disposition
= ist
->st
->disposition
;
1741 if (ost
->st
->stream_copy
) {
1742 /* if stream_copy is selected, no need to decode or encode */
1743 codec
->codec_id
= icodec
->codec_id
;
1744 codec
->codec_type
= icodec
->codec_type
;
1746 if(!codec
->codec_tag
){
1747 if( !os
->oformat
->codec_tag
1748 || av_codec_get_id (os
->oformat
->codec_tag
, icodec
->codec_tag
) > 0
1749 || av_codec_get_tag(os
->oformat
->codec_tag
, icodec
->codec_id
) <= 0)
1750 codec
->codec_tag
= icodec
->codec_tag
;
1753 codec
->bit_rate
= icodec
->bit_rate
;
1754 codec
->extradata
= icodec
->extradata
;
1755 codec
->extradata_size
= icodec
->extradata_size
;
1756 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){
1757 codec
->time_base
= icodec
->time_base
;
1758 codec
->time_base
.num
*= icodec
->ticks_per_frame
;
1760 codec
->time_base
= ist
->st
->time_base
;
1761 switch(codec
->codec_type
) {
1762 case CODEC_TYPE_AUDIO
:
1763 if(audio_volume
!= 256) {
1764 fprintf(stderr
,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1767 codec
->channel_layout
= icodec
->channel_layout
;
1768 codec
->sample_rate
= icodec
->sample_rate
;
1769 codec
->channels
= icodec
->channels
;
1770 codec
->frame_size
= icodec
->frame_size
;
1771 codec
->block_align
= icodec
->block_align
;
1772 if(codec
->block_align
== 1 && codec
->codec_id
== CODEC_ID_MP3
)
1773 codec
->block_align
= 0;
1774 if(codec
->codec_id
== CODEC_ID_AC3
)
1775 codec
->block_align
= 0;
1777 case CODEC_TYPE_VIDEO
:
1779 fprintf(stderr
,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1782 codec
->pix_fmt
= icodec
->pix_fmt
;
1783 codec
->width
= icodec
->width
;
1784 codec
->height
= icodec
->height
;
1785 codec
->has_b_frames
= icodec
->has_b_frames
;
1787 case CODEC_TYPE_SUBTITLE
:
1788 codec
->width
= icodec
->width
;
1789 codec
->height
= icodec
->height
;
1795 switch(codec
->codec_type
) {
1796 case CODEC_TYPE_AUDIO
:
1797 if (av_fifo_init(&ost
->fifo
, 1024))
1799 ost
->reformat_pair
= MAKE_SFMT_PAIR(SAMPLE_FMT_NONE
,SAMPLE_FMT_NONE
);
1800 ost
->audio_resample
= codec
->sample_rate
!= icodec
->sample_rate
|| audio_sync_method
> 1;
1801 icodec
->request_channels
= codec
->channels
;
1802 ist
->decoding_needed
= 1;
1803 ost
->encoding_needed
= 1;
1805 case CODEC_TYPE_VIDEO
:
1806 ost
->video_crop
= ((frame_leftBand
+ frame_rightBand
+ frame_topBand
+ frame_bottomBand
) != 0);
1807 ost
->video_pad
= ((frame_padleft
+ frame_padright
+ frame_padtop
+ frame_padbottom
) != 0);
1808 ost
->video_resample
= ((codec
->width
!= icodec
->width
-
1809 (frame_leftBand
+ frame_rightBand
) +
1810 (frame_padleft
+ frame_padright
)) ||
1811 (codec
->height
!= icodec
->height
-
1812 (frame_topBand
+ frame_bottomBand
) +
1813 (frame_padtop
+ frame_padbottom
)) ||
1814 (codec
->pix_fmt
!= icodec
->pix_fmt
));
1815 if (ost
->video_crop
) {
1816 ost
->topBand
= frame_topBand
;
1817 ost
->leftBand
= frame_leftBand
;
1819 if (ost
->video_pad
) {
1820 ost
->padtop
= frame_padtop
;
1821 ost
->padleft
= frame_padleft
;
1822 ost
->padbottom
= frame_padbottom
;
1823 ost
->padright
= frame_padright
;
1824 if (!ost
->video_resample
) {
1825 avcodec_get_frame_defaults(&ost
->pict_tmp
);
1826 if(avpicture_alloc((AVPicture
*)&ost
->pict_tmp
, codec
->pix_fmt
,
1827 codec
->width
, codec
->height
))
1831 if (ost
->video_resample
) {
1832 avcodec_get_frame_defaults(&ost
->pict_tmp
);
1833 if(avpicture_alloc((AVPicture
*)&ost
->pict_tmp
, codec
->pix_fmt
,
1834 codec
->width
, codec
->height
)) {
1835 fprintf(stderr
, "Cannot allocate temp picture, check pix fmt\n");
1838 sws_flags
= av_get_int(sws_opts
, "sws_flags", NULL
);
1839 ost
->img_resample_ctx
= sws_getContext(
1840 icodec
->width
- (frame_leftBand
+ frame_rightBand
),
1841 icodec
->height
- (frame_topBand
+ frame_bottomBand
),
1843 codec
->width
- (frame_padleft
+ frame_padright
),
1844 codec
->height
- (frame_padtop
+ frame_padbottom
),
1846 sws_flags
, NULL
, NULL
, NULL
);
1847 if (ost
->img_resample_ctx
== NULL
) {
1848 fprintf(stderr
, "Cannot get resampling context\n");
1851 ost
->resample_height
= icodec
->height
- (frame_topBand
+ frame_bottomBand
);
1853 ost
->encoding_needed
= 1;
1854 ist
->decoding_needed
= 1;
1856 case CODEC_TYPE_SUBTITLE
:
1857 ost
->encoding_needed
= 1;
1858 ist
->decoding_needed
= 1;
1865 if (ost
->encoding_needed
&&
1866 (codec
->flags
& (CODEC_FLAG_PASS1
| CODEC_FLAG_PASS2
))) {
1867 char logfilename
[1024];
1872 snprintf(logfilename
, sizeof(logfilename
), "%s-%d.log",
1873 pass_logfilename_prefix
? pass_logfilename_prefix
: DEFAULT_PASS_LOGFILENAME_PREFIX
,
1875 if (codec
->flags
& CODEC_FLAG_PASS1
) {
1876 f
= fopen(logfilename
, "w");
1878 fprintf(stderr
, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename
, strerror(errno
));
1883 /* read the log file */
1884 f
= fopen(logfilename
, "r");
1886 fprintf(stderr
, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename
, strerror(errno
));
1889 fseek(f
, 0, SEEK_END
);
1891 fseek(f
, 0, SEEK_SET
);
1892 logbuffer
= av_malloc(size
+ 1);
1894 fprintf(stderr
, "Could not allocate log buffer\n");
1897 size
= fread(logbuffer
, 1, size
, f
);
1899 logbuffer
[size
] = '\0';
1900 codec
->stats_in
= logbuffer
;
1904 if(codec
->codec_type
== CODEC_TYPE_VIDEO
){
1905 int size
= codec
->width
* codec
->height
;
1906 bit_buffer_size
= FFMAX(bit_buffer_size
, 6*size
+ 200);
1911 bit_buffer
= av_malloc(bit_buffer_size
);
1915 /* dump the file output parameters - cannot be done before in case
1917 for(i
=0;i
<nb_output_files
;i
++) {
1918 dump_format(output_files
[i
], i
, output_files
[i
]->filename
, 1);
1921 /* dump the stream mapping */
1923 fprintf(stderr
, "Stream mapping:\n");
1924 for(i
=0;i
<nb_ostreams
;i
++) {
1926 fprintf(stderr
, " Stream #%d.%d -> #%d.%d",
1927 ist_table
[ost
->source_index
]->file_index
,
1928 ist_table
[ost
->source_index
]->index
,
1931 if (ost
->sync_ist
!= ist_table
[ost
->source_index
])
1932 fprintf(stderr
, " [sync #%d.%d]",
1933 ost
->sync_ist
->file_index
,
1934 ost
->sync_ist
->index
);
1935 fprintf(stderr
, "\n");
1939 /* open each encoder */
1940 for(i
=0;i
<nb_ostreams
;i
++) {
1942 if (ost
->encoding_needed
) {
1943 AVCodec
*codec
= output_codecs
[i
];
1945 codec
= avcodec_find_encoder(ost
->st
->codec
->codec_id
);
1947 fprintf(stderr
, "Unsupported codec for output stream #%d.%d\n",
1948 ost
->file_index
, ost
->index
);
1951 if (avcodec_open(ost
->st
->codec
, codec
) < 0) {
1952 fprintf(stderr
, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1953 ost
->file_index
, ost
->index
);
1956 extra_size
+= ost
->st
->codec
->extradata_size
;
1960 /* open each decoder */
1961 for(i
=0;i
<nb_istreams
;i
++) {
1963 if (ist
->decoding_needed
) {
1964 AVCodec
*codec
= input_codecs
[i
];
1966 codec
= avcodec_find_decoder(ist
->st
->codec
->codec_id
);
1968 fprintf(stderr
, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1969 ist
->st
->codec
->codec_id
, ist
->file_index
, ist
->index
);
1972 if (avcodec_open(ist
->st
->codec
, codec
) < 0) {
1973 fprintf(stderr
, "Error while opening codec for input stream #%d.%d\n",
1974 ist
->file_index
, ist
->index
);
1977 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1978 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1983 for(i
=0;i
<nb_istreams
;i
++) {
1985 is
= input_files
[ist
->file_index
];
1987 ist
->next_pts
= AV_NOPTS_VALUE
;
1991 /* set meta data information from input file if required */
1992 for (i
=0;i
<nb_meta_data_maps
;i
++) {
1993 AVFormatContext
*out_file
;
1994 AVFormatContext
*in_file
;
1996 int out_file_index
= meta_data_maps
[i
].out_file
;
1997 int in_file_index
= meta_data_maps
[i
].in_file
;
1998 if (out_file_index
< 0 || out_file_index
>= nb_output_files
) {
1999 fprintf(stderr
, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index
, out_file_index
, in_file_index
);
2000 ret
= AVERROR(EINVAL
);
2003 if (in_file_index
< 0 || in_file_index
>= nb_input_files
) {
2004 fprintf(stderr
, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index
, out_file_index
, in_file_index
);
2005 ret
= AVERROR(EINVAL
);
2009 out_file
= output_files
[out_file_index
];
2010 in_file
= input_files
[in_file_index
];
2012 strcpy(out_file
->title
, in_file
->title
);
2013 strcpy(out_file
->author
, in_file
->author
);
2014 strcpy(out_file
->copyright
, in_file
->copyright
);
2015 strcpy(out_file
->comment
, in_file
->comment
);
2016 strcpy(out_file
->album
, in_file
->album
);
2017 out_file
->year
= in_file
->year
;
2018 out_file
->track
= in_file
->track
;
2019 strcpy(out_file
->genre
, in_file
->genre
);
2022 /* open files and write file headers */
2023 for(i
=0;i
<nb_output_files
;i
++) {
2024 os
= output_files
[i
];
2025 if (av_write_header(os
) < 0) {
2026 fprintf(stderr
, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i
);
2027 ret
= AVERROR(EINVAL
);
2030 if (strcmp(output_files
[i
]->oformat
->name
, "rtp")) {
2035 print_sdp(output_files
, nb_output_files
);
2038 if (!using_stdin
&& verbose
>= 0) {
2039 fprintf(stderr
, "Press [q] to stop encoding\n");
2040 url_set_interrupt_cb(decode_interrupt_cb
);
2045 timer_start
= av_gettime();
2047 for(; received_sigterm
== 0;) {
2048 int file_index
, ist_index
;
2056 /* if 'q' pressed, exits */
2060 /* read_key() returns 0 on EOF */
2066 /* select the stream that we must read now by looking at the
2067 smallest output pts */
2069 for(i
=0;i
<nb_ostreams
;i
++) {
2072 os
= output_files
[ost
->file_index
];
2073 ist
= ist_table
[ost
->source_index
];
2074 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
)
2075 opts
= ost
->sync_opts
* av_q2d(ost
->st
->codec
->time_base
);
2077 opts
= ost
->st
->pts
.val
* av_q2d(ost
->st
->time_base
);
2078 ipts
= (double)ist
->pts
;
2079 if (!file_table
[ist
->file_index
].eof_reached
){
2080 if(ipts
< ipts_min
) {
2082 if(input_sync
) file_index
= ist
->file_index
;
2084 if(opts
< opts_min
) {
2086 if(!input_sync
) file_index
= ist
->file_index
;
2089 if(ost
->frame_number
>= max_frames
[ost
->st
->codec
->codec_type
]){
2094 /* if none, if is finished */
2095 if (file_index
< 0) {
2099 /* finish if recording time exhausted */
2100 if (opts_min
>= (recording_time
/ 1000000.0))
2103 /* finish if limit size exhausted */
2104 if (limit_filesize
!= 0 && limit_filesize
< url_ftell(output_files
[0]->pb
))
2107 /* read a frame from it and output it in the fifo */
2108 is
= input_files
[file_index
];
2109 ret
= av_read_frame(is
, &pkt
);
2110 if(ret
== AVERROR(EAGAIN
) && strcmp(is
->iformat
->name
, "ffm"))
2113 file_table
[file_index
].eof_reached
= 1;
2121 av_pkt_dump_log(NULL
, AV_LOG_DEBUG
, &pkt
, do_hex_dump
);
2123 /* the following test is needed in case new streams appear
2124 dynamically in stream : we ignore them */
2125 if (pkt
.stream_index
>= file_table
[file_index
].nb_streams
)
2126 goto discard_packet
;
2127 ist_index
= file_table
[file_index
].ist_index
+ pkt
.stream_index
;
2128 ist
= ist_table
[ist_index
];
2130 goto discard_packet
;
2132 if (pkt
.dts
!= AV_NOPTS_VALUE
)
2133 pkt
.dts
+= av_rescale_q(input_files_ts_offset
[ist
->file_index
], AV_TIME_BASE_Q
, ist
->st
->time_base
);
2134 if (pkt
.pts
!= AV_NOPTS_VALUE
)
2135 pkt
.pts
+= av_rescale_q(input_files_ts_offset
[ist
->file_index
], AV_TIME_BASE_Q
, ist
->st
->time_base
);
2137 if(input_files_ts_scale
[file_index
][pkt
.stream_index
]){
2138 if(pkt
.pts
!= AV_NOPTS_VALUE
)
2139 pkt
.pts
*= input_files_ts_scale
[file_index
][pkt
.stream_index
];
2140 if(pkt
.dts
!= AV_NOPTS_VALUE
)
2141 pkt
.dts
*= input_files_ts_scale
[file_index
][pkt
.stream_index
];
2144 // 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);
2145 if (pkt
.dts
!= AV_NOPTS_VALUE
&& ist
->next_pts
!= AV_NOPTS_VALUE
2146 && (is
->iformat
->flags
& AVFMT_TS_DISCONT
)) {
2147 int64_t pkt_dts
= av_rescale_q(pkt
.dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
2148 int64_t delta
= pkt_dts
- ist
->next_pts
;
2149 if((FFABS(delta
) > 1LL*dts_delta_threshold
*AV_TIME_BASE
|| pkt_dts
+1<ist
->pts
)&& !copy_ts
){
2150 input_files_ts_offset
[ist
->file_index
]-= delta
;
2152 fprintf(stderr
, "timestamp discontinuity %"PRId64
", new offset= %"PRId64
"\n", delta
, input_files_ts_offset
[ist
->file_index
]);
2153 pkt
.dts
-= av_rescale_q(delta
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
2154 if(pkt
.pts
!= AV_NOPTS_VALUE
)
2155 pkt
.pts
-= av_rescale_q(delta
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
2159 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2160 if (output_packet(ist
, ist_index
, ost_table
, nb_ostreams
, &pkt
) < 0) {
2163 fprintf(stderr
, "Error while decoding stream #%d.%d\n",
2164 ist
->file_index
, ist
->index
);
2167 av_free_packet(&pkt
);
2172 av_free_packet(&pkt
);
2174 /* dump report by using the output first video and audio streams */
2175 print_report(output_files
, ost_table
, nb_ostreams
, 0);
2178 /* at the end of stream, we must flush the decoder buffers */
2179 for(i
=0;i
<nb_istreams
;i
++) {
2181 if (ist
->decoding_needed
) {
2182 output_packet(ist
, i
, ost_table
, nb_ostreams
, NULL
);
2188 /* write the trailer if needed and close file */
2189 for(i
=0;i
<nb_output_files
;i
++) {
2190 os
= output_files
[i
];
2191 av_write_trailer(os
);
2194 /* dump report by using the first video and audio streams */
2195 print_report(output_files
, ost_table
, nb_ostreams
, 1);
2197 /* close each encoder */
2198 for(i
=0;i
<nb_ostreams
;i
++) {
2200 if (ost
->encoding_needed
) {
2201 av_freep(&ost
->st
->codec
->stats_in
);
2202 avcodec_close(ost
->st
->codec
);
2206 /* close each decoder */
2207 for(i
=0;i
<nb_istreams
;i
++) {
2209 if (ist
->decoding_needed
) {
2210 avcodec_close(ist
->st
->codec
);
2218 av_freep(&bit_buffer
);
2219 av_free(file_table
);
2222 for(i
=0;i
<nb_istreams
;i
++) {
2229 for(i
=0;i
<nb_ostreams
;i
++) {
2233 fclose(ost
->logfile
);
2234 ost
->logfile
= NULL
;
2236 av_fifo_free(&ost
->fifo
); /* works even if fifo is not
2237 initialized but set to zero */
2238 av_free(ost
->pict_tmp
.data
[0]);
2239 if (ost
->video_resample
)
2240 sws_freeContext(ost
->img_resample_ctx
);
2242 audio_resample_close(ost
->resample
);
2243 if (ost
->reformat_ctx
)
2244 av_audio_convert_free(ost
->reformat_ctx
);
2252 ret
= AVERROR(ENOMEM
);
2257 int file_read(const char *filename
)
2260 unsigned char buffer
[1024];
2263 if (url_open(&h
, filename
, O_RDONLY
) < 0) {
2264 printf("could not open '%s'\n", filename
);
2268 len
= url_read(h
, buffer
, sizeof(buffer
));
2271 for(i
=0;i
<len
;i
++) putchar(buffer
[i
]);
2278 static void opt_format(const char *arg
)
2280 /* compatibility stuff for pgmyuv */
2281 if (!strcmp(arg
, "pgmyuv")) {
2282 pgmyuv_compatibility_hack
=1;
2283 // opt_image_format(arg);
2285 fprintf(stderr
, "pgmyuv format is deprecated, use image2\n");
2288 file_iformat
= av_find_input_format(arg
);
2289 file_oformat
= guess_format(arg
, NULL
, NULL
);
2290 if (!file_iformat
&& !file_oformat
) {
2291 fprintf(stderr
, "Unknown input or output format: %s\n", arg
);
2296 static void opt_video_rc_override_string(const char *arg
)
2298 video_rc_override_string
= arg
;
2301 static int opt_me_threshold(const char *opt
, const char *arg
)
2303 me_threshold
= parse_number_or_die(opt
, arg
, OPT_INT64
, INT_MIN
, INT_MAX
);
2307 static int opt_verbose(const char *opt
, const char *arg
)
2309 verbose
= parse_number_or_die(opt
, arg
, OPT_INT64
, -10, 10);
2310 av_log_set_level(verbose
);
2314 static int opt_frame_rate(const char *opt
, const char *arg
)
2316 if (av_parse_video_frame_rate(&frame_rate
, arg
) < 0) {
2317 fprintf(stderr
, "Incorrect value for %s: %s\n", opt
, arg
);
2323 static int opt_bitrate(const char *opt
, const char *arg
)
2325 int codec_type
= opt
[0]=='a' ? CODEC_TYPE_AUDIO
: CODEC_TYPE_VIDEO
;
2327 opt_default(opt
, arg
);
2329 if (av_get_int(avctx_opts
[codec_type
], "b", NULL
) < 1000)
2330 fprintf(stderr
, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2335 static void opt_frame_crop_top(const char *arg
)
2337 frame_topBand
= atoi(arg
);
2338 if (frame_topBand
< 0) {
2339 fprintf(stderr
, "Incorrect top crop size\n");
2342 if ((frame_topBand
% 2) != 0) {
2343 fprintf(stderr
, "Top crop size must be a multiple of 2\n");
2346 if ((frame_topBand
) >= frame_height
){
2347 fprintf(stderr
, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2350 frame_height
-= frame_topBand
;
2353 static void opt_frame_crop_bottom(const char *arg
)
2355 frame_bottomBand
= atoi(arg
);
2356 if (frame_bottomBand
< 0) {
2357 fprintf(stderr
, "Incorrect bottom crop size\n");
2360 if ((frame_bottomBand
% 2) != 0) {
2361 fprintf(stderr
, "Bottom crop size must be a multiple of 2\n");
2364 if ((frame_bottomBand
) >= frame_height
){
2365 fprintf(stderr
, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2368 frame_height
-= frame_bottomBand
;
2371 static void opt_frame_crop_left(const char *arg
)
2373 frame_leftBand
= atoi(arg
);
2374 if (frame_leftBand
< 0) {
2375 fprintf(stderr
, "Incorrect left crop size\n");
2378 if ((frame_leftBand
% 2) != 0) {
2379 fprintf(stderr
, "Left crop size must be a multiple of 2\n");
2382 if ((frame_leftBand
) >= frame_width
){
2383 fprintf(stderr
, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2386 frame_width
-= frame_leftBand
;
2389 static void opt_frame_crop_right(const char *arg
)
2391 frame_rightBand
= atoi(arg
);
2392 if (frame_rightBand
< 0) {
2393 fprintf(stderr
, "Incorrect right crop size\n");
2396 if ((frame_rightBand
% 2) != 0) {
2397 fprintf(stderr
, "Right crop size must be a multiple of 2\n");
2400 if ((frame_rightBand
) >= frame_width
){
2401 fprintf(stderr
, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2404 frame_width
-= frame_rightBand
;
2407 static void opt_frame_size(const char *arg
)
2409 if (av_parse_video_frame_size(&frame_width
, &frame_height
, arg
) < 0) {
2410 fprintf(stderr
, "Incorrect frame size\n");
2413 if ((frame_width
% 2) != 0 || (frame_height
% 2) != 0) {
2414 fprintf(stderr
, "Frame size must be a multiple of 2\n");
2420 #define SCALEBITS 10
2421 #define ONE_HALF (1 << (SCALEBITS - 1))
2422 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2424 #define RGB_TO_Y(r, g, b) \
2425 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2426 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2428 #define RGB_TO_U(r1, g1, b1, shift)\
2429 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2430 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2432 #define RGB_TO_V(r1, g1, b1, shift)\
2433 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2434 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2436 static void opt_pad_color(const char *arg
) {
2437 /* Input is expected to be six hex digits similar to
2438 how colors are expressed in html tags (but without the #) */
2439 int rgb
= strtol(arg
, NULL
, 16);
2443 g
= ((rgb
>> 8) & 255);
2446 padcolor
[0] = RGB_TO_Y(r
,g
,b
);
2447 padcolor
[1] = RGB_TO_U(r
,g
,b
,0);
2448 padcolor
[2] = RGB_TO_V(r
,g
,b
,0);
2451 static void opt_frame_pad_top(const char *arg
)
2453 frame_padtop
= atoi(arg
);
2454 if (frame_padtop
< 0) {
2455 fprintf(stderr
, "Incorrect top pad size\n");
2458 if ((frame_padtop
% 2) != 0) {
2459 fprintf(stderr
, "Top pad size must be a multiple of 2\n");
2464 static void opt_frame_pad_bottom(const char *arg
)
2466 frame_padbottom
= atoi(arg
);
2467 if (frame_padbottom
< 0) {
2468 fprintf(stderr
, "Incorrect bottom pad size\n");
2471 if ((frame_padbottom
% 2) != 0) {
2472 fprintf(stderr
, "Bottom pad size must be a multiple of 2\n");
2478 static void opt_frame_pad_left(const char *arg
)
2480 frame_padleft
= atoi(arg
);
2481 if (frame_padleft
< 0) {
2482 fprintf(stderr
, "Incorrect left pad size\n");
2485 if ((frame_padleft
% 2) != 0) {
2486 fprintf(stderr
, "Left pad size must be a multiple of 2\n");
2492 static void opt_frame_pad_right(const char *arg
)
2494 frame_padright
= atoi(arg
);
2495 if (frame_padright
< 0) {
2496 fprintf(stderr
, "Incorrect right pad size\n");
2499 if ((frame_padright
% 2) != 0) {
2500 fprintf(stderr
, "Right pad size must be a multiple of 2\n");
2505 static void list_fmts(void (*get_fmt_string
)(char *buf
, int buf_size
, int fmt
), int nb_fmts
)
2509 for (i
=-1; i
< nb_fmts
; i
++) {
2510 get_fmt_string (fmt_str
, sizeof(fmt_str
), i
);
2511 fprintf(stdout
, "%s\n", fmt_str
);
2515 static void opt_frame_pix_fmt(const char *arg
)
2517 if (strcmp(arg
, "list"))
2518 frame_pix_fmt
= avcodec_get_pix_fmt(arg
);
2520 list_fmts(avcodec_pix_fmt_string
, PIX_FMT_NB
);
2525 static void opt_frame_aspect_ratio(const char *arg
)
2532 p
= strchr(arg
, ':');
2534 x
= strtol(arg
, &end
, 10);
2536 y
= strtol(end
+1, &end
, 10);
2538 ar
= (double)x
/ (double)y
;
2540 ar
= strtod(arg
, NULL
);
2543 fprintf(stderr
, "Incorrect aspect ratio specification.\n");
2546 frame_aspect_ratio
= ar
;
2549 static void opt_qscale(const char *arg
)
2551 video_qscale
= atof(arg
);
2552 if (video_qscale
<= 0 ||
2553 video_qscale
> 255) {
2554 fprintf(stderr
, "qscale must be > 0.0 and <= 255\n");
2559 static void opt_top_field_first(const char *arg
)
2561 top_field_first
= atoi(arg
);
2564 static int opt_thread_count(const char *opt
, const char *arg
)
2566 thread_count
= parse_number_or_die(opt
, arg
, OPT_INT64
, 0, INT_MAX
);
2569 fprintf(stderr
, "Warning: not compiled with thread support, using thread emulation\n");
2574 static void opt_audio_sample_fmt(const char *arg
)
2576 if (strcmp(arg
, "list"))
2577 audio_sample_fmt
= avcodec_get_sample_fmt(arg
);
2579 list_fmts(avcodec_sample_fmt_string
, SAMPLE_FMT_NB
);
2584 static int opt_audio_rate(const char *opt
, const char *arg
)
2586 audio_sample_rate
= parse_number_or_die(opt
, arg
, OPT_INT64
, 0, INT_MAX
);
2590 static int opt_audio_channels(const char *opt
, const char *arg
)
2592 audio_channels
= parse_number_or_die(opt
, arg
, OPT_INT64
, 0, INT_MAX
);
2596 static void opt_video_channel(const char *arg
)
2598 video_channel
= strtol(arg
, NULL
, 0);
2601 static void opt_video_standard(const char *arg
)
2603 video_standard
= av_strdup(arg
);
2606 static void opt_codec(int *pstream_copy
, char **pcodec_name
,
2607 int codec_type
, const char *arg
)
2609 av_freep(pcodec_name
);
2610 if (!strcmp(arg
, "copy")) {
2613 *pcodec_name
= av_strdup(arg
);
2617 static void opt_audio_codec(const char *arg
)
2619 opt_codec(&audio_stream_copy
, &audio_codec_name
, CODEC_TYPE_AUDIO
, arg
);
2622 static void opt_audio_tag(const char *arg
)
2625 audio_codec_tag
= strtol(arg
, &tail
, 0);
2628 audio_codec_tag
= arg
[0] + (arg
[1]<<8) + (arg
[2]<<16) + (arg
[3]<<24);
2631 static void opt_video_tag(const char *arg
)
2634 video_codec_tag
= strtol(arg
, &tail
, 0);
2637 video_codec_tag
= arg
[0] + (arg
[1]<<8) + (arg
[2]<<16) + (arg
[3]<<24);
2641 static void add_frame_hooker(const char *arg
)
2646 char *args
= av_strdup(arg
);
2650 argv
[0] = strtok(args
, " ");
2651 while (argc
< 62 && (argv
[++argc
] = strtok(NULL
, " "))) {
2654 i
= frame_hook_add(argc
, argv
);
2657 fprintf(stderr
, "Failed to add video hook function: %s\n", arg
);
2663 static void opt_video_codec(const char *arg
)
2665 opt_codec(&video_stream_copy
, &video_codec_name
, CODEC_TYPE_VIDEO
, arg
);
2668 static void opt_subtitle_codec(const char *arg
)
2670 opt_codec(&subtitle_stream_copy
, &subtitle_codec_name
, CODEC_TYPE_SUBTITLE
, arg
);
2673 static void opt_map(const char *arg
)
2678 m
= &stream_maps
[nb_stream_maps
++];
2680 m
->file_index
= strtol(arg
, &p
, 0);
2684 m
->stream_index
= strtol(p
, &p
, 0);
2687 m
->sync_file_index
= strtol(p
, &p
, 0);
2690 m
->sync_stream_index
= strtol(p
, &p
, 0);
2692 m
->sync_file_index
= m
->file_index
;
2693 m
->sync_stream_index
= m
->stream_index
;
2697 static void opt_map_meta_data(const char *arg
)
2702 m
= &meta_data_maps
[nb_meta_data_maps
++];
2704 m
->out_file
= strtol(arg
, &p
, 0);
2708 m
->in_file
= strtol(p
, &p
, 0);
2711 static void opt_input_ts_scale(const char *arg
)
2713 unsigned int stream
;
2717 stream
= strtol(arg
, &p
, 0);
2720 scale
= strtod(p
, &p
);
2722 if(stream
>= MAX_STREAMS
)
2725 input_files_ts_scale
[nb_input_files
][stream
]= scale
;
2728 static int opt_recording_time(const char *opt
, const char *arg
)
2730 recording_time
= parse_time_or_die(opt
, arg
, 1);
2734 static int opt_start_time(const char *opt
, const char *arg
)
2736 start_time
= parse_time_or_die(opt
, arg
, 1);
2740 static int opt_rec_timestamp(const char *opt
, const char *arg
)
2742 rec_timestamp
= parse_time_or_die(opt
, arg
, 0) / 1000000;
2746 static int opt_input_ts_offset(const char *opt
, const char *arg
)
2748 input_ts_offset
= parse_time_or_die(opt
, arg
, 1);
2752 static enum CodecID
find_codec_or_die(const char *name
, int type
, int encoder
)
2754 const char *codec_string
= encoder
? "encoder" : "decoder";
2758 return CODEC_ID_NONE
;
2760 avcodec_find_encoder_by_name(name
) :
2761 avcodec_find_decoder_by_name(name
);
2763 fprintf(stderr
, "Unknown %s '%s'\n", codec_string
, name
);
2766 if(codec
->type
!= type
) {
2767 fprintf(stderr
, "Invalid %s type '%s'\n", codec_string
, name
);
2773 static void opt_input_file(const char *filename
)
2775 AVFormatContext
*ic
;
2776 AVFormatParameters params
, *ap
= ¶ms
;
2777 int err
, i
, ret
, rfps
, rfps_base
;
2780 if (!strcmp(filename
, "-"))
2783 using_stdin
|= !strncmp(filename
, "pipe:", 5) ||
2784 !strcmp(filename
, "/dev/stdin");
2786 /* get default parameters from command line */
2787 ic
= avformat_alloc_context();
2789 memset(ap
, 0, sizeof(*ap
));
2790 ap
->prealloced_context
= 1;
2791 ap
->sample_rate
= audio_sample_rate
;
2792 ap
->channels
= audio_channels
;
2793 ap
->time_base
.den
= frame_rate
.num
;
2794 ap
->time_base
.num
= frame_rate
.den
;
2795 ap
->width
= frame_width
+ frame_padleft
+ frame_padright
;
2796 ap
->height
= frame_height
+ frame_padtop
+ frame_padbottom
;
2797 ap
->pix_fmt
= frame_pix_fmt
;
2798 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2799 ap
->channel
= video_channel
;
2800 ap
->standard
= video_standard
;
2801 ap
->video_codec_id
= find_codec_or_die(video_codec_name
, CODEC_TYPE_VIDEO
, 0);
2802 ap
->audio_codec_id
= find_codec_or_die(audio_codec_name
, CODEC_TYPE_AUDIO
, 0);
2803 if(pgmyuv_compatibility_hack
)
2804 ap
->video_codec_id
= CODEC_ID_PGMYUV
;
2806 set_context_opts(ic
, avformat_opts
, AV_OPT_FLAG_DECODING_PARAM
);
2808 ic
->video_codec_id
= find_codec_or_die(video_codec_name
, CODEC_TYPE_VIDEO
, 0);
2809 ic
->audio_codec_id
= find_codec_or_die(audio_codec_name
, CODEC_TYPE_AUDIO
, 0);
2810 ic
->subtitle_codec_id
= find_codec_or_die(subtitle_codec_name
, CODEC_TYPE_SUBTITLE
, 0);
2812 /* open the input file with generic libav function */
2813 err
= av_open_input_file(&ic
, filename
, file_iformat
, 0, ap
);
2815 print_error(filename
, err
);
2820 for(i
=0; i
<ic
->nb_programs
; i
++)
2821 if(ic
->programs
[i
]->id
!= opt_programid
)
2822 ic
->programs
[i
]->discard
= AVDISCARD_ALL
;
2825 ic
->loop_input
= loop_input
;
2827 /* If not enough info to get the stream parameters, we decode the
2828 first frames to get it. (used in mpeg case for example) */
2829 ret
= av_find_stream_info(ic
);
2830 if (ret
< 0 && verbose
>= 0) {
2831 fprintf(stderr
, "%s: could not find codec parameters\n", filename
);
2835 timestamp
= start_time
;
2836 /* add the stream start time */
2837 if (ic
->start_time
!= AV_NOPTS_VALUE
)
2838 timestamp
+= ic
->start_time
;
2840 /* if seeking requested, we execute it */
2841 if (start_time
!= 0) {
2842 ret
= av_seek_frame(ic
, -1, timestamp
, AVSEEK_FLAG_BACKWARD
);
2844 fprintf(stderr
, "%s: could not seek to position %0.3f\n",
2845 filename
, (double)timestamp
/ AV_TIME_BASE
);
2847 /* reset seek info */
2851 /* update the current parameters so that they match the one of the input stream */
2852 for(i
=0;i
<ic
->nb_streams
;i
++) {
2853 AVCodecContext
*enc
= ic
->streams
[i
]->codec
;
2855 avcodec_thread_init(enc
, thread_count
);
2856 enc
->thread_count
= thread_count
;
2857 switch(enc
->codec_type
) {
2858 case CODEC_TYPE_AUDIO
:
2859 set_context_opts(enc
, avctx_opts
[CODEC_TYPE_AUDIO
], AV_OPT_FLAG_AUDIO_PARAM
| AV_OPT_FLAG_DECODING_PARAM
);
2860 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2861 channel_layout
= enc
->channel_layout
;
2862 audio_channels
= enc
->channels
;
2863 audio_sample_rate
= enc
->sample_rate
;
2864 audio_sample_fmt
= enc
->sample_fmt
;
2865 input_codecs
[nb_icodecs
++] = avcodec_find_decoder_by_name(audio_codec_name
);
2867 ic
->streams
[i
]->discard
= AVDISCARD_ALL
;
2869 case CODEC_TYPE_VIDEO
:
2870 set_context_opts(enc
, avctx_opts
[CODEC_TYPE_VIDEO
], AV_OPT_FLAG_VIDEO_PARAM
| AV_OPT_FLAG_DECODING_PARAM
);
2871 frame_height
= enc
->height
;
2872 frame_width
= enc
->width
;
2873 if(ic
->streams
[i
]->sample_aspect_ratio
.num
)
2874 frame_aspect_ratio
=av_q2d(ic
->streams
[i
]->sample_aspect_ratio
);
2876 frame_aspect_ratio
=av_q2d(enc
->sample_aspect_ratio
);
2877 frame_aspect_ratio
*= (float) enc
->width
/ enc
->height
;
2878 frame_pix_fmt
= enc
->pix_fmt
;
2879 rfps
= ic
->streams
[i
]->r_frame_rate
.num
;
2880 rfps_base
= ic
->streams
[i
]->r_frame_rate
.den
;
2881 if(enc
->lowres
) enc
->flags
|= CODEC_FLAG_EMU_EDGE
;
2883 enc
->debug
|= FF_DEBUG_MV
;
2885 if (enc
->time_base
.den
!= rfps
|| enc
->time_base
.num
!= rfps_base
) {
2888 fprintf(stderr
,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2889 i
, (float)enc
->time_base
.den
/ enc
->time_base
.num
, enc
->time_base
.den
, enc
->time_base
.num
,
2891 (float)rfps
/ rfps_base
, rfps
, rfps_base
);
2893 /* update the current frame rate to match the stream frame rate */
2894 frame_rate
.num
= rfps
;
2895 frame_rate
.den
= rfps_base
;
2897 input_codecs
[nb_icodecs
++] = avcodec_find_decoder_by_name(video_codec_name
);
2899 ic
->streams
[i
]->discard
= AVDISCARD_ALL
;
2900 else if(video_discard
)
2901 ic
->streams
[i
]->discard
= video_discard
;
2903 case CODEC_TYPE_DATA
:
2905 case CODEC_TYPE_SUBTITLE
:
2906 input_codecs
[nb_icodecs
++] = avcodec_find_decoder_by_name(subtitle_codec_name
);
2907 if(subtitle_disable
)
2908 ic
->streams
[i
]->discard
= AVDISCARD_ALL
;
2910 case CODEC_TYPE_ATTACHMENT
:
2911 case CODEC_TYPE_UNKNOWN
:
2919 input_files
[nb_input_files
] = ic
;
2920 input_files_ts_offset
[nb_input_files
] = input_ts_offset
- (copy_ts
? 0 : timestamp
);
2921 /* dump the file content */
2923 dump_format(ic
, nb_input_files
, filename
, 0);
2926 file_iformat
= NULL
;
2927 file_oformat
= NULL
;
2931 av_freep(&video_codec_name
);
2932 av_freep(&audio_codec_name
);
2933 av_freep(&subtitle_codec_name
);
2936 static void check_audio_video_sub_inputs(int *has_video_ptr
, int *has_audio_ptr
,
2937 int *has_subtitle_ptr
)
2939 int has_video
, has_audio
, has_subtitle
, i
, j
;
2940 AVFormatContext
*ic
;
2945 for(j
=0;j
<nb_input_files
;j
++) {
2946 ic
= input_files
[j
];
2947 for(i
=0;i
<ic
->nb_streams
;i
++) {
2948 AVCodecContext
*enc
= ic
->streams
[i
]->codec
;
2949 switch(enc
->codec_type
) {
2950 case CODEC_TYPE_AUDIO
:
2953 case CODEC_TYPE_VIDEO
:
2956 case CODEC_TYPE_SUBTITLE
:
2959 case CODEC_TYPE_DATA
:
2960 case CODEC_TYPE_ATTACHMENT
:
2961 case CODEC_TYPE_UNKNOWN
:
2968 *has_video_ptr
= has_video
;
2969 *has_audio_ptr
= has_audio
;
2970 *has_subtitle_ptr
= has_subtitle
;
2973 static void new_video_stream(AVFormatContext
*oc
)
2976 AVCodecContext
*video_enc
;
2979 st
= av_new_stream(oc
, oc
->nb_streams
);
2981 fprintf(stderr
, "Could not alloc stream\n");
2984 avcodec_get_context_defaults2(st
->codec
, CODEC_TYPE_VIDEO
);
2985 bitstream_filters
[nb_output_files
][oc
->nb_streams
- 1]= video_bitstream_filters
;
2986 video_bitstream_filters
= NULL
;
2989 avcodec_thread_init(st
->codec
, thread_count
);
2991 video_enc
= st
->codec
;
2994 video_enc
->codec_tag
= video_codec_tag
;
2996 if( (video_global_header
&1)
2997 || (video_global_header
==0 && (oc
->oformat
->flags
& AVFMT_GLOBALHEADER
))){
2998 video_enc
->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
2999 avctx_opts
[CODEC_TYPE_VIDEO
]->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
3001 if(video_global_header
&2){
3002 video_enc
->flags2
|= CODEC_FLAG2_LOCAL_HEADER
;
3003 avctx_opts
[CODEC_TYPE_VIDEO
]->flags2
|= CODEC_FLAG2_LOCAL_HEADER
;
3006 if (video_stream_copy
) {
3007 st
->stream_copy
= 1;
3008 video_enc
->codec_type
= CODEC_TYPE_VIDEO
;
3009 video_enc
->sample_aspect_ratio
=
3010 st
->sample_aspect_ratio
= av_d2q(frame_aspect_ratio
*frame_height
/frame_width
, 255);
3015 AVRational fps
= frame_rate
.num
? frame_rate
: (AVRational
){25,1};
3017 if (video_codec_name
) {
3018 codec_id
= find_codec_or_die(video_codec_name
, CODEC_TYPE_VIDEO
, 1);
3019 codec
= avcodec_find_encoder_by_name(video_codec_name
);
3020 output_codecs
[nb_ocodecs
] = codec
;
3022 codec_id
= av_guess_codec(oc
->oformat
, NULL
, oc
->filename
, NULL
, CODEC_TYPE_VIDEO
);
3023 codec
= avcodec_find_encoder(codec_id
);
3026 video_enc
->codec_id
= codec_id
;
3028 set_context_opts(video_enc
, avctx_opts
[CODEC_TYPE_VIDEO
], AV_OPT_FLAG_VIDEO_PARAM
| AV_OPT_FLAG_ENCODING_PARAM
);
3030 if (codec
&& codec
->supported_framerates
&& !force_fps
)
3031 fps
= codec
->supported_framerates
[av_find_nearest_q_idx(fps
, codec
->supported_framerates
)];
3032 video_enc
->time_base
.den
= fps
.num
;
3033 video_enc
->time_base
.num
= fps
.den
;
3035 video_enc
->width
= frame_width
+ frame_padright
+ frame_padleft
;
3036 video_enc
->height
= frame_height
+ frame_padtop
+ frame_padbottom
;
3037 video_enc
->sample_aspect_ratio
= av_d2q(frame_aspect_ratio
*video_enc
->height
/video_enc
->width
, 255);
3038 video_enc
->pix_fmt
= frame_pix_fmt
;
3039 st
->sample_aspect_ratio
= video_enc
->sample_aspect_ratio
;
3041 if(codec
&& codec
->pix_fmts
){
3042 const enum PixelFormat
*p
= codec
->pix_fmts
;
3044 if(*p
== video_enc
->pix_fmt
)
3048 video_enc
->pix_fmt
= codec
->pix_fmts
[0];
3052 video_enc
->gop_size
= 0;
3053 if (video_qscale
|| same_quality
) {
3054 video_enc
->flags
|= CODEC_FLAG_QSCALE
;
3055 video_enc
->global_quality
=
3056 st
->quality
= FF_QP2LAMBDA
* video_qscale
;
3060 video_enc
->intra_matrix
= intra_matrix
;
3062 video_enc
->inter_matrix
= inter_matrix
;
3064 video_enc
->thread_count
= thread_count
;
3065 p
= video_rc_override_string
;
3068 int e
=sscanf(p
, "%d,%d,%d", &start
, &end
, &q
);
3070 fprintf(stderr
, "error parsing rc_override\n");
3073 video_enc
->rc_override
=
3074 av_realloc(video_enc
->rc_override
,
3075 sizeof(RcOverride
)*(i
+1));
3076 video_enc
->rc_override
[i
].start_frame
= start
;
3077 video_enc
->rc_override
[i
].end_frame
= end
;
3079 video_enc
->rc_override
[i
].qscale
= q
;
3080 video_enc
->rc_override
[i
].quality_factor
= 1.0;
3083 video_enc
->rc_override
[i
].qscale
= 0;
3084 video_enc
->rc_override
[i
].quality_factor
= -q
/100.0;
3089 video_enc
->rc_override_count
=i
;
3090 if (!video_enc
->rc_initial_buffer_occupancy
)
3091 video_enc
->rc_initial_buffer_occupancy
= video_enc
->rc_buffer_size
*3/4;
3092 video_enc
->me_threshold
= me_threshold
;
3093 video_enc
->intra_dc_precision
= intra_dc_precision
- 8;
3096 video_enc
->flags
|= CODEC_FLAG_PSNR
;
3101 video_enc
->flags
|= CODEC_FLAG_PASS1
;
3103 video_enc
->flags
|= CODEC_FLAG_PASS2
;
3109 /* reset some key parameters */
3111 av_freep(&video_codec_name
);
3112 video_stream_copy
= 0;
3115 static void new_audio_stream(AVFormatContext
*oc
)
3118 AVCodecContext
*audio_enc
;
3121 st
= av_new_stream(oc
, oc
->nb_streams
);
3123 fprintf(stderr
, "Could not alloc stream\n");
3126 avcodec_get_context_defaults2(st
->codec
, CODEC_TYPE_AUDIO
);
3128 bitstream_filters
[nb_output_files
][oc
->nb_streams
- 1]= audio_bitstream_filters
;
3129 audio_bitstream_filters
= NULL
;
3132 avcodec_thread_init(st
->codec
, thread_count
);
3134 audio_enc
= st
->codec
;
3135 audio_enc
->codec_type
= CODEC_TYPE_AUDIO
;
3138 audio_enc
->codec_tag
= audio_codec_tag
;
3140 if (oc
->oformat
->flags
& AVFMT_GLOBALHEADER
) {
3141 audio_enc
->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
3142 avctx_opts
[CODEC_TYPE_AUDIO
]->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
3144 if (audio_stream_copy
) {
3145 st
->stream_copy
= 1;
3146 audio_enc
->channels
= audio_channels
;
3150 set_context_opts(audio_enc
, avctx_opts
[CODEC_TYPE_AUDIO
], AV_OPT_FLAG_AUDIO_PARAM
| AV_OPT_FLAG_ENCODING_PARAM
);
3152 if (audio_codec_name
) {
3153 codec_id
= find_codec_or_die(audio_codec_name
, CODEC_TYPE_AUDIO
, 1);
3154 codec
= avcodec_find_encoder_by_name(audio_codec_name
);
3155 output_codecs
[nb_ocodecs
] = codec
;
3157 codec_id
= av_guess_codec(oc
->oformat
, NULL
, oc
->filename
, NULL
, CODEC_TYPE_AUDIO
);
3158 codec
= avcodec_find_encoder(codec_id
);
3160 audio_enc
->codec_id
= codec_id
;
3162 if (audio_qscale
> QSCALE_NONE
) {
3163 audio_enc
->flags
|= CODEC_FLAG_QSCALE
;
3164 audio_enc
->global_quality
= st
->quality
= FF_QP2LAMBDA
* audio_qscale
;
3166 audio_enc
->thread_count
= thread_count
;
3167 audio_enc
->channels
= audio_channels
;
3168 audio_enc
->sample_fmt
= audio_sample_fmt
;
3169 audio_enc
->channel_layout
= channel_layout
;
3171 if(codec
&& codec
->sample_fmts
){
3172 const enum SampleFormat
*p
= codec
->sample_fmts
;
3174 if(*p
== audio_enc
->sample_fmt
)
3178 audio_enc
->sample_fmt
= codec
->sample_fmts
[0];
3182 audio_enc
->sample_rate
= audio_sample_rate
;
3183 audio_enc
->time_base
= (AVRational
){1, audio_sample_rate
};
3184 if (audio_language
) {
3185 av_strlcpy(st
->language
, audio_language
, sizeof(st
->language
));
3186 av_free(audio_language
);
3187 audio_language
= NULL
;
3190 /* reset some key parameters */
3192 av_freep(&audio_codec_name
);
3193 audio_stream_copy
= 0;
3196 static void new_subtitle_stream(AVFormatContext
*oc
)
3199 AVCodecContext
*subtitle_enc
;
3201 st
= av_new_stream(oc
, oc
->nb_streams
);
3203 fprintf(stderr
, "Could not alloc stream\n");
3206 avcodec_get_context_defaults2(st
->codec
, CODEC_TYPE_SUBTITLE
);
3208 bitstream_filters
[nb_output_files
][oc
->nb_streams
- 1]= subtitle_bitstream_filters
;
3209 subtitle_bitstream_filters
= NULL
;
3211 subtitle_enc
= st
->codec
;
3212 subtitle_enc
->codec_type
= CODEC_TYPE_SUBTITLE
;
3213 if (subtitle_stream_copy
) {
3214 st
->stream_copy
= 1;
3216 set_context_opts(avctx_opts
[CODEC_TYPE_SUBTITLE
], subtitle_enc
, AV_OPT_FLAG_SUBTITLE_PARAM
| AV_OPT_FLAG_ENCODING_PARAM
);
3217 subtitle_enc
->codec_id
= find_codec_or_die(subtitle_codec_name
, CODEC_TYPE_SUBTITLE
, 1);
3218 output_codecs
[nb_ocodecs
] = avcodec_find_encoder_by_name(subtitle_codec_name
);
3222 if (subtitle_language
) {
3223 av_strlcpy(st
->language
, subtitle_language
, sizeof(st
->language
));
3224 av_free(subtitle_language
);
3225 subtitle_language
= NULL
;
3228 subtitle_disable
= 0;
3229 av_freep(&subtitle_codec_name
);
3230 subtitle_stream_copy
= 0;
3233 static void opt_new_audio_stream(void)
3235 AVFormatContext
*oc
;
3236 if (nb_output_files
<= 0) {
3237 fprintf(stderr
, "At least one output file must be specified\n");
3240 oc
= output_files
[nb_output_files
- 1];
3241 new_audio_stream(oc
);
3244 static void opt_new_video_stream(void)
3246 AVFormatContext
*oc
;
3247 if (nb_output_files
<= 0) {
3248 fprintf(stderr
, "At least one output file must be specified\n");
3251 oc
= output_files
[nb_output_files
- 1];
3252 new_video_stream(oc
);
3255 static void opt_new_subtitle_stream(void)
3257 AVFormatContext
*oc
;
3258 if (nb_output_files
<= 0) {
3259 fprintf(stderr
, "At least one output file must be specified\n");
3262 oc
= output_files
[nb_output_files
- 1];
3263 new_subtitle_stream(oc
);
3266 static void opt_output_file(const char *filename
)
3268 AVFormatContext
*oc
;
3269 int use_video
, use_audio
, use_subtitle
;
3270 int input_has_video
, input_has_audio
, input_has_subtitle
;
3271 AVFormatParameters params
, *ap
= ¶ms
;
3273 if (!strcmp(filename
, "-"))
3276 oc
= avformat_alloc_context();
3278 if (!file_oformat
) {
3279 file_oformat
= guess_format(NULL
, filename
, NULL
);
3280 if (!file_oformat
) {
3281 fprintf(stderr
, "Unable to find a suitable output format for '%s'\n",
3287 oc
->oformat
= file_oformat
;
3288 av_strlcpy(oc
->filename
, filename
, sizeof(oc
->filename
));
3290 if (!strcmp(file_oformat
->name
, "ffm") &&
3291 av_strstart(filename
, "http:", NULL
)) {
3292 /* special case for files sent to ffserver: we get the stream
3293 parameters from ffserver */
3294 int err
= read_ffserver_streams(oc
, filename
);
3296 print_error(filename
, err
);
3300 use_video
= file_oformat
->video_codec
!= CODEC_ID_NONE
|| video_stream_copy
|| video_codec_name
;
3301 use_audio
= file_oformat
->audio_codec
!= CODEC_ID_NONE
|| audio_stream_copy
|| audio_codec_name
;
3302 use_subtitle
= file_oformat
->subtitle_codec
!= CODEC_ID_NONE
|| subtitle_stream_copy
|| subtitle_codec_name
;
3304 /* disable if no corresponding type found and at least one
3306 if (nb_input_files
> 0) {
3307 check_audio_video_sub_inputs(&input_has_video
, &input_has_audio
,
3308 &input_has_subtitle
);
3309 if (!input_has_video
)
3311 if (!input_has_audio
)
3313 if (!input_has_subtitle
)
3317 /* manual disable */
3318 if (audio_disable
) {
3321 if (video_disable
) {
3324 if (subtitle_disable
) {
3329 new_video_stream(oc
);
3333 new_audio_stream(oc
);
3337 new_subtitle_stream(oc
);
3340 oc
->timestamp
= rec_timestamp
;
3343 av_strlcpy(oc
->title
, str_title
, sizeof(oc
->title
));
3345 av_strlcpy(oc
->author
, str_author
, sizeof(oc
->author
));
3347 av_strlcpy(oc
->copyright
, str_copyright
, sizeof(oc
->copyright
));
3349 av_strlcpy(oc
->comment
, str_comment
, sizeof(oc
->comment
));
3351 av_strlcpy(oc
->album
, str_album
, sizeof(oc
->album
));
3353 av_strlcpy(oc
->genre
, str_genre
, sizeof(oc
->genre
));
3356 output_files
[nb_output_files
++] = oc
;
3358 /* check filename in case of an image number is expected */
3359 if (oc
->oformat
->flags
& AVFMT_NEEDNUMBER
) {
3360 if (!av_filename_number_test(oc
->filename
)) {
3361 print_error(oc
->filename
, AVERROR_NUMEXPECTED
);
3366 if (!(oc
->oformat
->flags
& AVFMT_NOFILE
)) {
3367 /* test if it already exists to avoid loosing precious files */
3368 if (!file_overwrite
&&
3369 (strchr(filename
, ':') == NULL
||
3370 filename
[1] == ':' ||
3371 av_strstart(filename
, "file:", NULL
))) {
3372 if (url_exist(filename
)) {
3376 fprintf(stderr
,"File '%s' already exists. Overwrite ? [y/N] ", filename
);
3379 if (toupper(c
) != 'Y') {
3380 fprintf(stderr
, "Not overwriting - exiting\n");
3385 fprintf(stderr
,"File '%s' already exists. Exiting.\n", filename
);
3392 if (url_fopen(&oc
->pb
, filename
, URL_WRONLY
) < 0) {
3393 fprintf(stderr
, "Could not open '%s'\n", filename
);
3398 memset(ap
, 0, sizeof(*ap
));
3399 if (av_set_parameters(oc
, ap
) < 0) {
3400 fprintf(stderr
, "%s: Invalid encoding parameters\n",
3405 oc
->preload
= (int)(mux_preload
*AV_TIME_BASE
);
3406 oc
->max_delay
= (int)(mux_max_delay
*AV_TIME_BASE
);
3407 oc
->loop_output
= loop_output
;
3409 set_context_opts(oc
, avformat_opts
, AV_OPT_FLAG_ENCODING_PARAM
);
3411 /* reset some options */
3412 file_oformat
= NULL
;
3413 file_iformat
= NULL
;
3416 /* same option as mencoder */
3417 static void opt_pass(const char *pass_str
)
3420 pass
= atoi(pass_str
);
3421 if (pass
!= 1 && pass
!= 2) {
3422 fprintf(stderr
, "pass number can be only 1 or 2\n");
3428 static int64_t getutime(void)
3431 struct rusage rusage
;
3433 getrusage(RUSAGE_SELF
, &rusage
);
3434 return (rusage
.ru_utime
.tv_sec
* 1000000LL) + rusage
.ru_utime
.tv_usec
;
3435 #elif HAVE_GETPROCESSTIMES
3437 FILETIME c
, e
, k
, u
;
3438 proc
= GetCurrentProcess();
3439 GetProcessTimes(proc
, &c
, &e
, &k
, &u
);
3440 return ((int64_t) u
.dwHighDateTime
<< 32 | u
.dwLowDateTime
) / 10;
3442 return av_gettime();
3446 static void parse_matrix_coeffs(uint16_t *dest
, const char *str
)
3449 const char *p
= str
;
3456 fprintf(stderr
, "Syntax error in matrix \"%s\" at coeff %d\n", str
, i
);
3463 static void opt_inter_matrix(const char *arg
)
3465 inter_matrix
= av_mallocz(sizeof(uint16_t) * 64);
3466 parse_matrix_coeffs(inter_matrix
, arg
);
3469 static void opt_intra_matrix(const char *arg
)
3471 intra_matrix
= av_mallocz(sizeof(uint16_t) * 64);
3472 parse_matrix_coeffs(intra_matrix
, arg
);
3476 * Trivial log callback.
3477 * Only suitable for show_help and similar since it lacks prefix handling.
3479 static void log_callback_help(void* ptr
, int level
, const char* fmt
, va_list vl
)
3481 vfprintf(stdout
, fmt
, vl
);
3484 static void show_help(void)
3486 av_log_set_callback(log_callback_help
);
3487 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3488 "Hyper fast Audio and Video encoder\n");
3490 show_help_options(options
, "Main options:\n",
3491 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_SUBTITLE
| OPT_GRAB
, 0);
3492 show_help_options(options
, "\nAdvanced options:\n",
3493 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_SUBTITLE
| OPT_GRAB
,
3495 show_help_options(options
, "\nVideo options:\n",
3496 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_GRAB
,
3498 show_help_options(options
, "\nAdvanced Video options:\n",
3499 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_GRAB
,
3500 OPT_VIDEO
| OPT_EXPERT
);
3501 show_help_options(options
, "\nAudio options:\n",
3502 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_GRAB
,
3504 show_help_options(options
, "\nAdvanced Audio options:\n",
3505 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_GRAB
,
3506 OPT_AUDIO
| OPT_EXPERT
);
3507 show_help_options(options
, "\nSubtitle options:\n",
3508 OPT_SUBTITLE
| OPT_GRAB
,
3510 show_help_options(options
, "\nAudio/Video grab options:\n",
3514 av_opt_show(avctx_opts
[0], NULL
);
3516 av_opt_show(avformat_opts
, NULL
);
3518 av_opt_show(sws_opts
, NULL
);
3521 static void opt_target(const char *arg
)
3524 static const char *const frame_rates
[] = {"25", "30000/1001", "24000/1001"};
3526 if(!strncmp(arg
, "pal-", 4)) {
3529 } else if(!strncmp(arg
, "ntsc-", 5)) {
3532 } else if(!strncmp(arg
, "film-", 5)) {
3537 /* Calculate FR via float to avoid int overflow */
3538 fr
= (int)(frame_rate
.num
* 1000.0 / frame_rate
.den
);
3541 } else if((fr
== 29970) || (fr
== 23976)) {
3544 /* Try to determine PAL/NTSC by peeking in the input files */
3545 if(nb_input_files
) {
3547 for(j
= 0; j
< nb_input_files
; j
++) {
3548 for(i
= 0; i
< input_files
[j
]->nb_streams
; i
++) {
3549 AVCodecContext
*c
= input_files
[j
]->streams
[i
]->codec
;
3550 if(c
->codec_type
!= CODEC_TYPE_VIDEO
)
3552 fr
= c
->time_base
.den
* 1000 / c
->time_base
.num
;
3556 } else if((fr
== 29970) || (fr
== 23976)) {
3566 if(verbose
&& norm
>= 0)
3567 fprintf(stderr
, "Assuming %s for target.\n", norm
? "NTSC" : "PAL");
3571 fprintf(stderr
, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3572 fprintf(stderr
, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3573 fprintf(stderr
, "or set a framerate with \"-r xxx\".\n");
3577 if(!strcmp(arg
, "vcd")) {
3579 opt_video_codec("mpeg1video");
3580 opt_audio_codec("mp2");
3583 opt_frame_size(norm
? "352x240" : "352x288");
3584 opt_frame_rate(NULL
, frame_rates
[norm
]);
3585 opt_default("gop", norm
? "18" : "15");
3587 opt_default("b", "1150000");
3588 opt_default("maxrate", "1150000");
3589 opt_default("minrate", "1150000");
3590 opt_default("bufsize", "327680"); // 40*1024*8;
3592 opt_default("ab", "224000");
3593 audio_sample_rate
= 44100;
3596 opt_default("packetsize", "2324");
3597 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3599 /* We have to offset the PTS, so that it is consistent with the SCR.
3600 SCR starts at 36000, but the first two packs contain only padding
3601 and the first pack from the other stream, respectively, may also have
3602 been written before.
3603 So the real data starts at SCR 36000+3*1200. */
3604 mux_preload
= (36000+3*1200) / 90000.0; //0.44
3605 } else if(!strcmp(arg
, "svcd")) {
3607 opt_video_codec("mpeg2video");
3608 opt_audio_codec("mp2");
3611 opt_frame_size(norm
? "480x480" : "480x576");
3612 opt_frame_rate(NULL
, frame_rates
[norm
]);
3613 opt_default("gop", norm
? "18" : "15");
3615 opt_default("b", "2040000");
3616 opt_default("maxrate", "2516000");
3617 opt_default("minrate", "0"); //1145000;
3618 opt_default("bufsize", "1835008"); //224*1024*8;
3619 opt_default("flags", "+scan_offset");
3622 opt_default("ab", "224000");
3623 audio_sample_rate
= 44100;
3625 opt_default("packetsize", "2324");
3627 } else if(!strcmp(arg
, "dvd")) {
3629 opt_video_codec("mpeg2video");
3630 opt_audio_codec("ac3");
3633 opt_frame_size(norm
? "720x480" : "720x576");
3634 opt_frame_rate(NULL
, frame_rates
[norm
]);
3635 opt_default("gop", norm
? "18" : "15");
3637 opt_default("b", "6000000");
3638 opt_default("maxrate", "9000000");
3639 opt_default("minrate", "0"); //1500000;
3640 opt_default("bufsize", "1835008"); //224*1024*8;
3642 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3643 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3645 opt_default("ab", "448000");
3646 audio_sample_rate
= 48000;
3648 } else if(!strncmp(arg
, "dv", 2)) {
3652 opt_frame_size(norm
? "720x480" : "720x576");
3653 opt_frame_pix_fmt(!strncmp(arg
, "dv50", 4) ? "yuv422p" :
3654 (norm
? "yuv411p" : "yuv420p"));
3655 opt_frame_rate(NULL
, frame_rates
[norm
]);
3657 audio_sample_rate
= 48000;
3661 fprintf(stderr
, "Unknown target: %s\n", arg
);
3666 static void opt_vstats_file (const char *arg
)
3668 av_free (vstats_filename
);
3669 vstats_filename
=av_strdup (arg
);
3672 static void opt_vstats (void)
3675 time_t today2
= time(NULL
);
3676 struct tm
*today
= localtime(&today2
);
3678 snprintf(filename
, sizeof(filename
), "vstats_%02d%02d%02d.log", today
->tm_hour
, today
->tm_min
,
3680 opt_vstats_file(filename
);
3683 static int opt_bsf(const char *opt
, const char *arg
)
3685 AVBitStreamFilterContext
*bsfc
= av_bitstream_filter_init(arg
); //FIXME split name and args for filter at '='
3686 AVBitStreamFilterContext
**bsfp
;
3689 fprintf(stderr
, "Unknown bitstream filter %s\n", arg
);
3693 bsfp
= *opt
== 'v' ? &video_bitstream_filters
:
3694 *opt
== 'a' ? &audio_bitstream_filters
:
3695 &subtitle_bitstream_filters
;
3697 bsfp
= &(*bsfp
)->next
;
3704 static int opt_preset(const char *opt
, const char *arg
)
3707 char filename
[1000], tmp
[1000], tmp2
[1000], line
[1000];
3709 const char *base
[2]= { getenv("HOME"),
3713 for(i
=!base
[0]; i
<2 && !f
; i
++){
3714 snprintf(filename
, sizeof(filename
), "%s%s/%s.ffpreset", base
[i
], i
? "" : "/.ffmpeg", arg
);
3715 f
= fopen(filename
, "r");
3717 char *codec_name
= *opt
== 'v' ? video_codec_name
:
3718 *opt
== 'a' ? audio_codec_name
:
3719 subtitle_codec_name
;
3720 snprintf(filename
, sizeof(filename
), "%s%s/%s-%s.ffpreset", base
[i
], i
? "" : "/.ffmpeg", codec_name
, arg
);
3721 f
= fopen(filename
, "r");
3724 if(!f
&& ((arg
[0]=='.' && arg
[1]=='/') || arg
[0]=='/' ||
3726 av_strlcpy(filename
, arg
, sizeof(filename
));
3727 f
= fopen(filename
, "r");
3731 fprintf(stderr
, "File for preset '%s' not found\n", arg
);
3736 int e
= fscanf(f
, "%999[^\n]\n", line
) - 1;
3737 if(line
[0] == '#' && !e
)
3739 e
|= sscanf(line
, "%999[^=]=%999[^\n]\n", tmp
, tmp2
) - 2;
3741 fprintf(stderr
, "%s: Invalid syntax: '%s'\n", filename
, line
);
3744 if(!strcmp(tmp
, "acodec")){
3745 opt_audio_codec(tmp2
);
3746 }else if(!strcmp(tmp
, "vcodec")){
3747 opt_video_codec(tmp2
);
3748 }else if(!strcmp(tmp
, "scodec")){
3749 opt_subtitle_codec(tmp2
);
3750 }else if(opt_default(tmp
, tmp2
) < 0){
3751 fprintf(stderr
, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename
, line
, tmp
, tmp2
);
3761 static const OptionDef options
[] = {
3763 { "L", OPT_EXIT
, {(void*)show_license
}, "show license" },
3764 { "h", OPT_EXIT
, {(void*)show_help
}, "show help" },
3765 { "version", OPT_EXIT
, {(void*)show_version
}, "show version" },
3766 { "formats", OPT_EXIT
, {(void*)show_formats
}, "show available formats, codecs, protocols, ..." },
3767 { "f", HAS_ARG
, {(void*)opt_format
}, "force format", "fmt" },
3768 { "i", HAS_ARG
, {(void*)opt_input_file
}, "input file name", "filename" },
3769 { "y", OPT_BOOL
, {(void*)&file_overwrite
}, "overwrite output files" },
3770 { "map", HAS_ARG
| OPT_EXPERT
, {(void*)opt_map
}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3771 { "map_meta_data", HAS_ARG
| OPT_EXPERT
, {(void*)opt_map_meta_data
}, "set meta data information of outfile from infile", "outfile:infile" },
3772 { "t", OPT_FUNC2
| HAS_ARG
, {(void*)opt_recording_time
}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3773 { "fs", HAS_ARG
| OPT_INT64
, {(void*)&limit_filesize
}, "set the limit file size in bytes", "limit_size" }, //
3774 { "ss", OPT_FUNC2
| HAS_ARG
, {(void*)opt_start_time
}, "set the start time offset", "time_off" },
3775 { "itsoffset", OPT_FUNC2
| HAS_ARG
, {(void*)opt_input_ts_offset
}, "set the input ts offset", "time_off" },
3776 { "itsscale", HAS_ARG
, {(void*)opt_input_ts_scale
}, "set the input ts scale", "stream:scale" },
3777 { "title", HAS_ARG
| OPT_STRING
, {(void*)&str_title
}, "set the title", "string" },
3778 { "timestamp", OPT_FUNC2
| HAS_ARG
, {(void*)&opt_rec_timestamp
}, "set the timestamp ('now' to set the current time)", "time" },
3779 { "author", HAS_ARG
| OPT_STRING
, {(void*)&str_author
}, "set the author", "string" },
3780 { "copyright", HAS_ARG
| OPT_STRING
, {(void*)&str_copyright
}, "set the copyright", "string" },
3781 { "comment", HAS_ARG
| OPT_STRING
, {(void*)&str_comment
}, "set the comment", "string" },
3782 { "genre", HAS_ARG
| OPT_STRING
, {(void*)&str_genre
}, "set the genre", "string" },
3783 { "album", HAS_ARG
| OPT_STRING
, {(void*)&str_album
}, "set the album", "string" },
3784 { "dframes", OPT_INT
| HAS_ARG
, {(void*)&max_frames
[CODEC_TYPE_DATA
]}, "set the number of data frames to record", "number" },
3785 { "benchmark", OPT_BOOL
| OPT_EXPERT
, {(void*)&do_benchmark
},
3786 "add timings for benchmarking" },
3787 { "dump", OPT_BOOL
| OPT_EXPERT
, {(void*)&do_pkt_dump
},
3788 "dump each input packet" },
3789 { "hex", OPT_BOOL
| OPT_EXPERT
, {(void*)&do_hex_dump
},
3790 "when dumping packets, also dump the payload" },
3791 { "re", OPT_BOOL
| OPT_EXPERT
, {(void*)&rate_emu
}, "read input at native frame rate", "" },
3792 { "loop_input", OPT_BOOL
| OPT_EXPERT
, {(void*)&loop_input
}, "loop (current only works with images)" },
3793 { "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)", "" },
3794 { "v", HAS_ARG
| OPT_FUNC2
, {(void*)opt_verbose
}, "set the logging verbosity level", "number" },
3795 { "target", HAS_ARG
, {(void*)opt_target
}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3796 { "threads", OPT_FUNC2
| HAS_ARG
| OPT_EXPERT
, {(void*)opt_thread_count
}, "thread count", "count" },
3797 { "vsync", HAS_ARG
| OPT_INT
| OPT_EXPERT
, {(void*)&video_sync_method
}, "video sync method", "" },
3798 { "async", HAS_ARG
| OPT_INT
| OPT_EXPERT
, {(void*)&audio_sync_method
}, "audio sync method", "" },
3799 { "adrift_threshold", HAS_ARG
| OPT_FLOAT
| OPT_EXPERT
, {(void*)&audio_drift_threshold
}, "audio drift threshold", "threshold" },
3800 { "vglobal", HAS_ARG
| OPT_INT
| OPT_EXPERT
, {(void*)&video_global_header
}, "video global header storage type", "" },
3801 { "copyts", OPT_BOOL
| OPT_EXPERT
, {(void*)©_ts
}, "copy timestamps" },
3802 { "shortest", OPT_BOOL
| OPT_EXPERT
, {(void*)&opt_shortest
}, "finish encoding within shortest input" }, //
3803 { "dts_delta_threshold", HAS_ARG
| OPT_FLOAT
| OPT_EXPERT
, {(void*)&dts_delta_threshold
}, "timestamp discontinuity delta threshold", "threshold" },
3804 { "programid", HAS_ARG
| OPT_INT
| OPT_EXPERT
, {(void*)&opt_programid
}, "desired program number", "" },
3805 { "xerror", OPT_BOOL
, {(void*)&exit_on_error
}, "exit on error", "error" },
3806 { "copyinkf", OPT_BOOL
| OPT_EXPERT
, {(void*)©_initial_nonkeyframes
}, "copy initial non-keyframes" },
3809 { "b", OPT_FUNC2
| HAS_ARG
| OPT_VIDEO
, {(void*)opt_bitrate
}, "set bitrate (in bits/s)", "bitrate" },
3810 { "vb", OPT_FUNC2
| HAS_ARG
| OPT_VIDEO
, {(void*)opt_bitrate
}, "set bitrate (in bits/s)", "bitrate" },
3811 { "vframes", OPT_INT
| HAS_ARG
| OPT_VIDEO
, {(void*)&max_frames
[CODEC_TYPE_VIDEO
]}, "set the number of video frames to record", "number" },
3812 { "r", OPT_FUNC2
| HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_rate
}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3813 { "s", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_size
}, "set frame size (WxH or abbreviation)", "size" },
3814 { "aspect", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_aspect_ratio
}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3815 { "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" },
3816 { "croptop", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_crop_top
}, "set top crop band size (in pixels)", "size" },
3817 { "cropbottom", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_crop_bottom
}, "set bottom crop band size (in pixels)", "size" },
3818 { "cropleft", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_crop_left
}, "set left crop band size (in pixels)", "size" },
3819 { "cropright", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_crop_right
}, "set right crop band size (in pixels)", "size" },
3820 { "padtop", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_pad_top
}, "set top pad band size (in pixels)", "size" },
3821 { "padbottom", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_pad_bottom
}, "set bottom pad band size (in pixels)", "size" },
3822 { "padleft", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_pad_left
}, "set left pad band size (in pixels)", "size" },
3823 { "padright", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_pad_right
}, "set right pad band size (in pixels)", "size" },
3824 { "padcolor", HAS_ARG
| OPT_VIDEO
, {(void*)opt_pad_color
}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3825 { "intra", OPT_BOOL
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&intra_only
}, "use only intra frames"},
3826 { "vn", OPT_BOOL
| OPT_VIDEO
, {(void*)&video_disable
}, "disable video" },
3827 { "vdt", OPT_INT
| HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&video_discard
}, "discard threshold", "n" },
3828 { "qscale", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_qscale
}, "use fixed video quantizer scale (VBR)", "q" },
3829 { "rc_override", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_video_rc_override_string
}, "rate control override for specific intervals", "override" },
3830 { "vcodec", HAS_ARG
| OPT_VIDEO
, {(void*)opt_video_codec
}, "force video codec ('copy' to copy stream)", "codec" },
3831 { "me_threshold", HAS_ARG
| OPT_FUNC2
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_me_threshold
}, "motion estimaton threshold", "threshold" },
3832 { "sameq", OPT_BOOL
| OPT_VIDEO
, {(void*)&same_quality
},
3833 "use same video quality as source (implies VBR)" },
3834 { "pass", HAS_ARG
| OPT_VIDEO
, {(void*)&opt_pass
}, "select the pass number (1 or 2)", "n" },
3835 { "passlogfile", HAS_ARG
| OPT_STRING
| OPT_VIDEO
, {(void*)&pass_logfilename_prefix
}, "select two pass log file name prefix", "prefix" },
3836 { "deinterlace", OPT_BOOL
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&do_deinterlace
},
3837 "deinterlace pictures" },
3838 { "psnr", OPT_BOOL
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&do_psnr
}, "calculate PSNR of compressed frames" },
3839 { "vstats", OPT_EXPERT
| OPT_VIDEO
, {(void*)&opt_vstats
}, "dump video coding statistics to file" },
3840 { "vstats_file", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_vstats_file
}, "dump video coding statistics to file", "file" },
3842 { "vhook", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)add_frame_hooker
}, "insert video processing module", "module" },
3844 { "intra_matrix", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_intra_matrix
}, "specify intra matrix coeffs", "matrix" },
3845 { "inter_matrix", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_inter_matrix
}, "specify inter matrix coeffs", "matrix" },
3846 { "top", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_top_field_first
}, "top=1/bottom=0/auto=-1 field first", "" },
3847 { "dc", OPT_INT
| HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&intra_dc_precision
}, "intra_dc_precision", "precision" },
3848 { "vtag", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_video_tag
}, "force video tag/fourcc", "fourcc/tag" },
3849 { "newvideo", OPT_VIDEO
, {(void*)opt_new_video_stream
}, "add a new video stream to the current output stream" },
3850 { "qphist", OPT_BOOL
| OPT_EXPERT
| OPT_VIDEO
, { (void *)&qp_hist
}, "show QP histogram" },
3851 { "force_fps", OPT_BOOL
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&force_fps
}, "force the selected framerate, disable the best supported framerate selection" },
3854 { "ab", OPT_FUNC2
| HAS_ARG
| OPT_AUDIO
, {(void*)opt_bitrate
}, "set bitrate (in bits/s)", "bitrate" },
3855 { "aframes", OPT_INT
| HAS_ARG
| OPT_AUDIO
, {(void*)&max_frames
[CODEC_TYPE_AUDIO
]}, "set the number of audio frames to record", "number" },
3856 { "aq", OPT_FLOAT
| HAS_ARG
| OPT_AUDIO
, {(void*)&audio_qscale
}, "set audio quality (codec-specific)", "quality", },
3857 { "ar", HAS_ARG
| OPT_FUNC2
| OPT_AUDIO
, {(void*)opt_audio_rate
}, "set audio sampling rate (in Hz)", "rate" },
3858 { "ac", HAS_ARG
| OPT_FUNC2
| OPT_AUDIO
, {(void*)opt_audio_channels
}, "set number of audio channels", "channels" },
3859 { "an", OPT_BOOL
| OPT_AUDIO
, {(void*)&audio_disable
}, "disable audio" },
3860 { "acodec", HAS_ARG
| OPT_AUDIO
, {(void*)opt_audio_codec
}, "force audio codec ('copy' to copy stream)", "codec" },
3861 { "atag", HAS_ARG
| OPT_EXPERT
| OPT_AUDIO
, {(void*)opt_audio_tag
}, "force audio tag/fourcc", "fourcc/tag" },
3862 { "vol", OPT_INT
| HAS_ARG
| OPT_AUDIO
, {(void*)&audio_volume
}, "change audio volume (256=normal)" , "volume" }, //
3863 { "newaudio", OPT_AUDIO
, {(void*)opt_new_audio_stream
}, "add a new audio stream to the current output stream" },
3864 { "alang", HAS_ARG
| OPT_STRING
| OPT_AUDIO
, {(void *)&audio_language
}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3865 { "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" },
3867 /* subtitle options */
3868 { "sn", OPT_BOOL
| OPT_SUBTITLE
, {(void*)&subtitle_disable
}, "disable subtitle" },
3869 { "scodec", HAS_ARG
| OPT_SUBTITLE
, {(void*)opt_subtitle_codec
}, "force subtitle codec ('copy' to copy stream)", "codec" },
3870 { "newsubtitle", OPT_SUBTITLE
, {(void*)opt_new_subtitle_stream
}, "add a new subtitle stream to the current output stream" },
3871 { "slang", HAS_ARG
| OPT_STRING
| OPT_SUBTITLE
, {(void *)&subtitle_language
}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3874 { "vc", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
| OPT_GRAB
, {(void*)opt_video_channel
}, "set video grab channel (DV1394 only)", "channel" },
3875 { "tvstd", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
| OPT_GRAB
, {(void*)opt_video_standard
}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3876 { "isync", OPT_BOOL
| OPT_EXPERT
| OPT_GRAB
, {(void*)&input_sync
}, "sync read on input", "" },
3879 { "muxdelay", OPT_FLOAT
| HAS_ARG
| OPT_EXPERT
, {(void*)&mux_max_delay
}, "set the maximum demux-decode delay", "seconds" },
3880 { "muxpreload", OPT_FLOAT
| HAS_ARG
| OPT_EXPERT
, {(void*)&mux_preload
}, "set the initial demux-decode delay", "seconds" },
3882 { "absf", OPT_FUNC2
| HAS_ARG
| OPT_AUDIO
| OPT_EXPERT
, {(void*)opt_bsf
}, "", "bitstream_filter" },
3883 { "vbsf", OPT_FUNC2
| HAS_ARG
| OPT_VIDEO
| OPT_EXPERT
, {(void*)opt_bsf
}, "", "bitstream_filter" },
3884 { "sbsf", OPT_FUNC2
| HAS_ARG
| OPT_SUBTITLE
| OPT_EXPERT
, {(void*)opt_bsf
}, "", "bitstream_filter" },
3886 { "apre", OPT_FUNC2
| HAS_ARG
| OPT_AUDIO
| OPT_EXPERT
, {(void*)opt_preset
}, "set the audio options to the indicated preset", "preset" },
3887 { "vpre", OPT_FUNC2
| HAS_ARG
| OPT_VIDEO
| OPT_EXPERT
, {(void*)opt_preset
}, "set the video options to the indicated preset", "preset" },
3888 { "spre", OPT_FUNC2
| HAS_ARG
| OPT_SUBTITLE
| OPT_EXPERT
, {(void*)opt_preset
}, "set the subtitle options to the indicated preset", "preset" },
3890 { "default", OPT_FUNC2
| HAS_ARG
| OPT_AUDIO
| OPT_VIDEO
| OPT_EXPERT
, {(void*)opt_default
}, "generic catch all option", "" },
3894 int main(int argc
, char **argv
)
3899 avcodec_register_all();
3900 avdevice_register_all();
3903 if(isatty(STDIN_FILENO
))
3904 url_set_interrupt_cb(decode_interrupt_cb
);
3906 for(i
=0; i
<CODEC_TYPE_NB
; i
++){
3907 avctx_opts
[i
]= avcodec_alloc_context2(i
);
3909 avformat_opts
= avformat_alloc_context();
3910 sws_opts
= sws_getContext(16,16,0, 16,16,0, sws_flags
, NULL
,NULL
,NULL
);
3915 parse_options(argc
, argv
, options
, opt_output_file
);
3917 /* file converter / grab */
3918 if (nb_output_files
<= 0) {
3919 fprintf(stderr
, "At least one output file must be specified\n");
3923 if (nb_input_files
== 0) {
3924 fprintf(stderr
, "At least one input file must be specified\n");
3929 if (av_encode(output_files
, nb_output_files
, input_files
, nb_input_files
,
3930 stream_maps
, nb_stream_maps
) < 0)
3932 ti
= getutime() - ti
;
3934 printf("bench: utime=%0.3fs\n", ti
/ 1000000.0);