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
21 #define HAVE_AV_CONFIG_H
25 #include "framehook.h"
33 #include <sys/ioctl.h>
36 #include <sys/resource.h>
40 #include <sys/types.h>
41 #include <sys/select.h>
44 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
53 #if !defined(INFINITY) && defined(HUGE_VAL)
54 #define INFINITY HUGE_VAL
57 /* select an input stream for an output stream */
58 typedef struct AVStreamMap
{
62 int sync_stream_index
;
65 /** select an input file for an output file */
66 typedef struct AVMetaDataMap
{
71 extern const OptionDef options
[];
73 static void show_help(void);
74 static void show_license(void);
75 static int opt_default(const char *opt
, const char *arg
);
79 static AVFormatContext
*input_files
[MAX_FILES
];
80 static int64_t input_files_ts_offset
[MAX_FILES
];
81 static int nb_input_files
= 0;
83 static AVFormatContext
*output_files
[MAX_FILES
];
84 static int nb_output_files
= 0;
86 static AVStreamMap stream_maps
[MAX_FILES
];
87 static int nb_stream_maps
;
89 static AVMetaDataMap meta_data_maps
[MAX_FILES
];
90 static int nb_meta_data_maps
;
92 static AVInputFormat
*file_iformat
;
93 static AVOutputFormat
*file_oformat
;
94 static int frame_width
= 0;
95 static int frame_height
= 0;
96 static float frame_aspect_ratio
= 0;
97 static enum PixelFormat frame_pix_fmt
= PIX_FMT_NONE
;
98 static int frame_padtop
= 0;
99 static int frame_padbottom
= 0;
100 static int frame_padleft
= 0;
101 static int frame_padright
= 0;
102 static int padcolor
[3] = {16,128,128}; /* default to black */
103 static int frame_topBand
= 0;
104 static int frame_bottomBand
= 0;
105 static int frame_leftBand
= 0;
106 static int frame_rightBand
= 0;
107 static int max_frames
[4] = {INT_MAX
, INT_MAX
, INT_MAX
, INT_MAX
};
108 static int frame_rate
= 25;
109 static int frame_rate_base
= 1;
110 static float video_qscale
= 0;
111 static int video_qdiff
= 3;
112 static uint16_t *intra_matrix
= NULL
;
113 static uint16_t *inter_matrix
= NULL
;
114 #if 0 //experimental, (can be removed)
115 static float video_rc_qsquish
=1.0;
116 static float video_rc_qmod_amp
=0;
117 static int video_rc_qmod_freq
=0;
119 static char *video_rc_override_string
=NULL
;
120 static char *video_rc_eq
="tex^qComp";
121 static int me_method
= ME_EPZS
;
122 static int video_disable
= 0;
123 static int video_discard
= 0;
124 static int video_codec_id
= CODEC_ID_NONE
;
125 static int video_codec_tag
= 0;
126 static int same_quality
= 0;
127 static int do_deinterlace
= 0;
128 static int packet_size
= 0;
129 static int strict
= 0;
130 static int top_field_first
= -1;
131 static int me_threshold
= 0;
132 static int intra_dc_precision
= 8;
133 static int loop_input
= 0;
134 static int loop_output
= AVFMT_NOOUTPUTLOOP
;
135 static int qp_hist
= 0;
137 static int intra_only
= 0;
138 static int audio_sample_rate
= 44100;
139 static int audio_bit_rate
= 64000;
140 #define QSCALE_NONE -99999
141 static float audio_qscale
= QSCALE_NONE
;
142 static int audio_disable
= 0;
143 static int audio_channels
= 1;
144 static int audio_codec_id
= CODEC_ID_NONE
;
145 static int audio_codec_tag
= 0;
146 static char *audio_language
= NULL
;
148 static int subtitle_codec_id
= CODEC_ID_NONE
;
149 static char *subtitle_language
= NULL
;
151 static float mux_preload
= 0.5;
152 static float mux_max_delay
= 0.7;
154 static int64_t recording_time
= 0;
155 static int64_t start_time
= 0;
156 static int64_t rec_timestamp
= 0;
157 static int64_t input_ts_offset
= 0;
158 static int file_overwrite
= 0;
159 static char *str_title
= NULL
;
160 static char *str_author
= NULL
;
161 static char *str_copyright
= NULL
;
162 static char *str_comment
= NULL
;
163 static char *str_album
= NULL
;
164 static int do_benchmark
= 0;
165 static int do_hex_dump
= 0;
166 static int do_pkt_dump
= 0;
167 static int do_psnr
= 0;
168 static int do_vstats
= 0;
169 static int do_pass
= 0;
170 static char *pass_logfilename
= NULL
;
171 static int audio_stream_copy
= 0;
172 static int video_stream_copy
= 0;
173 static int subtitle_stream_copy
= 0;
174 static int video_sync_method
= 1;
175 static int audio_sync_method
= 0;
176 static int copy_ts
= 0;
177 static int opt_shortest
= 0; //
178 static int video_global_header
= 0;
180 static int rate_emu
= 0;
183 static const char *video_grab_format
= "bktr";
185 #ifdef CONFIG_VIDEO4LINUX2
186 static const char *video_grab_format
= "video4linux2";
188 static const char *video_grab_format
= "video4linux";
191 static char *video_device
= NULL
;
192 static char *grab_device
= NULL
;
193 static int video_channel
= 0;
194 static char *video_standard
= "ntsc";
196 static const char *audio_grab_format
= "audio_device";
197 static char *audio_device
= NULL
;
198 static int audio_volume
= 256;
200 static int using_stdin
= 0;
201 static int using_vhook
= 0;
202 static int verbose
= 1;
203 static int thread_count
= 1;
204 static int q_pressed
= 0;
205 static int64_t video_size
= 0;
206 static int64_t audio_size
= 0;
207 static int64_t extra_size
= 0;
208 static int nb_frames_dup
= 0;
209 static int nb_frames_drop
= 0;
210 static int input_sync
;
211 static int limit_filesize
= 0; //
213 static int pgmyuv_compatibility_hack
=0;
214 static int dts_delta_threshold
= 10;
216 static int sws_flags
= SWS_BICUBIC
;
218 const char **opt_names
=NULL
;
219 int opt_name_count
=0;
220 AVCodecContext
*avctx_opts
;
221 AVFormatContext
*avformat_opts
;
223 static AVBitStreamFilterContext
*video_bitstream_filters
=NULL
;
224 static AVBitStreamFilterContext
*audio_bitstream_filters
=NULL
;
225 static AVBitStreamFilterContext
*bitstream_filters
[MAX_FILES
][MAX_STREAMS
];
227 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
229 struct AVInputStream
;
231 typedef struct AVOutputStream
{
232 int file_index
; /* file index */
233 int index
; /* stream index in the output file */
234 int source_index
; /* AVInputStream index */
235 AVStream
*st
; /* stream in the output file */
236 int encoding_needed
; /* true if encoding needed for this stream */
238 /* input pts and corresponding output pts
240 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
241 struct AVInputStream
*sync_ist
; /* input stream to sync against */
242 int64_t sync_opts
; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
245 AVFrame pict_tmp
; /* temporary image for resampling */
246 struct SwsContext
*img_resample_ctx
; /* for image resampling */
250 int topBand
; /* cropping area sizes */
254 int padtop
; /* padding area sizes */
261 ReSampleContext
*resample
; /* for audio resampling */
262 AVFifoBuffer fifo
; /* for compression: one audio fifo per codec */
266 typedef struct AVInputStream
{
270 int discard
; /* true if stream data should be discarded */
271 int decoding_needed
; /* true if the packets must be decoded in 'raw_fifo' */
272 int64_t sample_index
; /* current sample */
274 int64_t start
; /* time when read started */
275 unsigned long frame
; /* current frame */
276 int64_t next_pts
; /* synthetic pts for cases where pkt.pts
278 int64_t pts
; /* current pts */
279 int is_start
; /* is 1 at the start and after a discontinuity */
282 typedef struct AVInputFile
{
283 int eof_reached
; /* true if eof reached */
284 int ist_index
; /* index of first stream in ist_table */
285 int buffer_size
; /* current total buffer size */
286 int buffer_size_max
; /* buffer size at which we consider we can stop
288 int nb_streams
; /* nb streams we are aware of */
293 /* init terminal so that we can grab keys */
294 static struct termios oldtty
;
296 static void term_exit(void)
298 tcsetattr (0, TCSANOW
, &oldtty
);
301 static volatile sig_atomic_t received_sigterm
= 0;
304 sigterm_handler(int sig
)
306 received_sigterm
= sig
;
310 static void term_init(void)
317 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
318 |INLCR
|IGNCR
|ICRNL
|IXON
);
319 tty
.c_oflag
|= OPOST
;
320 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
321 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
326 tcsetattr (0, TCSANOW
, &tty
);
328 signal(SIGINT
, sigterm_handler
); /* Interrupt (ANSI). */
329 signal(SIGQUIT
, sigterm_handler
); /* Quit (POSIX). */
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)
345 #ifndef CONFIG_BEOS_NETSERVER
353 n
= select(1, &rfds
, NULL
, NULL
, &tv
);
365 static int decode_interrupt_cb(void)
367 return q_pressed
|| (q_pressed
= read_key() == 'q');
372 static volatile int received_sigterm
= 0;
374 /* no interactive support */
375 static void term_exit(void)
379 static void term_init(void)
383 static int read_key(void)
390 static int read_ffserver_streams(AVFormatContext
*s
, const char *filename
)
395 err
= av_open_input_file(&ic
, filename
, NULL
, FFM_PACKET_SIZE
, NULL
);
398 /* copy stream format */
399 s
->nb_streams
= ic
->nb_streams
;
400 for(i
=0;i
<ic
->nb_streams
;i
++) {
403 // FIXME: a more elegant solution is needed
404 st
= av_mallocz(sizeof(AVStream
));
405 memcpy(st
, ic
->streams
[i
], sizeof(AVStream
));
406 st
->codec
= avcodec_alloc_context();
407 memcpy(st
->codec
, ic
->streams
[i
]->codec
, sizeof(AVCodecContext
));
411 av_close_input_file(ic
);
416 get_sync_ipts(const AVOutputStream
*ost
)
418 const AVInputStream
*ist
= ost
->sync_ist
;
419 return (double)(ist
->pts
+ input_files_ts_offset
[ist
->file_index
] - start_time
)/AV_TIME_BASE
;
422 static void write_frame(AVFormatContext
*s
, AVPacket
*pkt
, AVCodecContext
*avctx
, AVBitStreamFilterContext
*bsfc
){
424 AVPacket new_pkt
= *pkt
;
425 int a
= av_bitstream_filter_filter(bsfc
, avctx
, NULL
,
426 &new_pkt
.data
, &new_pkt
.size
,
427 pkt
->data
, pkt
->size
,
428 pkt
->flags
& PKT_FLAG_KEY
);
431 new_pkt
.destruct
= av_destruct_packet
;
438 av_interleaved_write_frame(s
, pkt
);
441 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
443 static void do_audio_out(AVFormatContext
*s
,
446 unsigned char *buf
, int size
)
449 static uint8_t *audio_buf
= NULL
;
450 static uint8_t *audio_out
= NULL
;
451 const int audio_out_size
= 4*MAX_AUDIO_PACKET_SIZE
;
453 int size_out
, frame_bytes
, ret
;
454 AVCodecContext
*enc
= ost
->st
->codec
;
456 /* SC: dynamic allocation of buffers */
458 audio_buf
= av_malloc(2*MAX_AUDIO_PACKET_SIZE
);
460 audio_out
= av_malloc(audio_out_size
);
461 if (!audio_buf
|| !audio_out
)
462 return; /* Should signal an error ! */
464 if(audio_sync_method
){
465 double delta
= get_sync_ipts(ost
) * enc
->sample_rate
- ost
->sync_opts
466 - av_fifo_size(&ost
->fifo
)/(ost
->st
->codec
->channels
* 2);
467 double idelta
= delta
*ist
->st
->codec
->sample_rate
/ enc
->sample_rate
;
468 int byte_delta
= ((int)idelta
)*2*ist
->st
->codec
->channels
;
470 //FIXME resample delay
471 if(fabs(delta
) > 50){
474 byte_delta
= FFMAX(byte_delta
, -size
);
478 fprintf(stderr
, "discarding %d audio samples\n", (int)-delta
);
483 static uint8_t *input_tmp
= NULL
;
484 input_tmp
= av_realloc(input_tmp
, byte_delta
+ size
);
486 if(byte_delta
+ size
<= MAX_AUDIO_PACKET_SIZE
)
489 byte_delta
= MAX_AUDIO_PACKET_SIZE
- size
;
491 memset(input_tmp
, 0, byte_delta
);
492 memcpy(input_tmp
+ byte_delta
, buf
, size
);
496 fprintf(stderr
, "adding %d audio samples of silence\n", (int)delta
);
498 }else if(audio_sync_method
>1){
499 int comp
= clip(delta
, -audio_sync_method
, audio_sync_method
);
500 assert(ost
->audio_resample
);
502 fprintf(stderr
, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta
, comp
, enc
->sample_rate
);
503 // 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));
504 av_resample_compensate(*(struct AVResampleContext
**)ost
->resample
, comp
, enc
->sample_rate
);
508 ost
->sync_opts
= lrintf(get_sync_ipts(ost
) * enc
->sample_rate
)
509 - av_fifo_size(&ost
->fifo
)/(ost
->st
->codec
->channels
* 2); //FIXME wrong
511 if (ost
->audio_resample
) {
513 size_out
= audio_resample(ost
->resample
,
514 (short *)buftmp
, (short *)buf
,
515 size
/ (ist
->st
->codec
->channels
* 2));
516 size_out
= size_out
* enc
->channels
* 2;
522 /* now encode as many frames as possible */
523 if (enc
->frame_size
> 1) {
524 /* output resampled raw samples */
525 av_fifo_write(&ost
->fifo
, buftmp
, size_out
);
527 frame_bytes
= enc
->frame_size
* 2 * enc
->channels
;
529 while (av_fifo_read(&ost
->fifo
, audio_buf
, frame_bytes
) == 0) {
531 av_init_packet(&pkt
);
533 ret
= avcodec_encode_audio(enc
, audio_out
, audio_out_size
,
536 pkt
.stream_index
= ost
->index
;
539 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
540 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
541 pkt
.flags
|= PKT_FLAG_KEY
;
542 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
544 ost
->sync_opts
+= enc
->frame_size
;
548 av_init_packet(&pkt
);
550 ost
->sync_opts
+= size_out
/ (2 * enc
->channels
);
552 /* output a pcm frame */
553 /* XXX: change encoding codec API to avoid this ? */
554 switch(enc
->codec
->id
) {
555 case CODEC_ID_PCM_S32LE
:
556 case CODEC_ID_PCM_S32BE
:
557 case CODEC_ID_PCM_U32LE
:
558 case CODEC_ID_PCM_U32BE
:
559 size_out
= size_out
<< 1;
561 case CODEC_ID_PCM_S24LE
:
562 case CODEC_ID_PCM_S24BE
:
563 case CODEC_ID_PCM_U24LE
:
564 case CODEC_ID_PCM_U24BE
:
565 case CODEC_ID_PCM_S24DAUD
:
566 size_out
= size_out
/ 2 * 3;
568 case CODEC_ID_PCM_S16LE
:
569 case CODEC_ID_PCM_S16BE
:
570 case CODEC_ID_PCM_U16LE
:
571 case CODEC_ID_PCM_U16BE
:
574 size_out
= size_out
>> 1;
577 ret
= avcodec_encode_audio(enc
, audio_out
, size_out
,
580 pkt
.stream_index
= ost
->index
;
583 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
584 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
585 pkt
.flags
|= PKT_FLAG_KEY
;
586 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
590 static void pre_process_video_frame(AVInputStream
*ist
, AVPicture
*picture
, void **bufp
)
594 AVPicture picture_tmp
;
597 dec
= ist
->st
->codec
;
599 /* deinterlace : must be done before any resize */
600 if (do_deinterlace
|| using_vhook
) {
603 /* create temporary picture */
604 size
= avpicture_get_size(dec
->pix_fmt
, dec
->width
, dec
->height
);
605 buf
= av_malloc(size
);
609 picture2
= &picture_tmp
;
610 avpicture_fill(picture2
, buf
, dec
->pix_fmt
, dec
->width
, dec
->height
);
613 if(avpicture_deinterlace(picture2
, picture
,
614 dec
->pix_fmt
, dec
->width
, dec
->height
) < 0) {
615 /* if error, do not deinterlace */
621 img_copy(picture2
, picture
, dec
->pix_fmt
, dec
->width
, dec
->height
);
627 frame_hook_process(picture2
, dec
->pix_fmt
, dec
->width
, dec
->height
);
629 if (picture
!= picture2
)
630 *picture
= *picture2
;
634 /* we begin to correct av delay at this threshold */
635 #define AV_DELAY_MAX 0.100
637 static void do_subtitle_out(AVFormatContext
*s
,
643 static uint8_t *subtitle_out
= NULL
;
644 int subtitle_out_max_size
= 65536;
645 int subtitle_out_size
, nb
, i
;
649 if (pts
== AV_NOPTS_VALUE
) {
650 fprintf(stderr
, "Subtitle packets must have a pts\n");
654 enc
= ost
->st
->codec
;
657 subtitle_out
= av_malloc(subtitle_out_max_size
);
660 /* Note: DVB subtitle need one packet to draw them and one other
661 packet to clear them */
662 /* XXX: signal it in the codec context ? */
663 if (enc
->codec_id
== CODEC_ID_DVB_SUBTITLE
)
668 for(i
= 0; i
< nb
; i
++) {
669 subtitle_out_size
= avcodec_encode_subtitle(enc
, subtitle_out
,
670 subtitle_out_max_size
, sub
);
672 av_init_packet(&pkt
);
673 pkt
.stream_index
= ost
->index
;
674 pkt
.data
= subtitle_out
;
675 pkt
.size
= subtitle_out_size
;
676 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
);
677 if (enc
->codec_id
== CODEC_ID_DVB_SUBTITLE
) {
678 /* XXX: the pts correction is handled here. Maybe handling
679 it in the codec would be better */
681 pkt
.pts
+= 90 * sub
->start_display_time
;
683 pkt
.pts
+= 90 * sub
->end_display_time
;
685 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
689 static int bit_buffer_size
= 1024*256;
690 static uint8_t *bit_buffer
= NULL
;
692 static void do_video_out(AVFormatContext
*s
,
698 int nb_frames
, i
, ret
;
699 AVFrame
*final_picture
, *formatted_picture
, *resampling_dst
, *padding_src
;
700 AVFrame picture_crop_temp
, picture_pad_temp
;
701 uint8_t *buf
= NULL
, *buf1
= NULL
;
702 AVCodecContext
*enc
, *dec
;
704 avcodec_get_frame_defaults(&picture_crop_temp
);
705 avcodec_get_frame_defaults(&picture_pad_temp
);
707 enc
= ost
->st
->codec
;
708 dec
= ist
->st
->codec
;
710 /* by default, we output a single frame */
715 if(video_sync_method
){
717 vdelta
= get_sync_ipts(ost
) / av_q2d(enc
->time_base
) - ost
->sync_opts
;
718 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
721 else if (vdelta
> 1.1)
722 nb_frames
= lrintf(vdelta
);
723 //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);
727 fprintf(stderr
, "*** drop!\n");
728 }else if (nb_frames
> 1) {
729 nb_frames_dup
+= nb_frames
;
731 fprintf(stderr
, "*** %d dup!\n", nb_frames
-1);
734 ost
->sync_opts
= lrintf(get_sync_ipts(ost
) / av_q2d(enc
->time_base
));
736 nb_frames
= FFMIN(nb_frames
, max_frames
[CODEC_TYPE_VIDEO
] - ost
->frame_number
);
740 if (ost
->video_crop
) {
741 if (img_crop((AVPicture
*)&picture_crop_temp
, (AVPicture
*)in_picture
, dec
->pix_fmt
, ost
->topBand
, ost
->leftBand
) < 0) {
742 av_log(NULL
, AV_LOG_ERROR
, "error cropping picture\n");
745 formatted_picture
= &picture_crop_temp
;
747 formatted_picture
= in_picture
;
750 final_picture
= formatted_picture
;
751 padding_src
= formatted_picture
;
752 resampling_dst
= &ost
->pict_tmp
;
753 if (ost
->video_pad
) {
754 final_picture
= &ost
->pict_tmp
;
755 if (ost
->video_resample
) {
756 if (img_crop((AVPicture
*)&picture_pad_temp
, (AVPicture
*)final_picture
, enc
->pix_fmt
, ost
->padtop
, ost
->padleft
) < 0) {
757 av_log(NULL
, AV_LOG_ERROR
, "error padding picture\n");
760 resampling_dst
= &picture_pad_temp
;
764 if (ost
->video_resample
) {
766 final_picture
= &ost
->pict_tmp
;
767 sws_scale(ost
->img_resample_ctx
, formatted_picture
->data
, formatted_picture
->linesize
,
768 0, ost
->resample_height
, resampling_dst
->data
, resampling_dst
->linesize
);
771 if (ost
->video_pad
) {
772 img_pad((AVPicture
*)final_picture
, (AVPicture
*)padding_src
,
773 enc
->height
, enc
->width
, enc
->pix_fmt
,
774 ost
->padtop
, ost
->padbottom
, ost
->padleft
, ost
->padright
, padcolor
);
777 /* duplicates frame if needed */
778 for(i
=0;i
<nb_frames
;i
++) {
780 av_init_packet(&pkt
);
781 pkt
.stream_index
= ost
->index
;
783 if (s
->oformat
->flags
& AVFMT_RAWPICTURE
) {
784 /* raw pictures are written as AVPicture structure to
785 avoid any copies. We support temorarily the older
787 AVFrame
* old_frame
= enc
->coded_frame
;
788 enc
->coded_frame
= dec
->coded_frame
; //FIXME/XXX remove this hack
789 pkt
.data
= (uint8_t *)final_picture
;
790 pkt
.size
= sizeof(AVPicture
);
791 if(dec
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
792 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
793 if(dec
->coded_frame
&& dec
->coded_frame
->key_frame
)
794 pkt
.flags
|= PKT_FLAG_KEY
;
796 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
797 enc
->coded_frame
= old_frame
;
801 big_picture
= *final_picture
;
802 /* better than nothing: use input picture interlaced
804 big_picture
.interlaced_frame
= in_picture
->interlaced_frame
;
805 if(avctx_opts
->flags
& (CODEC_FLAG_INTERLACED_DCT
|CODEC_FLAG_INTERLACED_ME
)){
806 if(top_field_first
== -1)
807 big_picture
.top_field_first
= in_picture
->top_field_first
;
809 big_picture
.top_field_first
= top_field_first
;
812 /* handles sameq here. This is not correct because it may
813 not be a global option */
815 big_picture
.quality
= ist
->st
->quality
;
817 big_picture
.quality
= ost
->st
->quality
;
819 big_picture
.pict_type
= 0;
820 // big_picture.pts = AV_NOPTS_VALUE;
821 big_picture
.pts
= ost
->sync_opts
;
822 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
823 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
824 ret
= avcodec_encode_video(enc
,
825 bit_buffer
, bit_buffer_size
,
828 fprintf(stderr
, "Video encoding failed\n");
831 //enc->frame_number = enc->real_pict_num;
833 pkt
.data
= bit_buffer
;
835 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
836 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
837 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
838 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
839 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
841 if(enc
->coded_frame
&& enc
->coded_frame
->key_frame
)
842 pkt
.flags
|= PKT_FLAG_KEY
;
843 write_frame(s
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
845 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
846 // enc->frame_number-1, enc->real_pict_num, ret,
848 /* if two pass, output log */
849 if (ost
->logfile
&& enc
->stats_out
) {
850 fprintf(ost
->logfile
, "%s", enc
->stats_out
);
862 static double psnr(double d
){
863 if(d
==0) return INFINITY
;
864 return -10.0*log(d
)/log(10.0);
867 static void do_video_stats(AVFormatContext
*os
, AVOutputStream
*ost
,
870 static FILE *fvstats
=NULL
;
877 double ti1
, bitrate
, avg_bitrate
;
881 today
= localtime(&today2
);
882 snprintf(filename
, sizeof(filename
), "vstats_%02d%02d%02d.log", today
->tm_hour
,
885 fvstats
= fopen(filename
,"w");
893 enc
= ost
->st
->codec
;
894 if (enc
->codec_type
== CODEC_TYPE_VIDEO
) {
895 frame_number
= ost
->frame_number
;
896 fprintf(fvstats
, "frame= %5d q= %2.1f ", frame_number
, enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
);
897 if (enc
->flags
&CODEC_FLAG_PSNR
)
898 fprintf(fvstats
, "PSNR= %6.2f ", psnr(enc
->coded_frame
->error
[0]/(enc
->width
*enc
->height
*255.0*255.0)));
900 fprintf(fvstats
,"f_size= %6d ", frame_size
);
901 /* compute pts value */
902 ti1
= ost
->sync_opts
* av_q2d(enc
->time_base
);
906 bitrate
= (frame_size
* 8) / av_q2d(enc
->time_base
) / 1000.0;
907 avg_bitrate
= (double)(video_size
* 8) / ti1
/ 1000.0;
908 fprintf(fvstats
, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
909 (double)video_size
/ 1024, ti1
, bitrate
, avg_bitrate
);
910 fprintf(fvstats
,"type= %c\n", av_get_pict_type_char(enc
->coded_frame
->pict_type
));
914 static void print_report(AVFormatContext
**output_files
,
915 AVOutputStream
**ost_table
, int nb_ostreams
,
920 AVFormatContext
*oc
, *os
;
923 int frame_number
, vid
, i
;
924 double bitrate
, ti1
, pts
;
925 static int64_t last_time
= -1;
926 static int qp_histogram
[52];
928 if (!is_last_report
) {
930 /* display the report every 0.5 seconds */
931 cur_time
= av_gettime();
932 if (last_time
== -1) {
933 last_time
= cur_time
;
936 if ((cur_time
- last_time
) < 500000)
938 last_time
= cur_time
;
942 oc
= output_files
[0];
944 total_size
= url_ftell(&oc
->pb
);
949 for(i
=0;i
<nb_ostreams
;i
++) {
951 os
= output_files
[ost
->file_index
];
952 enc
= ost
->st
->codec
;
953 if (vid
&& enc
->codec_type
== CODEC_TYPE_VIDEO
) {
954 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "q=%2.1f ",
955 enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
);
957 if (!vid
&& enc
->codec_type
== CODEC_TYPE_VIDEO
) {
958 frame_number
= ost
->frame_number
;
959 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "frame=%5d q=%3.1f ",
960 frame_number
, enc
->coded_frame ? enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
: -1);
962 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "L");
963 if(qp_hist
&& enc
->coded_frame
){
965 int qp
= lrintf(enc
->coded_frame
->quality
/(float)FF_QP2LAMBDA
);
966 if(qp
>=0 && qp
<sizeof(qp_histogram
)/sizeof(int))
969 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "%X", (int)lrintf(log(qp_histogram
[j
]+1)/log(2)));
971 if (enc
->flags
&CODEC_FLAG_PSNR
){
973 double error
, error_sum
=0;
974 double scale
, scale_sum
=0;
975 char type
[3]= {'Y','U','V'};
976 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "PSNR=");
979 error
= enc
->error
[j
];
980 scale
= enc
->width
*enc
->height
*255.0*255.0*frame_number
;
982 error
= enc
->coded_frame
->error
[j
];
983 scale
= enc
->width
*enc
->height
*255.0*255.0;
988 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "%c:%2.2f ", type
[j
], psnr(error
/scale
));
990 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "*:%2.2f ", psnr(error_sum
/scale_sum
));
994 /* compute min output value */
995 pts
= (double)ost
->st
->pts
.val
* ost
->st
->time_base
.num
/ ost
->st
->time_base
.den
;
996 if ((pts
< ti1
) && (pts
> 0))
1002 if (verbose
|| is_last_report
) {
1003 bitrate
= (double)(total_size
* 8) / ti1
/ 1000.0;
1005 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
1006 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1007 (double)total_size
/ 1024, ti1
, bitrate
);
1010 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), " dup=%d drop=%d",
1011 nb_frames_dup
, nb_frames_drop
);
1014 fprintf(stderr
, "%s \r", buf
);
1019 if (is_last_report
&& verbose
>= 0){
1020 int64_t raw
= audio_size
+ video_size
+ extra_size
;
1021 fprintf(stderr
, "\n");
1022 fprintf(stderr
, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1026 100.0*(total_size
- raw
)/raw
1031 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1032 static int output_packet(AVInputStream
*ist
, int ist_index
,
1033 AVOutputStream
**ost_table
, int nb_ostreams
,
1034 const AVPacket
*pkt
)
1036 AVFormatContext
*os
;
1037 AVOutputStream
*ost
;
1041 int data_size
, got_picture
;
1043 void *buffer_to_free
;
1044 static unsigned int samples_size
= 0;
1045 static short *samples
= NULL
;
1046 AVSubtitle subtitle
, *subtitle_to_free
;
1050 ist
->pts
= ist
->next_pts
; // needed for last packet if vsync=0
1051 } else if (pkt
->dts
!= AV_NOPTS_VALUE
) { //FIXME seems redundant, as libavformat does this too
1052 ist
->next_pts
= ist
->pts
= av_rescale_q(pkt
->dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
1054 // assert(ist->pts == ist->next_pts);
1068 /* decode the packet if needed */
1069 data_buf
= NULL
; /* fail safe */
1071 subtitle_to_free
= NULL
;
1072 if (ist
->decoding_needed
) {
1073 switch(ist
->st
->codec
->codec_type
) {
1074 case CODEC_TYPE_AUDIO
:{
1076 samples
= av_fast_realloc(samples
, &samples_size
, FFMAX(pkt
->size
, AVCODEC_MAX_AUDIO_FRAME_SIZE
));
1077 /* XXX: could avoid copy if PCM 16 bits with same
1078 endianness as CPU */
1079 ret
= avcodec_decode_audio(ist
->st
->codec
, samples
, &data_size
,
1085 /* Some bug in mpeg audio decoder gives */
1086 /* data_size < 0, it seems they are overflows */
1087 if (data_size
<= 0) {
1088 /* no audio frame */
1091 data_buf
= (uint8_t *)samples
;
1092 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
/2 * data_size
) /
1093 (ist
->st
->codec
->sample_rate
* ist
->st
->codec
->channels
);
1095 case CODEC_TYPE_VIDEO
:
1096 data_size
= (ist
->st
->codec
->width
* ist
->st
->codec
->height
* 3) / 2;
1097 /* XXX: allocate picture correctly */
1098 avcodec_get_frame_defaults(&picture
);
1100 ret
= avcodec_decode_video(ist
->st
->codec
,
1101 &picture
, &got_picture
, ptr
, len
);
1102 ist
->st
->quality
= picture
.quality
;
1106 /* no picture yet */
1107 goto discard_packet
;
1109 if (ist
->st
->codec
->time_base
.num
!= 0) {
1110 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
*
1111 ist
->st
->codec
->time_base
.num
) /
1112 ist
->st
->codec
->time_base
.den
;
1116 case CODEC_TYPE_SUBTITLE
:
1117 ret
= avcodec_decode_subtitle(ist
->st
->codec
,
1118 &subtitle
, &got_subtitle
, ptr
, len
);
1121 if (!got_subtitle
) {
1122 goto discard_packet
;
1124 subtitle_to_free
= &subtitle
;
1131 switch(ist
->st
->codec
->codec_type
) {
1132 case CODEC_TYPE_AUDIO
:
1133 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
* ist
->st
->codec
->frame_size
) /
1134 (ist
->st
->codec
->sample_rate
* ist
->st
->codec
->channels
);
1136 case CODEC_TYPE_VIDEO
:
1137 if (ist
->st
->codec
->time_base
.num
!= 0) {
1138 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
*
1139 ist
->st
->codec
->time_base
.num
) /
1140 ist
->st
->codec
->time_base
.den
;
1150 buffer_to_free
= NULL
;
1151 if (ist
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
1152 pre_process_video_frame(ist
, (AVPicture
*)&picture
,
1156 // preprocess audio (volume)
1157 if (ist
->st
->codec
->codec_type
== CODEC_TYPE_AUDIO
) {
1158 if (audio_volume
!= 256) {
1161 for(i
=0;i
<(data_size
/ sizeof(short));i
++) {
1162 int v
= ((*volp
) * audio_volume
+ 128) >> 8;
1163 if (v
< -32768) v
= -32768;
1164 if (v
> 32767) v
= 32767;
1170 /* frame rate emulation */
1171 if (ist
->st
->codec
->rate_emu
) {
1172 int64_t pts
= av_rescale((int64_t) ist
->frame
* ist
->st
->codec
->time_base
.num
, 1000000, ist
->st
->codec
->time_base
.den
);
1173 int64_t now
= av_gettime() - ist
->start
;
1181 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1182 is the one of the next displayed one */
1183 /* XXX: add mpeg4 too ? */
1184 if (ist
->st
->codec
->codec_id
== CODEC_ID_MPEG1VIDEO
) {
1185 if (ist
->st
->codec
->pict_type
!= B_TYPE
) {
1187 tmp
= ist
->last_ip_pts
;
1188 ist
->last_ip_pts
= ist
->frac_pts
.val
;
1189 ist
->frac_pts
.val
= tmp
;
1193 /* if output time reached then transcode raw format,
1194 encode packets and output them */
1195 if (start_time
== 0 || ist
->pts
>= start_time
)
1196 for(i
=0;i
<nb_ostreams
;i
++) {
1200 if (ost
->source_index
== ist_index
) {
1201 os
= output_files
[ost
->file_index
];
1204 printf("%d: got pts=%0.3f %0.3f\n", i
,
1205 (double)pkt
->pts
/ AV_TIME_BASE
,
1206 ((double)ist
->pts
/ AV_TIME_BASE
) -
1207 ((double)ost
->st
->pts
.val
* ost
->st
->time_base
.num
/ ost
->st
->time_base
.den
));
1209 /* set the input output pts pairs */
1210 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1212 if (ost
->encoding_needed
) {
1213 switch(ost
->st
->codec
->codec_type
) {
1214 case CODEC_TYPE_AUDIO
:
1215 do_audio_out(os
, ost
, ist
, data_buf
, data_size
);
1217 case CODEC_TYPE_VIDEO
:
1218 do_video_out(os
, ost
, ist
, &picture
, &frame_size
);
1219 video_size
+= frame_size
;
1220 if (do_vstats
&& frame_size
)
1221 do_video_stats(os
, ost
, frame_size
);
1223 case CODEC_TYPE_SUBTITLE
:
1224 do_subtitle_out(os
, ost
, ist
, &subtitle
,
1231 AVFrame avframe
; //FIXME/XXX remove this
1233 av_init_packet(&opkt
);
1235 /* no reencoding needed : output the packet directly */
1236 /* force the input stream PTS */
1238 avcodec_get_frame_defaults(&avframe
);
1239 ost
->st
->codec
->coded_frame
= &avframe
;
1240 avframe
.key_frame
= pkt
->flags
& PKT_FLAG_KEY
;
1242 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_AUDIO
)
1243 audio_size
+= data_size
;
1244 else if (ost
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
1245 video_size
+= data_size
;
1249 opkt
.stream_index
= ost
->index
;
1250 if(pkt
->pts
!= AV_NOPTS_VALUE
)
1251 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
);
1253 opkt
.pts
= AV_NOPTS_VALUE
;
1257 if (pkt
->dts
== AV_NOPTS_VALUE
)
1258 dts
= ist
->next_pts
;
1260 dts
= av_rescale_q(pkt
->dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
1261 opkt
.dts
= av_rescale_q(dts
+ input_files_ts_offset
[ist
->file_index
], AV_TIME_BASE_Q
, ost
->st
->time_base
);
1263 opkt
.flags
= pkt
->flags
;
1265 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1266 if(av_parser_change(ist
->st
->parser
, ost
->st
->codec
, &opkt
.data
, &opkt
.size
, data_buf
, data_size
, pkt
->flags
& PKT_FLAG_KEY
))
1267 opkt
.destruct
= av_destruct_packet
;
1269 write_frame(os
, &opkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
->stream_index
]);
1270 ost
->st
->codec
->frame_number
++;
1271 ost
->frame_number
++;
1272 av_free_packet(&opkt
);
1276 av_free(buffer_to_free
);
1277 /* XXX: allocate the subtitles in the codec ? */
1278 if (subtitle_to_free
) {
1279 if (subtitle_to_free
->rects
!= NULL
) {
1280 for (i
= 0; i
< subtitle_to_free
->num_rects
; i
++) {
1281 av_free(subtitle_to_free
->rects
[i
].bitmap
);
1282 av_free(subtitle_to_free
->rects
[i
].rgba_palette
);
1284 av_freep(&subtitle_to_free
->rects
);
1286 subtitle_to_free
->num_rects
= 0;
1287 subtitle_to_free
= NULL
;
1294 for(i
=0;i
<nb_ostreams
;i
++) {
1296 if (ost
->source_index
== ist_index
) {
1297 AVCodecContext
*enc
= ost
->st
->codec
;
1298 os
= output_files
[ost
->file_index
];
1300 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_AUDIO
&& enc
->frame_size
<=1)
1302 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
&& (os
->oformat
->flags
& AVFMT_RAWPICTURE
))
1305 if (ost
->encoding_needed
) {
1309 av_init_packet(&pkt
);
1310 pkt
.stream_index
= ost
->index
;
1312 switch(ost
->st
->codec
->codec_type
) {
1313 case CODEC_TYPE_AUDIO
:
1314 fifo_bytes
= av_fifo_size(&ost
->fifo
);
1316 /* encode any samples remaining in fifo */
1317 if(fifo_bytes
> 0 && enc
->codec
->capabilities
& CODEC_CAP_SMALL_LAST_FRAME
) {
1318 int fs_tmp
= enc
->frame_size
;
1319 enc
->frame_size
= fifo_bytes
/ (2 * enc
->channels
);
1320 if(av_fifo_read(&ost
->fifo
, (uint8_t *)samples
, fifo_bytes
) == 0) {
1321 ret
= avcodec_encode_audio(enc
, bit_buffer
, bit_buffer_size
, samples
);
1323 enc
->frame_size
= fs_tmp
;
1326 ret
= avcodec_encode_audio(enc
, bit_buffer
, bit_buffer_size
, NULL
);
1329 pkt
.flags
|= PKT_FLAG_KEY
;
1331 case CODEC_TYPE_VIDEO
:
1332 ret
= avcodec_encode_video(enc
, bit_buffer
, bit_buffer_size
, NULL
);
1334 if(enc
->coded_frame
&& enc
->coded_frame
->key_frame
)
1335 pkt
.flags
|= PKT_FLAG_KEY
;
1336 if (ost
->logfile
&& enc
->stats_out
) {
1337 fprintf(ost
->logfile
, "%s", enc
->stats_out
);
1346 pkt
.data
= bit_buffer
;
1348 if(enc
->coded_frame
&& enc
->coded_frame
->pts
!= AV_NOPTS_VALUE
)
1349 pkt
.pts
= av_rescale_q(enc
->coded_frame
->pts
, enc
->time_base
, ost
->st
->time_base
);
1350 write_frame(os
, &pkt
, ost
->st
->codec
, bitstream_filters
[ost
->file_index
][pkt
.stream_index
]);
1364 * The following code is the main loop of the file converter
1366 static int av_encode(AVFormatContext
**output_files
,
1367 int nb_output_files
,
1368 AVFormatContext
**input_files
,
1370 AVStreamMap
*stream_maps
, int nb_stream_maps
)
1372 int ret
, i
, j
, k
, n
, nb_istreams
= 0, nb_ostreams
= 0;
1373 AVFormatContext
*is
, *os
;
1374 AVCodecContext
*codec
, *icodec
;
1375 AVOutputStream
*ost
, **ost_table
= NULL
;
1376 AVInputStream
*ist
, **ist_table
= NULL
;
1377 AVInputFile
*file_table
;
1378 AVFormatContext
*stream_no_data
;
1381 file_table
= (AVInputFile
*) av_mallocz(nb_input_files
* sizeof(AVInputFile
));
1385 /* input stream init */
1387 for(i
=0;i
<nb_input_files
;i
++) {
1388 is
= input_files
[i
];
1389 file_table
[i
].ist_index
= j
;
1390 file_table
[i
].nb_streams
= is
->nb_streams
;
1391 j
+= is
->nb_streams
;
1395 ist_table
= av_mallocz(nb_istreams
* sizeof(AVInputStream
*));
1399 for(i
=0;i
<nb_istreams
;i
++) {
1400 ist
= av_mallocz(sizeof(AVInputStream
));
1406 for(i
=0;i
<nb_input_files
;i
++) {
1407 is
= input_files
[i
];
1408 for(k
=0;k
<is
->nb_streams
;k
++) {
1409 ist
= ist_table
[j
++];
1410 ist
->st
= is
->streams
[k
];
1411 ist
->file_index
= i
;
1413 ist
->discard
= 1; /* the stream is discarded by default
1416 if (ist
->st
->codec
->rate_emu
) {
1417 ist
->start
= av_gettime();
1423 /* output stream init */
1425 for(i
=0;i
<nb_output_files
;i
++) {
1426 os
= output_files
[i
];
1427 if (!os
->nb_streams
) {
1428 fprintf(stderr
, "Output file does not contain any stream\n");
1431 nb_ostreams
+= os
->nb_streams
;
1433 if (nb_stream_maps
> 0 && nb_stream_maps
!= nb_ostreams
) {
1434 fprintf(stderr
, "Number of stream maps must match number of output streams\n");
1438 /* Sanity check the mapping args -- do the input files & streams exist? */
1439 for(i
=0;i
<nb_stream_maps
;i
++) {
1440 int fi
= stream_maps
[i
].file_index
;
1441 int si
= stream_maps
[i
].stream_index
;
1443 if (fi
< 0 || fi
> nb_input_files
- 1 ||
1444 si
< 0 || si
> file_table
[fi
].nb_streams
- 1) {
1445 fprintf(stderr
,"Could not find input stream #%d.%d\n", fi
, si
);
1448 fi
= stream_maps
[i
].sync_file_index
;
1449 si
= stream_maps
[i
].sync_stream_index
;
1450 if (fi
< 0 || fi
> nb_input_files
- 1 ||
1451 si
< 0 || si
> file_table
[fi
].nb_streams
- 1) {
1452 fprintf(stderr
,"Could not find sync stream #%d.%d\n", fi
, si
);
1457 ost_table
= av_mallocz(sizeof(AVOutputStream
*) * nb_ostreams
);
1460 for(i
=0;i
<nb_ostreams
;i
++) {
1461 ost
= av_mallocz(sizeof(AVOutputStream
));
1468 for(k
=0;k
<nb_output_files
;k
++) {
1469 os
= output_files
[k
];
1470 for(i
=0;i
<os
->nb_streams
;i
++) {
1472 ost
= ost_table
[n
++];
1473 ost
->file_index
= k
;
1475 ost
->st
= os
->streams
[i
];
1476 if (nb_stream_maps
> 0) {
1477 ost
->source_index
= file_table
[stream_maps
[n
-1].file_index
].ist_index
+
1478 stream_maps
[n
-1].stream_index
;
1480 /* Sanity check that the stream types match */
1481 if (ist_table
[ost
->source_index
]->st
->codec
->codec_type
!= ost
->st
->codec
->codec_type
) {
1482 fprintf(stderr
, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1483 stream_maps
[n
-1].file_index
, stream_maps
[n
-1].stream_index
,
1484 ost
->file_index
, ost
->index
);
1489 /* get corresponding input stream index : we select the first one with the right type */
1491 for(j
=0;j
<nb_istreams
;j
++) {
1494 ist
->st
->codec
->codec_type
== ost
->st
->codec
->codec_type
) {
1495 ost
->source_index
= j
;
1502 /* try again and reuse existing stream */
1503 for(j
=0;j
<nb_istreams
;j
++) {
1505 if (ist
->st
->codec
->codec_type
== ost
->st
->codec
->codec_type
) {
1506 ost
->source_index
= j
;
1511 fprintf(stderr
, "Could not find input stream matching output stream #%d.%d\n",
1512 ost
->file_index
, ost
->index
);
1517 ist
= ist_table
[ost
->source_index
];
1519 ost
->sync_ist
= (nb_stream_maps
> 0) ?
1520 ist_table
[file_table
[stream_maps
[n
-1].sync_file_index
].ist_index
+
1521 stream_maps
[n
-1].sync_stream_index
] : ist
;
1525 /* for each output stream, we compute the right encoding parameters */
1526 for(i
=0;i
<nb_ostreams
;i
++) {
1528 ist
= ist_table
[ost
->source_index
];
1530 codec
= ost
->st
->codec
;
1531 icodec
= ist
->st
->codec
;
1533 if (ost
->st
->stream_copy
) {
1534 /* if stream_copy is selected, no need to decode or encode */
1535 codec
->codec_id
= icodec
->codec_id
;
1536 codec
->codec_type
= icodec
->codec_type
;
1537 if(!codec
->codec_tag
) codec
->codec_tag
= icodec
->codec_tag
;
1538 codec
->bit_rate
= icodec
->bit_rate
;
1539 codec
->extradata
= icodec
->extradata
;
1540 codec
->extradata_size
= icodec
->extradata_size
;
1541 if(av_q2d(icodec
->time_base
) > av_q2d(ist
->st
->time_base
) && av_q2d(ist
->st
->time_base
) < 1.0/1000)
1542 codec
->time_base
= icodec
->time_base
;
1544 codec
->time_base
= ist
->st
->time_base
;
1545 switch(codec
->codec_type
) {
1546 case CODEC_TYPE_AUDIO
:
1547 codec
->sample_rate
= icodec
->sample_rate
;
1548 codec
->channels
= icodec
->channels
;
1549 codec
->frame_size
= icodec
->frame_size
;
1550 codec
->block_align
= icodec
->block_align
;
1552 case CODEC_TYPE_VIDEO
:
1553 codec
->pix_fmt
= icodec
->pix_fmt
;
1554 codec
->width
= icodec
->width
;
1555 codec
->height
= icodec
->height
;
1556 codec
->has_b_frames
= icodec
->has_b_frames
;
1558 case CODEC_TYPE_SUBTITLE
:
1564 switch(codec
->codec_type
) {
1565 case CODEC_TYPE_AUDIO
:
1566 if (av_fifo_init(&ost
->fifo
, 2 * MAX_AUDIO_PACKET_SIZE
))
1569 if (codec
->channels
== icodec
->channels
&&
1570 codec
->sample_rate
== icodec
->sample_rate
) {
1571 ost
->audio_resample
= 0;
1573 if (codec
->channels
!= icodec
->channels
&&
1574 (icodec
->codec_id
== CODEC_ID_AC3
||
1575 icodec
->codec_id
== CODEC_ID_DTS
)) {
1576 /* Special case for 5:1 AC3 and DTS input */
1577 /* and mono or stereo output */
1578 /* Request specific number of channels */
1579 icodec
->channels
= codec
->channels
;
1580 if (codec
->sample_rate
== icodec
->sample_rate
)
1581 ost
->audio_resample
= 0;
1583 ost
->audio_resample
= 1;
1586 ost
->audio_resample
= 1;
1589 if(audio_sync_method
>1)
1590 ost
->audio_resample
= 1;
1592 if(ost
->audio_resample
){
1593 ost
->resample
= audio_resample_init(codec
->channels
, icodec
->channels
,
1594 codec
->sample_rate
, icodec
->sample_rate
);
1596 printf("Can't resample. Aborting.\n");
1600 ist
->decoding_needed
= 1;
1601 ost
->encoding_needed
= 1;
1603 case CODEC_TYPE_VIDEO
:
1604 ost
->video_crop
= ((frame_leftBand
+ frame_rightBand
+ frame_topBand
+ frame_bottomBand
) != 0);
1605 ost
->video_pad
= ((frame_padleft
+ frame_padright
+ frame_padtop
+ frame_padbottom
) != 0);
1606 ost
->video_resample
= ((codec
->width
!= icodec
->width
-
1607 (frame_leftBand
+ frame_rightBand
) +
1608 (frame_padleft
+ frame_padright
)) ||
1609 (codec
->height
!= icodec
->height
-
1610 (frame_topBand
+ frame_bottomBand
) +
1611 (frame_padtop
+ frame_padbottom
)) ||
1612 (codec
->pix_fmt
!= icodec
->pix_fmt
));
1613 if (ost
->video_crop
) {
1614 ost
->topBand
= frame_topBand
;
1615 ost
->leftBand
= frame_leftBand
;
1617 if (ost
->video_pad
) {
1618 ost
->padtop
= frame_padtop
;
1619 ost
->padleft
= frame_padleft
;
1620 ost
->padbottom
= frame_padbottom
;
1621 ost
->padright
= frame_padright
;
1622 if (!ost
->video_resample
) {
1623 avcodec_get_frame_defaults(&ost
->pict_tmp
);
1624 if( avpicture_alloc( (AVPicture
*)&ost
->pict_tmp
, codec
->pix_fmt
,
1625 codec
->width
, codec
->height
) )
1629 if (ost
->video_resample
) {
1630 avcodec_get_frame_defaults(&ost
->pict_tmp
);
1631 if( avpicture_alloc( (AVPicture
*)&ost
->pict_tmp
, codec
->pix_fmt
,
1632 codec
->width
, codec
->height
) )
1635 ost
->img_resample_ctx
= sws_getContext(
1636 icodec
->width
- (frame_leftBand
+ frame_rightBand
),
1637 icodec
->height
- (frame_topBand
+ frame_bottomBand
),
1639 codec
->width
- (frame_padleft
+ frame_padright
),
1640 codec
->height
- (frame_padtop
+ frame_padbottom
),
1642 sws_flags
, NULL
, NULL
, NULL
);
1643 if (ost
->img_resample_ctx
== NULL
) {
1644 fprintf(stderr
, "Cannot get resampling context\n");
1647 ost
->resample_height
= icodec
->height
- (frame_topBand
+ frame_bottomBand
);
1649 ost
->encoding_needed
= 1;
1650 ist
->decoding_needed
= 1;
1652 case CODEC_TYPE_SUBTITLE
:
1653 ost
->encoding_needed
= 1;
1654 ist
->decoding_needed
= 1;
1661 if (ost
->encoding_needed
&&
1662 (codec
->flags
& (CODEC_FLAG_PASS1
| CODEC_FLAG_PASS2
))) {
1663 char logfilename
[1024];
1668 snprintf(logfilename
, sizeof(logfilename
), "%s-%d.log",
1670 pass_logfilename
: DEFAULT_PASS_LOGFILENAME
, i
);
1671 if (codec
->flags
& CODEC_FLAG_PASS1
) {
1672 f
= fopen(logfilename
, "w");
1674 perror(logfilename
);
1679 /* read the log file */
1680 f
= fopen(logfilename
, "r");
1682 perror(logfilename
);
1685 fseek(f
, 0, SEEK_END
);
1687 fseek(f
, 0, SEEK_SET
);
1688 logbuffer
= av_malloc(size
+ 1);
1690 fprintf(stderr
, "Could not allocate log buffer\n");
1693 size
= fread(logbuffer
, 1, size
, f
);
1695 logbuffer
[size
] = '\0';
1696 codec
->stats_in
= logbuffer
;
1700 if(codec
->codec_type
== CODEC_TYPE_VIDEO
){
1701 int size
= codec
->width
* codec
->height
;
1702 bit_buffer_size
= FFMAX(bit_buffer_size
, 4*size
);
1707 bit_buffer
= av_malloc(bit_buffer_size
);
1711 /* dump the file output parameters - cannot be done before in case
1713 for(i
=0;i
<nb_output_files
;i
++) {
1714 dump_format(output_files
[i
], i
, output_files
[i
]->filename
, 1);
1717 /* dump the stream mapping */
1719 fprintf(stderr
, "Stream mapping:\n");
1720 for(i
=0;i
<nb_ostreams
;i
++) {
1722 fprintf(stderr
, " Stream #%d.%d -> #%d.%d",
1723 ist_table
[ost
->source_index
]->file_index
,
1724 ist_table
[ost
->source_index
]->index
,
1727 if (ost
->sync_ist
!= ist_table
[ost
->source_index
])
1728 fprintf(stderr
, " [sync #%d.%d]",
1729 ost
->sync_ist
->file_index
,
1730 ost
->sync_ist
->index
);
1731 fprintf(stderr
, "\n");
1735 /* open each encoder */
1736 for(i
=0;i
<nb_ostreams
;i
++) {
1738 if (ost
->encoding_needed
) {
1740 codec
= avcodec_find_encoder(ost
->st
->codec
->codec_id
);
1742 fprintf(stderr
, "Unsupported codec for output stream #%d.%d\n",
1743 ost
->file_index
, ost
->index
);
1746 if (avcodec_open(ost
->st
->codec
, codec
) < 0) {
1747 fprintf(stderr
, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1748 ost
->file_index
, ost
->index
);
1751 extra_size
+= ost
->st
->codec
->extradata_size
;
1755 /* open each decoder */
1756 for(i
=0;i
<nb_istreams
;i
++) {
1758 if (ist
->decoding_needed
) {
1760 codec
= avcodec_find_decoder(ist
->st
->codec
->codec_id
);
1762 fprintf(stderr
, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1763 ist
->st
->codec
->codec_id
, ist
->file_index
, ist
->index
);
1766 if (avcodec_open(ist
->st
->codec
, codec
) < 0) {
1767 fprintf(stderr
, "Error while opening codec for input stream #%d.%d\n",
1768 ist
->file_index
, ist
->index
);
1771 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1772 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1777 for(i
=0;i
<nb_istreams
;i
++) {
1779 is
= input_files
[ist
->file_index
];
1781 ist
->next_pts
= av_rescale_q(ist
->st
->start_time
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
1782 if(ist
->st
->start_time
== AV_NOPTS_VALUE
)
1784 if(input_files_ts_offset
[ist
->file_index
])
1785 ist
->next_pts
= AV_NOPTS_VALUE
;
1789 /* compute buffer size max (should use a complete heuristic) */
1790 for(i
=0;i
<nb_input_files
;i
++) {
1791 file_table
[i
].buffer_size_max
= 2048;
1794 /* set meta data information from input file if required */
1795 for (i
=0;i
<nb_meta_data_maps
;i
++) {
1796 AVFormatContext
*out_file
;
1797 AVFormatContext
*in_file
;
1799 int out_file_index
= meta_data_maps
[i
].out_file
;
1800 int in_file_index
= meta_data_maps
[i
].in_file
;
1801 if ( out_file_index
< 0 || out_file_index
>= nb_output_files
) {
1802 fprintf(stderr
, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index
, out_file_index
, in_file_index
);
1806 if ( in_file_index
< 0 || in_file_index
>= nb_input_files
) {
1807 fprintf(stderr
, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index
, out_file_index
, in_file_index
);
1812 out_file
= output_files
[out_file_index
];
1813 in_file
= input_files
[in_file_index
];
1815 strcpy(out_file
->title
, in_file
->title
);
1816 strcpy(out_file
->author
, in_file
->author
);
1817 strcpy(out_file
->copyright
, in_file
->copyright
);
1818 strcpy(out_file
->comment
, in_file
->comment
);
1819 strcpy(out_file
->album
, in_file
->album
);
1820 out_file
->year
= in_file
->year
;
1821 out_file
->track
= in_file
->track
;
1822 strcpy(out_file
->genre
, in_file
->genre
);
1825 /* open files and write file headers */
1826 for(i
=0;i
<nb_output_files
;i
++) {
1827 os
= output_files
[i
];
1828 if (av_write_header(os
) < 0) {
1829 fprintf(stderr
, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i
);
1836 if ( !using_stdin
&& verbose
>= 0) {
1837 fprintf(stderr
, "Press [q] to stop encoding\n");
1838 url_set_interrupt_cb(decode_interrupt_cb
);
1846 for(; received_sigterm
== 0;) {
1847 int file_index
, ist_index
;
1855 /* if 'q' pressed, exits */
1859 /* read_key() returns 0 on EOF */
1865 /* select the stream that we must read now by looking at the
1866 smallest output pts */
1868 for(i
=0;i
<nb_ostreams
;i
++) {
1871 os
= output_files
[ost
->file_index
];
1872 ist
= ist_table
[ost
->source_index
];
1873 if(ost
->st
->codec
->codec_type
== CODEC_TYPE_VIDEO
)
1874 opts
= ost
->sync_opts
* av_q2d(ost
->st
->codec
->time_base
);
1876 opts
= ost
->st
->pts
.val
* av_q2d(ost
->st
->time_base
);
1877 ipts
= (double)ist
->pts
;
1878 if (!file_table
[ist
->file_index
].eof_reached
){
1879 if(ipts
< ipts_min
) {
1881 if(input_sync
) file_index
= ist
->file_index
;
1883 if(opts
< opts_min
) {
1885 if(!input_sync
) file_index
= ist
->file_index
;
1888 if(ost
->frame_number
>= max_frames
[ost
->st
->codec
->codec_type
]){
1893 /* if none, if is finished */
1894 if (file_index
< 0) {
1898 /* finish if recording time exhausted */
1899 if (recording_time
> 0 && opts_min
>= (recording_time
/ 1000000.0))
1902 /* finish if limit size exhausted */
1903 if (limit_filesize
!= 0 && (limit_filesize
* 1024) < url_ftell(&output_files
[0]->pb
))
1906 /* read a frame from it and output it in the fifo */
1907 is
= input_files
[file_index
];
1908 if (av_read_frame(is
, &pkt
) < 0) {
1909 file_table
[file_index
].eof_reached
= 1;
1910 if (opt_shortest
) break; else continue; //
1914 stream_no_data
= is
;
1919 av_pkt_dump(stdout
, &pkt
, do_hex_dump
);
1921 /* the following test is needed in case new streams appear
1922 dynamically in stream : we ignore them */
1923 if (pkt
.stream_index
>= file_table
[file_index
].nb_streams
)
1924 goto discard_packet
;
1925 ist_index
= file_table
[file_index
].ist_index
+ pkt
.stream_index
;
1926 ist
= ist_table
[ist_index
];
1928 goto discard_packet
;
1930 // 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);
1931 if (pkt
.dts
!= AV_NOPTS_VALUE
&& ist
->next_pts
!= AV_NOPTS_VALUE
) {
1932 int64_t delta
= av_rescale_q(pkt
.dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
) - ist
->next_pts
;
1933 if(FFABS(delta
) > 1LL*dts_delta_threshold
*AV_TIME_BASE
&& !copy_ts
){
1934 input_files_ts_offset
[ist
->file_index
]-= delta
;
1936 fprintf(stderr
, "timestamp discontinuity %"PRId64
", new offset= %"PRId64
"\n", delta
, input_files_ts_offset
[ist
->file_index
]);
1937 for(i
=0; i
<file_table
[file_index
].nb_streams
; i
++){
1938 int index
= file_table
[file_index
].ist_index
+ i
;
1939 ist_table
[index
]->next_pts
+= delta
;
1940 ist_table
[index
]->is_start
=1;
1945 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1946 if (output_packet(ist
, ist_index
, ost_table
, nb_ostreams
, &pkt
) < 0) {
1949 fprintf(stderr
, "Error while decoding stream #%d.%d\n",
1950 ist
->file_index
, ist
->index
);
1952 av_free_packet(&pkt
);
1957 av_free_packet(&pkt
);
1959 /* dump report by using the output first video and audio streams */
1960 print_report(output_files
, ost_table
, nb_ostreams
, 0);
1963 /* at the end of stream, we must flush the decoder buffers */
1964 for(i
=0;i
<nb_istreams
;i
++) {
1966 if (ist
->decoding_needed
) {
1967 output_packet(ist
, i
, ost_table
, nb_ostreams
, NULL
);
1973 /* write the trailer if needed and close file */
1974 for(i
=0;i
<nb_output_files
;i
++) {
1975 os
= output_files
[i
];
1976 av_write_trailer(os
);
1979 /* dump report by using the first video and audio streams */
1980 print_report(output_files
, ost_table
, nb_ostreams
, 1);
1982 /* close each encoder */
1983 for(i
=0;i
<nb_ostreams
;i
++) {
1985 if (ost
->encoding_needed
) {
1986 av_freep(&ost
->st
->codec
->stats_in
);
1987 avcodec_close(ost
->st
->codec
);
1991 /* close each decoder */
1992 for(i
=0;i
<nb_istreams
;i
++) {
1994 if (ist
->decoding_needed
) {
1995 avcodec_close(ist
->st
->codec
);
2003 av_freep(&bit_buffer
);
2004 av_free(file_table
);
2007 for(i
=0;i
<nb_istreams
;i
++) {
2014 for(i
=0;i
<nb_ostreams
;i
++) {
2018 fclose(ost
->logfile
);
2019 ost
->logfile
= NULL
;
2021 av_fifo_free(&ost
->fifo
); /* works even if fifo is not
2022 initialized but set to zero */
2023 av_free(ost
->pict_tmp
.data
[0]);
2024 if (ost
->video_resample
)
2025 sws_freeContext(ost
->img_resample_ctx
);
2026 if (ost
->audio_resample
)
2027 audio_resample_close(ost
->resample
);
2040 int file_read(const char *filename
)
2043 unsigned char buffer
[1024];
2046 if (url_open(&h
, filename
, O_RDONLY
) < 0) {
2047 printf("could not open '%s'\n", filename
);
2051 len
= url_read(h
, buffer
, sizeof(buffer
));
2054 for(i
=0;i
<len
;i
++) putchar(buffer
[i
]);
2061 static void opt_format(const char *arg
)
2063 /* compatibility stuff for pgmyuv */
2064 if (!strcmp(arg
, "pgmyuv")) {
2065 pgmyuv_compatibility_hack
=1;
2066 // opt_image_format(arg);
2070 file_iformat
= av_find_input_format(arg
);
2071 file_oformat
= guess_format(arg
, NULL
, NULL
);
2072 if (!file_iformat
&& !file_oformat
) {
2073 fprintf(stderr
, "Unknown input or output format: %s\n", arg
);
2078 static void opt_video_rc_eq(char *arg
)
2083 static void opt_video_rc_override_string(char *arg
)
2085 video_rc_override_string
= arg
;
2088 static void opt_me_threshold(const char *arg
)
2090 me_threshold
= atoi(arg
);
2093 static void opt_verbose(const char *arg
)
2095 verbose
= atoi(arg
);
2096 av_log_set_level(atoi(arg
));
2099 static void opt_frame_rate(const char *arg
)
2101 if (parse_frame_rate(&frame_rate
, &frame_rate_base
, arg
) < 0) {
2102 fprintf(stderr
, "Incorrect frame rate\n");
2107 static void opt_frame_crop_top(const char *arg
)
2109 frame_topBand
= atoi(arg
);
2110 if (frame_topBand
< 0) {
2111 fprintf(stderr
, "Incorrect top crop size\n");
2114 if ((frame_topBand
% 2) != 0) {
2115 fprintf(stderr
, "Top crop size must be a multiple of 2\n");
2118 if ((frame_topBand
) >= frame_height
){
2119 fprintf(stderr
, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2122 frame_height
-= frame_topBand
;
2125 static void opt_frame_crop_bottom(const char *arg
)
2127 frame_bottomBand
= atoi(arg
);
2128 if (frame_bottomBand
< 0) {
2129 fprintf(stderr
, "Incorrect bottom crop size\n");
2132 if ((frame_bottomBand
% 2) != 0) {
2133 fprintf(stderr
, "Bottom crop size must be a multiple of 2\n");
2136 if ((frame_bottomBand
) >= frame_height
){
2137 fprintf(stderr
, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2140 frame_height
-= frame_bottomBand
;
2143 static void opt_frame_crop_left(const char *arg
)
2145 frame_leftBand
= atoi(arg
);
2146 if (frame_leftBand
< 0) {
2147 fprintf(stderr
, "Incorrect left crop size\n");
2150 if ((frame_leftBand
% 2) != 0) {
2151 fprintf(stderr
, "Left crop size must be a multiple of 2\n");
2154 if ((frame_leftBand
) >= frame_width
){
2155 fprintf(stderr
, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2158 frame_width
-= frame_leftBand
;
2161 static void opt_frame_crop_right(const char *arg
)
2163 frame_rightBand
= atoi(arg
);
2164 if (frame_rightBand
< 0) {
2165 fprintf(stderr
, "Incorrect right crop size\n");
2168 if ((frame_rightBand
% 2) != 0) {
2169 fprintf(stderr
, "Right crop size must be a multiple of 2\n");
2172 if ((frame_rightBand
) >= frame_width
){
2173 fprintf(stderr
, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2176 frame_width
-= frame_rightBand
;
2179 static void opt_frame_size(const char *arg
)
2181 if (parse_image_size(&frame_width
, &frame_height
, arg
) < 0) {
2182 fprintf(stderr
, "Incorrect frame size\n");
2185 if ((frame_width
% 2) != 0 || (frame_height
% 2) != 0) {
2186 fprintf(stderr
, "Frame size must be a multiple of 2\n");
2192 #define SCALEBITS 10
2193 #define ONE_HALF (1 << (SCALEBITS - 1))
2194 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2196 #define RGB_TO_Y(r, g, b) \
2197 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2198 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2200 #define RGB_TO_U(r1, g1, b1, shift)\
2201 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2202 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2204 #define RGB_TO_V(r1, g1, b1, shift)\
2205 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2206 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2208 static void opt_pad_color(const char *arg
) {
2209 /* Input is expected to be six hex digits similar to
2210 how colors are expressed in html tags (but without the #) */
2211 int rgb
= strtol(arg
, NULL
, 16);
2215 g
= ((rgb
>> 8) & 255);
2218 padcolor
[0] = RGB_TO_Y(r
,g
,b
);
2219 padcolor
[1] = RGB_TO_U(r
,g
,b
,0);
2220 padcolor
[2] = RGB_TO_V(r
,g
,b
,0);
2223 static void opt_frame_pad_top(const char *arg
)
2225 frame_padtop
= atoi(arg
);
2226 if (frame_padtop
< 0) {
2227 fprintf(stderr
, "Incorrect top pad size\n");
2230 if ((frame_padtop
% 2) != 0) {
2231 fprintf(stderr
, "Top pad size must be a multiple of 2\n");
2236 static void opt_frame_pad_bottom(const char *arg
)
2238 frame_padbottom
= atoi(arg
);
2239 if (frame_padbottom
< 0) {
2240 fprintf(stderr
, "Incorrect bottom pad size\n");
2243 if ((frame_padbottom
% 2) != 0) {
2244 fprintf(stderr
, "Bottom pad size must be a multiple of 2\n");
2250 static void opt_frame_pad_left(const char *arg
)
2252 frame_padleft
= atoi(arg
);
2253 if (frame_padleft
< 0) {
2254 fprintf(stderr
, "Incorrect left pad size\n");
2257 if ((frame_padleft
% 2) != 0) {
2258 fprintf(stderr
, "Left pad size must be a multiple of 2\n");
2264 static void opt_frame_pad_right(const char *arg
)
2266 frame_padright
= atoi(arg
);
2267 if (frame_padright
< 0) {
2268 fprintf(stderr
, "Incorrect right pad size\n");
2271 if ((frame_padright
% 2) != 0) {
2272 fprintf(stderr
, "Right pad size must be a multiple of 2\n");
2278 static void opt_frame_pix_fmt(const char *arg
)
2280 frame_pix_fmt
= avcodec_get_pix_fmt(arg
);
2283 static void opt_frame_aspect_ratio(const char *arg
)
2289 p
= strchr(arg
, ':');
2291 x
= strtol(arg
, (char **)&arg
, 10);
2293 y
= strtol(arg
+1, (char **)&arg
, 10);
2295 ar
= (double)x
/ (double)y
;
2297 ar
= strtod(arg
, (char **)&arg
);
2300 fprintf(stderr
, "Incorrect aspect ratio specification.\n");
2303 frame_aspect_ratio
= ar
;
2306 static void opt_qscale(const char *arg
)
2308 video_qscale
= atof(arg
);
2309 if (video_qscale
<= 0 ||
2310 video_qscale
> 255) {
2311 fprintf(stderr
, "qscale must be > 0.0 and <= 255\n");
2316 static void opt_qdiff(const char *arg
)
2318 video_qdiff
= atoi(arg
);
2319 if (video_qdiff
< 0 ||
2321 fprintf(stderr
, "qdiff must be >= 1 and <= 31\n");
2326 static void opt_packet_size(const char *arg
)
2328 packet_size
= atoi(arg
);
2331 static void opt_strict(const char *arg
)
2336 static void opt_top_field_first(const char *arg
)
2338 top_field_first
= atoi(arg
);
2341 static void opt_thread_count(const char *arg
)
2343 thread_count
= atoi(arg
);
2344 #if !defined(HAVE_THREADS)
2346 fprintf(stderr
, "Warning: not compiled with thread support, using thread emulation\n");
2350 static void opt_audio_bitrate(const char *arg
)
2352 audio_bit_rate
= atoi(arg
) * 1000;
2355 static void opt_audio_rate(const char *arg
)
2357 audio_sample_rate
= atoi(arg
);
2360 static void opt_audio_channels(const char *arg
)
2362 audio_channels
= atoi(arg
);
2365 static void opt_video_device(const char *arg
)
2367 video_device
= av_strdup(arg
);
2370 static void opt_grab_device(const char *arg
)
2372 grab_device
= av_strdup(arg
);
2375 static void opt_video_channel(const char *arg
)
2377 video_channel
= strtol(arg
, NULL
, 0);
2380 static void opt_video_standard(const char *arg
)
2382 video_standard
= av_strdup(arg
);
2385 static void opt_audio_device(const char *arg
)
2387 audio_device
= av_strdup(arg
);
2390 static void opt_codec(int *pstream_copy
, int *pcodec_id
,
2391 int codec_type
, const char *arg
)
2395 if (!strcmp(arg
, "copy")) {
2400 if (!strcmp(p
->name
, arg
) && p
->type
== codec_type
)
2405 fprintf(stderr
, "Unknown codec '%s'\n", arg
);
2413 static void opt_audio_codec(const char *arg
)
2415 opt_codec(&audio_stream_copy
, &audio_codec_id
, CODEC_TYPE_AUDIO
, arg
);
2418 static void opt_audio_tag(const char *arg
)
2421 audio_codec_tag
= strtol(arg
, &tail
, 0);
2424 audio_codec_tag
= arg
[0] + (arg
[1]<<8) + (arg
[2]<<16) + (arg
[3]<<24);
2427 static void opt_video_tag(const char *arg
)
2430 video_codec_tag
= strtol(arg
, &tail
, 0);
2433 video_codec_tag
= arg
[0] + (arg
[1]<<8) + (arg
[2]<<16) + (arg
[3]<<24);
2436 static void add_frame_hooker(const char *arg
)
2441 char *args
= av_strdup(arg
);
2445 argv
[0] = strtok(args
, " ");
2446 while (argc
< 62 && (argv
[++argc
] = strtok(NULL
, " "))) {
2449 i
= frame_hook_add(argc
, argv
);
2452 fprintf(stderr
, "Failed to add video hook function: %s\n", arg
);
2457 const char *motion_str
[] = {
2470 static void opt_motion_estimation(const char *arg
)
2476 fprintf(stderr
, "Unknown motion estimation method '%s'\n", arg
);
2479 if (!strcmp(*p
, arg
))
2483 me_method
= (p
- motion_str
) + 1;
2486 static void opt_video_codec(const char *arg
)
2488 opt_codec(&video_stream_copy
, &video_codec_id
, CODEC_TYPE_VIDEO
, arg
);
2491 static void opt_subtitle_codec(const char *arg
)
2493 opt_codec(&subtitle_stream_copy
, &subtitle_codec_id
, CODEC_TYPE_SUBTITLE
, arg
);
2496 static void opt_map(const char *arg
)
2502 m
= &stream_maps
[nb_stream_maps
++];
2504 m
->file_index
= strtol(arg
, (char **)&p
, 0);
2508 m
->stream_index
= strtol(p
, (char **)&p
, 0);
2511 m
->sync_file_index
= strtol(p
, (char **)&p
, 0);
2514 m
->sync_stream_index
= strtol(p
, (char **)&p
, 0);
2516 m
->sync_file_index
= m
->file_index
;
2517 m
->sync_stream_index
= m
->stream_index
;
2521 static void opt_map_meta_data(const char *arg
)
2527 m
= &meta_data_maps
[nb_meta_data_maps
++];
2529 m
->out_file
= strtol(arg
, (char **)&p
, 0);
2533 m
->in_file
= strtol(p
, (char **)&p
, 0);
2536 static void opt_recording_time(const char *arg
)
2538 recording_time
= parse_date(arg
, 1);
2541 static void opt_start_time(const char *arg
)
2543 start_time
= parse_date(arg
, 1);
2546 static void opt_rec_timestamp(const char *arg
)
2548 rec_timestamp
= parse_date(arg
, 0) / 1000000;
2551 static void opt_input_ts_offset(const char *arg
)
2553 input_ts_offset
= parse_date(arg
, 1);
2556 static void opt_input_file(const char *filename
)
2558 AVFormatContext
*ic
;
2559 AVFormatParameters params
, *ap
= ¶ms
;
2560 int err
, i
, ret
, rfps
, rfps_base
;
2563 if (!strcmp(filename
, "-"))
2566 using_stdin
|= !strncmp(filename
, "pipe:", 5) ||
2567 !strcmp( filename
, "/dev/stdin" );
2569 /* get default parameters from command line */
2570 ic
= av_alloc_format_context();
2572 memset(ap
, 0, sizeof(*ap
));
2573 ap
->prealloced_context
= 1;
2574 ap
->sample_rate
= audio_sample_rate
;
2575 ap
->channels
= audio_channels
;
2576 ap
->time_base
.den
= frame_rate
;
2577 ap
->time_base
.num
= frame_rate_base
;
2578 ap
->width
= frame_width
+ frame_padleft
+ frame_padright
;
2579 ap
->height
= frame_height
+ frame_padtop
+ frame_padbottom
;
2580 ap
->pix_fmt
= frame_pix_fmt
;
2581 ap
->device
= grab_device
;
2582 ap
->channel
= video_channel
;
2583 ap
->standard
= video_standard
;
2584 ap
->video_codec_id
= video_codec_id
;
2585 ap
->audio_codec_id
= audio_codec_id
;
2586 if(pgmyuv_compatibility_hack
)
2587 ap
->video_codec_id
= CODEC_ID_PGMYUV
;
2589 for(i
=0; i
<opt_name_count
; i
++){
2591 double d
= av_get_double(avformat_opts
, opt_names
[i
], &opt
);
2592 if(d
==d
&& (opt
->flags
&AV_OPT_FLAG_DECODING_PARAM
))
2593 av_set_double(ic
, opt_names
[i
], d
);
2595 /* open the input file with generic libav function */
2596 err
= av_open_input_file(&ic
, filename
, file_iformat
, 0, ap
);
2598 print_error(filename
, err
);
2602 ic
->loop_input
= loop_input
;
2604 /* If not enough info to get the stream parameters, we decode the
2605 first frames to get it. (used in mpeg case for example) */
2606 ret
= av_find_stream_info(ic
);
2607 if (ret
< 0 && verbose
>= 0) {
2608 fprintf(stderr
, "%s: could not find codec parameters\n", filename
);
2612 timestamp
= start_time
;
2613 /* add the stream start time */
2614 if (ic
->start_time
!= AV_NOPTS_VALUE
)
2615 timestamp
+= ic
->start_time
;
2617 /* if seeking requested, we execute it */
2618 if (start_time
!= 0) {
2619 ret
= av_seek_frame(ic
, -1, timestamp
, AVSEEK_FLAG_BACKWARD
);
2621 fprintf(stderr
, "%s: could not seek to position %0.3f\n",
2622 filename
, (double)timestamp
/ AV_TIME_BASE
);
2624 /* reset seek info */
2628 /* update the current parameters so that they match the one of the input stream */
2629 for(i
=0;i
<ic
->nb_streams
;i
++) {
2631 AVCodecContext
*enc
= ic
->streams
[i
]->codec
;
2632 #if defined(HAVE_THREADS)
2634 avcodec_thread_init(enc
, thread_count
);
2636 enc
->thread_count
= thread_count
;
2637 switch(enc
->codec_type
) {
2638 case CODEC_TYPE_AUDIO
:
2639 for(j
=0; j
<opt_name_count
; j
++){
2641 double d
= av_get_double(avctx_opts
, opt_names
[j
], &opt
);
2642 if(d
==d
&& (opt
->flags
&AV_OPT_FLAG_AUDIO_PARAM
) && (opt
->flags
&AV_OPT_FLAG_DECODING_PARAM
))
2643 av_set_double(enc
, opt_names
[j
], d
);
2645 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2646 audio_channels
= enc
->channels
;
2647 audio_sample_rate
= enc
->sample_rate
;
2649 ic
->streams
[i
]->discard
= AVDISCARD_ALL
;
2651 case CODEC_TYPE_VIDEO
:
2652 for(j
=0; j
<opt_name_count
; j
++){
2654 double d
= av_get_double(avctx_opts
, opt_names
[j
], &opt
);
2655 if(d
==d
&& (opt
->flags
&AV_OPT_FLAG_VIDEO_PARAM
) && (opt
->flags
&AV_OPT_FLAG_DECODING_PARAM
))
2656 av_set_double(enc
, opt_names
[j
], d
);
2658 frame_height
= enc
->height
;
2659 frame_width
= enc
->width
;
2660 frame_aspect_ratio
= av_q2d(enc
->sample_aspect_ratio
) * enc
->width
/ enc
->height
;
2661 frame_pix_fmt
= enc
->pix_fmt
;
2662 rfps
= ic
->streams
[i
]->r_frame_rate
.num
;
2663 rfps_base
= ic
->streams
[i
]->r_frame_rate
.den
;
2664 if(enc
->lowres
) enc
->flags
|= CODEC_FLAG_EMU_EDGE
;
2666 enc
->debug
|= FF_DEBUG_MV
;
2668 if (enc
->time_base
.den
!= rfps
|| enc
->time_base
.num
!= rfps_base
) {
2671 fprintf(stderr
,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2672 i
, (float)enc
->time_base
.den
/ enc
->time_base
.num
, enc
->time_base
.den
, enc
->time_base
.num
,
2674 (float)rfps
/ rfps_base
, rfps
, rfps_base
);
2676 /* update the current frame rate to match the stream frame rate */
2678 frame_rate_base
= rfps_base
;
2680 enc
->rate_emu
= rate_emu
;
2682 ic
->streams
[i
]->discard
= AVDISCARD_ALL
;
2683 else if(video_discard
)
2684 ic
->streams
[i
]->discard
= video_discard
;
2686 case CODEC_TYPE_DATA
:
2688 case CODEC_TYPE_SUBTITLE
:
2690 case CODEC_TYPE_UNKNOWN
:
2697 input_files
[nb_input_files
] = ic
;
2698 input_files_ts_offset
[nb_input_files
] = input_ts_offset
- (copy_ts ?
0 : timestamp
);
2699 /* dump the file content */
2701 dump_format(ic
, nb_input_files
, filename
, 0);
2704 file_iformat
= NULL
;
2705 file_oformat
= NULL
;
2713 static void opt_grab(const char *arg
)
2715 file_iformat
= av_find_input_format(arg
);
2719 static void check_audio_video_inputs(int *has_video_ptr
, int *has_audio_ptr
)
2721 int has_video
, has_audio
, i
, j
;
2722 AVFormatContext
*ic
;
2726 for(j
=0;j
<nb_input_files
;j
++) {
2727 ic
= input_files
[j
];
2728 for(i
=0;i
<ic
->nb_streams
;i
++) {
2729 AVCodecContext
*enc
= ic
->streams
[i
]->codec
;
2730 switch(enc
->codec_type
) {
2731 case CODEC_TYPE_AUDIO
:
2734 case CODEC_TYPE_VIDEO
:
2737 case CODEC_TYPE_DATA
:
2738 case CODEC_TYPE_UNKNOWN
:
2739 case CODEC_TYPE_SUBTITLE
:
2746 *has_video_ptr
= has_video
;
2747 *has_audio_ptr
= has_audio
;
2750 static void new_video_stream(AVFormatContext
*oc
)
2753 AVCodecContext
*video_enc
;
2756 st
= av_new_stream(oc
, oc
->nb_streams
);
2758 fprintf(stderr
, "Could not alloc stream\n");
2761 bitstream_filters
[nb_output_files
][oc
->nb_streams
- 1]= video_bitstream_filters
;
2762 video_bitstream_filters
= NULL
;
2764 #if defined(HAVE_THREADS)
2766 avcodec_thread_init(st
->codec
, thread_count
);
2769 video_enc
= st
->codec
;
2772 video_enc
->codec_tag
= video_codec_tag
;
2774 if( (video_global_header
&1)
2775 || (video_global_header
==0 && (oc
->oformat
->flags
& AVFMT_GLOBALHEADER
))){
2776 video_enc
->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
2777 avctx_opts
->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
2779 if(video_global_header
&2){
2780 video_enc
->flags2
|= CODEC_FLAG2_LOCAL_HEADER
;
2781 avctx_opts
->flags2
|= CODEC_FLAG2_LOCAL_HEADER
;
2784 if (video_stream_copy
) {
2785 st
->stream_copy
= 1;
2786 video_enc
->codec_type
= CODEC_TYPE_VIDEO
;
2792 codec_id
= av_guess_codec(oc
->oformat
, NULL
, oc
->filename
, NULL
, CODEC_TYPE_VIDEO
);
2793 if (video_codec_id
!= CODEC_ID_NONE
)
2794 codec_id
= video_codec_id
;
2796 video_enc
->codec_id
= codec_id
;
2797 codec
= avcodec_find_encoder(codec_id
);
2799 for(i
=0; i
<opt_name_count
; i
++){
2801 double d
= av_get_double(avctx_opts
, opt_names
[i
], &opt
);
2802 if(d
==d
&& (opt
->flags
&AV_OPT_FLAG_VIDEO_PARAM
) && (opt
->flags
&AV_OPT_FLAG_ENCODING_PARAM
))
2803 av_set_double(video_enc
, opt_names
[i
], d
);
2806 video_enc
->time_base
.den
= frame_rate
;
2807 video_enc
->time_base
.num
= frame_rate_base
;
2808 if(codec
&& codec
->supported_framerates
){
2809 const AVRational
*p
= codec
->supported_framerates
;
2810 AVRational req
= (AVRational
){frame_rate
, frame_rate_base
};
2811 const AVRational
*best
=NULL
;
2812 AVRational best_error
= (AVRational
){INT_MAX
, 1};
2813 for(; p
->den
!=0; p
++){
2814 AVRational error
= av_sub_q(req
, *p
);
2815 if(error
.num
<0) error
.num
*= -1;
2816 if(av_cmp_q(error
, best_error
) < 0){
2821 video_enc
->time_base
.den
= best
->num
;
2822 video_enc
->time_base
.num
= best
->den
;
2825 video_enc
->width
= frame_width
+ frame_padright
+ frame_padleft
;
2826 video_enc
->height
= frame_height
+ frame_padtop
+ frame_padbottom
;
2827 video_enc
->sample_aspect_ratio
= av_d2q(frame_aspect_ratio
*video_enc
->height
/video_enc
->width
, 255);
2828 video_enc
->pix_fmt
= frame_pix_fmt
;
2830 if(codec
&& codec
->pix_fmts
){
2831 const enum PixelFormat
*p
= codec
->pix_fmts
;
2833 if(*p
== video_enc
->pix_fmt
)
2837 video_enc
->pix_fmt
= codec
->pix_fmts
[0];
2841 video_enc
->gop_size
= 0;
2842 if (video_qscale
|| same_quality
) {
2843 video_enc
->flags
|= CODEC_FLAG_QSCALE
;
2844 video_enc
->global_quality
=
2845 st
->quality
= FF_QP2LAMBDA
* video_qscale
;
2849 video_enc
->intra_matrix
= intra_matrix
;
2851 video_enc
->inter_matrix
= inter_matrix
;
2853 video_enc
->max_qdiff
= video_qdiff
;
2854 video_enc
->rc_eq
= video_rc_eq
;
2855 video_enc
->thread_count
= thread_count
;
2856 p
= video_rc_override_string
;
2859 int e
=sscanf(p
, "%d,%d,%d", &start
, &end
, &q
);
2861 fprintf(stderr
, "error parsing rc_override\n");
2864 video_enc
->rc_override
=
2865 av_realloc(video_enc
->rc_override
,
2866 sizeof(RcOverride
)*(i
+1));
2867 video_enc
->rc_override
[i
].start_frame
= start
;
2868 video_enc
->rc_override
[i
].end_frame
= end
;
2870 video_enc
->rc_override
[i
].qscale
= q
;
2871 video_enc
->rc_override
[i
].quality_factor
= 1.0;
2874 video_enc
->rc_override
[i
].qscale
= 0;
2875 video_enc
->rc_override
[i
].quality_factor
= -q
/100.0;
2880 video_enc
->rc_override_count
=i
;
2881 video_enc
->rc_initial_buffer_occupancy
= video_enc
->rc_buffer_size
*3/4;
2882 video_enc
->me_threshold
= me_threshold
;
2883 video_enc
->intra_dc_precision
= intra_dc_precision
- 8;
2884 video_enc
->strict_std_compliance
= strict
;
2887 video_enc
->rtp_mode
= 1;
2888 video_enc
->rtp_payload_size
= packet_size
;
2892 video_enc
->flags
|= CODEC_FLAG_PSNR
;
2894 video_enc
->me_method
= me_method
;
2899 video_enc
->flags
|= CODEC_FLAG_PASS1
;
2901 video_enc
->flags
|= CODEC_FLAG_PASS2
;
2906 /* reset some key parameters */
2908 video_codec_id
= CODEC_ID_NONE
;
2909 video_stream_copy
= 0;
2912 static void new_audio_stream(AVFormatContext
*oc
)
2915 AVCodecContext
*audio_enc
;
2918 st
= av_new_stream(oc
, oc
->nb_streams
);
2920 fprintf(stderr
, "Could not alloc stream\n");
2924 bitstream_filters
[nb_output_files
][oc
->nb_streams
- 1]= audio_bitstream_filters
;
2925 audio_bitstream_filters
= NULL
;
2927 #if defined(HAVE_THREADS)
2929 avcodec_thread_init(st
->codec
, thread_count
);
2932 audio_enc
= st
->codec
;
2933 audio_enc
->codec_type
= CODEC_TYPE_AUDIO
;
2934 audio_enc
->strict_std_compliance
= strict
;
2937 audio_enc
->codec_tag
= audio_codec_tag
;
2939 if (oc
->oformat
->flags
& AVFMT_GLOBALHEADER
) {
2940 audio_enc
->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
2941 avctx_opts
->flags
|= CODEC_FLAG_GLOBAL_HEADER
;
2943 if (audio_stream_copy
) {
2944 st
->stream_copy
= 1;
2945 audio_enc
->channels
= audio_channels
;
2947 codec_id
= av_guess_codec(oc
->oformat
, NULL
, oc
->filename
, NULL
, CODEC_TYPE_AUDIO
);
2949 for(i
=0; i
<opt_name_count
; i
++){
2951 double d
= av_get_double(avctx_opts
, opt_names
[i
], &opt
);
2952 if(d
==d
&& (opt
->flags
&AV_OPT_FLAG_AUDIO_PARAM
) && (opt
->flags
&AV_OPT_FLAG_ENCODING_PARAM
))
2953 av_set_double(audio_enc
, opt_names
[i
], d
);
2956 if (audio_codec_id
!= CODEC_ID_NONE
)
2957 codec_id
= audio_codec_id
;
2958 audio_enc
->codec_id
= codec_id
;
2960 audio_enc
->bit_rate
= audio_bit_rate
;
2961 if (audio_qscale
> QSCALE_NONE
) {
2962 audio_enc
->flags
|= CODEC_FLAG_QSCALE
;
2963 audio_enc
->global_quality
= st
->quality
= FF_QP2LAMBDA
* audio_qscale
;
2965 audio_enc
->thread_count
= thread_count
;
2966 /* For audio codecs other than AC3 or DTS we limit */
2967 /* the number of coded channels to stereo */
2968 if (audio_channels
> 2 && codec_id
!= CODEC_ID_AC3
2969 && codec_id
!= CODEC_ID_DTS
) {
2970 audio_enc
->channels
= 2;
2972 audio_enc
->channels
= audio_channels
;
2974 audio_enc
->sample_rate
= audio_sample_rate
;
2975 audio_enc
->time_base
= (AVRational
){1, audio_sample_rate
};
2976 if (audio_language
) {
2977 pstrcpy(st
->language
, sizeof(st
->language
), audio_language
);
2978 av_free(audio_language
);
2979 audio_language
= NULL
;
2982 /* reset some key parameters */
2984 audio_codec_id
= CODEC_ID_NONE
;
2985 audio_stream_copy
= 0;
2988 static void opt_new_subtitle_stream(void)
2990 AVFormatContext
*oc
;
2992 AVCodecContext
*subtitle_enc
;
2995 if (nb_output_files
<= 0) {
2996 fprintf(stderr
, "At least one output file must be specified\n");
2999 oc
= output_files
[nb_output_files
- 1];
3001 st
= av_new_stream(oc
, oc
->nb_streams
);
3003 fprintf(stderr
, "Could not alloc stream\n");
3007 subtitle_enc
= st
->codec
;
3008 subtitle_enc
->codec_type
= CODEC_TYPE_SUBTITLE
;
3009 if (subtitle_stream_copy
) {
3010 st
->stream_copy
= 1;
3012 for(i
=0; i
<opt_name_count
; i
++){
3014 double d
= av_get_double(avctx_opts
, opt_names
[i
], &opt
);
3015 if(d
==d
&& (opt
->flags
&AV_OPT_FLAG_SUBTITLE_PARAM
) && (opt
->flags
&AV_OPT_FLAG_ENCODING_PARAM
))
3016 av_set_double(subtitle_enc
, opt_names
[i
], d
);
3018 subtitle_enc
->codec_id
= subtitle_codec_id
;
3021 if (subtitle_language
) {
3022 pstrcpy(st
->language
, sizeof(st
->language
), subtitle_language
);
3023 av_free(subtitle_language
);
3024 subtitle_language
= NULL
;
3027 subtitle_codec_id
= CODEC_ID_NONE
;
3028 subtitle_stream_copy
= 0;
3031 static void opt_new_audio_stream(void)
3033 AVFormatContext
*oc
;
3034 if (nb_output_files
<= 0) {
3035 fprintf(stderr
, "At least one output file must be specified\n");
3038 oc
= output_files
[nb_output_files
- 1];
3039 new_audio_stream(oc
);
3042 static void opt_new_video_stream(void)
3044 AVFormatContext
*oc
;
3045 if (nb_output_files
<= 0) {
3046 fprintf(stderr
, "At least one output file must be specified\n");
3049 oc
= output_files
[nb_output_files
- 1];
3050 new_video_stream(oc
);
3053 static void opt_output_file(const char *filename
)
3055 AVFormatContext
*oc
;
3056 int use_video
, use_audio
, input_has_video
, input_has_audio
, i
;
3057 AVFormatParameters params
, *ap
= ¶ms
;
3059 if (!strcmp(filename
, "-"))
3062 oc
= av_alloc_format_context();
3064 if (!file_oformat
) {
3065 file_oformat
= guess_format(NULL
, filename
, NULL
);
3066 if (!file_oformat
) {
3067 fprintf(stderr
, "Unable for find a suitable output format for '%s'\n",
3073 oc
->oformat
= file_oformat
;
3074 pstrcpy(oc
->filename
, sizeof(oc
->filename
), filename
);
3076 if (!strcmp(file_oformat
->name
, "ffm") &&
3077 strstart(filename
, "http:", NULL
)) {
3078 /* special case for files sent to ffserver: we get the stream
3079 parameters from ffserver */
3080 if (read_ffserver_streams(oc
, filename
) < 0) {
3081 fprintf(stderr
, "Could not read stream parameters from '%s'\n", filename
);
3085 use_video
= file_oformat
->video_codec
!= CODEC_ID_NONE
|| video_stream_copy
|| video_codec_id
!= CODEC_ID_NONE
;
3086 use_audio
= file_oformat
->audio_codec
!= CODEC_ID_NONE
|| audio_stream_copy
|| audio_codec_id
!= CODEC_ID_NONE
;
3088 /* disable if no corresponding type found and at least one
3090 if (nb_input_files
> 0) {
3091 check_audio_video_inputs(&input_has_video
, &input_has_audio
);
3092 if (!input_has_video
)
3094 if (!input_has_audio
)
3098 /* manual disable */
3099 if (audio_disable
) {
3102 if (video_disable
) {
3107 new_video_stream(oc
);
3111 new_audio_stream(oc
);
3114 oc
->timestamp
= rec_timestamp
;
3117 pstrcpy(oc
->title
, sizeof(oc
->title
), str_title
);
3119 pstrcpy(oc
->author
, sizeof(oc
->author
), str_author
);
3121 pstrcpy(oc
->copyright
, sizeof(oc
->copyright
), str_copyright
);
3123 pstrcpy(oc
->comment
, sizeof(oc
->comment
), str_comment
);
3125 pstrcpy(oc
->album
, sizeof(oc
->album
), str_album
);
3128 output_files
[nb_output_files
++] = oc
;
3130 /* check filename in case of an image number is expected */
3131 if (oc
->oformat
->flags
& AVFMT_NEEDNUMBER
) {
3132 if (!av_filename_number_test(oc
->filename
)) {
3133 print_error(oc
->filename
, AVERROR_NUMEXPECTED
);
3138 if (!(oc
->oformat
->flags
& AVFMT_NOFILE
)) {
3139 /* test if it already exists to avoid loosing precious files */
3140 if (!file_overwrite
&&
3141 (strchr(filename
, ':') == NULL
||
3142 strstart(filename
, "file:", NULL
))) {
3143 if (url_exist(filename
)) {
3146 if ( !using_stdin
) {
3147 fprintf(stderr
,"File '%s' already exists. Overwrite ? [y/N] ", filename
);
3150 if (toupper(c
) != 'Y') {
3151 fprintf(stderr
, "Not overwriting - exiting\n");
3156 fprintf(stderr
,"File '%s' already exists. Exiting.\n", filename
);
3163 if (url_fopen(&oc
->pb
, filename
, URL_WRONLY
) < 0) {
3164 fprintf(stderr
, "Could not open '%s'\n", filename
);
3169 memset(ap
, 0, sizeof(*ap
));
3170 if (av_set_parameters(oc
, ap
) < 0) {
3171 fprintf(stderr
, "%s: Invalid encoding parameters\n",
3176 oc
->preload
= (int)(mux_preload
*AV_TIME_BASE
);
3177 oc
->max_delay
= (int)(mux_max_delay
*AV_TIME_BASE
);
3178 oc
->loop_output
= loop_output
;
3180 for(i
=0; i
<opt_name_count
; i
++){
3182 double d
= av_get_double(avformat_opts
, opt_names
[i
], &opt
);
3183 if(d
==d
&& (opt
->flags
&AV_OPT_FLAG_ENCODING_PARAM
))
3184 av_set_double(oc
, opt_names
[i
], d
);
3187 /* reset some options */
3188 file_oformat
= NULL
;
3189 file_iformat
= NULL
;
3192 /* prepare dummy protocols for grab */
3193 static void prepare_grab(void)
3195 int has_video
, has_audio
, i
, j
;
3196 AVFormatContext
*oc
;
3197 AVFormatContext
*ic
;
3198 AVFormatParameters vp1
, *vp
= &vp1
;
3199 AVFormatParameters ap1
, *ap
= &ap1
;
3201 /* see if audio/video inputs are needed */
3204 memset(ap
, 0, sizeof(*ap
));
3205 memset(vp
, 0, sizeof(*vp
));
3206 vp
->time_base
.num
= 1;
3207 for(j
=0;j
<nb_output_files
;j
++) {
3208 oc
= output_files
[j
];
3209 for(i
=0;i
<oc
->nb_streams
;i
++) {
3210 AVCodecContext
*enc
= oc
->streams
[i
]->codec
;
3211 switch(enc
->codec_type
) {
3212 case CODEC_TYPE_AUDIO
:
3213 if (enc
->sample_rate
> ap
->sample_rate
)
3214 ap
->sample_rate
= enc
->sample_rate
;
3215 if (enc
->channels
> ap
->channels
)
3216 ap
->channels
= enc
->channels
;
3219 case CODEC_TYPE_VIDEO
:
3220 if (enc
->width
> vp
->width
)
3221 vp
->width
= enc
->width
;
3222 if (enc
->height
> vp
->height
)
3223 vp
->height
= enc
->height
;
3225 if (vp
->time_base
.num
*(int64_t)enc
->time_base
.den
> enc
->time_base
.num
*(int64_t)vp
->time_base
.den
){
3226 vp
->time_base
= enc
->time_base
;
3227 vp
->width
+= frame_leftBand
+ frame_rightBand
;
3228 vp
->width
-= (frame_padleft
+ frame_padright
);
3229 vp
->height
+= frame_topBand
+ frame_bottomBand
;
3230 vp
->height
-= (frame_padtop
+ frame_padbottom
);
3240 if (has_video
== 0 && has_audio
== 0) {
3241 fprintf(stderr
, "Output file must have at least one audio or video stream\n");
3246 AVInputFormat
*fmt1
;
3247 fmt1
= av_find_input_format(video_grab_format
);
3248 vp
->device
= video_device
;
3249 vp
->channel
= video_channel
;
3250 vp
->standard
= video_standard
;
3251 vp
->pix_fmt
= frame_pix_fmt
;
3252 if (av_open_input_file(&ic
, "", fmt1
, 0, vp
) < 0) {
3253 fprintf(stderr
, "Could not find video grab device\n");
3256 /* If not enough info to get the stream parameters, we decode the
3257 first frames to get it. */
3258 if ((ic
->ctx_flags
& AVFMTCTX_NOHEADER
) && av_find_stream_info(ic
) < 0) {
3259 fprintf(stderr
, "Could not find video grab parameters\n");