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
30 #include "libavformat/avformat.h"
31 #include "libavdevice/avdevice.h"
32 #include "libswscale/swscale.h"
33 #include "libavformat/framehook.h"
34 #include "libavcodec/opt.h"
35 #include "libavutil/fifo.h"
36 #include "libavutil/avstring.h"
37 #include "libavformat/os_support.h"
39 #ifdef HAVE_SYS_RESOURCE_H
40 #include <sys/types.h>
41 #include <sys/resource.h>
42 #elif defined(HAVE_GETPROCESSTIMES)
46 #if defined(HAVE_TERMIOS_H)
49 #include <sys/ioctl.h>
52 #elif defined(HAVE_CONIO_H)
55 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
65 const char program_name
[] = "FFmpeg";
66 const int program_birth_year
= 2000;
68 /* select an input stream for an output stream */
69 typedef struct AVStreamMap
{
73 int sync_stream_index
;
76 /** select an input file for an output file */
77 typedef struct AVMetaDataMap
{
82 static const OptionDef options
[];
86 static AVFormatContext
*input_files
[MAX_FILES
];
87 static int64_t input_files_ts_offset
[MAX_FILES
];
88 static int nb_input_files
= 0;
90 static AVFormatContext
*output_files
[MAX_FILES
];
91 static int nb_output_files
= 0;
93 static AVStreamMap stream_maps
[MAX_FILES
];
94 static int nb_stream_maps
;
96 static AVMetaDataMap meta_data_maps
[MAX_FILES
];
97 static int nb_meta_data_maps
;
99 static AVInputFormat
*file_iformat
;
100 static AVOutputFormat
*file_oformat
;
101 static int frame_width
= 0;
102 static int frame_height
= 0;
103 static float frame_aspect_ratio
= 0;
104 static enum PixelFormat frame_pix_fmt
= PIX_FMT_NONE
;
105 static int frame_padtop
= 0;
106 static int frame_padbottom
= 0;
107 static int frame_padleft
= 0;
108 static int frame_padright
= 0;
109 static int padcolor
[3] = {16,128,128}; /* default to black */
110 static int frame_topBand
= 0;
111 static int frame_bottomBand
= 0;
112 static int frame_leftBand
= 0;
113 static int frame_rightBand
= 0;
114 static int max_frames
[4] = {INT_MAX
, INT_MAX
, INT_MAX
, INT_MAX
};
115 static AVRational frame_rate
= (AVRational
) {0,0};
116 static float video_qscale
= 0;
117 static uint16_t *intra_matrix
= NULL
;
118 static uint16_t *inter_matrix
= NULL
;
119 #if 0 //experimental, (can be removed)
120 static float video_rc_qsquish
=1.0;
121 static float video_rc_qmod_amp
=0;
122 static int video_rc_qmod_freq
=0;
124 static const char *video_rc_override_string
=NULL
;
125 static int video_disable
= 0;
126 static int video_discard
= 0;
127 static char *video_codec_name
= NULL
;
128 static int video_codec_tag
= 0;
129 static int same_quality
= 0;
130 static int do_deinterlace
= 0;
131 static int strict
= 0;
132 static int top_field_first
= -1;
133 static int me_threshold
= 0;
134 static int intra_dc_precision
= 8;
135 static int loop_input
= 0;
136 static int loop_output
= AVFMT_NOOUTPUTLOOP
;
137 static int qp_hist
= 0;
139 static int intra_only
= 0;
140 static int audio_sample_rate
= 44100;
141 #define QSCALE_NONE -99999
142 static float audio_qscale
= QSCALE_NONE
;
143 static int audio_disable
= 0;
144 static int audio_channels
= 1;
145 static char *audio_codec_name
= NULL
;
146 static int audio_codec_tag
= 0;
147 static char *audio_language
= NULL
;
149 static int subtitle_disable
= 0;
150 static char *subtitle_codec_name
= NULL
;
151 static char *subtitle_language
= NULL
;
153 static float mux_preload
= 0.5;
154 static float mux_max_delay
= 0.7;
156 static int64_t recording_time
= 0;
157 static int64_t start_time
= 0;
158 static int64_t rec_timestamp
= 0;
159 static int64_t input_ts_offset
= 0;
160 static int file_overwrite
= 0;
161 static char *str_title
= NULL
;
162 static char *str_author
= NULL
;
163 static char *str_copyright
= NULL
;
164 static char *str_comment
= NULL
;
165 static char *str_genre
= NULL
;
166 static char *str_album
= NULL
;
167 static int do_benchmark
= 0;
168 static int do_hex_dump
= 0;
169 static int do_pkt_dump
= 0;
170 static int do_psnr
= 0;
171 static int do_pass
= 0;
172 static char *pass_logfilename
= NULL
;
173 static int audio_stream_copy
= 0;
174 static int video_stream_copy
= 0;
175 static int subtitle_stream_copy
= 0;
176 static int video_sync_method
= 1;
177 static int audio_sync_method
= 0;
178 static float audio_drift_threshold
= 0.1;
179 static int copy_ts
= 0;
180 static int opt_shortest
= 0; //
181 static int video_global_header
= 0;
182 static char *vstats_filename
;
183 static FILE *vstats_file
;
184 static int opt_programid
= 0;
186 static int rate_emu
= 0;
188 static int video_channel
= 0;
189 static char *video_standard
;
191 static int audio_volume
= 256;
193 static int using_stdin
= 0;
194 static int using_vhook
= 0;
195 static int verbose
= 1;
196 static int thread_count
= 1;
197 static int q_pressed
= 0;
198 static int64_t video_size
= 0;
199 static int64_t audio_size
= 0;
200 static int64_t extra_size
= 0;
201 static int nb_frames_dup
= 0;
202 static int nb_frames_drop
= 0;
203 static int input_sync
;
204 static uint64_t limit_filesize
= 0; //
206 static int pgmyuv_compatibility_hack
=0;
207 static float dts_delta_threshold
= 10;
209 static unsigned int sws_flags
= SWS_BICUBIC
;
211 static const char **opt_names
;
212 static int opt_name_count
;
213 static AVCodecContext
*avctx_opts
[CODEC_TYPE_NB
];
214 static AVFormatContext
*avformat_opts
;
215 static struct SwsContext
*sws_opts
;
216 static int64_t timer_start
;
218 static AVBitStreamFilterContext
*video_bitstream_filters
=NULL
;
219 static AVBitStreamFilterContext
*audio_bitstream_filters
=NULL
;
220 static AVBitStreamFilterContext
*subtitle_bitstream_filters
=NULL
;
221 static AVBitStreamFilterContext
*bitstream_filters
[MAX_FILES
][MAX_STREAMS
];
223 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
225 struct AVInputStream
;
227 typedef struct AVOutputStream
{
228 int file_index
; /* file index */
229 int index
; /* stream index in the output file */
230 int source_index
; /* AVInputStream index */
231 AVStream
*st
; /* stream in the output file */
232 int encoding_needed
; /* true if encoding needed for this stream */
234 /* input pts and corresponding output pts
236 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
237 struct AVInputStream
*sync_ist
; /* input stream to sync against */
238 int64_t sync_opts
; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
241 AVFrame pict_tmp
; /* temporary image for resampling */
242 struct SwsContext
*img_resample_ctx
; /* for image resampling */
246 int topBand
; /* cropping area sizes */
250 int padtop
; /* padding area sizes */
257 ReSampleContext
*resample
; /* for audio resampling */
258 AVFifoBuffer fifo
; /* for compression: one audio fifo per codec */
262 typedef struct AVInputStream
{
266 int discard
; /* true if stream data should be discarded */
267 int decoding_needed
; /* true if the packets must be decoded in 'raw_fifo' */
268 int64_t sample_index
; /* current sample */
270 int64_t start
; /* time when read started */
271 unsigned long frame
; /* current frame */
272 int64_t next_pts
; /* synthetic pts for cases where pkt.pts
274 int64_t pts
; /* current pts */
275 int is_start
; /* is 1 at the start and after a discontinuity */
278 typedef struct AVInputFile
{
279 int eof_reached
; /* true if eof reached */
280 int ist_index
; /* index of first stream in ist_table */
281 int buffer_size
; /* current total buffer size */
282 int nb_streams
; /* nb streams we are aware of */
285 #ifdef HAVE_TERMIOS_H
287 /* init terminal so that we can grab keys */
288 static struct termios oldtty
;
291 static void term_exit(void)
293 #ifdef HAVE_TERMIOS_H
294 tcsetattr (0, TCSANOW
, &oldtty
);
298 static volatile sig_atomic_t received_sigterm
= 0;
301 sigterm_handler(int sig
)
303 received_sigterm
= sig
;
307 static void term_init(void)
309 #ifdef HAVE_TERMIOS_H
315 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
316 |INLCR
|IGNCR
|ICRNL
|IXON
);
317 tty
.c_oflag
|= OPOST
;
318 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
319 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
324 tcsetattr (0, TCSANOW
, &tty
);
325 signal(SIGQUIT
, sigterm_handler
); /* Quit (POSIX). */
328 signal(SIGINT
, sigterm_handler
); /* Interrupt (ANSI). */
329 signal(SIGTERM
, sigterm_handler
); /* Termination (ANSI). */
331 register a function to be called at normal program termination
334 #ifdef CONFIG_BEOS_NETSERVER
335 fcntl(0, F_SETFL
, fcntl(0, F_GETFL
) | O_NONBLOCK
);
339 /* read a key without blocking */
340 static int read_key(void)
342 #if defined(HAVE_TERMIOS_H)
345 #ifndef CONFIG_BEOS_NETSERVER
353 n
= select(1, &rfds
, NULL
, NULL
, &tv
);
362 #elif defined(HAVE_CONIO_H)
369 static int decode_interrupt_cb(void)
371 return q_pressed
|| (q_pressed
= read_key() == 'q');
374 static int av_exit(int ret
)
379 for(i
=0;i
<nb_output_files
;i
++) {
380 /* maybe av_close_output_file ??? */
381 AVFormatContext
*s
= output_files
[i
];
383 if (!(s
->oformat
->flags
& AVFMT_NOFILE
) && s
->pb
)
385 for(j
=0;j
<s
->nb_streams
;j
++) {
386 av_free(s
->streams
[j
]->codec
);
387 av_free(s
->streams
[j
]);
391 for(i
=0;i
<nb_input_files
;i
++)
392 av_close_input_file(input_files
[i
]);
394 av_free(intra_matrix
);
395 av_free(inter_matrix
);
399 av_free(vstats_filename
);
403 av_free(video_codec_name
);
404 av_free(audio_codec_name
);
405 av_free(subtitle_codec_name
);
407 av_free(video_standard
);
409 #ifdef CONFIG_POWERPC_PERF
410 extern void powerpc_display_perf_report(void);
411 powerpc_display_perf_report();
412 #endif /* CONFIG_POWERPC_PERF */
414 if (received_sigterm
) {
416 "Received signal %d: terminating.\n",
417 (int) received_sigterm
);
421 exit(ret
); /* not all OS-es handle main() return value */
425 static int read_ffserver_streams(AVFormatContext
*s
, const char *filename
)
431 err
= av_open_input_file(&ic
, filename
, NULL
, FFM_PACKET_SIZE
, NULL
);
434 /* copy stream format */
435 s
->nb_streams
= ic
->nb_streams
;
436 for(i
=0;i
<ic
->nb_streams
;i
++) {
439 // FIXME: a more elegant solution is needed
440 st
= av_mallocz(sizeof(AVStream
));
441 memcpy(st
, ic
->streams
[i
], sizeof(AVStream
));
442 st
->codec
= avcodec_alloc_context();
443 memcpy(st
->codec
, ic
->streams
[i
]->codec
, sizeof(AVCodecContext
));
446 if (st
->codec
->codec_type
== CODEC_TYPE_AUDIO
&& audio_stream_copy
)
448 else if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
&& video_stream_copy
)
451 if(!st
->codec
->thread_count
)
452 st
->codec
->thread_count
= 1;
453 if(st
->codec
->thread_count
>1)
454 avcodec_thread_init(st
->codec
, st
->codec
->thread_count
);
456 if(st
->codec
->flags
& CODEC_FLAG_BITEXACT
)
461 s
->timestamp
= av_gettime();
463 av_close_input_file(ic
);
468 get_sync_ipts(const AVOutputStream
*ost
)
470 const AVInputStream
*ist
= ost
->sync_ist
;
471 return (double)(ist
->pts
- start_time
)/AV_TIME_BASE
;
474 static void write_frame(AVFormatContext
*s
, AVPacket
*pkt
, AVCodecContext
*avctx
, AVBitStreamFilterContext
*bsfc
){
478 AVPacket new_pkt
= *pkt
;
479 int a
= av_bitstream_filter_filter(bsfc
, avctx
, NULL
,
480 &new_pkt
.data
, &new_pkt
.size
,
481 pkt
->data
, pkt
->size
,
482 pkt
->flags
& PKT_FLAG_KEY
);
485 new_pkt
.destruct
= av_destruct_packet
;
487 fprintf(stderr
, "%s failed for stream %d, codec %s",
488 bsfc
->filter
->name
, pkt
->stream_index
,
489 avctx
->codec
? avctx
->codec
->name
: "copy");
497 ret
= av_interleaved_write_frame(s
, pkt
);
499 print_error("av_interleaved_write_frame()", ret
);
504 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
506 static void do_audio_out(AVFormatContext
*s
,
509 unsigned char *buf
, int size
)
512 static uint8_t *audio_buf
= NULL
;
513 static uint8_t *audio_out
= NULL
;
514 const int audio_out_size
= 4*MAX_AUDIO_PACKET_SIZE
;
516 int size_out
, frame_bytes
, ret
;
517 AVCodecContext
*enc
= ost
->st
->codec
;
518 AVCodecContext
*dec
= ist
->st
->codec
;
520 /* SC: dynamic allocation of buffers */
522 audio_buf
= av_malloc(2*MAX_AUDIO_PACKET_SIZE
);
524 audio_out
= av_malloc(audio_out_size
);
525 if (!audio_buf
|| !audio_out
)
526 return; /* Should signal an error ! */
528 if (enc
->channels
!= dec
->channels
)
529 ost
->audio_resample
= 1;
531 if (ost
->audio_resample
&& !ost
->resample
) {
532 ost
->resample
= audio_resample_init(enc
->channels
, dec
->channels
,
533 enc
->sample_rate
, dec
->sample_rate
);
534 if (!ost
->resample
) {
535 fprintf(stderr
, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
536 dec
->channels
, dec
->sample_rate
,
537 enc
->channels
, enc
->sample_rate
);
542 if(audio_sync_method
){
543 double delta
= get_sync_ipts(ost
) * enc
->sample_rate
- ost
->sync_opts
544 - av_fifo_size(&ost
->fifo
)/(ost
->st
->codec
->channels
* 2);
545 double idelta
= delta
*ist
->st
->codec
->sample_rate
/ enc
->sample_rate
;
546 int byte_delta
= ((int)idelta
)*2*ist
->st
->codec
->channels
;
548 //FIXME resample delay
549 if(fabs(delta
) > 50){
550 if(ist
->is_start
|| fabs(delta
) > audio_drift_threshold
*enc
->sample_rate
){
552 byte_delta
= FFMAX(byte_delta
, -size
);
556 fprintf(stderr
, "discarding %d audio samples\n", (int)-delta
);
561 static uint8_t *input_tmp
= NULL
;
562 input_tmp
= av_realloc(input_tmp
, byte_delta
+ size
);
564 if(byte_delta
+ size
<= MAX_AUDIO_PACKET_SIZE
)
567 byte_delta
= MAX_AUDIO_PACKET_SIZE
- size
;
569 memset(input_tmp
, 0, byte_delta
);
570 memcpy(input_tmp
+ byte_delta
, buf
, size
);
574 fprintf(stderr
, "adding %d audio samples of silence\n", (int)delta
);
576 }else if(audio_sync_method
>1){
577 int comp
= av_clip(delta
, -audio_sync_method
, audio_sync_method
);
578 assert(ost
->audio_resample
);
580 fprintf(stderr
, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta
, comp
, enc
->sample_rate
);
581 // 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));
582 av_resample_compensate(*(struct AVResampleContext
**)ost
->resample
, comp
, enc
->sample_rate
);
586 ost
->sync_opts
= lrintf(get_sync_ipts(ost
) * enc
->sample_rate
)
587 - av_fifo_size(&ost
->fifo
)/(ost
->st
->codec
->channels
* 2); //FIXME wrong
589 if (ost
->audio_resample
) {
591 size_out
= audio_resample(ost
->resample
,
592 (short *)buftmp
, (short *)buf
,
593 size
/ (ist
->st
->codec
->channels
* 2));
594 size_out
= size_out
* enc
->channels
* 2;
600 /* now encode as many frames as possible */
601 if (enc
->frame_size
> 1) {
602 /* output resampled raw samples */
603 av_fifo_realloc(&ost
->fifo
, av_fifo_size(&ost
->fifo
) + size_out
);
604 av_fifo_generic_write(&ost
->fifo
, buftmp
, size_out
, NULL
);
606 frame_bytes
= enc
->frame_size
* 2 * enc
->channels
;
608 while (av_fifo_size(&ost
->fifo
) >= frame_bytes
) {
610 av_init_packet(&pkt
);
612 av_fifo_read(&ost
->fifo
, audio_buf
, frame_bytes
);
614 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
616 ret
= avcodec_encode_audio(enc
, audio_out
, audio_out_size
,
619 pkt
.stream_index
= ost
->index
;
622 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
623 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
624 pkt
.flags
|= PKT_FLAG_KEY
;
625 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
627 ost
->sync_opts
+= enc
->frame_size
;
631 av_init_packet(&pkt
);
633 ost
->sync_opts
+= size_out
/ (2 * enc
->channels
);
635 /* output a pcm frame */
636 /* XXX: change encoding codec API to avoid this ? */
637 switch(enc
->codec
->id
) {
638 case CODEC_ID_PCM_S32LE
:
639 case CODEC_ID_PCM_S32BE
:
640 case CODEC_ID_PCM_U32LE
:
641 case CODEC_ID_PCM_U32BE
:
642 size_out
= size_out
<< 1;
644 case CODEC_ID_PCM_S24LE
:
645 case CODEC_ID_PCM_S24BE
:
646 case CODEC_ID_PCM_U24LE
:
647 case CODEC_ID_PCM_U24BE
:
648 case CODEC_ID_PCM_S24DAUD
:
649 size_out
= size_out
/ 2 * 3;
651 case CODEC_ID_PCM_S16LE
:
652 case CODEC_ID_PCM_S16BE
:
653 case CODEC_ID_PCM_U16LE
:
654 case CODEC_ID_PCM_U16BE
:
657 size_out
= size_out
>> 1;
660 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
661 ret
= avcodec_encode_audio(enc
, audio_out
, size_out
,
664 pkt
.stream_index
= ost
->index
;
667 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
668 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
669 pkt
.flags
|= PKT_FLAG_KEY
;
670 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
674 static void pre_process_video_frame(AVInputStream
*ist
, AVPicture
*picture
, void **bufp
)
678 AVPicture picture_tmp
;
681 dec
= ist
->st
->codec
;
683 /* deinterlace : must be done before any resize */
684 if (do_deinterlace
|| using_vhook
) {
687 /* create temporary picture */
688 size
= avpicture_get_size(dec
->pix_fmt
, dec
->width
, dec
->height
);
689 buf
= av_malloc(size
);
693 picture2
= &picture_tmp
;
694 avpicture_fill(picture2
, buf
, dec
->pix_fmt
, dec
->width
, dec
->height
);
697 if(avpicture_deinterlace(picture2
, picture
,
698 dec
->pix_fmt
, dec
->width
, dec
->height
) < 0) {
699 /* if error, do not deinterlace */
705 av_picture_copy(picture2
, picture
, dec
->pix_fmt
, dec
->width
, dec
->height
);
712 frame_hook_process(picture2
, dec
->pix_fmt
, dec
->width
, dec
->height
,
713 1000000 * ist
->pts
/ AV_TIME_BASE
);
715 if (picture
!= picture2
)
716 *picture
= *picture2
;
720 /* we begin to correct av delay at this threshold */
721 #define AV_DELAY_MAX 0.100
723 static void do_subtitle_out(AVFormatContext
*s
,
729 static uint8_t *subtitle_out
= NULL
;
730 int subtitle_out_max_size
= 65536;
731 int subtitle_out_size
, nb
, i
;
735 if (pts
== AV_NOPTS_VALUE
) {
736 fprintf(stderr
, "Subtitle packets must have a pts\n");
740 enc
= ost
->st
->codec
;
743 subtitle_out
= av_malloc(subtitle_out_max_size
);
746 /* Note: DVB subtitle need one packet to draw them and one other
747 packet to clear them */
748 /* XXX: signal it in the codec context ? */
749 if (enc
->codec_id
== CODEC_ID_DVB_SUBTITLE
)
754 for(i
= 0; i
< nb
; i
++) {
755 subtitle_out_size
= avcodec_encode_subtitle(enc
, subtitle_out
,
756 subtitle_out_max_size
, sub
);
758 av_init_packet(&pkt
);
759 pkt
.stream_index
= ost
->index
;
760 pkt
.data
= subtitle_out
;
761 pkt
.size
= subtitle_out_size
;
762 pkt
.pts
= av_rescale_q(pts
, ist
->st
->time_base
, ost
->st
->time_base
);
763 if (enc
->codec_id
== CODEC_ID_DVB_SUBTITLE
) {
764 /* XXX: the pts correction is handled here. Maybe handling
765 it in the codec would be better */
767 pkt
.pts
+= 90 * sub
->start_display_time
;
769 pkt
.pts
+= 90 * sub
->end_display_time
;
771 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
775 static int bit_buffer_size
= 1024*256;
776 static uint8_t *bit_buffer
= NULL
;
778 static void do_video_out(AVFormatContext
*s
,
784 int nb_frames
, i
, ret
;
785 AVFrame
*final_picture
, *formatted_picture
, *resampling_dst
, *padding_src
;
786 AVFrame picture_crop_temp
, picture_pad_temp
;
787 AVCodecContext
*enc
, *dec
;
789 avcodec_get_frame_defaults(&picture_crop_temp
);
790 avcodec_get_frame_defaults(&picture_pad_temp
);
792 enc
= ost
->st
->codec
;
793 dec
= ist
->st
->codec
;
795 /* by default, we output a single frame */
800 if(video_sync_method
){
802 vdelta
= get_sync_ipts(ost
) / av_q2d(enc
->time_base
) - ost
->sync_opts
;
803 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
806 else if (video_sync_method
== 2)
807 ost
->sync_opts
= lrintf(get_sync_ipts(ost
) / av_q2d(enc
->time_base
));
808 else if (vdelta
> 1.1)
809 nb_frames
= lrintf(vdelta
);
810 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
814 fprintf(stderr
, "*** drop!\n");
815 }else if (nb_frames
> 1) {
816 nb_frames_dup
+= nb_frames
;
818 fprintf(stderr
, "*** %d dup!\n", nb_frames
-1);
821 ost
->sync_opts
= lrintf(get_sync_ipts(ost
) / av_q2d(enc
->time_base
));
823 nb_frames
= FFMIN(nb_frames
, max_frames
[CODEC_TYPE_VIDEO
] - ost
->frame_number
);
827 if (ost
->video_crop
) {
828 if (av_picture_crop((AVPicture
*)&picture_crop_temp
, (AVPicture
*)in_picture
, dec
->pix_fmt
, ost
->topBand
, ost
->leftBand
) < 0) {
829 av_log(NULL
, AV_LOG_ERROR
, "error cropping picture\n");
832 formatted_picture
= &picture_crop_temp
;
834 formatted_picture
= in_picture
;
837 final_picture
= formatted_picture
;
838 padding_src
= formatted_picture
;
839 resampling_dst
= &ost
->pict_tmp
;
840 if (ost
->video_pad
) {
841 final_picture
= &ost
->pict_tmp
;
842 if (ost
->video_resample
) {
843 if (av_picture_crop((AVPicture
*)&picture_pad_temp
, (AVPicture
*)final_picture
, enc
->pix_fmt
, ost
->padtop
, ost
->padleft
) < 0) {
844 av_log(NULL
, AV_LOG_ERROR
, "error padding picture\n");
847 resampling_dst
= &picture_pad_temp
;
851 if (ost
->video_resample
) {
853 final_picture
= &ost
->pict_tmp
;
854 sws_scale(ost
->img_resample_ctx
, formatted_picture
->data
, formatted_picture
->linesize
,
855 0, ost
->resample_height
, resampling_dst
->data
, resampling_dst
->linesize
);
858 if (ost
->video_pad
) {
859 av_picture_pad((AVPicture
*)final_picture
, (AVPicture
*)padding_src
,
860 enc
->height
, enc
->width
, enc
->pix_fmt
,
861 ost
->padtop
, ost
->padbottom
, ost
->padleft
, ost
->padright
, padcolor
);
864 /* duplicates frame if needed */
865 for(i
=0;i
<nb_frames
;i
++) {
867 av_init_packet(&pkt
);
868 pkt
.stream_index
= ost
->index
;
870 if (s
->oformat
->flags
& AVFMT_RAWPICTURE
) {
871 /* raw pictures are written as AVPicture structure to
872 avoid any copies. We support temorarily the older
874 AVFrame
* old_frame
= enc
->coded_frame
;
875 enc
->coded_frame
= dec
->coded_frame
; //FIXME/XXX remove this hack
876 pkt
.data
= (uint8_t *)final_picture
;
877 pkt
.size
= sizeof(AVPicture
);
878 pkt
.pts
= av_rescale_q(ost
->sync_opts
, enc
->time_base
, ost
->st
->time_base
);
879 pkt
.flags
|= PKT_FLAG_KEY
;
881 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
882 enc
->coded_frame
= old_frame
;
886 big_picture
= *final_picture
;
887 /* better than nothing: use input picture interlaced
889 big_picture
.interlaced_frame
= in_picture
->interlaced_frame
;
890 if(avctx_opts
[CODEC_TYPE_VIDEO
]->flags
& (CODEC_FLAG_INTERLACED_DCT
|CODEC_FLAG_INTERLACED_ME
)){
891 if(top_field_first
== -1)
892 big_picture
.top_field_first
= in_picture
->top_field_first
;
894 big_picture
.top_field_first
= top_field_first
;
897 /* handles sameq here. This is not correct because it may
898 not be a global option */
900 big_picture
.quality
= ist
->st
->quality
;
902 big_picture
.quality
= ost
->st
->quality
;
904 big_picture
.pict_type
= 0;
905 // big_picture.pts = AV_NOPTS_VALUE;
906 big_picture
.pts
= ost
->sync_opts
;
907 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
908 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
909 ret
= avcodec_encode_video(enc
,
910 bit_buffer
, bit_buffer_size
,
913 fprintf(stderr
, "Video encoding failed\n");
916 //enc->frame_number = enc->real_pict_num;
918 pkt
.data
= bit_buffer
;
920 if(enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
921 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
922 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
923 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
924 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
926 if(enc
->coded_frame
->key_frame
)
927 pkt
.flags
|= PKT_FLAG_KEY
;
928 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
930 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
931 // enc->frame_number-1, enc->real_pict_num, ret,
933 /* if two pass, output log */
934 if (ost
->logfile
&& enc
->stats_out
) {
935 fprintf(ost
->logfile
, "%s", enc
->stats_out
);
944 static double psnr(double d
){
945 return -10.0*log(d
)/log(10.0);
948 static void do_video_stats(AVFormatContext
*os
, AVOutputStream
*ost
,
953 double ti1
, bitrate
, avg_bitrate
;
955 /* this is executed just the first time do_video_stats is called */
957 vstats_file
= fopen(vstats_filename
, "w");
964 enc
= ost
->st
->codec
;
965 if (enc
->codec_type
== CODEC_TYPE_VIDEO
) {
966 frame_number
= ost
->frame_number
;
967 fprintf(vstats_file
, "frame= %5d q= %2.1f ", frame_number
, enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
);
968 if (enc
->flags
&CODEC_FLAG_PSNR
)
969 fprintf(vstats_file
, "PSNR= %6.2f ", psnr(enc
->coded_frame
->error
[0]/(enc
->width
*enc
->height
*255.0*255.0)));
971 fprintf(vstats_file
,"f_size= %6d ", frame_size
);
972 /* compute pts value */
973 ti1
= ost
->sync_opts
* av_q2d(enc
->time_base
);
977 bitrate
= (frame_size
* 8) / av_q2d(enc
->time_base
) / 1000.0;
978 avg_bitrate
= (double)(video_size
* 8) / ti1
/ 1000.0;
979 fprintf(vstats_file
, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
980 (double)video_size
/ 1024, ti1
, bitrate
, avg_bitrate
);
981 fprintf(vstats_file
,"type= %c\n", av_get_pict_type_char(enc
->coded_frame
->pict_type
));
985 static void print_report(AVFormatContext
**output_files
,
986 AVOutputStream
**ost_table
, int nb_ostreams
,
991 AVFormatContext
*oc
, *os
;
994 int frame_number
, vid
, i
;
995 double bitrate
, ti1
, pts
;
996 static int64_t last_time
= -1;
997 static int qp_histogram
[52];
999 if (!is_last_report
) {
1001 /* display the report every 0.5 seconds */
1002 cur_time
= av_gettime();
1003 if (last_time
== -1) {
1004 last_time
= cur_time
;
1007 if ((cur_time
- last_time
) < 500000)
1009 last_time
= cur_time
;
1013 oc
= output_files
[0];
1015 total_size
= url_fsize(oc
->pb
);
1016 if(total_size
<0) // FIXME improve url_fsize() so it works with non seekable output too
1017 total_size
= url_ftell(oc
->pb
);
1022 for(i
=0;i
<nb_ostreams
;i
++) {
1024 os
= output_files
[ost
->file_index
];
1025 enc
= ost
->st
->codec
;
1026 if (vid
&& enc
->codec_type
== CODEC_TYPE_VIDEO
) {
1027 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "q=%2.1f ",
1028 !ost
->st
->stream_copy
?
1029 enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
: -1);
1031 if (!vid
&& enc
->codec_type
== CODEC_TYPE_VIDEO
) {
1032 float t
= (av_gettime()-timer_start
) / 1000000.0;
1034 frame_number
= ost
->frame_number
;
1035 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "frame=%5d fps=%3d q=%3.1f ",
1036 frame_number
, (t
>1)?(int)(frame_number
/t
+0.5) : 0,
1037 !ost
->st
->stream_copy
?
1038 enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
: -1);
1040 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "L");
1043 int qp
= lrintf(enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
);
1044 if(qp
>=0 && qp
<sizeof(qp_histogram
)/sizeof(int))
1047 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "%X", (int)lrintf(log(qp_histogram
[j
]+1)/log(2)));
1049 if (enc
->flags
&CODEC_FLAG_PSNR
){
1051 double error
, error_sum
=0;
1052 double scale
, scale_sum
=0;
1053 char type
[3]= {'Y','U','V'};
1054 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "PSNR=");
1057 error
= enc
->error
[j
];
1058 scale
= enc
->width
*enc
->height
*255.0*255.0*frame_number
;
1060 error
= enc
->coded_frame
->error
[j
];
1061 scale
= enc
->width
*enc
->height
*255.0*255.0;
1066 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "%c:%2.2f ", type
[j
], psnr(error
/scale
));
1068 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "*:%2.2f ", psnr(error_sum
/scale_sum
));
1072 /* compute min output value */
1073 pts
= (double)ost
->st
->pts
.val
* av_q2d(ost
->st
->time_base
);
1074 if ((pts
< ti1
) && (pts
> 0))
1080 if (verbose
|| is_last_report
) {
1081 bitrate
= (double)(total_size
* 8) / ti1
/ 1000.0;
1083 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
1084 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1085 (double)total_size
/ 1024, ti1
, bitrate
);
1088 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), " dup=%d drop=%d",
1089 nb_frames_dup
, nb_frames_drop
);
1092 fprintf(stderr
, "%s \r", buf
);
1097 if (is_last_report
&& verbose
>= 0){
1098 int64_t raw
= audio_size
+ video_size
+ extra_size
;
1099 fprintf(stderr
, "\n");
1100 fprintf(stderr
, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1104 100.0*(total_size
- raw
)/raw
1109 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1110 static int output_packet(AVInputStream
*ist
, int ist_index
,
1111 AVOutputStream
**ost_table
, int nb_ostreams
,
1112 const AVPacket
*pkt
)
1114 AVFormatContext
*os
;
1115 AVOutputStream
*ost
;
1119 int data_size
, got_picture
;
1121 void *buffer_to_free
;
1122 static unsigned int samples_size
= 0;
1123 static short *samples
= NULL
;
1124 AVSubtitle subtitle
, *subtitle_to_free
;
1127 if(ist
->next_pts
== AV_NOPTS_VALUE
)
1128 ist
->next_pts
= ist
->pts
;
1137 if(pkt
->dts
!= AV_NOPTS_VALUE
)
1138 ist
->next_pts
= ist
->pts
= av_rescale_q(pkt
->dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
1144 ist
->pts
= ist
->next_pts
;
1146 if(len
&& len
!= pkt
->size
&& verbose
>0)
1147 fprintf(stderr
, "Multiple frames in a packet from stream %d\n", pkt
->stream_index
);
1149 /* decode the packet if needed */
1150 data_buf
= NULL
; /* fail safe */
1152 subtitle_to_free
= NULL
;
1153 if (ist
->decoding_needed
) {
1154 switch(ist
->st
->codec
->codec_type
) {
1155 case CODEC_TYPE_AUDIO
:{
1157 samples
= av_fast_realloc(samples
, &samples_size
, FFMAX(pkt
->size
*sizeof(*samples
), AVCODEC_MAX_AUDIO_FRAME_SIZE
));
1158 data_size
= samples_size
;
1159 /* XXX: could avoid copy if PCM 16 bits with same
1160 endianness as CPU */
1161 ret
= avcodec_decode_audio2(ist
->st
->codec
, samples
, &data_size
,
1167 /* Some bug in mpeg audio decoder gives */
1168 /* data_size < 0, it seems they are overflows */
1169 if (data_size
<= 0) {
1170 /* no audio frame */
1173 data_buf
= (uint8_t *)samples
;
1174 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
/2 * data_size
) /
1175 (ist
->st
->codec
->sample_rate
* ist
->st
->codec
->channels
);
1177 case CODEC_TYPE_VIDEO
:
1178 data_size
= (ist
->st
->codec
->width
* ist
->st
->codec
->height
* 3) / 2;
1179 /* XXX: allocate picture correctly */
1180 avcodec_get_frame_defaults(&picture
);
1182 ret
= avcodec_decode_video(ist
->st
->codec
,
1183 &picture
, &got_picture
, ptr
, len
);
1184 ist
->st
->quality
= picture
.quality
;
1188 /* no picture yet */
1189 goto discard_packet
;
1191 if (ist
->st
->codec
->time_base
.num
!= 0) {
1192 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
*
1193 ist
->st
->codec
->time_base
.num
) /
1194 ist
->st
->codec
->time_base
.den
;
1198 case CODEC_TYPE_SUBTITLE
:
1199 ret
= avcodec_decode_subtitle(ist
->st
->codec
,
1200 &subtitle
, &got_subtitle
, ptr
, len
);
1203 if (!got_subtitle
) {
1204 goto discard_packet
;
1206 subtitle_to_free
= &subtitle
;
1213 switch(ist
->st
->codec
->codec_type
) {
1214 case CODEC_TYPE_AUDIO
:
1215 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
* ist
->st
->codec
->frame_size
) /
1216 ist
->st
->codec
->sample_rate
;
1218 case CODEC_TYPE_VIDEO
:
1219 if (ist
->st
->codec
->time_base
.num
!= 0) {
1220 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
*
1221 ist
->st
->codec
->time_base
.num
) /
1222 ist
->st
->codec
->time_base
.den
;
1232 buffer_to_free
= NULL
;
1233 if (ist
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
1234 pre_process_video_frame(ist
, (AVPicture
*)&picture
,
1238 // preprocess audio (volume)
1239 if (ist
->st
->codec
->codec_type
== CODEC_TYPE_AUDIO
) {
1240 if (audio_volume
!= 256) {
1243 for(i
=0;i
<(data_size
/ sizeof(short));i
++) {
1244 int v
= ((*volp
) * audio_volume
+ 128) >> 8;
1245 if (v
< -32768) v
= -32768;
1246 if (v
> 32767) v
= 32767;
1252 /* frame rate emulation */
1253 if (ist
->st
->codec
->rate_emu
) {
1254 int64_t pts
= av_rescale((int64_t) ist
->frame
* ist
->st
->codec
->time_base
.num
, 1000000, ist
->st
->codec
->time_base
.den
);
1255 int64_t now
= av_gettime() - ist
->start
;
1263 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1264 is the one of the next displayed one */
1265 /* XXX: add mpeg4 too ? */
1266 if (ist
->st
->codec
->codec_id
== CODEC_ID_MPEG1VIDEO
) {
1267 if (ist
->st
->codec
->pict_type
!= B_TYPE
) {
1269 tmp
= ist
->last_ip_pts
;
1270 ist
->last_ip_pts
= ist
->frac_pts
.val
;
1271 ist
->frac_pts
.val
= tmp
;
1275 /* if output time reached then transcode raw format,
1276 encode packets and output them */
1277 if (start_time
== 0 || ist
->pts
>= start_time
)
1278 for(i
=0;i
<nb_ostreams
;i
++) {
1282 if (ost
->source_index
== ist_index
) {
1283 os
= output_files
[ost
->file_index
];
1286 printf("%d: got pts=%0.3f %0.3f\n", i
,
1287 (double)pkt
->pts
/ AV_TIME_BASE
,
1288 ((double)ist
->pts
/ AV_TIME_BASE
) -
1289 ((double)ost
->st
->pts
.val
* ost
->st
->time_base
.num
/ ost
->st
->time_base
.den
));
1291 /* set the input output pts pairs */
1292 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1294 if (ost
->encoding_needed
) {
1295 switch(ost
->st
->codec
->codec_type
) {
1296 case CODEC_TYPE_AUDIO
:
1297 do_audio_out(os
, ost
, ist
, data_buf
, data_size
);
1299 case CODEC_TYPE_VIDEO
:
1300 do_video_out(os
, ost
, ist
, &picture
, &frame_size
);
1301 video_size
+= frame_size
;
1302 if (vstats_filename
&& frame_size
)
1303 do_video_stats(os
, ost
, frame_size
);
1305 case CODEC_TYPE_SUBTITLE
:
1306 do_subtitle_out(os
, ost
, ist
, &subtitle
,
1313 AVFrame avframe
; //FIXME/XXX remove this
1315 av_init_packet(&opkt
);
1317 if (!ost
->frame_number
&& !(pkt
->flags
& PKT_FLAG_KEY
))
1320 /* no reencoding needed : output the packet directly */
1321 /* force the input stream PTS */
1323 avcodec_get_frame_defaults(&avframe
);
1324 ost
->st
->codec
->coded_frame
= &avframe
;
1325 avframe
.key_frame
= pkt
->flags
& PKT_FLAG_KEY
;
1327 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_AUDIO
)
1328 audio_size
+= data_size
;
1329 else if (ost
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
1330 video_size
+= data_size
;
1334 opkt
.stream_index
= ost
->index
;
1335 if(pkt
->pts
!= AV_NOPTS_VALUE
)
1336 opkt
.pts
= av_rescale_q(pkt
->pts
, ist
->st
->time_base
, ost
->st
->time_base
);
1338 opkt
.pts
= AV_NOPTS_VALUE
;
1340 if (pkt
->dts
== AV_NOPTS_VALUE
)
1341 opkt
.dts
= av_rescale_q(ist
->pts
, AV_TIME_BASE_Q
, ost
->st
->time_base
);
1343 opkt
.dts
= av_rescale_q(pkt
->dts
, ist
->st
->time_base
, ost
->st
->time_base
);
1345 opkt
.duration
= av_rescale_q(pkt
->duration
, ist
->st
->time_base
, ost
->st
->time_base
);
1346 opkt
.flags
= pkt
->flags
;
1348 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1349 if(av_parser_change(ist
->st
->parser
, ost
->st
->codec
, &opkt
.data
, &opkt
.size
, data_buf
, data_size
, pkt
->flags
& PKT_FLAG_KEY
))
1350 opkt
.destruct
= av_destruct_packet
;
1352 write_frame(os
, &opkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][opkt
.stream_index
]);
1353 ost
->st
->codec
->frame_number
++;
1354 ost
->frame_number
++;
1355 av_free_packet(&opkt
);
1359 av_free(buffer_to_free
);
1360 /* XXX: allocate the subtitles in the codec ? */
1361 if (subtitle_to_free
) {
1362 if (subtitle_to_free
->rects
!= NULL
) {
1363 for (i
= 0; i
< subtitle_to_free
->num_rects
; i
++) {
1364 av_free(subtitle_to_free
->rects
[i
].bitmap
);
1365 av_free(subtitle_to_free
->rects
[i
].rgba_palette
);
1367 av_freep(&subtitle_to_free
->rects
);
1369 subtitle_to_free
->num_rects
= 0;
1370 subtitle_to_free
= NULL
;
1377 for(i
=0;i
<nb_ostreams
;i
++) {
1379 if (ost
->source_index
== ist_index
) {
1380 AVCodecContext
*enc
= ost
->st
->codec
;
1381 os
= output_files
[ost
->file_index
];
1383 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_AUDIO
&& enc
->frame_size
<=1)
1385 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
&& (os
->oformat
->flags
& AVFMT_RAWPICTURE
))
1388 if (ost
->encoding_needed
) {
1392 av_init_packet(&pkt
);
1393 pkt
.stream_index
= ost
->index
;
1395 switch(ost
->st
->codec
->codec_type
) {
1396 case CODEC_TYPE_AUDIO
:
1397 fifo_bytes
= av_fifo_size(&ost
->fifo
);
1399 /* encode any samples remaining in fifo */
1400 if(fifo_bytes
> 0 && enc
->codec
->capabilities
& CODEC_CAP_SMALL_LAST_FRAME
) {
1401 int fs_tmp
= enc
->frame_size
;
1402 enc
->frame_size
= fifo_bytes
/ (2 * enc
->channels
);
1403 av_fifo_read(&ost
->fifo
, (uint8_t *)samples
, fifo_bytes
);
1404 ret
= avcodec_encode_audio(enc
, bit_buffer
, bit_buffer_size
, samples
);
1405 enc
->frame_size
= fs_tmp
;
1408 ret
= avcodec_encode_audio(enc
, bit_buffer
, bit_buffer_size
, NULL
);
1411 pkt
.flags
|= PKT_FLAG_KEY
;
1413 case CODEC_TYPE_VIDEO
:
1414 ret
= avcodec_encode_video(enc
, bit_buffer
, bit_buffer_size
, NULL
);
1416 if(enc
->coded_frame
&& enc
->coded_frame
->key_frame
)
1417 pkt
.flags
|= PKT_FLAG_KEY
;
1418 if (ost
->logfile
&& enc
->stats_out
) {
1419 fprintf(ost
->logfile
, "%s", enc
->stats_out
);
1428 pkt
.data
= bit_buffer
;
1430 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
1431 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
1432 write_frame(os
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
1444 static void print_sdp(AVFormatContext
**avc
, int n
)
1448 avf_sdp_create(avc
, n
, sdp
, sizeof(sdp
));
1449 printf("SDP:\n%s\n", sdp
);
1452 static int stream_index_from_inputs(AVFormatContext
**input_files
,
1454 AVInputFile
*file_table
,
1455 AVInputStream
**ist_table
,
1456 enum CodecType type
,
1460 for(z
=0; z
<nb_input_files
; z
++) {
1461 AVFormatContext
*ic
= input_files
[z
];
1462 for(p
=0; p
<ic
->nb_programs
; p
++) {
1463 AVProgram
*program
= ic
->programs
[p
];
1464 if(program
->id
!= programid
)
1466 for(q
=0; q
<program
->nb_stream_indexes
; q
++) {
1467 int sidx
= program
->stream_index
[q
];
1468 int ris
= file_table
[z
].ist_index
+ sidx
;
1469 if(ist_table
[ris
]->discard
&& ic
->streams
[sidx
]->codec
->codec_type
== type
)
1479 * The following code is the main loop of the file converter
1481 static int av_encode(AVFormatContext
**output_files
,
1482 int nb_output_files
,
1483 AVFormatContext
**input_files
,
1485 AVStreamMap
*stream_maps
, int nb_stream_maps
)
1487 int ret
, i
, j
, k
, n
, nb_istreams
= 0, nb_ostreams
= 0;
1488 AVFormatContext
*is
, *os
;
1489 AVCodecContext
*codec
, *icodec
;
1490 AVOutputStream
*ost
, **ost_table
= NULL
;
1491 AVInputStream
*ist
, **ist_table
= NULL
;
1492 AVInputFile
*file_table
;
1496 file_table
= av_mallocz(nb_input_files
* sizeof(AVInputFile
));
1500 /* input stream init */
1502 for(i
=0;i
<nb_input_files
;i
++) {
1503 is
= input_files
[i
];
1504 file_table
[i
].ist_index
= j
;
1505 file_table
[i
].nb_streams
= is
->nb_streams
;
1506 j
+= is
->nb_streams
;
1510 ist_table
= av_mallocz(nb_istreams
* sizeof(AVInputStream
*));
1514 for(i
=0;i
<nb_istreams
;i
++) {
1515 ist
= av_mallocz(sizeof(AVInputStream
));
1521 for(i
=0;i
<nb_input_files
;i
++) {
1522 is
= input_files
[i
];
1523 for(k
=0;k
<is
->nb_streams
;k
++) {
1524 ist
= ist_table
[j
++];
1525 ist
->st
= is
->streams
[k
];
1526 ist
->file_index
= i
;
1528 ist
->discard
= 1; /* the stream is discarded by default
1531 if (ist
->st
->codec
->rate_emu
) {
1532 ist
->start
= av_gettime();
1538 /* output stream init */
1540 for(i
=0;i
<nb_output_files
;i
++) {
1541 os
= output_files
[i
];
1542 if (!os
->nb_streams
) {
1543 fprintf(stderr
, "Output file does not contain any stream\n");
1546 nb_ostreams
+= os
->nb_streams
;
1548 if (nb_stream_maps
> 0 && nb_stream_maps
!= nb_ostreams
) {
1549 fprintf(stderr
, "Number of stream maps must match number of output streams\n");
1553 /* Sanity check the mapping args -- do the input files & streams exist? */
1554 for(i
=0;i
<nb_stream_maps
;i
++) {
1555 int fi
= stream_maps
[i
].file_index
;
1556 int si
= stream_maps
[i
].stream_index
;
1558 if (fi
< 0 || fi
> nb_input_files
- 1 ||
1559 si
< 0 || si
> file_table
[fi
].nb_streams
- 1) {
1560 fprintf(stderr
,"Could not find input stream #%d.%d\n", fi
, si
);
1563 fi
= stream_maps
[i
].sync_file_index
;
1564 si
= stream_maps
[i
].sync_stream_index
;
1565 if (fi
< 0 || fi
> nb_input_files
- 1 ||
1566 si
< 0 || si
> file_table
[fi
].nb_streams
- 1) {
1567 fprintf(stderr
,"Could not find sync stream #%d.%d\n", fi
, si
);
1572 ost_table
= av_mallocz(sizeof(AVOutputStream
*) * nb_ostreams
);
1575 for(i
=0;i
<nb_ostreams
;i
++) {
1576 ost
= av_mallocz(sizeof(AVOutputStream
));
1583 for(k
=0;k
<nb_output_files
;k
++) {
1584 os
= output_files
[k
];
1585 for(i
=0;i
<os
->nb_streams
;i
++) {
1587 ost
= ost_table
[n
++];
1588 ost
->file_index
= k
;
1590 ost
->st
= os
->streams
[i
];
1591 if (nb_stream_maps
> 0) {
1592 ost
->source_index
= file_table
[stream_maps
[n
-1].file_index
].ist_index
+
1593 stream_maps
[n
-1].stream_index
;
1595 /* Sanity check that the stream types match */
1596 if (ist_table
[ost
->source_index
]->st
->codec
->codec_type
!= ost
->st
->codec
->codec_type
) {
1597 fprintf(stderr
, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1598 stream_maps
[n
-1].file_index
, stream_maps
[n
-1].stream_index
,
1599 ost
->file_index
, ost
->index
);
1606 j
= stream_index_from_inputs(input_files
, nb_input_files
, file_table
, ist_table
, ost
->st
->codec
->codec_type
, opt_programid
);
1608 ost
->source_index
= j
;
1612 /* get corresponding input stream index : we select the first one with the right type */
1614 for(j
=0;j
<nb_istreams
;j
++) {
1617 ist
->st
->codec
->codec_type
== ost
->st
->codec
->codec_type
) {
1618 ost
->source_index
= j
;
1626 if(! opt_programid
) {
1627 /* try again and reuse existing stream */
1628 for(j
=0;j
<nb_istreams
;j
++) {
1630 if (ist
->st
->codec
->codec_type
== ost
->st
->codec
->codec_type
) {
1631 ost
->source_index
= j
;
1637 int i
= ost
->file_index
;
1638 dump_format(output_files
[i
], i
, output_files
[i
]->filename
, 1);
1639 fprintf(stderr
, "Could not find input stream matching output stream #%d.%d\n",
1640 ost
->file_index
, ost
->index
);
1645 ist
= ist_table
[ost
->source_index
];
1647 ost
->sync_ist
= (nb_stream_maps
> 0) ?
1648 ist_table
[file_table
[stream_maps
[n
-1].sync_file_index
].ist_index
+
1649 stream_maps
[n
-1].sync_stream_index
] : ist
;
1653 /* for each output stream, we compute the right encoding parameters */
1654 for(i
=0;i
<nb_ostreams
;i
++) {
1656 os
= output_files
[ost
->file_index
];
1657 ist
= ist_table
[ost
->source_index
];
1659 codec
= ost
->st
->codec
;
1660 icodec
= ist
->st
->codec
;
1662 if (!ost
->st
->language
[0])
1663 av_strlcpy(ost
->st
->language
, ist
->st
->language
,
1664 sizeof(ost
->st
->language
));
1666 ost
->st
->disposition
= ist
->st
->disposition
;
1668 if (ost
->st
->stream_copy
) {
1669 /* if stream_copy is selected, no need to decode or encode */
1670 codec
->codec_id
= icodec
->codec_id
;
1671 codec
->codec_type
= icodec
->codec_type
;
1673 if(!codec
->codec_tag
){
1674 if( !os
->oformat
->codec_tag
1675 || av_codec_get_id (os
->oformat
->codec_tag
, icodec
->codec_tag
) > 0
1676 || av_codec_get_tag(os
->oformat
->codec_tag
, icodec
->codec_id
) <= 0)
1677 codec
->codec_tag
= icodec
->codec_tag
;
1680 codec
->bit_rate
= icodec
->bit_rate
;
1681 codec
->extradata
= icodec
->extradata
;
1682 codec
->extradata_size
= icodec
->extradata_size
;
1683 if(av_q2d(icodec
->time_base
) > av_q2d(ist
->st
->time_base
) && av_q2d(ist
->st
->time_base
) < 1.0/1000)
1684 codec
->time_base
= icodec
->time_base
;
1686 codec
->time_base
= ist
->st
->time_base
;
1687 switch(codec
->codec_type
) {
1688 case CODEC_TYPE_AUDIO
:
1689 codec
->sample_rate
= icodec
->sample_rate
;
1690 codec
->channels
= icodec
->channels
;
1691 codec
->frame_size
= icodec
->frame_size
;
1692 codec
->block_align
= icodec
->block_align
;
1693 if(codec
->block_align
== 1 && codec
->codec_id
== CODEC_ID_MP3
)
1694 codec
->block_align
= 0;
1695 if(codec
->codec_id
== CODEC_ID_AC3
)
1696 codec
->block_align
= 0;
1698 case CODEC_TYPE_VIDEO
:
1700 fprintf(stderr
,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1703 codec
->pix_fmt
= icodec
->pix_fmt
;
1704 codec
->width
= icodec
->width
;
1705 codec
->height
= icodec
->height
;
1706 codec
->has_b_frames
= icodec
->has_b_frames
;
1708 case CODEC_TYPE_SUBTITLE
:
1714 switch(codec
->codec_type
) {
1715 case CODEC_TYPE_AUDIO
:
1716 if (av_fifo_init(&ost
->fifo
, 1024))
1718 ost
->audio_resample
= codec
->sample_rate
!= icodec
->sample_rate
|| audio_sync_method
> 1;
1719 icodec
->request_channels
= codec
->channels
;
1720 ist
->decoding_needed
= 1;
1721 ost
->encoding_needed
= 1;
1723 case CODEC_TYPE_VIDEO
:
1724 ost
->video_crop
= ((frame_leftBand
+ frame_rightBand
+ frame_topBand
+ frame_bottomBand
) != 0);
1725 ost
->video_pad
= ((frame_padleft
+ frame_padright
+ frame_padtop
+ frame_padbottom
) != 0);
1726 ost
->video_resample
= ((codec
->width
!= icodec
->width
-
1727 (frame_leftBand
+ frame_rightBand
) +
1728 (frame_padleft
+ frame_padright
)) ||
1729 (codec
->height
!= icodec
->height
-
1730 (frame_topBand
+ frame_bottomBand
) +
1731 (frame_padtop
+ frame_padbottom
)) ||
1732 (codec
->pix_fmt
!= icodec
->pix_fmt
));
1733 if (ost
->video_crop
) {
1734 ost
->topBand
= frame_topBand
;
1735 ost
->leftBand
= frame_leftBand
;
1737 if (ost
->video_pad
) {
1738 ost
->padtop
= frame_padtop
;
1739 ost
->padleft
= frame_padleft
;
1740 ost
->padbottom
= frame_padbottom
;
1741 ost
->padright
= frame_padright
;
1742 if (!ost
->video_resample
) {
1743 avcodec_get_frame_defaults(&ost
->pict_tmp
);
1744 if(avpicture_alloc((AVPicture
*)&ost
->pict_tmp
, codec
->pix_fmt
,
1745 codec
->width
, codec
->height
))
1749 if (ost
->video_resample
) {
1750 avcodec_get_frame_defaults(&ost
->pict_tmp
);
1751 if(avpicture_alloc((AVPicture
*)&ost
->pict_tmp
, codec
->pix_fmt
,
1752 codec
->width
, codec
->height
)) {
1753 fprintf(stderr
, "Cannot allocate temp picture, check pix fmt\n");
1756 sws_flags
= av_get_int(sws_opts
, "sws_flags", NULL
);
1757 ost
->img_resample_ctx
= sws_getContext(
1758 icodec
->width
- (frame_leftBand
+ frame_rightBand
),
1759 icodec
->height
- (frame_topBand
+ frame_bottomBand
),
1761 codec
->width
- (frame_padleft
+ frame_padright
),
1762 codec
->height
- (frame_padtop
+ frame_padbottom
),
1764 sws_flags
, NULL
, NULL
, NULL
);
1765 if (ost
->img_resample_ctx
== NULL
) {
1766 fprintf(stderr
, "Cannot get resampling context\n");
1769 ost
->resample_height
= icodec
->height
- (frame_topBand
+ frame_bottomBand
);
1771 ost
->encoding_needed
= 1;
1772 ist
->decoding_needed
= 1;
1774 case CODEC_TYPE_SUBTITLE
:
1775 ost
->encoding_needed
= 1;
1776 ist
->decoding_needed
= 1;
1783 if (ost
->encoding_needed
&&
1784 (codec
->flags
& (CODEC_FLAG_PASS1
| CODEC_FLAG_PASS2
))) {
1785 char logfilename
[1024];
1790 snprintf(logfilename
, sizeof(logfilename
), "%s-%d.log",
1792 pass_logfilename
: DEFAULT_PASS_LOGFILENAME
, i
);
1793 if (codec
->flags
& CODEC_FLAG_PASS1
) {
1794 f
= fopen(logfilename
, "w");
1796 perror(logfilename
);
1801 /* read the log file */
1802 f
= fopen(logfilename
, "r");
1804 perror(logfilename
);
1807 fseek(f
, 0, SEEK_END
);
1809 fseek(f
, 0, SEEK_SET
);
1810 logbuffer
= av_malloc(size
+ 1);
1812 fprintf(stderr
, "Could not allocate log buffer\n");
1815 size
= fread(logbuffer
, 1, size
, f
);
1817 logbuffer
[size
] = '\0';
1818 codec
->stats_in
= logbuffer
;
1822 if(codec
->codec_type
== CODEC_TYPE_VIDEO
){
1823 int size
= codec
->width
* codec
->height
;
1824 bit_buffer_size
= FFMAX(bit_buffer_size
, 4*size
);
1829 bit_buffer
= av_malloc(bit_buffer_size
);
1833 /* dump the file output parameters - cannot be done before in case
1835 for(i
=0;i
<nb_output_files
;i
++) {
1836 dump_format(output_files
[i
], i
, output_files
[i
]->filename
, 1);
1839 /* dump the stream mapping */
1841 fprintf(stderr
, "Stream mapping:\n");
1842 for(i
=0;i
<nb_ostreams
;i
++) {
1844 fprintf(stderr
, " Stream #%d.%d -> #%d.%d",
1845 ist_table
[ost
->source_index
]->file_index
,
1846 ist_table
[ost
->source_index
]->index
,
1849 if (ost
->sync_ist
!= ist_table
[ost
->source_index
])
1850 fprintf(stderr
, " [sync #%d.%d]",
1851 ost
->sync_ist
->file_index
,
1852 ost
->sync_ist
->index
);
1853 fprintf(stderr
, "\n");
1857 /* open each encoder */
1858 for(i
=0;i
<nb_ostreams
;i
++) {
1860 if (ost
->encoding_needed
) {
1862 codec
= avcodec_find_encoder(ost
->st
->codec
->codec_id
);
1864 fprintf(stderr
, "Unsupported codec for output stream #%d.%d\n",
1865 ost
->file_index
, ost
->index
);
1868 if (avcodec_open(ost
->st
->codec
, codec
) < 0) {
1869 fprintf(stderr
, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1870 ost
->file_index
, ost
->index
);
1873 extra_size
+= ost
->st
->codec
->extradata_size
;
1877 /* open each decoder */
1878 for(i
=0;i
<nb_istreams
;i
++) {
1880 if (ist
->decoding_needed
) {
1882 codec
= avcodec_find_decoder(ist
->st
->codec
->codec_id
);
1884 fprintf(stderr
, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1885 ist
->st
->codec
->codec_id
, ist
->file_index
, ist
->index
);
1888 if (avcodec_open(ist
->st
->codec
, codec
) < 0) {
1889 fprintf(stderr
, "Error while opening codec for input stream #%d.%d\n",
1890 ist
->file_index
, ist
->index
);
1893 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1894 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1899 for(i
=0;i
<nb_istreams
;i
++) {
1901 is
= input_files
[ist
->file_index
];
1903 ist
->next_pts
= AV_NOPTS_VALUE
;
1907 /* set meta data information from input file if required */
1908 for (i
=0;i
<nb_meta_data_maps
;i
++) {
1909 AVFormatContext
*out_file
;
1910 AVFormatContext
*in_file
;
1912 int out_file_index
= meta_data_maps
[i
].out_file
;
1913 int in_file_index
= meta_data_maps
[i
].in_file
;
1914 if (out_file_index
< 0 || out_file_index
>= nb_output_files
) {
1915 fprintf(stderr
, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index
, out_file_index
, in_file_index
);
1916 ret
= AVERROR(EINVAL
);
1919 if (in_file_index
< 0 || in_file_index
>= nb_input_files
) {
1920 fprintf(stderr
, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index
, out_file_index
, in_file_index
);
1921 ret
= AVERROR(EINVAL
);
1925 out_file
= output_files
[out_file_index
];
1926 in_file
= input_files
[in_file_index
];
1928 strcpy(out_file
->title
, in_file
->title
);
1929 strcpy(out_file
->author
, in_file
->author
);
1930 strcpy(out_file
->copyright
, in_file
->copyright
);
1931 strcpy(out_file
->comment
, in_file
->comment
);
1932 strcpy(out_file
->album
, in_file
->album
);
1933 out_file
->year
= in_file
->year
;
1934 out_file
->track
= in_file
->track
;
1935 strcpy(out_file
->genre
, in_file
->genre
);
1938 /* open files and write file headers */
1939 for(i
=0;i
<nb_output_files
;i
++) {
1940 os
= output_files
[i
];
1941 if (av_write_header(os
) < 0) {
1942 fprintf(stderr
, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i
);
1943 ret
= AVERROR(EINVAL
);
1946 if (strcmp(output_files
[i
]->oformat
->name
, "rtp")) {
1951 print_sdp(output_files
, nb_output_files
);
1954 if (!using_stdin
&& verbose
>= 0) {
1955 fprintf(stderr
, "Press [q] to stop encoding\n");
1956 url_set_interrupt_cb(decode_interrupt_cb
);
1961 timer_start
= av_gettime();
1963 for(; received_sigterm
== 0;) {
1964 int file_index
, ist_index
;
1972 /* if 'q' pressed, exits */
1976 /* read_key() returns 0 on EOF */
1982 /* select the stream that we must read now by looking at the
1983 smallest output pts */
1985 for(i
=0;i
<nb_ostreams
;i
++) {
1988 os
= output_files
[ost
->file_index
];
1989 ist
= ist_table
[ost
->source_index
];
1990 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
)
1991 opts
= ost
->sync_opts
* av_q2d(ost
->st
->codec
->time_base
);
1993 opts
= ost
->st
->pts
.val
* av_q2d(ost
->st
->time_base
);
1994 ipts
= (double)ist
->pts
;
1995 if (!file_table
[ist
->file_index
].eof_reached
){
1996 if(ipts
< ipts_min
) {
1998 if(input_sync
) file_index
= ist
->file_index
;
2000 if(opts
< opts_min
) {
2002 if(!input_sync
) file_index
= ist
->file_index
;
2005 if(ost
->frame_number
>= max_frames
[ost
->st
->codec
->codec_type
]){
2010 /* if none, if is finished */
2011 if (file_index
< 0) {
2015 /* finish if recording time exhausted */
2016 if (recording_time
> 0 && opts_min
>= (recording_time
/ 1000000.0))
2019 /* finish if limit size exhausted */
2020 if (limit_filesize
!= 0 && limit_filesize
< url_ftell(output_files
[0]->pb
))
2023 /* read a frame from it and output it in the fifo */
2024 is
= input_files
[file_index
];
2025 if (av_read_frame(is
, &pkt
) < 0) {
2026 file_table
[file_index
].eof_reached
= 1;
2034 av_pkt_dump_log(NULL
, AV_LOG_DEBUG
, &pkt
, do_hex_dump
);
2036 /* the following test is needed in case new streams appear
2037 dynamically in stream : we ignore them */
2038 if (pkt
.stream_index
>= file_table
[file_index
].nb_streams
)
2039 goto discard_packet
;
2040 ist_index
= file_table
[file_index
].ist_index
+ pkt
.stream_index
;
2041 ist
= ist_table
[ist_index
];
2043 goto discard_packet
;
2045 if (pkt
.dts
!= AV_NOPTS_VALUE
)
2046 pkt
.dts
+= av_rescale_q(input_files_ts_offset
[ist
->file_index
], AV_TIME_BASE_Q
, ist
->st
->time_base
);
2047 if (pkt
.pts
!= AV_NOPTS_VALUE
)
2048 pkt
.pts
+= av_rescale_q(input_files_ts_offset
[ist
->file_index
], AV_TIME_BASE_Q
, ist
->st
->time_base
);
2050 // 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);
2051 if (pkt
.dts
!= AV_NOPTS_VALUE
&& ist
->next_pts
!= AV_NOPTS_VALUE
) {
2052 int64_t pkt_dts
= av_rescale_q(pkt
.dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
2053 int64_t delta
= pkt_dts
- ist
->next_pts
;
2054 if((FFABS(delta
) > 1LL*dts_delta_threshold
*AV_TIME_BASE
|| pkt_dts
+1<ist
->pts
)&& !copy_ts
){
2055 input_files_ts_offset
[ist
->file_index
]-= delta
;
2057 fprintf(stderr
, "timestamp discontinuity %"PRId64
", new offset= %"PRId64
"\n", delta
, input_files_ts_offset
[ist
->file_index
]);
2058 pkt
.dts
-= av_rescale_q(delta
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
2059 if(pkt
.pts
!= AV_NOPTS_VALUE
)
2060 pkt
.pts
-= av_rescale_q(delta
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
2064 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2065 if (output_packet(ist
, ist_index
, ost_table
, nb_ostreams
, &pkt
) < 0) {
2068 fprintf(stderr
, "Error while decoding stream #%d.%d\n",
2069 ist
->file_index
, ist
->index
);
2071 av_free_packet(&pkt
);
2076 av_free_packet(&pkt
);
2078 /* dump report by using the output first video and audio streams */
2079 print_report(output_files
, ost_table
, nb_ostreams
, 0);
2082 /* at the end of stream, we must flush the decoder buffers */
2083 for(i
=0;i
<nb_istreams
;i
++) {
2085 if (ist
->decoding_needed
) {
2086 output_packet(ist
, i
, ost_table
, nb_ostreams
, NULL
);
2092 /* write the trailer if needed and close file */
2093 for(i
=0;i
<nb_output_files
;i
++) {
2094 os
= output_files
[i
];
2095 av_write_trailer(os
);
2098 /* dump report by using the first video and audio streams */
2099 print_report(output_files
, ost_table
, nb_ostreams
, 1);
2101 /* close each encoder */
2102 for(i
=0;i
<nb_ostreams
;i
++) {
2104 if (ost
->encoding_needed
) {
2105 av_freep(&ost
->st
->codec
->stats_in
);
2106 avcodec_close(ost
->st
->codec
);
2110 /* close each decoder */
2111 for(i
=0;i
<nb_istreams
;i
++) {
2113 if (ist
->decoding_needed
) {
2114 avcodec_close(ist
->st
->codec
);
2122 av_freep(&bit_buffer
);
2123 av_free(file_table
);
2126 for(i
=0;i
<nb_istreams
;i
++) {
2133 for(i
=0;i
<nb_ostreams
;i
++) {
2137 fclose(ost
->logfile
);
2138 ost
->logfile
= NULL
;
2140 av_fifo_free(&ost
->fifo
); /* works even if fifo is not
2141 initialized but set to zero */
2142 av_free(ost
->pict_tmp
.data
[0]);
2143 if (ost
->video_resample
)
2144 sws_freeContext(ost
->img_resample_ctx
);
2146 audio_resample_close(ost
->resample
);
2154 ret
= AVERROR(ENOMEM
);
2159 int file_read(const char *filename
)
2162 unsigned char buffer
[1024];
2165 if (url_open(&h
, filename
, O_RDONLY
) < 0) {
2166 printf("could not open '%s'\n", filename
);
2170 len
= url_read(h
, buffer
, sizeof(buffer
));
2173 for(i
=0;i
<len
;i
++) putchar(buffer
[i
]);
2180 static void opt_format(const char *arg
)
2182 /* compatibility stuff for pgmyuv */
2183 if (!strcmp(arg
, "pgmyuv")) {
2184 pgmyuv_compatibility_hack
=1;
2185 // opt_image_format(arg);
2187 fprintf(stderr
, "pgmyuv format is deprecated, use image2\n");
2190 file_iformat
= av_find_input_format(arg
);
2191 file_oformat
= guess_format(arg
, NULL
, NULL
);
2192 if (!file_iformat
&& !file_oformat
) {
2193 fprintf(stderr
, "Unknown input or output format: %s\n", arg
);
2198 static int opt_default(const char *opt
, const char *arg
){
2200 const AVOption
*o
= NULL
;
2201 int opt_types
[]={AV_OPT_FLAG_VIDEO_PARAM
, AV_OPT_FLAG_AUDIO_PARAM
, 0, AV_OPT_FLAG_SUBTITLE_PARAM
, 0};
2203 for(type
=0; type
<CODEC_TYPE_NB
; type
++){
2204 const AVOption
*o2
= av_find_opt(avctx_opts
[0], opt
, NULL
, opt_types
[type
], opt_types
[type
]);
2206 o
= av_set_string(avctx_opts
[type
], opt
, arg
);
2209 o
= av_set_string(avformat_opts
, opt
, arg
);
2211 o
= av_set_string(sws_opts
, opt
, arg
);
2214 o
= av_set_string(avctx_opts
[CODEC_TYPE_AUDIO
], opt
+1, arg
);
2215 else if(opt
[0] == 'v')
2216 o
= av_set_string(avctx_opts
[CODEC_TYPE_VIDEO
], opt
+1, arg
);
2217 else if(opt
[0] == 's')
2218 o
= av_set_string(avctx_opts
[CODEC_TYPE_SUBTITLE
], opt
+1, arg
);
2223 // av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
2225 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
2226 opt_names
= av_realloc(opt_names
, sizeof(void*)*(opt_name_count
+1));
2227 opt_names
[opt_name_count
++]= o
->name
;
2229 if(avctx_opts
[0]->debug
|| avformat_opts
->debug
)
2230 av_log_set_level(AV_LOG_DEBUG
);
2234 static void opt_video_rc_override_string(const char *arg
)
2236 video_rc_override_string
= arg
;
2239 static int opt_me_threshold(const char *opt
, const char *arg
)
2241 me_threshold
= parse_number_or_die(opt
, arg
, OPT_INT64
, INT_MIN
, INT_MAX
);
2245 static int opt_verbose(const char *opt
, const char *arg
)
2247 verbose
= parse_number_or_die(opt
, arg
, OPT_INT64
, -10, 10);
2248 av_log_set_level(verbose
);
2252 static void opt_frame_rate(const char *arg
)
2254 if (av_parse_video_frame_rate(&frame_rate
, arg
) < 0) {
2255 fprintf(stderr
, "Incorrect frame rate\n");
2260 static int opt_bitrate(const char *opt
, const char *arg
)
2262 int codec_type
= opt
[0]=='a' ? CODEC_TYPE_AUDIO
: CODEC_TYPE_VIDEO
;
2264 opt_default(opt
, arg
);
2266 if (av_get_int(avctx_opts
[codec_type
], "b", NULL
) < 1000)
2267 fprintf(stderr
, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2272 static void opt_frame_crop_top(const char *arg
)
2274 frame_topBand
= atoi(arg
);
2275 if (frame_topBand
< 0) {
2276 fprintf(stderr
, "Incorrect top crop size\n");
2279 if ((frame_topBand
% 2) != 0) {
2280 fprintf(stderr
, "Top crop size must be a multiple of 2\n");
2283 if ((frame_topBand
) >= frame_height
){
2284 fprintf(stderr
, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2287 frame_height
-= frame_topBand
;
2290 static void opt_frame_crop_bottom(const char *arg
)
2292 frame_bottomBand
= atoi(arg
);
2293 if (frame_bottomBand
< 0) {
2294 fprintf(stderr
, "Incorrect bottom crop size\n");
2297 if ((frame_bottomBand
% 2) != 0) {
2298 fprintf(stderr
, "Bottom crop size must be a multiple of 2\n");
2301 if ((frame_bottomBand
) >= frame_height
){
2302 fprintf(stderr
, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2305 frame_height
-= frame_bottomBand
;
2308 static void opt_frame_crop_left(const char *arg
)
2310 frame_leftBand
= atoi(arg
);
2311 if (frame_leftBand
< 0) {
2312 fprintf(stderr
, "Incorrect left crop size\n");
2315 if ((frame_leftBand
% 2) != 0) {
2316 fprintf(stderr
, "Left crop size must be a multiple of 2\n");
2319 if ((frame_leftBand
) >= frame_width
){
2320 fprintf(stderr
, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2323 frame_width
-= frame_leftBand
;
2326 static void opt_frame_crop_right(const char *arg
)
2328 frame_rightBand
= atoi(arg
);
2329 if (frame_rightBand
< 0) {
2330 fprintf(stderr
, "Incorrect right crop size\n");
2333 if ((frame_rightBand
% 2) != 0) {
2334 fprintf(stderr
, "Right crop size must be a multiple of 2\n");
2337 if ((frame_rightBand
) >= frame_width
){
2338 fprintf(stderr
, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2341 frame_width
-= frame_rightBand
;
2344 static void opt_frame_size(const char *arg
)
2346 if (av_parse_video_frame_size(&frame_width
, &frame_height
, arg
) < 0) {
2347 fprintf(stderr
, "Incorrect frame size\n");
2350 if ((frame_width
% 2) != 0 || (frame_height
% 2) != 0) {
2351 fprintf(stderr
, "Frame size must be a multiple of 2\n");
2357 #define SCALEBITS 10
2358 #define ONE_HALF (1 << (SCALEBITS - 1))
2359 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2361 #define RGB_TO_Y(r, g, b) \
2362 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2363 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2365 #define RGB_TO_U(r1, g1, b1, shift)\
2366 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2367 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2369 #define RGB_TO_V(r1, g1, b1, shift)\
2370 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2371 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2373 static void opt_pad_color(const char *arg
) {
2374 /* Input is expected to be six hex digits similar to
2375 how colors are expressed in html tags (but without the #) */
2376 int rgb
= strtol(arg
, NULL
, 16);
2380 g
= ((rgb
>> 8) & 255);
2383 padcolor
[0] = RGB_TO_Y(r
,g
,b
);
2384 padcolor
[1] = RGB_TO_U(r
,g
,b
,0);
2385 padcolor
[2] = RGB_TO_V(r
,g
,b
,0);
2388 static void opt_frame_pad_top(const char *arg
)
2390 frame_padtop
= atoi(arg
);
2391 if (frame_padtop
< 0) {
2392 fprintf(stderr
, "Incorrect top pad size\n");
2395 if ((frame_padtop
% 2) != 0) {
2396 fprintf(stderr
, "Top pad size must be a multiple of 2\n");
2401 static void opt_frame_pad_bottom(const char *arg
)
2403 frame_padbottom
= atoi(arg
);
2404 if (frame_padbottom
< 0) {
2405 fprintf(stderr
, "Incorrect bottom pad size\n");
2408 if ((frame_padbottom
% 2) != 0) {
2409 fprintf(stderr
, "Bottom pad size must be a multiple of 2\n");
2415 static void opt_frame_pad_left(const char *arg
)
2417 frame_padleft
= atoi(arg
);
2418 if (frame_padleft
< 0) {
2419 fprintf(stderr
, "Incorrect left pad size\n");
2422 if ((frame_padleft
% 2) != 0) {
2423 fprintf(stderr
, "Left pad size must be a multiple of 2\n");
2429 static void opt_frame_pad_right(const char *arg
)
2431 frame_padright
= atoi(arg
);
2432 if (frame_padright
< 0) {
2433 fprintf(stderr
, "Incorrect right pad size\n");
2436 if ((frame_padright
% 2) != 0) {
2437 fprintf(stderr
, "Right pad size must be a multiple of 2\n");
2442 static void list_pix_fmts(void)
2445 char pix_fmt_str
[128];
2446 for (i
=-1; i
< PIX_FMT_NB
; i
++) {
2447 avcodec_pix_fmt_string (pix_fmt_str
, sizeof(pix_fmt_str
), i
);
2448 fprintf(stdout
, "%s\n", pix_fmt_str
);
2452 static void opt_frame_pix_fmt(const char *arg
)
2454 if (strcmp(arg
, "list"))
2455 frame_pix_fmt
= avcodec_get_pix_fmt(arg
);
2462 static void opt_frame_aspect_ratio(const char *arg
)
2469 p
= strchr(arg
, ':');
2471 x
= strtol(arg
, &end
, 10);
2473 y
= strtol(end
+1, &end
, 10);
2475 ar
= (double)x
/ (double)y
;
2477 ar
= strtod(arg
, NULL
);
2480 fprintf(stderr
, "Incorrect aspect ratio specification.\n");
2483 frame_aspect_ratio
= ar
;
2486 static void opt_qscale(const char *arg
)
2488 video_qscale
= atof(arg
);
2489 if (video_qscale
<= 0 ||
2490 video_qscale
> 255) {
2491 fprintf(stderr
, "qscale must be > 0.0 and <= 255\n");
2496 static void opt_strict(const char *arg
)
2501 static void opt_top_field_first(const char *arg
)
2503 top_field_first
= atoi(arg
);
2506 static int opt_thread_count(const char *opt
, const char *arg
)
2508 thread_count
= parse_number_or_die(opt
, arg
, OPT_INT64
, 0, INT_MAX
);
2509 #if !defined(HAVE_THREADS)
2511 fprintf(stderr
, "Warning: not compiled with thread support, using thread emulation\n");
2516 static int opt_audio_rate(const char *opt
, const char *arg
)
2518 audio_sample_rate
= parse_number_or_die(opt
, arg
, OPT_INT64
, 0, INT_MAX
);
2522 static int opt_audio_channels(const char *opt
, const char *arg
)
2524 audio_channels
= parse_number_or_die(opt
, arg
, OPT_INT64
, 0, INT_MAX
);
2528 static void opt_video_channel(const char *arg
)
2530 video_channel
= strtol(arg
, NULL
, 0);
2533 static void opt_video_standard(const char *arg
)
2535 video_standard
= av_strdup(arg
);
2538 static void opt_codec(int *pstream_copy
, char **pcodec_name
,
2539 int codec_type
, const char *arg
)
2541 av_freep(pcodec_name
);
2542 if (!strcmp(arg
, "copy")) {
2545 *pcodec_name
= av_strdup(arg
);
2549 static void opt_audio_codec(const char *arg
)
2551 opt_codec(&audio_stream_copy
, &audio_codec_name
, CODEC_TYPE_AUDIO
, arg
);
2554 static void opt_audio_tag(const char *arg
)
2557 audio_codec_tag
= strtol(arg
, &tail
, 0);
2560 audio_codec_tag
= arg
[0] + (arg
[1]<<8) + (arg
[2]<<16) + (arg
[3]<<24);
2563 static void opt_video_tag(const char *arg
)
2566 video_codec_tag
= strtol(arg
, &tail
, 0);
2569 video_codec_tag
= arg
[0] + (arg
[1]<<8) + (arg
[2]<<16) + (arg
[3]<<24);
2573 static void add_frame_hooker(const char *arg
)
2578 char *args
= av_strdup(arg
);
2582 argv
[0] = strtok(args
, " ");
2583 while (argc
< 62 && (argv
[++argc
] = strtok(NULL
, " "))) {
2586 i
= frame_hook_add(argc
, argv
);
2589 fprintf(stderr
, "Failed to add video hook function: %s\n", arg
);
2595 static void opt_video_codec(const char *arg
)
2597 opt_codec(&video_stream_copy
, &video_codec_name
, CODEC_TYPE_VIDEO
, arg
);
2600 static void opt_subtitle_codec(const char *arg
)
2602 opt_codec(&subtitle_stream_copy
, &subtitle_codec_name
, CODEC_TYPE_SUBTITLE
, arg
);
2605 static void opt_map(const char *arg
)
2610 m
= &stream_maps
[nb_stream_maps
++];
2612 m
->file_index
= strtol(arg
, &p
, 0);
2616 m
->stream_index
= strtol(p
, &p
, 0);
2619 m
->sync_file_index
= strtol(p
, &p
, 0);
2622 m
->sync_stream_index
= strtol(p
, &p
, 0);
2624 m
->sync_file_index
= m
->file_index
;
2625 m
->sync_stream_index
= m
->stream_index
;
2629 static void opt_map_meta_data(const char *arg
)
2634 m
= &meta_data_maps
[nb_meta_data_maps
++];
2636 m
->out_file
= strtol(arg
, &p
, 0);
2640 m
->in_file
= strtol(p
, &p
, 0);
2643 static int opt_recording_time(const char *opt
, const char *arg
)
2645 recording_time
= parse_time_or_die(opt
, arg
, 1);
2649 static int opt_start_time(const char *opt
, const char *arg
)
2651 start_time
= parse_time_or_die(opt
, arg
, 1);
2655 static int opt_rec_timestamp(const char *opt
, const char *arg
)
2657 rec_timestamp
= parse_time_or_die(opt
, arg
, 0) / 1000000;
2661 static int opt_input_ts_offset(const char *opt
, const char *arg
)
2663 input_ts_offset
= parse_time_or_die(opt
, arg
, 1);
2667 static enum CodecID
find_codec_or_die(const char *name
, int type
, int encoder
)
2669 const char *codec_string
= encoder
? "encoder" : "decoder";
2673 return CODEC_ID_NONE
;
2675 avcodec_find_encoder_by_name(name
) :
2676 avcodec_find_decoder_by_name(name
);
2678 av_log(NULL
, AV_LOG_ERROR
, "Unknown %s '%s'\n", codec_string
, name
);
2681 if(codec
->type
!= type
) {
2682 av_log(NULL
, AV_LOG_ERROR
, "Invalid %s type '%s'\n", codec_string
, name
);
2688 static void set_context_opts(void *ctx
, void *opts_ctx
, int flags
)
2691 for(i
=0; i
<opt_name_count
; i
++){
2693 const AVOption
*opt
;
2694 const char *str
= av_get_string(opts_ctx
, opt_names
[i
], &opt
, buf
, sizeof(buf
));
2695 /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
2696 if(str
&& ((opt
->flags
& flags
) == flags
))
2697 av_set_string(ctx
, opt_names
[i
], str
);
2701 static void opt_input_file(const char *filename
)
2703 AVFormatContext
*ic
;
2704 AVFormatParameters params
, *ap
= ¶ms
;
2705 int err
, i
, ret
, rfps
, rfps_base
;
2708 if (!strcmp(filename
, "-"))
2711 using_stdin
|= !strncmp(filename
, "pipe:", 5) ||
2712 !strcmp(filename
, "/dev/stdin");
2714 /* get default parameters from command line */
2715 ic
= av_alloc_format_context();
2717 memset(ap
, 0, sizeof(*ap
));
2718 ap
->prealloced_context
= 1;
2719 ap
->sample_rate
= audio_sample_rate
;
2720 ap
->channels
= audio_channels
;
2721 ap
->time_base
.den
= frame_rate
.num
;
2722 ap
->time_base
.num
= frame_rate
.den
;
2723 ap
->width
= frame_width
+ frame_padleft
+ frame_padright
;
2724 ap
->height
= frame_height
+ frame_padtop
+ frame_padbottom
;
2725 ap
->pix_fmt
= frame_pix_fmt
;
2726 ap
->channel
= video_channel
;
2727 ap
->standard
= video_standard
;
2728 ap
->video_codec_id
= find_codec_or_die(video_codec_name
, CODEC_TYPE_VIDEO
, 0);
2729 ap
->audio_codec_id
= find_codec_or_die(audio_codec_name
, CODEC_TYPE_AUDIO
, 0);
2730 if(pgmyuv_compatibility_hack
)
2731 ap
->video_codec_id
= CODEC_ID_PGMYUV
;
2733 set_context_opts(ic
, avformat_opts
, AV_OPT_FLAG_DECODING_PARAM
);
2735 ic
->video_codec_id
= find_codec_or_die(video_codec_name
, CODEC_TYPE_VIDEO
, 0);
2736 ic
->audio_codec_id
= find_codec_or_die(audio_codec_name
, CODEC_TYPE_AUDIO
, 0);
2737 ic
->subtitle_codec_id
= find_codec_or_die(subtitle_codec_name
, CODEC_TYPE_SUBTITLE
, 0);
2739 /* open the input file with generic libav function */
2740 err
= av_open_input_file(&ic
, filename
, file_iformat
, 0, ap
);
2742 print_error(filename
, err
);
2747 for(i
=0; i
<ic
->nb_programs
; i
++)
2748 if(ic
->programs
[i
]->id
!= opt_programid
)
2749 ic
->programs
[i
]->discard
= AVDISCARD_ALL
;
2752 ic
->loop_input
= loop_input
;
2754 /* If not enough info to get the stream parameters, we decode the
2755 first frames to get it. (used in mpeg case for example) */
2756 ret
= av_find_stream_info(ic
);
2757 if (ret
< 0 && verbose
>= 0) {
2758 fprintf(stderr
, "%s: could not find codec parameters\n", filename
);
2762 timestamp
= start_time
;
2763 /* add the stream start time */
2764 if (ic
->start_time
!= AV_NOPTS_VALUE
)
2765 timestamp
+= ic
->start_time
;
2767 /* if seeking requested, we execute it */
2768 if (start_time
!= 0) {
2769 ret
= av_seek_frame(ic
, -1, timestamp
, AVSEEK_FLAG_BACKWARD
);
2771 fprintf(stderr
, "%s: could not seek to position %0.3f\n",
2772 filename
, (double)timestamp
/ AV_TIME_BASE
);
2774 /* reset seek info */
2778 /* update the current parameters so that they match the one of the input stream */
2779 for(i
=0;i
<ic
->nb_streams
;i
++) {
2780 AVCodecContext
*enc
= ic
->streams
[i
]->codec
;
2782 avcodec_thread_init(enc
, thread_count
);
2783 enc
->thread_count
= thread_count
;
2784 switch(enc
->codec_type
) {
2785 case CODEC_TYPE_AUDIO
:
2786 set_context_opts(enc
, avctx_opts
[CODEC_TYPE_AUDIO
], AV_OPT_FLAG_AUDIO_PARAM
| AV_OPT_FLAG_DECODING_PARAM
);
2787 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2788 audio_channels
= enc
->channels
;
2789 audio_sample_rate
= enc
->sample_rate
;
2791 ic
->streams
[i
]->discard
= AVDISCARD_ALL
;
2793 case CODEC_TYPE_VIDEO
:
2794 set_context_opts(enc
, avctx_opts
[CODEC_TYPE_VIDEO
], AV_OPT_FLAG_VIDEO_PARAM
| AV_OPT_FLAG_DECODING_PARAM
);
2795 frame_height
= enc
->height
;
2796 frame_width
= enc
->width
;
2797 frame_aspect_ratio
= av_q2d(enc
->sample_aspect_ratio
) * enc
->width
/ enc
->height
;
2798 frame_pix_fmt
= enc
->pix_fmt
;
2799 rfps
= ic
->streams
[i
]->r_frame_rate
.num
;
2800 rfps_base
= ic
->streams
[i
]->r_frame_rate
.den
;
2801 if(enc
->lowres
) enc
->flags
|= CODEC_FLAG_EMU_EDGE
;
2803 enc
->debug
|= FF_DEBUG_MV
;
2805 if (enc
->time_base
.den
!= rfps
|| enc
->time_base
.num
!= rfps_base
) {
2808 fprintf(stderr
,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2809 i
, (float)enc
->time_base
.den
/ enc
->time_base
.num
, enc
->time_base
.den
, enc
->time_base
.num
,
2811 (float)rfps
/ rfps_base
, rfps
, rfps_base
);
2813 /* update the current frame rate to match the stream frame rate */
2814 frame_rate
.num
= rfps
;
2815 frame_rate
.den
= rfps_base
;
2817 enc
->rate_emu
= rate_emu
;
2819 ic
->streams
[i
]->discard
= AVDISCARD_ALL
;
2820 else if(video_discard
)
2821 ic
->streams
[i
]->discard
= video_discard
;
2823 case CODEC_TYPE_DATA
:
2825 case CODEC_TYPE_SUBTITLE
:
2826 if(subtitle_disable
)
2827 ic
->streams
[i
]->discard
= AVDISCARD_ALL
;
2829 case CODEC_TYPE_ATTACHMENT
:
2830 case CODEC_TYPE_UNKNOWN
:
2837 input_files
[nb_input_files
] = ic
;
2838 input_files_ts_offset
[nb_input_files
] = input_ts_offset
- (copy_ts
? 0 : timestamp
);
2839 /* dump the file content */
2841 dump_format(ic
, nb_input_files
, filename
, 0);
2844 file_iformat
= NULL
;
2845 file_oformat
= NULL
;
2850 av_freep(&video_codec_name
);
2851 av_freep(&audio_codec_name
);
2852 av_freep(&subtitle_codec_name
);
2855 static void check_audio_video_sub_inputs(int *has_video_ptr
, int *has_audio_ptr
,
2856 int *has_subtitle_ptr
)
2858 int has_video
, has_audio
, has_subtitle
, i
, j
;
2859 AVFormatContext
*ic
;
2864 for(j
=0;j
<nb_input_files
;j
++) {
2865 ic
= input_files
[j
];
2866 for(i
=0;i
<ic
->nb_streams
;i
++) {
2867 AVCodecContext
*enc
= ic
->streams
[i
]->codec
;
2868 switch(enc
->codec_type
) {
2869 case CODEC_TYPE_AUDIO
:
2872 case CODEC_TYPE_VIDEO
:
2875 case CODEC_TYPE_SUBTITLE
:
2878 case CODEC_TYPE_DATA
:
2879 case CODEC_TYPE_ATTACHMENT
:
2880 case CODEC_TYPE_UNKNOWN
:
2887 *has_video_ptr
= has_video
;
2888 *has_audio_ptr
= has_audio
;
2889 *has_subtitle_ptr
= has_subtitle
;
2892 static void new_video_stream(AVFormatContext
*oc
)
2895 AVCodecContext
*video_enc
;
2898 st
= av_new_stream(oc
, oc
->nb_streams
);
2900 fprintf(stderr
, "Could not alloc stream\n");
2903 avcodec_get_context_defaults2(st
->codec
, CODEC_TYPE_VIDEO
);
2904 bitstream_filters
[nb_output_files
][oc
->nb_streams
- 1]= video_bitstream_filters
;
2905 video_bitstream_filters
= NULL
;
2908 avcodec_thread_init(st
->codec
, thread_count
);
2910 video_enc
= st
->codec
;
2913 video_enc
->codec_tag
= video_codec_tag
;
2915 if( (video_global_header
&1)
2916 || (video_global_header
==0 && (oc
->oformat
->flags
& AVFMT_GLOBALHEADER
))){
2917 video_enc
->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
2918 avctx_opts
[CODEC_TYPE_VIDEO
]->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
2920 if(video_global_header
&2){
2921 video_enc
->flags2
|= CODEC_FLAG2_LOCAL_HEADER
;
2922 avctx_opts
[CODEC_TYPE_VIDEO
]->flags2
|= CODEC_FLAG2_LOCAL_HEADER
;
2925 if (video_stream_copy
) {
2926 st
->stream_copy
= 1;
2927 video_enc
->codec_type
= CODEC_TYPE_VIDEO
;
2932 AVRational fps
= frame_rate
.num
? frame_rate
: (AVRational
){25,1};
2934 codec_id
= av_guess_codec(oc
->oformat
, NULL
, oc
->filename
, NULL
, CODEC_TYPE_VIDEO
);
2935 if (video_codec_name
)
2936 codec_id
= find_codec_or_die(video_codec_name
, CODEC_TYPE_VIDEO
, 1);
2938 video_enc
->codec_id
= codec_id
;
2939 codec
= avcodec_find_encoder(codec_id
);
2941 set_context_opts(video_enc
, avctx_opts
[CODEC_TYPE_VIDEO
], AV_OPT_FLAG_VIDEO_PARAM
| AV_OPT_FLAG_ENCODING_PARAM
);
2943 video_enc
->time_base
.den
= fps
.num
;
2944 video_enc
->time_base
.num
= fps
.den
;
2945 if(codec
&& codec
->supported_framerates
){
2946 const AVRational
*p
= codec
->supported_framerates
;
2947 const AVRational
*best
=NULL
;
2948 AVRational best_error
= (AVRational
){INT_MAX
, 1};
2949 for(; p
->den
!=0; p
++){
2950 AVRational error
= av_sub_q(fps
, *p
);
2951 if(error
.num
<0) error
.num
*= -1;
2952 if(av_cmp_q(error
, best_error
) < 0){
2957 video_enc
->time_base
.den
= best
->num
;
2958 video_enc
->time_base
.num
= best
->den
;
2961 video_enc
->width
= frame_width
+ frame_padright
+ frame_padleft
;
2962 video_enc
->height
= frame_height
+ frame_padtop
+ frame_padbottom
;
2963 video_enc
->sample_aspect_ratio
= av_d2q(frame_aspect_ratio
*video_enc
->height
/video_enc
->width
, 255);
2964 video_enc
->pix_fmt
= frame_pix_fmt
;
2966 if(codec
&& codec
->pix_fmts
){
2967 const enum PixelFormat
*p
= codec
->pix_fmts
;
2969 if(*p
== video_enc
->pix_fmt
)
2973 video_enc
->pix_fmt
= codec
->pix_fmts
[0];
2977 video_enc
->gop_size
= 0;
2978 if (video_qscale
|| same_quality
) {
2979 video_enc
->flags
|= CODEC_FLAG_QSCALE
;
2980 video_enc
->global_quality
=
2981 st
->quality
= FF_QP2LAMBDA
* video_qscale
;
2985 video_enc
->intra_matrix
= intra_matrix
;
2987 video_enc
->inter_matrix
= inter_matrix
;
2989 video_enc
->thread_count
= thread_count
;
2990 p
= video_rc_override_string
;
2993 int e
=sscanf(p
, "%d,%d,%d", &start
, &end
, &q
);
2995 fprintf(stderr
, "error parsing rc_override\n");
2998 video_enc
->rc_override
=
2999 av_realloc(video_enc
->rc_override
,
3000 sizeof(RcOverride
)*(i
+1));
3001 video_enc
->rc_override
[i
].start_frame
= start
;
3002 video_enc
->rc_override
[i
].end_frame
= end
;
3004 video_enc
->rc_override
[i
].qscale
= q
;
3005 video_enc
->rc_override
[i
].quality_factor
= 1.0;
3008 video_enc
->rc_override
[i
].qscale
= 0;
3009 video_enc
->rc_override
[i
].quality_factor
= -q
/100.0;
3014 video_enc
->rc_override_count
=i
;
3015 if (!video_enc
->rc_initial_buffer_occupancy
)
3016 video_enc
->rc_initial_buffer_occupancy
= video_enc
->rc_buffer_size
*3/4;
3017 video_enc
->me_threshold
= me_threshold
;
3018 video_enc
->intra_dc_precision
= intra_dc_precision
- 8;
3019 video_enc
->strict_std_compliance
= strict
;
3022 video_enc
->flags
|= CODEC_FLAG_PSNR
;
3027 video_enc
->flags
|= CODEC_FLAG_PASS1
;
3029 video_enc
->flags
|= CODEC_FLAG_PASS2
;
3034 /* reset some key parameters */
3036 av_freep(&video_codec_name
);
3037 video_stream_copy
= 0;
3040 static void new_audio_stream(AVFormatContext
*oc
)
3043 AVCodecContext
*audio_enc
;
3046 st
= av_new_stream(oc
, oc
->nb_streams
);
3048 fprintf(stderr
, "Could not alloc stream\n");
3051 avcodec_get_context_defaults2(st
->codec
, CODEC_TYPE_AUDIO
);
3053 bitstream_filters
[nb_output_files
][oc
->nb_streams
- 1]= audio_bitstream_filters
;
3054 audio_bitstream_filters
= NULL
;
3057 avcodec_thread_init(st
->codec
, thread_count
);
3059 audio_enc
= st
->codec
;
3060 audio_enc
->codec_type
= CODEC_TYPE_AUDIO
;
3061 audio_enc
->strict_std_compliance
= strict
;
3064 audio_enc
->codec_tag
= audio_codec_tag
;
3066 if (oc
->oformat
->flags
& AVFMT_GLOBALHEADER
) {
3067 audio_enc
->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
3068 avctx_opts
[CODEC_TYPE_AUDIO
]->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
3070 if (audio_stream_copy
) {
3071 st
->stream_copy
= 1;
3072 audio_enc
->channels
= audio_channels
;
3074 codec_id
= av_guess_codec(oc
->oformat
, NULL
, oc
->filename
, NULL
, CODEC_TYPE_AUDIO
);
3076 set_context_opts(audio_enc
, avctx_opts
[CODEC_TYPE_AUDIO
], AV_OPT_FLAG_AUDIO_PARAM
| AV_OPT_FLAG_ENCODING_PARAM
);
3078 if (audio_codec_name
)
3079 codec_id
= find_codec_or_die(audio_codec_name
, CODEC_TYPE_AUDIO
, 1);
3080 audio_enc
->codec_id
= codec_id
;
3082 if (audio_qscale
> QSCALE_NONE
) {
3083 audio_enc
->flags
|= CODEC_FLAG_QSCALE
;
3084 audio_enc
->global_quality
= st
->quality
= FF_QP2LAMBDA
* audio_qscale
;
3086 audio_enc
->thread_count
= thread_count
;
3087 audio_enc
->channels
= audio_channels
;
3089 audio_enc
->sample_rate
= audio_sample_rate
;
3090 audio_enc
->time_base
= (AVRational
){1, audio_sample_rate
};
3091 if (audio_language
) {
3092 av_strlcpy(st
->language
, audio_language
, sizeof(st
->language
));
3093 av_free(audio_language
);
3094 audio_language
= NULL
;
3097 /* reset some key parameters */
3099 av_freep(&audio_codec_name
);
3100 audio_stream_copy
= 0;
3103 static void new_subtitle_stream(AVFormatContext
*oc
)
3106 AVCodecContext
*subtitle_enc
;
3108 st
= av_new_stream(oc
, oc
->nb_streams
);
3110 fprintf(stderr
, "Could not alloc stream\n");
3113 avcodec_get_context_defaults2(st
->codec
, CODEC_TYPE_SUBTITLE
);
3115 bitstream_filters
[nb_output_files
][oc
->nb_streams
- 1]= subtitle_bitstream_filters
;
3116 subtitle_bitstream_filters
= NULL
;
3118 subtitle_enc
= st
->codec
;
3119 subtitle_enc
->codec_type
= CODEC_TYPE_SUBTITLE
;
3120 if (subtitle_stream_copy
) {
3121 st
->stream_copy
= 1;
3123 set_context_opts(avctx_opts
[CODEC_TYPE_SUBTITLE
], subtitle_enc
, AV_OPT_FLAG_SUBTITLE_PARAM
| AV_OPT_FLAG_ENCODING_PARAM
);
3124 subtitle_enc
->codec_id
= find_codec_or_die(subtitle_codec_name
, CODEC_TYPE_SUBTITLE
, 1);
3127 if (subtitle_language
) {
3128 av_strlcpy(st
->language
, subtitle_language
, sizeof(st
->language
));
3129 av_free(subtitle_language
);
3130 subtitle_language
= NULL
;
3133 subtitle_disable
= 0;
3134 av_freep(&subtitle_codec_name
);
3135 subtitle_stream_copy
= 0;
3138 static void opt_new_audio_stream(void)
3140 AVFormatContext
*oc
;
3141 if (nb_output_files
<= 0) {
3142 fprintf(stderr
, "At least one output file must be specified\n");
3145 oc
= output_files
[nb_output_files
- 1];
3146 new_audio_stream(oc
);
3149 static void opt_new_video_stream(void)
3151 AVFormatContext
*oc
;
3152 if (nb_output_files
<= 0) {
3153 fprintf(stderr
, "At least one output file must be specified\n");
3156 oc
= output_files
[nb_output_files
- 1];
3157 new_video_stream(oc
);
3160 static void opt_new_subtitle_stream(void)
3162 AVFormatContext
*oc
;
3163 if (nb_output_files
<= 0) {
3164 fprintf(stderr
, "At least one output file must be specified\n");
3167 oc
= output_files
[nb_output_files
- 1];
3168 new_subtitle_stream(oc
);
3171 static void opt_output_file(const char *filename
)
3173 AVFormatContext
*oc
;
3174 int use_video
, use_audio
, use_subtitle
;
3175 int input_has_video
, input_has_audio
, input_has_subtitle
;
3176 AVFormatParameters params
, *ap
= ¶ms
;
3178 if (!strcmp(filename
, "-"))
3181 oc
= av_alloc_format_context();
3183 if (!file_oformat
) {
3184 file_oformat
= guess_format(NULL
, filename
, NULL
);
3185 if (!file_oformat
) {
3186 fprintf(stderr
, "Unable to find a suitable output format for '%s'\n",
3192 oc
->oformat
= file_oformat
;
3193 av_strlcpy(oc
->filename
, filename
, sizeof(oc
->filename
));
3195 if (!strcmp(file_oformat
->name
, "ffm") &&
3196 av_strstart(filename
, "http:", NULL
)) {
3197 /* special case for files sent to ffserver: we get the stream
3198 parameters from ffserver */
3199 int err
= read_ffserver_streams(oc
, filename
);
3201 print_error(filename
, err
);
3205 use_video
= file_oformat
->video_codec
!= CODEC_ID_NONE
|| video_stream_copy
|| video_codec_name
;
3206 use_audio
= file_oformat
->audio_codec
!= CODEC_ID_NONE
|| audio_stream_copy
|| audio_codec_name
;
3207 use_subtitle
= file_oformat
->subtitle_codec
!= CODEC_ID_NONE
|| subtitle_stream_copy
|| subtitle_codec_name
;
3209 /* disable if no corresponding type found and at least one
3211 if (nb_input_files
> 0) {
3212 check_audio_video_sub_inputs(&input_has_video
, &input_has_audio
,
3213 &input_has_subtitle
);
3214 if (!input_has_video
)
3216 if (!input_has_audio
)
3218 if (!input_has_subtitle
)
3222 /* manual disable */
3223 if (audio_disable
) {
3226 if (video_disable
) {
3229 if (subtitle_disable
) {
3234 new_video_stream(oc
);
3238 new_audio_stream(oc
);
3242 new_subtitle_stream(oc
);
3245 oc
->timestamp
= rec_timestamp
;
3248 av_strlcpy(oc
->title
, str_title
, sizeof(oc
->title
));
3250 av_strlcpy(oc
->author
, str_author
, sizeof(oc
->author
));
3252 av_strlcpy(oc
->copyright
, str_copyright
, sizeof(oc
->copyright
));
3254 av_strlcpy(oc
->comment
, str_comment
, sizeof(oc
->comment
));
3256 av_strlcpy(oc
->album
, str_album
, sizeof(oc
->album
));
3258 av_strlcpy(oc
->genre
, str_genre
, sizeof(oc
->genre
));
3261 output_files
[nb_output_files
++] = oc
;
3263 /* check filename in case of an image number is expected */
3264 if (oc
->oformat
->flags
& AVFMT_NEEDNUMBER
) {
3265 if (!av_filename_number_test(oc
->filename
)) {
3266 print_error(oc
->filename
, AVERROR_NUMEXPECTED
);
3271 if (!(oc
->oformat
->flags
& AVFMT_NOFILE
)) {
3272 /* test if it already exists to avoid loosing precious files */
3273 if (!file_overwrite
&&
3274 (strchr(filename
, ':') == NULL
||
3275 filename
[1] == ':' ||
3276 av_strstart(filename
, "file:", NULL
))) {
3277 if (url_exist(filename
)) {
3281 fprintf(stderr
,"File '%s' already exists. Overwrite ? [y/N] ", filename
);
3284 if (toupper(c
) != 'Y') {
3285 fprintf(stderr
, "Not overwriting - exiting\n");
3290 fprintf(stderr
,"File '%s' already exists. Exiting.\n", filename
);
3297 if (url_fopen(&oc
->pb
, filename
, URL_WRONLY
) < 0) {
3298 fprintf(stderr
, "Could not open '%s'\n", filename
);
3303 memset(ap
, 0, sizeof(*ap
));
3304 if (av_set_parameters(oc
, ap
) < 0) {
3305 fprintf(stderr
, "%s: Invalid encoding parameters\n",
3310 oc
->preload
= (int)(mux_preload
*AV_TIME_BASE
);
3311 oc
->max_delay
= (int)(mux_max_delay
*AV_TIME_BASE
);
3312 oc
->loop_output
= loop_output
;
3314 set_context_opts(oc
, avformat_opts
, AV_OPT_FLAG_ENCODING_PARAM
);
3316 /* reset some options */
3317 file_oformat
= NULL
;
3318 file_iformat
= NULL
;
3321 /* same option as mencoder */
3322 static void opt_pass(const char *pass_str
)
3325 pass
= atoi(pass_str
);
3326 if (pass
!= 1 && pass
!= 2) {
3327 fprintf(stderr
, "pass number can be only 1 or 2\n");
3333 static int64_t getutime(void)
3335 #ifdef HAVE_GETRUSAGE
3336 struct rusage rusage
;
3338 getrusage(RUSAGE_SELF
, &rusage
);
3339 return (rusage
.ru_utime
.tv_sec
* 1000000LL) + rusage
.ru_utime
.tv_usec
;
3340 #elif defined(HAVE_GETPROCESSTIMES)
3342 FILETIME c
, e
, k
, u
;
3343 proc
= GetCurrentProcess();
3344 GetProcessTimes(proc
, &c
, &e
, &k
, &u
);
3345 return ((int64_t) u
.dwHighDateTime
<< 32 | u
.dwLowDateTime
) / 10;
3347 return av_gettime();
3351 static void parse_matrix_coeffs(uint16_t *dest
, const char *str
)
3354 const char *p
= str
;
3361 fprintf(stderr
, "Syntax error in matrix \"%s\" at coeff %d\n", str
, i
);
3368 static void opt_inter_matrix(const char *arg
)
3370 inter_matrix
= av_mallocz(sizeof(uint16_t) * 64);
3371 parse_matrix_coeffs(inter_matrix
, arg
);
3374 static void opt_intra_matrix(const char *arg
)
3376 intra_matrix
= av_mallocz(sizeof(uint16_t) * 64);
3377 parse_matrix_coeffs(intra_matrix
, arg
);
3381 * Trivial log callback.
3382 * Only suitable for show_help and similar since it lacks prefix handling.
3384 static void log_callback_help(void* ptr
, int level
, const char* fmt
, va_list vl
)
3386 vfprintf(stdout
, fmt
, vl
);
3389 static void show_help(void)
3391 av_log_set_callback(log_callback_help
);
3392 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3393 "Hyper fast Audio and Video encoder\n");
3395 show_help_options(options
, "Main options:\n",
3396 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_SUBTITLE
| OPT_GRAB
, 0);
3397 show_help_options(options
, "\nAdvanced options:\n",
3398 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_SUBTITLE
| OPT_GRAB
,
3400 show_help_options(options
, "\nVideo options:\n",
3401 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_GRAB
,
3403 show_help_options(options
, "\nAdvanced Video options:\n",
3404 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_GRAB
,
3405 OPT_VIDEO
| OPT_EXPERT
);
3406 show_help_options(options
, "\nAudio options:\n",
3407 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_GRAB
,
3409 show_help_options(options
, "\nAdvanced Audio options:\n",
3410 OPT_EXPERT
| OPT_AUDIO
| OPT_VIDEO
| OPT_GRAB
,
3411 OPT_AUDIO
| OPT_EXPERT
);
3412 show_help_options(options
, "\nSubtitle options:\n",
3413 OPT_SUBTITLE
| OPT_GRAB
,
3415 show_help_options(options
, "\nAudio/Video grab options:\n",
3419 av_opt_show(avctx_opts
[0], NULL
);
3421 av_opt_show(avformat_opts
, NULL
);
3423 av_opt_show(sws_opts
, NULL
);
3426 static void opt_target(const char *arg
)
3429 static const char *const frame_rates
[] = {"25", "30000/1001", "24000/1001"};
3431 if(!strncmp(arg
, "pal-", 4)) {
3434 } else if(!strncmp(arg
, "ntsc-", 5)) {
3437 } else if(!strncmp(arg
, "film-", 5)) {
3442 /* Calculate FR via float to avoid int overflow */
3443 fr
= (int)(frame_rate
.num
* 1000.0 / frame_rate
.den
);
3446 } else if((fr
== 29970) || (fr
== 23976)) {
3449 /* Try to determine PAL/NTSC by peeking in the input files */
3450 if(nb_input_files
) {
3452 for(j
= 0; j
< nb_input_files
; j
++) {
3453 for(i
= 0; i
< input_files
[j
]->nb_streams
; i
++) {
3454 AVCodecContext
*c
= input_files
[j
]->streams
[i
]->codec
;
3455 if(c
->codec_type
!= CODEC_TYPE_VIDEO
)
3457 fr
= c
->time_base
.den
* 1000 / c
->time_base
.num
;
3461 } else if((fr
== 29970) || (fr
== 23976)) {
3471 if(verbose
&& norm
>= 0)
3472 fprintf(stderr
, "Assuming %s for target.\n", norm
? "NTSC" : "PAL");
3476 fprintf(stderr
, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3477 fprintf(stderr
, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3478 fprintf(stderr
, "or set a framerate with \"-r xxx\".\n");
3482 if(!strcmp(arg
, "vcd")) {
3484 opt_video_codec("mpeg1video");
3485 opt_audio_codec("mp2");
3488 opt_frame_size(norm
? "352x240" : "352x288");
3489 opt_frame_rate(frame_rates
[norm
]);
3490 opt_default("gop", norm
? "18" : "15");
3492 opt_default("b", "1150000");
3493 opt_default("maxrate", "1150000");
3494 opt_default("minrate", "1150000");
3495 opt_default("bufsize", "327680"); // 40*1024*8;
3497 opt_default("ab", "224000");
3498 audio_sample_rate
= 44100;
3501 opt_default("packetsize", "2324");
3502 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3504 /* We have to offset the PTS, so that it is consistent with the SCR.
3505 SCR starts at 36000, but the first two packs contain only padding
3506 and the first pack from the other stream, respectively, may also have
3507 been written before.
3508 So the real data starts at SCR 36000+3*1200. */
3509 mux_preload
= (36000+3*1200) / 90000.0; //0.44
3510 } else if(!strcmp(arg
, "svcd")) {
3512 opt_video_codec("mpeg2video");
3513 opt_audio_codec("mp2");
3516 opt_frame_size(norm
? "480x480" : "480x576");
3517 opt_frame_rate(frame_rates
[norm
]);
3518 opt_default("gop", norm
? "18" : "15");
3520 opt_default("b", "2040000");
3521 opt_default("maxrate", "2516000");
3522 opt_default("minrate", "0"); //1145000;
3523 opt_default("bufsize", "1835008"); //224*1024*8;
3524 opt_default("flags", "+SCAN_OFFSET");
3527 opt_default("ab", "224000");
3528 audio_sample_rate
= 44100;
3530 opt_default("packetsize", "2324");
3532 } else if(!strcmp(arg
, "dvd")) {
3534 opt_video_codec("mpeg2video");
3535 opt_audio_codec("ac3");
3538 opt_frame_size(norm
? "720x480" : "720x576");
3539 opt_frame_rate(frame_rates
[norm
]);
3540 opt_default("gop", norm
? "18" : "15");
3542 opt_default("b", "6000000");
3543 opt_default("maxrate", "9000000");
3544 opt_default("minrate", "0"); //1500000;
3545 opt_default("bufsize", "1835008"); //224*1024*8;
3547 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3548 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3550 opt_default("ab", "448000");
3551 audio_sample_rate
= 48000;
3553 } else if(!strncmp(arg
, "dv", 2)) {
3557 opt_frame_size(norm
? "720x480" : "720x576");
3558 opt_frame_pix_fmt(!strncmp(arg
, "dv50", 4) ? "yuv422p" :
3559 (norm
? "yuv411p" : "yuv420p"));
3560 opt_frame_rate(frame_rates
[norm
]);
3562 audio_sample_rate
= 48000;
3566 fprintf(stderr
, "Unknown target: %s\n", arg
);
3571 static void opt_vstats_file (const char *arg
)
3573 av_free (vstats_filename
);
3574 vstats_filename
=av_strdup (arg
);
3577 static void opt_vstats (void)
3580 time_t today2
= time(NULL
);
3581 struct tm
*today
= localtime(&today2
);
3583 snprintf(filename
, sizeof(filename
), "vstats_%02d%02d%02d.log", today
->tm_hour
, today
->tm_min
,
3585 opt_vstats_file(filename
);
3588 static int opt_bsf(const char *opt
, const char *arg
)
3590 AVBitStreamFilterContext
*bsfc
= av_bitstream_filter_init(arg
); //FIXME split name and args for filter at '='
3591 AVBitStreamFilterContext
**bsfp
;
3594 fprintf(stderr
, "Unknown bitstream filter %s\n", arg
);
3598 bsfp
= *opt
== 'v' ? &video_bitstream_filters
:
3599 *opt
== 'a' ? &audio_bitstream_filters
:
3600 &subtitle_bitstream_filters
;
3602 bsfp
= &(*bsfp
)->next
;
3609 static int opt_preset(const char *opt
, const char *arg
)
3612 char tmp
[1000], tmp2
[1000];
3614 const char *base
[3]= { getenv("HOME"),
3619 for(i
=!base
[0]; i
<3 && !f
; i
++){
3620 snprintf(tmp
, sizeof(tmp
), "%s/%sffmpeg/%s.ffpreset", base
[i
], i
? "" : ".", arg
);
3623 char *codec_name
= *opt
== 'v' ? video_codec_name
:
3624 *opt
== 'a' ? audio_codec_name
:
3625 subtitle_codec_name
;
3626 snprintf(tmp
, sizeof(tmp
), "%s/%sffmpeg/%s-%s.ffpreset", base
[i
], i
? "" : ".", codec_name
, arg
);
3632 fprintf(stderr
, "Preset file not found\n");
3637 int e
= fscanf(f
, "%999[^=]=%999[^\n]\n", tmp
, tmp2
);
3639 fprintf(stderr
, "Preset file invalid\n");
3642 opt_default(tmp
, tmp2
);
3650 static const OptionDef options
[] = {
3652 { "L", OPT_EXIT
, {(void*)show_license
}, "show license" },
3653 { "h", OPT_EXIT
, {(void*)show_help
}, "show help" },
3654 { "version", OPT_EXIT
, {(void*)show_version
}, "show version" },
3655 { "formats", OPT_EXIT
, {(void*)show_formats
}, "show available formats, codecs, protocols, ..." },
3656 { "f", HAS_ARG
, {(void*)opt_format
}, "force format", "fmt" },
3657 { "i", HAS_ARG
, {(void*)opt_input_file
}, "input file name", "filename" },
3658 { "y", OPT_BOOL
, {(void*)&file_overwrite
}, "overwrite output files" },
3659 { "map", HAS_ARG
| OPT_EXPERT
, {(void*)opt_map
}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3660 { "map_meta_data", HAS_ARG
| OPT_EXPERT
, {(void*)opt_map_meta_data
}, "set meta data information of outfile from infile", "outfile:infile" },
3661 { "t", OPT_FUNC2
| HAS_ARG
, {(void*)opt_recording_time
}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3662 { "fs", HAS_ARG
| OPT_INT64
, {(void*)&limit_filesize
}, "set the limit file size in bytes", "limit_size" }, //
3663 { "ss", OPT_FUNC2
| HAS_ARG
, {(void*)opt_start_time
}, "set the start time offset", "time_off" },
3664 { "itsoffset", OPT_FUNC2
| HAS_ARG
, {(void*)opt_input_ts_offset
}, "set the input ts offset", "time_off" },
3665 { "title", HAS_ARG
| OPT_STRING
, {(void*)&str_title
}, "set the title", "string" },
3666 { "timestamp", OPT_FUNC2
| HAS_ARG
, {(void*)&opt_rec_timestamp
}, "set the timestamp", "time" },
3667 { "author", HAS_ARG
| OPT_STRING
, {(void*)&str_author
}, "set the author", "string" },
3668 { "copyright", HAS_ARG
| OPT_STRING
, {(void*)&str_copyright
}, "set the copyright", "string" },
3669 { "comment", HAS_ARG
| OPT_STRING
, {(void*)&str_comment
}, "set the comment", "string" },
3670 { "genre", HAS_ARG
| OPT_STRING
, {(void*)&str_genre
}, "set the genre", "string" },
3671 { "album", HAS_ARG
| OPT_STRING
, {(void*)&str_album
}, "set the album", "string" },
3672 { "dframes", OPT_INT
| HAS_ARG
, {(void*)&max_frames
[CODEC_TYPE_DATA
]}, "set the number of data frames to record", "number" },
3673 { "benchmark", OPT_BOOL
| OPT_EXPERT
, {(void*)&do_benchmark
},
3674 "add timings for benchmarking" },
3675 { "dump", OPT_BOOL
| OPT_EXPERT
, {(void*)&do_pkt_dump
},
3676 "dump each input packet" },
3677 { "hex", OPT_BOOL
| OPT_EXPERT
, {(void*)&do_hex_dump
},
3678 "when dumping packets, also dump the payload" },
3679 { "re", OPT_BOOL
| OPT_EXPERT
, {(void*)&rate_emu
}, "read input at native frame rate", "" },
3680 { "loop_input", OPT_BOOL
| OPT_EXPERT
, {(void*)&loop_input
}, "loop (current only works with images)" },
3681 { "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)", "" },
3682 { "v", HAS_ARG
| OPT_FUNC2
, {(void*)opt_verbose
}, "set the logging verbosity level", "number" },
3683 { "target", HAS_ARG
, {(void*)opt_target
}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3684 { "threads", OPT_FUNC2
| HAS_ARG
| OPT_EXPERT
, {(void*)opt_thread_count
}, "thread count", "count" },
3685 { "vsync", HAS_ARG
| OPT_INT
| OPT_EXPERT
, {(void*)&video_sync_method
}, "video sync method", "" },
3686 { "async", HAS_ARG
| OPT_INT
| OPT_EXPERT
, {(void*)&audio_sync_method
}, "audio sync method", "" },
3687 { "adrift_threshold", HAS_ARG
| OPT_FLOAT
| OPT_EXPERT
, {(void*)&audio_drift_threshold
}, "audio drift threshold", "threshold" },
3688 { "vglobal", HAS_ARG
| OPT_INT
| OPT_EXPERT
, {(void*)&video_global_header
}, "video global header storage type", "" },
3689 { "copyts", OPT_BOOL
| OPT_EXPERT
, {(void*)©_ts
}, "copy timestamps" },
3690 { "shortest", OPT_BOOL
| OPT_EXPERT
, {(void*)&opt_shortest
}, "finish encoding within shortest input" }, //
3691 { "dts_delta_threshold", HAS_ARG
| OPT_FLOAT
| OPT_EXPERT
, {(void*)&dts_delta_threshold
}, "timestamp discontinuity delta threshold", "threshold" },
3692 { "programid", HAS_ARG
| OPT_INT
| OPT_EXPERT
, {(void*)&opt_programid
}, "desired program number", "" },
3695 { "b", OPT_FUNC2
| HAS_ARG
| OPT_VIDEO
, {(void*)opt_bitrate
}, "set bitrate (in bits/s)", "bitrate" },
3696 { "vb", OPT_FUNC2
| HAS_ARG
| OPT_VIDEO
, {(void*)opt_bitrate
}, "set bitrate (in bits/s)", "bitrate" },
3697 { "vframes", OPT_INT
| HAS_ARG
| OPT_VIDEO
, {(void*)&max_frames
[CODEC_TYPE_VIDEO
]}, "set the number of video frames to record", "number" },
3698 { "r", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_rate
}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3699 { "s", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_size
}, "set frame size (WxH or abbreviation)", "size" },
3700 { "aspect", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_aspect_ratio
}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3701 { "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" },
3702 { "croptop", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_crop_top
}, "set top crop band size (in pixels)", "size" },
3703 { "cropbottom", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_crop_bottom
}, "set bottom crop band size (in pixels)", "size" },
3704 { "cropleft", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_crop_left
}, "set left crop band size (in pixels)", "size" },
3705 { "cropright", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_crop_right
}, "set right crop band size (in pixels)", "size" },
3706 { "padtop", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_pad_top
}, "set top pad band size (in pixels)", "size" },
3707 { "padbottom", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_pad_bottom
}, "set bottom pad band size (in pixels)", "size" },
3708 { "padleft", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_pad_left
}, "set left pad band size (in pixels)", "size" },
3709 { "padright", HAS_ARG
| OPT_VIDEO
, {(void*)opt_frame_pad_right
}, "set right pad band size (in pixels)", "size" },
3710 { "padcolor", HAS_ARG
| OPT_VIDEO
, {(void*)opt_pad_color
}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3711 { "intra", OPT_BOOL
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&intra_only
}, "use only intra frames"},
3712 { "vn", OPT_BOOL
| OPT_VIDEO
, {(void*)&video_disable
}, "disable video" },
3713 { "vdt", OPT_INT
| HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&video_discard
}, "discard threshold", "n" },
3714 { "qscale", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_qscale
}, "use fixed video quantizer scale (VBR)", "q" },
3715 { "rc_override", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_video_rc_override_string
}, "rate control override for specific intervals", "override" },
3716 { "vcodec", HAS_ARG
| OPT_VIDEO
, {(void*)opt_video_codec
}, "force video codec ('copy' to copy stream)", "codec" },
3717 { "me_threshold", HAS_ARG
| OPT_FUNC2
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_me_threshold
}, "motion estimaton threshold", "threshold" },
3718 { "strict", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_strict
}, "how strictly to follow the standards", "strictness" },
3719 { "sameq", OPT_BOOL
| OPT_VIDEO
, {(void*)&same_quality
},
3720 "use same video quality as source (implies VBR)" },
3721 { "pass", HAS_ARG
| OPT_VIDEO
, {(void*)&opt_pass
}, "select the pass number (1 or 2)", "n" },
3722 { "passlogfile", HAS_ARG
| OPT_STRING
| OPT_VIDEO
, {(void*)&pass_logfilename
}, "select two pass log file name", "file" },
3723 { "deinterlace", OPT_BOOL
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&do_deinterlace
},
3724 "deinterlace pictures" },
3725 { "psnr", OPT_BOOL
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&do_psnr
}, "calculate PSNR of compressed frames" },
3726 { "vstats", OPT_EXPERT
| OPT_VIDEO
, {(void*)&opt_vstats
}, "dump video coding statistics to file" },
3727 { "vstats_file", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_vstats_file
}, "dump video coding statistics to file", "file" },
3729 { "vhook", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)add_frame_hooker
}, "insert video processing module", "module" },
3731 { "intra_matrix", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_intra_matrix
}, "specify intra matrix coeffs", "matrix" },
3732 { "inter_matrix", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_inter_matrix
}, "specify inter matrix coeffs", "matrix" },
3733 { "top", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_top_field_first
}, "top=1/bottom=0/auto=-1 field first", "" },
3734 { "dc", OPT_INT
| HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)&intra_dc_precision
}, "intra_dc_precision", "precision" },
3735 { "vtag", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
, {(void*)opt_video_tag
}, "force video tag/fourcc", "fourcc/tag" },
3736 { "newvideo", OPT_VIDEO
, {(void*)opt_new_video_stream
}, "add a new video stream to the current output stream" },
3737 { "qphist", OPT_BOOL
| OPT_EXPERT
| OPT_VIDEO
, { (void *)&qp_hist
}, "show QP histogram" },
3740 { "ab", OPT_FUNC2
| HAS_ARG
| OPT_AUDIO
, {(void*)opt_bitrate
}, "set bitrate (in bits/s)", "bitrate" },
3741 { "aframes", OPT_INT
| HAS_ARG
| OPT_AUDIO
, {(void*)&max_frames
[CODEC_TYPE_AUDIO
]}, "set the number of audio frames to record", "number" },
3742 { "aq", OPT_FLOAT
| HAS_ARG
| OPT_AUDIO
, {(void*)&audio_qscale
}, "set audio quality (codec-specific)", "quality", },
3743 { "ar", HAS_ARG
| OPT_FUNC2
| OPT_AUDIO
, {(void*)opt_audio_rate
}, "set audio sampling rate (in Hz)", "rate" },
3744 { "ac", HAS_ARG
| OPT_FUNC2
| OPT_AUDIO
, {(void*)opt_audio_channels
}, "set number of audio channels", "channels" },
3745 { "an", OPT_BOOL
| OPT_AUDIO
, {(void*)&audio_disable
}, "disable audio" },
3746 { "acodec", HAS_ARG
| OPT_AUDIO
, {(void*)opt_audio_codec
}, "force audio codec ('copy' to copy stream)", "codec" },
3747 { "atag", HAS_ARG
| OPT_EXPERT
| OPT_AUDIO
, {(void*)opt_audio_tag
}, "force audio tag/fourcc", "fourcc/tag" },
3748 { "vol", OPT_INT
| HAS_ARG
| OPT_AUDIO
, {(void*)&audio_volume
}, "change audio volume (256=normal)" , "volume" }, //
3749 { "newaudio", OPT_AUDIO
, {(void*)opt_new_audio_stream
}, "add a new audio stream to the current output stream" },
3750 { "alang", HAS_ARG
| OPT_STRING
| OPT_AUDIO
, {(void *)&audio_language
}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3752 /* subtitle options */
3753 { "sn", OPT_BOOL
| OPT_SUBTITLE
, {(void*)&subtitle_disable
}, "disable subtitle" },
3754 { "scodec", HAS_ARG
| OPT_SUBTITLE
, {(void*)opt_subtitle_codec
}, "force subtitle codec ('copy' to copy stream)", "codec" },
3755 { "newsubtitle", OPT_SUBTITLE
, {(void*)opt_new_subtitle_stream
}, "add a new subtitle stream to the current output stream" },
3756 { "slang", HAS_ARG
| OPT_STRING
| OPT_SUBTITLE
, {(void *)&subtitle_language
}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3759 { "vc", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
| OPT_GRAB
, {(void*)opt_video_channel
}, "set video grab channel (DV1394 only)", "channel" },
3760 { "tvstd", HAS_ARG
| OPT_EXPERT
| OPT_VIDEO
| OPT_GRAB
, {(void*)opt_video_standard
}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3761 { "isync", OPT_BOOL
| OPT_EXPERT
| OPT_GRAB
, {(void*)&input_sync
}, "sync read on input", "" },
3764 { "muxdelay", OPT_FLOAT
| HAS_ARG
| OPT_EXPERT
, {(void*)&mux_max_delay
}, "set the maximum demux-decode delay", "seconds" },
3765 { "muxpreload", OPT_FLOAT
| HAS_ARG
| OPT_EXPERT
, {(void*)&mux_preload
}, "set the initial demux-decode delay", "seconds" },
3767 { "absf", OPT_FUNC2
| HAS_ARG
| OPT_AUDIO
| OPT_EXPERT
, {(void*)opt_bsf
}, "", "bitstream_filter" },
3768 { "vbsf", OPT_FUNC2
| HAS_ARG
| OPT_VIDEO
| OPT_EXPERT
, {(void*)opt_bsf
}, "", "bitstream_filter" },
3769 { "sbsf", OPT_FUNC2
| HAS_ARG
| OPT_SUBTITLE
| OPT_EXPERT
, {(void*)opt_bsf
}, "", "bitstream_filter" },
3771 { "apre", OPT_FUNC2
| HAS_ARG
| OPT_AUDIO
| OPT_EXPERT
, {(void*)opt_preset
}, "", "preset" },
3772 { "vpre", OPT_FUNC2
| HAS_ARG
| OPT_VIDEO
| OPT_EXPERT
, {(void*)opt_preset
}, "", "preset" },
3773 { "spre", OPT_FUNC2
| HAS_ARG
| OPT_SUBTITLE
| OPT_EXPERT
, {(void*)opt_preset
}, "", "preset" },
3775 { "default", OPT_FUNC2
| HAS_ARG
| OPT_AUDIO
| OPT_VIDEO
| OPT_EXPERT
, {(void*)opt_default
}, "generic catch all option", "" },
3779 int main(int argc
, char **argv
)
3784 avcodec_register_all();
3785 avdevice_register_all();
3788 if(isatty(STDIN_FILENO
))
3789 url_set_interrupt_cb(decode_interrupt_cb
);
3791 for(i
=0; i
<CODEC_TYPE_NB
; i
++){
3792 avctx_opts
[i
]= avcodec_alloc_context2(i
);
3794 avformat_opts
= av_alloc_format_context();
3795 sws_opts
= sws_getContext(16,16,0, 16,16,0, sws_flags
, NULL
,NULL
,NULL
);
3804 parse_options(argc
, argv
, options
, opt_output_file
);
3806 /* file converter / grab */
3807 if (nb_output_files
<= 0) {
3808 fprintf(stderr
, "Must supply at least one output file\n");
3812 if (nb_input_files
== 0) {
3813 fprintf(stderr
, "Must supply at least one input file\n");
3818 av_encode(output_files
, nb_output_files
, input_files
, nb_input_files
,
3819 stream_maps
, nb_stream_maps
);
3820 ti
= getutime() - ti
;
3822 printf("bench: utime=%0.3fs\n", ti
/ 1000000.0);