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
32 #include "framehook.h"
42 #include <sys/ioctl.h>
45 #include <sys/resource.h>
48 #include <sys/types.h>
49 #include <sys/select.h>
52 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
61 #if !defined(INFINITY) && defined(HUGE_VAL)
62 #define INFINITY HUGE_VAL
67 /* select an input stream for an output stream */
68 typedef struct AVStreamMap
{
72 int sync_stream_index
;
75 /** select an input file for an output file */
76 typedef struct AVMetaDataMap
{
81 extern const OptionDef options
[];
83 static void show_help(void);
84 static void show_license(void);
85 static int opt_default(const char *opt
, const char *arg
);
89 static AVFormatContext
*input_files
[MAX_FILES
];
90 static int64_t input_files_ts_offset
[MAX_FILES
];
91 static int nb_input_files
= 0;
93 static AVFormatContext
*output_files
[MAX_FILES
];
94 static int nb_output_files
= 0;
96 static AVStreamMap stream_maps
[MAX_FILES
];
97 static int nb_stream_maps
;
99 static AVMetaDataMap meta_data_maps
[MAX_FILES
];
100 static int nb_meta_data_maps
;
102 static AVInputFormat
*file_iformat
;
103 static AVOutputFormat
*file_oformat
;
104 static int frame_width
= 0;
105 static int frame_height
= 0;
106 static float frame_aspect_ratio
= 0;
107 static enum PixelFormat frame_pix_fmt
= PIX_FMT_NONE
;
108 static int frame_padtop
= 0;
109 static int frame_padbottom
= 0;
110 static int frame_padleft
= 0;
111 static int frame_padright
= 0;
112 static int padcolor
[3] = {16,128,128}; /* default to black */
113 static int frame_topBand
= 0;
114 static int frame_bottomBand
= 0;
115 static int frame_leftBand
= 0;
116 static int frame_rightBand
= 0;
117 static int max_frames
[4] = {INT_MAX
, INT_MAX
, INT_MAX
, INT_MAX
};
118 static AVRational frame_rate
= (AVRational
) {25,1};
119 static float video_qscale
= 0;
120 static int video_qdiff
= 3;
121 static uint16_t *intra_matrix
= NULL
;
122 static uint16_t *inter_matrix
= NULL
;
123 #if 0 //experimental, (can be removed)
124 static float video_rc_qsquish
=1.0;
125 static float video_rc_qmod_amp
=0;
126 static int video_rc_qmod_freq
=0;
128 static char *video_rc_override_string
=NULL
;
129 static char *video_rc_eq
="tex^qComp";
130 static int me_method
= ME_EPZS
;
131 static int video_disable
= 0;
132 static int video_discard
= 0;
133 static int video_codec_id
= CODEC_ID_NONE
;
134 static int video_codec_tag
= 0;
135 static int same_quality
= 0;
136 static int do_deinterlace
= 0;
137 static int strict
= 0;
138 static int top_field_first
= -1;
139 static int me_threshold
= 0;
140 static int intra_dc_precision
= 8;
141 static int loop_input
= 0;
142 static int loop_output
= AVFMT_NOOUTPUTLOOP
;
143 static int qp_hist
= 0;
145 static int intra_only
= 0;
146 static int audio_sample_rate
= 44100;
147 #define QSCALE_NONE -99999
148 static float audio_qscale
= QSCALE_NONE
;
149 static int audio_disable
= 0;
150 static int audio_channels
= 1;
151 static int audio_codec_id
= CODEC_ID_NONE
;
152 static int audio_codec_tag
= 0;
153 static char *audio_language
= NULL
;
155 static int subtitle_codec_id
= CODEC_ID_NONE
;
156 static char *subtitle_language
= NULL
;
158 static float mux_preload
= 0.5;
159 static float mux_max_delay
= 0.7;
161 static int64_t recording_time
= 0;
162 static int64_t start_time
= 0;
163 static int64_t rec_timestamp
= 0;
164 static int64_t input_ts_offset
= 0;
165 static int file_overwrite
= 0;
166 static char *str_title
= NULL
;
167 static char *str_author
= NULL
;
168 static char *str_copyright
= NULL
;
169 static char *str_comment
= NULL
;
170 static char *str_album
= NULL
;
171 static int do_benchmark
= 0;
172 static int do_hex_dump
= 0;
173 static int do_pkt_dump
= 0;
174 static int do_psnr
= 0;
175 static int do_pass
= 0;
176 static char *pass_logfilename
= NULL
;
177 static int audio_stream_copy
= 0;
178 static int video_stream_copy
= 0;
179 static int subtitle_stream_copy
= 0;
180 static int video_sync_method
= 1;
181 static int audio_sync_method
= 0;
182 static int copy_ts
= 0;
183 static int opt_shortest
= 0; //
184 static int video_global_header
= 0;
185 static char *vstats_filename
;
186 static FILE *fvstats
;
188 static int rate_emu
= 0;
190 static int video_channel
= 0;
191 static char *video_standard
;
193 static int audio_volume
= 256;
195 static int using_stdin
= 0;
196 static int using_vhook
= 0;
197 static int verbose
= 1;
198 static int thread_count
= 1;
199 static int q_pressed
= 0;
200 static int64_t video_size
= 0;
201 static int64_t audio_size
= 0;
202 static int64_t extra_size
= 0;
203 static int nb_frames_dup
= 0;
204 static int nb_frames_drop
= 0;
205 static int input_sync
;
206 static uint64_t limit_filesize
= 0; //
208 static int pgmyuv_compatibility_hack
=0;
209 static int dts_delta_threshold
= 10;
211 static int sws_flags
= SWS_BICUBIC
;
213 static const char **opt_names
;
214 static int opt_name_count
;
215 static AVCodecContext
*avctx_opts
[CODEC_TYPE_NB
];
216 static AVFormatContext
*avformat_opts
;
217 static struct SwsContext
*sws_opts
;
218 static int64_t timer_start
;
220 static AVBitStreamFilterContext
*video_bitstream_filters
=NULL
;
221 static AVBitStreamFilterContext
*audio_bitstream_filters
=NULL
;
222 static AVBitStreamFilterContext
*bitstream_filters
[MAX_FILES
][MAX_STREAMS
];
224 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
226 struct AVInputStream
;
228 typedef struct AVOutputStream
{
229 int file_index
; /* file index */
230 int index
; /* stream index in the output file */
231 int source_index
; /* AVInputStream index */
232 AVStream
*st
; /* stream in the output file */
233 int encoding_needed
; /* true if encoding needed for this stream */
235 /* input pts and corresponding output pts
237 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
238 struct AVInputStream
*sync_ist
; /* input stream to sync against */
239 int64_t sync_opts
; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
242 AVFrame pict_tmp
; /* temporary image for resampling */
243 struct SwsContext
*img_resample_ctx
; /* for image resampling */
247 int topBand
; /* cropping area sizes */
251 int padtop
; /* padding area sizes */
258 ReSampleContext
*resample
; /* for audio resampling */
259 AVFifoBuffer fifo
; /* for compression: one audio fifo per codec */
263 typedef struct AVInputStream
{
267 int discard
; /* true if stream data should be discarded */
268 int decoding_needed
; /* true if the packets must be decoded in 'raw_fifo' */
269 int64_t sample_index
; /* current sample */
271 int64_t start
; /* time when read started */
272 unsigned long frame
; /* current frame */
273 int64_t next_pts
; /* synthetic pts for cases where pkt.pts
275 int64_t pts
; /* current pts */
276 int is_start
; /* is 1 at the start and after a discontinuity */
279 typedef struct AVInputFile
{
280 int eof_reached
; /* true if eof reached */
281 int ist_index
; /* index of first stream in ist_table */
282 int buffer_size
; /* current total buffer size */
283 int nb_streams
; /* nb streams we are aware of */
288 /* init terminal so that we can grab keys */
289 static struct termios oldtty
;
292 static void term_exit(void)
295 tcsetattr (0, TCSANOW
, &oldtty
);
299 static volatile sig_atomic_t received_sigterm
= 0;
302 sigterm_handler(int sig
)
304 received_sigterm
= sig
;
308 static void term_init(void)
316 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
317 |INLCR
|IGNCR
|ICRNL
|IXON
);
318 tty
.c_oflag
|= OPOST
;
319 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
320 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
325 tcsetattr (0, TCSANOW
, &tty
);
326 signal(SIGQUIT
, sigterm_handler
); /* Quit (POSIX). */
329 signal(SIGINT
, sigterm_handler
); /* Interrupt (ANSI). */
330 signal(SIGTERM
, sigterm_handler
); /* Termination (ANSI). */
332 register a function to be called at normal program termination
335 #ifdef CONFIG_BEOS_NETSERVER
336 fcntl(0, F_SETFL
, fcntl(0, F_GETFL
) | O_NONBLOCK
);
340 /* read a key without blocking */
341 static int read_key(void)
349 #ifndef CONFIG_BEOS_NETSERVER
357 n
= select(1, &rfds
, NULL
, NULL
, &tv
);
370 static int decode_interrupt_cb(void)
372 return q_pressed
|| (q_pressed
= read_key() == 'q');
375 static int read_ffserver_streams(AVFormatContext
*s
, const char *filename
)
380 err
= av_open_input_file(&ic
, filename
, NULL
, FFM_PACKET_SIZE
, NULL
);
383 /* copy stream format */
384 s
->nb_streams
= ic
->nb_streams
;
385 for(i
=0;i
<ic
->nb_streams
;i
++) {
388 // FIXME: a more elegant solution is needed
389 st
= av_mallocz(sizeof(AVStream
));
390 memcpy(st
, ic
->streams
[i
], sizeof(AVStream
));
391 st
->codec
= avcodec_alloc_context();
392 memcpy(st
->codec
, ic
->streams
[i
]->codec
, sizeof(AVCodecContext
));
396 av_close_input_file(ic
);
401 get_sync_ipts(const AVOutputStream
*ost
)
403 const AVInputStream
*ist
= ost
->sync_ist
;
404 return (double)(ist
->pts
+ input_files_ts_offset
[ist
->file_index
] - start_time
)/AV_TIME_BASE
;
407 static void write_frame(AVFormatContext
*s
, AVPacket
*pkt
, AVCodecContext
*avctx
, AVBitStreamFilterContext
*bsfc
){
409 AVPacket new_pkt
= *pkt
;
410 int a
= av_bitstream_filter_filter(bsfc
, avctx
, NULL
,
411 &new_pkt
.data
, &new_pkt
.size
,
412 pkt
->data
, pkt
->size
,
413 pkt
->flags
& PKT_FLAG_KEY
);
416 new_pkt
.destruct
= av_destruct_packet
;
423 av_interleaved_write_frame(s
, pkt
);
426 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
428 static void do_audio_out(AVFormatContext
*s
,
431 unsigned char *buf
, int size
)
434 static uint8_t *audio_buf
= NULL
;
435 static uint8_t *audio_out
= NULL
;
436 const int audio_out_size
= 4*MAX_AUDIO_PACKET_SIZE
;
438 int size_out
, frame_bytes
, ret
;
439 AVCodecContext
*enc
= ost
->st
->codec
;
441 /* SC: dynamic allocation of buffers */
443 audio_buf
= av_malloc(2*MAX_AUDIO_PACKET_SIZE
);
445 audio_out
= av_malloc(audio_out_size
);
446 if (!audio_buf
|| !audio_out
)
447 return; /* Should signal an error ! */
449 if(audio_sync_method
){
450 double delta
= get_sync_ipts(ost
) * enc
->sample_rate
- ost
->sync_opts
451 - av_fifo_size(&ost
->fifo
)/(ost
->st
->codec
->channels
* 2);
452 double idelta
= delta
*ist
->st
->codec
->sample_rate
/ enc
->sample_rate
;
453 int byte_delta
= ((int)idelta
)*2*ist
->st
->codec
->channels
;
455 //FIXME resample delay
456 if(fabs(delta
) > 50){
459 byte_delta
= FFMAX(byte_delta
, -size
);
463 fprintf(stderr
, "discarding %d audio samples\n", (int)-delta
);
468 static uint8_t *input_tmp
= NULL
;
469 input_tmp
= av_realloc(input_tmp
, byte_delta
+ size
);
471 if(byte_delta
+ size
<= MAX_AUDIO_PACKET_SIZE
)
474 byte_delta
= MAX_AUDIO_PACKET_SIZE
- size
;
476 memset(input_tmp
, 0, byte_delta
);
477 memcpy(input_tmp
+ byte_delta
, buf
, size
);
481 fprintf(stderr
, "adding %d audio samples of silence\n", (int)delta
);
483 }else if(audio_sync_method
>1){
484 int comp
= av_clip(delta
, -audio_sync_method
, audio_sync_method
);
485 assert(ost
->audio_resample
);
487 fprintf(stderr
, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta
, comp
, enc
->sample_rate
);
488 // 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));
489 av_resample_compensate(*(struct AVResampleContext
**)ost
->resample
, comp
, enc
->sample_rate
);
493 ost
->sync_opts
= lrintf(get_sync_ipts(ost
) * enc
->sample_rate
)
494 - av_fifo_size(&ost
->fifo
)/(ost
->st
->codec
->channels
* 2); //FIXME wrong
496 if (ost
->audio_resample
) {
498 size_out
= audio_resample(ost
->resample
,
499 (short *)buftmp
, (short *)buf
,
500 size
/ (ist
->st
->codec
->channels
* 2));
501 size_out
= size_out
* enc
->channels
* 2;
507 /* now encode as many frames as possible */
508 if (enc
->frame_size
> 1) {
509 /* output resampled raw samples */
510 av_fifo_write(&ost
->fifo
, buftmp
, size_out
);
512 frame_bytes
= enc
->frame_size
* 2 * enc
->channels
;
514 while (av_fifo_read(&ost
->fifo
, audio_buf
, frame_bytes
) == 0) {
516 av_init_packet(&pkt
);
518 ret
= avcodec_encode_audio(enc
, audio_out
, audio_out_size
,
521 pkt
.stream_index
= ost
->index
;
524 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
525 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
526 pkt
.flags
|= PKT_FLAG_KEY
;
527 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
529 ost
->sync_opts
+= enc
->frame_size
;
533 av_init_packet(&pkt
);
535 ost
->sync_opts
+= size_out
/ (2 * enc
->channels
);
537 /* output a pcm frame */
538 /* XXX: change encoding codec API to avoid this ? */
539 switch(enc
->codec
->id
) {
540 case CODEC_ID_PCM_S32LE
:
541 case CODEC_ID_PCM_S32BE
:
542 case CODEC_ID_PCM_U32LE
:
543 case CODEC_ID_PCM_U32BE
:
544 size_out
= size_out
<< 1;
546 case CODEC_ID_PCM_S24LE
:
547 case CODEC_ID_PCM_S24BE
:
548 case CODEC_ID_PCM_U24LE
:
549 case CODEC_ID_PCM_U24BE
:
550 case CODEC_ID_PCM_S24DAUD
:
551 size_out
= size_out
/ 2 * 3;
553 case CODEC_ID_PCM_S16LE
:
554 case CODEC_ID_PCM_S16BE
:
555 case CODEC_ID_PCM_U16LE
:
556 case CODEC_ID_PCM_U16BE
:
559 size_out
= size_out
>> 1;
562 ret
= avcodec_encode_audio(enc
, audio_out
, size_out
,
565 pkt
.stream_index
= ost
->index
;
568 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
569 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
570 pkt
.flags
|= PKT_FLAG_KEY
;
571 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
575 static void pre_process_video_frame(AVInputStream
*ist
, AVPicture
*picture
, void **bufp
)
579 AVPicture picture_tmp
;
582 dec
= ist
->st
->codec
;
584 /* deinterlace : must be done before any resize */
585 if (do_deinterlace
|| using_vhook
) {
588 /* create temporary picture */
589 size
= avpicture_get_size(dec
->pix_fmt
, dec
->width
, dec
->height
);
590 buf
= av_malloc(size
);
594 picture2
= &picture_tmp
;
595 avpicture_fill(picture2
, buf
, dec
->pix_fmt
, dec
->width
, dec
->height
);
598 if(avpicture_deinterlace(picture2
, picture
,
599 dec
->pix_fmt
, dec
->width
, dec
->height
) < 0) {
600 /* if error, do not deinterlace */
606 av_picture_copy(picture2
, picture
, dec
->pix_fmt
, dec
->width
, dec
->height
);
612 frame_hook_process(picture2
, dec
->pix_fmt
, dec
->width
, dec
->height
,
613 1000000 * ist
->pts
/ AV_TIME_BASE
);
615 if (picture
!= picture2
)
616 *picture
= *picture2
;
620 /* we begin to correct av delay at this threshold */
621 #define AV_DELAY_MAX 0.100
623 static void do_subtitle_out(AVFormatContext
*s
,
629 static uint8_t *subtitle_out
= NULL
;
630 int subtitle_out_max_size
= 65536;
631 int subtitle_out_size
, nb
, i
;
635 if (pts
== AV_NOPTS_VALUE
) {
636 fprintf(stderr
, "Subtitle packets must have a pts\n");
640 enc
= ost
->st
->codec
;
643 subtitle_out
= av_malloc(subtitle_out_max_size
);
646 /* Note: DVB subtitle need one packet to draw them and one other
647 packet to clear them */
648 /* XXX: signal it in the codec context ? */
649 if (enc
->codec_id
== CODEC_ID_DVB_SUBTITLE
)
654 for(i
= 0; i
< nb
; i
++) {
655 subtitle_out_size
= avcodec_encode_subtitle(enc
, subtitle_out
,
656 subtitle_out_max_size
, sub
);
658 av_init_packet(&pkt
);
659 pkt
.stream_index
= ost
->index
;
660 pkt
.data
= subtitle_out
;
661 pkt
.size
= subtitle_out_size
;
662 pkt
.pts
= av_rescale_q(av_rescale_q(pts
, ist
->st
->time_base
, AV_TIME_BASE_Q
) + input_files_ts_offset
[ist
->file_index
], AV_TIME_BASE_Q
, ost
->st
->time_base
);
663 if (enc
->codec_id
== CODEC_ID_DVB_SUBTITLE
) {
664 /* XXX: the pts correction is handled here. Maybe handling
665 it in the codec would be better */
667 pkt
.pts
+= 90 * sub
->start_display_time
;
669 pkt
.pts
+= 90 * sub
->end_display_time
;
671 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
675 static int bit_buffer_size
= 1024*256;
676 static uint8_t *bit_buffer
= NULL
;
678 static void do_video_out(AVFormatContext
*s
,
684 int nb_frames
, i
, ret
;
685 AVFrame
*final_picture
, *formatted_picture
, *resampling_dst
, *padding_src
;
686 AVFrame picture_crop_temp
, picture_pad_temp
;
687 AVCodecContext
*enc
, *dec
;
689 avcodec_get_frame_defaults(&picture_crop_temp
);
690 avcodec_get_frame_defaults(&picture_pad_temp
);
692 enc
= ost
->st
->codec
;
693 dec
= ist
->st
->codec
;
695 /* by default, we output a single frame */
700 if(video_sync_method
){
702 vdelta
= get_sync_ipts(ost
) / av_q2d(enc
->time_base
) - ost
->sync_opts
;
703 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
706 else if (vdelta
> 1.1)
707 nb_frames
= lrintf(vdelta
);
708 //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);
712 fprintf(stderr
, "*** drop!\n");
713 }else if (nb_frames
> 1) {
714 nb_frames_dup
+= nb_frames
;
716 fprintf(stderr
, "*** %d dup!\n", nb_frames
-1);
719 ost
->sync_opts
= lrintf(get_sync_ipts(ost
) / av_q2d(enc
->time_base
));
721 nb_frames
= FFMIN(nb_frames
, max_frames
[CODEC_TYPE_VIDEO
] - ost
->frame_number
);
725 if (ost
->video_crop
) {
726 if (av_picture_crop((AVPicture
*)&picture_crop_temp
, (AVPicture
*)in_picture
, dec
->pix_fmt
, ost
->topBand
, ost
->leftBand
) < 0) {
727 av_log(NULL
, AV_LOG_ERROR
, "error cropping picture\n");
730 formatted_picture
= &picture_crop_temp
;
732 formatted_picture
= in_picture
;
735 final_picture
= formatted_picture
;
736 padding_src
= formatted_picture
;
737 resampling_dst
= &ost
->pict_tmp
;
738 if (ost
->video_pad
) {
739 final_picture
= &ost
->pict_tmp
;
740 if (ost
->video_resample
) {
741 if (av_picture_crop((AVPicture
*)&picture_pad_temp
, (AVPicture
*)final_picture
, enc
->pix_fmt
, ost
->padtop
, ost
->padleft
) < 0) {
742 av_log(NULL
, AV_LOG_ERROR
, "error padding picture\n");
745 resampling_dst
= &picture_pad_temp
;
749 if (ost
->video_resample
) {
751 final_picture
= &ost
->pict_tmp
;
752 sws_scale(ost
->img_resample_ctx
, formatted_picture
->data
, formatted_picture
->linesize
,
753 0, ost
->resample_height
, resampling_dst
->data
, resampling_dst
->linesize
);
756 if (ost
->video_pad
) {
757 av_picture_pad((AVPicture
*)final_picture
, (AVPicture
*)padding_src
,
758 enc
->height
, enc
->width
, enc
->pix_fmt
,
759 ost
->padtop
, ost
->padbottom
, ost
->padleft
, ost
->padright
, padcolor
);
762 /* duplicates frame if needed */
763 for(i
=0;i
<nb_frames
;i
++) {
765 av_init_packet(&pkt
);
766 pkt
.stream_index
= ost
->index
;
768 if (s
->oformat
->flags
& AVFMT_RAWPICTURE
) {
769 /* raw pictures are written as AVPicture structure to
770 avoid any copies. We support temorarily the older
772 AVFrame
* old_frame
= enc
->coded_frame
;
773 enc
->coded_frame
= dec
->coded_frame
; //FIXME/XXX remove this hack
774 pkt
.data
= (uint8_t *)final_picture
;
775 pkt
.size
= sizeof(AVPicture
);
776 if(dec
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
777 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
778 if(dec
->coded_frame
&& dec
->coded_frame
->key_frame
)
779 pkt
.flags
|= PKT_FLAG_KEY
;
781 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
782 enc
->coded_frame
= old_frame
;
786 big_picture
= *final_picture
;
787 /* better than nothing: use input picture interlaced
789 big_picture
.interlaced_frame
= in_picture
->interlaced_frame
;
790 if(avctx_opts
[CODEC_TYPE_VIDEO
]->flags
& (CODEC_FLAG_INTERLACED_DCT
|CODEC_FLAG_INTERLACED_ME
)){
791 if(top_field_first
== -1)
792 big_picture
.top_field_first
= in_picture
->top_field_first
;
794 big_picture
.top_field_first
= top_field_first
;
797 /* handles sameq here. This is not correct because it may
798 not be a global option */
800 big_picture
.quality
= ist
->st
->quality
;
802 big_picture
.quality
= ost
->st
->quality
;
804 big_picture
.pict_type
= 0;
805 // big_picture.pts = AV_NOPTS_VALUE;
806 big_picture
.pts
= ost
->sync_opts
;
807 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
808 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
809 ret
= avcodec_encode_video(enc
,
810 bit_buffer
, bit_buffer_size
,
813 fprintf(stderr
, "Video encoding failed\n");
816 //enc->frame_number = enc->real_pict_num;
818 pkt
.data
= bit_buffer
;
820 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
821 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
822 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
823 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
824 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
826 if(enc
->coded_frame
&& enc
->coded_frame
->key_frame
)
827 pkt
.flags
|= PKT_FLAG_KEY
;
828 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
830 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
831 // enc->frame_number-1, enc->real_pict_num, ret,
833 /* if two pass, output log */
834 if (ost
->logfile
&& enc
->stats_out
) {
835 fprintf(ost
->logfile
, "%s", enc
->stats_out
);
844 static double psnr(double d
){
845 if(d
==0) return INFINITY
;
846 return -10.0*log(d
)/log(10.0);
849 static void do_video_stats(AVFormatContext
*os
, AVOutputStream
*ost
,
855 double ti1
, bitrate
, avg_bitrate
;
857 /* this is executed just the first time do_video_stats is called */
859 fvstats
= fopen(vstats_filename
, "w");
867 enc
= ost
->st
->codec
;
868 if (enc
->codec_type
== CODEC_TYPE_VIDEO
) {
869 frame_number
= ost
->frame_number
;
870 fprintf(fvstats
, "frame= %5d q= %2.1f ", frame_number
, enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
);
871 if (enc
->flags
&CODEC_FLAG_PSNR
)
872 fprintf(fvstats
, "PSNR= %6.2f ", psnr(enc
->coded_frame
->error
[0]/(enc
->width
*enc
->height
*255.0*255.0)));
874 fprintf(fvstats
,"f_size= %6d ", frame_size
);
875 /* compute pts value */
876 ti1
= ost
->sync_opts
* av_q2d(enc
->time_base
);
880 bitrate
= (frame_size
* 8) / av_q2d(enc
->time_base
) / 1000.0;
881 avg_bitrate
= (double)(video_size
* 8) / ti1
/ 1000.0;
882 fprintf(fvstats
, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
883 (double)video_size
/ 1024, ti1
, bitrate
, avg_bitrate
);
884 fprintf(fvstats
,"type= %c\n", av_get_pict_type_char(enc
->coded_frame
->pict_type
));
888 static void print_report(AVFormatContext
**output_files
,
889 AVOutputStream
**ost_table
, int nb_ostreams
,
894 AVFormatContext
*oc
, *os
;
897 int frame_number
, vid
, i
;
898 double bitrate
, ti1
, pts
;
899 static int64_t last_time
= -1;
900 static int qp_histogram
[52];
902 if (!is_last_report
) {
904 /* display the report every 0.5 seconds */
905 cur_time
= av_gettime();
906 if (last_time
== -1) {
907 last_time
= cur_time
;
910 if ((cur_time
- last_time
) < 500000)
912 last_time
= cur_time
;
916 oc
= output_files
[0];
918 total_size
= url_fsize(&oc
->pb
);
919 if(total_size
<0) // FIXME improve url_fsize() so it works with non seekable output too
920 total_size
= url_ftell(&oc
->pb
);
925 for(i
=0;i
<nb_ostreams
;i
++) {
927 os
= output_files
[ost
->file_index
];
928 enc
= ost
->st
->codec
;
929 if (vid
&& enc
->codec_type
== CODEC_TYPE_VIDEO
) {
930 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "q=%2.1f ",
931 enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
);
933 if (!vid
&& enc
->codec_type
== CODEC_TYPE_VIDEO
) {
934 float t
= (av_gettime()-timer_start
) / 1000000.0;
936 frame_number
= ost
->frame_number
;
937 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "frame=%5d fps=%3d q=%3.1f ",
938 frame_number
, (t
>1)?
(int)(frame_number
/t
+0.5) : 0,
939 enc
->coded_frame ? enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
: -1);
941 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "L");
942 if(qp_hist
&& enc
->coded_frame
){
944 int qp
= lrintf(enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
);
945 if(qp
>=0 && qp
<sizeof(qp_histogram
)/sizeof(int))
948 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "%X", (int)lrintf(log(qp_histogram
[j
]+1)/log(2)));
950 if (enc
->flags
&CODEC_FLAG_PSNR
){
952 double error
, error_sum
=0;
953 double scale
, scale_sum
=0;
954 char type
[3]= {'Y','U','V'};
955 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "PSNR=");
958 error
= enc
->error
[j
];
959 scale
= enc
->width
*enc
->height
*255.0*255.0*frame_number
;
961 error
= enc
->coded_frame
->error
[j
];
962 scale
= enc
->width
*enc
->height
*255.0*255.0;
967 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "%c:%2.2f ", type
[j
], psnr(error
/scale
));
969 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "*:%2.2f ", psnr(error_sum
/scale_sum
));
973 /* compute min output value */
974 pts
= (double)ost
->st
->pts
.val
* ost
->st
->time_base
.num
/ ost
->st
->time_base
.den
;
975 if ((pts
< ti1
) && (pts
> 0))
981 if (verbose
|| is_last_report
) {
982 bitrate
= (double)(total_size
* 8) / ti1
/ 1000.0;
984 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
985 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
986 (double)total_size
/ 1024, ti1
, bitrate
);
989 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), " dup=%d drop=%d",
990 nb_frames_dup
, nb_frames_drop
);
993 fprintf(stderr
, "%s \r", buf
);
998 if (is_last_report
&& verbose
>= 0){
999 int64_t raw
= audio_size
+ video_size
+ extra_size
;
1000 fprintf(stderr
, "\n");
1001 fprintf(stderr
, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1005 100.0*(total_size
- raw
)/raw
1010 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1011 static int output_packet(AVInputStream
*ist
, int ist_index
,
1012 AVOutputStream
**ost_table
, int nb_ostreams
,
1013 const AVPacket
*pkt
)
1015 AVFormatContext
*os
;
1016 AVOutputStream
*ost
;
1020 int data_size
, got_picture
;
1022 void *buffer_to_free
;
1023 static unsigned int samples_size
= 0;
1024 static short *samples
= NULL
;
1025 AVSubtitle subtitle
, *subtitle_to_free
;
1029 ist
->pts
= ist
->next_pts
; // needed for last packet if vsync=0
1030 } else if (pkt
->dts
!= AV_NOPTS_VALUE
) { //FIXME seems redundant, as libavformat does this too
1031 ist
->next_pts
= ist
->pts
= av_rescale_q(pkt
->dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
1033 // assert(ist->pts == ist->next_pts);
1047 /* decode the packet if needed */
1048 data_buf
= NULL
; /* fail safe */
1050 subtitle_to_free
= NULL
;
1051 if (ist
->decoding_needed
) {
1052 switch(ist
->st
->codec
->codec_type
) {
1053 case CODEC_TYPE_AUDIO
:{
1055 samples
= av_fast_realloc(samples
, &samples_size
, FFMAX(pkt
->size
*sizeof(*samples
), AVCODEC_MAX_AUDIO_FRAME_SIZE
));
1056 data_size
= samples_size
;
1057 /* XXX: could avoid copy if PCM 16 bits with same
1058 endianness as CPU */
1059 ret
= avcodec_decode_audio2(ist
->st
->codec
, samples
, &data_size
,
1065 /* Some bug in mpeg audio decoder gives */
1066 /* data_size < 0, it seems they are overflows */
1067 if (data_size
<= 0) {
1068 /* no audio frame */
1071 data_buf
= (uint8_t *)samples
;
1072 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
/2 * data_size
) /
1073 (ist
->st
->codec
->sample_rate
* ist
->st
->codec
->channels
);
1075 case CODEC_TYPE_VIDEO
:
1076 data_size
= (ist
->st
->codec
->width
* ist
->st
->codec
->height
* 3) / 2;
1077 /* XXX: allocate picture correctly */
1078 avcodec_get_frame_defaults(&picture
);
1080 ret
= avcodec_decode_video(ist
->st
->codec
,
1081 &picture
, &got_picture
, ptr
, len
);
1082 ist
->st
->quality
= picture
.quality
;
1086 /* no picture yet */
1087 goto discard_packet
;
1089 if (ist
->st
->codec
->time_base
.num
!= 0) {
1090 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
*
1091 ist
->st
->codec
->time_base
.num
) /
1092 ist
->st
->codec
->time_base
.den
;
1096 case CODEC_TYPE_SUBTITLE
:
1097 ret
= avcodec_decode_subtitle(ist
->st
->codec
,
1098 &subtitle
, &got_subtitle
, ptr
, len
);
1101 if (!got_subtitle
) {
1102 goto discard_packet
;
1104 subtitle_to_free
= &subtitle
;
1111 switch(ist
->st
->codec
->codec_type
) {
1112 case CODEC_TYPE_AUDIO
:
1113 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
* ist
->st
->codec
->frame_size
) /
1114 (ist
->st
->codec
->sample_rate
* ist
->st
->codec
->channels
);
1116 case CODEC_TYPE_VIDEO
:
1117 if (ist
->st
->codec
->time_base
.num
!= 0) {
1118 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
*
1119 ist
->st
->codec
->time_base
.num
) /
1120 ist
->st
->codec
->time_base
.den
;
1130 buffer_to_free
= NULL
;
1131 if (ist
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
1132 pre_process_video_frame(ist
, (AVPicture
*)&picture
,
1136 // preprocess audio (volume)
1137 if (ist
->st
->codec
->codec_type
== CODEC_TYPE_AUDIO
) {
1138 if (audio_volume
!= 256) {
1141 for(i
=0;i
<(data_size
/ sizeof(short));i
++) {
1142 int v
= ((*volp
) * audio_volume
+ 128) >> 8;
1143 if (v
< -32768) v
= -32768;
1144 if (v
> 32767) v
= 32767;
1150 /* frame rate emulation */
1151 if (ist
->st
->codec
->rate_emu
) {
1152 int64_t pts
= av_rescale((int64_t) ist
->frame
* ist
->st
->codec
->time_base
.num
, 1000000, ist
->st
->codec
->time_base
.den
);
1153 int64_t now
= av_gettime() - ist
->start
;
1161 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1162 is the one of the next displayed one */
1163 /* XXX: add mpeg4 too ? */
1164 if (ist
->st
->codec
->codec_id
== CODEC_ID_MPEG1VIDEO
) {
1165 if (ist
->st
->codec
->pict_type
!= B_TYPE
) {
1167 tmp
= ist
->last_ip_pts
;
1168 ist
->last_ip_pts
= ist
->frac_pts
.val
;
1169 ist
->frac_pts
.val
= tmp
;
1173 /* if output time reached then transcode raw format,
1174 encode packets and output them */
1175 if (start_time
== 0 || ist
->pts
>= start_time
)
1176 for(i
=0;i
<nb_ostreams
;i
++) {
1180 if (ost
->source_index
== ist_index
) {
1181 os
= output_files
[ost
->file_index
];
1184 printf("%d: got pts=%0.3f %0.3f\n", i
,
1185 (double)pkt
->pts
/ AV_TIME_BASE
,
1186 ((double)ist
->pts
/ AV_TIME_BASE
) -
1187 ((double)ost
->st
->pts
.val
* ost
->st
->time_base
.num
/ ost
->st
->time_base
.den
));
1189 /* set the input output pts pairs */
1190 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1192 if (ost
->encoding_needed
) {
1193 switch(ost
->st
->codec
->codec_type
) {
1194 case CODEC_TYPE_AUDIO
:
1195 do_audio_out(os
, ost
, ist
, data_buf
, data_size
);
1197 case CODEC_TYPE_VIDEO
:
1198 do_video_out(os
, ost
, ist
, &picture
, &frame_size
);
1199 video_size
+= frame_size
;
1200 if (vstats_filename
&& frame_size
)
1201 do_video_stats(os
, ost
, frame_size
);
1203 case CODEC_TYPE_SUBTITLE
:
1204 do_subtitle_out(os
, ost
, ist
, &subtitle
,
1211 AVFrame avframe
; //FIXME/XXX remove this
1213 av_init_packet(&opkt
);
1215 /* no reencoding needed : output the packet directly */
1216 /* force the input stream PTS */
1218 avcodec_get_frame_defaults(&avframe
);
1219 ost
->st
->codec
->coded_frame
= &avframe
;
1220 avframe
.key_frame
= pkt
->flags
& PKT_FLAG_KEY
;
1222 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_AUDIO
)
1223 audio_size
+= data_size
;
1224 else if (ost
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
1225 video_size
+= data_size
;
1229 opkt
.stream_index
= ost
->index
;
1230 if(pkt
->pts
!= AV_NOPTS_VALUE
)
1231 opkt
.pts
= av_rescale_q(av_rescale_q(pkt
->pts
, ist
->st
->time_base
, AV_TIME_BASE_Q
) + input_files_ts_offset
[ist
->file_index
], AV_TIME_BASE_Q
, ost
->st
->time_base
);
1233 opkt
.pts
= AV_NOPTS_VALUE
;
1237 if (pkt
->dts
== AV_NOPTS_VALUE
)
1238 dts
= ist
->next_pts
;
1240 dts
= av_rescale_q(pkt
->dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
1241 opkt
.dts
= av_rescale_q(dts
+ input_files_ts_offset
[ist
->file_index
], AV_TIME_BASE_Q
, ost
->st
->time_base
);
1243 opkt
.flags
= pkt
->flags
;
1245 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1246 if(av_parser_change(ist
->st
->parser
, ost
->st
->codec
, &opkt
.data
, &opkt
.size
, data_buf
, data_size
, pkt
->flags
& PKT_FLAG_KEY
))
1247 opkt
.destruct
= av_destruct_packet
;
1249 write_frame(os
, &opkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
->stream_index
]);
1250 ost
->st
->codec
->frame_number
++;
1251 ost
->frame_number
++;
1252 av_free_packet(&opkt
);
1256 av_free(buffer_to_free
);
1257 /* XXX: allocate the subtitles in the codec ? */
1258 if (subtitle_to_free
) {
1259 if (subtitle_to_free
->rects
!= NULL
) {
1260 for (i
= 0; i
< subtitle_to_free
->num_rects
; i
++) {
1261 av_free(subtitle_to_free
->rects
[i
].bitmap
);
1262 av_free(subtitle_to_free
->rects
[i
].rgba_palette
);
1264 av_freep(&subtitle_to_free
->rects
);
1266 subtitle_to_free
->num_rects
= 0;
1267 subtitle_to_free
= NULL
;
1274 for(i
=0;i
<nb_ostreams
;i
++) {
1276 if (ost
->source_index
== ist_index
) {
1277 AVCodecContext
*enc
= ost
->st
->codec
;
1278 os
= output_files
[ost
->file_index
];
1280 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_AUDIO
&& enc
->frame_size
<=1)
1282 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
&& (os
->oformat
->flags
& AVFMT_RAWPICTURE
))
1285 if (ost
->encoding_needed
) {
1289 av_init_packet(&pkt
);
1290 pkt
.stream_index
= ost
->index
;
1292 switch(ost
->st
->codec
->codec_type
) {
1293 case CODEC_TYPE_AUDIO
:
1294 fifo_bytes
= av_fifo_size(&ost
->fifo
);
1296 /* encode any samples remaining in fifo */
1297 if(fifo_bytes
> 0 && enc
->codec
->capabilities
& CODEC_CAP_SMALL_LAST_FRAME
) {
1298 int fs_tmp
= enc
->frame_size
;
1299 enc
->frame_size
= fifo_bytes
/ (2 * enc
->channels
);
1300 if(av_fifo_read(&ost
->fifo
, (uint8_t *)samples
, fifo_bytes
) == 0) {
1301 ret
= avcodec_encode_audio(enc
, bit_buffer
, bit_buffer_size
, samples
);
1303 enc
->frame_size
= fs_tmp
;
1306 ret
= avcodec_encode_audio(enc
, bit_buffer
, bit_buffer_size
, NULL
);
1309 pkt
.flags
|= PKT_FLAG_KEY
;
1311 case CODEC_TYPE_VIDEO
:
1312 ret
= avcodec_encode_video(enc
, bit_buffer
, bit_buffer_size
, NULL
);
1314 if(enc
->coded_frame
&& enc
->coded_frame
->key_frame
)
1315 pkt
.flags
|= PKT_FLAG_KEY
;
1316 if (ost
->logfile
&& enc
->stats_out
) {
1317 fprintf(ost
->logfile
, "%s", enc
->stats_out
);
1326 pkt
.data
= bit_buffer
;
1328 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
1329 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
1330 write_frame(os
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
1344 * The following code is the main loop of the file converter
1346 static int av_encode(AVFormatContext
**output_files
,
1347 int nb_output_files
,
1348 AVFormatContext
**input_files
,
1350 AVStreamMap
*stream_maps
, int nb_stream_maps
)
1352 int ret
, i
, j
, k
, n
, nb_istreams
= 0, nb_ostreams
= 0;
1353 AVFormatContext
*is
, *os
;
1354 AVCodecContext
*codec
, *icodec
;
1355 AVOutputStream
*ost
, **ost_table
= NULL
;
1356 AVInputStream
*ist
, **ist_table
= NULL
;
1357 AVInputFile
*file_table
;
1360 file_table
= (AVInputFile
*) av_mallocz(nb_input_files
* sizeof(AVInputFile
));
1364 /* input stream init */
1366 for(i
=0;i
<nb_input_files
;i
++) {
1367 is
= input_files
[i
];
1368 file_table
[i
].ist_index
= j
;
1369 file_table
[i
].nb_streams
= is
->nb_streams
;
1370 j
+= is
->nb_streams
;
1374 ist_table
= av_mallocz(nb_istreams
* sizeof(AVInputStream
*));
1378 for(i
=0;i
<nb_istreams
;i
++) {
1379 ist
= av_mallocz(sizeof(AVInputStream
));
1385 for(i
=0;i
<nb_input_files
;i
++) {
1386 is
= input_files
[i
];
1387 for(k
=0;k
<is
->nb_streams
;k
++) {
1388 ist
= ist_table
[j
++];
1389 ist
->st
= is
->streams
[k
];
1390 ist
->file_index
= i
;
1392 ist
->discard
= 1; /* the stream is discarded by default
1395 if (ist
->st
->codec
->rate_emu
) {
1396 ist
->start
= av_gettime();
1402 /* output stream init */
1404 for(i
=0;i
<nb_output_files
;i
++) {
1405 os
= output_files
[i
];
1406 if (!os
->nb_streams
) {
1407 fprintf(stderr
, "Output file does not contain any stream\n");
1410 nb_ostreams
+= os
->nb_streams
;
1412 if (nb_stream_maps
> 0 && nb_stream_maps
!= nb_ostreams
) {
1413 fprintf(stderr
, "Number of stream maps must match number of output streams\n");
1417 /* Sanity check the mapping args -- do the input files & streams exist? */
1418 for(i
=0;i
<nb_stream_maps
;i
++) {
1419 int fi
= stream_maps
[i
].file_index
;
1420 int si
= stream_maps
[i
].stream_index
;
1422 if (fi
< 0 || fi
> nb_input_files
- 1 ||
1423 si
< 0 || si
> file_table
[fi
].nb_streams
- 1) {
1424 fprintf(stderr
,"Could not find input stream #%d.%d\n", fi
, si
);
1427 fi
= stream_maps
[i
].sync_file_index
;
1428 si
= stream_maps
[i
].sync_stream_index
;
1429 if (fi
< 0 || fi
> nb_input_files
- 1 ||
1430 si
< 0 || si
> file_table
[fi
].nb_streams
- 1) {
1431 fprintf(stderr
,"Could not find sync stream #%d.%d\n", fi
, si
);
1436 ost_table
= av_mallocz(sizeof(AVOutputStream
*) * nb_ostreams
);
1439 for(i
=0;i
<nb_ostreams
;i
++) {
1440 ost
= av_mallocz(sizeof(AVOutputStream
));
1447 for(k
=0;k
<nb_output_files
;k
++) {
1448 os
= output_files
[k
];
1449 for(i
=0;i
<os
->nb_streams
;i
++) {
1451 ost
= ost_table
[n
++];
1452 ost
->file_index
= k
;
1454 ost
->st
= os
->streams
[i
];
1455 if (nb_stream_maps
> 0) {
1456 ost
->source_index
= file_table
[stream_maps
[n
-1].file_index
].ist_index
+
1457 stream_maps
[n
-1].stream_index
;
1459 /* Sanity check that the stream types match */
1460 if (ist_table
[ost
->source_index
]->st
->codec
->codec_type
!= ost
->st
->codec
->codec_type
) {
1461 fprintf(stderr
, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1462 stream_maps
[n
-1].file_index
, stream_maps
[n
-1].stream_index
,
1463 ost
->file_index
, ost
->index
);
1468 /* get corresponding input stream index : we select the first one with the right type */
1470 for(j
=0;j
<nb_istreams
;j
++) {
1473 ist
->st
->codec
->codec_type
== ost
->st
->codec
->codec_type
) {
1474 ost
->source_index
= j
;
1481 /* try again and reuse existing stream */
1482 for(j
=0;j
<nb_istreams
;j
++) {
1484 if (ist
->st
->codec
->codec_type
== ost
->st
->codec
->codec_type
) {
1485 ost
->source_index
= j
;
1490 fprintf(stderr
, "Could not find input stream matching output stream #%d.%d\n",
1491 ost
->file_index
, ost
->index
);
1496 ist
= ist_table
[ost
->source_index
];
1498 ost
->sync_ist
= (nb_stream_maps
> 0) ?
1499 ist_table
[file_table
[stream_maps
[n
-1].sync_file_index
].ist_index
+
1500 stream_maps
[n
-1].sync_stream_index
] : ist
;
1504 /* for each output stream, we compute the right encoding parameters */
1505 for(i
=0;i
<nb_ostreams
;i
++) {
1507 ist
= ist_table
[ost
->source_index
];
1509 codec
= ost
->st
->codec
;
1510 icodec
= ist
->st
->codec
;
1512 if (ost
->st
->stream_copy
) {
1513 /* if stream_copy is selected, no need to decode or encode */
1514 codec
->codec_id
= icodec
->codec_id
;
1515 codec
->codec_type
= icodec
->codec_type
;
1516 if(!codec
->codec_tag
) codec
->codec_tag
= icodec
->codec_tag
;
1517 codec
->bit_rate
= icodec
->bit_rate
;
1518 codec
->extradata
= icodec
->extradata
;
1519 codec
->extradata_size
= icodec
->extradata_size
;
1520 if(av_q2d(icodec
->time_base
) > av_q2d(ist
->st
->time_base
) && av_q2d(ist
->st
->time_base
) < 1.0/1000)
1521 codec
->time_base
= icodec
->time_base
;
1523 codec
->time_base
= ist
->st
->time_base
;
1524 switch(codec
->codec_type
) {
1525 case CODEC_TYPE_AUDIO
:
1526 codec
->sample_rate
= icodec
->sample_rate
;
1527 codec
->channels
= icodec
->channels
;
1528 codec
->frame_size
= icodec
->frame_size
;
1529 codec
->block_align
= icodec
->block_align
;
1531 case CODEC_TYPE_VIDEO
:
1533 fprintf(stderr
,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1536 codec
->pix_fmt
= icodec
->pix_fmt
;
1537 codec
->width
= icodec
->width
;
1538 codec
->height
= icodec
->height
;
1539 codec
->has_b_frames
= icodec
->has_b_frames
;
1541 case CODEC_TYPE_SUBTITLE
:
1547 switch(codec
->codec_type
) {
1548 case CODEC_TYPE_AUDIO
:
1549 if (av_fifo_init(&ost
->fifo
, 2 * MAX_AUDIO_PACKET_SIZE
))
1552 if (codec
->channels
== icodec
->channels
&&
1553 codec
->sample_rate
== icodec
->sample_rate
) {
1554 ost
->audio_resample
= 0;
1556 if (codec
->channels
!= icodec
->channels
&&
1557 (icodec
->codec_id
== CODEC_ID_AC3
||
1558 icodec
->codec_id
== CODEC_ID_DTS
)) {
1559 /* Special case for 5:1 AC3 and DTS input */
1560 /* and mono or stereo output */
1561 /* Request specific number of channels */
1562 icodec
->channels
= codec
->channels
;
1563 if (codec
->sample_rate
== icodec
->sample_rate
)
1564 ost
->audio_resample
= 0;
1566 ost
->audio_resample
= 1;
1569 ost
->audio_resample
= 1;
1572 if(audio_sync_method
>1)
1573 ost
->audio_resample
= 1;
1575 if(ost
->audio_resample
){
1576 ost
->resample
= audio_resample_init(codec
->channels
, icodec
->channels
,
1577 codec
->sample_rate
, icodec
->sample_rate
);
1579 printf("Can't resample. Aborting.\n");
1583 ist
->decoding_needed
= 1;
1584 ost
->encoding_needed
= 1;
1586 case CODEC_TYPE_VIDEO
:
1587 ost
->video_crop
= ((frame_leftBand
+ frame_rightBand
+ frame_topBand
+ frame_bottomBand
) != 0);
1588 ost
->video_pad
= ((frame_padleft
+ frame_padright
+ frame_padtop
+ frame_padbottom
) != 0);
1589 ost
->video_resample
= ((codec
->width
!= icodec
->width
-
1590 (frame_leftBand
+ frame_rightBand
) +
1591 (frame_padleft
+ frame_padright
)) ||
1592 (codec
->height
!= icodec
->height
-
1593 (frame_topBand
+ frame_bottomBand
) +
1594 (frame_padtop
+ frame_padbottom
)) ||
1595 (codec
->pix_fmt
!= icodec
->pix_fmt
));
1596 if (ost
->video_crop
) {
1597 ost
->topBand
= frame_topBand
;
1598 ost
->leftBand
= frame_leftBand
;
1600 if (ost
->video_pad
) {
1601 ost
->padtop
= frame_padtop
;
1602 ost
->padleft
= frame_padleft
;
1603 ost
->padbottom
= frame_padbottom
;
1604 ost
->padright
= frame_padright
;
1605 if (!ost
->video_resample
) {
1606 avcodec_get_frame_defaults(&ost
->pict_tmp
);
1607 if( avpicture_alloc( (AVPicture
*)&ost
->pict_tmp
, codec
->pix_fmt
,
1608 codec
->width
, codec
->height
) )
1612 if (ost
->video_resample
) {
1613 avcodec_get_frame_defaults(&ost
->pict_tmp
);
1614 if( avpicture_alloc( (AVPicture
*)&ost
->pict_tmp
, codec
->pix_fmt
,
1615 codec
->width
, codec
->height
) ) {
1616 fprintf(stderr
, "Cannot allocate temp picture, check pix fmt\n");
1619 sws_flags
= av_get_int(sws_opts
, "sws_flags", NULL
);
1620 ost
->img_resample_ctx
= sws_getContext(
1621 icodec
->width
- (frame_leftBand
+ frame_rightBand
),
1622 icodec
->height
- (frame_topBand
+ frame_bottomBand
),
1624 codec
->width
- (frame_padleft
+ frame_padright
),
1625 codec
->height
- (frame_padtop
+ frame_padbottom
),
1627 sws_flags
, NULL
, NULL
, NULL
);
1628 if (ost
->img_resample_ctx
== NULL
) {
1629 fprintf(stderr
, "Cannot get resampling context\n");
1632 ost
->resample_height
= icodec
->height
- (frame_topBand
+ frame_bottomBand
);
1634 ost
->encoding_needed
= 1;
1635 ist
->decoding_needed
= 1;
1637 case CODEC_TYPE_SUBTITLE
:
1638 ost
->encoding_needed
= 1;
1639 ist
->decoding_needed
= 1;
1646 if (ost
->encoding_needed
&&
1647 (codec
->flags
& (CODEC_FLAG_PASS1
| CODEC_FLAG_PASS2
))) {
1648 char logfilename
[1024];
1653 snprintf(logfilename
, sizeof(logfilename
), "%s-%d.log",
1655 pass_logfilename
: DEFAULT_PASS_LOGFILENAME
, i
);
1656 if (codec
->flags
& CODEC_FLAG_PASS1
) {
1657 f
= fopen(logfilename
, "w");
1659 perror(logfilename
);
1664 /* read the log file */
1665 f
= fopen(logfilename
, "r");
1667 perror(logfilename
);
1670 fseek(f
, 0, SEEK_END
);
1672 fseek(f
, 0, SEEK_SET
);
1673 logbuffer
= av_malloc(size
+ 1);
1675 fprintf(stderr
, "Could not allocate log buffer\n");
1678 size
= fread(logbuffer
, 1, size
, f
);
1680 logbuffer
[size
] = '\0';
1681 codec
->stats_in
= logbuffer
;
1685 if(codec
->codec_type
== CODEC_TYPE_VIDEO
){
1686 int size
= codec
->width
* codec
->height
;
1687 bit_buffer_size
= FFMAX(bit_buffer_size
, 4*size
);
1692 bit_buffer
= av_malloc(bit_buffer_size
);
1696 /* dump the file output parameters - cannot be done before in case
1698 for(i
=0;i
<nb_output_files
;i
++) {
1699 dump_format(output_files
[i
], i
, output_files
[i
]->filename
, 1);
1702 /* dump the stream mapping */
1704 fprintf(stderr
, "Stream mapping:\n");
1705 for(i
=0;i
<nb_ostreams
;i
++) {
1707 fprintf(stderr
, " Stream #%d.%d -> #%d.%d",
1708 ist_table
[ost
->source_index
]->file_index
,
1709 ist_table
[ost
->source_index
]->index
,
1712 if (ost
->sync_ist
!= ist_table
[ost
->source_index
])
1713 fprintf(stderr
, " [sync #%d.%d]",
1714 ost
->sync_ist
->file_index
,
1715 ost
->sync_ist
->index
);
1716 fprintf(stderr
, "\n");
1720 /* open each encoder */
1721 for(i
=0;i
<nb_ostreams
;i
++) {
1723 if (ost
->encoding_needed
) {
1725 codec
= avcodec_find_encoder(ost
->st
->codec
->codec_id
);
1727 fprintf(stderr
, "Unsupported codec for output stream #%d.%d\n",
1728 ost
->file_index
, ost
->index
);
1731 if (avcodec_open(ost
->st
->codec
, codec
) < 0) {
1732 fprintf(stderr
, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1733 ost
->file_index
, ost
->index
);
1736 extra_size
+= ost
->st
->codec
->extradata_size
;
1740 /* open each decoder */
1741 for(i
=0;i
<nb_istreams
;i
++) {
1743 if (ist
->decoding_needed
) {
1745 codec
= avcodec_find_decoder(ist
->st
->codec
->codec_id
);
1747 fprintf(stderr
, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1748 ist
->st
->codec
->codec_id
, ist
->file_index
, ist
->index
);
1751 if (avcodec_open(ist
->st
->codec
, codec
) < 0) {
1752 fprintf(stderr
, "Error while opening codec for input stream #%d.%d\n",
1753 ist
->file_index
, ist
->index
);
1756 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1757 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1762 for(i
=0;i
<nb_istreams
;i
++) {
1764 is
= input_files
[ist
->file_index
];
1766 ist
->next_pts
= av_rescale_q(ist
->st
->start_time
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
1767 if(ist
->st
->start_time
== AV_NOPTS_VALUE
)
1769 if(input_files_ts_offset
[ist
->file_index
])
1770 ist
->next_pts
= AV_NOPTS_VALUE
;
1774 /* set meta data information from input file if required */
1775 for (i
=0;i
<nb_meta_data_maps
;i
++) {
1776 AVFormatContext
*out_file
;
1777 AVFormatContext
*in_file
;
1779 int out_file_index
= meta_data_maps
[i
].out_file
;
1780 int in_file_index
= meta_data_maps
[i
].in_file
;
1781 if ( out_file_index
< 0 || out_file_index
>= nb_output_files
) {
1782 fprintf(stderr
, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index
, out_file_index
, in_file_index
);
1783 ret
= AVERROR(EINVAL
);
1786 if ( in_file_index
< 0 || in_file_index
>= nb_input_files
) {
1787 fprintf(stderr
, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index
, out_file_index
, in_file_index
);
1788 ret
= AVERROR(EINVAL
);
1792 out_file
= output_files
[out_file_index
];
1793 in_file
= input_files
[in_file_index
];
1795 strcpy(out_file
->title
, in_file
->title
);
1796 strcpy(out_file
->author
, in_file
->author
);
1797 strcpy(out_file
->copyright
, in_file
->copyright
);
1798 strcpy(out_file
->comment
, in_file
->comment
);
1799 strcpy(out_file
->album
, in_file
->album
);
1800 out_file
->year
= in_file
->year
;
1801 out_file
->track
= in_file
->track
;
1802 strcpy(out_file
->genre
, in_file
->genre
);
1805 /* open files and write file headers */
1806 for(i
=0;i
<nb_output_files
;i
++) {
1807 os
= output_files
[i
];
1808 if (av_write_header(os
) < 0) {
1809 fprintf(stderr
, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i
);
1810 ret
= AVERROR(EINVAL
);
1815 if ( !using_stdin
&& verbose
>= 0) {
1816 fprintf(stderr
, "Press [q] to stop encoding\n");
1817 url_set_interrupt_cb(decode_interrupt_cb
);
1822 timer_start
= av_gettime();
1824 for(; received_sigterm
== 0;) {
1825 int file_index
, ist_index
;
1833 /* if 'q' pressed, exits */
1837 /* read_key() returns 0 on EOF */
1843 /* select the stream that we must read now by looking at the
1844 smallest output pts */
1846 for(i
=0;i
<nb_ostreams
;i
++) {
1849 os
= output_files
[ost
->file_index
];
1850 ist
= ist_table
[ost
->source_index
];
1851 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
)
1852 opts
= ost
->sync_opts
* av_q2d(ost
->st
->codec
->time_base
);
1854 opts
= ost
->st
->pts
.val
* av_q2d(ost
->st
->time_base
);
1855 ipts
= (double)ist
->pts
;
1856 if (!file_table
[ist
->file_index
].eof_reached
){
1857 if(ipts
< ipts_min
) {
1859 if(input_sync
) file_index
= ist
->file_index
;
1861 if(opts
< opts_min
) {
1863 if(!input_sync
) file_index
= ist
->file_index
;
1866 if(ost
->frame_number
>= max_frames
[ost
->st
->codec
->codec_type
]){
1871 /* if none, if is finished */
1872 if (file_index
< 0) {
1876 /* finish if recording time exhausted */
1877 if (recording_time
> 0 && opts_min
>= (recording_time
/ 1000000.0))
1880 /* finish if limit size exhausted */
1881 if (limit_filesize
!= 0 && limit_filesize
< url_ftell(&output_files
[0]->pb
))
1884 /* read a frame from it and output it in the fifo */
1885 is
= input_files
[file_index
];
1886 if (av_read_frame(is
, &pkt
) < 0) {
1887 file_table
[file_index
].eof_reached
= 1;
1888 if (opt_shortest
) break; else continue; //
1892 av_pkt_dump_log(NULL
, AV_LOG_DEBUG
, &pkt
, do_hex_dump
);
1894 /* the following test is needed in case new streams appear
1895 dynamically in stream : we ignore them */
1896 if (pkt
.stream_index
>= file_table
[file_index
].nb_streams
)
1897 goto discard_packet
;
1898 ist_index
= file_table
[file_index
].ist_index
+ pkt
.stream_index
;
1899 ist
= ist_table
[ist_index
];
1901 goto discard_packet
;
1903 // 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);
1904 if (pkt
.dts
!= AV_NOPTS_VALUE
&& ist
->next_pts
!= AV_NOPTS_VALUE
) {
1905 int64_t delta
= av_rescale_q(pkt
.dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
) - ist
->next_pts
;
1906 if(FFABS(delta
) > 1LL*dts_delta_threshold
*AV_TIME_BASE
&& !copy_ts
){
1907 input_files_ts_offset
[ist
->file_index
]-= delta
;
1909 fprintf(stderr
, "timestamp discontinuity %"PRId64
", new offset= %"PRId64
"\n", delta
, input_files_ts_offset
[ist
->file_index
]);
1910 for(i
=0; i
<file_table
[file_index
].nb_streams
; i
++){
1911 int index
= file_table
[file_index
].ist_index
+ i
;
1912 ist_table
[index
]->next_pts
+= delta
;
1913 ist_table
[index
]->is_start
=1;
1918 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1919 if (output_packet(ist
, ist_index
, ost_table
, nb_ostreams
, &pkt
) < 0) {
1922 fprintf(stderr
, "Error while decoding stream #%d.%d\n",
1923 ist
->file_index
, ist
->index
);
1925 av_free_packet(&pkt
);
1930 av_free_packet(&pkt
);
1932 /* dump report by using the output first video and audio streams */
1933 print_report(output_files
, ost_table
, nb_ostreams
, 0);
1936 /* at the end of stream, we must flush the decoder buffers */
1937 for(i
=0;i
<nb_istreams
;i
++) {
1939 if (ist
->decoding_needed
) {
1940 output_packet(ist
, i
, ost_table
, nb_ostreams
, NULL
);
1946 /* write the trailer if needed and close file */
1947 for(i
=0;i
<nb_output_files
;i
++) {
1948 os
= output_files
[i
];
1949 av_write_trailer(os
);
1952 /* dump report by using the first video and audio streams */
1953 print_report(output_files
, ost_table
, nb_ostreams
, 1);
1955 /* close each encoder */
1956 for(i
=0;i
<nb_ostreams
;i
++) {
1958 if (ost
->encoding_needed
) {
1959 av_freep(&ost
->st
->codec
->stats_in
);
1960 avcodec_close(ost
->st
->codec
);
1964 /* close each decoder */
1965 for(i
=0;i
<nb_istreams
;i
++) {
1967 if (ist
->decoding_needed
) {
1968 avcodec_close(ist
->st
->codec
);
1976 av_freep(&bit_buffer
);
1977 av_free(file_table
);
1980 for(i
=0;i
<nb_istreams
;i
++) {
1987 for(i
=0;i
<nb_ostreams
;i
++) {
1991 fclose(ost
->logfile
);
1992 ost
->logfile
= NULL
;
1994 av_fifo_free(&ost
->fifo
); /* works even if fifo is not
1995 initialized but set to zero */
1996 av_free(ost
->pict_tmp
.data
[0]);
1997 if (ost
->video_resample
)
1998 sws_freeContext(ost
->img_resample_ctx
);
1999 if (ost
->audio_resample
)
2000 audio_resample_close(ost
->resample
);
2008 ret
= AVERROR(ENOMEM
);
2013 int file_read(const char *filename
)
2016 unsigned char buffer
[1024];
2019 if (url_open(&h
, filename
, O_RDONLY
) < 0) {
2020 printf("could not open '%s'\n", filename
);
2024 len
= url_read(h
, buffer
, sizeof(buffer
));
2027 for(i
=0;i
<len
;i
++) putchar(buffer
[i
]);
2034 static void opt_format(const char *arg
)
2036 /* compatibility stuff for pgmyuv */
2037 if (!strcmp(arg
, "pgmyuv")) {
2038 pgmyuv_compatibility_hack
=1;
2039 // opt_image_format(arg);
2041 fprintf(stderr
, "pgmyuv format is deprecated, use image2\n");
2044 file_iformat
= av_find_input_format(arg
);
2045 file_oformat
= guess_format(arg
, NULL
, NULL
);
2046 if (!file_iformat
&& !file_oformat
) {
2047 fprintf(stderr
, "Unknown input or output format: %s\n", arg
);
2052 static void opt_video_rc_eq(char *arg
)
2057 static void opt_video_rc_override_string(char *arg
)
2059 video_rc_override_string
= arg
;
2062 static void opt_me_threshold(const char *arg
)
2064 me_threshold
= atoi(arg
);
2067 static void opt_verbose(const char *arg
)
2069 verbose
= atoi(arg
);
2070 av_log_level
= atoi(arg
);
2073 static void opt_frame_rate(const char *arg
)
2075 if (av_parse_video_frame_rate(&frame_rate
, arg
) < 0) {
2076 fprintf(stderr
, "Incorrect frame rate\n");
2081 static void opt_frame_crop_top(const char *arg
)
2083 frame_topBand
= atoi(arg
);
2084 if (frame_topBand
< 0) {
2085 fprintf(stderr
, "Incorrect top crop size\n");
2088 if ((frame_topBand
% 2) != 0) {
2089 fprintf(stderr
, "Top crop size must be a multiple of 2\n");
2092 if ((frame_topBand
) >= frame_height
){
2093 fprintf(stderr
, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2096 frame_height
-= frame_topBand
;
2099 static void opt_frame_crop_bottom(const char *arg
)
2101 frame_bottomBand
= atoi(arg
);
2102 if (frame_bottomBand
< 0) {
2103 fprintf(stderr
, "Incorrect bottom crop size\n");
2106 if ((frame_bottomBand
% 2) != 0) {
2107 fprintf(stderr
, "Bottom crop size must be a multiple of 2\n");
2110 if ((frame_bottomBand
) >= frame_height
){
2111 fprintf(stderr
, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2114 frame_height
-= frame_bottomBand
;
2117 static void opt_frame_crop_left(const char *arg
)
2119 frame_leftBand
= atoi(arg
);
2120 if (frame_leftBand
< 0) {
2121 fprintf(stderr
, "Incorrect left crop size\n");
2124 if ((frame_leftBand
% 2) != 0) {
2125 fprintf(stderr
, "Left crop size must be a multiple of 2\n");
2128 if ((frame_leftBand
) >= frame_width
){
2129 fprintf(stderr
, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2132 frame_width
-= frame_leftBand
;
2135 static void opt_frame_crop_right(const char *arg
)
2137 frame_rightBand
= atoi(arg
);
2138 if (frame_rightBand
< 0) {
2139 fprintf(stderr
, "Incorrect right crop size\n");
2142 if ((frame_rightBand
% 2) != 0) {
2143 fprintf(stderr
, "Right crop size must be a multiple of 2\n");
2146 if ((frame_rightBand
) >= frame_width
){
2147 fprintf(stderr
, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2150 frame_width
-= frame_rightBand
;
2153 static void opt_frame_size(const char *arg
)
2155 if (av_parse_video_frame_size(&frame_width
, &frame_height
, arg
) < 0) {
2156 fprintf(stderr
, "Incorrect frame size\n");
2159 if ((frame_width
% 2) != 0 || (frame_height
% 2) != 0) {
2160 fprintf(stderr
, "Frame size must be a multiple of 2\n");
2166 #define SCALEBITS 10
2167 #define ONE_HALF (1 << (SCALEBITS - 1))
2168 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2170 #define RGB_TO_Y(r, g, b) \
2171 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2172 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2174 #define RGB_TO_U(r1, g1, b1, shift)\
2175 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2176 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2178 #define RGB_TO_V(r1, g1, b1, shift)\
2179 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2180 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2182 static void opt_pad_color(const char *arg
) {
2183 /* Input is expected to be six hex digits similar to
2184 how colors are expressed in html tags (but without the #) */
2185 int rgb
= strtol(arg
, NULL
, 16);
2189 g
= ((rgb
>> 8) & 255);
2192 padcolor
[0] = RGB_TO_Y(r
,g
,b
);
2193 padcolor
[1] = RGB_TO_U(r
,g
,b
,0);
2194 padcolor
[2] = RGB_TO_V(r
,g
,b
,0);
2197 static void opt_frame_pad_top(const char *arg
)
2199 frame_padtop
= atoi(arg
);
2200 if (frame_padtop
< 0) {
2201 fprintf(stderr
, "Incorrect top pad size\n");
2204 if ((frame_padtop
% 2) != 0) {
2205 fprintf(stderr
, "Top pad size must be a multiple of 2\n");
2210 static void opt_frame_pad_bottom(const char *arg
)
2212 frame_padbottom
= atoi(arg
);
2213 if (frame_padbottom
< 0) {
2214 fprintf(stderr
, "Incorrect bottom pad size\n");
2217 if ((frame_padbottom
% 2) != 0) {
2218 fprintf(stderr
, "Bottom pad size must be a multiple of 2\n");
2224 static void opt_frame_pad_left(const char *arg
)
2226 frame_padleft
= atoi(arg
);
2227 if (frame_padleft
< 0) {
2228 fprintf(stderr
, "Incorrect left pad size\n");
2231 if ((frame_padleft
% 2) != 0) {
2232 fprintf(stderr
, "Left pad size must be a multiple of 2\n");
2238 static void opt_frame_pad_right(const char *arg
)
2240 frame_padright
= atoi(arg
);
2241 if (frame_padright
< 0) {
2242 fprintf(stderr
, "Incorrect right pad size\n");
2245 if ((frame_padright
% 2) != 0) {
2246 fprintf(stderr
, "Right pad size must be a multiple of 2\n");
2251 void list_pix_fmts(void)
2254 char pix_fmt_str
[128];
2255 for (i
=-1; i
< PIX_FMT_NB
; i
++) {
2256 avcodec_pix_fmt_string (pix_fmt_str
, sizeof(pix_fmt_str
), i
);
2257 fprintf(stdout
, "%s\n", pix_fmt_str
);
2261 static void opt_frame_pix_fmt(const char *arg
)
2263 if (strcmp(arg
, "list"))
2264 frame_pix_fmt
= avcodec_get_pix_fmt(arg
);
2271 static void opt_frame_aspect_ratio(const char *arg
)
2277 p
= strchr(arg
, ':');
2279 x
= strtol(arg
, (char **)&arg
, 10);
2281 y
= strtol(arg
+1, (char **)&arg
, 10);
2283 ar
= (double)x
/ (double)y
;
2285 ar
= strtod(arg
, (char **)&arg
);
2288 fprintf(stderr
, "Incorrect aspect ratio specification.\n");
2291 frame_aspect_ratio
= ar
;
2294 static void opt_qscale(const char *arg
)
2296 video_qscale
= atof(arg
);
2297 if (video_qscale
<= 0 ||
2298 video_qscale
> 255) {
2299 fprintf(stderr
, "qscale must be > 0.0 and <= 255\n");
2304 static void opt_qdiff(const char *arg
)
2306 video_qdiff
= atoi(arg
);
2307 if (video_qdiff
< 0 ||
2309 fprintf(stderr
, "qdiff must be >= 1 and <= 31\n");
2314 static void opt_strict(const char *arg
)
2319 static void opt_top_field_first(const char *arg
)
2321 top_field_first
= atoi(arg
);
2324 static void opt_thread_count(const char *arg
)
2326 thread_count
= atoi(arg
);
2327 #if !defined(HAVE_THREADS)
2329 fprintf(stderr
, "Warning: not compiled with thread support, using thread emulation\n");
2333 static void opt_audio_rate(const char *arg
)
2335 audio_sample_rate
= atoi(arg
);
2338 static void opt_audio_channels(const char *arg
)
2340 audio_channels
= atoi(arg
);
2343 static void opt_video_channel(const char *arg
)
2345 video_channel
= strtol(arg
, NULL
, 0);
2348 static void opt_video_standard(const char *arg
)
2350 video_standard
= av_strdup(arg
);
2353 static void opt_codec(int *pstream_copy
, int *pcodec_id
,
2354 int codec_type
, const char *arg
)
2358 if (!strcmp(arg
, "copy")) {
2363 if (!strcmp(p
->name
, arg
) && p
->type
== codec_type
)
2368 fprintf(stderr
, "Unknown codec '%s'\n", arg
);
2376 static void opt_audio_codec(const char *arg
)
2378 opt_codec(&audio_stream_copy
, &audio_codec_id
, CODEC_TYPE_AUDIO
, arg
);
2381 static void opt_audio_tag(const char *arg
)
2384 audio_codec_tag
= strtol(arg
, &tail
, 0);
2387 audio_codec_tag
= arg
[0] + (arg
[1]<<8) + (arg
[2]<<16) + (arg
[3]<<24);
2390 static void opt_video_tag(const char *arg
)
2393 video_codec_tag
= strtol(arg
, &tail
, 0);
2396 video_codec_tag
= arg
[0] + (arg
[1]<<8) + (arg
[2]<<16) + (arg
[3]<<24);
2399 static void add_frame_hooker(const char *arg
)
2404 char *args
= av_strdup(arg
);
2408 argv
[0] = strtok(args
, " ");
2409 while (argc
< 62 && (argv
[++argc
] = strtok(NULL
, " "))) {
2412 i
= frame_hook_add(argc
, argv
);
2415 fprintf(stderr
, "Failed to add video hook function: %s\n", arg
);
2420 const char *motion_str
[] = {
2433 static void opt_motion_estimation(const char *arg
)
2439 fprintf(stderr
, "Unknown motion estimation method '%s'\n", arg
);
2442 if (!strcmp(*p
, arg
))
2446 me_method
= (p
- motion_str
) + 1;
2449 static void opt_video_codec(const char *arg
)
2451 opt_codec(&video_stream_copy
, &video_codec_id
, CODEC_TYPE_VIDEO
, arg
);
2454 static void opt_subtitle_codec(const char *arg
)
2456 opt_codec(&subtitle_stream_copy
, &subtitle_codec_id
, CODEC_TYPE_SUBTITLE
, arg
);
2459 static void opt_map(const char *arg
)
2465 m
= &stream_maps
[nb_stream_maps
++];
2467 m
->file_index
= strtol(arg
, (char **)&p
, 0);
2471 m
->stream_index
= strtol(p
, (char **)&p
, 0);
2474 m
->sync_file_index
= strtol(p
, (char **)&p
, 0);
2477 m
->sync_stream_index
= strtol(p
, (char **)&p
, 0);
2479 m
->sync_file_index
= m
->file_index
;
2480 m
->sync_stream_index
= m
->stream_index
;
2484 static void opt_map_meta_data(const char *arg
)
2490 m
= &meta_data_maps
[nb_meta_data_maps
++];
2492 m
->out_file
= strtol(arg
, (char **)&p
, 0);
2496 m
->in_file
= strtol(p
, (char **)&p
, 0);
2499 static void opt_recording_time(const char *arg
)
2501 recording_time
= parse_date(arg
, 1);
2504 static void opt_start_time(const char *arg
)
2506 start_time
= parse_date(arg
, 1);
2509 static void opt_rec_timestamp(const char *arg
)
2511 rec_timestamp
= parse_date(arg
, 0) / 1000000;
2514 static void opt_input_ts_offset(const char *arg
)
2516 input_ts_offset
= parse_date(arg
, 1);
2519 static void opt_input_file(const char *filename
)
2521 AVFormatContext
*ic
;
2522 AVFormatParameters params
, *ap
= ¶ms
;
2523 int err
, i
, ret
, rfps
, rfps_base
;
2526 if (!strcmp(filename
, "-"))
2529 using_stdin
|= !strncmp(filename
, "pipe:", 5) ||
2530 !strcmp( filename
, "/dev/stdin" );
2532 /* get default parameters from command line */
2533 ic
= av_alloc_format_context();
2535 memset(ap
, 0, sizeof(*ap
));
2536 ap
->prealloced_context
= 1;
2537 ap
->sample_rate
= audio_sample_rate
;
2538 ap
->channels
= audio_channels
;
2539 ap
->time_base
.den
= frame_rate
.num
;
2540 ap
->time_base
.num
= frame_rate
.den
;
2541 ap
->width
= frame_width
+ frame_padleft
+ frame_padright
;
2542 ap
->height
= frame_height
+ frame_padtop
+ frame_padbottom
;
2543 ap
->pix_fmt
= frame_pix_fmt
;
2544 ap
->channel
= video_channel
;
2545 ap
->standard
= video_standard
;
2546 ap
->video_codec_id
= video_codec_id
;
2547 ap
->audio_codec_id
= audio_codec_id
;
2548 if(pgmyuv_compatibility_hack
)
2549 ap
->video_codec_id
= CODEC_ID_PGMYUV
;
2551 for(i
=0; i
<opt_name_count
; i
++){
2552 const AVOption
*opt
;
2553 double d
= av_get_double(avformat_opts
, opt_names
[i
], &opt
);
2554 if(d
==d
&& (opt
->flags
&AV_OPT_FLAG_DECODING_PARAM
))
2555 av_set_double(ic
, opt_names
[i
], d
);
2557 /* open the input file with generic libav function */
2558 err
= av_open_input_file(&ic
, filename
, file_iformat
, 0, ap
);
2560 print_error(filename
, err
);
2564 ic
->loop_input
= loop_input
;
2566 /* If not enough info to get the stream parameters, we decode the
2567 first frames to get it. (used in mpeg case for example) */
2568 ret
= av_find_stream_info(ic
);
2569 if (ret
< 0 && verbose
>= 0) {
2570 fprintf(stderr
, "%s: could not find codec parameters\n", filename
);
2574 timestamp
= start_time
;
2575 /* add the stream start time */
2576 if (ic
->start_time
!= AV_NOPTS_VALUE
)
2577 timestamp
+= ic
->start_time
;
2579 /* if seeking requested, we execute it */
2580 if (start_time
!= 0) {
2581 ret
= av_seek_frame(ic
, -1, timestamp
, AVSEEK_FLAG_BACKWARD
);
2583 fprintf(stderr
, "%s: could not seek to position %0.3f\n",
2584 filename
, (double)timestamp
/ AV_TIME_BASE
);
2586 /* reset seek info */
2590 /* update the current parameters so that they match the one of the input stream */
2591 for(i
=0;i
<ic
->nb_streams
;i
++) {
2593 AVCodecContext
*enc
= ic
->streams
[i
]->codec
;
2595 avcodec_thread_init(enc
, thread_count
);
2596 enc
->thread_count
= thread_count
;
2597 switch(enc
->codec_type
) {
2598 case CODEC_TYPE_AUDIO
:
2599 for(j
=0; j
<opt_name_count
; j
++){
2600 const AVOption
*opt
;
2601 double d
= av_get_double(avctx_opts
[CODEC_TYPE_AUDIO
], opt_names
[j
], &opt
);
2602 if(d
==d
&& (opt
->flags
&AV_OPT_FLAG_AUDIO_PARAM
) && (opt
->flags
&AV_OPT_FLAG_DECODING_PARAM
))
2603 av_set_double(enc
, opt_names
[j
], d
);
2605 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2606 audio_channels
= enc
->channels
;
2607 audio_sample_rate
= enc
->sample_rate
;
2609 ic
->streams
[i
]->discard
= AVDISCARD_ALL
;
2611 case CODEC_TYPE_VIDEO
:
2612 for(j
=0; j
<opt_name_count
; j
++){
2613 const AVOption
*opt
;
2614 double d
= av_get_double(avctx_opts
[CODEC_TYPE_VIDEO
], opt_names
[j
], &opt
);
2615 if(d
==d
&& (opt
->flags
&AV_OPT_FLAG_VIDEO_PARAM
) && (opt
->flags
&AV_OPT_FLAG_DECODING_PARAM
))
2616 av_set_double(enc
, opt_names
[j
], d
);
2618 frame_height
= enc
->height
;
2619 frame_width
= enc
->width
;
2620 frame_aspect_ratio
= av_q2d(enc
->sample_aspect_ratio
) * enc
->width
/ enc
->height
;
2621 frame_pix_fmt
= enc
->pix_fmt
;
2622 rfps
= ic
->streams
[i
]->r_frame_rate
.num
;
2623 rfps_base
= ic
->streams
[i
]->r_frame_rate
.den
;
2624 if(enc
->lowres
) enc
->flags
|= CODEC_FLAG_EMU_EDGE
;
2626 enc
->debug
|= FF_DEBUG_MV
;
2628 if (enc
->time_base
.den
!= rfps
|| enc
->time_base
.num
!= rfps_base
) {
2631 fprintf(stderr
,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2632 i
, (float)enc
->time_base
.den
/ enc
->time_base
.num
, enc
->time_base
.den
, enc
->time_base
.num
,
2634 (float)rfps
/ rfps_base
, rfps
, rfps_base
);
2636 /* update the current frame rate to match the stream frame rate */
2637 frame_rate
.num
= rfps
;
2638 frame_rate
.den
= rfps_base
;
2640 enc
->rate_emu
= rate_emu
;
2642 ic
->streams
[i
]->discard
= AVDISCARD_ALL
;
2643 else if(video_discard
)
2644 ic
->streams
[i
]->discard
= video_discard
;
2646 case CODEC_TYPE_DATA
:
2648 case CODEC_TYPE_SUBTITLE
:
2650 case CODEC_TYPE_UNKNOWN
:
2657 input_files
[nb_input_files
] = ic
;
2658 input_files_ts_offset
[nb_input_files
] = input_ts_offset
- (copy_ts ?
0 : timestamp
);
2659 /* dump the file content */
2661 dump_format(ic
, nb_input_files
, filename
, 0);
2664 file_iformat
= NULL
;
2665 file_oformat
= NULL
;
2672 static void check_audio_video_inputs(int *has_video_ptr
, int *has_audio_ptr
)
2674 int has_video
, has_audio
, i
, j
;
2675 AVFormatContext
*ic
;
2679 for(j
=0;j
<nb_input_files
;j
++) {
2680 ic
= input_files
[j
];
2681 for(i
=0;i
<ic
->nb_streams
;i
++) {
2682 AVCodecContext
*enc
= ic
->streams
[i
]->codec
;
2683 switch(enc
->codec_type
) {
2684 case CODEC_TYPE_AUDIO
:
2687 case CODEC_TYPE_VIDEO
:
2690 case CODEC_TYPE_DATA
:
2691 case CODEC_TYPE_UNKNOWN
:
2692 case CODEC_TYPE_SUBTITLE
:
2699 *has_video_ptr
= has_video
;
2700 *has_audio_ptr
= has_audio
;
2703 static void new_video_stream(AVFormatContext
*oc
)
2706 AVCodecContext
*video_enc
;
2709 st
= av_new_stream(oc
, oc
->nb_streams
);
2711 fprintf(stderr
, "Could not alloc stream\n");
2714 avcodec_get_context_defaults2(st
->codec
, CODEC_TYPE_VIDEO
);
2715 bitstream_filters
[nb_output_files
][oc
->nb_streams
- 1]= video_bitstream_filters
;
2716 video_bitstream_filters
= NULL
;
2719 avcodec_thread_init(st
->codec
, thread_count
);
2721 video_enc
= st
->codec
;
2724 video_enc
->codec_tag
= video_codec_tag
;
2726 if( (video_global_header
&1)
2727 || (video_global_header
==0 && (oc
->oformat
->flags
& AVFMT_GLOBALHEADER
))){
2728 video_enc
->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
2729 avctx_opts
[CODEC_TYPE_VIDEO
]->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
2731 if(video_global_header
&2){
2732 video_enc
->flags2
|= CODEC_FLAG2_LOCAL_HEADER
;
2733 avctx_opts
[CODEC_TYPE_VIDEO
]->flags2
|= CODEC_FLAG2_LOCAL_HEADER
;
2736 if (video_stream_copy
) {
2737 st
->stream_copy
= 1;
2738 video_enc
->codec_type
= CODEC_TYPE_VIDEO
;
2744 codec_id
= av_guess_codec(oc
->oformat
, NULL
, oc
->filename
, NULL
, CODEC_TYPE_VIDEO
);
2745 if (video_codec_id
!= CODEC_ID_NONE
)
2746 codec_id
= video_codec_id
;
2748 video_enc
->codec_id
= codec_id
;
2749 codec
= avcodec_find_encoder(codec_id
);
2751 for(i
=0; i
<opt_name_count
; i
++){
2752 const AVOption
*opt
;
2753 double d
= av_get_double(avctx_opts
[CODEC_TYPE_VIDEO
], opt_names
[i
], &opt
);
2754 if(d
==d
&& (opt
->flags
&AV_OPT_FLAG_VIDEO_PARAM
) && (opt
->flags
&AV_OPT_FLAG_ENCODING_PARAM
))
2755 av_set_double(video_enc
, opt_names
[i
], d
);
2758 video_enc
->time_base
.den
= frame_rate
.num
;
2759 video_enc
->time_base
.num
= frame_rate
.den
;
2760 if(codec
&& codec
->supported_framerates
){
2761 const AVRational
*p
= codec
->supported_framerates
;
2762 AVRational req
= (AVRational
){frame_rate
.num
, frame_rate
.den
};
2763 const AVRational
*best
=NULL
;
2764 AVRational best_error
= (AVRational
){INT_MAX
, 1};
2765 for(; p
->den
!=0; p
++){
2766 AVRational error
= av_sub_q(req
, *p
);
2767 if(error
.num
<0) error
.num
*= -1;
2768 if(av_cmp_q(error
, best_error
) < 0){
2773 video_enc
->time_base
.den
= best
->num
;
2774 video_enc
->time_base
.num
= best
->den
;
2777 video_enc
->width
= frame_width
+ frame_padright
+ frame_padleft
;
2778 video_enc
->height
= frame_height
+ frame_padtop
+ frame_padbottom
;
2779 video_enc
->sample_aspect_ratio
= av_d2q(frame_aspect_ratio
*video_enc
->height
/video_enc
->width
, 255);
2780 video_enc
->pix_fmt
= frame_pix_fmt
;
2782 if(codec
&& codec
->pix_fmts
){
2783 const enum PixelFormat
*p
= codec
->pix_fmts
;
2785 if(*p
== video_enc
->pix_fmt
)
2789 video_enc
->pix_fmt
= codec
->pix_fmts
[0];
2793 video_enc
->gop_size
= 0;
2794 if (video_qscale
|| same_quality
) {
2795 video_enc
->flags
|= CODEC_FLAG_QSCALE
;
2796 video_enc
->global_quality
=
2797 st
->quality
= FF_QP2LAMBDA
* video_qscale
;
2801 video_enc
->intra_matrix
= intra_matrix
;
2803 video_enc
->inter_matrix
= inter_matrix
;
2805 video_enc
->max_qdiff
= video_qdiff
;
2806 video_enc
->rc_eq
= video_rc_eq
;
2807 video_enc
->thread_count
= thread_count
;
2808 p
= video_rc_override_string
;
2811 int e
=sscanf(p
, "%d,%d,%d", &start
, &end
, &q
);
2813 fprintf(stderr
, "error parsing rc_override\n");
2816 video_enc
->rc_override
=
2817 av_realloc(video_enc
->rc_override
,
2818 sizeof(RcOverride
)*(i
+1));
2819 video_enc
->rc_override
[i
].start_frame
= start
;
2820 video_enc
->rc_override
[i
].end_frame
= end
;
2822 video_enc
->rc_override
[i
].qscale
= q
;
2823 video_enc
->rc_override
[i
].quality_factor
= 1.0;
2826 video_enc
->rc_override
[i
].qscale
= 0;
2827 video_enc
->rc_override
[i
].quality_factor
= -q
/100.0;
2832 video_enc
->rc_override_count
=i
;
2833 if (!video_enc
->rc_initial_buffer_occupancy
)
2834 video_enc
->rc_initial_buffer_occupancy
= video_enc
->rc_buffer_size
*3/4;
2835 video_enc
->me_threshold
= me_threshold
;
2836 video_enc
->intra_dc_precision
= intra_dc_precision
- 8;
2837 video_enc
->strict_std_compliance
= strict
;
2840 video_enc
->flags
|= CODEC_FLAG_PSNR
;
2842 video_enc
->me_method
= me_method
;
2847 video_enc
->flags
|= CODEC_FLAG_PASS1
;
2849 video_enc
->flags
|= CODEC_FLAG_PASS2
;
2854 /* reset some key parameters */
2856 video_codec_id
= CODEC_ID_NONE
;
2857 video_stream_copy
= 0;
2860 static void new_audio_stream(AVFormatContext
*oc
)
2863 AVCodecContext
*audio_enc
;
2866 st
= av_new_stream(oc
, oc
->nb_streams
);
2868 fprintf(stderr
, "Could not alloc stream\n");
2871 avcodec_get_context_defaults2(st
->codec
, CODEC_TYPE_AUDIO
);
2873 bitstream_filters
[nb_output_files
][oc
->nb_streams
- 1]= audio_bitstream_filters
;
2874 audio_bitstream_filters
= NULL
;
2877 avcodec_thread_init(st
->codec
, thread_count
);
2879 audio_enc
= st
->codec
;
2880 audio_enc
->codec_type
= CODEC_TYPE_AUDIO
;
2881 audio_enc
->strict_std_compliance
= strict
;
2884 audio_enc
->codec_tag
= audio_codec_tag
;
2886 if (oc
->oformat
->flags
& AVFMT_GLOBALHEADER
) {
2887 audio_enc
->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
2888 avctx_opts
[CODEC_TYPE_AUDIO
]->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
2890 if (audio_stream_copy
) {
2891 st
->stream_copy
= 1;
2892 audio_enc
->channels
= audio_channels
;
2894 codec_id
= av_guess_codec(oc
->oformat
, NULL
, oc
->filename
, NULL
, CODEC_TYPE_AUDIO
);
2896 for(i
=0; i
<opt_name_count
; i
++){
2897 const AVOption
*opt
;
2898 double d
= av_get_double(avctx_opts
[CODEC_TYPE_AUDIO
], opt_names
[i
], &opt
);
2899 if(d
==d
&& (opt
->flags
&AV_OPT_FLAG_AUDIO_PARAM
) && (opt
->flags
&AV_OPT_FLAG_ENCODING_PARAM
))
2900 av_set_double(audio_enc
, opt_names
[i
], d
);
2903 if (audio_codec_id
!= CODEC_ID_NONE
)
2904 codec_id
= audio_codec_id
;
2905 audio_enc
->codec_id
= codec_id
;
2907 if (audio_qscale
> QSCALE_NONE
) {
2908 audio_enc
->flags
|= CODEC_FLAG_QSCALE
;
2909 audio_enc
->global_quality
= st
->quality
= FF_QP2LAMBDA
* audio_qscale
;
2911 audio_enc
->thread_count
= thread_count
;
2912 audio_enc
->channels
= audio_channels
;
2914 audio_enc
->sample_rate
= audio_sample_rate
;
2915 audio_enc
->time_base
= (AVRational
){1, audio_sample_rate
};
2916 if (audio_language
) {
2917 av_strlcpy(st
->language
, audio_language
, sizeof(st
->language
));
2918 av_free(audio_language
);
2919 audio_language
= NULL
;
2922 /* reset some key parameters */
2924 audio_codec_id
= CODEC_ID_NONE
;
2925 audio_stream_copy
= 0;
2928 static void opt_new_subtitle_stream(void)
2930 AVFormatContext
*oc
;
2932 AVCodecContext
*subtitle_enc
;
2935 if (nb_output_files
<= 0) {
2936 fprintf(stderr
, "At least one output file must be specified\n");
2939 oc
= output_files
[nb_output_files
- 1];
2941 st
= av_new_stream(oc
, oc
->nb_streams
);
2943 fprintf(stderr
, "Could not alloc stream\n");
2946 avcodec_get_context_defaults2(st
->codec
, CODEC_TYPE_SUBTITLE
);
2948 subtitle_enc
= st
->codec
;
2949 subtitle_enc
->codec_type
= CODEC_TYPE_SUBTITLE
;
2950 if (subtitle_stream_copy
) {
2951 st
->stream_copy
= 1;
2953 for(i
=0; i
<opt_name_count
; i
++){
2954 const AVOption
*opt
;
2955 double d
= av_get_double(avctx_opts
[CODEC_TYPE_SUBTITLE
], opt_names
[i
], &opt
);
2956 if(d
==d
&& (opt
->flags
&AV_OPT_FLAG_SUBTITLE_PARAM
) && (opt
->flags
&AV_OPT_FLAG_ENCODING_PARAM
))
2957 av_set_double(subtitle_enc
, opt_names
[i
], d
);
2959 subtitle_enc
->codec_id
= subtitle_codec_id
;
2962 if (subtitle_language
) {
2963 av_strlcpy(st
->language
, subtitle_language
, sizeof(st
->language
));
2964 av_free(subtitle_language
);
2965 subtitle_language
= NULL
;
2968 subtitle_codec_id
= CODEC_ID_NONE
;
2969 subtitle_stream_copy
= 0;
2972 static void opt_new_audio_stream(void)
2974 AVFormatContext
*oc
;
2975 if (nb_output_files
<= 0) {
2976 fprintf(stderr
, "At least one output file must be specified\n");
2979 oc
= output_files
[nb_output_files
- 1];
2980 new_audio_stream(oc
);
2983 static void opt_new_video_stream(void)
2985 AVFormatContext
*oc
;
2986 if (nb_output_files
<= 0) {
2987 fprintf(stderr
, "At least one output file must be specified\n");
2990 oc
= output_files
[nb_output_files
- 1];
2991 new_video_stream(oc
);
2994 static void opt_output_file(const char *filename
)
2996 AVFormatContext
*oc
;
2997 int use_video
, use_audio
, input_has_video
, input_has_audio
, i
;
2998 AVFormatParameters params
, *ap
= ¶ms
;
3000 if (!strcmp(filename
, "-"))
3003 oc
= av_alloc_format_context();
3005 if (!file_oformat
) {
3006 file_oformat
= guess_format(NULL
, filename
, NULL
);
3007 if (!file_oformat
) {
3008 fprintf(stderr
, "Unable for find a suitable output format for '%s'\n",
3014 oc
->oformat
= file_oformat
;
3015 av_strlcpy(oc
->filename
, filename
, sizeof(oc
->filename
));
3017 if (!strcmp(file_oformat
->name
, "ffm") &&
3018 av_strstart(filename
, "http:", NULL
)) {
3019 /* special case for files sent to ffserver: we get the stream
3020 parameters from ffserver */
3021 if (read_ffserver_streams(oc
, filename
) < 0) {
3022 fprintf(stderr
, "Could not read stream parameters from '%s'\n", filename
);
3026 use_video
= file_oformat
->video_codec
!= CODEC_ID_NONE
|| video_stream_copy
|| video_codec_id
!= CODEC_ID_NONE
;
3027 use_audio
= file_oformat
->audio_codec
!= CODEC_ID_NONE
|| audio_stream_copy
|| audio_codec_id
!= CODEC_ID_NONE
;
3029 /* disable if no corresponding type found and at least one
3031 if (nb_input_files
> 0) {
3032 check_audio_video_inputs(&input_has_video
, &input_has_audio
);
3033 if (!input_has_video
)
3035 if (!input_has_audio
)
3039 /* manual disable */
3040 if (audio_disable
) {
3043 if (video_disable
) {
3048 new_video_stream(oc
);
3052 new_audio_stream(oc
);
3055 oc
->timestamp
= rec_timestamp
;
3058 av_strlcpy(oc
->title
, str_title
, sizeof(oc
->title
));
3060 av_strlcpy(oc
->author
, str_author
, sizeof(oc
->author
));
3062 av_strlcpy(oc
->copyright
, str_copyright
, sizeof(oc
->copyright
));
3064 av_strlcpy(oc
->comment
, str_comment
, sizeof(oc
->comment
));
3066 av_strlcpy(oc
->album
, str_album
, sizeof(oc
->album
));
3069 output_files
[nb_output_files
++] = oc
;
3071 /* check filename in case of an image number is expected */
3072 if (oc
->oformat
->flags
& AVFMT_NEEDNUMBER
) {
3073 if (!av_filename_number_test(oc
->filename
)) {
3074 print_error(oc
->filename
, AVERROR_NUMEXPECTED
);
3079 if (!(oc
->oformat
->flags
& AVFMT_NOFILE
)) {
3080 /* test if it already exists to avoid loosing precious files */
3081 if (!file_overwrite
&&
3082 (strchr(filename
, ':') == NULL
||
3083 av_strstart(filename
, "file:", NULL
))) {
3084 if (url_exist(filename
)) {
3087 if ( !using_stdin
) {
3088 fprintf(stderr
,"File '%s' already exists. Overwrite ? [y/N] ", filename
);
3091 if (toupper(c
) != 'Y') {
3092 fprintf(stderr
, "Not overwriting - exiting\n");
3097 fprintf(stderr
,"File '%s' already exists. Exiting.\n", filename
);
3104 if (url_fopen(&oc
->pb
, filename
, URL_WRONLY
) < 0) {
3105 fprintf(stderr
, "Could not open '%s'\n", filename
);
3110 memset(ap
, 0, sizeof(*ap
));
3111 if (av_set_parameters(oc
, ap
) < 0) {
3112 fprintf(stderr
, "%s: Invalid encoding parameters\n",
3117 oc
->preload
= (int)(mux_preload
*AV_TIME_BASE
);
3118 oc
->max_delay
= (int)(mux_max_delay
*AV_TIME_BASE
);
3119 oc
->loop_output
= loop_output
;
3121 for(i
=0; i
<opt_name_count
; i
++){
3122 const AVOption
*opt
;
3123 double d
= av_get_double(avformat_opts
, opt_names
[i
], &opt
);
3124 if(d
==d
&& (opt
->flags
&AV_OPT_FLAG_ENCODING_PARAM
))
3125 av_set_double(oc
, opt_names
[i
], d
);
3128 /* reset some options */
3129 file_oformat
= NULL
;
3130 file_iformat
= NULL
;
3133 /* same option as mencoder */
3134 static void opt_pass(const char *pass_str
)
3137 pass
= atoi(pass_str
);
3138 if (pass
!= 1 && pass
!= 2) {
3139 fprintf(stderr
, "pass number can be only 1 or 2\n");
3145 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3146 static int64_t getutime(void)
3148 return av_gettime();
3151 static int64_t getutime(void)
3153 struct rusage rusage
;
3155 getrusage(RUSAGE_SELF
, &rusage
);
3156 return (rusage
.ru_utime
.tv_sec
* 1000000LL) + rusage
.ru_utime
.tv_usec
;
3160 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3161 extern int ffm_nopts
;
3164 static void show_formats(void)
3166 AVInputFormat
*ifmt
;
3167 AVOutputFormat
*ofmt
;
3170 const char **pp
, *last_name
;
3172 printf("File formats:\n");
3177 const char *name
=NULL
;
3178 const char *long_name
=NULL
;
3180 for(ofmt
= first_oformat
; ofmt
!= NULL
; ofmt
= ofmt
->next
) {
3181 if((name
== NULL
|| strcmp(ofmt
->name
, name
)<0) &&
3182 strcmp(ofmt
->name
, last_name
)>0){
3184 long_name
= ofmt
->long_name
;
3188 for(ifmt
= first_iformat
; ifmt
!= NULL
; ifmt
= ifmt
->next
) {
3189 if((name
== NULL
|| strcmp(ifmt
->name
, name
)<0) &&
3190 strcmp(ifmt
->name
, last_name
)>0){
3192 long_name
= ifmt
->long_name
;
3195 if(name
&& strcmp(ifmt
->name
, name
)==0)
3207 long_name ? long_name
:" ");
3211 printf("Codecs:\n");
3217 const char *type_str
;
3220 for(p
= first_avcodec
; p
!= NULL
; p
= p
->next
) {
3221 if((p2
==NULL
|| strcmp(p
->name
, p2
->name
)<0) &&
3222 strcmp(p
->name
, last_name
)>0){
3224 decode
= encode
= cap
=0;
3226 if(p2
&& strcmp(p
->name
, p2
->name
)==0){
3227 if(p
->decode
) decode
=1;
3228 if(p
->encode
) encode
=1;
3229 cap
|= p
->capabilities
;
3234 last_name
= p2
->name
;
3237 case CODEC_TYPE_VIDEO
:
3240 case CODEC_TYPE_AUDIO
:
3243 case CODEC_TYPE_SUBTITLE
: