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
);
479 av_parser_close(ost
->parser
);
481 av_freep(&ost
->forced_keyframes
);
482 av_expr_free(ost
->forced_keyframes_pexpr
);
483 av_freep(&ost
->avfilter
);
484 av_freep(&ost
->logfile_prefix
);
486 av_freep(&ost
->audio_channels_map
);
487 ost
->audio_channels_mapped
= 0;
489 avcodec_free_context(&ost
->enc_ctx
);
491 av_freep(&output_streams
[i
]);
494 free_input_threads();
496 for (i
= 0; i
< nb_input_files
; i
++) {
497 avformat_close_input(&input_files
[i
]->ctx
);
498 av_freep(&input_files
[i
]);
500 for (i
= 0; i
< nb_input_streams
; i
++) {
501 InputStream
*ist
= input_streams
[i
];
503 av_frame_free(&ist
->decoded_frame
);
504 av_frame_free(&ist
->filter_frame
);
505 av_dict_free(&ist
->decoder_opts
);
506 avsubtitle_free(&ist
->prev_sub
.subtitle
);
507 av_frame_free(&ist
->sub2video
.frame
);
508 av_freep(&ist
->filters
);
509 av_freep(&ist
->hwaccel_device
);
511 avcodec_free_context(&ist
->dec_ctx
);
513 av_freep(&input_streams
[i
]);
518 av_free(vstats_filename
);
520 av_freep(&input_streams
);
521 av_freep(&input_files
);
522 av_freep(&output_streams
);
523 av_freep(&output_files
);
527 avformat_network_deinit();
529 if (received_sigterm
) {
530 av_log(NULL
, AV_LOG_INFO
, "Received signal %d: terminating.\n",
531 (int) received_sigterm
);
532 } else if (ret
&& transcode_init_done
) {
533 av_log(NULL
, AV_LOG_INFO
, "Conversion failed!\n");
538 void remove_avoptions(AVDictionary
**a
, AVDictionary
*b
)
540 AVDictionaryEntry
*t
= NULL
;
542 while ((t
= av_dict_get(b
, "", t
, AV_DICT_IGNORE_SUFFIX
))) {
543 av_dict_set(a
, t
->key
, NULL
, AV_DICT_MATCH_CASE
);
547 void assert_avoptions(AVDictionary
*m
)
549 AVDictionaryEntry
*t
;
550 if ((t
= av_dict_get(m
, "", NULL
, AV_DICT_IGNORE_SUFFIX
))) {
551 av_log(NULL
, AV_LOG_FATAL
, "Option %s not found.\n", t
->key
);
556 static void abort_codec_experimental(AVCodec
*c
, int encoder
)
561 static void update_benchmark(const char *fmt
, ...)
563 if (do_benchmark_all
) {
564 int64_t t
= getutime();
570 vsnprintf(buf
, sizeof(buf
), fmt
, va
);
572 printf("bench: %8"PRIu64
" %s \n", t
- current_time
, buf
);
578 static void close_all_output_streams(OutputStream
*ost
, OSTFinished this_stream
, OSTFinished others
)
581 for (i
= 0; i
< nb_output_streams
; i
++) {
582 OutputStream
*ost2
= output_streams
[i
];
583 ost2
->finished
|= ost
== ost2
? this_stream
: others
;
587 static void write_frame(AVFormatContext
*s
, AVPacket
*pkt
, OutputStream
*ost
)
589 AVBitStreamFilterContext
*bsfc
= ost
->bitstream_filters
;
590 AVCodecContext
*avctx
= ost
->st
->codec
;
593 if (!ost
->st
->codec
->extradata_size
&& ost
->enc_ctx
->extradata_size
) {
594 ost
->st
->codec
->extradata
= av_mallocz(ost
->enc_ctx
->extradata_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
595 if (ost
->st
->codec
->extradata
) {
596 memcpy(ost
->st
->codec
->extradata
, ost
->enc_ctx
->extradata
, ost
->enc_ctx
->extradata_size
);
597 ost
->st
->codec
->extradata_size
= ost
->enc_ctx
->extradata_size
;
601 if ((avctx
->codec_type
== AVMEDIA_TYPE_VIDEO
&& video_sync_method
== VSYNC_DROP
) ||
602 (avctx
->codec_type
== AVMEDIA_TYPE_AUDIO
&& audio_sync_method
< 0))
603 pkt
->pts
= pkt
->dts
= AV_NOPTS_VALUE
;
606 * Audio encoders may split the packets -- #frames in != #packets out.
607 * But there is no reordering, so we can limit the number of output packets
608 * by simply dropping them here.
609 * Counting encoded video frames needs to be done separately because of
610 * reordering, see do_video_out()
612 if (!(avctx
->codec_type
== AVMEDIA_TYPE_VIDEO
&& avctx
->codec
)) {
613 if (ost
->frame_number
>= ost
->max_frames
) {
621 av_packet_split_side_data(pkt
);
624 AVPacket new_pkt
= *pkt
;
625 int a
= av_bitstream_filter_filter(bsfc
, avctx
, NULL
,
626 &new_pkt
.data
, &new_pkt
.size
,
627 pkt
->data
, pkt
->size
,
628 pkt
->flags
& AV_PKT_FLAG_KEY
);
629 if(a
== 0 && new_pkt
.data
!= pkt
->data
&& new_pkt
.destruct
) {
630 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
632 memcpy(t
, new_pkt
.data
, new_pkt
.size
);
633 memset(t
+ new_pkt
.size
, 0, FF_INPUT_BUFFER_PADDING_SIZE
);
641 pkt
->side_data
= NULL
;
642 pkt
->side_data_elems
= 0;
644 new_pkt
.buf
= av_buffer_create(new_pkt
.data
, new_pkt
.size
,
645 av_buffer_default_free
, NULL
, 0);
649 av_log(NULL
, AV_LOG_ERROR
, "Failed to open bitstream filter %s for stream %d with codec %s",
650 bsfc
->filter
->name
, pkt
->stream_index
,
651 avctx
->codec
? avctx
->codec
->name
: "copy");
661 if (!(s
->oformat
->flags
& AVFMT_NOTIMESTAMPS
)) {
663 (avctx
->codec_type
== AVMEDIA_TYPE_AUDIO
|| avctx
->codec_type
== AVMEDIA_TYPE_VIDEO
) &&
664 pkt
->dts
!= AV_NOPTS_VALUE
&&
665 ost
->last_mux_dts
!= AV_NOPTS_VALUE
) {
666 int64_t max
= ost
->last_mux_dts
+ !(s
->oformat
->flags
& AVFMT_TS_NONSTRICT
);
667 if (pkt
->dts
< max
) {
668 int loglevel
= max
- pkt
->dts
> 2 || avctx
->codec_type
== AVMEDIA_TYPE_VIDEO
? AV_LOG_WARNING
: AV_LOG_DEBUG
;
669 av_log(s
, loglevel
, "Non-monotonous DTS in output stream "
670 "%d:%d; previous: %"PRId64
", current: %"PRId64
"; ",
671 ost
->file_index
, ost
->st
->index
, ost
->last_mux_dts
, pkt
->dts
);
673 av_log(NULL
, AV_LOG_FATAL
, "aborting.\n");
676 av_log(s
, loglevel
, "changing to %"PRId64
". This may result "
677 "in incorrect timestamps in the output file.\n",
679 if(pkt
->pts
>= pkt
->dts
)
680 pkt
->pts
= FFMAX(pkt
->pts
, max
);
684 if (pkt
->dts
!= AV_NOPTS_VALUE
&&
685 pkt
->pts
!= AV_NOPTS_VALUE
&&
686 pkt
->dts
> pkt
->pts
) {
687 av_log(s
, AV_LOG_WARNING
, "Invalid DTS: %"PRId64
" PTS: %"PRId64
" in output stream %d:%d\n",
689 ost
->file_index
, ost
->st
->index
);
690 pkt
->pts
= AV_NOPTS_VALUE
;
691 pkt
->dts
= AV_NOPTS_VALUE
;
694 ost
->last_mux_dts
= pkt
->dts
;
696 ost
->data_size
+= pkt
->size
;
697 ost
->packets_written
++;
699 pkt
->stream_index
= ost
->index
;
702 av_log(NULL
, AV_LOG_INFO
, "muxer <- type:%s "
703 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s size:%d\n",
704 av_get_media_type_string(ost
->enc_ctx
->codec_type
),
705 av_ts2str(pkt
->pts
), av_ts2timestr(pkt
->pts
, &ost
->st
->time_base
),
706 av_ts2str(pkt
->dts
), av_ts2timestr(pkt
->dts
, &ost
->st
->time_base
),
711 ret
= av_interleaved_write_frame(s
, pkt
);
713 print_error("av_interleaved_write_frame()", ret
);
714 main_return_code
= 1;
715 close_all_output_streams(ost
, MUXER_FINISHED
| ENCODER_FINISHED
, ENCODER_FINISHED
);
720 static void close_output_stream(OutputStream
*ost
)
722 OutputFile
*of
= output_files
[ost
->file_index
];
724 ost
->finished
|= ENCODER_FINISHED
;
726 int64_t end
= av_rescale_q(ost
->sync_opts
- ost
->first_pts
, ost
->enc_ctx
->time_base
, AV_TIME_BASE_Q
);
727 of
->recording_time
= FFMIN(of
->recording_time
, end
);
731 static int check_recording_time(OutputStream
*ost
)
733 OutputFile
*of
= output_files
[ost
->file_index
];
735 if (of
->recording_time
!= INT64_MAX
&&
736 av_compare_ts(ost
->sync_opts
- ost
->first_pts
, ost
->enc_ctx
->time_base
, of
->recording_time
,
737 AV_TIME_BASE_Q
) >= 0) {
738 close_output_stream(ost
);
744 static void do_audio_out(AVFormatContext
*s
, OutputStream
*ost
,
747 AVCodecContext
*enc
= ost
->enc_ctx
;
751 av_init_packet(&pkt
);
755 if (!check_recording_time(ost
))
758 if (frame
->pts
== AV_NOPTS_VALUE
|| audio_sync_method
< 0)
759 frame
->pts
= ost
->sync_opts
;
760 ost
->sync_opts
= frame
->pts
+ frame
->nb_samples
;
761 ost
->samples_encoded
+= frame
->nb_samples
;
762 ost
->frames_encoded
++;
764 av_assert0(pkt
.size
|| !pkt
.data
);
765 update_benchmark(NULL
);
767 av_log(NULL
, AV_LOG_INFO
, "encoder <- type:audio "
768 "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
769 av_ts2str(frame
->pts
), av_ts2timestr(frame
->pts
, &enc
->time_base
),
770 enc
->time_base
.num
, enc
->time_base
.den
);
773 if (avcodec_encode_audio2(enc
, &pkt
, frame
, &got_packet
) < 0) {
774 av_log(NULL
, AV_LOG_FATAL
, "Audio encoding failed (avcodec_encode_audio2)\n");
777 update_benchmark("encode_audio %d.%d", ost
->file_index
, ost
->index
);
780 av_packet_rescale_ts(&pkt
, enc
->time_base
, ost
->st
->time_base
);
783 av_log(NULL
, AV_LOG_INFO
, "encoder -> type:audio "
784 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
785 av_ts2str(pkt
.pts
), av_ts2timestr(pkt
.pts
, &ost
->st
->time_base
),
786 av_ts2str(pkt
.dts
), av_ts2timestr(pkt
.dts
, &ost
->st
->time_base
));
789 write_frame(s
, &pkt
, ost
);
793 static void do_subtitle_out(AVFormatContext
*s
,
798 int subtitle_out_max_size
= 1024 * 1024;
799 int subtitle_out_size
, nb
, i
;
804 if (sub
->pts
== AV_NOPTS_VALUE
) {
805 av_log(NULL
, AV_LOG_ERROR
, "Subtitle packets must have a pts\n");
814 subtitle_out
= av_malloc(subtitle_out_max_size
);
817 /* Note: DVB subtitle need one packet to draw them and one other
818 packet to clear them */
819 /* XXX: signal it in the codec context ? */
820 if (enc
->codec_id
== AV_CODEC_ID_DVB_SUBTITLE
)
825 /* shift timestamp to honor -ss and make check_recording_time() work with -t */
827 if (output_files
[ost
->file_index
]->start_time
!= AV_NOPTS_VALUE
)
828 pts
-= output_files
[ost
->file_index
]->start_time
;
829 for (i
= 0; i
< nb
; i
++) {
830 unsigned save_num_rects
= sub
->num_rects
;
832 ost
->sync_opts
= av_rescale_q(pts
, AV_TIME_BASE_Q
, enc
->time_base
);
833 if (!check_recording_time(ost
))
837 // start_display_time is required to be 0
838 sub
->pts
+= av_rescale_q(sub
->start_display_time
, (AVRational
){ 1, 1000 }, AV_TIME_BASE_Q
);
839 sub
->end_display_time
-= sub
->start_display_time
;
840 sub
->start_display_time
= 0;
844 ost
->frames_encoded
++;
846 subtitle_out_size
= avcodec_encode_subtitle(enc
, subtitle_out
,
847 subtitle_out_max_size
, sub
);
849 sub
->num_rects
= save_num_rects
;
850 if (subtitle_out_size
< 0) {
851 av_log(NULL
, AV_LOG_FATAL
, "Subtitle encoding failed\n");
855 av_init_packet(&pkt
);
856 pkt
.data
= subtitle_out
;
857 pkt
.size
= subtitle_out_size
;
858 pkt
.pts
= av_rescale_q(sub
->pts
, AV_TIME_BASE_Q
, ost
->st
->time_base
);
859 pkt
.duration
= av_rescale_q(sub
->end_display_time
, (AVRational
){ 1, 1000 }, ost
->st
->time_base
);
860 if (enc
->codec_id
== AV_CODEC_ID_DVB_SUBTITLE
) {
861 /* XXX: the pts correction is handled here. Maybe handling
862 it in the codec would be better */
864 pkt
.pts
+= 90 * sub
->start_display_time
;
866 pkt
.pts
+= 90 * sub
->end_display_time
;
869 write_frame(s
, &pkt
, ost
);
873 static void do_video_out(AVFormatContext
*s
,
877 int ret
, format_video_sync
;
879 AVCodecContext
*enc
= ost
->enc_ctx
;
880 AVCodecContext
*mux_enc
= ost
->st
->codec
;
882 double sync_ipts
, delta
;
885 InputStream
*ist
= NULL
;
887 if (ost
->source_index
>= 0)
888 ist
= input_streams
[ost
->source_index
];
890 if(ist
&& ist
->st
->start_time
!= AV_NOPTS_VALUE
&& ist
->st
->first_dts
!= AV_NOPTS_VALUE
&& ost
->frame_rate
.num
)
891 duration
= 1/(av_q2d(ost
->frame_rate
) * av_q2d(enc
->time_base
));
893 sync_ipts
= in_picture
->pts
;
894 delta
= sync_ipts
- ost
->sync_opts
+ duration
;
896 /* by default, we output a single frame */
899 format_video_sync
= video_sync_method
;
900 if (format_video_sync
== VSYNC_AUTO
) {
901 if(!strcmp(s
->oformat
->name
, "avi")) {
902 format_video_sync
= VSYNC_VFR
;
904 format_video_sync
= (s
->oformat
->flags
& AVFMT_VARIABLE_FPS
) ? ((s
->oformat
->flags
& AVFMT_NOTIMESTAMPS
) ? VSYNC_PASSTHROUGH
: VSYNC_VFR
) : VSYNC_CFR
;
906 && format_video_sync
== VSYNC_CFR
907 && input_files
[ist
->file_index
]->ctx
->nb_streams
== 1
908 && input_files
[ist
->file_index
]->input_ts_offset
== 0) {
909 format_video_sync
= VSYNC_VSCFR
;
911 if (format_video_sync
== VSYNC_CFR
&& copy_ts
) {
912 format_video_sync
= VSYNC_VSCFR
;
916 switch (format_video_sync
) {
918 if (ost
->frame_number
== 0 && delta
- duration
>= 0.5) {
919 av_log(NULL
, AV_LOG_DEBUG
, "Not duplicating %d initial frames\n", (int)lrintf(delta
- duration
));
921 ost
->sync_opts
= lrint(sync_ipts
);
924 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
927 else if (delta
> 1.1)
928 nb_frames
= lrintf(delta
);
933 else if (delta
> 0.6)
934 ost
->sync_opts
= lrint(sync_ipts
);
937 case VSYNC_PASSTHROUGH
:
938 ost
->sync_opts
= lrint(sync_ipts
);
944 nb_frames
= FFMIN(nb_frames
, ost
->max_frames
- ost
->frame_number
);
945 if (nb_frames
== 0) {
947 av_log(NULL
, AV_LOG_VERBOSE
,
948 "*** dropping frame %d from stream %d at ts %"PRId64
"\n",
949 ost
->frame_number
, ost
->st
->index
, in_picture
->pts
);
951 } else if (nb_frames
> 1) {
952 if (nb_frames
> dts_error_threshold
* 30) {
953 av_log(NULL
, AV_LOG_ERROR
, "%d frame duplication too large, skipping\n", nb_frames
- 1);
957 nb_frames_dup
+= nb_frames
- 1;
958 av_log(NULL
, AV_LOG_VERBOSE
, "*** %d dup!\n", nb_frames
- 1);
961 /* duplicates frame if needed */
962 for (i
= 0; i
< nb_frames
; i
++) {
963 av_init_packet(&pkt
);
967 in_picture
->pts
= ost
->sync_opts
;
970 if (!check_recording_time(ost
))
972 if (ost
->frame_number
>= ost
->max_frames
)
976 if (s
->oformat
->flags
& AVFMT_RAWPICTURE
&&
977 enc
->codec
->id
== AV_CODEC_ID_RAWVIDEO
) {
978 /* raw pictures are written as AVPicture structure to
979 avoid any copies. We support temporarily the older
981 mux_enc
->coded_frame
->interlaced_frame
= in_picture
->interlaced_frame
;
982 mux_enc
->coded_frame
->top_field_first
= in_picture
->top_field_first
;
983 if (mux_enc
->coded_frame
->interlaced_frame
)
984 mux_enc
->field_order
= mux_enc
->coded_frame
->top_field_first
? AV_FIELD_TB
:AV_FIELD_BT
;
986 mux_enc
->field_order
= AV_FIELD_PROGRESSIVE
;
987 pkt
.data
= (uint8_t *)in_picture
;
988 pkt
.size
= sizeof(AVPicture
);
989 pkt
.pts
= av_rescale_q(in_picture
->pts
, enc
->time_base
, ost
->st
->time_base
);
990 pkt
.flags
|= AV_PKT_FLAG_KEY
;
992 write_frame(s
, &pkt
, ost
);
994 int got_packet
, forced_keyframe
= 0;
997 if (enc
->flags
& (CODEC_FLAG_INTERLACED_DCT
|CODEC_FLAG_INTERLACED_ME
) &&
998 ost
->top_field_first
>= 0)
999 in_picture
->top_field_first
= !!ost
->top_field_first
;
1001 if (in_picture
->interlaced_frame
) {
1002 if (enc
->codec
->id
== AV_CODEC_ID_MJPEG
)
1003 mux_enc
->field_order
= in_picture
->top_field_first
? AV_FIELD_TT
:AV_FIELD_BB
;
1005 mux_enc
->field_order
= in_picture
->top_field_first
? AV_FIELD_TB
:AV_FIELD_BT
;
1007 mux_enc
->field_order
= AV_FIELD_PROGRESSIVE
;
1009 in_picture
->quality
= enc
->global_quality
;
1010 if (!enc
->me_threshold
)
1011 in_picture
->pict_type
= 0;
1013 pts_time
= in_picture
->pts
!= AV_NOPTS_VALUE
?
1014 in_picture
->pts
* av_q2d(enc
->time_base
) : NAN
;
1015 if (ost
->forced_kf_index
< ost
->forced_kf_count
&&
1016 in_picture
->pts
>= ost
->forced_kf_pts
[ost
->forced_kf_index
]) {
1017 ost
->forced_kf_index
++;
1018 forced_keyframe
= 1;
1019 } else if (ost
->forced_keyframes_pexpr
) {
1021 ost
->forced_keyframes_expr_const_values
[FKF_T
] = pts_time
;
1022 res
= av_expr_eval(ost
->forced_keyframes_pexpr
,
1023 ost
->forced_keyframes_expr_const_values
, NULL
);
1024 av_dlog(NULL
, "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",
1025 ost
->forced_keyframes_expr_const_values
[FKF_N
],
1026 ost
->forced_keyframes_expr_const_values
[FKF_N_FORCED
],
1027 ost
->forced_keyframes_expr_const_values
[FKF_PREV_FORCED_N
],
1028 ost
->forced_keyframes_expr_const_values
[FKF_T
],
1029 ost
->forced_keyframes_expr_const_values
[FKF_PREV_FORCED_T
],
1032 forced_keyframe
= 1;
1033 ost
->forced_keyframes_expr_const_values
[FKF_PREV_FORCED_N
] =
1034 ost
->forced_keyframes_expr_const_values
[FKF_N
];
1035 ost
->forced_keyframes_expr_const_values
[FKF_PREV_FORCED_T
] =
1036 ost
->forced_keyframes_expr_const_values
[FKF_T
];
1037 ost
->forced_keyframes_expr_const_values
[FKF_N_FORCED
] += 1;
1040 ost
->forced_keyframes_expr_const_values
[FKF_N
] += 1;
1043 if (forced_keyframe
) {
1044 in_picture
->pict_type
= AV_PICTURE_TYPE_I
;
1045 av_log(NULL
, AV_LOG_DEBUG
, "Forced keyframe at time %f\n", pts_time
);
1048 update_benchmark(NULL
);
1050 av_log(NULL
, AV_LOG_INFO
, "encoder <- type:video "
1051 "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
1052 av_ts2str(in_picture
->pts
), av_ts2timestr(in_picture
->pts
, &enc
->time_base
),
1053 enc
->time_base
.num
, enc
->time_base
.den
);
1056 ost
->frames_encoded
++;
1058 ret
= avcodec_encode_video2(enc
, &pkt
, in_picture
, &got_packet
);
1059 update_benchmark("encode_video %d.%d", ost
->file_index
, ost
->index
);
1061 av_log(NULL
, AV_LOG_FATAL
, "Video encoding failed\n");
1067 av_log(NULL
, AV_LOG_INFO
, "encoder -> type:video "
1068 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1069 av_ts2str(pkt
.pts
), av_ts2timestr(pkt
.pts
, &enc
->time_base
),
1070 av_ts2str(pkt
.dts
), av_ts2timestr(pkt
.dts
, &enc
->time_base
));
1073 if (pkt
.pts
== AV_NOPTS_VALUE
&& !(enc
->codec
->capabilities
& CODEC_CAP_DELAY
))
1074 pkt
.pts
= ost
->sync_opts
;
1076 av_packet_rescale_ts(&pkt
, enc
->time_base
, ost
->st
->time_base
);
1079 av_log(NULL
, AV_LOG_INFO
, "encoder -> type:video "
1080 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1081 av_ts2str(pkt
.pts
), av_ts2timestr(pkt
.pts
, &ost
->st
->time_base
),
1082 av_ts2str(pkt
.dts
), av_ts2timestr(pkt
.dts
, &ost
->st
->time_base
));
1085 frame_size
= pkt
.size
;
1086 write_frame(s
, &pkt
, ost
);
1088 /* if two pass, output log */
1089 if (ost
->logfile
&& enc
->stats_out
) {
1090 fprintf(ost
->logfile
, "%s", enc
->stats_out
);
1096 * For video, number of frames in == number of packets out.
1097 * But there may be reordering, so we can't throw away frames on encoder
1098 * flush, we need to limit them here, before they go into encoder.
1100 ost
->frame_number
++;
1102 if (vstats_filename
&& frame_size
)
1103 do_video_stats(ost
, frame_size
);
1107 static double psnr(double d
)
1109 return -10.0 * log(d
) / log(10.0);
1112 static void do_video_stats(OutputStream
*ost
, int frame_size
)
1114 AVCodecContext
*enc
;
1116 double ti1
, bitrate
, avg_bitrate
;
1118 /* this is executed just the first time do_video_stats is called */
1120 vstats_file
= fopen(vstats_filename
, "w");
1128 if (enc
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
1129 frame_number
= ost
->st
->nb_frames
;
1130 fprintf(vstats_file
, "frame= %5d q= %2.1f ", frame_number
, enc
->coded_frame
->quality
/ (float)FF_QP2LAMBDA
);
1131 if (enc
->flags
&CODEC_FLAG_PSNR
)
1132 fprintf(vstats_file
, "PSNR= %6.2f ", psnr(enc
->coded_frame
->error
[0] / (enc
->width
* enc
->height
* 255.0 * 255.0)));
1134 fprintf(vstats_file
,"f_size= %6d ", frame_size
);
1135 /* compute pts value */
1136 ti1
= av_stream_get_end_pts(ost
->st
) * av_q2d(ost
->st
->time_base
);
1140 bitrate
= (frame_size
* 8) / av_q2d(enc
->time_base
) / 1000.0;
1141 avg_bitrate
= (double)(ost
->data_size
* 8) / ti1
/ 1000.0;
1142 fprintf(vstats_file
, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1143 (double)ost
->data_size
/ 1024, ti1
, bitrate
, avg_bitrate
);
1144 fprintf(vstats_file
, "type= %c\n", av_get_picture_type_char(enc
->coded_frame
->pict_type
));
1148 static void finish_output_stream(OutputStream
*ost
)
1150 OutputFile
*of
= output_files
[ost
->file_index
];
1153 ost
->finished
= ENCODER_FINISHED
| MUXER_FINISHED
;
1156 for (i
= 0; i
< of
->ctx
->nb_streams
; i
++)
1157 output_streams
[of
->ost_index
+ i
]->finished
= ENCODER_FINISHED
| MUXER_FINISHED
;
1162 * Get and encode new output from any of the filtergraphs, without causing
1165 * @return 0 for success, <0 for severe errors
1167 static int reap_filters(void)
1169 AVFrame
*filtered_frame
= NULL
;
1173 /* Reap all buffers present in the buffer sinks */
1174 for (i
= 0; i
< nb_output_streams
; i
++) {
1175 OutputStream
*ost
= output_streams
[i
];
1176 OutputFile
*of
= output_files
[ost
->file_index
];
1177 AVFilterContext
*filter
;
1178 AVCodecContext
*enc
= ost
->enc_ctx
;
1183 filter
= ost
->filter
->filter
;
1185 if (!ost
->filtered_frame
&& !(ost
->filtered_frame
= av_frame_alloc())) {
1186 return AVERROR(ENOMEM
);
1188 filtered_frame
= ost
->filtered_frame
;
1191 ret
= av_buffersink_get_frame_flags(filter
, filtered_frame
,
1192 AV_BUFFERSINK_FLAG_NO_REQUEST
);
1194 if (ret
!= AVERROR(EAGAIN
) && ret
!= AVERROR_EOF
) {
1195 av_log(NULL
, AV_LOG_WARNING
,
1196 "Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret
));
1200 if (ost
->finished
) {
1201 av_frame_unref(filtered_frame
);
1204 frame_pts
= AV_NOPTS_VALUE
;
1205 if (filtered_frame
->pts
!= AV_NOPTS_VALUE
) {
1206 int64_t start_time
= (of
->start_time
== AV_NOPTS_VALUE
) ? 0 : of
->start_time
;
1207 filtered_frame
->pts
= frame_pts
=
1208 av_rescale_q(filtered_frame
->pts
, filter
->inputs
[0]->time_base
, enc
->time_base
) -
1209 av_rescale_q(start_time
, AV_TIME_BASE_Q
, enc
->time_base
);
1211 //if (ost->source_index >= 0)
1212 // *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
1214 switch (filter
->inputs
[0]->type
) {
1215 case AVMEDIA_TYPE_VIDEO
:
1216 filtered_frame
->pts
= frame_pts
;
1217 if (!ost
->frame_aspect_ratio
.num
)
1218 enc
->sample_aspect_ratio
= filtered_frame
->sample_aspect_ratio
;
1221 av_log(NULL
, AV_LOG_INFO
, "filter -> pts:%s pts_time:%s time_base:%d/%d\n",
1222 av_ts2str(filtered_frame
->pts
), av_ts2timestr(filtered_frame
->pts
, &enc
->time_base
),
1223 enc
->time_base
.num
, enc
->time_base
.den
);
1226 do_video_out(of
->ctx
, ost
, filtered_frame
);
1228 case AVMEDIA_TYPE_AUDIO
:
1229 filtered_frame
->pts
= frame_pts
;
1230 if (!(enc
->codec
->capabilities
& CODEC_CAP_PARAM_CHANGE
) &&
1231 enc
->channels
!= av_frame_get_channels(filtered_frame
)) {
1232 av_log(NULL
, AV_LOG_ERROR
,
1233 "Audio filter graph output is not normalized and encoder does not support parameter changes\n");
1236 do_audio_out(of
->ctx
, ost
, filtered_frame
);
1239 // TODO support subtitle filters
1243 av_frame_unref(filtered_frame
);
1250 static void print_final_stats(int64_t total_size
)
1252 uint64_t video_size
= 0, audio_size
= 0, extra_size
= 0, other_size
= 0;
1253 uint64_t subtitle_size
= 0;
1254 uint64_t data_size
= 0;
1255 float percent
= -1.0;
1258 for (i
= 0; i
< nb_output_streams
; i
++) {
1259 OutputStream
*ost
= output_streams
[i
];
1260 switch (ost
->enc_ctx
->codec_type
) {
1261 case AVMEDIA_TYPE_VIDEO
: video_size
+= ost
->data_size
; break;
1262 case AVMEDIA_TYPE_AUDIO
: audio_size
+= ost
->data_size
; break;
1263 case AVMEDIA_TYPE_SUBTITLE
: subtitle_size
+= ost
->data_size
; break;
1264 default: other_size
+= ost
->data_size
; break;
1266 extra_size
+= ost
->enc_ctx
->extradata_size
;
1267 data_size
+= ost
->data_size
;
1270 if (data_size
&& total_size
>0 && total_size
>= data_size
)
1271 percent
= 100.0 * (total_size
- data_size
) / data_size
;
1273 av_log(NULL
, AV_LOG_INFO
, "\n");
1274 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: ",
1275 video_size
/ 1024.0,
1276 audio_size
/ 1024.0,
1277 subtitle_size
/ 1024.0,
1278 other_size
/ 1024.0,
1279 extra_size
/ 1024.0);
1281 av_log(NULL
, AV_LOG_INFO
, "%f%%", percent
);
1283 av_log(NULL
, AV_LOG_INFO
, "unknown");
1284 av_log(NULL
, AV_LOG_INFO
, "\n");
1286 /* print verbose per-stream stats */
1287 for (i
= 0; i
< nb_input_files
; i
++) {
1288 InputFile
*f
= input_files
[i
];
1289 uint64_t total_packets
= 0, total_size
= 0;
1291 av_log(NULL
, AV_LOG_VERBOSE
, "Input file #%d (%s):\n",
1292 i
, f
->ctx
->filename
);
1294 for (j
= 0; j
< f
->nb_streams
; j
++) {
1295 InputStream
*ist
= input_streams
[f
->ist_index
+ j
];
1296 enum AVMediaType type
= ist
->dec_ctx
->codec_type
;
1298 total_size
+= ist
->data_size
;
1299 total_packets
+= ist
->nb_packets
;
1301 av_log(NULL
, AV_LOG_VERBOSE
, " Input stream #%d:%d (%s): ",
1302 i
, j
, media_type_string(type
));
1303 av_log(NULL
, AV_LOG_VERBOSE
, "%"PRIu64
" packets read (%"PRIu64
" bytes); ",
1304 ist
->nb_packets
, ist
->data_size
);
1306 if (ist
->decoding_needed
) {
1307 av_log(NULL
, AV_LOG_VERBOSE
, "%"PRIu64
" frames decoded",
1308 ist
->frames_decoded
);
1309 if (type
== AVMEDIA_TYPE_AUDIO
)
1310 av_log(NULL
, AV_LOG_VERBOSE
, " (%"PRIu64
" samples)", ist
->samples_decoded
);
1311 av_log(NULL
, AV_LOG_VERBOSE
, "; ");
1314 av_log(NULL
, AV_LOG_VERBOSE
, "\n");
1317 av_log(NULL
, AV_LOG_VERBOSE
, " Total: %"PRIu64
" packets (%"PRIu64
" bytes) demuxed\n",
1318 total_packets
, total_size
);
1321 for (i
= 0; i
< nb_output_files
; i
++) {
1322 OutputFile
*of
= output_files
[i
];
1323 uint64_t total_packets
= 0, total_size
= 0;
1325 av_log(NULL
, AV_LOG_VERBOSE
, "Output file #%d (%s):\n",
1326 i
, of
->ctx
->filename
);
1328 for (j
= 0; j
< of
->ctx
->nb_streams
; j
++) {
1329 OutputStream
*ost
= output_streams
[of
->ost_index
+ j
];
1330 enum AVMediaType type
= ost
->enc_ctx
->codec_type
;
1332 total_size
+= ost
->data_size
;
1333 total_packets
+= ost
->packets_written
;
1335 av_log(NULL
, AV_LOG_VERBOSE
, " Output stream #%d:%d (%s): ",
1336 i
, j
, media_type_string(type
));
1337 if (ost
->encoding_needed
) {
1338 av_log(NULL
, AV_LOG_VERBOSE
, "%"PRIu64
" frames encoded",
1339 ost
->frames_encoded
);
1340 if (type
== AVMEDIA_TYPE_AUDIO
)
1341 av_log(NULL
, AV_LOG_VERBOSE
, " (%"PRIu64
" samples)", ost
->samples_encoded
);
1342 av_log(NULL
, AV_LOG_VERBOSE
, "; ");
1345 av_log(NULL
, AV_LOG_VERBOSE
, "%"PRIu64
" packets muxed (%"PRIu64
" bytes); ",
1346 ost
->packets_written
, ost
->data_size
);
1348 av_log(NULL
, AV_LOG_VERBOSE
, "\n");
1351 av_log(NULL
, AV_LOG_VERBOSE
, " Total: %"PRIu64
" packets (%"PRIu64
" bytes) muxed\n",
1352 total_packets
, total_size
);
1354 if(video_size
+ data_size
+ audio_size
+ subtitle_size
+ extra_size
== 0){
1355 av_log(NULL
, AV_LOG_WARNING
, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
1359 static void print_report(int is_last_report
, int64_t timer_start
, int64_t cur_time
)
1362 AVBPrint buf_script
;
1364 AVFormatContext
*oc
;
1366 AVCodecContext
*enc
;
1367 int frame_number
, vid
, i
;
1369 int64_t pts
= INT64_MIN
;
1370 static int64_t last_time
= -1;
1371 static int qp_histogram
[52];
1372 int hours
, mins
, secs
, us
;
1374 if (!print_stats
&& !is_last_report
&& !progress_avio
)
1377 if (!is_last_report
) {
1378 if (last_time
== -1) {
1379 last_time
= cur_time
;
1382 if ((cur_time
- last_time
) < 500000)
1384 last_time
= cur_time
;
1388 oc
= output_files
[0]->ctx
;
1390 total_size
= avio_size(oc
->pb
);
1391 if (total_size
<= 0) // FIXME improve avio_size() so it works with non seekable output too
1392 total_size
= avio_tell(oc
->pb
);
1396 av_bprint_init(&buf_script
, 0, 1);
1397 for (i
= 0; i
< nb_output_streams
; i
++) {
1399 ost
= output_streams
[i
];
1401 if (!ost
->stream_copy
&& enc
->coded_frame
)
1402 q
= enc
->coded_frame
->quality
/ (float)FF_QP2LAMBDA
;
1403 if (vid
&& enc
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
1404 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "q=%2.1f ", q
);
1405 av_bprintf(&buf_script
, "stream_%d_%d_q=%.1f\n",
1406 ost
->file_index
, ost
->index
, q
);
1408 if (!vid
&& enc
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
1409 float fps
, t
= (cur_time
-timer_start
) / 1000000.0;
1411 frame_number
= ost
->frame_number
;
1412 fps
= t
> 1 ? frame_number
/ t
: 0;
1413 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "frame=%5d fps=%3.*f q=%3.1f ",
1414 frame_number
, fps
< 9.95, fps
, q
);
1415 av_bprintf(&buf_script
, "frame=%d\n", frame_number
);
1416 av_bprintf(&buf_script
, "fps=%.1f\n", fps
);
1417 av_bprintf(&buf_script
, "stream_%d_%d_q=%.1f\n",
1418 ost
->file_index
, ost
->index
, q
);
1420 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "L");
1424 if (qp
>= 0 && qp
< FF_ARRAY_ELEMS(qp_histogram
))
1426 for (j
= 0; j
< 32; j
++)
1427 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "%X", (int)lrintf(log2(qp_histogram
[j
] + 1)));
1429 if ((enc
->flags
&CODEC_FLAG_PSNR
) && (enc
->coded_frame
|| is_last_report
)) {
1431 double error
, error_sum
= 0;
1432 double scale
, scale_sum
= 0;
1434 char type
[3] = { 'Y','U','V' };
1435 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "PSNR=");
1436 for (j
= 0; j
< 3; j
++) {
1437 if (is_last_report
) {
1438 error
= enc
->error
[j
];
1439 scale
= enc
->width
* enc
->height
* 255.0 * 255.0 * frame_number
;
1441 error
= enc
->coded_frame
->error
[j
];
1442 scale
= enc
->width
* enc
->height
* 255.0 * 255.0;
1448 p
= psnr(error
/ scale
);
1449 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "%c:%2.2f ", type
[j
], p
);
1450 av_bprintf(&buf_script
, "stream_%d_%d_psnr_%c=%2.2f\n",
1451 ost
->file_index
, ost
->index
, type
[j
] | 32, p
);
1453 p
= psnr(error_sum
/ scale_sum
);
1454 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "*:%2.2f ", psnr(error_sum
/ scale_sum
));
1455 av_bprintf(&buf_script
, "stream_%d_%d_psnr_all=%2.2f\n",
1456 ost
->file_index
, ost
->index
, p
);
1460 /* compute min output value */
1461 if (av_stream_get_end_pts(ost
->st
) != AV_NOPTS_VALUE
)
1462 pts
= FFMAX(pts
, av_rescale_q(av_stream_get_end_pts(ost
->st
),
1463 ost
->st
->time_base
, AV_TIME_BASE_Q
));
1466 secs
= pts
/ AV_TIME_BASE
;
1467 us
= pts
% AV_TIME_BASE
;
1473 bitrate
= pts
&& total_size
>= 0 ? total_size
* 8 / (pts
/ 1000.0) : -1;
1475 if (total_size
< 0) snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
1477 else snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
1478 "size=%8.0fkB time=", total_size
/ 1024.0);
1479 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
1480 "%02d:%02d:%02d.%02d ", hours
, mins
, secs
,
1481 (100 * us
) / AV_TIME_BASE
);
1482 if (bitrate
< 0) snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
1484 else snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
1485 "bitrate=%6.1fkbits/s", bitrate
);
1486 if (total_size
< 0) av_bprintf(&buf_script
, "total_size=N/A\n");
1487 else av_bprintf(&buf_script
, "total_size=%"PRId64
"\n", total_size
);
1488 av_bprintf(&buf_script
, "out_time_ms=%"PRId64
"\n", pts
);
1489 av_bprintf(&buf_script
, "out_time=%02d:%02d:%02d.%06d\n",
1490 hours
, mins
, secs
, us
);
1492 if (nb_frames_dup
|| nb_frames_drop
)
1493 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), " dup=%d drop=%d",
1494 nb_frames_dup
, nb_frames_drop
);
1495 av_bprintf(&buf_script
, "dup_frames=%d\n", nb_frames_dup
);
1496 av_bprintf(&buf_script
, "drop_frames=%d\n", nb_frames_drop
);
1498 if (print_stats
|| is_last_report
) {
1499 if (print_stats
==1 && AV_LOG_INFO
> av_log_get_level()) {
1500 fprintf(stderr
, "%s \r", buf
);
1502 av_log(NULL
, AV_LOG_INFO
, "%s \r", buf
);
1507 if (progress_avio
) {
1508 av_bprintf(&buf_script
, "progress=%s\n",
1509 is_last_report
? "end" : "continue");
1510 avio_write(progress_avio
, buf_script
.str
,
1511 FFMIN(buf_script
.len
, buf_script
.size
- 1));
1512 avio_flush(progress_avio
);
1513 av_bprint_finalize(&buf_script
, NULL
);
1514 if (is_last_report
) {
1515 avio_close(progress_avio
);
1516 progress_avio
= NULL
;
1521 print_final_stats(total_size
);
1524 static void flush_encoders(void)
1528 for (i
= 0; i
< nb_output_streams
; i
++) {
1529 OutputStream
*ost
= output_streams
[i
];
1530 AVCodecContext
*enc
= ost
->enc_ctx
;
1531 AVFormatContext
*os
= output_files
[ost
->file_index
]->ctx
;
1532 int stop_encoding
= 0;
1534 if (!ost
->encoding_needed
)
1537 if (enc
->codec_type
== AVMEDIA_TYPE_AUDIO
&& enc
->frame_size
<= 1)
1539 if (enc
->codec_type
== AVMEDIA_TYPE_VIDEO
&& (os
->oformat
->flags
& AVFMT_RAWPICTURE
) && enc
->codec
->id
== AV_CODEC_ID_RAWVIDEO
)
1543 int (*encode
)(AVCodecContext
*, AVPacket
*, const AVFrame
*, int*) = NULL
;
1546 switch (enc
->codec_type
) {
1547 case AVMEDIA_TYPE_AUDIO
:
1548 encode
= avcodec_encode_audio2
;
1551 case AVMEDIA_TYPE_VIDEO
:
1552 encode
= avcodec_encode_video2
;
1563 av_init_packet(&pkt
);
1567 update_benchmark(NULL
);
1568 ret
= encode(enc
, &pkt
, NULL
, &got_packet
);
1569 update_benchmark("flush %s %d.%d", desc
, ost
->file_index
, ost
->index
);
1571 av_log(NULL
, AV_LOG_FATAL
, "%s encoding failed\n", desc
);
1574 if (ost
->logfile
&& enc
->stats_out
) {
1575 fprintf(ost
->logfile
, "%s", enc
->stats_out
);
1581 if (ost
->finished
& MUXER_FINISHED
) {
1582 av_free_packet(&pkt
);
1585 av_packet_rescale_ts(&pkt
, enc
->time_base
, ost
->st
->time_base
);
1586 pkt_size
= pkt
.size
;
1587 write_frame(os
, &pkt
, ost
);
1588 if (ost
->enc_ctx
->codec_type
== AVMEDIA_TYPE_VIDEO
&& vstats_filename
) {
1589 do_video_stats(ost
, pkt_size
);
1600 * Check whether a packet from ist should be written into ost at this time
1602 static int check_output_constraints(InputStream
*ist
, OutputStream
*ost
)
1604 OutputFile
*of
= output_files
[ost
->file_index
];
1605 int ist_index
= input_files
[ist
->file_index
]->ist_index
+ ist
->st
->index
;
1607 if (ost
->source_index
!= ist_index
)
1613 if (of
->start_time
!= AV_NOPTS_VALUE
&& ist
->pts
< of
->start_time
)
1619 static void do_streamcopy(InputStream
*ist
, OutputStream
*ost
, const AVPacket
*pkt
)
1621 OutputFile
*of
= output_files
[ost
->file_index
];
1622 InputFile
*f
= input_files
[ist
->file_index
];
1623 int64_t start_time
= (of
->start_time
== AV_NOPTS_VALUE
) ? 0 : of
->start_time
;
1624 int64_t ost_tb_start_time
= av_rescale_q(start_time
, AV_TIME_BASE_Q
, ost
->st
->time_base
);
1625 int64_t ist_tb_start_time
= av_rescale_q(start_time
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
1629 av_init_packet(&opkt
);
1631 if ((!ost
->frame_number
&& !(pkt
->flags
& AV_PKT_FLAG_KEY
)) &&
1632 !ost
->copy_initial_nonkeyframes
)
1635 if (pkt
->pts
== AV_NOPTS_VALUE
) {
1636 if (!ost
->frame_number
&& ist
->pts
< start_time
&&
1637 !ost
->copy_prior_start
)
1640 if (!ost
->frame_number
&& pkt
->pts
< ist_tb_start_time
&&
1641 !ost
->copy_prior_start
)
1645 if (of
->recording_time
!= INT64_MAX
&&
1646 ist
->pts
>= of
->recording_time
+ start_time
) {
1647 close_output_stream(ost
);
1651 if (f
->recording_time
!= INT64_MAX
) {
1652 start_time
= f
->ctx
->start_time
;
1653 if (f
->start_time
!= AV_NOPTS_VALUE
)
1654 start_time
+= f
->start_time
;
1655 if (ist
->pts
>= f
->recording_time
+ start_time
) {
1656 close_output_stream(ost
);
1661 /* force the input stream PTS */
1662 if (ost
->enc_ctx
->codec_type
== AVMEDIA_TYPE_VIDEO
)
1665 if (pkt
->pts
!= AV_NOPTS_VALUE
)
1666 opkt
.pts
= av_rescale_q(pkt
->pts
, ist
->st
->time_base
, ost
->st
->time_base
) - ost_tb_start_time
;
1668 opkt
.pts
= AV_NOPTS_VALUE
;
1670 if (pkt
->dts
== AV_NOPTS_VALUE
)
1671 opkt
.dts
= av_rescale_q(ist
->dts
, AV_TIME_BASE_Q
, ost
->st
->time_base
);
1673 opkt
.dts
= av_rescale_q(pkt
->dts
, ist
->st
->time_base
, ost
->st
->time_base
);
1674 opkt
.dts
-= ost_tb_start_time
;
1676 if (ost
->st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
&& pkt
->dts
!= AV_NOPTS_VALUE
) {
1677 int duration
= av_get_audio_frame_duration(ist
->dec_ctx
, pkt
->size
);
1679 duration
= ist
->dec_ctx
->frame_size
;
1680 opkt
.dts
= opkt
.pts
= av_rescale_delta(ist
->st
->time_base
, pkt
->dts
,
1681 (AVRational
){1, ist
->dec_ctx
->sample_rate
}, duration
, &ist
->filter_in_rescale_delta_last
,
1682 ost
->st
->time_base
) - ost_tb_start_time
;
1685 opkt
.duration
= av_rescale_q(pkt
->duration
, ist
->st
->time_base
, ost
->st
->time_base
);
1686 opkt
.flags
= pkt
->flags
;
1688 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1689 if ( ost
->enc_ctx
->codec_id
!= AV_CODEC_ID_H264
1690 && ost
->enc_ctx
->codec_id
!= AV_CODEC_ID_MPEG1VIDEO
1691 && ost
->enc_ctx
->codec_id
!= AV_CODEC_ID_MPEG2VIDEO
1692 && ost
->enc_ctx
->codec_id
!= AV_CODEC_ID_VC1
1694 if (av_parser_change(ost
->parser
, ost
->st
->codec
,
1695 &opkt
.data
, &opkt
.size
,
1696 pkt
->data
, pkt
->size
,
1697 pkt
->flags
& AV_PKT_FLAG_KEY
)) {
1698 opkt
.buf
= av_buffer_create(opkt
.data
, opkt
.size
, av_buffer_default_free
, NULL
, 0);
1703 opkt
.data
= pkt
->data
;
1704 opkt
.size
= pkt
->size
;
1706 av_copy_packet_side_data(&opkt
, pkt
);
1708 if (ost
->st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
&& (of
->ctx
->oformat
->flags
& AVFMT_RAWPICTURE
)) {
1709 /* store AVPicture in AVPacket, as expected by the output format */
1710 avpicture_fill(&pict
, opkt
.data
, ost
->st
->codec
->pix_fmt
, ost
->st
->codec
->width
, ost
->st
->codec
->height
);
1711 opkt
.data
= (uint8_t *)&pict
;
1712 opkt
.size
= sizeof(AVPicture
);
1713 opkt
.flags
|= AV_PKT_FLAG_KEY
;
1716 write_frame(of
->ctx
, &opkt
, ost
);
1719 int guess_input_channel_layout(InputStream
*ist
)
1721 AVCodecContext
*dec
= ist
->dec_ctx
;
1723 if (!dec
->channel_layout
) {
1724 char layout_name
[256];
1726 if (dec
->channels
> ist
->guess_layout_max
)
1728 dec
->channel_layout
= av_get_default_channel_layout(dec
->channels
);
1729 if (!dec
->channel_layout
)
1731 av_get_channel_layout_string(layout_name
, sizeof(layout_name
),
1732 dec
->channels
, dec
->channel_layout
);
1733 av_log(NULL
, AV_LOG_WARNING
, "Guessed Channel Layout for Input Stream "
1734 "#%d.%d : %s\n", ist
->file_index
, ist
->st
->index
, layout_name
);
1739 static int decode_audio(InputStream
*ist
, AVPacket
*pkt
, int *got_output
)
1741 AVFrame
*decoded_frame
, *f
;
1742 AVCodecContext
*avctx
= ist
->dec_ctx
;
1743 int i
, ret
, err
= 0, resample_changed
;
1744 AVRational decoded_frame_tb
;
1746 if (!ist
->decoded_frame
&& !(ist
->decoded_frame
= av_frame_alloc()))
1747 return AVERROR(ENOMEM
);
1748 if (!ist
->filter_frame
&& !(ist
->filter_frame
= av_frame_alloc()))
1749 return AVERROR(ENOMEM
);
1750 decoded_frame
= ist
->decoded_frame
;
1752 update_benchmark(NULL
);
1753 ret
= avcodec_decode_audio4(avctx
, decoded_frame
, got_output
, pkt
);
1754 update_benchmark("decode_audio %d.%d", ist
->file_index
, ist
->st
->index
);
1756 if (ret
>= 0 && avctx
->sample_rate
<= 0) {
1757 av_log(avctx
, AV_LOG_ERROR
, "Sample rate %d invalid\n", avctx
->sample_rate
);
1758 ret
= AVERROR_INVALIDDATA
;
1761 if (*got_output
|| ret
<0 || pkt
->size
)
1762 decode_error_stat
[ret
<0] ++;
1764 if (!*got_output
|| ret
< 0) {
1766 for (i
= 0; i
< ist
->nb_filters
; i
++)
1768 av_buffersrc_add_ref(ist
->filters
[i
]->filter
, NULL
, 0);
1770 av_buffersrc_add_frame(ist
->filters
[i
]->filter
, NULL
);
1776 ist
->samples_decoded
+= decoded_frame
->nb_samples
;
1777 ist
->frames_decoded
++;
1780 /* increment next_dts to use for the case where the input stream does not
1781 have timestamps or there are multiple frames in the packet */
1782 ist
->next_pts
+= ((int64_t)AV_TIME_BASE
* decoded_frame
->nb_samples
) /
1784 ist
->next_dts
+= ((int64_t)AV_TIME_BASE
* decoded_frame
->nb_samples
) /
1788 resample_changed
= ist
->resample_sample_fmt
!= decoded_frame
->format
||
1789 ist
->resample_channels
!= avctx
->channels
||
1790 ist
->resample_channel_layout
!= decoded_frame
->channel_layout
||
1791 ist
->resample_sample_rate
!= decoded_frame
->sample_rate
;
1792 if (resample_changed
) {
1793 char layout1
[64], layout2
[64];
1795 if (!guess_input_channel_layout(ist
)) {
1796 av_log(NULL
, AV_LOG_FATAL
, "Unable to find default channel "
1797 "layout for Input Stream #%d.%d\n", ist
->file_index
,
1801 decoded_frame
->channel_layout
= avctx
->channel_layout
;
1803 av_get_channel_layout_string(layout1
, sizeof(layout1
), ist
->resample_channels
,
1804 ist
->resample_channel_layout
);
1805 av_get_channel_layout_string(layout2
, sizeof(layout2
), avctx
->channels
,
1806 decoded_frame
->channel_layout
);
1808 av_log(NULL
, AV_LOG_INFO
,
1809 "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",
1810 ist
->file_index
, ist
->st
->index
,
1811 ist
->resample_sample_rate
, av_get_sample_fmt_name(ist
->resample_sample_fmt
),
1812 ist
->resample_channels
, layout1
,
1813 decoded_frame
->sample_rate
, av_get_sample_fmt_name(decoded_frame
->format
),
1814 avctx
->channels
, layout2
);
1816 ist
->resample_sample_fmt
= decoded_frame
->format
;
1817 ist
->resample_sample_rate
= decoded_frame
->sample_rate
;
1818 ist
->resample_channel_layout
= decoded_frame
->channel_layout
;
1819 ist
->resample_channels
= avctx
->channels
;
1821 for (i
= 0; i
< nb_filtergraphs
; i
++)
1822 if (ist_in_filtergraph(filtergraphs
[i
], ist
)) {
1823 FilterGraph
*fg
= filtergraphs
[i
];
1824 if (configure_filtergraph(fg
) < 0) {
1825 av_log(NULL
, AV_LOG_FATAL
, "Error reinitializing filters!\n");
1831 /* if the decoder provides a pts, use it instead of the last packet pts.
1832 the decoder could be delaying output by a packet or more. */
1833 if (decoded_frame
->pts
!= AV_NOPTS_VALUE
) {
1834 ist
->dts
= ist
->next_dts
= ist
->pts
= ist
->next_pts
= av_rescale_q(decoded_frame
->pts
, avctx
->time_base
, AV_TIME_BASE_Q
);
1835 decoded_frame_tb
= avctx
->time_base
;
1836 } else if (decoded_frame
->pkt_pts
!= AV_NOPTS_VALUE
) {
1837 decoded_frame
->pts
= decoded_frame
->pkt_pts
;
1838 decoded_frame_tb
= ist
->st
->time_base
;
1839 } else if (pkt
->pts
!= AV_NOPTS_VALUE
) {
1840 decoded_frame
->pts
= pkt
->pts
;
1841 decoded_frame_tb
= ist
->st
->time_base
;
1843 decoded_frame
->pts
= ist
->dts
;
1844 decoded_frame_tb
= AV_TIME_BASE_Q
;
1846 pkt
->pts
= AV_NOPTS_VALUE
;
1847 if (decoded_frame
->pts
!= AV_NOPTS_VALUE
)
1848 decoded_frame
->pts
= av_rescale_delta(decoded_frame_tb
, decoded_frame
->pts
,
1849 (AVRational
){1, avctx
->sample_rate
}, decoded_frame
->nb_samples
, &ist
->filter_in_rescale_delta_last
,
1850 (AVRational
){1, avctx
->sample_rate
});
1851 for (i
= 0; i
< ist
->nb_filters
; i
++) {
1852 if (i
< ist
->nb_filters
- 1) {
1853 f
= ist
->filter_frame
;
1854 err
= av_frame_ref(f
, decoded_frame
);
1859 err
= av_buffersrc_add_frame_flags(ist
->filters
[i
]->filter
, f
,
1860 AV_BUFFERSRC_FLAG_PUSH
);
1861 if (err
== AVERROR_EOF
)
1862 err
= 0; /* ignore */
1866 decoded_frame
->pts
= AV_NOPTS_VALUE
;
1868 av_frame_unref(ist
->filter_frame
);
1869 av_frame_unref(decoded_frame
);
1870 return err
< 0 ? err
: ret
;
1873 static int decode_video(InputStream
*ist
, AVPacket
*pkt
, int *got_output
)
1875 AVFrame
*decoded_frame
, *f
;
1876 int i
, ret
= 0, err
= 0, resample_changed
;
1877 int64_t best_effort_timestamp
;
1878 AVRational
*frame_sample_aspect
;
1880 if (!ist
->decoded_frame
&& !(ist
->decoded_frame
= av_frame_alloc()))
1881 return AVERROR(ENOMEM
);
1882 if (!ist
->filter_frame
&& !(ist
->filter_frame
= av_frame_alloc()))
1883 return AVERROR(ENOMEM
);
1884 decoded_frame
= ist
->decoded_frame
;
1885 pkt
->dts
= av_rescale_q(ist
->dts
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
1887 update_benchmark(NULL
);
1888 ret
= avcodec_decode_video2(ist
->dec_ctx
,
1889 decoded_frame
, got_output
, pkt
);
1890 update_benchmark("decode_video %d.%d", ist
->file_index
, ist
->st
->index
);
1892 // The following line may be required in some cases where there is no parser
1893 // or the parser does not has_b_frames correctly
1894 if (ist
->st
->codec
->has_b_frames
< ist
->dec_ctx
->has_b_frames
) {
1895 if (ist
->dec_ctx
->codec_id
== AV_CODEC_ID_H264
) {
1896 ist
->st
->codec
->has_b_frames
= ist
->dec_ctx
->has_b_frames
;
1898 av_log_ask_for_sample(
1900 "has_b_frames is larger in decoder than demuxer %d > %d ",
1901 ist
->dec_ctx
->has_b_frames
,
1902 ist
->st
->codec
->has_b_frames
1906 if (*got_output
|| ret
<0 || pkt
->size
)
1907 decode_error_stat
[ret
<0] ++;
1909 if (!*got_output
|| ret
< 0) {
1911 for (i
= 0; i
< ist
->nb_filters
; i
++)
1913 av_buffersrc_add_ref(ist
->filters
[i
]->filter
, NULL
, 0);
1915 av_buffersrc_add_frame(ist
->filters
[i
]->filter
, NULL
);
1921 if(ist
->top_field_first
>=0)
1922 decoded_frame
->top_field_first
= ist
->top_field_first
;
1924 ist
->frames_decoded
++;
1926 if (ist
->hwaccel_retrieve_data
&& decoded_frame
->format
== ist
->hwaccel_pix_fmt
) {
1927 err
= ist
->hwaccel_retrieve_data(ist
->dec_ctx
, decoded_frame
);
1931 ist
->hwaccel_retrieved_pix_fmt
= decoded_frame
->format
;
1933 best_effort_timestamp
= av_frame_get_best_effort_timestamp(decoded_frame
);
1934 if(best_effort_timestamp
!= AV_NOPTS_VALUE
)
1935 ist
->next_pts
= ist
->pts
= av_rescale_q(decoded_frame
->pts
= best_effort_timestamp
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
1938 av_log(NULL
, AV_LOG_INFO
, "decoder -> ist_index:%d type:video "
1939 "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",
1940 ist
->st
->index
, av_ts2str(decoded_frame
->pts
),
1941 av_ts2timestr(decoded_frame
->pts
, &ist
->st
->time_base
),
1942 best_effort_timestamp
,
1943 av_ts2timestr(best_effort_timestamp
, &ist
->st
->time_base
),
1944 decoded_frame
->key_frame
, decoded_frame
->pict_type
,
1945 ist
->st
->time_base
.num
, ist
->st
->time_base
.den
);
1950 if (ist
->st
->sample_aspect_ratio
.num
)
1951 decoded_frame
->sample_aspect_ratio
= ist
->st
->sample_aspect_ratio
;
1953 resample_changed
= ist
->resample_width
!= decoded_frame
->width
||
1954 ist
->resample_height
!= decoded_frame
->height
||
1955 ist
->resample_pix_fmt
!= decoded_frame
->format
;
1956 if (resample_changed
) {
1957 av_log(NULL
, AV_LOG_INFO
,
1958 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1959 ist
->file_index
, ist
->st
->index
,
1960 ist
->resample_width
, ist
->resample_height
, av_get_pix_fmt_name(ist
->resample_pix_fmt
),
1961 decoded_frame
->width
, decoded_frame
->height
, av_get_pix_fmt_name(decoded_frame
->format
));
1963 ist
->resample_width
= decoded_frame
->width
;
1964 ist
->resample_height
= decoded_frame
->height
;
1965 ist
->resample_pix_fmt
= decoded_frame
->format
;
1967 for (i
= 0; i
< nb_filtergraphs
; i
++) {
1968 if (ist_in_filtergraph(filtergraphs
[i
], ist
) && ist
->reinit_filters
&&
1969 configure_filtergraph(filtergraphs
[i
]) < 0) {
1970 av_log(NULL
, AV_LOG_FATAL
, "Error reinitializing filters!\n");
1976 frame_sample_aspect
= av_opt_ptr(avcodec_get_frame_class(), decoded_frame
, "sample_aspect_ratio");
1977 for (i
= 0; i
< ist
->nb_filters
; i
++) {
1978 if (!frame_sample_aspect
->num
)
1979 *frame_sample_aspect
= ist
->st
->sample_aspect_ratio
;
1981 if (i
< ist
->nb_filters
- 1) {
1982 f
= ist
->filter_frame
;
1983 err
= av_frame_ref(f
, decoded_frame
);
1988 ret
= av_buffersrc_add_frame_flags(ist
->filters
[i
]->filter
, f
, AV_BUFFERSRC_FLAG_PUSH
);
1989 if (ret
== AVERROR_EOF
) {
1990 ret
= 0; /* ignore */
1991 } else if (ret
< 0) {
1992 av_log(NULL
, AV_LOG_FATAL
,
1993 "Failed to inject frame into filter network: %s\n", av_err2str(ret
));
1999 av_frame_unref(ist
->filter_frame
);
2000 av_frame_unref(decoded_frame
);
2001 return err
< 0 ? err
: ret
;
2004 static int transcode_subtitles(InputStream
*ist
, AVPacket
*pkt
, int *got_output
)
2006 AVSubtitle subtitle
;
2007 int i
, ret
= avcodec_decode_subtitle2(ist
->dec_ctx
,
2008 &subtitle
, got_output
, pkt
);
2010 if (*got_output
|| ret
<0 || pkt
->size
)
2011 decode_error_stat
[ret
<0] ++;
2013 if (ret
< 0 || !*got_output
) {
2015 sub2video_flush(ist
);
2019 if (ist
->fix_sub_duration
) {
2021 if (ist
->prev_sub
.got_output
) {
2022 end
= av_rescale(subtitle
.pts
- ist
->prev_sub
.subtitle
.pts
,
2023 1000, AV_TIME_BASE
);
2024 if (end
< ist
->prev_sub
.subtitle
.end_display_time
) {
2025 av_log(ist
->dec_ctx
, AV_LOG_DEBUG
,
2026 "Subtitle duration reduced from %d to %d%s\n",
2027 ist
->prev_sub
.subtitle
.end_display_time
, end
,
2028 end
<= 0 ? ", dropping it" : "");
2029 ist
->prev_sub
.subtitle
.end_display_time
= end
;
2032 FFSWAP(int, *got_output
, ist
->prev_sub
.got_output
);
2033 FFSWAP(int, ret
, ist
->prev_sub
.ret
);
2034 FFSWAP(AVSubtitle
, subtitle
, ist
->prev_sub
.subtitle
);
2042 sub2video_update(ist
, &subtitle
);
2044 if (!subtitle
.num_rects
)
2047 ist
->frames_decoded
++;
2049 for (i
= 0; i
< nb_output_streams
; i
++) {
2050 OutputStream
*ost
= output_streams
[i
];
2052 if (!check_output_constraints(ist
, ost
) || !ost
->encoding_needed
2053 || ost
->enc
->type
!= AVMEDIA_TYPE_SUBTITLE
)
2056 do_subtitle_out(output_files
[ost
->file_index
]->ctx
, ost
, ist
, &subtitle
);
2060 avsubtitle_free(&subtitle
);
2064 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2065 static int process_input_packet(InputStream
*ist
, const AVPacket
*pkt
)
2071 if (!ist
->saw_first_ts
) {
2072 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;
2074 if (pkt
&& pkt
->pts
!= AV_NOPTS_VALUE
&& !ist
->decoding_needed
) {
2075 ist
->dts
+= av_rescale_q(pkt
->pts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
2076 ist
->pts
= ist
->dts
; //unused but better to set it to a value thats not totally wrong
2078 ist
->saw_first_ts
= 1;
2081 if (ist
->next_dts
== AV_NOPTS_VALUE
)
2082 ist
->next_dts
= ist
->dts
;
2083 if (ist
->next_pts
== AV_NOPTS_VALUE
)
2084 ist
->next_pts
= ist
->pts
;
2088 av_init_packet(&avpkt
);
2096 if (pkt
->dts
!= AV_NOPTS_VALUE
) {
2097 ist
->next_dts
= ist
->dts
= av_rescale_q(pkt
->dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
2098 if (ist
->dec_ctx
->codec_type
!= AVMEDIA_TYPE_VIDEO
|| !ist
->decoding_needed
)
2099 ist
->next_pts
= ist
->pts
= ist
->dts
;
2102 // while we have more to decode or while the decoder did output something on EOF
2103 while (ist
->decoding_needed
&& (avpkt
.size
> 0 || (!pkt
&& got_output
))) {
2107 ist
->pts
= ist
->next_pts
;
2108 ist
->dts
= ist
->next_dts
;
2110 if (avpkt
.size
&& avpkt
.size
!= pkt
->size
&&
2111 !(ist
->dec
->capabilities
& CODEC_CAP_SUBFRAMES
)) {
2112 av_log(NULL
, ist
->showed_multi_packet_warning
? AV_LOG_VERBOSE
: AV_LOG_WARNING
,
2113 "Multiple frames in a packet from stream %d\n", pkt
->stream_index
);
2114 ist
->showed_multi_packet_warning
= 1;
2117 switch (ist
->dec_ctx
->codec_type
) {
2118 case AVMEDIA_TYPE_AUDIO
:
2119 ret
= decode_audio (ist
, &avpkt
, &got_output
);
2121 case AVMEDIA_TYPE_VIDEO
:
2122 ret
= decode_video (ist
, &avpkt
, &got_output
);
2123 if (avpkt
.duration
) {
2124 duration
= av_rescale_q(avpkt
.duration
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
2125 } else if(ist
->dec_ctx
->time_base
.num
!= 0 && ist
->dec_ctx
->time_base
.den
!= 0) {
2126 int ticks
= av_stream_get_parser(ist
->st
) ? av_stream_get_parser(ist
->st
)->repeat_pict
+1 : ist
->dec_ctx
->ticks_per_frame
;
2127 duration
= ((int64_t)AV_TIME_BASE
*
2128 ist
->dec_ctx
->time_base
.num
* ticks
) /
2129 ist
->dec_ctx
->time_base
.den
;
2133 if(ist
->dts
!= AV_NOPTS_VALUE
&& duration
) {
2134 ist
->next_dts
+= duration
;
2136 ist
->next_dts
= AV_NOPTS_VALUE
;
2139 ist
->next_pts
+= duration
; //FIXME the duration is not correct in some cases
2141 case AVMEDIA_TYPE_SUBTITLE
:
2142 ret
= transcode_subtitles(ist
, &avpkt
, &got_output
);
2152 avpkt
.pts
= AV_NOPTS_VALUE
;
2154 // touch data and size only if not EOF
2156 if(ist
->dec_ctx
->codec_type
!= AVMEDIA_TYPE_AUDIO
)
2164 if (got_output
&& !pkt
)
2168 /* handle stream copy */
2169 if (!ist
->decoding_needed
) {
2170 ist
->dts
= ist
->next_dts
;
2171 switch (ist
->dec_ctx
->codec_type
) {
2172 case AVMEDIA_TYPE_AUDIO
:
2173 ist
->next_dts
+= ((int64_t)AV_TIME_BASE
* ist
->dec_ctx
->frame_size
) /
2174 ist
->dec_ctx
->sample_rate
;
2176 case AVMEDIA_TYPE_VIDEO
:
2177 if (ist
->framerate
.num
) {
2178 // TODO: Remove work-around for c99-to-c89 issue 7
2179 AVRational time_base_q
= AV_TIME_BASE_Q
;
2180 int64_t next_dts
= av_rescale_q(ist
->next_dts
, time_base_q
, av_inv_q(ist
->framerate
));
2181 ist
->next_dts
= av_rescale_q(next_dts
+ 1, av_inv_q(ist
->framerate
), time_base_q
);
2182 } else if (pkt
->duration
) {
2183 ist
->next_dts
+= av_rescale_q(pkt
->duration
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
2184 } else if(ist
->dec_ctx
->time_base
.num
!= 0) {
2185 int ticks
= av_stream_get_parser(ist
->st
) ? av_stream_get_parser(ist
->st
)->repeat_pict
+ 1 : ist
->dec_ctx
->ticks_per_frame
;
2186 ist
->next_dts
+= ((int64_t)AV_TIME_BASE
*
2187 ist
->dec_ctx
->time_base
.num
* ticks
) /
2188 ist
->dec_ctx
->time_base
.den
;
2192 ist
->pts
= ist
->dts
;
2193 ist
->next_pts
= ist
->next_dts
;
2195 for (i
= 0; pkt
&& i
< nb_output_streams
; i
++) {
2196 OutputStream
*ost
= output_streams
[i
];
2198 if (!check_output_constraints(ist
, ost
) || ost
->encoding_needed
)
2201 do_streamcopy(ist
, ost
, pkt
);
2207 static void print_sdp(void)
2211 AVFormatContext
**avc
= av_malloc_array(nb_output_files
, sizeof(*avc
));
2215 for (i
= 0; i
< nb_output_files
; i
++)
2216 avc
[i
] = output_files
[i
]->ctx
;
2218 av_sdp_create(avc
, nb_output_files
, sdp
, sizeof(sdp
));
2219 printf("SDP:\n%s\n", sdp
);
2224 static const HWAccel
*get_hwaccel(enum AVPixelFormat pix_fmt
)
2227 for (i
= 0; hwaccels
[i
].name
; i
++)
2228 if (hwaccels
[i
].pix_fmt
== pix_fmt
)
2229 return &hwaccels
[i
];
2233 static enum AVPixelFormat
get_format(AVCodecContext
*s
, const enum AVPixelFormat
*pix_fmts
)
2235 InputStream
*ist
= s
->opaque
;
2236 const enum AVPixelFormat
*p
;
2239 for (p
= pix_fmts
; *p
!= -1; p
++) {
2240 const AVPixFmtDescriptor
*desc
= av_pix_fmt_desc_get(*p
);
2241 const HWAccel
*hwaccel
;
2243 if (!(desc
->flags
& AV_PIX_FMT_FLAG_HWACCEL
))
2246 hwaccel
= get_hwaccel(*p
);
2248 (ist
->active_hwaccel_id
&& ist
->active_hwaccel_id
!= hwaccel
->id
) ||
2249 (ist
->hwaccel_id
!= HWACCEL_AUTO
&& ist
->hwaccel_id
!= hwaccel
->id
))
2252 ret
= hwaccel
->init(s
);
2254 if (ist
->hwaccel_id
== hwaccel
->id
) {
2255 av_log(NULL
, AV_LOG_FATAL
,
2256 "%s hwaccel requested for input stream #%d:%d, "
2257 "but cannot be initialized.\n", hwaccel
->name
,
2258 ist
->file_index
, ist
->st
->index
);
2263 ist
->active_hwaccel_id
= hwaccel
->id
;
2264 ist
->hwaccel_pix_fmt
= *p
;
2271 static int get_buffer(AVCodecContext
*s
, AVFrame
*frame
, int flags
)
2273 InputStream
*ist
= s
->opaque
;
2275 if (ist
->hwaccel_get_buffer
&& frame
->format
== ist
->hwaccel_pix_fmt
)
2276 return ist
->hwaccel_get_buffer(s
, frame
, flags
);
2278 return avcodec_default_get_buffer2(s
, frame
, flags
);
2281 static int init_input_stream(int ist_index
, char *error
, int error_len
)
2284 InputStream
*ist
= input_streams
[ist_index
];
2286 if (ist
->decoding_needed
) {
2287 AVCodec
*codec
= ist
->dec
;
2289 snprintf(error
, error_len
, "Decoder (codec %s) not found for input stream #%d:%d",
2290 avcodec_get_name(ist
->dec_ctx
->codec_id
), ist
->file_index
, ist
->st
->index
);
2291 return AVERROR(EINVAL
);
2294 ist
->dec_ctx
->opaque
= ist
;
2295 ist
->dec_ctx
->get_format
= get_format
;
2296 ist
->dec_ctx
->get_buffer2
= get_buffer
;
2297 ist
->dec_ctx
->thread_safe_callbacks
= 1;
2299 av_opt_set_int(ist
->dec_ctx
, "refcounted_frames", 1, 0);
2300 if (ist
->dec_ctx
->codec_id
== AV_CODEC_ID_DVB_SUBTITLE
&&
2301 (ist
->decoding_needed
& DECODING_FOR_OST
)) {
2302 av_dict_set(&ist
->decoder_opts
, "compute_edt", "1", AV_DICT_DONT_OVERWRITE
);
2303 if (ist
->decoding_needed
& DECODING_FOR_FILTER
)
2304 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");
2307 if (!av_dict_get(ist
->decoder_opts
, "threads", NULL
, 0))
2308 av_dict_set(&ist
->decoder_opts
, "threads", "auto", 0);
2309 if ((ret
= avcodec_open2(ist
->dec_ctx
, codec
, &ist
->decoder_opts
)) < 0) {
2310 if (ret
== AVERROR_EXPERIMENTAL
)
2311 abort_codec_experimental(codec
, 0);
2313 snprintf(error
, error_len
,
2314 "Error while opening decoder for input stream "
2316 ist
->file_index
, ist
->st
->index
, av_err2str(ret
));
2319 assert_avoptions(ist
->decoder_opts
);
2322 ist
->next_pts
= AV_NOPTS_VALUE
;
2323 ist
->next_dts
= AV_NOPTS_VALUE
;
2328 static InputStream
*get_input_stream(OutputStream
*ost
)
2330 if (ost
->source_index
>= 0)
2331 return input_streams
[ost
->source_index
];
2335 static int compare_int64(const void *a
, const void *b
)
2337 int64_t va
= *(int64_t *)a
, vb
= *(int64_t *)b
;
2338 return va
< vb
? -1 : va
> vb
? +1 : 0;
2341 static void parse_forced_key_frames(char *kf
, OutputStream
*ost
,
2342 AVCodecContext
*avctx
)
2345 int n
= 1, i
, size
, index
= 0;
2348 for (p
= kf
; *p
; p
++)
2352 pts
= av_malloc_array(size
, sizeof(*pts
));
2354 av_log(NULL
, AV_LOG_FATAL
, "Could not allocate forced key frames array.\n");
2359 for (i
= 0; i
< n
; i
++) {
2360 char *next
= strchr(p
, ',');
2365 if (!memcmp(p
, "chapters", 8)) {
2367 AVFormatContext
*avf
= output_files
[ost
->file_index
]->ctx
;
2370 if (avf
->nb_chapters
> INT_MAX
- size
||
2371 !(pts
= av_realloc_f(pts
, size
+= avf
->nb_chapters
- 1,
2373 av_log(NULL
, AV_LOG_FATAL
,
2374 "Could not allocate forced key frames array.\n");
2377 t
= p
[8] ? parse_time_or_die("force_key_frames", p
+ 8, 1) : 0;
2378 t
= av_rescale_q(t
, AV_TIME_BASE_Q
, avctx
->time_base
);
2380 for (j
= 0; j
< avf
->nb_chapters
; j
++) {
2381 AVChapter
*c
= avf
->chapters
[j
];
2382 av_assert1(index
< size
);
2383 pts
[index
++] = av_rescale_q(c
->start
, c
->time_base
,
2384 avctx
->time_base
) + t
;
2389 t
= parse_time_or_die("force_key_frames", p
, 1);
2390 av_assert1(index
< size
);
2391 pts
[index
++] = av_rescale_q(t
, AV_TIME_BASE_Q
, avctx
->time_base
);
2398 av_assert0(index
== size
);
2399 qsort(pts
, size
, sizeof(*pts
), compare_int64
);
2400 ost
->forced_kf_count
= size
;
2401 ost
->forced_kf_pts
= pts
;
2404 static void report_new_stream(int input_index
, AVPacket
*pkt
)
2406 InputFile
*file
= input_files
[input_index
];
2407 AVStream
*st
= file
->ctx
->streams
[pkt
->stream_index
];
2409 if (pkt
->stream_index
< file
->nb_streams_warn
)
2411 av_log(file
->ctx
, AV_LOG_WARNING
,
2412 "New %s stream %d:%d at pos:%"PRId64
" and DTS:%ss\n",
2413 av_get_media_type_string(st
->codec
->codec_type
),
2414 input_index
, pkt
->stream_index
,
2415 pkt
->pos
, av_ts2timestr(pkt
->dts
, &st
->time_base
));
2416 file
->nb_streams_warn
= pkt
->stream_index
+ 1;
2419 static void set_encoder_id(OutputFile
*of
, OutputStream
*ost
)
2421 AVDictionaryEntry
*e
;
2423 uint8_t *encoder_string
;
2424 int encoder_string_len
;
2425 int format_flags
= 0;
2426 int codec_flags
= 0;
2428 if (av_dict_get(ost
->st
->metadata
, "encoder", NULL
, 0))
2431 e
= av_dict_get(of
->opts
, "fflags", NULL
, 0);
2433 const AVOption
*o
= av_opt_find(of
->ctx
, "fflags", NULL
, 0, 0);
2436 av_opt_eval_flags(of
->ctx
, o
, e
->value
, &format_flags
);
2438 e
= av_dict_get(ost
->encoder_opts
, "flags", NULL
, 0);
2440 const AVOption
*o
= av_opt_find(ost
->enc_ctx
, "flags", NULL
, 0, 0);
2443 av_opt_eval_flags(ost
->enc_ctx
, o
, e
->value
, &codec_flags
);
2446 encoder_string_len
= sizeof(LIBAVCODEC_IDENT
) + strlen(ost
->enc
->name
) + 2;
2447 encoder_string
= av_mallocz(encoder_string_len
);
2448 if (!encoder_string
)
2451 if (!(format_flags
& AVFMT_FLAG_BITEXACT
) && !(codec_flags
& CODEC_FLAG_BITEXACT
))
2452 av_strlcpy(encoder_string
, LIBAVCODEC_IDENT
" ", encoder_string_len
);
2454 av_strlcpy(encoder_string
, "Lavc ", encoder_string_len
);
2455 av_strlcat(encoder_string
, ost
->enc
->name
, encoder_string_len
);
2456 av_dict_set(&ost
->st
->metadata
, "encoder", encoder_string
,
2457 AV_DICT_DONT_STRDUP_VAL
| AV_DICT_DONT_OVERWRITE
);
2460 static int transcode_init(void)
2462 int ret
= 0, i
, j
, k
;
2463 AVFormatContext
*oc
;
2469 for (i
= 0; i
< nb_filtergraphs
; i
++) {
2470 FilterGraph
*fg
= filtergraphs
[i
];
2471 for (j
= 0; j
< fg
->nb_outputs
; j
++) {
2472 OutputFilter
*ofilter
= fg
->outputs
[j
];
2473 if (!ofilter
->ost
|| ofilter
->ost
->source_index
>= 0)
2475 if (fg
->nb_inputs
!= 1)
2477 for (k
= nb_input_streams
-1; k
>= 0 ; k
--)
2478 if (fg
->inputs
[0]->ist
== input_streams
[k
])
2480 ofilter
->ost
->source_index
= k
;
2484 /* init framerate emulation */
2485 for (i
= 0; i
< nb_input_files
; i
++) {
2486 InputFile
*ifile
= input_files
[i
];
2487 if (ifile
->rate_emu
)
2488 for (j
= 0; j
< ifile
->nb_streams
; j
++)
2489 input_streams
[j
+ ifile
->ist_index
]->start
= av_gettime_relative();
2492 /* output stream init */
2493 for (i
= 0; i
< nb_output_files
; i
++) {
2494 oc
= output_files
[i
]->ctx
;
2495 if (!oc
->nb_streams
&& !(oc
->oformat
->flags
& AVFMT_NOSTREAMS
)) {
2496 av_dump_format(oc
, i
, oc
->filename
, 1);
2497 av_log(NULL
, AV_LOG_ERROR
, "Output file #%d does not contain any stream\n", i
);
2498 return AVERROR(EINVAL
);
2502 /* init complex filtergraphs */
2503 for (i
= 0; i
< nb_filtergraphs
; i
++)
2504 if ((ret
= avfilter_graph_config(filtergraphs
[i
]->graph
, NULL
)) < 0)
2507 /* for each output stream, we compute the right encoding parameters */
2508 for (i
= 0; i
< nb_output_streams
; i
++) {
2509 AVCodecContext
*enc_ctx
;
2510 AVCodecContext
*dec_ctx
= NULL
;
2511 ost
= output_streams
[i
];
2512 oc
= output_files
[ost
->file_index
]->ctx
;
2513 ist
= get_input_stream(ost
);
2515 if (ost
->attachment_filename
)
2518 enc_ctx
= ost
->enc_ctx
;
2521 dec_ctx
= ist
->dec_ctx
;
2523 ost
->st
->disposition
= ist
->st
->disposition
;
2524 enc_ctx
->bits_per_raw_sample
= dec_ctx
->bits_per_raw_sample
;
2525 enc_ctx
->chroma_sample_location
= dec_ctx
->chroma_sample_location
;
2527 for (j
=0; j
<oc
->nb_streams
; j
++) {
2528 AVStream
*st
= oc
->streams
[j
];
2529 if (st
!= ost
->st
&& st
->codec
->codec_type
== enc_ctx
->codec_type
)
2532 if (j
== oc
->nb_streams
)
2533 if (enc_ctx
->codec_type
== AVMEDIA_TYPE_AUDIO
|| enc_ctx
->codec_type
== AVMEDIA_TYPE_VIDEO
)
2534 ost
->st
->disposition
= AV_DISPOSITION_DEFAULT
;
2537 if (ost
->stream_copy
) {
2539 uint64_t extra_size
;
2541 av_assert0(ist
&& !ost
->filter
);
2543 extra_size
= (uint64_t)dec_ctx
->extradata_size
+ FF_INPUT_BUFFER_PADDING_SIZE
;
2545 if (extra_size
> INT_MAX
) {
2546 return AVERROR(EINVAL
);
2549 /* if stream_copy is selected, no need to decode or encode */
2550 enc_ctx
->codec_id
= dec_ctx
->codec_id
;
2551 enc_ctx
->codec_type
= dec_ctx
->codec_type
;
2553 if (!enc_ctx
->codec_tag
) {
2554 unsigned int codec_tag
;
2555 if (!oc
->oformat
->codec_tag
||
2556 av_codec_get_id (oc
->oformat
->codec_tag
, dec_ctx
->codec_tag
) == enc_ctx
->codec_id
||
2557 !av_codec_get_tag2(oc
->oformat
->codec_tag
, dec_ctx
->codec_id
, &codec_tag
))
2558 enc_ctx
->codec_tag
= dec_ctx
->codec_tag
;
2561 enc_ctx
->bit_rate
= dec_ctx
->bit_rate
;
2562 enc_ctx
->rc_max_rate
= dec_ctx
->rc_max_rate
;
2563 enc_ctx
->rc_buffer_size
= dec_ctx
->rc_buffer_size
;
2564 enc_ctx
->field_order
= dec_ctx
->field_order
;
2565 enc_ctx
->extradata
= av_mallocz(extra_size
);
2566 if (!enc_ctx
->extradata
) {
2567 return AVERROR(ENOMEM
);
2569 memcpy(enc_ctx
->extradata
, dec_ctx
->extradata
, dec_ctx
->extradata_size
);
2570 enc_ctx
->extradata_size
= dec_ctx
->extradata_size
;
2571 enc_ctx
->bits_per_coded_sample
= dec_ctx
->bits_per_coded_sample
;
2573 enc_ctx
->time_base
= ist
->st
->time_base
;
2575 * Avi is a special case here because it supports variable fps but
2576 * having the fps and timebase differe significantly adds quite some
2579 if(!strcmp(oc
->oformat
->name
, "avi")) {
2580 if ( copy_tb
<0 && av_q2d(ist
->st
->r_frame_rate
) >= av_q2d(ist
->st
->avg_frame_rate
)
2581 && 0.5/av_q2d(ist
->st
->r_frame_rate
) > av_q2d(ist
->st
->time_base
)
2582 && 0.5/av_q2d(ist
->st
->r_frame_rate
) > av_q2d(dec_ctx
->time_base
)
2583 && av_q2d(ist
->st
->time_base
) < 1.0/500 && av_q2d(dec_ctx
->time_base
) < 1.0/500
2585 enc_ctx
->time_base
.num
= ist
->st
->r_frame_rate
.den
;
2586 enc_ctx
->time_base
.den
= 2*ist
->st
->r_frame_rate
.num
;
2587 enc_ctx
->ticks_per_frame
= 2;
2588 } else if ( copy_tb
<0 && av_q2d(dec_ctx
->time_base
)*dec_ctx
->ticks_per_frame
> 2*av_q2d(ist
->st
->time_base
)
2589 && av_q2d(ist
->st
->time_base
) < 1.0/500
2591 enc_ctx
->time_base
= dec_ctx
->time_base
;
2592 enc_ctx
->time_base
.num
*= dec_ctx
->ticks_per_frame
;
2593 enc_ctx
->time_base
.den
*= 2;
2594 enc_ctx
->ticks_per_frame
= 2;
2596 } else if(!(oc
->oformat
->flags
& AVFMT_VARIABLE_FPS
)
2597 && strcmp(oc
->oformat
->name
, "mov") && strcmp(oc
->oformat
->name
, "mp4") && strcmp(oc
->oformat
->name
, "3gp")
2598 && strcmp(oc
->oformat
->name
, "3g2") && strcmp(oc
->oformat
->name
, "psp") && strcmp(oc
->oformat
->name
, "ipod")
2599 && strcmp(oc
->oformat
->name
, "f4v")
2601 if( copy_tb
<0 && dec_ctx
->time_base
.den
2602 && av_q2d(dec_ctx
->time_base
)*dec_ctx
->ticks_per_frame
> av_q2d(ist
->st
->time_base
)
2603 && av_q2d(ist
->st
->time_base
) < 1.0/500
2605 enc_ctx
->time_base
= dec_ctx
->time_base
;
2606 enc_ctx
->time_base
.num
*= dec_ctx
->ticks_per_frame
;
2609 if ( enc_ctx
->codec_tag
== AV_RL32("tmcd")
2610 && dec_ctx
->time_base
.num
< dec_ctx
->time_base
.den
2611 && dec_ctx
->time_base
.num
> 0
2612 && 121LL*dec_ctx
->time_base
.num
> dec_ctx
->time_base
.den
) {
2613 enc_ctx
->time_base
= dec_ctx
->time_base
;
2616 if (ist
&& !ost
->frame_rate
.num
)
2617 ost
->frame_rate
= ist
->framerate
;
2618 if(ost
->frame_rate
.num
)
2619 enc_ctx
->time_base
= av_inv_q(ost
->frame_rate
);
2621 av_reduce(&enc_ctx
->time_base
.num
, &enc_ctx
->time_base
.den
,
2622 enc_ctx
->time_base
.num
, enc_ctx
->time_base
.den
, INT_MAX
);
2624 ost
->parser
= av_parser_init(enc_ctx
->codec_id
);
2626 switch (enc_ctx
->codec_type
) {
2627 case AVMEDIA_TYPE_AUDIO
:
2628 if (audio_volume
!= 256) {
2629 av_log(NULL
, AV_LOG_FATAL
, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2632 enc_ctx
->channel_layout
= dec_ctx
->channel_layout
;
2633 enc_ctx
->sample_rate
= dec_ctx
->sample_rate
;
2634 enc_ctx
->channels
= dec_ctx
->channels
;
2635 enc_ctx
->frame_size
= dec_ctx
->frame_size
;
2636 enc_ctx
->audio_service_type
= dec_ctx
->audio_service_type
;
2637 enc_ctx
->block_align
= dec_ctx
->block_align
;
2638 enc_ctx
->delay
= dec_ctx
->delay
;
2639 if((enc_ctx
->block_align
== 1 || enc_ctx
->block_align
== 1152 || enc_ctx
->block_align
== 576) && enc_ctx
->codec_id
== AV_CODEC_ID_MP3
)
2640 enc_ctx
->block_align
= 0;
2641 if(enc_ctx
->codec_id
== AV_CODEC_ID_AC3
)
2642 enc_ctx
->block_align
= 0;
2644 case AVMEDIA_TYPE_VIDEO
:
2645 enc_ctx
->pix_fmt
= dec_ctx
->pix_fmt
;
2646 enc_ctx
->width
= dec_ctx
->width
;
2647 enc_ctx
->height
= dec_ctx
->height
;
2648 enc_ctx
->has_b_frames
= dec_ctx
->has_b_frames
;
2649 if (ost
->frame_aspect_ratio
.num
) { // overridden by the -aspect cli option
2651 av_mul_q(ost
->frame_aspect_ratio
,
2652 (AVRational
){ enc_ctx
->height
, enc_ctx
->width
});
2653 av_log(NULL
, AV_LOG_WARNING
, "Overriding aspect ratio "
2654 "with stream copy may produce invalid files\n");
2656 else if (ist
->st
->sample_aspect_ratio
.num
)
2657 sar
= ist
->st
->sample_aspect_ratio
;
2659 sar
= dec_ctx
->sample_aspect_ratio
;
2660 ost
->st
->sample_aspect_ratio
= enc_ctx
->sample_aspect_ratio
= sar
;
2661 ost
->st
->avg_frame_rate
= ist
->st
->avg_frame_rate
;
2663 case AVMEDIA_TYPE_SUBTITLE
:
2664 enc_ctx
->width
= dec_ctx
->width
;
2665 enc_ctx
->height
= dec_ctx
->height
;
2667 case AVMEDIA_TYPE_DATA
:
2668 case AVMEDIA_TYPE_ATTACHMENT
:
2675 ost
->enc
= avcodec_find_encoder(enc_ctx
->codec_id
);
2677 /* should only happen when a default codec is not present. */
2678 snprintf(error
, sizeof(error
), "Encoder (codec %s) not found for output stream #%d:%d",
2679 avcodec_get_name(ost
->st
->codec
->codec_id
), ost
->file_index
, ost
->index
);
2680 ret
= AVERROR(EINVAL
);
2685 ist
->decoding_needed
|= DECODING_FOR_OST
;
2686 ost
->encoding_needed
= 1;
2688 set_encoder_id(output_files
[ost
->file_index
], ost
);
2691 (enc_ctx
->codec_type
== AVMEDIA_TYPE_VIDEO
||
2692 enc_ctx
->codec_type
== AVMEDIA_TYPE_AUDIO
)) {
2694 fg
= init_simple_filtergraph(ist
, ost
);
2695 if (configure_filtergraph(fg
)) {
2696 av_log(NULL
, AV_LOG_FATAL
, "Error opening filters!\n");
2701 if (enc_ctx
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
2702 if (ost
->filter
&& !ost
->frame_rate
.num
)
2703 ost
->frame_rate
= av_buffersink_get_frame_rate(ost
->filter
->filter
);
2704 if (ist
&& !ost
->frame_rate
.num
)
2705 ost
->frame_rate
= ist
->framerate
;
2706 if (ist
&& !ost
->frame_rate
.num
)
2707 ost
->frame_rate
= ist
->st
->r_frame_rate
;
2708 if (ist
&& !ost
->frame_rate
.num
) {
2709 ost
->frame_rate
= (AVRational
){25, 1};
2710 av_log(NULL
, AV_LOG_WARNING
,
2712 "about the input framerate is available. Falling "
2713 "back to a default value of 25fps for output stream #%d:%d. Use the -r option "
2714 "if you want a different framerate.\n",
2715 ost
->file_index
, ost
->index
);
2717 // ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
2718 if (ost
->enc
&& ost
->enc
->supported_framerates
&& !ost
->force_fps
) {
2719 int idx
= av_find_nearest_q_idx(ost
->frame_rate
, ost
->enc
->supported_framerates
);
2720 ost
->frame_rate
= ost
->enc
->supported_framerates
[idx
];
2722 if (enc_ctx
->codec_id
== AV_CODEC_ID_MPEG4
) {
2723 av_reduce(&ost
->frame_rate
.num
, &ost
->frame_rate
.den
,
2724 ost
->frame_rate
.num
, ost
->frame_rate
.den
, 65535);
2728 switch (enc_ctx
->codec_type
) {
2729 case AVMEDIA_TYPE_AUDIO
:
2730 enc_ctx
->sample_fmt
= ost
->filter
->filter
->inputs
[0]->format
;
2731 enc_ctx
->sample_rate
= ost
->filter
->filter
->inputs
[0]->sample_rate
;
2732 enc_ctx
->channel_layout
= ost
->filter
->filter
->inputs
[0]->channel_layout
;
2733 enc_ctx
->channels
= avfilter_link_get_channels(ost
->filter
->filter
->inputs
[0]);
2734 enc_ctx
->time_base
= (AVRational
){ 1, enc_ctx
->sample_rate
};
2736 case AVMEDIA_TYPE_VIDEO
:
2737 enc_ctx
->time_base
= av_inv_q(ost
->frame_rate
);
2738 if (ost
->filter
&& !(enc_ctx
->time_base
.num
&& enc_ctx
->time_base
.den
))
2739 enc_ctx
->time_base
= ost
->filter
->filter
->inputs
[0]->time_base
;
2740 if ( av_q2d(enc_ctx
->time_base
) < 0.001 && video_sync_method
!= VSYNC_PASSTHROUGH
2741 && (video_sync_method
== VSYNC_CFR
|| video_sync_method
== VSYNC_VSCFR
|| (video_sync_method
== VSYNC_AUTO
&& !(oc
->oformat
->flags
& AVFMT_VARIABLE_FPS
)))){
2742 av_log(oc
, AV_LOG_WARNING
, "Frame rate very high for a muxer not efficiently supporting it.\n"
2743 "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
2745 for (j
= 0; j
< ost
->forced_kf_count
; j
++)
2746 ost
->forced_kf_pts
[j
] = av_rescale_q(ost
->forced_kf_pts
[j
],
2748 enc_ctx
->time_base
);
2750 enc_ctx
->width
= ost
->filter
->filter
->inputs
[0]->w
;
2751 enc_ctx
->height
= ost
->filter
->filter
->inputs
[0]->h
;
2752 enc_ctx
->sample_aspect_ratio
= ost
->st
->sample_aspect_ratio
=
2753 ost
->frame_aspect_ratio
.num
? // overridden by the -aspect cli option
2754 av_mul_q(ost
->frame_aspect_ratio
, (AVRational
){ enc_ctx
->height
, enc_ctx
->width
}) :
2755 ost
->filter
->filter
->inputs
[0]->sample_aspect_ratio
;
2756 if (!strncmp(ost
->enc
->name
, "libx264", 7) &&
2757 enc_ctx
->pix_fmt
== AV_PIX_FMT_NONE
&&
2758 ost
->filter
->filter
->inputs
[0]->format
!= AV_PIX_FMT_YUV420P
)
2759 av_log(NULL
, AV_LOG_WARNING
,
2760 "No pixel format specified, %s for H.264 encoding chosen.\n"
2761 "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
2762 av_get_pix_fmt_name(ost
->filter
->filter
->inputs
[0]->format
));
2763 if (!strncmp(ost
->enc
->name
, "mpeg2video", 10) &&
2764 enc_ctx
->pix_fmt
== AV_PIX_FMT_NONE
&&
2765 ost
->filter
->filter
->inputs
[0]->format
!= AV_PIX_FMT_YUV420P
)
2766 av_log(NULL
, AV_LOG_WARNING
,
2767 "No pixel format specified, %s for MPEG-2 encoding chosen.\n"
2768 "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
2769 av_get_pix_fmt_name(ost
->filter
->filter
->inputs
[0]->format
));
2770 enc_ctx
->pix_fmt
= ost
->filter
->filter
->inputs
[0]->format
;
2772 ost
->st
->avg_frame_rate
= ost
->frame_rate
;
2775 enc_ctx
->width
!= dec_ctx
->width
||
2776 enc_ctx
->height
!= dec_ctx
->height
||
2777 enc_ctx
->pix_fmt
!= dec_ctx
->pix_fmt
) {
2778 enc_ctx
->bits_per_raw_sample
= frame_bits_per_raw_sample
;
2781 if (ost
->forced_keyframes
) {
2782 if (!strncmp(ost
->forced_keyframes
, "expr:", 5)) {
2783 ret
= av_expr_parse(&ost
->forced_keyframes_pexpr
, ost
->forced_keyframes
+5,
2784 forced_keyframes_const_names
, NULL
, NULL
, NULL
, NULL
, 0, NULL
);
2786 av_log(NULL
, AV_LOG_ERROR
,
2787 "Invalid force_key_frames expression '%s'\n", ost
->forced_keyframes
+5);
2790 ost
->forced_keyframes_expr_const_values
[FKF_N
] = 0;
2791 ost
->forced_keyframes_expr_const_values
[FKF_N_FORCED
] = 0;
2792 ost
->forced_keyframes_expr_const_values
[FKF_PREV_FORCED_N
] = NAN
;
2793 ost
->forced_keyframes_expr_const_values
[FKF_PREV_FORCED_T
] = NAN
;
2795 parse_forced_key_frames(ost
->forced_keyframes
, ost
, ost
->enc_ctx
);
2799 case AVMEDIA_TYPE_SUBTITLE
:
2800 enc_ctx
->time_base
= (AVRational
){1, 1000};
2801 if (!enc_ctx
->width
) {
2802 enc_ctx
->width
= input_streams
[ost
->source_index
]->st
->codec
->width
;
2803 enc_ctx
->height
= input_streams
[ost
->source_index
]->st
->codec
->height
;
2811 if (enc_ctx
->flags
& (CODEC_FLAG_PASS1
| CODEC_FLAG_PASS2
)) {
2812 char logfilename
[1024];
2815 snprintf(logfilename
, sizeof(logfilename
), "%s-%d.log",
2816 ost
->logfile_prefix
? ost
->logfile_prefix
:
2817 DEFAULT_PASS_LOGFILENAME_PREFIX
,
2819 if (!strcmp(ost
->enc
->name
, "libx264")) {
2820 av_dict_set(&ost
->encoder_opts
, "stats", logfilename
, AV_DICT_DONT_OVERWRITE
);
2822 if (enc_ctx
->flags
& CODEC_FLAG_PASS2
) {
2824 size_t logbuffer_size
;
2825 if (cmdutils_read_file(logfilename
, &logbuffer
, &logbuffer_size
) < 0) {
2826 av_log(NULL
, AV_LOG_FATAL
, "Error reading log file '%s' for pass-2 encoding\n",
2830 enc_ctx
->stats_in
= logbuffer
;
2832 if (enc_ctx
->flags
& CODEC_FLAG_PASS1
) {
2833 f
= av_fopen_utf8(logfilename
, "wb");
2835 av_log(NULL
, AV_LOG_FATAL
, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2836 logfilename
, strerror(errno
));
2846 /* open each encoder */
2847 for (i
= 0; i
< nb_output_streams
; i
++) {
2848 ost
= output_streams
[i
];
2849 if (ost
->encoding_needed
) {
2850 AVCodec
*codec
= ost
->enc
;
2851 AVCodecContext
*dec
= NULL
;
2853 if ((ist
= get_input_stream(ost
)))
2855 if (dec
&& dec
->subtitle_header
) {
2856 /* ASS code assumes this buffer is null terminated so add extra byte. */
2857 ost
->enc_ctx
->subtitle_header
= av_mallocz(dec
->subtitle_header_size
+ 1);
2858 if (!ost
->enc_ctx
->subtitle_header
) {
2859 ret
= AVERROR(ENOMEM
);
2862 memcpy(ost
->enc_ctx
->subtitle_header
, dec
->subtitle_header
, dec
->subtitle_header_size
);
2863 ost
->enc_ctx
->subtitle_header_size
= dec
->subtitle_header_size
;
2865 if (!av_dict_get(ost
->encoder_opts
, "threads", NULL
, 0))
2866 av_dict_set(&ost
->encoder_opts
, "threads", "auto", 0);
2867 av_dict_set(&ost
->encoder_opts
, "side_data_only_packets", "1", 0);
2869 if ((ret
= avcodec_open2(ost
->enc_ctx
, codec
, &ost
->encoder_opts
)) < 0) {
2870 if (ret
== AVERROR_EXPERIMENTAL
)
2871 abort_codec_experimental(codec
, 1);
2872 snprintf(error
, sizeof(error
), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2873 ost
->file_index
, ost
->index
);
2876 if (ost
->enc
->type
== AVMEDIA_TYPE_AUDIO
&&
2877 !(ost
->enc
->capabilities
& CODEC_CAP_VARIABLE_FRAME_SIZE
))
2878 av_buffersink_set_frame_size(ost
->filter
->filter
,
2879 ost
->enc_ctx
->frame_size
);
2880 assert_avoptions(ost
->encoder_opts
);
2881 if (ost
->enc_ctx
->bit_rate
&& ost
->enc_ctx
->bit_rate
< 1000)
2882 av_log(NULL
, AV_LOG_WARNING
, "The bitrate parameter is set too low."
2883 " It takes bits/s as argument, not kbits/s\n");
2885 if (av_opt_set_dict(ost
->enc_ctx
, &ost
->encoder_opts
) < 0) {
2886 av_log(NULL
, AV_LOG_FATAL
,
2887 "Error setting up codec context options.\n");
2892 ret
= avcodec_copy_context(ost
->st
->codec
, ost
->enc_ctx
);
2894 av_log(NULL
, AV_LOG_FATAL
,
2895 "Error initializing the output stream codec context.\n");
2898 ost
->st
->codec
->codec
= ost
->enc_ctx
->codec
;
2900 // copy timebase while removing common factors
2901 ost
->st
->time_base
= av_add_q(ost
->enc_ctx
->time_base
, (AVRational
){0, 1});
2904 /* init input streams */
2905 for (i
= 0; i
< nb_input_streams
; i
++)
2906 if ((ret
= init_input_stream(i
, error
, sizeof(error
))) < 0) {
2907 for (i
= 0; i
< nb_output_streams
; i
++) {
2908 ost
= output_streams
[i
];
2909 avcodec_close(ost
->enc_ctx
);
2914 /* discard unused programs */
2915 for (i
= 0; i
< nb_input_files
; i
++) {
2916 InputFile
*ifile
= input_files
[i
];
2917 for (j
= 0; j
< ifile
->ctx
->nb_programs
; j
++) {
2918 AVProgram
*p
= ifile
->ctx
->programs
[j
];
2919 int discard
= AVDISCARD_ALL
;
2921 for (k
= 0; k
< p
->nb_stream_indexes
; k
++)
2922 if (!input_streams
[ifile
->ist_index
+ p
->stream_index
[k
]]->discard
) {
2923 discard
= AVDISCARD_DEFAULT
;
2926 p
->discard
= discard
;
2930 /* open files and write file headers */
2931 for (i
= 0; i
< nb_output_files
; i
++) {
2932 oc
= output_files
[i
]->ctx
;
2933 oc
->interrupt_callback
= int_cb
;
2934 if ((ret
= avformat_write_header(oc
, &output_files
[i
]->opts
)) < 0) {
2935 snprintf(error
, sizeof(error
),
2936 "Could not write header for output file #%d "
2937 "(incorrect codec parameters ?): %s",
2938 i
, av_err2str(ret
));
2939 ret
= AVERROR(EINVAL
);
2942 // assert_avoptions(output_files[i]->opts);
2943 if (strcmp(oc
->oformat
->name
, "rtp")) {
2949 /* dump the file output parameters - cannot be done before in case
2951 for (i
= 0; i
< nb_output_files
; i
++) {
2952 av_dump_format(output_files
[i
]->ctx
, i
, output_files
[i
]->ctx
->filename
, 1);
2955 /* dump the stream mapping */
2956 av_log(NULL
, AV_LOG_INFO
, "Stream mapping:\n");
2957 for (i
= 0; i
< nb_input_streams
; i
++) {
2958 ist
= input_streams
[i
];
2960 for (j
= 0; j
< ist
->nb_filters
; j
++) {
2961 if (ist
->filters
[j
]->graph
->graph_desc
) {
2962 av_log(NULL
, AV_LOG_INFO
, " Stream #%d:%d (%s) -> %s",
2963 ist
->file_index
, ist
->st
->index
, ist
->dec
? ist
->dec
->name
: "?",
2964 ist
->filters
[j
]->name
);
2965 if (nb_filtergraphs
> 1)
2966 av_log(NULL
, AV_LOG_INFO
, " (graph %d)", ist
->filters
[j
]->graph
->index
);
2967 av_log(NULL
, AV_LOG_INFO
, "\n");
2972 for (i
= 0; i
< nb_output_streams
; i
++) {
2973 ost
= output_streams
[i
];
2975 if (ost
->attachment_filename
) {
2976 /* an attached file */
2977 av_log(NULL
, AV_LOG_INFO
, " File %s -> Stream #%d:%d\n",
2978 ost
->attachment_filename
, ost
->file_index
, ost
->index
);
2982 if (ost
->filter
&& ost
->filter
->graph
->graph_desc
) {
2983 /* output from a complex graph */
2984 av_log(NULL
, AV_LOG_INFO
, " %s", ost
->filter
->name
);
2985 if (nb_filtergraphs
> 1)
2986 av_log(NULL
, AV_LOG_INFO
, " (graph %d)", ost
->filter
->graph
->index
);
2988 av_log(NULL
, AV_LOG_INFO
, " -> Stream #%d:%d (%s)\n", ost
->file_index
,
2989 ost
->index
, ost
->enc
? ost
->enc
->name
: "?");
2993 av_log(NULL
, AV_LOG_INFO
, " Stream #%d:%d -> #%d:%d",
2994 input_streams
[ost
->source_index
]->file_index
,
2995 input_streams
[ost
->source_index
]->st
->index
,
2998 if (ost
->sync_ist
!= input_streams
[ost
->source_index
])
2999 av_log(NULL
, AV_LOG_INFO
, " [sync #%d:%d]",
3000 ost
->sync_ist
->file_index
,
3001 ost
->sync_ist
->st
->index
);
3002 if (ost
->stream_copy
)
3003 av_log(NULL
, AV_LOG_INFO
, " (copy)");
3005 const AVCodec
*in_codec
= input_streams
[ost
->source_index
]->dec
;
3006 const AVCodec
*out_codec
= ost
->enc
;
3007 const char *decoder_name
= "?";
3008 const char *in_codec_name
= "?";
3009 const char *encoder_name
= "?";
3010 const char *out_codec_name
= "?";
3013 decoder_name
= in_codec
->name
;
3014 in_codec_name
= avcodec_descriptor_get(in_codec
->id
)->name
;
3015 if (!strcmp(decoder_name
, in_codec_name
))
3016 decoder_name
= "native";
3020 encoder_name
= out_codec
->name
;
3021 out_codec_name
= avcodec_descriptor_get(out_codec
->id
)->name
;
3022 if (!strcmp(encoder_name
, out_codec_name
))
3023 encoder_name
= "native";
3026 av_log(NULL
, AV_LOG_INFO
, " (%s (%s) -> %s (%s))",
3027 in_codec_name
, decoder_name
,
3028 out_codec_name
, encoder_name
);
3030 av_log(NULL
, AV_LOG_INFO
, "\n");
3034 av_log(NULL
, AV_LOG_ERROR
, "%s\n", error
);
3042 transcode_init_done
= 1;
3047 /* Return 1 if there remain streams where more output is wanted, 0 otherwise. */
3048 static int need_output(void)
3052 for (i
= 0; i
< nb_output_streams
; i
++) {
3053 OutputStream
*ost
= output_streams
[i
];
3054 OutputFile
*of
= output_files
[ost
->file_index
];
3055 AVFormatContext
*os
= output_files
[ost
->file_index
]->ctx
;
3057 if (ost
->finished
||
3058 (os
->pb
&& avio_tell(os
->pb
) >= of
->limit_filesize
))
3060 if (ost
->frame_number
>= ost
->max_frames
) {
3062 for (j
= 0; j
< of
->ctx
->nb_streams
; j
++)
3063 close_output_stream(output_streams
[of
->ost_index
+ j
]);
3074 * Select the output stream to process.
3076 * @return selected output stream, or NULL if none available
3078 static OutputStream
*choose_output(void)
3081 int64_t opts_min
= INT64_MAX
;
3082 OutputStream
*ost_min
= NULL
;
3084 for (i
= 0; i
< nb_output_streams
; i
++) {
3085 OutputStream
*ost
= output_streams
[i
];
3086 int64_t opts
= av_rescale_q(ost
->st
->cur_dts
, ost
->st
->time_base
,
3088 if (!ost
->unavailable
&& !ost
->finished
&& opts
< opts_min
) {
3096 static int check_keyboard_interaction(int64_t cur_time
)
3099 static int64_t last_time
;
3100 if (received_nb_signals
)
3101 return AVERROR_EXIT
;
3102 /* read_key() returns 0 on EOF */
3103 if(cur_time
- last_time
>= 100000 && !run_as_daemon
){
3105 last_time
= cur_time
;
3109 return AVERROR_EXIT
;
3110 if (key
== '+') av_log_set_level(av_log_get_level()+10);
3111 if (key
== '-') av_log_set_level(av_log_get_level()-10);
3112 if (key
== 's') qp_hist
^= 1;
3115 do_hex_dump
= do_pkt_dump
= 0;
3116 } else if(do_pkt_dump
){
3120 av_log_set_level(AV_LOG_DEBUG
);
3122 if (key
== 'c' || key
== 'C'){
3123 char buf
[4096], target
[64], command
[256], arg
[256] = {0};
3126 fprintf(stderr
, "\nEnter command: <target>|all <time>|-1 <command>[ <argument>]\n");
3128 while ((k
= read_key()) != '\n' && k
!= '\r' && i
< sizeof(buf
)-1)
3133 (n
= sscanf(buf
, "%63[^ ] %lf %255[^ ] %255[^\n]", target
, &time
, command
, arg
)) >= 3) {
3134 av_log(NULL
, AV_LOG_DEBUG
, "Processing command target:%s time:%f command:%s arg:%s",
3135 target
, time
, command
, arg
);
3136 for (i
= 0; i
< nb_filtergraphs
; i
++) {
3137 FilterGraph
*fg
= filtergraphs
[i
];
3140 ret
= avfilter_graph_send_command(fg
->graph
, target
, command
, arg
, buf
, sizeof(buf
),
3141 key
== 'c' ? AVFILTER_CMD_FLAG_ONE
: 0);
3142 fprintf(stderr
, "Command reply for stream %d: ret:%d res:\n%s", i
, ret
, buf
);
3143 } else if (key
== 'c') {
3144 fprintf(stderr
, "Queing commands only on filters supporting the specific command is unsupported\n");
3145 ret
= AVERROR_PATCHWELCOME
;
3147 ret
= avfilter_graph_queue_command(fg
->graph
, target
, command
, arg
, 0, time
);
3152 av_log(NULL
, AV_LOG_ERROR
,
3153 "Parse error, at least 3 arguments were expected, "
3154 "only %d given in string '%s'\n", n
, buf
);
3157 if (key
== 'd' || key
== 'D'){
3160 debug
= input_streams
[0]->st
->codec
->debug
<<1;
3161 if(!debug
) debug
= 1;
3162 while(debug
& (FF_DEBUG_DCT_COEFF
|FF_DEBUG_VIS_QP
|FF_DEBUG_VIS_MB_TYPE
)) //unsupported, would just crash
3165 if(scanf("%d", &debug
)!=1)
3166 fprintf(stderr
,"error parsing debug value\n");
3167 for(i
=0;i
<nb_input_streams
;i
++) {
3168 input_streams
[i
]->st
->codec
->debug
= debug
;
3170 for(i
=0;i
<nb_output_streams
;i
++) {
3171 OutputStream
*ost
= output_streams
[i
];
3172 ost
->enc_ctx
->debug
= debug
;
3174 if(debug
) av_log_set_level(AV_LOG_DEBUG
);
3175 fprintf(stderr
,"debug=%d\n", debug
);
3178 fprintf(stderr
, "key function\n"
3179 "? show this help\n"
3180 "+ increase verbosity\n"
3181 "- decrease verbosity\n"
3182 "c Send command to first matching filter supporting it\n"
3183 "C Send/Que command to all matching filters\n"
3184 "D cycle through available debug modes\n"
3185 "h dump packets/hex press to cycle through the 3 states\n"
3187 "s Show QP histogram\n"
3194 static void *input_thread(void *arg
)
3201 ret
= av_read_frame(f
->ctx
, &pkt
);
3203 if (ret
== AVERROR(EAGAIN
)) {
3208 av_thread_message_queue_set_err_recv(f
->in_thread_queue
, ret
);
3211 av_dup_packet(&pkt
);
3212 ret
= av_thread_message_queue_send(f
->in_thread_queue
, &pkt
, 0);
3214 if (ret
!= AVERROR_EOF
)
3215 av_log(f
->ctx
, AV_LOG_ERROR
,
3216 "Unable to send packet to main thread: %s\n",
3218 av_free_packet(&pkt
);
3219 av_thread_message_queue_set_err_recv(f
->in_thread_queue
, ret
);
3227 static void free_input_threads(void)
3231 for (i
= 0; i
< nb_input_files
; i
++) {
3232 InputFile
*f
= input_files
[i
];
3235 if (!f
->in_thread_queue
)
3237 av_thread_message_queue_set_err_send(f
->in_thread_queue
, AVERROR_EOF
);
3238 while (av_thread_message_queue_recv(f
->in_thread_queue
, &pkt
, 0) >= 0)
3239 av_free_packet(&pkt
);
3241 pthread_join(f
->thread
, NULL
);
3243 av_thread_message_queue_free(&f
->in_thread_queue
);
3247 static int init_input_threads(void)
3251 if (nb_input_files
== 1)
3254 for (i
= 0; i
< nb_input_files
; i
++) {
3255 InputFile
*f
= input_files
[i
];
3257 if (f
->ctx
->pb
? !f
->ctx
->pb
->seekable
:
3258 strcmp(f
->ctx
->iformat
->name
, "lavfi"))
3259 f
->non_blocking
= 1;
3260 ret
= av_thread_message_queue_alloc(&f
->in_thread_queue
,
3261 8, sizeof(AVPacket
));
3265 if ((ret
= pthread_create(&f
->thread
, NULL
, input_thread
, f
))) {
3266 av_log(NULL
, AV_LOG_ERROR
, "pthread_create failed: %s. Try to increase `ulimit -v` or decrease `ulimit -s`.\n", strerror(ret
));
3267 av_thread_message_queue_free(&f
->in_thread_queue
);
3268 return AVERROR(ret
);
3274 static int get_input_packet_mt(InputFile
*f
, AVPacket
*pkt
)
3276 return av_thread_message_queue_recv(f
->in_thread_queue
, pkt
,
3278 AV_THREAD_MESSAGE_NONBLOCK
: 0);
3282 static int get_input_packet(InputFile
*f
, AVPacket
*pkt
)
3286 for (i
= 0; i
< f
->nb_streams
; i
++) {
3287 InputStream
*ist
= input_streams
[f
->ist_index
+ i
];
3288 int64_t pts
= av_rescale(ist
->dts
, 1000000, AV_TIME_BASE
);
3289 int64_t now
= av_gettime_relative() - ist
->start
;
3291 return AVERROR(EAGAIN
);
3296 if (nb_input_files
> 1)
3297 return get_input_packet_mt(f
, pkt
);
3299 return av_read_frame(f
->ctx
, pkt
);
3302 static int got_eagain(void)
3305 for (i
= 0; i
< nb_output_streams
; i
++)
3306 if (output_streams
[i
]->unavailable
)
3311 static void reset_eagain(void)
3314 for (i
= 0; i
< nb_input_files
; i
++)
3315 input_files
[i
]->eagain
= 0;
3316 for (i
= 0; i
< nb_output_streams
; i
++)
3317 output_streams
[i
]->unavailable
= 0;
3322 * - 0 -- one packet was read and processed
3323 * - AVERROR(EAGAIN) -- no packets were available for selected file,
3324 * this function should be called again
3325 * - AVERROR_EOF -- this function should not be called again
3327 static int process_input(int file_index
)
3329 InputFile
*ifile
= input_files
[file_index
];
3330 AVFormatContext
*is
;
3336 ret
= get_input_packet(ifile
, &pkt
);
3338 if (ret
== AVERROR(EAGAIN
)) {
3343 if (ret
!= AVERROR_EOF
) {
3344 print_error(is
->filename
, ret
);
3349 for (i
= 0; i
< ifile
->nb_streams
; i
++) {
3350 ist
= input_streams
[ifile
->ist_index
+ i
];
3351 if (ist
->decoding_needed
) {
3352 ret
= process_input_packet(ist
, NULL
);
3357 /* mark all outputs that don't go through lavfi as finished */
3358 for (j
= 0; j
< nb_output_streams
; j
++) {
3359 OutputStream
*ost
= output_streams
[j
];
3361 if (ost
->source_index
== ifile
->ist_index
+ i
&&
3362 (ost
->stream_copy
|| ost
->enc
->type
== AVMEDIA_TYPE_SUBTITLE
))
3363 finish_output_stream(ost
);
3367 ifile
->eof_reached
= 1;
3368 return AVERROR(EAGAIN
);
3374 av_pkt_dump_log2(NULL
, AV_LOG_DEBUG
, &pkt
, do_hex_dump
,
3375 is
->streams
[pkt
.stream_index
]);
3377 /* the following test is needed in case new streams appear
3378 dynamically in stream : we ignore them */
3379 if (pkt
.stream_index
>= ifile
->nb_streams
) {
3380 report_new_stream(file_index
, &pkt
);
3381 goto discard_packet
;
3384 ist
= input_streams
[ifile
->ist_index
+ pkt
.stream_index
];
3386 ist
->data_size
+= pkt
.size
;
3390 goto discard_packet
;
3393 av_log(NULL
, AV_LOG_INFO
, "demuxer -> ist_index:%d type:%s "
3394 "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",
3395 ifile
->ist_index
+ pkt
.stream_index
, av_get_media_type_string(ist
->dec_ctx
->codec_type
),
3396 av_ts2str(ist
->next_dts
), av_ts2timestr(ist
->next_dts
, &AV_TIME_BASE_Q
),
3397 av_ts2str(ist
->next_pts
), av_ts2timestr(ist
->next_pts
, &AV_TIME_BASE_Q
),
3398 av_ts2str(pkt
.pts
), av_ts2timestr(pkt
.pts
, &ist
->st
->time_base
),
3399 av_ts2str(pkt
.dts
), av_ts2timestr(pkt
.dts
, &ist
->st
->time_base
),
3400 av_ts2str(input_files
[ist
->file_index
]->ts_offset
),
3401 av_ts2timestr(input_files
[ist
->file_index
]->ts_offset
, &AV_TIME_BASE_Q
));
3404 if(!ist
->wrap_correction_done
&& is
->start_time
!= AV_NOPTS_VALUE
&& ist
->st
->pts_wrap_bits
< 64){
3405 int64_t stime
, stime2
;
3406 // Correcting starttime based on the enabled streams
3407 // 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.
3408 // so we instead do it here as part of discontinuity handling
3409 if ( ist
->next_dts
== AV_NOPTS_VALUE
3410 && ifile
->ts_offset
== -is
->start_time
3411 && (is
->iformat
->flags
& AVFMT_TS_DISCONT
)) {
3412 int64_t new_start_time
= INT64_MAX
;
3413 for (i
=0; i
<is
->nb_streams
; i
++) {
3414 AVStream
*st
= is
->streams
[i
];
3415 if(st
->discard
== AVDISCARD_ALL
|| st
->start_time
== AV_NOPTS_VALUE
)
3417 new_start_time
= FFMIN(new_start_time
, av_rescale_q(st
->start_time
, st
->time_base
, AV_TIME_BASE_Q
));
3419 if (new_start_time
> is
->start_time
) {
3420 av_log(is
, AV_LOG_VERBOSE
, "Correcting start time by %"PRId64
"\n", new_start_time
- is
->start_time
);
3421 ifile
->ts_offset
= -new_start_time
;
3425 stime
= av_rescale_q(is
->start_time
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
3426 stime2
= stime
+ (1ULL<<ist
->st
->pts_wrap_bits
);
3427 ist
->wrap_correction_done
= 1;
3429 if(stime2
> stime
&& pkt
.dts
!= AV_NOPTS_VALUE
&& pkt
.dts
> stime
+ (1LL<<(ist
->st
->pts_wrap_bits
-1))) {
3430 pkt
.dts
-= 1ULL<<ist
->st
->pts_wrap_bits
;
3431 ist
->wrap_correction_done
= 0;
3433 if(stime2
> stime
&& pkt
.pts
!= AV_NOPTS_VALUE
&& pkt
.pts
> stime
+ (1LL<<(ist
->st
->pts_wrap_bits
-1))) {
3434 pkt
.pts
-= 1ULL<<ist
->st
->pts_wrap_bits
;
3435 ist
->wrap_correction_done
= 0;
3439 /* add the stream-global side data to the first packet */
3440 if (ist
->nb_packets
== 1) {
3441 if (ist
->st
->nb_side_data
)
3442 av_packet_split_side_data(&pkt
);
3443 for (i
= 0; i
< ist
->st
->nb_side_data
; i
++) {
3444 AVPacketSideData
*src_sd
= &ist
->st
->side_data
[i
];
3447 if (av_packet_get_side_data(&pkt
, src_sd
->type
, NULL
))
3450 dst_data
= av_packet_new_side_data(&pkt
, src_sd
->type
, src_sd
->size
);
3454 memcpy(dst_data
, src_sd
->data
, src_sd
->size
);
3458 if (pkt
.dts
!= AV_NOPTS_VALUE
)
3459 pkt
.dts
+= av_rescale_q(ifile
->ts_offset
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
3460 if (pkt
.pts
!= AV_NOPTS_VALUE
)
3461 pkt
.pts
+= av_rescale_q(ifile
->ts_offset
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
3463 if (pkt
.pts
!= AV_NOPTS_VALUE
)
3464 pkt
.pts
*= ist
->ts_scale
;
3465 if (pkt
.dts
!= AV_NOPTS_VALUE
)
3466 pkt
.dts
*= ist
->ts_scale
;
3468 if (pkt
.dts
!= AV_NOPTS_VALUE
&& ist
->next_dts
== AV_NOPTS_VALUE
&& !copy_ts
3469 && (is
->iformat
->flags
& AVFMT_TS_DISCONT
) && ifile
->last_ts
!= AV_NOPTS_VALUE
) {
3470 int64_t pkt_dts
= av_rescale_q(pkt
.dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
3471 int64_t delta
= pkt_dts
- ifile
->last_ts
;
3472 if(delta
< -1LL*dts_delta_threshold
*AV_TIME_BASE
||
3473 (delta
> 1LL*dts_delta_threshold
*AV_TIME_BASE
&&
3474 ist
->dec_ctx
->codec_type
!= AVMEDIA_TYPE_SUBTITLE
)){
3475 ifile
->ts_offset
-= delta
;
3476 av_log(NULL
, AV_LOG_DEBUG
,
3477 "Inter stream timestamp discontinuity %"PRId64
", new offset= %"PRId64
"\n",
3478 delta
, ifile
->ts_offset
);
3479 pkt
.dts
-= av_rescale_q(delta
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
3480 if (pkt
.pts
!= AV_NOPTS_VALUE
)
3481 pkt
.pts
-= av_rescale_q(delta
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
3485 if (pkt
.dts
!= AV_NOPTS_VALUE
&& ist
->next_dts
!= AV_NOPTS_VALUE
&&
3487 int64_t pkt_dts
= av_rescale_q(pkt
.dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
3488 int64_t delta
= pkt_dts
- ist
->next_dts
;
3489 if (is
->iformat
->flags
& AVFMT_TS_DISCONT
) {
3490 if (delta
< -1LL*dts_delta_threshold
*AV_TIME_BASE
||
3491 (delta
> 1LL*dts_delta_threshold
*AV_TIME_BASE
&&
3492 ist
->dec_ctx
->codec_type
!= AVMEDIA_TYPE_SUBTITLE
) ||
3493 pkt_dts
+ AV_TIME_BASE
/10 < FFMAX(ist
->pts
, ist
->dts
)) {
3494 ifile
->ts_offset
-= delta
;
3495 av_log(NULL
, AV_LOG_DEBUG
,
3496 "timestamp discontinuity %"PRId64
", new offset= %"PRId64
"\n",
3497 delta
, ifile
->ts_offset
);
3498 pkt
.dts
-= av_rescale_q(delta
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
3499 if (pkt
.pts
!= AV_NOPTS_VALUE
)
3500 pkt
.pts
-= av_rescale_q(delta
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
3503 if ( delta
< -1LL*dts_error_threshold
*AV_TIME_BASE
||
3504 (delta
> 1LL*dts_error_threshold
*AV_TIME_BASE
&& ist
->dec_ctx
->codec_type
!= AVMEDIA_TYPE_SUBTITLE
)) {
3505 av_log(NULL
, AV_LOG_WARNING
, "DTS %"PRId64
", next:%"PRId64
" st:%d invalid dropping\n", pkt
.dts
, ist
->next_dts
, pkt
.stream_index
);
3506 pkt
.dts
= AV_NOPTS_VALUE
;
3508 if (pkt
.pts
!= AV_NOPTS_VALUE
){
3509 int64_t pkt_pts
= av_rescale_q(pkt
.pts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
3510 delta
= pkt_pts
- ist
->next_dts
;
3511 if ( delta
< -1LL*dts_error_threshold
*AV_TIME_BASE
||
3512 (delta
> 1LL*dts_error_threshold
*AV_TIME_BASE
&& ist
->dec_ctx
->codec_type
!= AVMEDIA_TYPE_SUBTITLE
)) {
3513 av_log(NULL
, AV_LOG_WARNING
, "PTS %"PRId64
", next:%"PRId64
" invalid dropping st:%d\n", pkt
.pts
, ist
->next_dts
, pkt
.stream_index
);
3514 pkt
.pts
= AV_NOPTS_VALUE
;
3520 if (pkt
.dts
!= AV_NOPTS_VALUE
)
3521 ifile
->last_ts
= av_rescale_q(pkt
.dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
3524 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",
3525 ifile
->ist_index
+ pkt
.stream_index
, av_get_media_type_string(ist
->dec_ctx
->codec_type
),
3526 av_ts2str(pkt
.pts
), av_ts2timestr(pkt
.pts
, &ist
->st
->time_base
),
3527 av_ts2str(pkt
.dts
), av_ts2timestr(pkt
.dts
, &ist
->st
->time_base
),
3528 av_ts2str(input_files
[ist
->file_index
]->ts_offset
),
3529 av_ts2timestr(input_files
[ist
->file_index
]->ts_offset
, &AV_TIME_BASE_Q
));
3532 sub2video_heartbeat(ist
, pkt
.pts
);
3534 ret
= process_input_packet(ist
, &pkt
);
3536 av_log(NULL
, AV_LOG_ERROR
, "Error while decoding stream #%d:%d: %s\n",
3537 ist
->file_index
, ist
->st
->index
, av_err2str(ret
));
3543 av_free_packet(&pkt
);
3549 * Perform a step of transcoding for the specified filter graph.
3551 * @param[in] graph filter graph to consider
3552 * @param[out] best_ist input stream where a frame would allow to continue
3553 * @return 0 for success, <0 for error
3555 static int transcode_from_filter(FilterGraph
*graph
, InputStream
**best_ist
)
3558 int nb_requests
, nb_requests_max
= 0;
3559 InputFilter
*ifilter
;
3563 ret
= avfilter_graph_request_oldest(graph
->graph
);
3565 return reap_filters();
3567 if (ret
== AVERROR_EOF
) {
3568 ret
= reap_filters();
3569 for (i
= 0; i
< graph
->nb_outputs
; i
++)
3570 close_output_stream(graph
->outputs
[i
]->ost
);
3573 if (ret
!= AVERROR(EAGAIN
))
3576 for (i
= 0; i
< graph
->nb_inputs
; i
++) {
3577 ifilter
= graph
->inputs
[i
];
3579 if (input_files
[ist
->file_index
]->eagain
||
3580 input_files
[ist
->file_index
]->eof_reached
)
3582 nb_requests
= av_buffersrc_get_nb_failed_requests(ifilter
->filter
);
3583 if (nb_requests
> nb_requests_max
) {
3584 nb_requests_max
= nb_requests
;
3590 for (i
= 0; i
< graph
->nb_outputs
; i
++)
3591 graph
->outputs
[i
]->ost
->unavailable
= 1;
3597 * Run a single step of transcoding.
3599 * @return 0 for success, <0 for error
3601 static int transcode_step(void)
3607 ost
= choose_output();
3614 av_log(NULL
, AV_LOG_VERBOSE
, "No more inputs to read from, finishing.\n");
3619 if ((ret
= transcode_from_filter(ost
->filter
->graph
, &ist
)) < 0)
3624 av_assert0(ost
->source_index
>= 0);
3625 ist
= input_streams
[ost
->source_index
];
3628 ret
= process_input(ist
->file_index
);
3629 if (ret
== AVERROR(EAGAIN
)) {
3630 if (input_files
[ist
->file_index
]->eagain
)
3631 ost
->unavailable
= 1;
3635 return ret
== AVERROR_EOF
? 0 : ret
;
3637 return reap_filters();
3641 * The following code is the main loop of the file converter
3643 static int transcode(void)
3646 AVFormatContext
*os
;
3649 int64_t timer_start
;
3651 ret
= transcode_init();
3655 if (stdin_interaction
) {
3656 av_log(NULL
, AV_LOG_INFO
, "Press [q] to stop, [?] for help\n");
3659 timer_start
= av_gettime_relative();
3662 if ((ret
= init_input_threads()) < 0)
3666 while (!received_sigterm
) {
3667 int64_t cur_time
= av_gettime_relative();
3669 /* if 'q' pressed, exits */
3670 if (stdin_interaction
)
3671 if (check_keyboard_interaction(cur_time
) < 0)
3674 /* check if there's any stream where output is still needed */
3675 if (!need_output()) {
3676 av_log(NULL
, AV_LOG_VERBOSE
, "No more output streams to write to, finishing.\n");
3680 ret
= transcode_step();
3682 if (ret
== AVERROR_EOF
|| ret
== AVERROR(EAGAIN
))
3685 av_log(NULL
, AV_LOG_ERROR
, "Error while filtering.\n");
3689 /* dump report by using the output first video and audio streams */
3690 print_report(0, timer_start
, cur_time
);
3693 free_input_threads();
3696 /* at the end of stream, we must flush the decoder buffers */
3697 for (i
= 0; i
< nb_input_streams
; i
++) {
3698 ist
= input_streams
[i
];
3699 if (!input_files
[ist
->file_index
]->eof_reached
&& ist
->decoding_needed
) {
3700 process_input_packet(ist
, NULL
);
3707 /* write the trailer if needed and close file */
3708 for (i
= 0; i
< nb_output_files
; i
++) {
3709 os
= output_files
[i
]->ctx
;
3710 av_write_trailer(os
);
3713 /* dump report by using the first video and audio streams */
3714 print_report(1, timer_start
, av_gettime_relative());
3716 /* close each encoder */
3717 for (i
= 0; i
< nb_output_streams
; i
++) {
3718 ost
= output_streams
[i
];
3719 if (ost
->encoding_needed
) {
3720 av_freep(&ost
->enc_ctx
->stats_in
);
3724 /* close each decoder */
3725 for (i
= 0; i
< nb_input_streams
; i
++) {
3726 ist
= input_streams
[i
];
3727 if (ist
->decoding_needed
) {
3728 avcodec_close(ist
->dec_ctx
);
3729 if (ist
->hwaccel_uninit
)
3730 ist
->hwaccel_uninit(ist
->dec_ctx
);
3739 free_input_threads();
3742 if (output_streams
) {
3743 for (i
= 0; i
< nb_output_streams
; i
++) {
3744 ost
= output_streams
[i
];
3747 fclose(ost
->logfile
);
3748 ost
->logfile
= NULL
;
3750 av_freep(&ost
->forced_kf_pts
);
3751 av_freep(&ost
->apad
);
3752 av_dict_free(&ost
->encoder_opts
);
3753 av_dict_free(&ost
->swr_opts
);
3754 av_dict_free(&ost
->resample_opts
);
3762 static int64_t getutime(void)
3765 struct rusage rusage
;
3767 getrusage(RUSAGE_SELF
, &rusage
);
3768 return (rusage
.ru_utime
.tv_sec
* 1000000LL) + rusage
.ru_utime
.tv_usec
;
3769 #elif HAVE_GETPROCESSTIMES
3771 FILETIME c
, e
, k
, u
;
3772 proc
= GetCurrentProcess();
3773 GetProcessTimes(proc
, &c
, &e
, &k
, &u
);
3774 return ((int64_t) u
.dwHighDateTime
<< 32 | u
.dwLowDateTime
) / 10;
3776 return av_gettime();
3780 static int64_t getmaxrss(void)
3782 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3783 struct rusage rusage
;
3784 getrusage(RUSAGE_SELF
, &rusage
);
3785 return (int64_t)rusage
.ru_maxrss
* 1024;
3786 #elif HAVE_GETPROCESSMEMORYINFO
3788 PROCESS_MEMORY_COUNTERS memcounters
;
3789 proc
= GetCurrentProcess();
3790 memcounters
.cb
= sizeof(memcounters
);
3791 GetProcessMemoryInfo(proc
, &memcounters
, sizeof(memcounters
));
3792 return memcounters
.PeakPagefileUsage
;
3798 static void log_callback_null(void *ptr
, int level
, const char *fmt
, va_list vl
)
3802 int main(int argc
, char **argv
)
3807 register_exit(ffmpeg_cleanup
);
3809 setvbuf(stderr
,NULL
,_IONBF
,0); /* win32 runtime needs this */
3811 av_log_set_flags(AV_LOG_SKIP_REPEATED
);
3812 parse_loglevel(argc
, argv
, options
);
3814 if(argc
>1 && !strcmp(argv
[1], "-d")){
3816 av_log_set_callback(log_callback_null
);
3821 avcodec_register_all();
3823 avdevice_register_all();
3825 avfilter_register_all();
3827 avformat_network_init();
3829 show_banner(argc
, argv
, options
);
3833 /* parse options and open all input/output files */
3834 ret
= ffmpeg_parse_options(argc
, argv
);
3838 if (nb_output_files
<= 0 && nb_input_files
== 0) {
3840 av_log(NULL
, AV_LOG_WARNING
, "Use -h to get full help or, even better, run 'man %s'\n", program_name
);
3844 /* file converter / grab */
3845 if (nb_output_files
<= 0) {
3846 av_log(NULL
, AV_LOG_FATAL
, "At least one output file must be specified\n");
3850 // if (nb_input_files == 0) {
3851 // av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
3855 current_time
= ti
= getutime();
3856 if (transcode() < 0)
3858 ti
= getutime() - ti
;
3860 printf("bench: utime=%0.3fs\n", ti
/ 1000000.0);
3862 av_log(NULL
, AV_LOG_DEBUG
, "%"PRIu64
" frames successfully decoded, %"PRIu64
" decoding errors\n",
3863 decode_error_stat
[0], decode_error_stat
[1]);
3864 if ((decode_error_stat
[0] + decode_error_stat
[1]) * max_error_rate
< decode_error_stat
[1])
3867 exit_program(received_nb_signals
? 255 : main_return_code
);
3868 return main_return_code
;