2 * Copyright (c) 2000-2003 Fabrice Bellard
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * multimedia converter based on the FFmpeg libraries
44 #include "libavformat/avformat.h"
45 #include "libavdevice/avdevice.h"
46 #include "libswresample/swresample.h"
47 #include "libavutil/opt.h"
48 #include "libavutil/channel_layout.h"
49 #include "libavutil/parseutils.h"
50 #include "libavutil/samplefmt.h"
51 #include "libavutil/fifo.h"
52 #include "libavutil/intreadwrite.h"
53 #include "libavutil/dict.h"
54 #include "libavutil/mathematics.h"
55 #include "libavutil/pixdesc.h"
56 #include "libavutil/avstring.h"
57 #include "libavutil/libm.h"
58 #include "libavutil/imgutils.h"
59 #include "libavutil/timestamp.h"
60 #include "libavutil/bprint.h"
61 #include "libavutil/time.h"
62 #include "libavutil/threadmessage.h"
63 #include "libavformat/os_support.h"
65 #include "libavformat/ffm.h" // not public API
67 # include "libavfilter/avcodec.h"
68 # include "libavfilter/avfilter.h"
69 # include "libavfilter/buffersrc.h"
70 # include "libavfilter/buffersink.h"
72 #if HAVE_SYS_RESOURCE_H
74 #include <sys/types.h>
75 #include <sys/resource.h>
76 #elif HAVE_GETPROCESSTIMES
79 #if HAVE_GETPROCESSMEMORYINFO
85 #include <sys/select.h>
90 #include <sys/ioctl.h>
104 #include "cmdutils.h"
106 #include "libavutil/avassert.h"
108 const char program_name
[] = "ffmpeg";
109 const int program_birth_year
= 2000;
111 static FILE *vstats_file
;
113 const char *const forced_keyframes_const_names
[] = {
122 static void do_video_stats(OutputStream
*ost
, int frame_size
);
123 static int64_t getutime(void);
124 static int64_t getmaxrss(void);
126 static int run_as_daemon
= 0;
127 static int nb_frames_dup
= 0;
128 static int nb_frames_drop
= 0;
129 static int64_t decode_error_stat
[2];
131 static int current_time
;
132 AVIOContext
*progress_avio
= NULL
;
134 static uint8_t *subtitle_out
;
136 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
138 InputStream
**input_streams
= NULL
;
139 int nb_input_streams
= 0;
140 InputFile
**input_files
= NULL
;
141 int nb_input_files
= 0;
143 OutputStream
**output_streams
= NULL
;
144 int nb_output_streams
= 0;
145 OutputFile
**output_files
= NULL
;
146 int nb_output_files
= 0;
148 FilterGraph
**filtergraphs
;
153 /* init terminal so that we can grab keys */
154 static struct termios oldtty
;
155 static int restore_tty
;
158 static void free_input_threads(void);
162 Convert subtitles to video with alpha to insert them in filter graphs.
163 This is a temporary solution until libavfilter gets real subtitles support.
166 static int sub2video_get_blank_frame(InputStream
*ist
)
169 AVFrame
*frame
= ist
->sub2video
.frame
;
171 av_frame_unref(frame
);
172 ist
->sub2video
.frame
->width
= ist
->sub2video
.w
;
173 ist
->sub2video
.frame
->height
= ist
->sub2video
.h
;
174 ist
->sub2video
.frame
->format
= AV_PIX_FMT_RGB32
;
175 if ((ret
= av_frame_get_buffer(frame
, 32)) < 0)
177 memset(frame
->data
[0], 0, frame
->height
* frame
->linesize
[0]);
181 static void sub2video_copy_rect(uint8_t *dst
, int dst_linesize
, int w
, int h
,
184 uint32_t *pal
, *dst2
;
188 if (r
->type
!= SUBTITLE_BITMAP
) {
189 av_log(NULL
, AV_LOG_WARNING
, "sub2video: non-bitmap subtitle\n");
192 if (r
->x
< 0 || r
->x
+ r
->w
> w
|| r
->y
< 0 || r
->y
+ r
->h
> h
) {
193 av_log(NULL
, AV_LOG_WARNING
, "sub2video: rectangle overflowing\n");
197 dst
+= r
->y
* dst_linesize
+ r
->x
* 4;
198 src
= r
->pict
.data
[0];
199 pal
= (uint32_t *)r
->pict
.data
[1];
200 for (y
= 0; y
< r
->h
; y
++) {
201 dst2
= (uint32_t *)dst
;
203 for (x
= 0; x
< r
->w
; x
++)
204 *(dst2
++) = pal
[*(src2
++)];
206 src
+= r
->pict
.linesize
[0];
210 static void sub2video_push_ref(InputStream
*ist
, int64_t pts
)
212 AVFrame
*frame
= ist
->sub2video
.frame
;
215 av_assert1(frame
->data
[0]);
216 ist
->sub2video
.last_pts
= frame
->pts
= pts
;
217 for (i
= 0; i
< ist
->nb_filters
; i
++)
218 av_buffersrc_add_frame_flags(ist
->filters
[i
]->filter
, frame
,
219 AV_BUFFERSRC_FLAG_KEEP_REF
|
220 AV_BUFFERSRC_FLAG_PUSH
);
223 static void sub2video_update(InputStream
*ist
, AVSubtitle
*sub
)
225 int w
= ist
->sub2video
.w
, h
= ist
->sub2video
.h
;
226 AVFrame
*frame
= ist
->sub2video
.frame
;
230 int64_t pts
, end_pts
;
235 pts
= av_rescale_q(sub
->pts
+ sub
->start_display_time
* 1000LL,
236 AV_TIME_BASE_Q
, ist
->st
->time_base
);
237 end_pts
= av_rescale_q(sub
->pts
+ sub
->end_display_time
* 1000LL,
238 AV_TIME_BASE_Q
, ist
->st
->time_base
);
239 num_rects
= sub
->num_rects
;
241 pts
= ist
->sub2video
.end_pts
;
245 if (sub2video_get_blank_frame(ist
) < 0) {
246 av_log(ist
->dec_ctx
, AV_LOG_ERROR
,
247 "Impossible to get a blank canvas.\n");
250 dst
= frame
->data
[0];
251 dst_linesize
= frame
->linesize
[0];
252 for (i
= 0; i
< num_rects
; i
++)
253 sub2video_copy_rect(dst
, dst_linesize
, w
, h
, sub
->rects
[i
]);
254 sub2video_push_ref(ist
, pts
);
255 ist
->sub2video
.end_pts
= end_pts
;
258 static void sub2video_heartbeat(InputStream
*ist
, int64_t pts
)
260 InputFile
*infile
= input_files
[ist
->file_index
];
264 /* When a frame is read from a file, examine all sub2video streams in
265 the same file and send the sub2video frame again. Otherwise, decoded
266 video frames could be accumulating in the filter graph while a filter
267 (possibly overlay) is desperately waiting for a subtitle frame. */
268 for (i
= 0; i
< infile
->nb_streams
; i
++) {
269 InputStream
*ist2
= input_streams
[infile
->ist_index
+ i
];
270 if (!ist2
->sub2video
.frame
)
272 /* subtitles seem to be usually muxed ahead of other streams;
273 if not, subtracting a larger time here is necessary */
274 pts2
= av_rescale_q(pts
, ist
->st
->time_base
, ist2
->st
->time_base
) - 1;
275 /* do not send the heartbeat frame if the subtitle is already ahead */
276 if (pts2
<= ist2
->sub2video
.last_pts
)
278 if (pts2
>= ist2
->sub2video
.end_pts
|| !ist2
->sub2video
.frame
->data
[0])
279 sub2video_update(ist2
, NULL
);
280 for (j
= 0, nb_reqs
= 0; j
< ist2
->nb_filters
; j
++)
281 nb_reqs
+= av_buffersrc_get_nb_failed_requests(ist2
->filters
[j
]->filter
);
283 sub2video_push_ref(ist2
, pts2
);
287 static void sub2video_flush(InputStream
*ist
)
291 if (ist
->sub2video
.end_pts
< INT64_MAX
)
292 sub2video_update(ist
, NULL
);
293 for (i
= 0; i
< ist
->nb_filters
; i
++)
294 av_buffersrc_add_ref(ist
->filters
[i
]->filter
, NULL
, 0);
297 /* end of sub2video hack */
299 static void term_exit_sigsafe(void)
303 tcsetattr (0, TCSANOW
, &oldtty
);
309 av_log(NULL
, AV_LOG_QUIET
, "%s", "");
313 static volatile int received_sigterm
= 0;
314 static volatile int received_nb_signals
= 0;
315 static volatile int transcode_init_done
= 0;
316 static int main_return_code
= 0;
319 sigterm_handler(int sig
)
321 received_sigterm
= sig
;
322 received_nb_signals
++;
324 if(received_nb_signals
> 3)
335 istty
= isatty(0) && isatty(2);
337 if (istty
&& tcgetattr (0, &tty
) == 0) {
341 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
342 |INLCR
|IGNCR
|ICRNL
|IXON
);
343 tty
.c_oflag
|= OPOST
;
344 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
345 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
350 tcsetattr (0, TCSANOW
, &tty
);
352 signal(SIGQUIT
, sigterm_handler
); /* Quit (POSIX). */
355 avformat_network_deinit();
357 signal(SIGINT
, sigterm_handler
); /* Interrupt (ANSI). */
358 signal(SIGTERM
, sigterm_handler
); /* Termination (ANSI). */
360 signal(SIGXCPU
, sigterm_handler
);
364 /* read a key without blocking */
365 static int read_key(void)
377 n
= select(1, &rfds
, NULL
, NULL
, &tv
);
386 # if HAVE_PEEKNAMEDPIPE
388 static HANDLE input_handle
;
391 input_handle
= GetStdHandle(STD_INPUT_HANDLE
);
392 is_pipe
= !GetConsoleMode(input_handle
, &dw
);
395 if (stdin
->_cnt
> 0) {
400 /* When running under a GUI, you will end here. */
401 if (!PeekNamedPipe(input_handle
, NULL
, 0, NULL
, &nchars
, NULL
)) {
402 // input pipe may have been closed by the program that ran ffmpeg
420 static int decode_interrupt_cb(void *ctx
)
422 return received_nb_signals
> transcode_init_done
;
425 const AVIOInterruptCB int_cb
= { decode_interrupt_cb
, NULL
};
427 static void ffmpeg_cleanup(int ret
)
432 int maxrss
= getmaxrss() / 1024;
433 printf("bench: maxrss=%ikB\n", maxrss
);
436 for (i
= 0; i
< nb_filtergraphs
; i
++) {
437 FilterGraph
*fg
= filtergraphs
[i
];
438 avfilter_graph_free(&fg
->graph
);
439 for (j
= 0; j
< fg
->nb_inputs
; j
++) {
440 av_freep(&fg
->inputs
[j
]->name
);
441 av_freep(&fg
->inputs
[j
]);
443 av_freep(&fg
->inputs
);
444 for (j
= 0; j
< fg
->nb_outputs
; j
++) {
445 av_freep(&fg
->outputs
[j
]->name
);
446 av_freep(&fg
->outputs
[j
]);
448 av_freep(&fg
->outputs
);
449 av_freep(&fg
->graph_desc
);
451 av_freep(&filtergraphs
[i
]);
453 av_freep(&filtergraphs
);
455 av_freep(&subtitle_out
);
458 for (i
= 0; i
< nb_output_files
; i
++) {
459 OutputFile
*of
= output_files
[i
];
460 AVFormatContext
*s
= of
->ctx
;
461 if (s
&& s
->oformat
&& !(s
->oformat
->flags
& AVFMT_NOFILE
) && s
->pb
)
463 avformat_free_context(s
);
464 av_dict_free(&of
->opts
);
466 av_freep(&output_files
[i
]);
468 for (i
= 0; i
< nb_output_streams
; i
++) {
469 OutputStream
*ost
= output_streams
[i
];
470 AVBitStreamFilterContext
*bsfc
= ost
->bitstream_filters
;
472 AVBitStreamFilterContext
*next
= bsfc
->next
;
473 av_bitstream_filter_close(bsfc
);
476 ost
->bitstream_filters
= NULL
;
477 av_frame_free(&ost
->filtered_frame
);
478 av_frame_free(&ost
->last_frame
);
480 av_parser_close(ost
->parser
);
482 av_freep(&ost
->forced_keyframes
);
483 av_expr_free(ost
->forced_keyframes_pexpr
);
484 av_freep(&ost
->avfilter
);
485 av_freep(&ost
->logfile_prefix
);
487 av_freep(&ost
->audio_channels_map
);
488 ost
->audio_channels_mapped
= 0;
490 avcodec_free_context(&ost
->enc_ctx
);
492 av_freep(&output_streams
[i
]);
495 free_input_threads();
497 for (i
= 0; i
< nb_input_files
; i
++) {
498 avformat_close_input(&input_files
[i
]->ctx
);
499 av_freep(&input_files
[i
]);
501 for (i
= 0; i
< nb_input_streams
; i
++) {
502 InputStream
*ist
= input_streams
[i
];
504 av_frame_free(&ist
->decoded_frame
);
505 av_frame_free(&ist
->filter_frame
);
506 av_dict_free(&ist
->decoder_opts
);
507 avsubtitle_free(&ist
->prev_sub
.subtitle
);
508 av_frame_free(&ist
->sub2video
.frame
);
509 av_freep(&ist
->filters
);
510 av_freep(&ist
->hwaccel_device
);
512 avcodec_free_context(&ist
->dec_ctx
);
514 av_freep(&input_streams
[i
]);
519 av_free(vstats_filename
);
521 av_freep(&input_streams
);
522 av_freep(&input_files
);
523 av_freep(&output_streams
);
524 av_freep(&output_files
);
528 avformat_network_deinit();
530 if (received_sigterm
) {
531 av_log(NULL
, AV_LOG_INFO
, "Received signal %d: terminating.\n",
532 (int) received_sigterm
);
533 } else if (ret
&& transcode_init_done
) {
534 av_log(NULL
, AV_LOG_INFO
, "Conversion failed!\n");
539 void remove_avoptions(AVDictionary
**a
, AVDictionary
*b
)
541 AVDictionaryEntry
*t
= NULL
;
543 while ((t
= av_dict_get(b
, "", t
, AV_DICT_IGNORE_SUFFIX
))) {
544 av_dict_set(a
, t
->key
, NULL
, AV_DICT_MATCH_CASE
);
548 void assert_avoptions(AVDictionary
*m
)
550 AVDictionaryEntry
*t
;
551 if ((t
= av_dict_get(m
, "", NULL
, AV_DICT_IGNORE_SUFFIX
))) {
552 av_log(NULL
, AV_LOG_FATAL
, "Option %s not found.\n", t
->key
);
557 static void abort_codec_experimental(AVCodec
*c
, int encoder
)
562 static void update_benchmark(const char *fmt
, ...)
564 if (do_benchmark_all
) {
565 int64_t t
= getutime();
571 vsnprintf(buf
, sizeof(buf
), fmt
, va
);
573 printf("bench: %8"PRIu64
" %s \n", t
- current_time
, buf
);
579 static void close_all_output_streams(OutputStream
*ost
, OSTFinished this_stream
, OSTFinished others
)
582 for (i
= 0; i
< nb_output_streams
; i
++) {
583 OutputStream
*ost2
= output_streams
[i
];
584 ost2
->finished
|= ost
== ost2
? this_stream
: others
;
588 static void write_frame(AVFormatContext
*s
, AVPacket
*pkt
, OutputStream
*ost
)
590 AVBitStreamFilterContext
*bsfc
= ost
->bitstream_filters
;
591 AVCodecContext
*avctx
= ost
->st
->codec
;
594 if (!ost
->st
->codec
->extradata_size
&& ost
->enc_ctx
->extradata_size
) {
595 ost
->st
->codec
->extradata
= av_mallocz(ost
->enc_ctx
->extradata_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
596 if (ost
->st
->codec
->extradata
) {
597 memcpy(ost
->st
->codec
->extradata
, ost
->enc_ctx
->extradata
, ost
->enc_ctx
->extradata_size
);
598 ost
->st
->codec
->extradata_size
= ost
->enc_ctx
->extradata_size
;
602 if ((avctx
->codec_type
== AVMEDIA_TYPE_VIDEO
&& video_sync_method
== VSYNC_DROP
) ||
603 (avctx
->codec_type
== AVMEDIA_TYPE_AUDIO
&& audio_sync_method
< 0))
604 pkt
->pts
= pkt
->dts
= AV_NOPTS_VALUE
;
607 * Audio encoders may split the packets -- #frames in != #packets out.
608 * But there is no reordering, so we can limit the number of output packets
609 * by simply dropping them here.
610 * Counting encoded video frames needs to be done separately because of
611 * reordering, see do_video_out()
613 if (!(avctx
->codec_type
== AVMEDIA_TYPE_VIDEO
&& avctx
->codec
)) {
614 if (ost
->frame_number
>= ost
->max_frames
) {
622 av_packet_split_side_data(pkt
);
625 AVPacket new_pkt
= *pkt
;
626 AVDictionaryEntry
*bsf_arg
= av_dict_get(ost
->bsf_args
,
629 int a
= av_bitstream_filter_filter(bsfc
, avctx
,
630 bsf_arg
? bsf_arg
->value
: NULL
,
631 &new_pkt
.data
, &new_pkt
.size
,
632 pkt
->data
, pkt
->size
,
633 pkt
->flags
& AV_PKT_FLAG_KEY
);
634 if(a
== 0 && new_pkt
.data
!= pkt
->data
&& new_pkt
.destruct
) {
635 uint8_t *t
= av_malloc(new_pkt
.size
+ FF_INPUT_BUFFER_PADDING_SIZE
); //the new should be a subset of the old so cannot overflow
637 memcpy(t
, new_pkt
.data
, new_pkt
.size
);
638 memset(t
+ new_pkt
.size
, 0, FF_INPUT_BUFFER_PADDING_SIZE
);
646 pkt
->side_data
= NULL
;
647 pkt
->side_data_elems
= 0;
649 new_pkt
.buf
= av_buffer_create(new_pkt
.data
, new_pkt
.size
,
650 av_buffer_default_free
, NULL
, 0);
654 av_log(NULL
, AV_LOG_ERROR
, "Failed to open bitstream filter %s for stream %d with codec %s",
655 bsfc
->filter
->name
, pkt
->stream_index
,
656 avctx
->codec
? avctx
->codec
->name
: "copy");
666 if (!(s
->oformat
->flags
& AVFMT_NOTIMESTAMPS
)) {
667 if (pkt
->dts
!= AV_NOPTS_VALUE
&&
668 pkt
->pts
!= AV_NOPTS_VALUE
&&
669 pkt
->dts
> pkt
->pts
) {
670 av_log(s
, AV_LOG_WARNING
, "Invalid DTS: %"PRId64
" PTS: %"PRId64
" in output stream %d:%d, replacing by guess\n",
672 ost
->file_index
, ost
->st
->index
);
674 pkt
->dts
= pkt
->pts
+ pkt
->dts
+ ost
->last_mux_dts
+ 1
675 - FFMIN3(pkt
->pts
, pkt
->dts
, ost
->last_mux_dts
+ 1)
676 - FFMAX3(pkt
->pts
, pkt
->dts
, ost
->last_mux_dts
+ 1);
679 (avctx
->codec_type
== AVMEDIA_TYPE_AUDIO
|| avctx
->codec_type
== AVMEDIA_TYPE_VIDEO
) &&
680 pkt
->dts
!= AV_NOPTS_VALUE
&&
681 ost
->last_mux_dts
!= AV_NOPTS_VALUE
) {
682 int64_t max
= ost
->last_mux_dts
+ !(s
->oformat
->flags
& AVFMT_TS_NONSTRICT
);
683 if (pkt
->dts
< max
) {
684 int loglevel
= max
- pkt
->dts
> 2 || avctx
->codec_type
== AVMEDIA_TYPE_VIDEO
? AV_LOG_WARNING
: AV_LOG_DEBUG
;
685 av_log(s
, loglevel
, "Non-monotonous DTS in output stream "
686 "%d:%d; previous: %"PRId64
", current: %"PRId64
"; ",
687 ost
->file_index
, ost
->st
->index
, ost
->last_mux_dts
, pkt
->dts
);
689 av_log(NULL
, AV_LOG_FATAL
, "aborting.\n");
692 av_log(s
, loglevel
, "changing to %"PRId64
". This may result "
693 "in incorrect timestamps in the output file.\n",
695 if(pkt
->pts
>= pkt
->dts
)
696 pkt
->pts
= FFMAX(pkt
->pts
, max
);
701 ost
->last_mux_dts
= pkt
->dts
;
703 ost
->data_size
+= pkt
->size
;
704 ost
->packets_written
++;
706 pkt
->stream_index
= ost
->index
;
709 av_log(NULL
, AV_LOG_INFO
, "muxer <- type:%s "
710 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s size:%d\n",
711 av_get_media_type_string(ost
->enc_ctx
->codec_type
),
712 av_ts2str(pkt
->pts
), av_ts2timestr(pkt
->pts
, &ost
->st
->time_base
),
713 av_ts2str(pkt
->dts
), av_ts2timestr(pkt
->dts
, &ost
->st
->time_base
),
718 ret
= av_interleaved_write_frame(s
, pkt
);
720 print_error("av_interleaved_write_frame()", ret
);
721 main_return_code
= 1;
722 close_all_output_streams(ost
, MUXER_FINISHED
| ENCODER_FINISHED
, ENCODER_FINISHED
);
727 static void close_output_stream(OutputStream
*ost
)
729 OutputFile
*of
= output_files
[ost
->file_index
];
731 ost
->finished
|= ENCODER_FINISHED
;
733 int64_t end
= av_rescale_q(ost
->sync_opts
- ost
->first_pts
, ost
->enc_ctx
->time_base
, AV_TIME_BASE_Q
);
734 of
->recording_time
= FFMIN(of
->recording_time
, end
);
738 static int check_recording_time(OutputStream
*ost
)
740 OutputFile
*of
= output_files
[ost
->file_index
];
742 if (of
->recording_time
!= INT64_MAX
&&
743 av_compare_ts(ost
->sync_opts
- ost
->first_pts
, ost
->enc_ctx
->time_base
, of
->recording_time
,
744 AV_TIME_BASE_Q
) >= 0) {
745 close_output_stream(ost
);
751 static void do_audio_out(AVFormatContext
*s
, OutputStream
*ost
,
754 AVCodecContext
*enc
= ost
->enc_ctx
;
758 av_init_packet(&pkt
);
762 if (!check_recording_time(ost
))
765 if (frame
->pts
== AV_NOPTS_VALUE
|| audio_sync_method
< 0)
766 frame
->pts
= ost
->sync_opts
;
767 ost
->sync_opts
= frame
->pts
+ frame
->nb_samples
;
768 ost
->samples_encoded
+= frame
->nb_samples
;
769 ost
->frames_encoded
++;
771 av_assert0(pkt
.size
|| !pkt
.data
);
772 update_benchmark(NULL
);
774 av_log(NULL
, AV_LOG_INFO
, "encoder <- type:audio "
775 "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
776 av_ts2str(frame
->pts
), av_ts2timestr(frame
->pts
, &enc
->time_base
),
777 enc
->time_base
.num
, enc
->time_base
.den
);
780 if (avcodec_encode_audio2(enc
, &pkt
, frame
, &got_packet
) < 0) {
781 av_log(NULL
, AV_LOG_FATAL
, "Audio encoding failed (avcodec_encode_audio2)\n");
784 update_benchmark("encode_audio %d.%d", ost
->file_index
, ost
->index
);
787 av_packet_rescale_ts(&pkt
, enc
->time_base
, ost
->st
->time_base
);
790 av_log(NULL
, AV_LOG_INFO
, "encoder -> type:audio "
791 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
792 av_ts2str(pkt
.pts
), av_ts2timestr(pkt
.pts
, &ost
->st
->time_base
),
793 av_ts2str(pkt
.dts
), av_ts2timestr(pkt
.dts
, &ost
->st
->time_base
));
796 write_frame(s
, &pkt
, ost
);
800 static void do_subtitle_out(AVFormatContext
*s
,
805 int subtitle_out_max_size
= 1024 * 1024;
806 int subtitle_out_size
, nb
, i
;
811 if (sub
->pts
== AV_NOPTS_VALUE
) {
812 av_log(NULL
, AV_LOG_ERROR
, "Subtitle packets must have a pts\n");
821 subtitle_out
= av_malloc(subtitle_out_max_size
);
824 /* Note: DVB subtitle need one packet to draw them and one other
825 packet to clear them */
826 /* XXX: signal it in the codec context ? */
827 if (enc
->codec_id
== AV_CODEC_ID_DVB_SUBTITLE
)
832 /* shift timestamp to honor -ss and make check_recording_time() work with -t */
834 if (output_files
[ost
->file_index
]->start_time
!= AV_NOPTS_VALUE
)
835 pts
-= output_files
[ost
->file_index
]->start_time
;
836 for (i
= 0; i
< nb
; i
++) {
837 unsigned save_num_rects
= sub
->num_rects
;
839 ost
->sync_opts
= av_rescale_q(pts
, AV_TIME_BASE_Q
, enc
->time_base
);
840 if (!check_recording_time(ost
))
844 // start_display_time is required to be 0
845 sub
->pts
+= av_rescale_q(sub
->start_display_time
, (AVRational
){ 1, 1000 }, AV_TIME_BASE_Q
);
846 sub
->end_display_time
-= sub
->start_display_time
;
847 sub
->start_display_time
= 0;
851 ost
->frames_encoded
++;
853 subtitle_out_size
= avcodec_encode_subtitle(enc
, subtitle_out
,
854 subtitle_out_max_size
, sub
);
856 sub
->num_rects
= save_num_rects
;
857 if (subtitle_out_size
< 0) {
858 av_log(NULL
, AV_LOG_FATAL
, "Subtitle encoding failed\n");
862 av_init_packet(&pkt
);
863 pkt
.data
= subtitle_out
;
864 pkt
.size
= subtitle_out_size
;
865 pkt
.pts
= av_rescale_q(sub
->pts
, AV_TIME_BASE_Q
, ost
->st
->time_base
);
866 pkt
.duration
= av_rescale_q(sub
->end_display_time
, (AVRational
){ 1, 1000 }, ost
->st
->time_base
);
867 if (enc
->codec_id
== AV_CODEC_ID_DVB_SUBTITLE
) {
868 /* XXX: the pts correction is handled here. Maybe handling
869 it in the codec would be better */
871 pkt
.pts
+= 90 * sub
->start_display_time
;
873 pkt
.pts
+= 90 * sub
->end_display_time
;
876 write_frame(s
, &pkt
, ost
);
880 static void do_video_out(AVFormatContext
*s
,
882 AVFrame
*next_picture
)
884 int ret
, format_video_sync
;
886 AVCodecContext
*enc
= ost
->enc_ctx
;
887 AVCodecContext
*mux_enc
= ost
->st
->codec
;
888 int nb_frames
, nb0_frames
, i
;
889 double sync_ipts
, delta
, delta0
;
892 InputStream
*ist
= NULL
;
894 if (ost
->source_index
>= 0)
895 ist
= input_streams
[ost
->source_index
];
897 if(ist
&& ist
->st
->start_time
!= AV_NOPTS_VALUE
&& ist
->st
->first_dts
!= AV_NOPTS_VALUE
&& ost
->frame_rate
.num
)
898 duration
= 1/(av_q2d(ost
->frame_rate
) * av_q2d(enc
->time_base
));
900 if (!ost
->filters_script
&&
904 lrintf(av_frame_get_pkt_duration(next_picture
) * av_q2d(ist
->st
->time_base
) / av_q2d(enc
->time_base
)) > 0) {
905 duration
= lrintf(av_frame_get_pkt_duration(next_picture
) * av_q2d(ist
->st
->time_base
) / av_q2d(enc
->time_base
));
908 sync_ipts
= next_picture
->pts
;
909 delta0
= sync_ipts
- ost
->sync_opts
;
910 delta
= delta0
+ duration
;
912 /* by default, we output a single frame */
916 format_video_sync
= video_sync_method
;
917 if (format_video_sync
== VSYNC_AUTO
) {
918 if(!strcmp(s
->oformat
->name
, "avi")) {
919 format_video_sync
= VSYNC_VFR
;
921 format_video_sync
= (s
->oformat
->flags
& AVFMT_VARIABLE_FPS
) ? ((s
->oformat
->flags
& AVFMT_NOTIMESTAMPS
) ? VSYNC_PASSTHROUGH
: VSYNC_VFR
) : VSYNC_CFR
;
923 && format_video_sync
== VSYNC_CFR
924 && input_files
[ist
->file_index
]->ctx
->nb_streams
== 1
925 && input_files
[ist
->file_index
]->input_ts_offset
== 0) {
926 format_video_sync
= VSYNC_VSCFR
;
928 if (format_video_sync
== VSYNC_CFR
&& copy_ts
) {
929 format_video_sync
= VSYNC_VSCFR
;
935 format_video_sync
!= VSYNC_PASSTHROUGH
&&
936 format_video_sync
!= VSYNC_DROP
) {
937 double cor
= FFMIN(-delta0
, duration
);
938 av_log(NULL
, AV_LOG_WARNING
, "Past duration %f too large\n", -delta0
);
944 switch (format_video_sync
) {
946 if (ost
->frame_number
== 0 && delta
- duration
>= 0.5) {
947 av_log(NULL
, AV_LOG_DEBUG
, "Not duplicating %d initial frames\n", (int)lrintf(delta
- duration
));
950 ost
->sync_opts
= lrint(sync_ipts
);
953 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
956 else if (delta
> 1.1) {
957 nb_frames
= lrintf(delta
);
959 nb0_frames
= lrintf(delta0
- 0.6);
965 else if (delta
> 0.6)
966 ost
->sync_opts
= lrint(sync_ipts
);
969 case VSYNC_PASSTHROUGH
:
970 ost
->sync_opts
= lrint(sync_ipts
);
976 nb_frames
= FFMIN(nb_frames
, ost
->max_frames
- ost
->frame_number
);
977 nb0_frames
= FFMIN(nb0_frames
, nb_frames
);
978 if (nb0_frames
== 0 && ost
->last_droped
) {
980 av_log(NULL
, AV_LOG_VERBOSE
,
981 "*** dropping frame %d from stream %d at ts %"PRId64
"\n",
982 ost
->frame_number
, ost
->st
->index
, ost
->last_frame
->pts
);
984 if (nb_frames
> (nb0_frames
&& ost
->last_droped
) + (nb_frames
> nb0_frames
)) {
985 if (nb_frames
> dts_error_threshold
* 30) {
986 av_log(NULL
, AV_LOG_ERROR
, "%d frame duplication too large, skipping\n", nb_frames
- 1);
990 nb_frames_dup
+= nb_frames
- (nb0_frames
&& ost
->last_droped
) - (nb_frames
> nb0_frames
);
991 av_log(NULL
, AV_LOG_VERBOSE
, "*** %d dup!\n", nb_frames
- 1);
993 ost
->last_droped
= nb_frames
== nb0_frames
;
995 /* duplicates frame if needed */
996 for (i
= 0; i
< nb_frames
; i
++) {
998 av_init_packet(&pkt
);
1002 if (i
< nb0_frames
&& ost
->last_frame
) {
1003 in_picture
= ost
->last_frame
;
1005 in_picture
= next_picture
;
1007 in_picture
->pts
= ost
->sync_opts
;
1010 if (!check_recording_time(ost
))
1012 if (ost
->frame_number
>= ost
->max_frames
)
1016 if (s
->oformat
->flags
& AVFMT_RAWPICTURE
&&
1017 enc
->codec
->id
== AV_CODEC_ID_RAWVIDEO
) {
1018 /* raw pictures are written as AVPicture structure to
1019 avoid any copies. We support temporarily the older
1021 if (in_picture
->interlaced_frame
)
1022 mux_enc
->field_order
= in_picture
->top_field_first
? AV_FIELD_TB
:AV_FIELD_BT
;
1024 mux_enc
->field_order
= AV_FIELD_PROGRESSIVE
;
1025 pkt
.data
= (uint8_t *)in_picture
;
1026 pkt
.size
= sizeof(AVPicture
);
1027 pkt
.pts
= av_rescale_q(in_picture
->pts
, enc
->time_base
, ost
->st
->time_base
);
1028 pkt
.flags
|= AV_PKT_FLAG_KEY
;
1030 write_frame(s
, &pkt
, ost
);
1032 int got_packet
, forced_keyframe
= 0;
1035 if (enc
->flags
& (CODEC_FLAG_INTERLACED_DCT
|CODEC_FLAG_INTERLACED_ME
) &&
1036 ost
->top_field_first
>= 0)
1037 in_picture
->top_field_first
= !!ost
->top_field_first
;
1039 if (in_picture
->interlaced_frame
) {
1040 if (enc
->codec
->id
== AV_CODEC_ID_MJPEG
)
1041 mux_enc
->field_order
= in_picture
->top_field_first
? AV_FIELD_TT
:AV_FIELD_BB
;
1043 mux_enc
->field_order
= in_picture
->top_field_first
? AV_FIELD_TB
:AV_FIELD_BT
;
1045 mux_enc
->field_order
= AV_FIELD_PROGRESSIVE
;
1047 in_picture
->quality
= enc
->global_quality
;
1048 in_picture
->pict_type
= 0;
1050 pts_time
= in_picture
->pts
!= AV_NOPTS_VALUE
?
1051 in_picture
->pts
* av_q2d(enc
->time_base
) : NAN
;
1052 if (ost
->forced_kf_index
< ost
->forced_kf_count
&&
1053 in_picture
->pts
>= ost
->forced_kf_pts
[ost
->forced_kf_index
]) {
1054 ost
->forced_kf_index
++;
1055 forced_keyframe
= 1;
1056 } else if (ost
->forced_keyframes_pexpr
) {
1058 ost
->forced_keyframes_expr_const_values
[FKF_T
] = pts_time
;
1059 res
= av_expr_eval(ost
->forced_keyframes_pexpr
,
1060 ost
->forced_keyframes_expr_const_values
, NULL
);
1061 av_dlog(NULL
, "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",
1062 ost
->forced_keyframes_expr_const_values
[FKF_N
],
1063 ost
->forced_keyframes_expr_const_values
[FKF_N_FORCED
],
1064 ost
->forced_keyframes_expr_const_values
[FKF_PREV_FORCED_N
],
1065 ost
->forced_keyframes_expr_const_values
[FKF_T
],
1066 ost
->forced_keyframes_expr_const_values
[FKF_PREV_FORCED_T
],
1069 forced_keyframe
= 1;
1070 ost
->forced_keyframes_expr_const_values
[FKF_PREV_FORCED_N
] =
1071 ost
->forced_keyframes_expr_const_values
[FKF_N
];
1072 ost
->forced_keyframes_expr_const_values
[FKF_PREV_FORCED_T
] =
1073 ost
->forced_keyframes_expr_const_values
[FKF_T
];
1074 ost
->forced_keyframes_expr_const_values
[FKF_N_FORCED
] += 1;
1077 ost
->forced_keyframes_expr_const_values
[FKF_N
] += 1;
1080 if (forced_keyframe
) {
1081 in_picture
->pict_type
= AV_PICTURE_TYPE_I
;
1082 av_log(NULL
, AV_LOG_DEBUG
, "Forced keyframe at time %f\n", pts_time
);
1085 update_benchmark(NULL
);
1087 av_log(NULL
, AV_LOG_INFO
, "encoder <- type:video "
1088 "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
1089 av_ts2str(in_picture
->pts
), av_ts2timestr(in_picture
->pts
, &enc
->time_base
),
1090 enc
->time_base
.num
, enc
->time_base
.den
);
1093 ost
->frames_encoded
++;
1095 ret
= avcodec_encode_video2(enc
, &pkt
, in_picture
, &got_packet
);
1096 update_benchmark("encode_video %d.%d", ost
->file_index
, ost
->index
);
1098 av_log(NULL
, AV_LOG_FATAL
, "Video encoding failed\n");
1104 av_log(NULL
, AV_LOG_INFO
, "encoder -> type:video "
1105 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1106 av_ts2str(pkt
.pts
), av_ts2timestr(pkt
.pts
, &enc
->time_base
),
1107 av_ts2str(pkt
.dts
), av_ts2timestr(pkt
.dts
, &enc
->time_base
));
1110 if (pkt
.pts
== AV_NOPTS_VALUE
&& !(enc
->codec
->capabilities
& CODEC_CAP_DELAY
))
1111 pkt
.pts
= ost
->sync_opts
;
1113 av_packet_rescale_ts(&pkt
, enc
->time_base
, ost
->st
->time_base
);
1116 av_log(NULL
, AV_LOG_INFO
, "encoder -> type:video "
1117 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1118 av_ts2str(pkt
.pts
), av_ts2timestr(pkt
.pts
, &ost
->st
->time_base
),
1119 av_ts2str(pkt
.dts
), av_ts2timestr(pkt
.dts
, &ost
->st
->time_base
));
1122 frame_size
= pkt
.size
;
1123 write_frame(s
, &pkt
, ost
);
1125 /* if two pass, output log */
1126 if (ost
->logfile
&& enc
->stats_out
) {
1127 fprintf(ost
->logfile
, "%s", enc
->stats_out
);
1133 * For video, number of frames in == number of packets out.
1134 * But there may be reordering, so we can't throw away frames on encoder
1135 * flush, we need to limit them here, before they go into encoder.
1137 ost
->frame_number
++;
1139 if (vstats_filename
&& frame_size
)
1140 do_video_stats(ost
, frame_size
);
1143 if (!ost
->last_frame
)
1144 ost
->last_frame
= av_frame_alloc();
1145 av_frame_unref(ost
->last_frame
);
1146 av_frame_ref(ost
->last_frame
, next_picture
);
1149 static double psnr(double d
)
1151 return -10.0 * log(d
) / log(10.0);
1154 static void do_video_stats(OutputStream
*ost
, int frame_size
)
1156 AVCodecContext
*enc
;
1158 double ti1
, bitrate
, avg_bitrate
;
1160 /* this is executed just the first time do_video_stats is called */
1162 vstats_file
= fopen(vstats_filename
, "w");
1170 if (enc
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
1171 frame_number
= ost
->st
->nb_frames
;
1172 fprintf(vstats_file
, "frame= %5d q= %2.1f ", frame_number
, enc
->coded_frame
->quality
/ (float)FF_QP2LAMBDA
);
1173 if (enc
->flags
&CODEC_FLAG_PSNR
)
1174 fprintf(vstats_file
, "PSNR= %6.2f ", psnr(enc
->coded_frame
->error
[0] / (enc
->width
* enc
->height
* 255.0 * 255.0)));
1176 fprintf(vstats_file
,"f_size= %6d ", frame_size
);
1177 /* compute pts value */
1178 ti1
= av_stream_get_end_pts(ost
->st
) * av_q2d(ost
->st
->time_base
);
1182 bitrate
= (frame_size
* 8) / av_q2d(enc
->time_base
) / 1000.0;
1183 avg_bitrate
= (double)(ost
->data_size
* 8) / ti1
/ 1000.0;
1184 fprintf(vstats_file
, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1185 (double)ost
->data_size
/ 1024, ti1
, bitrate
, avg_bitrate
);
1186 fprintf(vstats_file
, "type= %c\n", av_get_picture_type_char(enc
->coded_frame
->pict_type
));
1190 static void finish_output_stream(OutputStream
*ost
)
1192 OutputFile
*of
= output_files
[ost
->file_index
];
1195 ost
->finished
= ENCODER_FINISHED
| MUXER_FINISHED
;
1198 for (i
= 0; i
< of
->ctx
->nb_streams
; i
++)
1199 output_streams
[of
->ost_index
+ i
]->finished
= ENCODER_FINISHED
| MUXER_FINISHED
;
1204 * Get and encode new output from any of the filtergraphs, without causing
1207 * @return 0 for success, <0 for severe errors
1209 static int reap_filters(void)
1211 AVFrame
*filtered_frame
= NULL
;
1215 /* Reap all buffers present in the buffer sinks */
1216 for (i
= 0; i
< nb_output_streams
; i
++) {
1217 OutputStream
*ost
= output_streams
[i
];
1218 OutputFile
*of
= output_files
[ost
->file_index
];
1219 AVFilterContext
*filter
;
1220 AVCodecContext
*enc
= ost
->enc_ctx
;
1225 filter
= ost
->filter
->filter
;
1227 if (!ost
->filtered_frame
&& !(ost
->filtered_frame
= av_frame_alloc())) {
1228 return AVERROR(ENOMEM
);
1230 filtered_frame
= ost
->filtered_frame
;
1233 ret
= av_buffersink_get_frame_flags(filter
, filtered_frame
,
1234 AV_BUFFERSINK_FLAG_NO_REQUEST
);
1236 if (ret
!= AVERROR(EAGAIN
) && ret
!= AVERROR_EOF
) {
1237 av_log(NULL
, AV_LOG_WARNING
,
1238 "Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret
));
1242 if (ost
->finished
) {
1243 av_frame_unref(filtered_frame
);
1246 frame_pts
= AV_NOPTS_VALUE
;
1247 if (filtered_frame
->pts
!= AV_NOPTS_VALUE
) {
1248 int64_t start_time
= (of
->start_time
== AV_NOPTS_VALUE
) ? 0 : of
->start_time
;
1249 filtered_frame
->pts
= frame_pts
=
1250 av_rescale_q(filtered_frame
->pts
, filter
->inputs
[0]->time_base
, enc
->time_base
) -
1251 av_rescale_q(start_time
, AV_TIME_BASE_Q
, enc
->time_base
);
1253 //if (ost->source_index >= 0)
1254 // *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
1256 switch (filter
->inputs
[0]->type
) {
1257 case AVMEDIA_TYPE_VIDEO
:
1258 filtered_frame
->pts
= frame_pts
;
1259 if (!ost
->frame_aspect_ratio
.num
)
1260 enc
->sample_aspect_ratio
= filtered_frame
->sample_aspect_ratio
;
1263 av_log(NULL
, AV_LOG_INFO
, "filter -> pts:%s pts_time:%s time_base:%d/%d\n",
1264 av_ts2str(filtered_frame
->pts
), av_ts2timestr(filtered_frame
->pts
, &enc
->time_base
),
1265 enc
->time_base
.num
, enc
->time_base
.den
);
1268 do_video_out(of
->ctx
, ost
, filtered_frame
);
1270 case AVMEDIA_TYPE_AUDIO
:
1271 filtered_frame
->pts
= frame_pts
;
1272 if (!(enc
->codec
->capabilities
& CODEC_CAP_PARAM_CHANGE
) &&
1273 enc
->channels
!= av_frame_get_channels(filtered_frame
)) {
1274 av_log(NULL
, AV_LOG_ERROR
,
1275 "Audio filter graph output is not normalized and encoder does not support parameter changes\n");
1278 do_audio_out(of
->ctx
, ost
, filtered_frame
);
1281 // TODO support subtitle filters
1285 av_frame_unref(filtered_frame
);
1292 static void print_final_stats(int64_t total_size
)
1294 uint64_t video_size
= 0, audio_size
= 0, extra_size
= 0, other_size
= 0;
1295 uint64_t subtitle_size
= 0;
1296 uint64_t data_size
= 0;
1297 float percent
= -1.0;
1300 for (i
= 0; i
< nb_output_streams
; i
++) {
1301 OutputStream
*ost
= output_streams
[i
];
1302 switch (ost
->enc_ctx
->codec_type
) {
1303 case AVMEDIA_TYPE_VIDEO
: video_size
+= ost
->data_size
; break;
1304 case AVMEDIA_TYPE_AUDIO
: audio_size
+= ost
->data_size
; break;
1305 case AVMEDIA_TYPE_SUBTITLE
: subtitle_size
+= ost
->data_size
; break;
1306 default: other_size
+= ost
->data_size
; break;
1308 extra_size
+= ost
->enc_ctx
->extradata_size
;
1309 data_size
+= ost
->data_size
;
1312 if (data_size
&& total_size
>0 && total_size
>= data_size
)
1313 percent
= 100.0 * (total_size
- data_size
) / data_size
;
1315 av_log(NULL
, AV_LOG_INFO
, "video:%1.0fkB audio:%1.0fkB subtitle:%1.0fkB other streams:%1.0fkB global headers:%1.0fkB muxing overhead: ",
1316 video_size
/ 1024.0,
1317 audio_size
/ 1024.0,
1318 subtitle_size
/ 1024.0,
1319 other_size
/ 1024.0,
1320 extra_size
/ 1024.0);
1322 av_log(NULL
, AV_LOG_INFO
, "%f%%", percent
);
1324 av_log(NULL
, AV_LOG_INFO
, "unknown");
1325 av_log(NULL
, AV_LOG_INFO
, "\n");
1327 /* print verbose per-stream stats */
1328 for (i
= 0; i
< nb_input_files
; i
++) {
1329 InputFile
*f
= input_files
[i
];
1330 uint64_t total_packets
= 0, total_size
= 0;
1332 av_log(NULL
, AV_LOG_VERBOSE
, "Input file #%d (%s):\n",
1333 i
, f
->ctx
->filename
);
1335 for (j
= 0; j
< f
->nb_streams
; j
++) {
1336 InputStream
*ist
= input_streams
[f
->ist_index
+ j
];
1337 enum AVMediaType type
= ist
->dec_ctx
->codec_type
;
1339 total_size
+= ist
->data_size
;
1340 total_packets
+= ist
->nb_packets
;
1342 av_log(NULL
, AV_LOG_VERBOSE
, " Input stream #%d:%d (%s): ",
1343 i
, j
, media_type_string(type
));
1344 av_log(NULL
, AV_LOG_VERBOSE
, "%"PRIu64
" packets read (%"PRIu64
" bytes); ",
1345 ist
->nb_packets
, ist
->data_size
);
1347 if (ist
->decoding_needed
) {
1348 av_log(NULL
, AV_LOG_VERBOSE
, "%"PRIu64
" frames decoded",
1349 ist
->frames_decoded
);
1350 if (type
== AVMEDIA_TYPE_AUDIO
)
1351 av_log(NULL
, AV_LOG_VERBOSE
, " (%"PRIu64
" samples)", ist
->samples_decoded
);
1352 av_log(NULL
, AV_LOG_VERBOSE
, "; ");
1355 av_log(NULL
, AV_LOG_VERBOSE
, "\n");
1358 av_log(NULL
, AV_LOG_VERBOSE
, " Total: %"PRIu64
" packets (%"PRIu64
" bytes) demuxed\n",
1359 total_packets
, total_size
);
1362 for (i
= 0; i
< nb_output_files
; i
++) {
1363 OutputFile
*of
= output_files
[i
];
1364 uint64_t total_packets
= 0, total_size
= 0;
1366 av_log(NULL
, AV_LOG_VERBOSE
, "Output file #%d (%s):\n",
1367 i
, of
->ctx
->filename
);
1369 for (j
= 0; j
< of
->ctx
->nb_streams
; j
++) {
1370 OutputStream
*ost
= output_streams
[of
->ost_index
+ j
];
1371 enum AVMediaType type
= ost
->enc_ctx
->codec_type
;
1373 total_size
+= ost
->data_size
;
1374 total_packets
+= ost
->packets_written
;
1376 av_log(NULL
, AV_LOG_VERBOSE
, " Output stream #%d:%d (%s): ",
1377 i
, j
, media_type_string(type
));
1378 if (ost
->encoding_needed
) {
1379 av_log(NULL
, AV_LOG_VERBOSE
, "%"PRIu64
" frames encoded",
1380 ost
->frames_encoded
);
1381 if (type
== AVMEDIA_TYPE_AUDIO
)
1382 av_log(NULL
, AV_LOG_VERBOSE
, " (%"PRIu64
" samples)", ost
->samples_encoded
);
1383 av_log(NULL
, AV_LOG_VERBOSE
, "; ");
1386 av_log(NULL
, AV_LOG_VERBOSE
, "%"PRIu64
" packets muxed (%"PRIu64
" bytes); ",
1387 ost
->packets_written
, ost
->data_size
);
1389 av_log(NULL
, AV_LOG_VERBOSE
, "\n");
1392 av_log(NULL
, AV_LOG_VERBOSE
, " Total: %"PRIu64
" packets (%"PRIu64
" bytes) muxed\n",
1393 total_packets
, total_size
);
1395 if(video_size
+ data_size
+ audio_size
+ subtitle_size
+ extra_size
== 0){
1396 av_log(NULL
, AV_LOG_WARNING
, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
1400 static void print_report(int is_last_report
, int64_t timer_start
, int64_t cur_time
)
1403 AVBPrint buf_script
;
1405 AVFormatContext
*oc
;
1407 AVCodecContext
*enc
;
1408 int frame_number
, vid
, i
;
1410 int64_t pts
= INT64_MIN
;
1411 static int64_t last_time
= -1;
1412 static int qp_histogram
[52];
1413 int hours
, mins
, secs
, us
;
1415 if (!print_stats
&& !is_last_report
&& !progress_avio
)
1418 if (!is_last_report
) {
1419 if (last_time
== -1) {
1420 last_time
= cur_time
;
1423 if ((cur_time
- last_time
) < 500000)
1425 last_time
= cur_time
;
1429 oc
= output_files
[0]->ctx
;
1431 total_size
= avio_size(oc
->pb
);
1432 if (total_size
<= 0) // FIXME improve avio_size() so it works with non seekable output too
1433 total_size
= avio_tell(oc
->pb
);
1437 av_bprint_init(&buf_script
, 0, 1);
1438 for (i
= 0; i
< nb_output_streams
; i
++) {
1440 ost
= output_streams
[i
];
1442 if (!ost
->stream_copy
&& enc
->coded_frame
)
1443 q
= enc
->coded_frame
->quality
/ (float)FF_QP2LAMBDA
;
1444 if (vid
&& enc
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
1445 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "q=%2.1f ", q
);
1446 av_bprintf(&buf_script
, "stream_%d_%d_q=%.1f\n",
1447 ost
->file_index
, ost
->index
, q
);
1449 if (!vid
&& enc
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
1450 float fps
, t
= (cur_time
-timer_start
) / 1000000.0;
1452 frame_number
= ost
->frame_number
;
1453 fps
= t
> 1 ? frame_number
/ t
: 0;
1454 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "frame=%5d fps=%3.*f q=%3.1f ",
1455 frame_number
, fps
< 9.95, fps
, q
);
1456 av_bprintf(&buf_script
, "frame=%d\n", frame_number
);
1457 av_bprintf(&buf_script
, "fps=%.1f\n", fps
);
1458 av_bprintf(&buf_script
, "stream_%d_%d_q=%.1f\n",
1459 ost
->file_index
, ost
->index
, q
);
1461 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "L");
1465 if (qp
>= 0 && qp
< FF_ARRAY_ELEMS(qp_histogram
))
1467 for (j
= 0; j
< 32; j
++)
1468 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "%X", (int)lrintf(log2(qp_histogram
[j
] + 1)));
1470 if ((enc
->flags
&CODEC_FLAG_PSNR
) && (enc
->coded_frame
|| is_last_report
)) {
1472 double error
, error_sum
= 0;
1473 double scale
, scale_sum
= 0;
1475 char type
[3] = { 'Y','U','V' };
1476 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "PSNR=");
1477 for (j
= 0; j
< 3; j
++) {
1478 if (is_last_report
) {
1479 error
= enc
->error
[j
];
1480 scale
= enc
->width
* enc
->height
* 255.0 * 255.0 * frame_number
;
1482 error
= enc
->coded_frame
->error
[j
];
1483 scale
= enc
->width
* enc
->height
* 255.0 * 255.0;
1489 p
= psnr(error
/ scale
);
1490 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "%c:%2.2f ", type
[j
], p
);
1491 av_bprintf(&buf_script
, "stream_%d_%d_psnr_%c=%2.2f\n",
1492 ost
->file_index
, ost
->index
, type
[j
] | 32, p
);
1494 p
= psnr(error_sum
/ scale_sum
);
1495 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "*:%2.2f ", psnr(error_sum
/ scale_sum
));
1496 av_bprintf(&buf_script
, "stream_%d_%d_psnr_all=%2.2f\n",
1497 ost
->file_index
, ost
->index
, p
);
1501 /* compute min output value */
1502 if (av_stream_get_end_pts(ost
->st
) != AV_NOPTS_VALUE
)
1503 pts
= FFMAX(pts
, av_rescale_q(av_stream_get_end_pts(ost
->st
),
1504 ost
->st
->time_base
, AV_TIME_BASE_Q
));
1506 nb_frames_drop
+= ost
->last_droped
;
1509 secs
= pts
/ AV_TIME_BASE
;
1510 us
= pts
% AV_TIME_BASE
;
1516 bitrate
= pts
&& total_size
>= 0 ? total_size
* 8 / (pts
/ 1000.0) : -1;
1518 if (total_size
< 0) snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
1520 else snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
1521 "size=%8.0fkB time=", total_size
/ 1024.0);
1522 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
1523 "%02d:%02d:%02d.%02d ", hours
, mins
, secs
,
1524 (100 * us
) / AV_TIME_BASE
);
1525 if (bitrate
< 0) snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
1527 else snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
1528 "bitrate=%6.1fkbits/s", bitrate
);
1529 if (total_size
< 0) av_bprintf(&buf_script
, "total_size=N/A\n");
1530 else av_bprintf(&buf_script
, "total_size=%"PRId64
"\n", total_size
);
1531 av_bprintf(&buf_script
, "out_time_ms=%"PRId64
"\n", pts
);
1532 av_bprintf(&buf_script
, "out_time=%02d:%02d:%02d.%06d\n",
1533 hours
, mins
, secs
, us
);
1535 if (nb_frames_dup
|| nb_frames_drop
)
1536 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), " dup=%d drop=%d",
1537 nb_frames_dup
, nb_frames_drop
);
1538 av_bprintf(&buf_script
, "dup_frames=%d\n", nb_frames_dup
);
1539 av_bprintf(&buf_script
, "drop_frames=%d\n", nb_frames_drop
);
1541 if (print_stats
|| is_last_report
) {
1542 const char end
= is_last_report
? '\n' : '\r';
1543 if (print_stats
==1 && AV_LOG_INFO
> av_log_get_level()) {
1544 fprintf(stderr
, "%s %c", buf
, end
);
1546 av_log(NULL
, AV_LOG_INFO
, "%s %c", buf
, end
);
1551 if (progress_avio
) {
1552 av_bprintf(&buf_script
, "progress=%s\n",
1553 is_last_report
? "end" : "continue");
1554 avio_write(progress_avio
, buf_script
.str
,
1555 FFMIN(buf_script
.len
, buf_script
.size
- 1));
1556 avio_flush(progress_avio
);
1557 av_bprint_finalize(&buf_script
, NULL
);
1558 if (is_last_report
) {
1559 avio_close(progress_avio
);
1560 progress_avio
= NULL
;
1565 print_final_stats(total_size
);
1568 static void flush_encoders(void)
1572 for (i
= 0; i
< nb_output_streams
; i
++) {
1573 OutputStream
*ost
= output_streams
[i
];
1574 AVCodecContext
*enc
= ost
->enc_ctx
;
1575 AVFormatContext
*os
= output_files
[ost
->file_index
]->ctx
;
1576 int stop_encoding
= 0;
1578 if (!ost
->encoding_needed
)
1581 if (enc
->codec_type
== AVMEDIA_TYPE_AUDIO
&& enc
->frame_size
<= 1)
1583 if (enc
->codec_type
== AVMEDIA_TYPE_VIDEO
&& (os
->oformat
->flags
& AVFMT_RAWPICTURE
) && enc
->codec
->id
== AV_CODEC_ID_RAWVIDEO
)
1587 int (*encode
)(AVCodecContext
*, AVPacket
*, const AVFrame
*, int*) = NULL
;
1590 switch (enc
->codec_type
) {
1591 case AVMEDIA_TYPE_AUDIO
:
1592 encode
= avcodec_encode_audio2
;
1595 case AVMEDIA_TYPE_VIDEO
:
1596 encode
= avcodec_encode_video2
;
1607 av_init_packet(&pkt
);
1611 update_benchmark(NULL
);
1612 ret
= encode(enc
, &pkt
, NULL
, &got_packet
);
1613 update_benchmark("flush %s %d.%d", desc
, ost
->file_index
, ost
->index
);
1615 av_log(NULL
, AV_LOG_FATAL
, "%s encoding failed\n", desc
);
1618 if (ost
->logfile
&& enc
->stats_out
) {
1619 fprintf(ost
->logfile
, "%s", enc
->stats_out
);
1625 if (ost
->finished
& MUXER_FINISHED
) {
1626 av_free_packet(&pkt
);
1629 av_packet_rescale_ts(&pkt
, enc
->time_base
, ost
->st
->time_base
);
1630 pkt_size
= pkt
.size
;
1631 write_frame(os
, &pkt
, ost
);
1632 if (ost
->enc_ctx
->codec_type
== AVMEDIA_TYPE_VIDEO
&& vstats_filename
) {
1633 do_video_stats(ost
, pkt_size
);
1644 * Check whether a packet from ist should be written into ost at this time
1646 static int check_output_constraints(InputStream
*ist
, OutputStream
*ost
)
1648 OutputFile
*of
= output_files
[ost
->file_index
];
1649 int ist_index
= input_files
[ist
->file_index
]->ist_index
+ ist
->st
->index
;
1651 if (ost
->source_index
!= ist_index
)
1657 if (of
->start_time
!= AV_NOPTS_VALUE
&& ist
->pts
< of
->start_time
)
1663 static void do_streamcopy(InputStream
*ist
, OutputStream
*ost
, const AVPacket
*pkt
)
1665 OutputFile
*of
= output_files
[ost
->file_index
];
1666 InputFile
*f
= input_files
[ist
->file_index
];
1667 int64_t start_time
= (of
->start_time
== AV_NOPTS_VALUE
) ? 0 : of
->start_time
;
1668 int64_t ost_tb_start_time
= av_rescale_q(start_time
, AV_TIME_BASE_Q
, ost
->st
->time_base
);
1669 int64_t ist_tb_start_time
= av_rescale_q(start_time
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
1673 av_init_packet(&opkt
);
1675 if ((!ost
->frame_number
&& !(pkt
->flags
& AV_PKT_FLAG_KEY
)) &&
1676 !ost
->copy_initial_nonkeyframes
)
1679 if (pkt
->pts
== AV_NOPTS_VALUE
) {
1680 if (!ost
->frame_number
&& ist
->pts
< start_time
&&
1681 !ost
->copy_prior_start
)
1684 if (!ost
->frame_number
&& pkt
->pts
< ist_tb_start_time
&&
1685 !ost
->copy_prior_start
)
1689 if (of
->recording_time
!= INT64_MAX
&&
1690 ist
->pts
>= of
->recording_time
+ start_time
) {
1691 close_output_stream(ost
);
1695 if (f
->recording_time
!= INT64_MAX
) {
1696 start_time
= f
->ctx
->start_time
;
1697 if (f
->start_time
!= AV_NOPTS_VALUE
)
1698 start_time
+= f
->start_time
;
1699 if (ist
->pts
>= f
->recording_time
+ start_time
) {
1700 close_output_stream(ost
);
1705 /* force the input stream PTS */
1706 if (ost
->enc_ctx
->codec_type
== AVMEDIA_TYPE_VIDEO
)
1709 if (pkt
->pts
!= AV_NOPTS_VALUE
)
1710 opkt
.pts
= av_rescale_q(pkt
->pts
, ist
->st
->time_base
, ost
->st
->time_base
) - ost_tb_start_time
;
1712 opkt
.pts
= AV_NOPTS_VALUE
;
1714 if (pkt
->dts
== AV_NOPTS_VALUE
)
1715 opkt
.dts
= av_rescale_q(ist
->dts
, AV_TIME_BASE_Q
, ost
->st
->time_base
);
1717 opkt
.dts
= av_rescale_q(pkt
->dts
, ist
->st
->time_base
, ost
->st
->time_base
);
1718 opkt
.dts
-= ost_tb_start_time
;
1720 if (ost
->st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
&& pkt
->dts
!= AV_NOPTS_VALUE
) {
1721 int duration
= av_get_audio_frame_duration(ist
->dec_ctx
, pkt
->size
);
1723 duration
= ist
->dec_ctx
->frame_size
;
1724 opkt
.dts
= opkt
.pts
= av_rescale_delta(ist
->st
->time_base
, pkt
->dts
,
1725 (AVRational
){1, ist
->dec_ctx
->sample_rate
}, duration
, &ist
->filter_in_rescale_delta_last
,
1726 ost
->st
->time_base
) - ost_tb_start_time
;
1729 opkt
.duration
= av_rescale_q(pkt
->duration
, ist
->st
->time_base
, ost
->st
->time_base
);
1730 opkt
.flags
= pkt
->flags
;
1732 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1733 if ( ost
->enc_ctx
->codec_id
!= AV_CODEC_ID_H264
1734 && ost
->enc_ctx
->codec_id
!= AV_CODEC_ID_MPEG1VIDEO
1735 && ost
->enc_ctx
->codec_id
!= AV_CODEC_ID_MPEG2VIDEO
1736 && ost
->enc_ctx
->codec_id
!= AV_CODEC_ID_VC1
1738 if (av_parser_change(ost
->parser
, ost
->st
->codec
,
1739 &opkt
.data
, &opkt
.size
,
1740 pkt
->data
, pkt
->size
,
1741 pkt
->flags
& AV_PKT_FLAG_KEY
)) {
1742 opkt
.buf
= av_buffer_create(opkt
.data
, opkt
.size
, av_buffer_default_free
, NULL
, 0);
1747 opkt
.data
= pkt
->data
;
1748 opkt
.size
= pkt
->size
;
1750 av_copy_packet_side_data(&opkt
, pkt
);
1752 if (ost
->st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
&& (of
->ctx
->oformat
->flags
& AVFMT_RAWPICTURE
)) {
1753 /* store AVPicture in AVPacket, as expected by the output format */
1754 avpicture_fill(&pict
, opkt
.data
, ost
->st
->codec
->pix_fmt
, ost
->st
->codec
->width
, ost
->st
->codec
->height
);
1755 opkt
.data
= (uint8_t *)&pict
;
1756 opkt
.size
= sizeof(AVPicture
);
1757 opkt
.flags
|= AV_PKT_FLAG_KEY
;
1760 write_frame(of
->ctx
, &opkt
, ost
);
1763 int guess_input_channel_layout(InputStream
*ist
)
1765 AVCodecContext
*dec
= ist
->dec_ctx
;
1767 if (!dec
->channel_layout
) {
1768 char layout_name
[256];
1770 if (dec
->channels
> ist
->guess_layout_max
)
1772 dec
->channel_layout
= av_get_default_channel_layout(dec
->channels
);
1773 if (!dec
->channel_layout
)
1775 av_get_channel_layout_string(layout_name
, sizeof(layout_name
),
1776 dec
->channels
, dec
->channel_layout
);
1777 av_log(NULL
, AV_LOG_WARNING
, "Guessed Channel Layout for Input Stream "
1778 "#%d.%d : %s\n", ist
->file_index
, ist
->st
->index
, layout_name
);
1783 static int decode_audio(InputStream
*ist
, AVPacket
*pkt
, int *got_output
)
1785 AVFrame
*decoded_frame
, *f
;
1786 AVCodecContext
*avctx
= ist
->dec_ctx
;
1787 int i
, ret
, err
= 0, resample_changed
;
1788 AVRational decoded_frame_tb
;
1790 if (!ist
->decoded_frame
&& !(ist
->decoded_frame
= av_frame_alloc()))
1791 return AVERROR(ENOMEM
);
1792 if (!ist
->filter_frame
&& !(ist
->filter_frame
= av_frame_alloc()))
1793 return AVERROR(ENOMEM
);
1794 decoded_frame
= ist
->decoded_frame
;
1796 update_benchmark(NULL
);
1797 ret
= avcodec_decode_audio4(avctx
, decoded_frame
, got_output
, pkt
);
1798 update_benchmark("decode_audio %d.%d", ist
->file_index
, ist
->st
->index
);
1800 if (ret
>= 0 && avctx
->sample_rate
<= 0) {
1801 av_log(avctx
, AV_LOG_ERROR
, "Sample rate %d invalid\n", avctx
->sample_rate
);
1802 ret
= AVERROR_INVALIDDATA
;
1805 if (*got_output
|| ret
<0 || pkt
->size
)
1806 decode_error_stat
[ret
<0] ++;
1808 if (!*got_output
|| ret
< 0) {
1810 for (i
= 0; i
< ist
->nb_filters
; i
++)
1812 av_buffersrc_add_ref(ist
->filters
[i
]->filter
, NULL
, 0);
1814 av_buffersrc_add_frame(ist
->filters
[i
]->filter
, NULL
);
1820 ist
->samples_decoded
+= decoded_frame
->nb_samples
;
1821 ist
->frames_decoded
++;
1824 /* increment next_dts to use for the case where the input stream does not
1825 have timestamps or there are multiple frames in the packet */
1826 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
* decoded_frame
->nb_samples
) /
1828 ist
->next_dts
+= ((int64_t)AV_TIME_BASE
* decoded_frame
->nb_samples
) /
1832 resample_changed
= ist
->resample_sample_fmt
!= decoded_frame
->format
||
1833 ist
->resample_channels
!= avctx
->channels
||
1834 ist
->resample_channel_layout
!= decoded_frame
->channel_layout
||
1835 ist
->resample_sample_rate
!= decoded_frame
->sample_rate
;
1836 if (resample_changed
) {
1837 char layout1
[64], layout2
[64];
1839 if (!guess_input_channel_layout(ist
)) {
1840 av_log(NULL
, AV_LOG_FATAL
, "Unable to find default channel "
1841 "layout for Input Stream #%d.%d\n", ist
->file_index
,
1845 decoded_frame
->channel_layout
= avctx
->channel_layout
;
1847 av_get_channel_layout_string(layout1
, sizeof(layout1
), ist
->resample_channels
,
1848 ist
->resample_channel_layout
);
1849 av_get_channel_layout_string(layout2
, sizeof(layout2
), avctx
->channels
,
1850 decoded_frame
->channel_layout
);
1852 av_log(NULL
, AV_LOG_INFO
,
1853 "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:%s to rate:%d fmt:%s ch:%d chl:%s\n",
1854 ist
->file_index
, ist
->st
->index
,
1855 ist
->resample_sample_rate
, av_get_sample_fmt_name(ist
->resample_sample_fmt
),
1856 ist
->resample_channels
, layout1
,
1857 decoded_frame
->sample_rate
, av_get_sample_fmt_name(decoded_frame
->format
),
1858 avctx
->channels
, layout2
);
1860 ist
->resample_sample_fmt
= decoded_frame
->format
;
1861 ist
->resample_sample_rate
= decoded_frame
->sample_rate
;
1862 ist
->resample_channel_layout
= decoded_frame
->channel_layout
;
1863 ist
->resample_channels
= avctx
->channels
;
1865 for (i
= 0; i
< nb_filtergraphs
; i
++)
1866 if (ist_in_filtergraph(filtergraphs
[i
], ist
)) {
1867 FilterGraph
*fg
= filtergraphs
[i
];
1868 if (configure_filtergraph(fg
) < 0) {
1869 av_log(NULL
, AV_LOG_FATAL
, "Error reinitializing filters!\n");
1875 /* if the decoder provides a pts, use it instead of the last packet pts.
1876 the decoder could be delaying output by a packet or more. */
1877 if (decoded_frame
->pts
!= AV_NOPTS_VALUE
) {
1878 ist
->dts
= ist
->next_dts
= ist
->pts
= ist
->next_pts
= av_rescale_q(decoded_frame
->pts
, avctx
->time_base
, AV_TIME_BASE_Q
);
1879 decoded_frame_tb
= avctx
->time_base
;
1880 } else if (decoded_frame
->pkt_pts
!= AV_NOPTS_VALUE
) {
1881 decoded_frame
->pts
= decoded_frame
->pkt_pts
;
1882 decoded_frame_tb
= ist
->st
->time_base
;
1883 } else if (pkt
->pts
!= AV_NOPTS_VALUE
) {
1884 decoded_frame
->pts
= pkt
->pts
;
1885 decoded_frame_tb
= ist
->st
->time_base
;
1887 decoded_frame
->pts
= ist
->dts
;
1888 decoded_frame_tb
= AV_TIME_BASE_Q
;
1890 pkt
->pts
= AV_NOPTS_VALUE
;
1891 if (decoded_frame
->pts
!= AV_NOPTS_VALUE
)
1892 decoded_frame
->pts
= av_rescale_delta(decoded_frame_tb
, decoded_frame
->pts
,
1893 (AVRational
){1, avctx
->sample_rate
}, decoded_frame
->nb_samples
, &ist
->filter_in_rescale_delta_last
,
1894 (AVRational
){1, avctx
->sample_rate
});
1895 for (i
= 0; i
< ist
->nb_filters
; i
++) {
1896 if (i
< ist
->nb_filters
- 1) {
1897 f
= ist
->filter_frame
;
1898 err
= av_frame_ref(f
, decoded_frame
);
1903 err
= av_buffersrc_add_frame_flags(ist
->filters
[i
]->filter
, f
,
1904 AV_BUFFERSRC_FLAG_PUSH
);
1905 if (err
== AVERROR_EOF
)
1906 err
= 0; /* ignore */
1910 decoded_frame
->pts
= AV_NOPTS_VALUE
;
1912 av_frame_unref(ist
->filter_frame
);
1913 av_frame_unref(decoded_frame
);
1914 return err
< 0 ? err
: ret
;
1917 static int decode_video(InputStream
*ist
, AVPacket
*pkt
, int *got_output
)
1919 AVFrame
*decoded_frame
, *f
;
1920 int i
, ret
= 0, err
= 0, resample_changed
;
1921 int64_t best_effort_timestamp
;
1922 AVRational
*frame_sample_aspect
;
1924 if (!ist
->decoded_frame
&& !(ist
->decoded_frame
= av_frame_alloc()))
1925 return AVERROR(ENOMEM
);
1926 if (!ist
->filter_frame
&& !(ist
->filter_frame
= av_frame_alloc()))
1927 return AVERROR(ENOMEM
);
1928 decoded_frame
= ist
->decoded_frame
;
1929 pkt
->dts
= av_rescale_q(ist
->dts
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
1931 update_benchmark(NULL
);
1932 ret
= avcodec_decode_video2(ist
->dec_ctx
,
1933 decoded_frame
, got_output
, pkt
);
1934 update_benchmark("decode_video %d.%d", ist
->file_index
, ist
->st
->index
);
1936 // The following line may be required in some cases where there is no parser
1937 // or the parser does not has_b_frames correctly
1938 if (ist
->st
->codec
->has_b_frames
< ist
->dec_ctx
->has_b_frames
) {
1939 if (ist
->dec_ctx
->codec_id
== AV_CODEC_ID_H264
) {
1940 ist
->st
->codec
->has_b_frames
= ist
->dec_ctx
->has_b_frames
;
1942 av_log_ask_for_sample(
1944 "has_b_frames is larger in decoder than demuxer %d > %d ",
1945 ist
->dec_ctx
->has_b_frames
,
1946 ist
->st
->codec
->has_b_frames
1950 if (*got_output
|| ret
<0 || pkt
->size
)
1951 decode_error_stat
[ret
<0] ++;
1953 if (*got_output
&& ret
>= 0) {
1954 if (ist
->dec_ctx
->width
!= decoded_frame
->width
||
1955 ist
->dec_ctx
->height
!= decoded_frame
->height
||
1956 ist
->dec_ctx
->pix_fmt
!= decoded_frame
->format
) {
1957 av_log(NULL
, AV_LOG_DEBUG
, "Frame parameters mismatch context %d,%d,%d != %d,%d,%d\n",
1958 decoded_frame
->width
,
1959 decoded_frame
->height
,
1960 decoded_frame
->format
,
1961 ist
->dec_ctx
->width
,
1962 ist
->dec_ctx
->height
,
1963 ist
->dec_ctx
->pix_fmt
);
1967 if (!*got_output
|| ret
< 0) {
1969 for (i
= 0; i
< ist
->nb_filters
; i
++)
1971 av_buffersrc_add_ref(ist
->filters
[i
]->filter
, NULL
, 0);
1973 av_buffersrc_add_frame(ist
->filters
[i
]->filter
, NULL
);
1979 if(ist
->top_field_first
>=0)
1980 decoded_frame
->top_field_first
= ist
->top_field_first
;
1982 ist
->frames_decoded
++;
1984 if (ist
->hwaccel_retrieve_data
&& decoded_frame
->format
== ist
->hwaccel_pix_fmt
) {
1985 err
= ist
->hwaccel_retrieve_data(ist
->dec_ctx
, decoded_frame
);
1989 ist
->hwaccel_retrieved_pix_fmt
= decoded_frame
->format
;
1991 best_effort_timestamp
= av_frame_get_best_effort_timestamp(decoded_frame
);
1992 if(best_effort_timestamp
!= AV_NOPTS_VALUE
)
1993 ist
->next_pts
= ist
->pts
= av_rescale_q(decoded_frame
->pts
= best_effort_timestamp
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
1996 av_log(NULL
, AV_LOG_INFO
, "decoder -> ist_index:%d type:video "
1997 "frame_pts:%s frame_pts_time:%s best_effort_ts:%"PRId64
" best_effort_ts_time:%s keyframe:%d frame_type:%d time_base:%d/%d\n",
1998 ist
->st
->index
, av_ts2str(decoded_frame
->pts
),
1999 av_ts2timestr(decoded_frame
->pts
, &ist
->st
->time_base
),
2000 best_effort_timestamp
,
2001 av_ts2timestr(best_effort_timestamp
, &ist
->st
->time_base
),
2002 decoded_frame
->key_frame
, decoded_frame
->pict_type
,
2003 ist
->st
->time_base
.num
, ist
->st
->time_base
.den
);
2008 if (ist
->st
->sample_aspect_ratio
.num
)
2009 decoded_frame
->sample_aspect_ratio
= ist
->st
->sample_aspect_ratio
;
2011 resample_changed
= ist
->resample_width
!= decoded_frame
->width
||
2012 ist
->resample_height
!= decoded_frame
->height
||
2013 ist
->resample_pix_fmt
!= decoded_frame
->format
;
2014 if (resample_changed
) {
2015 av_log(NULL
, AV_LOG_INFO
,
2016 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2017 ist
->file_index
, ist
->st
->index
,
2018 ist
->resample_width
, ist
->resample_height
, av_get_pix_fmt_name(ist
->resample_pix_fmt
),
2019 decoded_frame
->width
, decoded_frame
->height
, av_get_pix_fmt_name(decoded_frame
->format
));
2021 ist
->resample_width
= decoded_frame
->width
;
2022 ist
->resample_height
= decoded_frame
->height
;
2023 ist
->resample_pix_fmt
= decoded_frame
->format
;
2025 for (i
= 0; i
< nb_filtergraphs
; i
++) {
2026 if (ist_in_filtergraph(filtergraphs
[i
], ist
) && ist
->reinit_filters
&&
2027 configure_filtergraph(filtergraphs
[i
]) < 0) {
2028 av_log(NULL
, AV_LOG_FATAL
, "Error reinitializing filters!\n");
2034 frame_sample_aspect
= av_opt_ptr(avcodec_get_frame_class(), decoded_frame
, "sample_aspect_ratio");
2035 for (i
= 0; i
< ist
->nb_filters
; i
++) {
2036 if (!frame_sample_aspect
->num
)
2037 *frame_sample_aspect
= ist
->st
->sample_aspect_ratio
;
2039 if (i
< ist
->nb_filters
- 1) {
2040 f
= ist
->filter_frame
;
2041 err
= av_frame_ref(f
, decoded_frame
);
2046 ret
= av_buffersrc_add_frame_flags(ist
->filters
[i
]->filter
, f
, AV_BUFFERSRC_FLAG_PUSH
);
2047 if (ret
== AVERROR_EOF
) {
2048 ret
= 0; /* ignore */
2049 } else if (ret
< 0) {
2050 av_log(NULL
, AV_LOG_FATAL
,
2051 "Failed to inject frame into filter network: %s\n", av_err2str(ret
));
2057 av_frame_unref(ist
->filter_frame
);
2058 av_frame_unref(decoded_frame
);
2059 return err
< 0 ? err
: ret
;
2062 static int transcode_subtitles(InputStream
*ist
, AVPacket
*pkt
, int *got_output
)
2064 AVSubtitle subtitle
;
2065 int i
, ret
= avcodec_decode_subtitle2(ist
->dec_ctx
,
2066 &subtitle
, got_output
, pkt
);
2068 if (*got_output
|| ret
<0 || pkt
->size
)
2069 decode_error_stat
[ret
<0] ++;
2071 if (ret
< 0 || !*got_output
) {
2073 sub2video_flush(ist
);
2077 if (ist
->fix_sub_duration
) {
2079 if (ist
->prev_sub
.got_output
) {
2080 end
= av_rescale(subtitle
.pts
- ist
->prev_sub
.subtitle
.pts
,
2081 1000, AV_TIME_BASE
);
2082 if (end
< ist
->prev_sub
.subtitle
.end_display_time
) {
2083 av_log(ist
->dec_ctx
, AV_LOG_DEBUG
,
2084 "Subtitle duration reduced from %d to %d%s\n",
2085 ist
->prev_sub
.subtitle
.end_display_time
, end
,
2086 end
<= 0 ? ", dropping it" : "");
2087 ist
->prev_sub
.subtitle
.end_display_time
= end
;
2090 FFSWAP(int, *got_output
, ist
->prev_sub
.got_output
);
2091 FFSWAP(int, ret
, ist
->prev_sub
.ret
);
2092 FFSWAP(AVSubtitle
, subtitle
, ist
->prev_sub
.subtitle
);
2100 sub2video_update(ist
, &subtitle
);
2102 if (!subtitle
.num_rects
)
2105 ist
->frames_decoded
++;
2107 for (i
= 0; i
< nb_output_streams
; i
++) {
2108 OutputStream
*ost
= output_streams
[i
];
2110 if (!check_output_constraints(ist
, ost
) || !ost
->encoding_needed
2111 || ost
->enc
->type
!= AVMEDIA_TYPE_SUBTITLE
)
2114 do_subtitle_out(output_files
[ost
->file_index
]->ctx
, ost
, ist
, &subtitle
);
2118 avsubtitle_free(&subtitle
);
2122 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2123 static int process_input_packet(InputStream
*ist
, const AVPacket
*pkt
)
2129 if (!ist
->saw_first_ts
) {
2130 ist
->dts
= ist
->st
->avg_frame_rate
.num
? - ist
->dec_ctx
->has_b_frames
* AV_TIME_BASE
/ av_q2d(ist
->st
->avg_frame_rate
) : 0;
2132 if (pkt
&& pkt
->pts
!= AV_NOPTS_VALUE
&& !ist
->decoding_needed
) {
2133 ist
->dts
+= av_rescale_q(pkt
->pts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
2134 ist
->pts
= ist
->dts
; //unused but better to set it to a value thats not totally wrong
2136 ist
->saw_first_ts
= 1;
2139 if (ist
->next_dts
== AV_NOPTS_VALUE
)
2140 ist
->next_dts
= ist
->dts
;
2141 if (ist
->next_pts
== AV_NOPTS_VALUE
)
2142 ist
->next_pts
= ist
->pts
;
2146 av_init_packet(&avpkt
);
2154 if (pkt
->dts
!= AV_NOPTS_VALUE
) {
2155 ist
->next_dts
= ist
->dts
= av_rescale_q(pkt
->dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
2156 if (ist
->dec_ctx
->codec_type
!= AVMEDIA_TYPE_VIDEO
|| !ist
->decoding_needed
)
2157 ist
->next_pts
= ist
->pts
= ist
->dts
;
2160 // while we have more to decode or while the decoder did output something on EOF
2161 while (ist
->decoding_needed
&& (avpkt
.size
> 0 || (!pkt
&& got_output
))) {
2165 ist
->pts
= ist
->next_pts
;
2166 ist
->dts
= ist
->next_dts
;
2168 if (avpkt
.size
&& avpkt
.size
!= pkt
->size
&&
2169 !(ist
->dec
->capabilities
& CODEC_CAP_SUBFRAMES
)) {
2170 av_log(NULL
, ist
->showed_multi_packet_warning
? AV_LOG_VERBOSE
: AV_LOG_WARNING
,
2171 "Multiple frames in a packet from stream %d\n", pkt
->stream_index
);
2172 ist
->showed_multi_packet_warning
= 1;
2175 switch (ist
->dec_ctx
->codec_type
) {
2176 case AVMEDIA_TYPE_AUDIO
:
2177 ret
= decode_audio (ist
, &avpkt
, &got_output
);
2179 case AVMEDIA_TYPE_VIDEO
:
2180 ret
= decode_video (ist
, &avpkt
, &got_output
);
2181 if (avpkt
.duration
) {
2182 duration
= av_rescale_q(avpkt
.duration
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
2183 } else if(ist
->dec_ctx
->framerate
.num
!= 0 && ist
->dec_ctx
->framerate
.den
!= 0) {
2184 int ticks
= av_stream_get_parser(ist
->st
) ? av_stream_get_parser(ist
->st
)->repeat_pict
+1 : ist
->dec_ctx
->ticks_per_frame
;
2185 duration
= ((int64_t)AV_TIME_BASE
*
2186 ist
->dec_ctx
->framerate
.den
* ticks
) /
2187 ist
->dec_ctx
->framerate
.num
/ ist
->dec_ctx
->ticks_per_frame
;
2191 if(ist
->dts
!= AV_NOPTS_VALUE
&& duration
) {
2192 ist
->next_dts
+= duration
;
2194 ist
->next_dts
= AV_NOPTS_VALUE
;
2197 ist
->next_pts
+= duration
; //FIXME the duration is not correct in some cases
2199 case AVMEDIA_TYPE_SUBTITLE
:
2200 ret
= transcode_subtitles(ist
, &avpkt
, &got_output
);
2210 avpkt
.pts
= AV_NOPTS_VALUE
;
2212 // touch data and size only if not EOF
2214 if(ist
->dec_ctx
->codec_type
!= AVMEDIA_TYPE_AUDIO
)
2222 if (got_output
&& !pkt
)
2226 /* handle stream copy */
2227 if (!ist
->decoding_needed
) {
2228 ist
->dts
= ist
->next_dts
;
2229 switch (ist
->dec_ctx
->codec_type
) {
2230 case AVMEDIA_TYPE_AUDIO
:
2231 ist
->next_dts
+= ((int64_t)AV_TIME_BASE
* ist
->dec_ctx
->frame_size
) /
2232 ist
->dec_ctx
->sample_rate
;
2234 case AVMEDIA_TYPE_VIDEO
:
2235 if (ist
->framerate
.num
) {
2236 // TODO: Remove work-around for c99-to-c89 issue 7
2237 AVRational time_base_q
= AV_TIME_BASE_Q
;
2238 int64_t next_dts
= av_rescale_q(ist
->next_dts
, time_base_q
, av_inv_q(ist
->framerate
));
2239 ist
->next_dts
= av_rescale_q(next_dts
+ 1, av_inv_q(ist
->framerate
), time_base_q
);
2240 } else if (pkt
->duration
) {
2241 ist
->next_dts
+= av_rescale_q(pkt
->duration
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
2242 } else if(ist
->dec_ctx
->framerate
.num
!= 0) {
2243 int ticks
= av_stream_get_parser(ist
->st
) ? av_stream_get_parser(ist
->st
)->repeat_pict
+ 1 : ist
->dec_ctx
->ticks_per_frame
;
2244 ist
->next_dts
+= ((int64_t)AV_TIME_BASE
*
2245 ist
->dec_ctx
->framerate
.den
* ticks
) /
2246 ist
->dec_ctx
->framerate
.num
/ ist
->dec_ctx
->ticks_per_frame
;
2250 ist
->pts
= ist
->dts
;
2251 ist
->next_pts
= ist
->next_dts
;
2253 for (i
= 0; pkt
&& i
< nb_output_streams
; i
++) {
2254 OutputStream
*ost
= output_streams
[i
];
2256 if (!check_output_constraints(ist
, ost
) || ost
->encoding_needed
)
2259 do_streamcopy(ist
, ost
, pkt
);
2265 static void print_sdp(void)
2269 AVFormatContext
**avc
= av_malloc_array(nb_output_files
, sizeof(*avc
));
2273 for (i
= 0; i
< nb_output_files
; i
++)
2274 avc
[i
] = output_files
[i
]->ctx
;
2276 av_sdp_create(avc
, nb_output_files
, sdp
, sizeof(sdp
));
2277 printf("SDP:\n%s\n", sdp
);
2282 static const HWAccel
*get_hwaccel(enum AVPixelFormat pix_fmt
)
2285 for (i
= 0; hwaccels
[i
].name
; i
++)
2286 if (hwaccels
[i
].pix_fmt
== pix_fmt
)
2287 return &hwaccels
[i
];
2291 static enum AVPixelFormat
get_format(AVCodecContext
*s
, const enum AVPixelFormat
*pix_fmts
)
2293 InputStream
*ist
= s
->opaque
;
2294 const enum AVPixelFormat
*p
;
2297 for (p
= pix_fmts
; *p
!= -1; p
++) {
2298 const AVPixFmtDescriptor
*desc
= av_pix_fmt_desc_get(*p
);
2299 const HWAccel
*hwaccel
;
2301 if (!(desc
->flags
& AV_PIX_FMT_FLAG_HWACCEL
))
2304 hwaccel
= get_hwaccel(*p
);
2306 (ist
->active_hwaccel_id
&& ist
->active_hwaccel_id
!= hwaccel
->id
) ||
2307 (ist
->hwaccel_id
!= HWACCEL_AUTO
&& ist
->hwaccel_id
!= hwaccel
->id
))
2310 ret
= hwaccel
->init(s
);
2312 if (ist
->hwaccel_id
== hwaccel
->id
) {
2313 av_log(NULL
, AV_LOG_FATAL
,
2314 "%s hwaccel requested for input stream #%d:%d, "
2315 "but cannot be initialized.\n", hwaccel
->name
,
2316 ist
->file_index
, ist
->st
->index
);
2321 ist
->active_hwaccel_id
= hwaccel
->id
;
2322 ist
->hwaccel_pix_fmt
= *p
;
2329 static int get_buffer(AVCodecContext
*s
, AVFrame
*frame
, int flags
)
2331 InputStream
*ist
= s
->opaque
;
2333 if (ist
->hwaccel_get_buffer
&& frame
->format
== ist
->hwaccel_pix_fmt
)
2334 return ist
->hwaccel_get_buffer(s
, frame
, flags
);
2336 return avcodec_default_get_buffer2(s
, frame
, flags
);
2339 static int init_input_stream(int ist_index
, char *error
, int error_len
)
2342 InputStream
*ist
= input_streams
[ist_index
];
2344 if (ist
->decoding_needed
) {
2345 AVCodec
*codec
= ist
->dec
;
2347 snprintf(error
, error_len
, "Decoder (codec %s) not found for input stream #%d:%d",
2348 avcodec_get_name(ist
->dec_ctx
->codec_id
), ist
->file_index
, ist
->st
->index
);
2349 return AVERROR(EINVAL
);
2352 ist
->dec_ctx
->opaque
= ist
;
2353 ist
->dec_ctx
->get_format
= get_format
;
2354 ist
->dec_ctx
->get_buffer2
= get_buffer
;
2355 ist
->dec_ctx
->thread_safe_callbacks
= 1;
2357 av_opt_set_int(ist
->dec_ctx
, "refcounted_frames", 1, 0);
2358 if (ist
->dec_ctx
->codec_id
== AV_CODEC_ID_DVB_SUBTITLE
&&
2359 (ist
->decoding_needed
& DECODING_FOR_OST
)) {
2360 av_dict_set(&ist
->decoder_opts
, "compute_edt", "1", AV_DICT_DONT_OVERWRITE
);
2361 if (ist
->decoding_needed
& DECODING_FOR_FILTER
)
2362 av_log(NULL
, AV_LOG_WARNING
, "Warning using DVB subtitles for filtering and output at the same time is not fully supported, also see -compute_edt [0|1]\n");
2365 if (!av_dict_get(ist
->decoder_opts
, "threads", NULL
, 0))
2366 av_dict_set(&ist
->decoder_opts
, "threads", "auto", 0);
2367 if ((ret
= avcodec_open2(ist
->dec_ctx
, codec
, &ist
->decoder_opts
)) < 0) {
2368 if (ret
== AVERROR_EXPERIMENTAL
)
2369 abort_codec_experimental(codec
, 0);
2371 snprintf(error
, error_len
,
2372 "Error while opening decoder for input stream "
2374 ist
->file_index
, ist
->st
->index
, av_err2str(ret
));
2377 assert_avoptions(ist
->decoder_opts
);
2380 ist
->next_pts
= AV_NOPTS_VALUE
;
2381 ist
->next_dts
= AV_NOPTS_VALUE
;
2386 static InputStream
*get_input_stream(OutputStream
*ost
)
2388 if (ost
->source_index
>= 0)
2389 return input_streams
[ost
->source_index
];
2393 static int compare_int64(const void *a
, const void *b
)
2395 int64_t va
= *(int64_t *)a
, vb
= *(int64_t *)b
;
2396 return va
< vb
? -1 : va
> vb
? +1 : 0;
2399 static void parse_forced_key_frames(char *kf
, OutputStream
*ost
,
2400 AVCodecContext
*avctx
)
2403 int n
= 1, i
, size
, index
= 0;
2406 for (p
= kf
; *p
; p
++)
2410 pts
= av_malloc_array(size
, sizeof(*pts
));
2412 av_log(NULL
, AV_LOG_FATAL
, "Could not allocate forced key frames array.\n");
2417 for (i
= 0; i
< n
; i
++) {
2418 char *next
= strchr(p
, ',');
2423 if (!memcmp(p
, "chapters", 8)) {
2425 AVFormatContext
*avf
= output_files
[ost
->file_index
]->ctx
;
2428 if (avf
->nb_chapters
> INT_MAX
- size
||
2429 !(pts
= av_realloc_f(pts
, size
+= avf
->nb_chapters
- 1,
2431 av_log(NULL
, AV_LOG_FATAL
,
2432 "Could not allocate forced key frames array.\n");
2435 t
= p
[8] ? parse_time_or_die("force_key_frames", p
+ 8, 1) : 0;
2436 t
= av_rescale_q(t
, AV_TIME_BASE_Q
, avctx
->time_base
);
2438 for (j
= 0; j
< avf
->nb_chapters
; j
++) {
2439 AVChapter
*c
= avf
->chapters
[j
];
2440 av_assert1(index
< size
);
2441 pts
[index
++] = av_rescale_q(c
->start
, c
->time_base
,
2442 avctx
->time_base
) + t
;
2447 t
= parse_time_or_die("force_key_frames", p
, 1);
2448 av_assert1(index
< size
);
2449 pts
[index
++] = av_rescale_q(t
, AV_TIME_BASE_Q
, avctx
->time_base
);
2456 av_assert0(index
== size
);
2457 qsort(pts
, size
, sizeof(*pts
), compare_int64
);
2458 ost
->forced_kf_count
= size
;
2459 ost
->forced_kf_pts
= pts
;
2462 static void report_new_stream(int input_index
, AVPacket
*pkt
)
2464 InputFile
*file
= input_files
[input_index
];
2465 AVStream
*st
= file
->ctx
->streams
[pkt
->stream_index
];
2467 if (pkt
->stream_index
< file
->nb_streams_warn
)
2469 av_log(file
->ctx
, AV_LOG_WARNING
,
2470 "New %s stream %d:%d at pos:%"PRId64
" and DTS:%ss\n",
2471 av_get_media_type_string(st
->codec
->codec_type
),
2472 input_index
, pkt
->stream_index
,
2473 pkt
->pos
, av_ts2timestr(pkt
->dts
, &st
->time_base
));
2474 file
->nb_streams_warn
= pkt
->stream_index
+ 1;
2477 static void set_encoder_id(OutputFile
*of
, OutputStream
*ost
)
2479 AVDictionaryEntry
*e
;
2481 uint8_t *encoder_string
;
2482 int encoder_string_len
;
2483 int format_flags
= 0;
2484 int codec_flags
= 0;
2486 if (av_dict_get(ost
->st
->metadata
, "encoder", NULL
, 0))
2489 e
= av_dict_get(of
->opts
, "fflags", NULL
, 0);
2491 const AVOption
*o
= av_opt_find(of
->ctx
, "fflags", NULL
, 0, 0);
2494 av_opt_eval_flags(of
->ctx
, o
, e
->value
, &format_flags
);
2496 e
= av_dict_get(ost
->encoder_opts
, "flags", NULL
, 0);
2498 const AVOption
*o
= av_opt_find(ost
->enc_ctx
, "flags", NULL
, 0, 0);
2501 av_opt_eval_flags(ost
->enc_ctx
, o
, e
->value
, &codec_flags
);
2504 encoder_string_len
= sizeof(LIBAVCODEC_IDENT
) + strlen(ost
->enc
->name
) + 2;
2505 encoder_string
= av_mallocz(encoder_string_len
);
2506 if (!encoder_string
)
2509 if (!(format_flags
& AVFMT_FLAG_BITEXACT
) && !(codec_flags
& CODEC_FLAG_BITEXACT
))
2510 av_strlcpy(encoder_string
, LIBAVCODEC_IDENT
" ", encoder_string_len
);
2512 av_strlcpy(encoder_string
, "Lavc ", encoder_string_len
);
2513 av_strlcat(encoder_string
, ost
->enc
->name
, encoder_string_len
);
2514 av_dict_set(&ost
->st
->metadata
, "encoder", encoder_string
,
2515 AV_DICT_DONT_STRDUP_VAL
| AV_DICT_DONT_OVERWRITE
);
2518 static int transcode_init(void)
2520 int ret
= 0, i
, j
, k
;
2521 AVFormatContext
*oc
;
2527 for (i
= 0; i
< nb_filtergraphs
; i
++) {
2528 FilterGraph
*fg
= filtergraphs
[i
];
2529 for (j
= 0; j
< fg
->nb_outputs
; j
++) {
2530 OutputFilter
*ofilter
= fg
->outputs
[j
];
2531 if (!ofilter
->ost
|| ofilter
->ost
->source_index
>= 0)
2533 if (fg
->nb_inputs
!= 1)
2535 for (k
= nb_input_streams
-1; k
>= 0 ; k
--)
2536 if (fg
->inputs
[0]->ist
== input_streams
[k
])
2538 ofilter
->ost
->source_index
= k
;
2542 /* init framerate emulation */
2543 for (i
= 0; i
< nb_input_files
; i
++) {
2544 InputFile
*ifile
= input_files
[i
];
2545 if (ifile
->rate_emu
)
2546 for (j
= 0; j
< ifile
->nb_streams
; j
++)
2547 input_streams
[j
+ ifile
->ist_index
]->start
= av_gettime_relative();
2550 /* output stream init */
2551 for (i
= 0; i
< nb_output_files
; i
++) {
2552 oc
= output_files
[i
]->ctx
;
2553 if (!oc
->nb_streams
&& !(oc
->oformat
->flags
& AVFMT_NOSTREAMS
)) {
2554 av_dump_format(oc
, i
, oc
->filename
, 1);
2555 av_log(NULL
, AV_LOG_ERROR
, "Output file #%d does not contain any stream\n", i
);
2556 return AVERROR(EINVAL
);
2560 /* init complex filtergraphs */
2561 for (i
= 0; i
< nb_filtergraphs
; i
++)
2562 if ((ret
= avfilter_graph_config(filtergraphs
[i
]->graph
, NULL
)) < 0)
2565 /* for each output stream, we compute the right encoding parameters */
2566 for (i
= 0; i
< nb_output_streams
; i
++) {
2567 AVCodecContext
*enc_ctx
;
2568 AVCodecContext
*dec_ctx
= NULL
;
2569 ost
= output_streams
[i
];
2570 oc
= output_files
[ost
->file_index
]->ctx
;
2571 ist
= get_input_stream(ost
);
2573 if (ost
->attachment_filename
)
2576 enc_ctx
= ost
->enc_ctx
;
2579 dec_ctx
= ist
->dec_ctx
;
2581 ost
->st
->disposition
= ist
->st
->disposition
;
2582 enc_ctx
->bits_per_raw_sample
= dec_ctx
->bits_per_raw_sample
;
2583 enc_ctx
->chroma_sample_location
= dec_ctx
->chroma_sample_location
;
2585 for (j
=0; j
<oc
->nb_streams
; j
++) {
2586 AVStream
*st
= oc
->streams
[j
];
2587 if (st
!= ost
->st
&& st
->codec
->codec_type
== enc_ctx
->codec_type
)
2590 if (j
== oc
->nb_streams
)
2591 if (enc_ctx
->codec_type
== AVMEDIA_TYPE_AUDIO
|| enc_ctx
->codec_type
== AVMEDIA_TYPE_VIDEO
)
2592 ost
->st
->disposition
= AV_DISPOSITION_DEFAULT
;
2595 if (ost
->stream_copy
) {
2597 uint64_t extra_size
;
2599 av_assert0(ist
&& !ost
->filter
);
2601 extra_size
= (uint64_t)dec_ctx
->extradata_size
+ FF_INPUT_BUFFER_PADDING_SIZE
;
2603 if (extra_size
> INT_MAX
) {
2604 return AVERROR(EINVAL
);
2607 /* if stream_copy is selected, no need to decode or encode */
2608 enc_ctx
->codec_id
= dec_ctx
->codec_id
;
2609 enc_ctx
->codec_type
= dec_ctx
->codec_type
;
2611 if (!enc_ctx
->codec_tag
) {
2612 unsigned int codec_tag
;
2613 if (!oc
->oformat
->codec_tag
||
2614 av_codec_get_id (oc
->oformat
->codec_tag
, dec_ctx
->codec_tag
) == enc_ctx
->codec_id
||
2615 !av_codec_get_tag2(oc
->oformat
->codec_tag
, dec_ctx
->codec_id
, &codec_tag
))
2616 enc_ctx
->codec_tag
= dec_ctx
->codec_tag
;
2619 enc_ctx
->bit_rate
= dec_ctx
->bit_rate
;
2620 enc_ctx
->rc_max_rate
= dec_ctx
->rc_max_rate
;
2621 enc_ctx
->rc_buffer_size
= dec_ctx
->rc_buffer_size
;
2622 enc_ctx
->field_order
= dec_ctx
->field_order
;
2623 enc_ctx
->extradata
= av_mallocz(extra_size
);
2624 if (!enc_ctx
->extradata
) {
2625 return AVERROR(ENOMEM
);
2627 memcpy(enc_ctx
->extradata
, dec_ctx
->extradata
, dec_ctx
->extradata_size
);
2628 enc_ctx
->extradata_size
= dec_ctx
->extradata_size
;
2629 enc_ctx
->bits_per_coded_sample
= dec_ctx
->bits_per_coded_sample
;
2631 enc_ctx
->time_base
= ist
->st
->time_base
;
2633 * Avi is a special case here because it supports variable fps but
2634 * having the fps and timebase differe significantly adds quite some
2637 if(!strcmp(oc
->oformat
->name
, "avi")) {
2638 if ( copy_tb
<0 && av_q2d(ist
->st
->r_frame_rate
) >= av_q2d(ist
->st
->avg_frame_rate
)
2639 && 0.5/av_q2d(ist
->st
->r_frame_rate
) > av_q2d(ist
->st
->time_base
)
2640 && 0.5/av_q2d(ist
->st
->r_frame_rate
) > av_q2d(dec_ctx
->time_base
)
2641 && av_q2d(ist
->st
->time_base
) < 1.0/500 && av_q2d(dec_ctx
->time_base
) < 1.0/500
2643 enc_ctx
->time_base
.num
= ist
->st
->r_frame_rate
.den
;
2644 enc_ctx
->time_base
.den
= 2*ist
->st
->r_frame_rate
.num
;
2645 enc_ctx
->ticks_per_frame
= 2;
2646 } else if ( copy_tb
<0 && av_q2d(dec_ctx
->time_base
)*dec_ctx
->ticks_per_frame
> 2*av_q2d(ist
->st
->time_base
)
2647 && av_q2d(ist
->st
->time_base
) < 1.0/500
2649 enc_ctx
->time_base
= dec_ctx
->time_base
;
2650 enc_ctx
->time_base
.num
*= dec_ctx
->ticks_per_frame
;
2651 enc_ctx
->time_base
.den
*= 2;
2652 enc_ctx
->ticks_per_frame
= 2;
2654 } else if(!(oc
->oformat
->flags
& AVFMT_VARIABLE_FPS
)
2655 && strcmp(oc
->oformat
->name
, "mov") && strcmp(oc
->oformat
->name
, "mp4") && strcmp(oc
->oformat
->name
, "3gp")
2656 && strcmp(oc
->oformat
->name
, "3g2") && strcmp(oc
->oformat
->name
, "psp") && strcmp(oc
->oformat
->name
, "ipod")
2657 && strcmp(oc
->oformat
->name
, "f4v")
2659 if( copy_tb
<0 && dec_ctx
->time_base
.den
2660 && av_q2d(dec_ctx
->time_base
)*dec_ctx
->ticks_per_frame
> av_q2d(ist
->st
->time_base
)
2661 && av_q2d(ist
->st
->time_base
) < 1.0/500
2663 enc_ctx
->time_base
= dec_ctx
->time_base
;
2664 enc_ctx
->time_base
.num
*= dec_ctx
->ticks_per_frame
;
2667 if ( enc_ctx
->codec_tag
== AV_RL32("tmcd")
2668 && dec_ctx
->time_base
.num
< dec_ctx
->time_base
.den
2669 && dec_ctx
->time_base
.num
> 0
2670 && 121LL*dec_ctx
->time_base
.num
> dec_ctx
->time_base
.den
) {
2671 enc_ctx
->time_base
= dec_ctx
->time_base
;
2674 if (ist
&& !ost
->frame_rate
.num
)
2675 ost
->frame_rate
= ist
->framerate
;
2676 if(ost
->frame_rate
.num
)
2677 enc_ctx
->time_base
= av_inv_q(ost
->frame_rate
);
2679 av_reduce(&enc_ctx
->time_base
.num
, &enc_ctx
->time_base
.den
,
2680 enc_ctx
->time_base
.num
, enc_ctx
->time_base
.den
, INT_MAX
);
2682 if (ist
->st
->nb_side_data
) {
2683 ost
->st
->side_data
= av_realloc_array(NULL
, ist
->st
->nb_side_data
,
2684 sizeof(*ist
->st
->side_data
));
2685 if (!ost
->st
->side_data
)
2686 return AVERROR(ENOMEM
);
2688 for (j
= 0; j
< ist
->st
->nb_side_data
; j
++) {
2689 const AVPacketSideData
*sd_src
= &ist
->st
->side_data
[j
];
2690 AVPacketSideData
*sd_dst
= &ost
->st
->side_data
[j
];
2692 sd_dst
->data
= av_malloc(sd_src
->size
);
2694 return AVERROR(ENOMEM
);
2695 memcpy(sd_dst
->data
, sd_src
->data
, sd_src
->size
);
2696 sd_dst
->size
= sd_src
->size
;
2697 sd_dst
->type
= sd_src
->type
;
2698 ost
->st
->nb_side_data
++;
2702 ost
->parser
= av_parser_init(enc_ctx
->codec_id
);
2704 switch (enc_ctx
->codec_type
) {
2705 case AVMEDIA_TYPE_AUDIO
:
2706 if (audio_volume
!= 256) {
2707 av_log(NULL
, AV_LOG_FATAL
, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2710 enc_ctx
->channel_layout
= dec_ctx
->channel_layout
;
2711 enc_ctx
->sample_rate
= dec_ctx
->sample_rate
;
2712 enc_ctx
->channels
= dec_ctx
->channels
;
2713 enc_ctx
->frame_size
= dec_ctx
->frame_size
;
2714 enc_ctx
->audio_service_type
= dec_ctx
->audio_service_type
;
2715 enc_ctx
->block_align
= dec_ctx
->block_align
;
2716 enc_ctx
->initial_padding
= dec_ctx
->delay
;
2717 #if FF_API_AUDIOENC_DELAY
2718 enc_ctx
->delay
= dec_ctx
->delay
;
2720 if((enc_ctx
->block_align
== 1 || enc_ctx
->block_align
== 1152 || enc_ctx
->block_align
== 576) && enc_ctx
->codec_id
== AV_CODEC_ID_MP3
)
2721 enc_ctx
->block_align
= 0;
2722 if(enc_ctx
->codec_id
== AV_CODEC_ID_AC3
)
2723 enc_ctx
->block_align
= 0;
2725 case AVMEDIA_TYPE_VIDEO
:
2726 enc_ctx
->pix_fmt
= dec_ctx
->pix_fmt
;
2727 enc_ctx
->width
= dec_ctx
->width
;
2728 enc_ctx
->height
= dec_ctx
->height
;
2729 enc_ctx
->has_b_frames
= dec_ctx
->has_b_frames
;
2730 if (ost
->frame_aspect_ratio
.num
) { // overridden by the -aspect cli option
2732 av_mul_q(ost
->frame_aspect_ratio
,
2733 (AVRational
){ enc_ctx
->height
, enc_ctx
->width
});
2734 av_log(NULL
, AV_LOG_WARNING
, "Overriding aspect ratio "
2735 "with stream copy may produce invalid files\n");
2737 else if (ist
->st
->sample_aspect_ratio
.num
)
2738 sar
= ist
->st
->sample_aspect_ratio
;
2740 sar
= dec_ctx
->sample_aspect_ratio
;
2741 ost
->st
->sample_aspect_ratio
= enc_ctx
->sample_aspect_ratio
= sar
;
2742 ost
->st
->avg_frame_rate
= ist
->st
->avg_frame_rate
;
2744 case AVMEDIA_TYPE_SUBTITLE
:
2745 enc_ctx
->width
= dec_ctx
->width
;
2746 enc_ctx
->height
= dec_ctx
->height
;
2748 case AVMEDIA_TYPE_DATA
:
2749 case AVMEDIA_TYPE_ATTACHMENT
:
2756 ost
->enc
= avcodec_find_encoder(enc_ctx
->codec_id
);
2758 /* should only happen when a default codec is not present. */
2759 snprintf(error
, sizeof(error
), "Encoder (codec %s) not found for output stream #%d:%d",
2760 avcodec_get_name(ost
->st
->codec
->codec_id
), ost
->file_index
, ost
->index
);
2761 ret
= AVERROR(EINVAL
);
2766 ist
->decoding_needed
|= DECODING_FOR_OST
;
2767 ost
->encoding_needed
= 1;
2769 set_encoder_id(output_files
[ost
->file_index
], ost
);
2772 (enc_ctx
->codec_type
== AVMEDIA_TYPE_VIDEO
||
2773 enc_ctx
->codec_type
== AVMEDIA_TYPE_AUDIO
)) {
2775 fg
= init_simple_filtergraph(ist
, ost
);
2776 if (configure_filtergraph(fg
)) {
2777 av_log(NULL
, AV_LOG_FATAL
, "Error opening filters!\n");
2782 if (enc_ctx
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
2783 if (ost
->filter
&& !ost
->frame_rate
.num
)
2784 ost
->frame_rate
= av_buffersink_get_frame_rate(ost
->filter
->filter
);
2785 if (ist
&& !ost
->frame_rate
.num
)
2786 ost
->frame_rate
= ist
->framerate
;
2787 if (ist
&& !ost
->frame_rate
.num
)
2788 ost
->frame_rate
= ist
->st
->r_frame_rate
;
2789 if (ist
&& !ost
->frame_rate
.num
) {
2790 ost
->frame_rate
= (AVRational
){25, 1};
2791 av_log(NULL
, AV_LOG_WARNING
,
2793 "about the input framerate is available. Falling "
2794 "back to a default value of 25fps for output stream #%d:%d. Use the -r option "
2795 "if you want a different framerate.\n",
2796 ost
->file_index
, ost
->index
);
2798 // ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
2799 if (ost
->enc
&& ost
->enc
->supported_framerates
&& !ost
->force_fps
) {
2800 int idx
= av_find_nearest_q_idx(ost
->frame_rate
, ost
->enc
->supported_framerates
);
2801 ost
->frame_rate
= ost
->enc
->supported_framerates
[idx
];
2803 if (enc_ctx
->codec_id
== AV_CODEC_ID_MPEG4
) {
2804 av_reduce(&ost
->frame_rate
.num
, &ost
->frame_rate
.den
,
2805 ost
->frame_rate
.num
, ost
->frame_rate
.den
, 65535);
2809 switch (enc_ctx
->codec_type
) {
2810 case AVMEDIA_TYPE_AUDIO
:
2811 enc_ctx
->sample_fmt
= ost
->filter
->filter
->inputs
[0]->format
;
2812 enc_ctx
->sample_rate
= ost
->filter
->filter
->inputs
[0]->sample_rate
;
2813 enc_ctx
->channel_layout
= ost
->filter
->filter
->inputs
[0]->channel_layout
;
2814 enc_ctx
->channels
= avfilter_link_get_channels(ost
->filter
->filter
->inputs
[0]);
2815 enc_ctx
->time_base
= (AVRational
){ 1, enc_ctx
->sample_rate
};
2817 case AVMEDIA_TYPE_VIDEO
:
2818 enc_ctx
->time_base
= av_inv_q(ost
->frame_rate
);
2819 if (ost
->filter
&& !(enc_ctx
->time_base
.num
&& enc_ctx
->time_base
.den
))
2820 enc_ctx
->time_base
= ost
->filter
->filter
->inputs
[0]->time_base
;
2821 if ( av_q2d(enc_ctx
->time_base
) < 0.001 && video_sync_method
!= VSYNC_PASSTHROUGH
2822 && (video_sync_method
== VSYNC_CFR
|| video_sync_method
== VSYNC_VSCFR
|| (video_sync_method
== VSYNC_AUTO
&& !(oc
->oformat
->flags
& AVFMT_VARIABLE_FPS
)))){
2823 av_log(oc
, AV_LOG_WARNING
, "Frame rate very high for a muxer not efficiently supporting it.\n"
2824 "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
2826 for (j
= 0; j
< ost
->forced_kf_count
; j
++)
2827 ost
->forced_kf_pts
[j
] = av_rescale_q(ost
->forced_kf_pts
[j
],
2829 enc_ctx
->time_base
);
2831 enc_ctx
->width
= ost
->filter
->filter
->inputs
[0]->w
;
2832 enc_ctx
->height
= ost
->filter
->filter
->inputs
[0]->h
;
2833 enc_ctx
->sample_aspect_ratio
= ost
->st
->sample_aspect_ratio
=
2834 ost
->frame_aspect_ratio
.num
? // overridden by the -aspect cli option
2835 av_mul_q(ost
->frame_aspect_ratio
, (AVRational
){ enc_ctx
->height
, enc_ctx
->width
}) :
2836 ost
->filter
->filter
->inputs
[0]->sample_aspect_ratio
;
2837 if (!strncmp(ost
->enc
->name
, "libx264", 7) &&
2838 enc_ctx
->pix_fmt
== AV_PIX_FMT_NONE
&&
2839 ost
->filter
->filter
->inputs
[0]->format
!= AV_PIX_FMT_YUV420P
)
2840 av_log(NULL
, AV_LOG_WARNING
,
2841 "No pixel format specified, %s for H.264 encoding chosen.\n"
2842 "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
2843 av_get_pix_fmt_name(ost
->filter
->filter
->inputs
[0]->format
));
2844 if (!strncmp(ost
->enc
->name
, "mpeg2video", 10) &&
2845 enc_ctx
->pix_fmt
== AV_PIX_FMT_NONE
&&
2846 ost
->filter
->filter
->inputs
[0]->format
!= AV_PIX_FMT_YUV420P
)
2847 av_log(NULL
, AV_LOG_WARNING
,
2848 "No pixel format specified, %s for MPEG-2 encoding chosen.\n"
2849 "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
2850 av_get_pix_fmt_name(ost
->filter
->filter
->inputs
[0]->format
));
2851 enc_ctx
->pix_fmt
= ost
->filter
->filter
->inputs
[0]->format
;
2853 ost
->st
->avg_frame_rate
= ost
->frame_rate
;
2856 enc_ctx
->width
!= dec_ctx
->width
||
2857 enc_ctx
->height
!= dec_ctx
->height
||
2858 enc_ctx
->pix_fmt
!= dec_ctx
->pix_fmt
) {
2859 enc_ctx
->bits_per_raw_sample
= frame_bits_per_raw_sample
;
2862 if (ost
->forced_keyframes
) {
2863 if (!strncmp(ost
->forced_keyframes
, "expr:", 5)) {
2864 ret
= av_expr_parse(&ost
->forced_keyframes_pexpr
, ost
->forced_keyframes
+5,
2865 forced_keyframes_const_names
, NULL
, NULL
, NULL
, NULL
, 0, NULL
);
2867 av_log(NULL
, AV_LOG_ERROR
,
2868 "Invalid force_key_frames expression '%s'\n", ost
->forced_keyframes
+5);
2871 ost
->forced_keyframes_expr_const_values
[FKF_N
] = 0;
2872 ost
->forced_keyframes_expr_const_values
[FKF_N_FORCED
] = 0;
2873 ost
->forced_keyframes_expr_const_values
[FKF_PREV_FORCED_N
] = NAN
;
2874 ost
->forced_keyframes_expr_const_values
[FKF_PREV_FORCED_T
] = NAN
;
2876 parse_forced_key_frames(ost
->forced_keyframes
, ost
, ost
->enc_ctx
);
2880 case AVMEDIA_TYPE_SUBTITLE
:
2881 enc_ctx
->time_base
= (AVRational
){1, 1000};
2882 if (!enc_ctx
->width
) {
2883 enc_ctx
->width
= input_streams
[ost
->source_index
]->st
->codec
->width
;
2884 enc_ctx
->height
= input_streams
[ost
->source_index
]->st
->codec
->height
;
2892 if (enc_ctx
->flags
& (CODEC_FLAG_PASS1
| CODEC_FLAG_PASS2
)) {
2893 char logfilename
[1024];
2896 snprintf(logfilename
, sizeof(logfilename
), "%s-%d.log",
2897 ost
->logfile_prefix
? ost
->logfile_prefix
:
2898 DEFAULT_PASS_LOGFILENAME_PREFIX
,
2900 if (!strcmp(ost
->enc
->name
, "libx264")) {
2901 av_dict_set(&ost
->encoder_opts
, "stats", logfilename
, AV_DICT_DONT_OVERWRITE
);
2903 if (enc_ctx
->flags
& CODEC_FLAG_PASS2
) {
2905 size_t logbuffer_size
;
2906 if (cmdutils_read_file(logfilename
, &logbuffer
, &logbuffer_size
) < 0) {
2907 av_log(NULL
, AV_LOG_FATAL
, "Error reading log file '%s' for pass-2 encoding\n",
2911 enc_ctx
->stats_in
= logbuffer
;
2913 if (enc_ctx
->flags
& CODEC_FLAG_PASS1
) {
2914 f
= av_fopen_utf8(logfilename
, "wb");
2916 av_log(NULL
, AV_LOG_FATAL
, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2917 logfilename
, strerror(errno
));
2927 /* open each encoder */
2928 for (i
= 0; i
< nb_output_streams
; i
++) {
2929 ost
= output_streams
[i
];
2930 if (ost
->encoding_needed
) {
2931 AVCodec
*codec
= ost
->enc
;
2932 AVCodecContext
*dec
= NULL
;
2934 if ((ist
= get_input_stream(ost
)))
2936 if (dec
&& dec
->subtitle_header
) {
2937 /* ASS code assumes this buffer is null terminated so add extra byte. */
2938 ost
->enc_ctx
->subtitle_header
= av_mallocz(dec
->subtitle_header_size
+ 1);
2939 if (!ost
->enc_ctx
->subtitle_header
) {
2940 ret
= AVERROR(ENOMEM
);
2943 memcpy(ost
->enc_ctx
->subtitle_header
, dec
->subtitle_header
, dec
->subtitle_header_size
);
2944 ost
->enc_ctx
->subtitle_header_size
= dec
->subtitle_header_size
;
2946 if (!av_dict_get(ost
->encoder_opts
, "threads", NULL
, 0))
2947 av_dict_set(&ost
->encoder_opts
, "threads", "auto", 0);
2948 av_dict_set(&ost
->encoder_opts
, "side_data_only_packets", "1", 0);
2950 if ((ret
= avcodec_open2(ost
->enc_ctx
, codec
, &ost
->encoder_opts
)) < 0) {
2951 if (ret
== AVERROR_EXPERIMENTAL
)
2952 abort_codec_experimental(codec
, 1);
2953 snprintf(error
, sizeof(error
), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2954 ost
->file_index
, ost
->index
);
2957 if (ost
->enc
->type
== AVMEDIA_TYPE_AUDIO
&&
2958 !(ost
->enc
->capabilities
& CODEC_CAP_VARIABLE_FRAME_SIZE
))
2959 av_buffersink_set_frame_size(ost
->filter
->filter
,
2960 ost
->enc_ctx
->frame_size
);
2961 assert_avoptions(ost
->encoder_opts
);
2962 if (ost
->enc_ctx
->bit_rate
&& ost
->enc_ctx
->bit_rate
< 1000)
2963 av_log(NULL
, AV_LOG_WARNING
, "The bitrate parameter is set too low."
2964 " It takes bits/s as argument, not kbits/s\n");
2966 ret
= av_opt_set_dict(ost
->enc_ctx
, &ost
->encoder_opts
);
2968 av_log(NULL
, AV_LOG_FATAL
,
2969 "Error setting up codec context options.\n");
2974 ret
= avcodec_copy_context(ost
->st
->codec
, ost
->enc_ctx
);
2976 av_log(NULL
, AV_LOG_FATAL
,
2977 "Error initializing the output stream codec context.\n");
2980 ost
->st
->codec
->codec
= ost
->enc_ctx
->codec
;
2982 // copy timebase while removing common factors
2983 ost
->st
->time_base
= av_add_q(ost
->enc_ctx
->time_base
, (AVRational
){0, 1});
2986 /* init input streams */
2987 for (i
= 0; i
< nb_input_streams
; i
++)
2988 if ((ret
= init_input_stream(i
, error
, sizeof(error
))) < 0) {
2989 for (i
= 0; i
< nb_output_streams
; i
++) {
2990 ost
= output_streams
[i
];
2991 avcodec_close(ost
->enc_ctx
);
2996 /* discard unused programs */
2997 for (i
= 0; i
< nb_input_files
; i
++) {
2998 InputFile
*ifile
= input_files
[i
];
2999 for (j
= 0; j
< ifile
->ctx
->nb_programs
; j
++) {
3000 AVProgram
*p
= ifile
->ctx
->programs
[j
];
3001 int discard
= AVDISCARD_ALL
;
3003 for (k
= 0; k
< p
->nb_stream_indexes
; k
++)
3004 if (!input_streams
[ifile
->ist_index
+ p
->stream_index
[k
]]->discard
) {
3005 discard
= AVDISCARD_DEFAULT
;
3008 p
->discard
= discard
;
3012 /* open files and write file headers */
3013 for (i
= 0; i
< nb_output_files
; i
++) {
3014 oc
= output_files
[i
]->ctx
;
3015 oc
->interrupt_callback
= int_cb
;
3016 if ((ret
= avformat_write_header(oc
, &output_files
[i
]->opts
)) < 0) {
3017 snprintf(error
, sizeof(error
),
3018 "Could not write header for output file #%d "
3019 "(incorrect codec parameters ?): %s",
3020 i
, av_err2str(ret
));
3021 ret
= AVERROR(EINVAL
);
3024 // assert_avoptions(output_files[i]->opts);
3025 if (strcmp(oc
->oformat
->name
, "rtp")) {
3031 /* dump the file output parameters - cannot be done before in case
3033 for (i
= 0; i
< nb_output_files
; i
++) {
3034 av_dump_format(output_files
[i
]->ctx
, i
, output_files
[i
]->ctx
->filename
, 1);
3037 /* dump the stream mapping */
3038 av_log(NULL
, AV_LOG_INFO
, "Stream mapping:\n");
3039 for (i
= 0; i
< nb_input_streams
; i
++) {
3040 ist
= input_streams
[i
];
3042 for (j
= 0; j
< ist
->nb_filters
; j
++) {
3043 if (ist
->filters
[j
]->graph
->graph_desc
) {
3044 av_log(NULL
, AV_LOG_INFO
, " Stream #%d:%d (%s) -> %s",
3045 ist
->file_index
, ist
->st
->index
, ist
->dec
? ist
->dec
->name
: "?",
3046 ist
->filters
[j
]->name
);
3047 if (nb_filtergraphs
> 1)
3048 av_log(NULL
, AV_LOG_INFO
, " (graph %d)", ist
->filters
[j
]->graph
->index
);
3049 av_log(NULL
, AV_LOG_INFO
, "\n");
3054 for (i
= 0; i
< nb_output_streams
; i
++) {
3055 ost
= output_streams
[i
];
3057 if (ost
->attachment_filename
) {
3058 /* an attached file */
3059 av_log(NULL
, AV_LOG_INFO
, " File %s -> Stream #%d:%d\n",
3060 ost
->attachment_filename
, ost
->file_index
, ost
->index
);
3064 if (ost
->filter
&& ost
->filter
->graph
->graph_desc
) {
3065 /* output from a complex graph */
3066 av_log(NULL
, AV_LOG_INFO
, " %s", ost
->filter
->name
);
3067 if (nb_filtergraphs
> 1)
3068 av_log(NULL
, AV_LOG_INFO
, " (graph %d)", ost
->filter
->graph
->index
);
3070 av_log(NULL
, AV_LOG_INFO
, " -> Stream #%d:%d (%s)\n", ost
->file_index
,
3071 ost
->index
, ost
->enc
? ost
->enc
->name
: "?");
3075 av_log(NULL
, AV_LOG_INFO
, " Stream #%d:%d -> #%d:%d",
3076 input_streams
[ost
->source_index
]->file_index
,
3077 input_streams
[ost
->source_index
]->st
->index
,
3080 if (ost
->sync_ist
!= input_streams
[ost
->source_index
])
3081 av_log(NULL
, AV_LOG_INFO
, " [sync #%d:%d]",
3082 ost
->sync_ist
->file_index
,
3083 ost
->sync_ist
->st
->index
);
3084 if (ost
->stream_copy
)
3085 av_log(NULL
, AV_LOG_INFO
, " (copy)");
3087 const AVCodec
*in_codec
= input_streams
[ost
->source_index
]->dec
;
3088 const AVCodec
*out_codec
= ost
->enc
;
3089 const char *decoder_name
= "?";
3090 const char *in_codec_name
= "?";
3091 const char *encoder_name
= "?";
3092 const char *out_codec_name
= "?";
3095 decoder_name
= in_codec
->name
;
3096 in_codec_name
= avcodec_descriptor_get(in_codec
->id
)->name
;
3097 if (!strcmp(decoder_name
, in_codec_name
))
3098 decoder_name
= "native";
3102 encoder_name
= out_codec
->name
;
3103 out_codec_name
= avcodec_descriptor_get(out_codec
->id
)->name
;
3104 if (!strcmp(encoder_name
, out_codec_name
))
3105 encoder_name
= "native";
3108 av_log(NULL
, AV_LOG_INFO
, " (%s (%s) -> %s (%s))",
3109 in_codec_name
, decoder_name
,
3110 out_codec_name
, encoder_name
);
3112 av_log(NULL
, AV_LOG_INFO
, "\n");
3116 av_log(NULL
, AV_LOG_ERROR
, "%s\n", error
);
3124 transcode_init_done
= 1;
3129 /* Return 1 if there remain streams where more output is wanted, 0 otherwise. */
3130 static int need_output(void)
3134 for (i
= 0; i
< nb_output_streams
; i
++) {
3135 OutputStream
*ost
= output_streams
[i
];
3136 OutputFile
*of
= output_files
[ost
->file_index
];
3137 AVFormatContext
*os
= output_files
[ost
->file_index
]->ctx
;
3139 if (ost
->finished
||
3140 (os
->pb
&& avio_tell(os
->pb
) >= of
->limit_filesize
))
3142 if (ost
->frame_number
>= ost
->max_frames
) {
3144 for (j
= 0; j
< of
->ctx
->nb_streams
; j
++)
3145 close_output_stream(output_streams
[of
->ost_index
+ j
]);
3156 * Select the output stream to process.
3158 * @return selected output stream, or NULL if none available
3160 static OutputStream
*choose_output(void)
3163 int64_t opts_min
= INT64_MAX
;
3164 OutputStream
*ost_min
= NULL
;
3166 for (i
= 0; i
< nb_output_streams
; i
++) {
3167 OutputStream
*ost
= output_streams
[i
];
3168 int64_t opts
= av_rescale_q(ost
->st
->cur_dts
, ost
->st
->time_base
,
3170 if (!ost
->finished
&& opts
< opts_min
) {
3172 ost_min
= ost
->unavailable
? NULL
: ost
;
3178 static int check_keyboard_interaction(int64_t cur_time
)
3181 static int64_t last_time
;
3182 if (received_nb_signals
)
3183 return AVERROR_EXIT
;
3184 /* read_key() returns 0 on EOF */
3185 if(cur_time
- last_time
>= 100000 && !run_as_daemon
){
3187 last_time
= cur_time
;
3191 return AVERROR_EXIT
;
3192 if (key
== '+') av_log_set_level(av_log_get_level()+10);
3193 if (key
== '-') av_log_set_level(av_log_get_level()-10);
3194 if (key
== 's') qp_hist
^= 1;
3197 do_hex_dump
= do_pkt_dump
= 0;
3198 } else if(do_pkt_dump
){
3202 av_log_set_level(AV_LOG_DEBUG
);
3204 if (key
== 'c' || key
== 'C'){
3205 char buf
[4096], target
[64], command
[256], arg
[256] = {0};
3208 fprintf(stderr
, "\nEnter command: <target>|all <time>|-1 <command>[ <argument>]\n");
3210 while ((k
= read_key()) != '\n' && k
!= '\r' && i
< sizeof(buf
)-1)
3215 (n
= sscanf(buf
, "%63[^ ] %lf %255[^ ] %255[^\n]", target
, &time
, command
, arg
)) >= 3) {
3216 av_log(NULL
, AV_LOG_DEBUG
, "Processing command target:%s time:%f command:%s arg:%s",
3217 target
, time
, command
, arg
);
3218 for (i
= 0; i
< nb_filtergraphs
; i
++) {
3219 FilterGraph
*fg
= filtergraphs
[i
];
3222 ret
= avfilter_graph_send_command(fg
->graph
, target
, command
, arg
, buf
, sizeof(buf
),
3223 key
== 'c' ? AVFILTER_CMD_FLAG_ONE
: 0);
3224 fprintf(stderr
, "Command reply for stream %d: ret:%d res:\n%s", i
, ret
, buf
);
3225 } else if (key
== 'c') {
3226 fprintf(stderr
, "Queing commands only on filters supporting the specific command is unsupported\n");
3227 ret
= AVERROR_PATCHWELCOME
;
3229 ret
= avfilter_graph_queue_command(fg
->graph
, target
, command
, arg
, 0, time
);
3234 av_log(NULL
, AV_LOG_ERROR
,
3235 "Parse error, at least 3 arguments were expected, "
3236 "only %d given in string '%s'\n", n
, buf
);
3239 if (key
== 'd' || key
== 'D'){
3242 debug
= input_streams
[0]->st
->codec
->debug
<<1;
3243 if(!debug
) debug
= 1;
3244 while(debug
& (FF_DEBUG_DCT_COEFF
|FF_DEBUG_VIS_QP
|FF_DEBUG_VIS_MB_TYPE
)) //unsupported, would just crash
3247 if(scanf("%d", &debug
)!=1)
3248 fprintf(stderr
,"error parsing debug value\n");
3249 for(i
=0;i
<nb_input_streams
;i
++) {
3250 input_streams
[i
]->st
->codec
->debug
= debug
;
3252 for(i
=0;i
<nb_output_streams
;i
++) {
3253 OutputStream
*ost
= output_streams
[i
];
3254 ost
->enc_ctx
->debug
= debug
;
3256 if(debug
) av_log_set_level(AV_LOG_DEBUG
);
3257 fprintf(stderr
,"debug=%d\n", debug
);
3260 fprintf(stderr
, "key function\n"
3261 "? show this help\n"
3262 "+ increase verbosity\n"
3263 "- decrease verbosity\n"
3264 "c Send command to first matching filter supporting it\n"
3265 "C Send/Que command to all matching filters\n"
3266 "D cycle through available debug modes\n"
3267 "h dump packets/hex press to cycle through the 3 states\n"
3269 "s Show QP histogram\n"
3276 static void *input_thread(void *arg
)
3283 ret
= av_read_frame(f
->ctx
, &pkt
);
3285 if (ret
== AVERROR(EAGAIN
)) {
3290 av_thread_message_queue_set_err_recv(f
->in_thread_queue
, ret
);
3293 av_dup_packet(&pkt
);
3294 ret
= av_thread_message_queue_send(f
->in_thread_queue
, &pkt
, 0);
3296 if (ret
!= AVERROR_EOF
)
3297 av_log(f
->ctx
, AV_LOG_ERROR
,
3298 "Unable to send packet to main thread: %s\n",
3300 av_free_packet(&pkt
);
3301 av_thread_message_queue_set_err_recv(f
->in_thread_queue
, ret
);
3309 static void free_input_threads(void)
3313 for (i
= 0; i
< nb_input_files
; i
++) {
3314 InputFile
*f
= input_files
[i
];
3317 if (!f
->in_thread_queue
)
3319 av_thread_message_queue_set_err_send(f
->in_thread_queue
, AVERROR_EOF
);
3320 while (av_thread_message_queue_recv(f
->in_thread_queue
, &pkt
, 0) >= 0)
3321 av_free_packet(&pkt
);
3323 pthread_join(f
->thread
, NULL
);
3325 av_thread_message_queue_free(&f
->in_thread_queue
);
3329 static int init_input_threads(void)
3333 if (nb_input_files
== 1)
3336 for (i
= 0; i
< nb_input_files
; i
++) {
3337 InputFile
*f
= input_files
[i
];
3339 if (f
->ctx
->pb
? !f
->ctx
->pb
->seekable
:
3340 strcmp(f
->ctx
->iformat
->name
, "lavfi"))
3341 f
->non_blocking
= 1;
3342 ret
= av_thread_message_queue_alloc(&f
->in_thread_queue
,
3343 8, sizeof(AVPacket
));
3347 if ((ret
= pthread_create(&f
->thread
, NULL
, input_thread
, f
))) {
3348 av_log(NULL
, AV_LOG_ERROR
, "pthread_create failed: %s. Try to increase `ulimit -v` or decrease `ulimit -s`.\n", strerror(ret
));
3349 av_thread_message_queue_free(&f
->in_thread_queue
);
3350 return AVERROR(ret
);
3356 static int get_input_packet_mt(InputFile
*f
, AVPacket
*pkt
)
3358 return av_thread_message_queue_recv(f
->in_thread_queue
, pkt
,
3360 AV_THREAD_MESSAGE_NONBLOCK
: 0);
3364 static int get_input_packet(InputFile
*f
, AVPacket
*pkt
)
3368 for (i
= 0; i
< f
->nb_streams
; i
++) {
3369 InputStream
*ist
= input_streams
[f
->ist_index
+ i
];
3370 int64_t pts
= av_rescale(ist
->dts
, 1000000, AV_TIME_BASE
);
3371 int64_t now
= av_gettime_relative() - ist
->start
;
3373 return AVERROR(EAGAIN
);
3378 if (nb_input_files
> 1)
3379 return get_input_packet_mt(f
, pkt
);
3381 return av_read_frame(f
->ctx
, pkt
);
3384 static int got_eagain(void)
3387 for (i
= 0; i
< nb_output_streams
; i
++)
3388 if (output_streams
[i
]->unavailable
)
3393 static void reset_eagain(void)
3396 for (i
= 0; i
< nb_input_files
; i
++)
3397 input_files
[i
]->eagain
= 0;
3398 for (i
= 0; i
< nb_output_streams
; i
++)
3399 output_streams
[i
]->unavailable
= 0;
3404 * - 0 -- one packet was read and processed
3405 * - AVERROR(EAGAIN) -- no packets were available for selected file,
3406 * this function should be called again
3407 * - AVERROR_EOF -- this function should not be called again
3409 static int process_input(int file_index
)
3411 InputFile
*ifile
= input_files
[file_index
];
3412 AVFormatContext
*is
;
3418 ret
= get_input_packet(ifile
, &pkt
);
3420 if (ret
== AVERROR(EAGAIN
)) {
3425 if (ret
!= AVERROR_EOF
) {
3426 print_error(is
->filename
, ret
);
3431 for (i
= 0; i
< ifile
->nb_streams
; i
++) {
3432 ist
= input_streams
[ifile
->ist_index
+ i
];
3433 if (ist
->decoding_needed
) {
3434 ret
= process_input_packet(ist
, NULL
);
3439 /* mark all outputs that don't go through lavfi as finished */
3440 for (j
= 0; j
< nb_output_streams
; j
++) {
3441 OutputStream
*ost
= output_streams
[j
];
3443 if (ost
->source_index
== ifile
->ist_index
+ i
&&
3444 (ost
->stream_copy
|| ost
->enc
->type
== AVMEDIA_TYPE_SUBTITLE
))
3445 finish_output_stream(ost
);
3449 ifile
->eof_reached
= 1;
3450 return AVERROR(EAGAIN
);
3456 av_pkt_dump_log2(NULL
, AV_LOG_DEBUG
, &pkt
, do_hex_dump
,
3457 is
->streams
[pkt
.stream_index
]);
3459 /* the following test is needed in case new streams appear
3460 dynamically in stream : we ignore them */
3461 if (pkt
.stream_index
>= ifile
->nb_streams
) {
3462 report_new_stream(file_index
, &pkt
);
3463 goto discard_packet
;
3466 ist
= input_streams
[ifile
->ist_index
+ pkt
.stream_index
];
3468 ist
->data_size
+= pkt
.size
;
3472 goto discard_packet
;
3475 av_log(NULL
, AV_LOG_INFO
, "demuxer -> ist_index:%d type:%s "
3476 "next_dts:%s next_dts_time:%s next_pts:%s next_pts_time:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%s off_time:%s\n",
3477 ifile
->ist_index
+ pkt
.stream_index
, av_get_media_type_string(ist
->dec_ctx
->codec_type
),
3478 av_ts2str(ist
->next_dts
), av_ts2timestr(ist
->next_dts
, &AV_TIME_BASE_Q
),
3479 av_ts2str(ist
->next_pts
), av_ts2timestr(ist
->next_pts
, &AV_TIME_BASE_Q
),
3480 av_ts2str(pkt
.pts
), av_ts2timestr(pkt
.pts
, &ist
->st
->time_base
),
3481 av_ts2str(pkt
.dts
), av_ts2timestr(pkt
.dts
, &ist
->st
->time_base
),
3482 av_ts2str(input_files
[ist
->file_index
]->ts_offset
),
3483 av_ts2timestr(input_files
[ist
->file_index
]->ts_offset
, &AV_TIME_BASE_Q
));
3486 if(!ist
->wrap_correction_done
&& is
->start_time
!= AV_NOPTS_VALUE
&& ist
->st
->pts_wrap_bits
< 64){
3487 int64_t stime
, stime2
;
3488 // Correcting starttime based on the enabled streams
3489 // FIXME this ideally should be done before the first use of starttime but we do not know which are the enabled streams at that point.
3490 // so we instead do it here as part of discontinuity handling
3491 if ( ist
->next_dts
== AV_NOPTS_VALUE
3492 && ifile
->ts_offset
== -is
->start_time
3493 && (is
->iformat
->flags
& AVFMT_TS_DISCONT
)) {
3494 int64_t new_start_time
= INT64_MAX
;
3495 for (i
=0; i
<is
->nb_streams
; i
++) {
3496 AVStream
*st
= is
->streams
[i
];
3497 if(st
->discard
== AVDISCARD_ALL
|| st
->start_time
== AV_NOPTS_VALUE
)
3499 new_start_time
= FFMIN(new_start_time
, av_rescale_q(st
->start_time
, st
->time_base
, AV_TIME_BASE_Q
));
3501 if (new_start_time
> is
->start_time
) {
3502 av_log(is
, AV_LOG_VERBOSE
, "Correcting start time by %"PRId64
"\n", new_start_time
- is
->start_time
);
3503 ifile
->ts_offset
= -new_start_time
;
3507 stime
= av_rescale_q(is
->start_time
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
3508 stime2
= stime
+ (1ULL<<ist
->st
->pts_wrap_bits
);
3509 ist
->wrap_correction_done
= 1;
3511 if(stime2
> stime
&& pkt
.dts
!= AV_NOPTS_VALUE
&& pkt
.dts
> stime
+ (1LL<<(ist
->st
->pts_wrap_bits
-1))) {
3512 pkt
.dts
-= 1ULL<<ist
->st
->pts_wrap_bits
;
3513 ist
->wrap_correction_done
= 0;
3515 if(stime2
> stime
&& pkt
.pts
!= AV_NOPTS_VALUE
&& pkt
.pts
> stime
+ (1LL<<(ist
->st
->pts_wrap_bits
-1))) {
3516 pkt
.pts
-= 1ULL<<ist
->st
->pts_wrap_bits
;
3517 ist
->wrap_correction_done
= 0;
3521 /* add the stream-global side data to the first packet */
3522 if (ist
->nb_packets
== 1) {
3523 if (ist
->st
->nb_side_data
)
3524 av_packet_split_side_data(&pkt
);
3525 for (i
= 0; i
< ist
->st
->nb_side_data
; i
++) {
3526 AVPacketSideData
*src_sd
= &ist
->st
->side_data
[i
];
3529 if (av_packet_get_side_data(&pkt
, src_sd
->type
, NULL
))
3532 dst_data
= av_packet_new_side_data(&pkt
, src_sd
->type
, src_sd
->size
);
3536 memcpy(dst_data
, src_sd
->data
, src_sd
->size
);
3540 if (pkt
.dts
!= AV_NOPTS_VALUE
)
3541 pkt
.dts
+= av_rescale_q(ifile
->ts_offset
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
3542 if (pkt
.pts
!= AV_NOPTS_VALUE
)
3543 pkt
.pts
+= av_rescale_q(ifile
->ts_offset
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
3545 if (pkt
.pts
!= AV_NOPTS_VALUE
)
3546 pkt
.pts
*= ist
->ts_scale
;
3547 if (pkt
.dts
!= AV_NOPTS_VALUE
)
3548 pkt
.dts
*= ist
->ts_scale
;
3550 if ((ist
->dec_ctx
->codec_type
== AVMEDIA_TYPE_VIDEO
||
3551 ist
->dec_ctx
->codec_type
== AVMEDIA_TYPE_AUDIO
) &&
3552 pkt
.dts
!= AV_NOPTS_VALUE
&& ist
->next_dts
== AV_NOPTS_VALUE
&& !copy_ts
3553 && (is
->iformat
->flags
& AVFMT_TS_DISCONT
) && ifile
->last_ts
!= AV_NOPTS_VALUE
) {
3554 int64_t pkt_dts
= av_rescale_q(pkt
.dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
3555 int64_t delta
= pkt_dts
- ifile
->last_ts
;
3556 if (delta
< -1LL*dts_delta_threshold
*AV_TIME_BASE
||
3557 delta
> 1LL*dts_delta_threshold
*AV_TIME_BASE
){
3558 ifile
->ts_offset
-= delta
;
3559 av_log(NULL
, AV_LOG_DEBUG
,
3560 "Inter stream timestamp discontinuity %"PRId64
", new offset= %"PRId64
"\n",
3561 delta
, ifile
->ts_offset
);
3562 pkt
.dts
-= av_rescale_q(delta
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
3563 if (pkt
.pts
!= AV_NOPTS_VALUE
)
3564 pkt
.pts
-= av_rescale_q(delta
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
3568 if ((ist
->dec_ctx
->codec_type
== AVMEDIA_TYPE_VIDEO
||
3569 ist
->dec_ctx
->codec_type
== AVMEDIA_TYPE_AUDIO
) &&
3570 pkt
.dts
!= AV_NOPTS_VALUE
&& ist
->next_dts
!= AV_NOPTS_VALUE
&&
3572 int64_t pkt_dts
= av_rescale_q(pkt
.dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
3573 int64_t delta
= pkt_dts
- ist
->next_dts
;
3574 if (is
->iformat
->flags
& AVFMT_TS_DISCONT
) {
3575 if (delta
< -1LL*dts_delta_threshold
*AV_TIME_BASE
||
3576 delta
> 1LL*dts_delta_threshold
*AV_TIME_BASE
||
3577 pkt_dts
+ AV_TIME_BASE
/10 < FFMAX(ist
->pts
, ist
->dts
)) {
3578 ifile
->ts_offset
-= delta
;
3579 av_log(NULL
, AV_LOG_DEBUG
,
3580 "timestamp discontinuity %"PRId64
", new offset= %"PRId64
"\n",
3581 delta
, ifile
->ts_offset
);
3582 pkt
.dts
-= av_rescale_q(delta
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
3583 if (pkt
.pts
!= AV_NOPTS_VALUE
)
3584 pkt
.pts
-= av_rescale_q(delta
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
3587 if ( delta
< -1LL*dts_error_threshold
*AV_TIME_BASE
||
3588 delta
> 1LL*dts_error_threshold
*AV_TIME_BASE
) {
3589 av_log(NULL
, AV_LOG_WARNING
, "DTS %"PRId64
", next:%"PRId64
" st:%d invalid dropping\n", pkt
.dts
, ist
->next_dts
, pkt
.stream_index
);
3590 pkt
.dts
= AV_NOPTS_VALUE
;
3592 if (pkt
.pts
!= AV_NOPTS_VALUE
){
3593 int64_t pkt_pts
= av_rescale_q(pkt
.pts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
3594 delta
= pkt_pts
- ist
->next_dts
;
3595 if ( delta
< -1LL*dts_error_threshold
*AV_TIME_BASE
||
3596 delta
> 1LL*dts_error_threshold
*AV_TIME_BASE
) {
3597 av_log(NULL
, AV_LOG_WARNING
, "PTS %"PRId64
", next:%"PRId64
" invalid dropping st:%d\n", pkt
.pts
, ist
->next_dts
, pkt
.stream_index
);
3598 pkt
.pts
= AV_NOPTS_VALUE
;
3604 if (pkt
.dts
!= AV_NOPTS_VALUE
)
3605 ifile
->last_ts
= av_rescale_q(pkt
.dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
3608 av_log(NULL
, AV_LOG_INFO
, "demuxer+ffmpeg -> ist_index:%d type:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%s off_time:%s\n",
3609 ifile
->ist_index
+ pkt
.stream_index
, av_get_media_type_string(ist
->dec_ctx
->codec_type
),
3610 av_ts2str(pkt
.pts
), av_ts2timestr(pkt
.pts
, &ist
->st
->time_base
),
3611 av_ts2str(pkt
.dts
), av_ts2timestr(pkt
.dts
, &ist
->st
->time_base
),
3612 av_ts2str(input_files
[ist
->file_index
]->ts_offset
),
3613 av_ts2timestr(input_files
[ist
->file_index
]->ts_offset
, &AV_TIME_BASE_Q
));
3616 sub2video_heartbeat(ist
, pkt
.pts
);
3618 ret
= process_input_packet(ist
, &pkt
);
3620 av_log(NULL
, AV_LOG_ERROR
, "Error while decoding stream #%d:%d: %s\n",
3621 ist
->file_index
, ist
->st
->index
, av_err2str(ret
));
3627 av_free_packet(&pkt
);
3633 * Perform a step of transcoding for the specified filter graph.
3635 * @param[in] graph filter graph to consider
3636 * @param[out] best_ist input stream where a frame would allow to continue
3637 * @return 0 for success, <0 for error
3639 static int transcode_from_filter(FilterGraph
*graph
, InputStream
**best_ist
)
3642 int nb_requests
, nb_requests_max
= 0;
3643 InputFilter
*ifilter
;
3647 ret
= avfilter_graph_request_oldest(graph
->graph
);
3649 return reap_filters();
3651 if (ret
== AVERROR_EOF
) {
3652 ret
= reap_filters();
3653 for (i
= 0; i
< graph
->nb_outputs
; i
++)
3654 close_output_stream(graph
->outputs
[i
]->ost
);
3657 if (ret
!= AVERROR(EAGAIN
))
3660 for (i
= 0; i
< graph
->nb_inputs
; i
++) {
3661 ifilter
= graph
->inputs
[i
];
3663 if (input_files
[ist
->file_index
]->eagain
||
3664 input_files
[ist
->file_index
]->eof_reached
)
3666 nb_requests
= av_buffersrc_get_nb_failed_requests(ifilter
->filter
);
3667 if (nb_requests
> nb_requests_max
) {
3668 nb_requests_max
= nb_requests
;
3674 for (i
= 0; i
< graph
->nb_outputs
; i
++)
3675 graph
->outputs
[i
]->ost
->unavailable
= 1;
3681 * Run a single step of transcoding.
3683 * @return 0 for success, <0 for error
3685 static int transcode_step(void)
3691 ost
= choose_output();
3698 av_log(NULL
, AV_LOG_VERBOSE
, "No more inputs to read from, finishing.\n");
3703 if ((ret
= transcode_from_filter(ost
->filter
->graph
, &ist
)) < 0)
3708 av_assert0(ost
->source_index
>= 0);
3709 ist
= input_streams
[ost
->source_index
];
3712 ret
= process_input(ist
->file_index
);
3713 if (ret
== AVERROR(EAGAIN
)) {
3714 if (input_files
[ist
->file_index
]->eagain
)
3715 ost
->unavailable
= 1;
3719 return ret
== AVERROR_EOF
? 0 : ret
;
3721 return reap_filters();
3725 * The following code is the main loop of the file converter
3727 static int transcode(void)
3730 AVFormatContext
*os
;
3733 int64_t timer_start
;
3735 ret
= transcode_init();
3739 if (stdin_interaction
) {
3740 av_log(NULL
, AV_LOG_INFO
, "Press [q] to stop, [?] for help\n");
3743 timer_start
= av_gettime_relative();
3746 if ((ret
= init_input_threads()) < 0)
3750 while (!received_sigterm
) {
3751 int64_t cur_time
= av_gettime_relative();
3753 /* if 'q' pressed, exits */
3754 if (stdin_interaction
)
3755 if (check_keyboard_interaction(cur_time
) < 0)
3758 /* check if there's any stream where output is still needed */
3759 if (!need_output()) {
3760 av_log(NULL
, AV_LOG_VERBOSE
, "No more output streams to write to, finishing.\n");
3764 ret
= transcode_step();
3766 if (ret
== AVERROR_EOF
|| ret
== AVERROR(EAGAIN
))
3769 av_log(NULL
, AV_LOG_ERROR
, "Error while filtering.\n");
3773 /* dump report by using the output first video and audio streams */
3774 print_report(0, timer_start
, cur_time
);
3777 free_input_threads();
3780 /* at the end of stream, we must flush the decoder buffers */
3781 for (i
= 0; i
< nb_input_streams
; i
++) {
3782 ist
= input_streams
[i
];
3783 if (!input_files
[ist
->file_index
]->eof_reached
&& ist
->decoding_needed
) {
3784 process_input_packet(ist
, NULL
);
3791 /* write the trailer if needed and close file */
3792 for (i
= 0; i
< nb_output_files
; i
++) {
3793 os
= output_files
[i
]->ctx
;
3794 av_write_trailer(os
);
3797 /* dump report by using the first video and audio streams */
3798 print_report(1, timer_start
, av_gettime_relative());
3800 /* close each encoder */
3801 for (i
= 0; i
< nb_output_streams
; i
++) {
3802 ost
= output_streams
[i
];
3803 if (ost
->encoding_needed
) {
3804 av_freep(&ost
->enc_ctx
->stats_in
);
3808 /* close each decoder */
3809 for (i
= 0; i
< nb_input_streams
; i
++) {
3810 ist
= input_streams
[i
];
3811 if (ist
->decoding_needed
) {
3812 avcodec_close(ist
->dec_ctx
);
3813 if (ist
->hwaccel_uninit
)
3814 ist
->hwaccel_uninit(ist
->dec_ctx
);
3823 free_input_threads();
3826 if (output_streams
) {
3827 for (i
= 0; i
< nb_output_streams
; i
++) {
3828 ost
= output_streams
[i
];
3831 fclose(ost
->logfile
);
3832 ost
->logfile
= NULL
;
3834 av_freep(&ost
->forced_kf_pts
);
3835 av_freep(&ost
->apad
);
3836 av_dict_free(&ost
->encoder_opts
);
3837 av_dict_free(&ost
->swr_opts
);
3838 av_dict_free(&ost
->resample_opts
);
3839 av_dict_free(&ost
->bsf_args
);
3847 static int64_t getutime(void)
3850 struct rusage rusage
;
3852 getrusage(RUSAGE_SELF
, &rusage
);
3853 return (rusage
.ru_utime
.tv_sec
* 1000000LL) + rusage
.ru_utime
.tv_usec
;
3854 #elif HAVE_GETPROCESSTIMES
3856 FILETIME c
, e
, k
, u
;
3857 proc
= GetCurrentProcess();
3858 GetProcessTimes(proc
, &c
, &e
, &k
, &u
);
3859 return ((int64_t) u
.dwHighDateTime
<< 32 | u
.dwLowDateTime
) / 10;
3861 return av_gettime_relative();
3865 static int64_t getmaxrss(void)
3867 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3868 struct rusage rusage
;
3869 getrusage(RUSAGE_SELF
, &rusage
);
3870 return (int64_t)rusage
.ru_maxrss
* 1024;
3871 #elif HAVE_GETPROCESSMEMORYINFO
3873 PROCESS_MEMORY_COUNTERS memcounters
;
3874 proc
= GetCurrentProcess();
3875 memcounters
.cb
= sizeof(memcounters
);
3876 GetProcessMemoryInfo(proc
, &memcounters
, sizeof(memcounters
));
3877 return memcounters
.PeakPagefileUsage
;
3883 static void log_callback_null(void *ptr
, int level
, const char *fmt
, va_list vl
)
3887 int main(int argc
, char **argv
)
3892 register_exit(ffmpeg_cleanup
);
3894 setvbuf(stderr
,NULL
,_IONBF
,0); /* win32 runtime needs this */
3896 av_log_set_flags(AV_LOG_SKIP_REPEATED
);
3897 parse_loglevel(argc
, argv
, options
);
3899 if(argc
>1 && !strcmp(argv
[1], "-d")){
3901 av_log_set_callback(log_callback_null
);
3906 avcodec_register_all();
3908 avdevice_register_all();
3910 avfilter_register_all();
3912 avformat_network_init();
3914 show_banner(argc
, argv
, options
);
3918 /* parse options and open all input/output files */
3919 ret
= ffmpeg_parse_options(argc
, argv
);
3923 if (nb_output_files
<= 0 && nb_input_files
== 0) {
3925 av_log(NULL
, AV_LOG_WARNING
, "Use -h to get full help or, even better, run 'man %s'\n", program_name
);
3929 /* file converter / grab */
3930 if (nb_output_files
<= 0) {
3931 av_log(NULL
, AV_LOG_FATAL
, "At least one output file must be specified\n");
3935 // if (nb_input_files == 0) {
3936 // av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
3940 current_time
= ti
= getutime();
3941 if (transcode() < 0)
3943 ti
= getutime() - ti
;
3945 printf("bench: utime=%0.3fs\n", ti
/ 1000000.0);
3947 av_log(NULL
, AV_LOG_DEBUG
, "%"PRIu64
" frames successfully decoded, %"PRIu64
" decoding errors\n",
3948 decode_error_stat
[0], decode_error_stat
[1]);
3949 if ((decode_error_stat
[0] + decode_error_stat
[1]) * max_error_rate
< decode_error_stat
[1])
3952 exit_program(received_nb_signals
? 255 : main_return_code
);
3953 return main_return_code
;