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
42 #include "libavformat/avformat.h"
43 #include "libavdevice/avdevice.h"
44 #include "libswresample/swresample.h"
45 #include "libavutil/opt.h"
46 #include "libavutil/channel_layout.h"
47 #include "libavutil/parseutils.h"
48 #include "libavutil/samplefmt.h"
49 #include "libavutil/fifo.h"
50 #include "libavutil/internal.h"
51 #include "libavutil/intreadwrite.h"
52 #include "libavutil/dict.h"
53 #include "libavutil/mathematics.h"
54 #include "libavutil/pixdesc.h"
55 #include "libavutil/avstring.h"
56 #include "libavutil/libm.h"
57 #include "libavutil/imgutils.h"
58 #include "libavutil/timestamp.h"
59 #include "libavutil/bprint.h"
60 #include "libavutil/time.h"
61 #include "libavutil/threadmessage.h"
62 #include "libavcodec/mathops.h"
63 #include "libavformat/os_support.h"
65 # include "libavfilter/avfilter.h"
66 # include "libavfilter/buffersrc.h"
67 # include "libavfilter/buffersink.h"
69 #if HAVE_SYS_RESOURCE_H
71 #include <sys/types.h>
72 #include <sys/resource.h>
73 #elif HAVE_GETPROCESSTIMES
76 #if HAVE_GETPROCESSMEMORYINFO
80 #if HAVE_SETCONSOLECTRLHANDLER
86 #include <sys/select.h>
91 #include <sys/ioctl.h>
105 #include "cmdutils.h"
107 #include "libavutil/avassert.h"
109 const char program_name[] = "ffmpeg";
110 const int program_birth_year = 2000;
112 static FILE *vstats_file;
114 const char *const forced_keyframes_const_names[] = {
123 static void do_video_stats(OutputStream *ost, int frame_size);
124 static int64_t getutime(void);
125 static int64_t getmaxrss(void);
127 static int run_as_daemon = 0;
128 static int nb_frames_dup = 0;
129 static int nb_frames_drop = 0;
130 static int64_t decode_error_stat[2];
132 static int current_time;
133 AVIOContext *progress_avio = NULL;
135 static uint8_t *subtitle_out;
137 InputStream **input_streams = NULL;
138 int nb_input_streams = 0;
139 InputFile **input_files = NULL;
140 int nb_input_files = 0;
142 OutputStream **output_streams = NULL;
143 int nb_output_streams = 0;
144 OutputFile **output_files = NULL;
145 int nb_output_files = 0;
147 FilterGraph **filtergraphs;
152 /* init terminal so that we can grab keys */
153 static struct termios oldtty;
154 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->dec_ctx->width ? ist->dec_ctx->width : ist->sub2video.w;
173 ist->sub2video.frame->height = ist->dec_ctx->height ? ist->dec_ctx->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 (%d %d %d %d) overflowing %d %d\n",
194 r->x, r->y, r->w, r->h, w, h
199 dst += r->y * dst_linesize + r->x * 4;
200 src = r->pict.data[0];
201 pal = (uint32_t *)r->pict.data[1];
202 for (y = 0; y < r->h; y++) {
203 dst2 = (uint32_t *)dst;
205 for (x = 0; x < r->w; x++)
206 *(dst2++) = pal[*(src2++)];
208 src += r->pict.linesize[0];
212 static void sub2video_push_ref(InputStream *ist, int64_t pts)
214 AVFrame *frame = ist->sub2video.frame;
217 av_assert1(frame->data[0]);
218 ist->sub2video.last_pts = frame->pts = pts;
219 for (i = 0; i < ist->nb_filters; i++)
220 av_buffersrc_add_frame_flags(ist->filters[i]->filter, frame,
221 AV_BUFFERSRC_FLAG_KEEP_REF |
222 AV_BUFFERSRC_FLAG_PUSH);
225 static void sub2video_update(InputStream *ist, AVSubtitle *sub)
227 AVFrame *frame = ist->sub2video.frame;
231 int64_t pts, end_pts;
236 pts = av_rescale_q(sub->pts + sub->start_display_time * 1000LL,
237 AV_TIME_BASE_Q, ist->st->time_base);
238 end_pts = av_rescale_q(sub->pts + sub->end_display_time * 1000LL,
239 AV_TIME_BASE_Q, ist->st->time_base);
240 num_rects = sub->num_rects;
242 pts = ist->sub2video.end_pts;
246 if (sub2video_get_blank_frame(ist) < 0) {
247 av_log(ist->dec_ctx, AV_LOG_ERROR,
248 "Impossible to get a blank canvas.\n");
251 dst = frame->data [0];
252 dst_linesize = frame->linesize[0];
253 for (i = 0; i < num_rects; i++)
254 sub2video_copy_rect(dst, dst_linesize, frame->width, frame->height, sub->rects[i]);
255 sub2video_push_ref(ist, pts);
256 ist->sub2video.end_pts = end_pts;
259 static void sub2video_heartbeat(InputStream *ist, int64_t pts)
261 InputFile *infile = input_files[ist->file_index];
265 /* When a frame is read from a file, examine all sub2video streams in
266 the same file and send the sub2video frame again. Otherwise, decoded
267 video frames could be accumulating in the filter graph while a filter
268 (possibly overlay) is desperately waiting for a subtitle frame. */
269 for (i = 0; i < infile->nb_streams; i++) {
270 InputStream *ist2 = input_streams[infile->ist_index + i];
271 if (!ist2->sub2video.frame)
273 /* subtitles seem to be usually muxed ahead of other streams;
274 if not, subtracting a larger time here is necessary */
275 pts2 = av_rescale_q(pts, ist->st->time_base, ist2->st->time_base) - 1;
276 /* do not send the heartbeat frame if the subtitle is already ahead */
277 if (pts2 <= ist2->sub2video.last_pts)
279 if (pts2 >= ist2->sub2video.end_pts || !ist2->sub2video.frame->data[0])
280 sub2video_update(ist2, NULL);
281 for (j = 0, nb_reqs = 0; j < ist2->nb_filters; j++)
282 nb_reqs += av_buffersrc_get_nb_failed_requests(ist2->filters[j]->filter);
284 sub2video_push_ref(ist2, pts2);
288 static void sub2video_flush(InputStream *ist)
292 if (ist->sub2video.end_pts < INT64_MAX)
293 sub2video_update(ist, NULL);
294 for (i = 0; i < ist->nb_filters; i++)
295 av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
298 /* end of sub2video hack */
300 static void term_exit_sigsafe(void)
304 tcsetattr (0, TCSANOW, &oldtty);
310 av_log(NULL, AV_LOG_QUIET, "%s", "");
314 static volatile int received_sigterm = 0;
315 static volatile int received_nb_signals = 0;
316 static volatile int transcode_init_done = 0;
317 static volatile int ffmpeg_exited = 0;
318 static int main_return_code = 0;
321 sigterm_handler(int sig)
323 received_sigterm = sig;
324 received_nb_signals++;
326 if(received_nb_signals > 3) {
327 write(2/*STDERR_FILENO*/, "Received > 3 system signals, hard exiting\n",
328 strlen("Received > 3 system signals, hard exiting\n"));
334 #if HAVE_SETCONSOLECTRLHANDLER
335 static BOOL WINAPI CtrlHandler(DWORD fdwCtrlType)
337 av_log(NULL, AV_LOG_DEBUG, "\nReceived windows signal %ld\n", fdwCtrlType);
342 case CTRL_BREAK_EVENT:
343 sigterm_handler(SIGINT);
346 case CTRL_CLOSE_EVENT:
347 case CTRL_LOGOFF_EVENT:
348 case CTRL_SHUTDOWN_EVENT:
349 sigterm_handler(SIGTERM);
350 /* Basically, with these 3 events, when we return from this method the
351 process is hard terminated, so stall as long as we need to
352 to try and let the main thread(s) clean up and gracefully terminate
353 (we have at most 5 seconds, but should be done far before that). */
354 while (!ffmpeg_exited) {
360 av_log(NULL, AV_LOG_ERROR, "Received unknown windows signal %ld\n", fdwCtrlType);
371 if (tcgetattr (0, &tty) == 0) {
375 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
376 |INLCR|IGNCR|ICRNL|IXON);
377 tty.c_oflag |= OPOST;
378 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
379 tty.c_cflag &= ~(CSIZE|PARENB);
384 tcsetattr (0, TCSANOW, &tty);
386 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
390 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
391 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
393 signal(SIGXCPU, sigterm_handler);
395 #if HAVE_SETCONSOLECTRLHANDLER
396 SetConsoleCtrlHandler((PHANDLER_ROUTINE) CtrlHandler, TRUE);
400 /* read a key without blocking */
401 static int read_key(void)
413 n = select(1, &rfds, NULL, NULL, &tv);
422 # if HAVE_PEEKNAMEDPIPE
424 static HANDLE input_handle;
427 input_handle = GetStdHandle(STD_INPUT_HANDLE);
428 is_pipe = !GetConsoleMode(input_handle, &dw);
432 /* When running under a GUI, you will end here. */
433 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL)) {
434 // input pipe may have been closed by the program that ran ffmpeg
452 static int decode_interrupt_cb(void *ctx)
454 return received_nb_signals > transcode_init_done;
457 const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
459 static void ffmpeg_cleanup(int ret)
464 int maxrss = getmaxrss() / 1024;
465 av_log(NULL, AV_LOG_INFO, "bench: maxrss=%ikB\n", maxrss);
468 for (i = 0; i < nb_filtergraphs; i++) {
469 FilterGraph *fg = filtergraphs[i];
470 avfilter_graph_free(&fg->graph);
471 for (j = 0; j < fg->nb_inputs; j++) {
472 av_freep(&fg->inputs[j]->name);
473 av_freep(&fg->inputs[j]);
475 av_freep(&fg->inputs);
476 for (j = 0; j < fg->nb_outputs; j++) {
477 av_freep(&fg->outputs[j]->name);
478 av_freep(&fg->outputs[j]);
480 av_freep(&fg->outputs);
481 av_freep(&fg->graph_desc);
483 av_freep(&filtergraphs[i]);
485 av_freep(&filtergraphs);
487 av_freep(&subtitle_out);
490 for (i = 0; i < nb_output_files; i++) {
491 OutputFile *of = output_files[i];
496 if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE))
498 avformat_free_context(s);
499 av_dict_free(&of->opts);
501 av_freep(&output_files[i]);
503 for (i = 0; i < nb_output_streams; i++) {
504 OutputStream *ost = output_streams[i];
505 AVBitStreamFilterContext *bsfc;
510 bsfc = ost->bitstream_filters;
512 AVBitStreamFilterContext *next = bsfc->next;
513 av_bitstream_filter_close(bsfc);
516 ost->bitstream_filters = NULL;
517 av_frame_free(&ost->filtered_frame);
518 av_frame_free(&ost->last_frame);
520 av_parser_close(ost->parser);
522 av_freep(&ost->forced_keyframes);
523 av_expr_free(ost->forced_keyframes_pexpr);
524 av_freep(&ost->avfilter);
525 av_freep(&ost->logfile_prefix);
527 av_freep(&ost->audio_channels_map);
528 ost->audio_channels_mapped = 0;
530 avcodec_free_context(&ost->enc_ctx);
532 av_freep(&output_streams[i]);
535 free_input_threads();
537 for (i = 0; i < nb_input_files; i++) {
538 avformat_close_input(&input_files[i]->ctx);
539 av_freep(&input_files[i]);
541 for (i = 0; i < nb_input_streams; i++) {
542 InputStream *ist = input_streams[i];
544 av_frame_free(&ist->decoded_frame);
545 av_frame_free(&ist->filter_frame);
546 av_dict_free(&ist->decoder_opts);
547 avsubtitle_free(&ist->prev_sub.subtitle);
548 av_frame_free(&ist->sub2video.frame);
549 av_freep(&ist->filters);
550 av_freep(&ist->hwaccel_device);
552 avcodec_free_context(&ist->dec_ctx);
554 av_freep(&input_streams[i]);
559 av_freep(&vstats_filename);
561 av_freep(&input_streams);
562 av_freep(&input_files);
563 av_freep(&output_streams);
564 av_freep(&output_files);
568 avformat_network_deinit();
570 if (received_sigterm) {
571 av_log(NULL, AV_LOG_INFO, "Exiting normally, received signal %d.\n",
572 (int) received_sigterm);
573 } else if (ret && transcode_init_done) {
574 av_log(NULL, AV_LOG_INFO, "Conversion failed!\n");
580 void remove_avoptions(AVDictionary **a, AVDictionary *b)
582 AVDictionaryEntry *t = NULL;
584 while ((t = av_dict_get(b, "", t, AV_DICT_IGNORE_SUFFIX))) {
585 av_dict_set(a, t->key, NULL, AV_DICT_MATCH_CASE);
589 void assert_avoptions(AVDictionary *m)
591 AVDictionaryEntry *t;
592 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
593 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
598 static void abort_codec_experimental(AVCodec *c, int encoder)
603 static void update_benchmark(const char *fmt, ...)
605 if (do_benchmark_all) {
606 int64_t t = getutime();
612 vsnprintf(buf, sizeof(buf), fmt, va);
614 av_log(NULL, AV_LOG_INFO, "bench: %8"PRIu64" %s \n", t - current_time, buf);
620 static void close_all_output_streams(OutputStream *ost, OSTFinished this_stream, OSTFinished others)
623 for (i = 0; i < nb_output_streams; i++) {
624 OutputStream *ost2 = output_streams[i];
625 ost2->finished |= ost == ost2 ? this_stream : others;
629 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
631 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
632 AVCodecContext *avctx = ost->encoding_needed ? ost->enc_ctx : ost->st->codec;
635 if (!ost->st->codec->extradata_size && ost->enc_ctx->extradata_size) {
636 ost->st->codec->extradata = av_mallocz(ost->enc_ctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
637 if (ost->st->codec->extradata) {
638 memcpy(ost->st->codec->extradata, ost->enc_ctx->extradata, ost->enc_ctx->extradata_size);
639 ost->st->codec->extradata_size = ost->enc_ctx->extradata_size;
643 if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
644 (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
645 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
648 * Audio encoders may split the packets -- #frames in != #packets out.
649 * But there is no reordering, so we can limit the number of output packets
650 * by simply dropping them here.
651 * Counting encoded video frames needs to be done separately because of
652 * reordering, see do_video_out()
654 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
655 if (ost->frame_number >= ost->max_frames) {
656 av_packet_unref(pkt);
661 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
663 uint8_t *sd = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS,
665 ost->quality = sd ? AV_RL32(sd) : -1;
666 ost->pict_type = sd ? sd[4] : AV_PICTURE_TYPE_NONE;
668 for (i = 0; i<FF_ARRAY_ELEMS(ost->error); i++) {
670 ost->error[i] = AV_RL64(sd + 8 + 8*i);
677 av_packet_split_side_data(pkt);
680 AVPacket new_pkt = *pkt;
681 AVDictionaryEntry *bsf_arg = av_dict_get(ost->bsf_args,
684 int a = av_bitstream_filter_filter(bsfc, avctx,
685 bsf_arg ? bsf_arg->value : NULL,
686 &new_pkt.data, &new_pkt.size,
687 pkt->data, pkt->size,
688 pkt->flags & AV_PKT_FLAG_KEY);
689 if(a == 0 && new_pkt.data != pkt->data) {
690 uint8_t *t = av_malloc(new_pkt.size + AV_INPUT_BUFFER_PADDING_SIZE); //the new should be a subset of the old so cannot overflow
692 memcpy(t, new_pkt.data, new_pkt.size);
693 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
701 pkt->side_data = NULL;
702 pkt->side_data_elems = 0;
703 av_packet_unref(pkt);
704 new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
705 av_buffer_default_free, NULL, 0);
710 av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
711 bsfc->filter->name, pkt->stream_index,
712 avctx->codec ? avctx->codec->name : "copy");
722 if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
723 if (pkt->dts != AV_NOPTS_VALUE &&
724 pkt->pts != AV_NOPTS_VALUE &&
725 pkt->dts > pkt->pts) {
726 av_log(s, AV_LOG_WARNING, "Invalid DTS: %"PRId64" PTS: %"PRId64" in output stream %d:%d, replacing by guess\n",
728 ost->file_index, ost->st->index);
730 pkt->dts = pkt->pts + pkt->dts + ost->last_mux_dts + 1
731 - FFMIN3(pkt->pts, pkt->dts, ost->last_mux_dts + 1)
732 - FFMAX3(pkt->pts, pkt->dts, ost->last_mux_dts + 1);
735 (avctx->codec_type == AVMEDIA_TYPE_AUDIO || avctx->codec_type == AVMEDIA_TYPE_VIDEO) &&
736 pkt->dts != AV_NOPTS_VALUE &&
737 ost->last_mux_dts != AV_NOPTS_VALUE) {
738 int64_t max = ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
739 if (pkt->dts < max) {
740 int loglevel = max - pkt->dts > 2 || avctx->codec_type == AVMEDIA_TYPE_VIDEO ? AV_LOG_WARNING : AV_LOG_DEBUG;
741 av_log(s, loglevel, "Non-monotonous DTS in output stream "
742 "%d:%d; previous: %"PRId64", current: %"PRId64"; ",
743 ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);
745 av_log(NULL, AV_LOG_FATAL, "aborting.\n");
748 av_log(s, loglevel, "changing to %"PRId64". This may result "
749 "in incorrect timestamps in the output file.\n",
751 if(pkt->pts >= pkt->dts)
752 pkt->pts = FFMAX(pkt->pts, max);
757 ost->last_mux_dts = pkt->dts;
759 ost->data_size += pkt->size;
760 ost->packets_written++;
762 pkt->stream_index = ost->index;
765 av_log(NULL, AV_LOG_INFO, "muxer <- type:%s "
766 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s size:%d\n",
767 av_get_media_type_string(ost->enc_ctx->codec_type),
768 av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &ost->st->time_base),
769 av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &ost->st->time_base),
774 ret = av_interleaved_write_frame(s, pkt);
776 print_error("av_interleaved_write_frame()", ret);
777 main_return_code = 1;
778 close_all_output_streams(ost, MUXER_FINISHED | ENCODER_FINISHED, ENCODER_FINISHED);
780 av_packet_unref(pkt);
783 static void close_output_stream(OutputStream *ost)
785 OutputFile *of = output_files[ost->file_index];
787 ost->finished |= ENCODER_FINISHED;
789 int64_t end = av_rescale_q(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, AV_TIME_BASE_Q);
790 of->recording_time = FFMIN(of->recording_time, end);
794 static int check_recording_time(OutputStream *ost)
796 OutputFile *of = output_files[ost->file_index];
798 if (of->recording_time != INT64_MAX &&
799 av_compare_ts(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, of->recording_time,
800 AV_TIME_BASE_Q) >= 0) {
801 close_output_stream(ost);
807 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
810 AVCodecContext *enc = ost->enc_ctx;
814 av_init_packet(&pkt);
818 if (!check_recording_time(ost))
821 if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
822 frame->pts = ost->sync_opts;
823 ost->sync_opts = frame->pts + frame->nb_samples;
824 ost->samples_encoded += frame->nb_samples;
825 ost->frames_encoded++;
827 av_assert0(pkt.size || !pkt.data);
828 update_benchmark(NULL);
830 av_log(NULL, AV_LOG_INFO, "encoder <- type:audio "
831 "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
832 av_ts2str(frame->pts), av_ts2timestr(frame->pts, &enc->time_base),
833 enc->time_base.num, enc->time_base.den);
836 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
837 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
840 update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
843 av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);
846 av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
847 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
848 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
849 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
852 write_frame(s, &pkt, ost);
856 static void do_subtitle_out(AVFormatContext *s,
861 int subtitle_out_max_size = 1024 * 1024;
862 int subtitle_out_size, nb, i;
867 if (sub->pts == AV_NOPTS_VALUE) {
868 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
877 subtitle_out = av_malloc(subtitle_out_max_size);
879 av_log(NULL, AV_LOG_FATAL, "Failed to allocate subtitle_out\n");
884 /* Note: DVB subtitle need one packet to draw them and one other
885 packet to clear them */
886 /* XXX: signal it in the codec context ? */
887 if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
892 /* shift timestamp to honor -ss and make check_recording_time() work with -t */
894 if (output_files[ost->file_index]->start_time != AV_NOPTS_VALUE)
895 pts -= output_files[ost->file_index]->start_time;
896 for (i = 0; i < nb; i++) {
897 unsigned save_num_rects = sub->num_rects;
899 ost->sync_opts = av_rescale_q(pts, AV_TIME_BASE_Q, enc->time_base);
900 if (!check_recording_time(ost))
904 // start_display_time is required to be 0
905 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
906 sub->end_display_time -= sub->start_display_time;
907 sub->start_display_time = 0;
911 ost->frames_encoded++;
913 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
914 subtitle_out_max_size, sub);
916 sub->num_rects = save_num_rects;
917 if (subtitle_out_size < 0) {
918 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
922 av_init_packet(&pkt);
923 pkt.data = subtitle_out;
924 pkt.size = subtitle_out_size;
925 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
926 pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->st->time_base);
927 if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
928 /* XXX: the pts correction is handled here. Maybe handling
929 it in the codec would be better */
931 pkt.pts += 90 * sub->start_display_time;
933 pkt.pts += 90 * sub->end_display_time;
936 write_frame(s, &pkt, ost);
940 static void do_video_out(AVFormatContext *s,
942 AVFrame *next_picture,
945 int ret, format_video_sync;
947 AVCodecContext *enc = ost->enc_ctx;
948 AVCodecContext *mux_enc = ost->st->codec;
949 int nb_frames, nb0_frames, i;
950 double delta, delta0;
953 InputStream *ist = NULL;
954 AVFilterContext *filter = ost->filter->filter;
956 if (ost->source_index >= 0)
957 ist = input_streams[ost->source_index];
959 if (filter->inputs[0]->frame_rate.num > 0 &&
960 filter->inputs[0]->frame_rate.den > 0)
961 duration = 1/(av_q2d(filter->inputs[0]->frame_rate) * av_q2d(enc->time_base));
963 if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
964 duration = FFMIN(duration, 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base)));
966 if (!ost->filters_script &&
970 lrintf(av_frame_get_pkt_duration(next_picture) * av_q2d(ist->st->time_base) / av_q2d(enc->time_base)) > 0) {
971 duration = lrintf(av_frame_get_pkt_duration(next_picture) * av_q2d(ist->st->time_base) / av_q2d(enc->time_base));
976 nb0_frames = nb_frames = mid_pred(ost->last_nb0_frames[0],
977 ost->last_nb0_frames[1],
978 ost->last_nb0_frames[2]);
980 delta0 = sync_ipts - ost->sync_opts;
981 delta = delta0 + duration;
983 /* by default, we output a single frame */
987 format_video_sync = video_sync_method;
988 if (format_video_sync == VSYNC_AUTO) {
989 if(!strcmp(s->oformat->name, "avi")) {
990 format_video_sync = VSYNC_VFR;
992 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : VSYNC_CFR;
994 && format_video_sync == VSYNC_CFR
995 && input_files[ist->file_index]->ctx->nb_streams == 1
996 && input_files[ist->file_index]->input_ts_offset == 0) {
997 format_video_sync = VSYNC_VSCFR;
999 if (format_video_sync == VSYNC_CFR && copy_ts) {
1000 format_video_sync = VSYNC_VSCFR;
1006 format_video_sync != VSYNC_PASSTHROUGH &&
1007 format_video_sync != VSYNC_DROP) {
1008 double cor = FFMIN(-delta0, duration);
1009 if (delta0 < -0.6) {
1010 av_log(NULL, AV_LOG_WARNING, "Past duration %f too large\n", -delta0);
1012 av_log(NULL, AV_LOG_DEBUG, "Cliping frame in rate conversion by %f\n", -delta0);
1018 switch (format_video_sync) {
1020 if (ost->frame_number == 0 && delta - duration >= 0.5) {
1021 av_log(NULL, AV_LOG_DEBUG, "Not duplicating %d initial frames\n", (int)lrintf(delta - duration));
1024 ost->sync_opts = lrint(sync_ipts);
1027 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1028 if (frame_drop_threshold && delta < frame_drop_threshold && ost->frame_number) {
1030 } else if (delta < -1.1)
1032 else if (delta > 1.1) {
1033 nb_frames = lrintf(delta);
1035 nb0_frames = lrintf(delta0 - 0.6);
1041 else if (delta > 0.6)
1042 ost->sync_opts = lrint(sync_ipts);
1045 case VSYNC_PASSTHROUGH:
1046 ost->sync_opts = lrint(sync_ipts);
1053 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1054 nb0_frames = FFMIN(nb0_frames, nb_frames);
1056 memmove(ost->last_nb0_frames + 1,
1057 ost->last_nb0_frames,
1058 sizeof(ost->last_nb0_frames[0]) * (FF_ARRAY_ELEMS(ost->last_nb0_frames) - 1));
1059 ost->last_nb0_frames[0] = nb0_frames;
1061 if (nb0_frames == 0 && ost->last_droped) {
1063 av_log(NULL, AV_LOG_VERBOSE,
1064 "*** dropping frame %d from stream %d at ts %"PRId64"\n",
1065 ost->frame_number, ost->st->index, ost->last_frame->pts);
1067 if (nb_frames > (nb0_frames && ost->last_droped) + (nb_frames > nb0_frames)) {
1068 if (nb_frames > dts_error_threshold * 30) {
1069 av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skipping\n", nb_frames - 1);
1073 nb_frames_dup += nb_frames - (nb0_frames && ost->last_droped) - (nb_frames > nb0_frames);
1074 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1076 ost->last_droped = nb_frames == nb0_frames && next_picture;
1078 /* duplicates frame if needed */
1079 for (i = 0; i < nb_frames; i++) {
1080 AVFrame *in_picture;
1081 av_init_packet(&pkt);
1085 if (i < nb0_frames && ost->last_frame) {
1086 in_picture = ost->last_frame;
1088 in_picture = next_picture;
1093 in_picture->pts = ost->sync_opts;
1096 if (!check_recording_time(ost))
1098 if (ost->frame_number >= ost->max_frames)
1102 #if FF_API_LAVF_FMT_RAWPICTURE
1103 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1104 enc->codec->id == AV_CODEC_ID_RAWVIDEO) {
1105 /* raw pictures are written as AVPicture structure to
1106 avoid any copies. We support temporarily the older
1108 if (in_picture->interlaced_frame)
1109 mux_enc->field_order = in_picture->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
1111 mux_enc->field_order = AV_FIELD_PROGRESSIVE;
1112 pkt.data = (uint8_t *)in_picture;
1113 pkt.size = sizeof(AVPicture);
1114 pkt.pts = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
1115 pkt.flags |= AV_PKT_FLAG_KEY;
1117 write_frame(s, &pkt, ost);
1121 int got_packet, forced_keyframe = 0;
1124 if (enc->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME) &&
1125 ost->top_field_first >= 0)
1126 in_picture->top_field_first = !!ost->top_field_first;
1128 if (in_picture->interlaced_frame) {
1129 if (enc->codec->id == AV_CODEC_ID_MJPEG)
1130 mux_enc->field_order = in_picture->top_field_first ? AV_FIELD_TT:AV_FIELD_BB;
1132 mux_enc->field_order = in_picture->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
1134 mux_enc->field_order = AV_FIELD_PROGRESSIVE;
1136 in_picture->quality = enc->global_quality;
1137 in_picture->pict_type = 0;
1139 pts_time = in_picture->pts != AV_NOPTS_VALUE ?
1140 in_picture->pts * av_q2d(enc->time_base) : NAN;
1141 if (ost->forced_kf_index < ost->forced_kf_count &&
1142 in_picture->pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1143 ost->forced_kf_index++;
1144 forced_keyframe = 1;
1145 } else if (ost->forced_keyframes_pexpr) {
1147 ost->forced_keyframes_expr_const_values[FKF_T] = pts_time;
1148 res = av_expr_eval(ost->forced_keyframes_pexpr,
1149 ost->forced_keyframes_expr_const_values, NULL);
1150 ff_dlog(NULL, "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",
1151 ost->forced_keyframes_expr_const_values[FKF_N],
1152 ost->forced_keyframes_expr_const_values[FKF_N_FORCED],
1153 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N],
1154 ost->forced_keyframes_expr_const_values[FKF_T],
1155 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T],
1158 forced_keyframe = 1;
1159 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] =
1160 ost->forced_keyframes_expr_const_values[FKF_N];
1161 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] =
1162 ost->forced_keyframes_expr_const_values[FKF_T];
1163 ost->forced_keyframes_expr_const_values[FKF_N_FORCED] += 1;
1166 ost->forced_keyframes_expr_const_values[FKF_N] += 1;
1167 } else if ( ost->forced_keyframes
1168 && !strncmp(ost->forced_keyframes, "source", 6)
1169 && in_picture->key_frame==1) {
1170 forced_keyframe = 1;
1173 if (forced_keyframe) {
1174 in_picture->pict_type = AV_PICTURE_TYPE_I;
1175 av_log(NULL, AV_LOG_DEBUG, "Forced keyframe at time %f\n", pts_time);
1178 update_benchmark(NULL);
1180 av_log(NULL, AV_LOG_INFO, "encoder <- type:video "
1181 "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
1182 av_ts2str(in_picture->pts), av_ts2timestr(in_picture->pts, &enc->time_base),
1183 enc->time_base.num, enc->time_base.den);
1186 ost->frames_encoded++;
1188 ret = avcodec_encode_video2(enc, &pkt, in_picture, &got_packet);
1189 update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
1191 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1197 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1198 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1199 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &enc->time_base),
1200 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &enc->time_base));
1203 if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & AV_CODEC_CAP_DELAY))
1204 pkt.pts = ost->sync_opts;
1206 av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);
1209 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1210 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1211 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1212 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1215 frame_size = pkt.size;
1216 write_frame(s, &pkt, ost);
1218 /* if two pass, output log */
1219 if (ost->logfile && enc->stats_out) {
1220 fprintf(ost->logfile, "%s", enc->stats_out);
1226 * For video, number of frames in == number of packets out.
1227 * But there may be reordering, so we can't throw away frames on encoder
1228 * flush, we need to limit them here, before they go into encoder.
1230 ost->frame_number++;
1232 if (vstats_filename && frame_size)
1233 do_video_stats(ost, frame_size);
1236 if (!ost->last_frame)
1237 ost->last_frame = av_frame_alloc();
1238 av_frame_unref(ost->last_frame);
1239 if (next_picture && ost->last_frame)
1240 av_frame_ref(ost->last_frame, next_picture);
1242 av_frame_free(&ost->last_frame);
1245 static double psnr(double d)
1247 return -10.0 * log(d) / log(10.0);
1250 static void do_video_stats(OutputStream *ost, int frame_size)
1252 AVCodecContext *enc;
1254 double ti1, bitrate, avg_bitrate;
1256 /* this is executed just the first time do_video_stats is called */
1258 vstats_file = fopen(vstats_filename, "w");
1266 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1267 frame_number = ost->st->nb_frames;
1268 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number,
1269 ost->quality / (float)FF_QP2LAMBDA);
1271 if (ost->error[0]>=0 && (enc->flags & AV_CODEC_FLAG_PSNR))
1272 fprintf(vstats_file, "PSNR= %6.2f ", psnr(ost->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1274 fprintf(vstats_file,"f_size= %6d ", frame_size);
1275 /* compute pts value */
1276 ti1 = av_stream_get_end_pts(ost->st) * av_q2d(ost->st->time_base);
1280 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1281 avg_bitrate = (double)(ost->data_size * 8) / ti1 / 1000.0;
1282 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1283 (double)ost->data_size / 1024, ti1, bitrate, avg_bitrate);
1284 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(ost->pict_type));
1288 static void finish_output_stream(OutputStream *ost)
1290 OutputFile *of = output_files[ost->file_index];
1293 ost->finished = ENCODER_FINISHED | MUXER_FINISHED;
1296 for (i = 0; i < of->ctx->nb_streams; i++)
1297 output_streams[of->ost_index + i]->finished = ENCODER_FINISHED | MUXER_FINISHED;
1302 * Get and encode new output from any of the filtergraphs, without causing
1305 * @return 0 for success, <0 for severe errors
1307 static int reap_filters(int flush)
1309 AVFrame *filtered_frame = NULL;
1312 /* Reap all buffers present in the buffer sinks */
1313 for (i = 0; i < nb_output_streams; i++) {
1314 OutputStream *ost = output_streams[i];
1315 OutputFile *of = output_files[ost->file_index];
1316 AVFilterContext *filter;
1317 AVCodecContext *enc = ost->enc_ctx;
1322 filter = ost->filter->filter;
1324 if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
1325 return AVERROR(ENOMEM);
1327 filtered_frame = ost->filtered_frame;
1330 double float_pts = AV_NOPTS_VALUE; // this is identical to filtered_frame.pts but with higher precision
1331 ret = av_buffersink_get_frame_flags(filter, filtered_frame,
1332 AV_BUFFERSINK_FLAG_NO_REQUEST);
1334 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
1335 av_log(NULL, AV_LOG_WARNING,
1336 "Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));
1337 } else if (flush && ret == AVERROR_EOF) {
1338 if (filter->inputs[0]->type == AVMEDIA_TYPE_VIDEO)
1339 do_video_out(of->ctx, ost, NULL, AV_NOPTS_VALUE);
1343 if (ost->finished) {
1344 av_frame_unref(filtered_frame);
1347 if (filtered_frame->pts != AV_NOPTS_VALUE) {
1348 int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1349 AVRational tb = enc->time_base;
1350 int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16);
1352 tb.den <<= extra_bits;
1354 av_rescale_q(filtered_frame->pts, filter->inputs[0]->time_base, tb) -
1355 av_rescale_q(start_time, AV_TIME_BASE_Q, tb);
1356 float_pts /= 1 << extra_bits;
1357 // avoid exact midoints to reduce the chance of rounding differences, this can be removed in case the fps code is changed to work with integers
1358 float_pts += FFSIGN(float_pts) * 1.0 / (1<<17);
1360 filtered_frame->pts =
1361 av_rescale_q(filtered_frame->pts, filter->inputs[0]->time_base, enc->time_base) -
1362 av_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);
1364 //if (ost->source_index >= 0)
1365 // *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
1367 switch (filter->inputs[0]->type) {
1368 case AVMEDIA_TYPE_VIDEO:
1369 if (!ost->frame_aspect_ratio.num)
1370 enc->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
1373 av_log(NULL, AV_LOG_INFO, "filter -> pts:%s pts_time:%s exact:%f time_base:%d/%d\n",
1374 av_ts2str(filtered_frame->pts), av_ts2timestr(filtered_frame->pts, &enc->time_base),
1376 enc->time_base.num, enc->time_base.den);
1379 do_video_out(of->ctx, ost, filtered_frame, float_pts);
1381 case AVMEDIA_TYPE_AUDIO:
1382 if (!(enc->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
1383 enc->channels != av_frame_get_channels(filtered_frame)) {
1384 av_log(NULL, AV_LOG_ERROR,
1385 "Audio filter graph output is not normalized and encoder does not support parameter changes\n");
1388 do_audio_out(of->ctx, ost, filtered_frame);
1391 // TODO support subtitle filters
1395 av_frame_unref(filtered_frame);
1402 static void print_final_stats(int64_t total_size)
1404 uint64_t video_size = 0, audio_size = 0, extra_size = 0, other_size = 0;
1405 uint64_t subtitle_size = 0;
1406 uint64_t data_size = 0;
1407 float percent = -1.0;
1411 for (i = 0; i < nb_output_streams; i++) {
1412 OutputStream *ost = output_streams[i];
1413 switch (ost->enc_ctx->codec_type) {
1414 case AVMEDIA_TYPE_VIDEO: video_size += ost->data_size; break;
1415 case AVMEDIA_TYPE_AUDIO: audio_size += ost->data_size; break;
1416 case AVMEDIA_TYPE_SUBTITLE: subtitle_size += ost->data_size; break;
1417 default: other_size += ost->data_size; break;
1419 extra_size += ost->enc_ctx->extradata_size;
1420 data_size += ost->data_size;
1421 if ( (ost->enc_ctx->flags & (AV_CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))
1422 != AV_CODEC_FLAG_PASS1)
1426 if (data_size && total_size>0 && total_size >= data_size)
1427 percent = 100.0 * (total_size - data_size) / data_size;
1429 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: ",
1430 video_size / 1024.0,
1431 audio_size / 1024.0,
1432 subtitle_size / 1024.0,
1433 other_size / 1024.0,
1434 extra_size / 1024.0);
1436 av_log(NULL, AV_LOG_INFO, "%f%%", percent);
1438 av_log(NULL, AV_LOG_INFO, "unknown");
1439 av_log(NULL, AV_LOG_INFO, "\n");
1441 /* print verbose per-stream stats */
1442 for (i = 0; i < nb_input_files; i++) {
1443 InputFile *f = input_files[i];
1444 uint64_t total_packets = 0, total_size = 0;
1446 av_log(NULL, AV_LOG_VERBOSE, "Input file #%d (%s):\n",
1447 i, f->ctx->filename);
1449 for (j = 0; j < f->nb_streams; j++) {
1450 InputStream *ist = input_streams[f->ist_index + j];
1451 enum AVMediaType type = ist->dec_ctx->codec_type;
1453 total_size += ist->data_size;
1454 total_packets += ist->nb_packets;
1456 av_log(NULL, AV_LOG_VERBOSE, " Input stream #%d:%d (%s): ",
1457 i, j, media_type_string(type));
1458 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets read (%"PRIu64" bytes); ",
1459 ist->nb_packets, ist->data_size);
1461 if (ist->decoding_needed) {
1462 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames decoded",
1463 ist->frames_decoded);
1464 if (type == AVMEDIA_TYPE_AUDIO)
1465 av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ist->samples_decoded);
1466 av_log(NULL, AV_LOG_VERBOSE, "; ");
1469 av_log(NULL, AV_LOG_VERBOSE, "\n");
1472 av_log(NULL, AV_LOG_VERBOSE, " Total: %"PRIu64" packets (%"PRIu64" bytes) demuxed\n",
1473 total_packets, total_size);
1476 for (i = 0; i < nb_output_files; i++) {
1477 OutputFile *of = output_files[i];
1478 uint64_t total_packets = 0, total_size = 0;
1480 av_log(NULL, AV_LOG_VERBOSE, "Output file #%d (%s):\n",
1481 i, of->ctx->filename);
1483 for (j = 0; j < of->ctx->nb_streams; j++) {
1484 OutputStream *ost = output_streams[of->ost_index + j];
1485 enum AVMediaType type = ost->enc_ctx->codec_type;
1487 total_size += ost->data_size;
1488 total_packets += ost->packets_written;
1490 av_log(NULL, AV_LOG_VERBOSE, " Output stream #%d:%d (%s): ",
1491 i, j, media_type_string(type));
1492 if (ost->encoding_needed) {
1493 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames encoded",
1494 ost->frames_encoded);
1495 if (type == AVMEDIA_TYPE_AUDIO)
1496 av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ost->samples_encoded);
1497 av_log(NULL, AV_LOG_VERBOSE, "; ");
1500 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets muxed (%"PRIu64" bytes); ",
1501 ost->packets_written, ost->data_size);
1503 av_log(NULL, AV_LOG_VERBOSE, "\n");
1506 av_log(NULL, AV_LOG_VERBOSE, " Total: %"PRIu64" packets (%"PRIu64" bytes) muxed\n",
1507 total_packets, total_size);
1509 if(video_size + data_size + audio_size + subtitle_size + extra_size == 0){
1510 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded ");
1512 av_log(NULL, AV_LOG_WARNING, "\n");
1514 av_log(NULL, AV_LOG_WARNING, "(check -ss / -t / -frames parameters if used)\n");
1519 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
1522 AVBPrint buf_script;
1524 AVFormatContext *oc;
1526 AVCodecContext *enc;
1527 int frame_number, vid, i;
1529 int64_t pts = INT64_MIN + 1;
1530 static int64_t last_time = -1;
1531 static int qp_histogram[52];
1532 int hours, mins, secs, us;
1534 if (!print_stats && !is_last_report && !progress_avio)
1537 if (!is_last_report) {
1538 if (last_time == -1) {
1539 last_time = cur_time;
1542 if ((cur_time - last_time) < 500000)
1544 last_time = cur_time;
1548 oc = output_files[0]->ctx;
1550 total_size = avio_size(oc->pb);
1551 if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
1552 total_size = avio_tell(oc->pb);
1556 av_bprint_init(&buf_script, 0, 1);
1557 for (i = 0; i < nb_output_streams; i++) {
1559 ost = output_streams[i];
1561 if (!ost->stream_copy)
1562 q = ost->quality / (float) FF_QP2LAMBDA;
1564 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1565 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1566 av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1567 ost->file_index, ost->index, q);
1569 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1570 float fps, t = (cur_time-timer_start) / 1000000.0;
1572 frame_number = ost->frame_number;
1573 fps = t > 1 ? frame_number / t : 0;
1574 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
1575 frame_number, fps < 9.95, fps, q);
1576 av_bprintf(&buf_script, "frame=%d\n", frame_number);
1577 av_bprintf(&buf_script, "fps=%.1f\n", fps);
1578 av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1579 ost->file_index, ost->index, q);
1581 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1585 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1587 for (j = 0; j < 32; j++)
1588 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log2(qp_histogram[j] + 1)));
1591 if ((enc->flags & AV_CODEC_FLAG_PSNR) && (ost->pict_type != AV_PICTURE_TYPE_NONE || is_last_report)) {
1593 double error, error_sum = 0;
1594 double scale, scale_sum = 0;
1596 char type[3] = { 'Y','U','V' };
1597 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1598 for (j = 0; j < 3; j++) {
1599 if (is_last_report) {
1600 error = enc->error[j];
1601 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1603 error = ost->error[j];
1604 scale = enc->width * enc->height * 255.0 * 255.0;
1610 p = psnr(error / scale);
1611 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], p);
1612 av_bprintf(&buf_script, "stream_%d_%d_psnr_%c=%2.2f\n",
1613 ost->file_index, ost->index, type[j] | 32, p);
1615 p = psnr(error_sum / scale_sum);
1616 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1617 av_bprintf(&buf_script, "stream_%d_%d_psnr_all=%2.2f\n",
1618 ost->file_index, ost->index, p);
1622 /* compute min output value */
1623 if (av_stream_get_end_pts(ost->st) != AV_NOPTS_VALUE)
1624 pts = FFMAX(pts, av_rescale_q(av_stream_get_end_pts(ost->st),
1625 ost->st->time_base, AV_TIME_BASE_Q));
1627 nb_frames_drop += ost->last_droped;
1630 secs = FFABS(pts) / AV_TIME_BASE;
1631 us = FFABS(pts) % AV_TIME_BASE;
1637 bitrate = pts && total_size >= 0 ? total_size * 8 / (pts / 1000.0) : -1;
1639 if (total_size < 0) snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1641 else snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1642 "size=%8.0fkB time=", total_size / 1024.0);
1644 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "-");
1645 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1646 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1647 (100 * us) / AV_TIME_BASE);
1650 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),"bitrate=N/A");
1651 av_bprintf(&buf_script, "bitrate=N/A\n");
1653 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),"bitrate=%6.1fkbits/s", bitrate);
1654 av_bprintf(&buf_script, "bitrate=%6.1fkbits/s\n", bitrate);
1657 if (total_size < 0) av_bprintf(&buf_script, "total_size=N/A\n");
1658 else av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
1659 av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
1660 av_bprintf(&buf_script, "out_time=%02d:%02d:%02d.%06d\n",
1661 hours, mins, secs, us);
1663 if (nb_frames_dup || nb_frames_drop)
1664 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1665 nb_frames_dup, nb_frames_drop);
1666 av_bprintf(&buf_script, "dup_frames=%d\n", nb_frames_dup);
1667 av_bprintf(&buf_script, "drop_frames=%d\n", nb_frames_drop);
1669 if (print_stats || is_last_report) {
1670 const char end = is_last_report ? '\n' : '\r';
1671 if (print_stats==1 && AV_LOG_INFO > av_log_get_level()) {
1672 fprintf(stderr, "%s %c", buf, end);
1674 av_log(NULL, AV_LOG_INFO, "%s %c", buf, end);
1679 if (progress_avio) {
1680 av_bprintf(&buf_script, "progress=%s\n",
1681 is_last_report ? "end" : "continue");
1682 avio_write(progress_avio, buf_script.str,
1683 FFMIN(buf_script.len, buf_script.size - 1));
1684 avio_flush(progress_avio);
1685 av_bprint_finalize(&buf_script, NULL);
1686 if (is_last_report) {
1687 avio_closep(&progress_avio);
1692 print_final_stats(total_size);
1695 static void flush_encoders(void)
1699 for (i = 0; i < nb_output_streams; i++) {
1700 OutputStream *ost = output_streams[i];
1701 AVCodecContext *enc = ost->enc_ctx;
1702 AVFormatContext *os = output_files[ost->file_index]->ctx;
1703 int stop_encoding = 0;
1705 if (!ost->encoding_needed)
1708 if (enc->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1710 #if FF_API_LAVF_FMT_RAWPICTURE
1711 if (enc->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == AV_CODEC_ID_RAWVIDEO)
1716 int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
1719 switch (enc->codec_type) {
1720 case AVMEDIA_TYPE_AUDIO:
1721 encode = avcodec_encode_audio2;
1724 case AVMEDIA_TYPE_VIDEO:
1725 encode = avcodec_encode_video2;
1736 av_init_packet(&pkt);
1740 update_benchmark(NULL);
1741 ret = encode(enc, &pkt, NULL, &got_packet);
1742 update_benchmark("flush %s %d.%d", desc, ost->file_index, ost->index);
1744 av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
1749 if (ost->logfile && enc->stats_out) {
1750 fprintf(ost->logfile, "%s", enc->stats_out);
1756 if (ost->finished & MUXER_FINISHED) {
1757 av_packet_unref(&pkt);
1760 av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);
1761 pkt_size = pkt.size;
1762 write_frame(os, &pkt, ost);
1763 if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO && vstats_filename) {
1764 do_video_stats(ost, pkt_size);
1775 * Check whether a packet from ist should be written into ost at this time
1777 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1779 OutputFile *of = output_files[ost->file_index];
1780 int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
1782 if (ost->source_index != ist_index)
1788 if (of->start_time != AV_NOPTS_VALUE && ist->pts < of->start_time)
1794 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1796 OutputFile *of = output_files[ost->file_index];
1797 InputFile *f = input_files [ist->file_index];
1798 int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1799 int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1800 int64_t ist_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ist->st->time_base);
1804 av_init_packet(&opkt);
1806 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1807 !ost->copy_initial_nonkeyframes)
1810 if (pkt->pts == AV_NOPTS_VALUE) {
1811 if (!ost->frame_number && ist->pts < start_time &&
1812 !ost->copy_prior_start)
1815 if (!ost->frame_number && pkt->pts < ist_tb_start_time &&
1816 !ost->copy_prior_start)
1820 if (of->recording_time != INT64_MAX &&
1821 ist->pts >= of->recording_time + start_time) {
1822 close_output_stream(ost);
1826 if (f->recording_time != INT64_MAX) {
1827 start_time = f->ctx->start_time;
1828 if (f->start_time != AV_NOPTS_VALUE)
1829 start_time += f->start_time;
1830 if (ist->pts >= f->recording_time + start_time) {
1831 close_output_stream(ost);
1836 /* force the input stream PTS */
1837 if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
1840 if (pkt->pts != AV_NOPTS_VALUE)
1841 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1843 opkt.pts = AV_NOPTS_VALUE;
1845 if (pkt->dts == AV_NOPTS_VALUE)
1846 opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
1848 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1849 opkt.dts -= ost_tb_start_time;
1851 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
1852 int duration = av_get_audio_frame_duration(ist->dec_ctx, pkt->size);
1854 duration = ist->dec_ctx->frame_size;
1855 opkt.dts = opkt.pts = av_rescale_delta(ist->st->time_base, pkt->dts,
1856 (AVRational){1, ist->dec_ctx->sample_rate}, duration, &ist->filter_in_rescale_delta_last,
1857 ost->st->time_base) - ost_tb_start_time;
1860 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1861 opkt.flags = pkt->flags;
1862 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1863 if ( ost->st->codec->codec_id != AV_CODEC_ID_H264
1864 && ost->st->codec->codec_id != AV_CODEC_ID_MPEG1VIDEO
1865 && ost->st->codec->codec_id != AV_CODEC_ID_MPEG2VIDEO
1866 && ost->st->codec->codec_id != AV_CODEC_ID_VC1
1868 int ret = av_parser_change(ost->parser, ost->st->codec,
1869 &opkt.data, &opkt.size,
1870 pkt->data, pkt->size,
1871 pkt->flags & AV_PKT_FLAG_KEY);
1873 av_log(NULL, AV_LOG_FATAL, "av_parser_change failed: %s\n",
1878 opkt.buf = av_buffer_create(opkt.data, opkt.size, av_buffer_default_free, NULL, 0);
1883 opkt.data = pkt->data;
1884 opkt.size = pkt->size;
1886 av_copy_packet_side_data(&opkt, pkt);
1888 #if FF_API_LAVF_FMT_RAWPICTURE
1889 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1890 ost->st->codec->codec_id == AV_CODEC_ID_RAWVIDEO &&
1891 (of->ctx->oformat->flags & AVFMT_RAWPICTURE)) {
1892 /* store AVPicture in AVPacket, as expected by the output format */
1893 int ret = avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1895 av_log(NULL, AV_LOG_FATAL, "avpicture_fill failed: %s\n",
1899 opkt.data = (uint8_t *)&pict;
1900 opkt.size = sizeof(AVPicture);
1901 opkt.flags |= AV_PKT_FLAG_KEY;
1905 write_frame(of->ctx, &opkt, ost);
1908 int guess_input_channel_layout(InputStream *ist)
1910 AVCodecContext *dec = ist->dec_ctx;
1912 if (!dec->channel_layout) {
1913 char layout_name[256];
1915 if (dec->channels > ist->guess_layout_max)
1917 dec->channel_layout = av_get_default_channel_layout(dec->channels);
1918 if (!dec->channel_layout)
1920 av_get_channel_layout_string(layout_name, sizeof(layout_name),
1921 dec->channels, dec->channel_layout);
1922 av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
1923 "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
1928 static void check_decode_result(InputStream *ist, int *got_output, int ret)
1930 if (*got_output || ret<0)
1931 decode_error_stat[ret<0] ++;
1933 if (ret < 0 && exit_on_error)
1936 if (exit_on_error && *got_output && ist) {
1937 if (av_frame_get_decode_error_flags(ist->decoded_frame) || (ist->decoded_frame->flags & AV_FRAME_FLAG_CORRUPT)) {
1938 av_log(NULL, AV_LOG_FATAL, "%s: corrupt decoded frame in stream %d\n", input_files[ist->file_index]->ctx->filename, ist->st->index);
1944 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1946 AVFrame *decoded_frame, *f;
1947 AVCodecContext *avctx = ist->dec_ctx;
1948 int i, ret, err = 0, resample_changed;
1949 AVRational decoded_frame_tb;
1951 if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
1952 return AVERROR(ENOMEM);
1953 if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
1954 return AVERROR(ENOMEM);
1955 decoded_frame = ist->decoded_frame;
1957 update_benchmark(NULL);
1958 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1959 update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
1961 if (ret >= 0 && avctx->sample_rate <= 0) {
1962 av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
1963 ret = AVERROR_INVALIDDATA;
1966 check_decode_result(ist, got_output, ret);
1968 if (!*got_output || ret < 0)
1971 ist->samples_decoded += decoded_frame->nb_samples;
1972 ist->frames_decoded++;
1975 /* increment next_dts to use for the case where the input stream does not
1976 have timestamps or there are multiple frames in the packet */
1977 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1979 ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1983 resample_changed = ist->resample_sample_fmt != decoded_frame->format ||
1984 ist->resample_channels != avctx->channels ||
1985 ist->resample_channel_layout != decoded_frame->channel_layout ||
1986 ist->resample_sample_rate != decoded_frame->sample_rate;
1987 if (resample_changed) {
1988 char layout1[64], layout2[64];
1990 if (!guess_input_channel_layout(ist)) {
1991 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
1992 "layout for Input Stream #%d.%d\n", ist->file_index,
1996 decoded_frame->channel_layout = avctx->channel_layout;
1998 av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
1999 ist->resample_channel_layout);
2000 av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
2001 decoded_frame->channel_layout);
2003 av_log(NULL, AV_LOG_INFO,
2004 "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",
2005 ist->file_index, ist->st->index,
2006 ist->resample_sample_rate, av_get_sample_fmt_name(ist->resample_sample_fmt),
2007 ist->resample_channels, layout1,
2008 decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
2009 avctx->channels, layout2);
2011 ist->resample_sample_fmt = decoded_frame->format;
2012 ist->resample_sample_rate = decoded_frame->sample_rate;
2013 ist->resample_channel_layout = decoded_frame->channel_layout;
2014 ist->resample_channels = avctx->channels;
2016 for (i = 0; i < nb_filtergraphs; i++)
2017 if (ist_in_filtergraph(filtergraphs[i], ist)) {
2018 FilterGraph *fg = filtergraphs[i];
2019 if (configure_filtergraph(fg) < 0) {
2020 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2026 /* if the decoder provides a pts, use it instead of the last packet pts.
2027 the decoder could be delaying output by a packet or more. */
2028 if (decoded_frame->pts != AV_NOPTS_VALUE) {
2029 ist->dts = ist->next_dts = ist->pts = ist->next_pts = av_rescale_q(decoded_frame->pts, avctx->time_base, AV_TIME_BASE_Q);
2030 decoded_frame_tb = avctx->time_base;
2031 } else if (decoded_frame->pkt_pts != AV_NOPTS_VALUE) {
2032 decoded_frame->pts = decoded_frame->pkt_pts;
2033 decoded_frame_tb = ist->st->time_base;
2034 } else if (pkt->pts != AV_NOPTS_VALUE) {
2035 decoded_frame->pts = pkt->pts;
2036 decoded_frame_tb = ist->st->time_base;
2038 decoded_frame->pts = ist->dts;
2039 decoded_frame_tb = AV_TIME_BASE_Q;
2041 pkt->pts = AV_NOPTS_VALUE;
2042 if (decoded_frame->pts != AV_NOPTS_VALUE)
2043 decoded_frame->pts = av_rescale_delta(decoded_frame_tb, decoded_frame->pts,
2044 (AVRational){1, avctx->sample_rate}, decoded_frame->nb_samples, &ist->filter_in_rescale_delta_last,
2045 (AVRational){1, avctx->sample_rate});
2046 ist->nb_samples = decoded_frame->nb_samples;
2047 for (i = 0; i < ist->nb_filters; i++) {
2048 if (i < ist->nb_filters - 1) {
2049 f = ist->filter_frame;
2050 err = av_frame_ref(f, decoded_frame);
2055 err = av_buffersrc_add_frame_flags(ist->filters[i]->filter, f,
2056 AV_BUFFERSRC_FLAG_PUSH);
2057 if (err == AVERROR_EOF)
2058 err = 0; /* ignore */
2062 decoded_frame->pts = AV_NOPTS_VALUE;
2064 av_frame_unref(ist->filter_frame);
2065 av_frame_unref(decoded_frame);
2066 return err < 0 ? err : ret;
2069 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
2071 AVFrame *decoded_frame, *f;
2072 int i, ret = 0, err = 0, resample_changed;
2073 int64_t best_effort_timestamp;
2074 AVRational *frame_sample_aspect;
2076 if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
2077 return AVERROR(ENOMEM);
2078 if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
2079 return AVERROR(ENOMEM);
2080 decoded_frame = ist->decoded_frame;
2081 pkt->dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2083 update_benchmark(NULL);
2084 ret = avcodec_decode_video2(ist->dec_ctx,
2085 decoded_frame, got_output, pkt);
2086 update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2088 // The following line may be required in some cases where there is no parser
2089 // or the parser does not has_b_frames correctly
2090 if (ist->st->codec->has_b_frames < ist->dec_ctx->has_b_frames) {
2091 if (ist->dec_ctx->codec_id == AV_CODEC_ID_H264) {
2092 ist->st->codec->has_b_frames = ist->dec_ctx->has_b_frames;
2094 av_log(ist->dec_ctx, AV_LOG_WARNING,
2095 "has_b_frames is larger in decoder than demuxer %d > %d.\n"
2096 "If you want to help, upload a sample "
2097 "of this file to ftp://upload.ffmpeg.org/incoming/ "
2098 "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)",
2099 ist->dec_ctx->has_b_frames,
2100 ist->st->codec->has_b_frames);
2103 check_decode_result(ist, got_output, ret);
2105 if (*got_output && ret >= 0) {
2106 if (ist->dec_ctx->width != decoded_frame->width ||
2107 ist->dec_ctx->height != decoded_frame->height ||
2108 ist->dec_ctx->pix_fmt != decoded_frame->format) {
2109 av_log(NULL, AV_LOG_DEBUG, "Frame parameters mismatch context %d,%d,%d != %d,%d,%d\n",
2110 decoded_frame->width,
2111 decoded_frame->height,
2112 decoded_frame->format,
2113 ist->dec_ctx->width,
2114 ist->dec_ctx->height,
2115 ist->dec_ctx->pix_fmt);
2119 if (!*got_output || ret < 0)
2122 if(ist->top_field_first>=0)
2123 decoded_frame->top_field_first = ist->top_field_first;
2125 ist->frames_decoded++;
2127 if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) {
2128 err = ist->hwaccel_retrieve_data(ist->dec_ctx, decoded_frame);
2132 ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
2134 best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
2135 if(best_effort_timestamp != AV_NOPTS_VALUE)
2136 ist->next_pts = ist->pts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2139 av_log(NULL, AV_LOG_INFO, "decoder -> ist_index:%d type:video "
2140 "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",
2141 ist->st->index, av_ts2str(decoded_frame->pts),
2142 av_ts2timestr(decoded_frame->pts, &ist->st->time_base),
2143 best_effort_timestamp,
2144 av_ts2timestr(best_effort_timestamp, &ist->st->time_base),
2145 decoded_frame->key_frame, decoded_frame->pict_type,
2146 ist->st->time_base.num, ist->st->time_base.den);
2151 if (ist->st->sample_aspect_ratio.num)
2152 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2154 resample_changed = ist->resample_width != decoded_frame->width ||
2155 ist->resample_height != decoded_frame->height ||
2156 ist->resample_pix_fmt != decoded_frame->format;
2157 if (resample_changed) {
2158 av_log(NULL, AV_LOG_INFO,
2159 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2160 ist->file_index, ist->st->index,
2161 ist->resample_width, ist->resample_height, av_get_pix_fmt_name(ist->resample_pix_fmt),
2162 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2164 ist->resample_width = decoded_frame->width;
2165 ist->resample_height = decoded_frame->height;
2166 ist->resample_pix_fmt = decoded_frame->format;
2168 for (i = 0; i < nb_filtergraphs; i++) {
2169 if (ist_in_filtergraph(filtergraphs[i], ist) && ist->reinit_filters &&
2170 configure_filtergraph(filtergraphs[i]) < 0) {
2171 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2177 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2178 for (i = 0; i < ist->nb_filters; i++) {
2179 if (!frame_sample_aspect->num)
2180 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2182 if (i < ist->nb_filters - 1) {
2183 f = ist->filter_frame;
2184 err = av_frame_ref(f, decoded_frame);
2189 ret = av_buffersrc_add_frame_flags(ist->filters[i]->filter, f, AV_BUFFERSRC_FLAG_PUSH);
2190 if (ret == AVERROR_EOF) {
2191 ret = 0; /* ignore */
2192 } else if (ret < 0) {
2193 av_log(NULL, AV_LOG_FATAL,
2194 "Failed to inject frame into filter network: %s\n", av_err2str(ret));
2200 av_frame_unref(ist->filter_frame);
2201 av_frame_unref(decoded_frame);
2202 return err < 0 ? err : ret;
2205 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2207 AVSubtitle subtitle;
2208 int i, ret = avcodec_decode_subtitle2(ist->dec_ctx,
2209 &subtitle, got_output, pkt);
2211 check_decode_result(NULL, got_output, ret);
2213 if (ret < 0 || !*got_output) {
2215 sub2video_flush(ist);
2219 if (ist->fix_sub_duration) {
2221 if (ist->prev_sub.got_output) {
2222 end = av_rescale(subtitle.pts - ist->prev_sub.subtitle.pts,
2223 1000, AV_TIME_BASE);
2224 if (end < ist->prev_sub.subtitle.end_display_time) {
2225 av_log(ist->dec_ctx, AV_LOG_DEBUG,
2226 "Subtitle duration reduced from %d to %d%s\n",
2227 ist->prev_sub.subtitle.end_display_time, end,
2228 end <= 0 ? ", dropping it" : "");
2229 ist->prev_sub.subtitle.end_display_time = end;
2232 FFSWAP(int, *got_output, ist->prev_sub.got_output);
2233 FFSWAP(int, ret, ist->prev_sub.ret);
2234 FFSWAP(AVSubtitle, subtitle, ist->prev_sub.subtitle);
2242 sub2video_update(ist, &subtitle);
2244 if (!subtitle.num_rects)
2247 ist->frames_decoded++;
2249 for (i = 0; i < nb_output_streams; i++) {
2250 OutputStream *ost = output_streams[i];
2252 if (!check_output_constraints(ist, ost) || !ost->encoding_needed
2253 || ost->enc->type != AVMEDIA_TYPE_SUBTITLE)
2256 do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle);
2260 avsubtitle_free(&subtitle);
2264 static int send_filter_eof(InputStream *ist)
2267 for (i = 0; i < ist->nb_filters; i++) {
2268 ret = av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
2275 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2276 static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eof)
2282 if (!ist->saw_first_ts) {
2283 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;
2285 if (pkt && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2286 ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2287 ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2289 ist->saw_first_ts = 1;
2292 if (ist->next_dts == AV_NOPTS_VALUE)
2293 ist->next_dts = ist->dts;
2294 if (ist->next_pts == AV_NOPTS_VALUE)
2295 ist->next_pts = ist->pts;
2299 av_init_packet(&avpkt);
2307 if (pkt->dts != AV_NOPTS_VALUE) {
2308 ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2309 if (ist->dec_ctx->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2310 ist->next_pts = ist->pts = ist->dts;
2313 // while we have more to decode or while the decoder did output something on EOF
2314 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2318 ist->pts = ist->next_pts;
2319 ist->dts = ist->next_dts;
2321 if (avpkt.size && avpkt.size != pkt->size &&
2322 !(ist->dec->capabilities & AV_CODEC_CAP_SUBFRAMES)) {
2323 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2324 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2325 ist->showed_multi_packet_warning = 1;
2328 switch (ist->dec_ctx->codec_type) {
2329 case AVMEDIA_TYPE_AUDIO:
2330 ret = decode_audio (ist, &avpkt, &got_output);
2332 case AVMEDIA_TYPE_VIDEO:
2333 ret = decode_video (ist, &avpkt, &got_output);
2334 if (avpkt.duration) {
2335 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2336 } else if(ist->dec_ctx->framerate.num != 0 && ist->dec_ctx->framerate.den != 0) {
2337 int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict+1 : ist->dec_ctx->ticks_per_frame;
2338 duration = ((int64_t)AV_TIME_BASE *
2339 ist->dec_ctx->framerate.den * ticks) /
2340 ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
2344 if(ist->dts != AV_NOPTS_VALUE && duration) {
2345 ist->next_dts += duration;
2347 ist->next_dts = AV_NOPTS_VALUE;
2350 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2352 case AVMEDIA_TYPE_SUBTITLE:
2353 ret = transcode_subtitles(ist, &avpkt, &got_output);
2360 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
2361 ist->file_index, ist->st->index, av_err2str(ret));
2368 avpkt.pts= AV_NOPTS_VALUE;
2370 // touch data and size only if not EOF
2372 if(ist->dec_ctx->codec_type != AVMEDIA_TYPE_AUDIO)
2380 if (got_output && !pkt)
2384 /* after flushing, send an EOF on all the filter inputs attached to the stream */
2385 /* except when looping we need to flush but not to send an EOF */
2386 if (!pkt && ist->decoding_needed && !got_output && !no_eof) {
2387 int ret = send_filter_eof(ist);
2389 av_log(NULL, AV_LOG_FATAL, "Error marking filters as finished\n");
2394 /* handle stream copy */
2395 if (!ist->decoding_needed) {
2396 ist->dts = ist->next_dts;
2397 switch (ist->dec_ctx->codec_type) {
2398 case AVMEDIA_TYPE_AUDIO:
2399 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) /
2400 ist->dec_ctx->sample_rate;
2402 case AVMEDIA_TYPE_VIDEO:
2403 if (ist->framerate.num) {
2404 // TODO: Remove work-around for c99-to-c89 issue 7
2405 AVRational time_base_q = AV_TIME_BASE_Q;
2406 int64_t next_dts = av_rescale_q(ist->next_dts, time_base_q, av_inv_q(ist->framerate));
2407 ist->next_dts = av_rescale_q(next_dts + 1, av_inv_q(ist->framerate), time_base_q);
2408 } else if (pkt->duration) {
2409 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2410 } else if(ist->dec_ctx->framerate.num != 0) {
2411 int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict + 1 : ist->dec_ctx->ticks_per_frame;
2412 ist->next_dts += ((int64_t)AV_TIME_BASE *
2413 ist->dec_ctx->framerate.den * ticks) /
2414 ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
2418 ist->pts = ist->dts;
2419 ist->next_pts = ist->next_dts;
2421 for (i = 0; pkt && i < nb_output_streams; i++) {
2422 OutputStream *ost = output_streams[i];
2424 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2427 do_streamcopy(ist, ost, pkt);
2433 static void print_sdp(void)
2438 AVIOContext *sdp_pb;
2439 AVFormatContext **avc = av_malloc_array(nb_output_files, sizeof(*avc));
2443 for (i = 0, j = 0; i < nb_output_files; i++) {
2444 if (!strcmp(output_files[i]->ctx->oformat->name, "rtp")) {
2445 avc[j] = output_files[i]->ctx;
2450 av_sdp_create(avc, j, sdp, sizeof(sdp));
2452 if (!sdp_filename) {
2453 printf("SDP:\n%s\n", sdp);
2456 if (avio_open2(&sdp_pb, sdp_filename, AVIO_FLAG_WRITE, &int_cb, NULL) < 0) {
2457 av_log(NULL, AV_LOG_ERROR, "Failed to open sdp file '%s'\n", sdp_filename);
2459 avio_printf(sdp_pb, "SDP:\n%s", sdp);
2460 avio_closep(&sdp_pb);
2461 av_freep(&sdp_filename);
2468 static const HWAccel *get_hwaccel(enum AVPixelFormat pix_fmt)
2471 for (i = 0; hwaccels[i].name; i++)
2472 if (hwaccels[i].pix_fmt == pix_fmt)
2473 return &hwaccels[i];
2477 static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
2479 InputStream *ist = s->opaque;
2480 const enum AVPixelFormat *p;
2483 for (p = pix_fmts; *p != -1; p++) {
2484 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(*p);
2485 const HWAccel *hwaccel;
2487 if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
2490 hwaccel = get_hwaccel(*p);
2492 (ist->active_hwaccel_id && ist->active_hwaccel_id != hwaccel->id) ||
2493 (ist->hwaccel_id != HWACCEL_AUTO && ist->hwaccel_id != hwaccel->id))
2496 ret = hwaccel->init(s);
2498 if (ist->hwaccel_id == hwaccel->id) {
2499 av_log(NULL, AV_LOG_FATAL,
2500 "%s hwaccel requested for input stream #%d:%d, "
2501 "but cannot be initialized.\n", hwaccel->name,
2502 ist->file_index, ist->st->index);
2503 return AV_PIX_FMT_NONE;
2507 ist->active_hwaccel_id = hwaccel->id;
2508 ist->hwaccel_pix_fmt = *p;
2515 static int get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
2517 InputStream *ist = s->opaque;
2519 if (ist->hwaccel_get_buffer && frame->format == ist->hwaccel_pix_fmt)
2520 return ist->hwaccel_get_buffer(s, frame, flags);
2522 return avcodec_default_get_buffer2(s, frame, flags);
2525 static int init_input_stream(int ist_index, char *error, int error_len)
2528 InputStream *ist = input_streams[ist_index];
2530 if (ist->decoding_needed) {
2531 AVCodec *codec = ist->dec;
2533 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2534 avcodec_get_name(ist->dec_ctx->codec_id), ist->file_index, ist->st->index);
2535 return AVERROR(EINVAL);
2538 ist->dec_ctx->opaque = ist;
2539 ist->dec_ctx->get_format = get_format;
2540 ist->dec_ctx->get_buffer2 = get_buffer;
2541 ist->dec_ctx->thread_safe_callbacks = 1;
2543 av_opt_set_int(ist->dec_ctx, "refcounted_frames", 1, 0);
2544 if (ist->dec_ctx->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
2545 (ist->decoding_needed & DECODING_FOR_OST)) {
2546 av_dict_set(&ist->decoder_opts, "compute_edt", "1", AV_DICT_DONT_OVERWRITE);
2547 if (ist->decoding_needed & DECODING_FOR_FILTER)
2548 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");
2551 if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0))
2552 av_dict_set(&ist->decoder_opts, "threads", "auto", 0);
2553 if ((ret = avcodec_open2(ist->dec_ctx, codec, &ist->decoder_opts)) < 0) {
2554 if (ret == AVERROR_EXPERIMENTAL)
2555 abort_codec_experimental(codec, 0);
2557 snprintf(error, error_len,
2558 "Error while opening decoder for input stream "
2560 ist->file_index, ist->st->index, av_err2str(ret));
2563 assert_avoptions(ist->decoder_opts);
2566 ist->next_pts = AV_NOPTS_VALUE;
2567 ist->next_dts = AV_NOPTS_VALUE;
2572 static InputStream *get_input_stream(OutputStream *ost)
2574 if (ost->source_index >= 0)
2575 return input_streams[ost->source_index];
2579 static int compare_int64(const void *a, const void *b)
2581 int64_t va = *(int64_t *)a, vb = *(int64_t *)b;
2582 return va < vb ? -1 : va > vb ? +1 : 0;
2585 static int init_output_stream(OutputStream *ost, char *error, int error_len)
2589 if (ost->encoding_needed) {
2590 AVCodec *codec = ost->enc;
2591 AVCodecContext *dec = NULL;
2594 if ((ist = get_input_stream(ost)))
2596 if (dec && dec->subtitle_header) {
2597 /* ASS code assumes this buffer is null terminated so add extra byte. */
2598 ost->enc_ctx->subtitle_header = av_mallocz(dec->subtitle_header_size + 1);
2599 if (!ost->enc_ctx->subtitle_header)
2600 return AVERROR(ENOMEM);
2601 memcpy(ost->enc_ctx->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2602 ost->enc_ctx->subtitle_header_size = dec->subtitle_header_size;
2604 if (!av_dict_get(ost->encoder_opts, "threads", NULL, 0))
2605 av_dict_set(&ost->encoder_opts, "threads", "auto", 0);
2606 if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2608 !av_dict_get(ost->encoder_opts, "b", NULL, 0) &&
2609 !av_dict_get(ost->encoder_opts, "ab", NULL, 0))
2610 av_dict_set(&ost->encoder_opts, "b", "128000", 0);
2612 if ((ret = avcodec_open2(ost->enc_ctx, codec, &ost->encoder_opts)) < 0) {
2613 if (ret == AVERROR_EXPERIMENTAL)
2614 abort_codec_experimental(codec, 1);
2615 snprintf(error, error_len,
2616 "Error while opening encoder for output stream #%d:%d - "
2617 "maybe incorrect parameters such as bit_rate, rate, width or height",
2618 ost->file_index, ost->index);
2621 if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2622 !(ost->enc->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE))
2623 av_buffersink_set_frame_size(ost->filter->filter,
2624 ost->enc_ctx->frame_size);
2625 assert_avoptions(ost->encoder_opts);
2626 if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000)
2627 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2628 " It takes bits/s as argument, not kbits/s\n");
2630 ret = avcodec_copy_context(ost->st->codec, ost->enc_ctx);
2632 av_log(NULL, AV_LOG_FATAL,
2633 "Error initializing the output stream codec context.\n");
2637 // copy timebase while removing common factors
2638 ost->st->time_base = av_add_q(ost->enc_ctx->time_base, (AVRational){0, 1});
2639 ost->st->codec->codec= ost->enc_ctx->codec;
2641 ret = av_opt_set_dict(ost->enc_ctx, &ost->encoder_opts);
2643 av_log(NULL, AV_LOG_FATAL,
2644 "Error setting up codec context options.\n");
2647 // copy timebase while removing common factors
2648 ost->st->time_base = av_add_q(ost->st->codec->time_base, (AVRational){0, 1});
2654 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2655 AVCodecContext *avctx)
2658 int n = 1, i, size, index = 0;
2661 for (p = kf; *p; p++)
2665 pts = av_malloc_array(size, sizeof(*pts));
2667 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2672 for (i = 0; i < n; i++) {
2673 char *next = strchr(p, ',');
2678 if (!memcmp(p, "chapters", 8)) {
2680 AVFormatContext *avf = output_files[ost->file_index]->ctx;
2683 if (avf->nb_chapters > INT_MAX - size ||
2684 !(pts = av_realloc_f(pts, size += avf->nb_chapters - 1,
2686 av_log(NULL, AV_LOG_FATAL,
2687 "Could not allocate forced key frames array.\n");
2690 t = p[8] ? parse_time_or_die("force_key_frames", p + 8, 1) : 0;
2691 t = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2693 for (j = 0; j < avf->nb_chapters; j++) {
2694 AVChapter *c = avf->chapters[j];
2695 av_assert1(index < size);
2696 pts[index++] = av_rescale_q(c->start, c->time_base,
2697 avctx->time_base) + t;
2702 t = parse_time_or_die("force_key_frames", p, 1);
2703 av_assert1(index < size);
2704 pts[index++] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2711 av_assert0(index == size);
2712 qsort(pts, size, sizeof(*pts), compare_int64);
2713 ost->forced_kf_count = size;
2714 ost->forced_kf_pts = pts;
2717 static void report_new_stream(int input_index, AVPacket *pkt)
2719 InputFile *file = input_files[input_index];
2720 AVStream *st = file->ctx->streams[pkt->stream_index];
2722 if (pkt->stream_index < file->nb_streams_warn)
2724 av_log(file->ctx, AV_LOG_WARNING,
2725 "New %s stream %d:%d at pos:%"PRId64" and DTS:%ss\n",
2726 av_get_media_type_string(st->codec->codec_type),
2727 input_index, pkt->stream_index,
2728 pkt->pos, av_ts2timestr(pkt->dts, &st->time_base));
2729 file->nb_streams_warn = pkt->stream_index + 1;
2732 static void set_encoder_id(OutputFile *of, OutputStream *ost)
2734 AVDictionaryEntry *e;
2736 uint8_t *encoder_string;
2737 int encoder_string_len;
2738 int format_flags = 0;
2739 int codec_flags = 0;
2741 if (av_dict_get(ost->st->metadata, "encoder", NULL, 0))
2744 e = av_dict_get(of->opts, "fflags", NULL, 0);
2746 const AVOption *o = av_opt_find(of->ctx, "fflags", NULL, 0, 0);
2749 av_opt_eval_flags(of->ctx, o, e->value, &format_flags);
2751 e = av_dict_get(ost->encoder_opts, "flags", NULL, 0);
2753 const AVOption *o = av_opt_find(ost->enc_ctx, "flags", NULL, 0, 0);
2756 av_opt_eval_flags(ost->enc_ctx, o, e->value, &codec_flags);
2759 encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(ost->enc->name) + 2;
2760 encoder_string = av_mallocz(encoder_string_len);
2761 if (!encoder_string)
2764 if (!(format_flags & AVFMT_FLAG_BITEXACT) && !(codec_flags & AV_CODEC_FLAG_BITEXACT))
2765 av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
2767 av_strlcpy(encoder_string, "Lavc ", encoder_string_len);
2768 av_strlcat(encoder_string, ost->enc->name, encoder_string_len);
2769 av_dict_set(&ost->st->metadata, "encoder", encoder_string,
2770 AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE);
2773 static int transcode_init(void)
2775 int ret = 0, i, j, k;
2776 AVFormatContext *oc;
2779 char error[1024] = {0};
2782 for (i = 0; i < nb_filtergraphs; i++) {
2783 FilterGraph *fg = filtergraphs[i];
2784 for (j = 0; j < fg->nb_outputs; j++) {
2785 OutputFilter *ofilter = fg->outputs[j];
2786 if (!ofilter->ost || ofilter->ost->source_index >= 0)
2788 if (fg->nb_inputs != 1)
2790 for (k = nb_input_streams-1; k >= 0 ; k--)
2791 if (fg->inputs[0]->ist == input_streams[k])
2793 ofilter->ost->source_index = k;
2797 /* init framerate emulation */
2798 for (i = 0; i < nb_input_files; i++) {
2799 InputFile *ifile = input_files[i];
2800 if (ifile->rate_emu)
2801 for (j = 0; j < ifile->nb_streams; j++)
2802 input_streams[j + ifile->ist_index]->start = av_gettime_relative();
2805 /* for each output stream, we compute the right encoding parameters */
2806 for (i = 0; i < nb_output_streams; i++) {
2807 AVCodecContext *enc_ctx;
2808 AVCodecContext *dec_ctx = NULL;
2809 ost = output_streams[i];
2810 oc = output_files[ost->file_index]->ctx;
2811 ist = get_input_stream(ost);
2813 if (ost->attachment_filename)
2816 enc_ctx = ost->stream_copy ? ost->st->codec : ost->enc_ctx;
2819 dec_ctx = ist->dec_ctx;
2821 ost->st->disposition = ist->st->disposition;
2822 enc_ctx->bits_per_raw_sample = dec_ctx->bits_per_raw_sample;
2823 enc_ctx->chroma_sample_location = dec_ctx->chroma_sample_location;
2825 for (j=0; j<oc->nb_streams; j++) {
2826 AVStream *st = oc->streams[j];
2827 if (st != ost->st && st->codec->codec_type == enc_ctx->codec_type)
2830 if (j == oc->nb_streams)
2831 if (enc_ctx->codec_type == AVMEDIA_TYPE_AUDIO || enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
2832 ost->st->disposition = AV_DISPOSITION_DEFAULT;
2835 if (ost->stream_copy) {
2837 uint64_t extra_size;
2839 av_assert0(ist && !ost->filter);
2841 extra_size = (uint64_t)dec_ctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE;
2843 if (extra_size > INT_MAX) {
2844 return AVERROR(EINVAL);
2847 /* if stream_copy is selected, no need to decode or encode */
2848 enc_ctx->codec_id = dec_ctx->codec_id;
2849 enc_ctx->codec_type = dec_ctx->codec_type;
2851 if (!enc_ctx->codec_tag) {
2852 unsigned int codec_tag;
2853 if (!oc->oformat->codec_tag ||
2854 av_codec_get_id (oc->oformat->codec_tag, dec_ctx->codec_tag) == enc_ctx->codec_id ||
2855 !av_codec_get_tag2(oc->oformat->codec_tag, dec_ctx->codec_id, &codec_tag))
2856 enc_ctx->codec_tag = dec_ctx->codec_tag;
2859 enc_ctx->bit_rate = dec_ctx->bit_rate;
2860 enc_ctx->rc_max_rate = dec_ctx->rc_max_rate;
2861 enc_ctx->rc_buffer_size = dec_ctx->rc_buffer_size;
2862 enc_ctx->field_order = dec_ctx->field_order;
2863 if (dec_ctx->extradata_size) {
2864 enc_ctx->extradata = av_mallocz(extra_size);
2865 if (!enc_ctx->extradata) {
2866 return AVERROR(ENOMEM);
2868 memcpy(enc_ctx->extradata, dec_ctx->extradata, dec_ctx->extradata_size);
2870 enc_ctx->extradata_size= dec_ctx->extradata_size;
2871 enc_ctx->bits_per_coded_sample = dec_ctx->bits_per_coded_sample;
2873 enc_ctx->time_base = ist->st->time_base;
2875 * Avi is a special case here because it supports variable fps but
2876 * having the fps and timebase differe significantly adds quite some
2879 if(!strcmp(oc->oformat->name, "avi")) {
2880 if ( copy_tb<0 && av_q2d(ist->st->r_frame_rate) >= av_q2d(ist->st->avg_frame_rate)
2881 && 0.5/av_q2d(ist->st->r_frame_rate) > av_q2d(ist->st->time_base)
2882 && 0.5/av_q2d(ist->st->r_frame_rate) > av_q2d(dec_ctx->time_base)
2883 && av_q2d(ist->st->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
2885 enc_ctx->time_base.num = ist->st->r_frame_rate.den;
2886 enc_ctx->time_base.den = 2*ist->st->r_frame_rate.num;
2887 enc_ctx->ticks_per_frame = 2;
2888 } else if ( copy_tb<0 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2889 && av_q2d(ist->st->time_base) < 1.0/500
2891 enc_ctx->time_base = dec_ctx->time_base;
2892 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
2893 enc_ctx->time_base.den *= 2;
2894 enc_ctx->ticks_per_frame = 2;
2896 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2897 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2898 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2899 && strcmp(oc->oformat->name, "f4v")
2901 if( copy_tb<0 && dec_ctx->time_base.den
2902 && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->st->time_base)
2903 && av_q2d(ist->st->time_base) < 1.0/500
2905 enc_ctx->time_base = dec_ctx->time_base;
2906 enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
2909 if ( enc_ctx->codec_tag == AV_RL32("tmcd")
2910 && dec_ctx->time_base.num < dec_ctx->time_base.den
2911 && dec_ctx->time_base.num > 0
2912 && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
2913 enc_ctx->time_base = dec_ctx->time_base;
2916 if (!ost->frame_rate.num)
2917 ost->frame_rate = ist->framerate;
2918 if(ost->frame_rate.num)
2919 enc_ctx->time_base = av_inv_q(ost->frame_rate);
2921 av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
2922 enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
2924 if (ist->st->nb_side_data) {
2925 ost->st->side_data = av_realloc_array(NULL, ist->st->nb_side_data,
2926 sizeof(*ist->st->side_data));
2927 if (!ost->st->side_data)
2928 return AVERROR(ENOMEM);
2930 ost->st->nb_side_data = 0;
2931 for (j = 0; j < ist->st->nb_side_data; j++) {
2932 const AVPacketSideData *sd_src = &ist->st->side_data[j];
2933 AVPacketSideData *sd_dst = &ost->st->side_data[ost->st->nb_side_data];
2935 if (ost->rotate_overridden && sd_src->type == AV_PKT_DATA_DISPLAYMATRIX)
2938 sd_dst->data = av_malloc(sd_src->size);
2940 return AVERROR(ENOMEM);
2941 memcpy(sd_dst->data, sd_src->data, sd_src->size);
2942 sd_dst->size = sd_src->size;
2943 sd_dst->type = sd_src->type;
2944 ost->st->nb_side_data++;
2948 ost->parser = av_parser_init(enc_ctx->codec_id);
2950 switch (enc_ctx->codec_type) {
2951 case AVMEDIA_TYPE_AUDIO:
2952 if (audio_volume != 256) {
2953 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2956 enc_ctx->channel_layout = dec_ctx->channel_layout;
2957 enc_ctx->sample_rate = dec_ctx->sample_rate;
2958 enc_ctx->channels = dec_ctx->channels;
2959 enc_ctx->frame_size = dec_ctx->frame_size;
2960 enc_ctx->audio_service_type = dec_ctx->audio_service_type;
2961 enc_ctx->block_align = dec_ctx->block_align;
2962 enc_ctx->initial_padding = dec_ctx->delay;
2963 #if FF_API_AUDIOENC_DELAY
2964 enc_ctx->delay = dec_ctx->delay;
2966 if((enc_ctx->block_align == 1 || enc_ctx->block_align == 1152 || enc_ctx->block_align == 576) && enc_ctx->codec_id == AV_CODEC_ID_MP3)
2967 enc_ctx->block_align= 0;
2968 if(enc_ctx->codec_id == AV_CODEC_ID_AC3)
2969 enc_ctx->block_align= 0;
2971 case AVMEDIA_TYPE_VIDEO:
2972 enc_ctx->pix_fmt = dec_ctx->pix_fmt;
2973 enc_ctx->width = dec_ctx->width;
2974 enc_ctx->height = dec_ctx->height;
2975 enc_ctx->has_b_frames = dec_ctx->has_b_frames;
2976 if (ost->frame_aspect_ratio.num) { // overridden by the -aspect cli option
2978 av_mul_q(ost->frame_aspect_ratio,
2979 (AVRational){ enc_ctx->height, enc_ctx->width });
2980 av_log(NULL, AV_LOG_WARNING, "Overriding aspect ratio "
2981 "with stream copy may produce invalid files\n");
2983 else if (ist->st->sample_aspect_ratio.num)
2984 sar = ist->st->sample_aspect_ratio;
2986 sar = dec_ctx->sample_aspect_ratio;
2987 ost->st->sample_aspect_ratio = enc_ctx->sample_aspect_ratio = sar;
2988 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2989 ost->st->r_frame_rate = ist->st->r_frame_rate;
2991 case AVMEDIA_TYPE_SUBTITLE:
2992 enc_ctx->width = dec_ctx->width;
2993 enc_ctx->height = dec_ctx->height;
2995 case AVMEDIA_TYPE_UNKNOWN:
2996 case AVMEDIA_TYPE_DATA:
2997 case AVMEDIA_TYPE_ATTACHMENT:
3004 ost->enc = avcodec_find_encoder(enc_ctx->codec_id);
3006 /* should only happen when a default codec is not present. */
3007 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
3008 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
3009 ret = AVERROR(EINVAL);
3013 set_encoder_id(output_files[ost->file_index], ost);
3016 if (qsv_transcode_init(ost))
3021 (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3022 enc_ctx->codec_type == AVMEDIA_TYPE_AUDIO)) {
3024 fg = init_simple_filtergraph(ist, ost);
3025 if (configure_filtergraph(fg)) {
3026 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3031 if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3032 if (!ost->frame_rate.num)
3033 ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
3034 if (ist && !ost->frame_rate.num)
3035 ost->frame_rate = ist->framerate;
3036 if (ist && !ost->frame_rate.num)
3037 ost->frame_rate = ist->st->r_frame_rate;
3038 if (ist && !ost->frame_rate.num) {
3039 ost->frame_rate = (AVRational){25, 1};
3040 av_log(NULL, AV_LOG_WARNING,
3042 "about the input framerate is available. Falling "
3043 "back to a default value of 25fps for output stream #%d:%d. Use the -r option "
3044 "if you want a different framerate.\n",
3045 ost->file_index, ost->index);
3047 // ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
3048 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3049 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3050 ost->frame_rate = ost->enc->supported_framerates[idx];
3052 // reduce frame rate for mpeg4 to be within the spec limits
3053 if (enc_ctx->codec_id == AV_CODEC_ID_MPEG4) {
3054 av_reduce(&ost->frame_rate.num, &ost->frame_rate.den,
3055 ost->frame_rate.num, ost->frame_rate.den, 65535);
3059 switch (enc_ctx->codec_type) {
3060 case AVMEDIA_TYPE_AUDIO:
3061 enc_ctx->sample_fmt = ost->filter->filter->inputs[0]->format;
3062 enc_ctx->sample_rate = ost->filter->filter->inputs[0]->sample_rate;
3063 enc_ctx->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
3064 enc_ctx->channels = avfilter_link_get_channels(ost->filter->filter->inputs[0]);
3065 enc_ctx->time_base = (AVRational){ 1, enc_ctx->sample_rate };
3067 case AVMEDIA_TYPE_VIDEO:
3068 enc_ctx->time_base = av_inv_q(ost->frame_rate);
3069 if (!(enc_ctx->time_base.num && enc_ctx->time_base.den))
3070 enc_ctx->time_base = ost->filter->filter->inputs[0]->time_base;
3071 if ( av_q2d(enc_ctx->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3072 && (video_sync_method == VSYNC_CFR || video_sync_method == VSYNC_VSCFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3073 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3074 "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3076 for (j = 0; j < ost->forced_kf_count; j++)
3077 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3079 enc_ctx->time_base);
3081 enc_ctx->width = ost->filter->filter->inputs[0]->w;
3082 enc_ctx->height = ost->filter->filter->inputs[0]->h;
3083 enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3084 ost->frame_aspect_ratio.num ? // overridden by the -aspect cli option
3085 av_mul_q(ost->frame_aspect_ratio, (AVRational){ enc_ctx->height, enc_ctx->width }) :
3086 ost->filter->filter->inputs[0]->sample_aspect_ratio;
3087 if (!strncmp(ost->enc->name, "libx264", 7) &&
3088 enc_ctx->pix_fmt == AV_PIX_FMT_NONE &&
3089 ost->filter->filter->inputs[0]->format != AV_PIX_FMT_YUV420P)
3090 av_log(NULL, AV_LOG_WARNING,
3091 "No pixel format specified, %s for H.264 encoding chosen.\n"
3092 "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
3093 av_get_pix_fmt_name(ost->filter->filter->inputs[0]->format));
3094 if (!strncmp(ost->enc->name, "mpeg2video", 10) &&
3095 enc_ctx->pix_fmt == AV_PIX_FMT_NONE &&
3096 ost->filter->filter->inputs[0]->format != AV_PIX_FMT_YUV420P)
3097 av_log(NULL, AV_LOG_WARNING,
3098 "No pixel format specified, %s for MPEG-2 encoding chosen.\n"
3099 "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
3100 av_get_pix_fmt_name(ost->filter->filter->inputs[0]->format));
3101 enc_ctx->pix_fmt = ost->filter->filter->inputs[0]->format;
3103 ost->st->avg_frame_rate = ost->frame_rate;
3106 enc_ctx->width != dec_ctx->width ||
3107 enc_ctx->height != dec_ctx->height ||
3108 enc_ctx->pix_fmt != dec_ctx->pix_fmt) {
3109 enc_ctx->bits_per_raw_sample = frame_bits_per_raw_sample;
3112 if (ost->forced_keyframes) {
3113 if (!strncmp(ost->forced_keyframes, "expr:", 5)) {
3114 ret = av_expr_parse(&ost->forced_keyframes_pexpr, ost->forced_keyframes+5,
3115 forced_keyframes_const_names, NULL, NULL, NULL, NULL, 0, NULL);
3117 av_log(NULL, AV_LOG_ERROR,
3118 "Invalid force_key_frames expression '%s'\n", ost->forced_keyframes+5);
3121 ost->forced_keyframes_expr_const_values[FKF_N] = 0;
3122 ost->forced_keyframes_expr_const_values[FKF_N_FORCED] = 0;
3123 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] = NAN;
3124 ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] = NAN;
3126 // Don't parse the 'forced_keyframes' in case of 'keep-source-keyframes',
3127 // parse it only for static kf timings
3128 } else if(strncmp(ost->forced_keyframes, "source", 6)) {
3129 parse_forced_key_frames(ost->forced_keyframes, ost, ost->enc_ctx);
3133 case AVMEDIA_TYPE_SUBTITLE:
3134 enc_ctx->time_base = (AVRational){1, 1000};
3135 if (!enc_ctx->width) {
3136 enc_ctx->width = input_streams[ost->source_index]->st->codec->width;
3137 enc_ctx->height = input_streams[ost->source_index]->st->codec->height;
3140 case AVMEDIA_TYPE_DATA:
3148 if (ost->disposition) {
3149 static const AVOption opts[] = {
3150 { "disposition" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
3151 { "default" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEFAULT }, .unit = "flags" },
3152 { "dub" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DUB }, .unit = "flags" },
3153 { "original" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ORIGINAL }, .unit = "flags" },
3154 { "comment" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_COMMENT }, .unit = "flags" },
3155 { "lyrics" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_LYRICS }, .unit = "flags" },
3156 { "karaoke" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_KARAOKE }, .unit = "flags" },
3157 { "forced" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_FORCED }, .unit = "flags" },
3158 { "hearing_impaired" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_HEARING_IMPAIRED }, .unit = "flags" },
3159 { "visual_impaired" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_VISUAL_IMPAIRED }, .unit = "flags" },
3160 { "clean_effects" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CLEAN_EFFECTS }, .unit = "flags" },
3161 { "captions" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CAPTIONS }, .unit = "flags" },
3162 { "descriptions" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DESCRIPTIONS }, .unit = "flags" },
3163 { "metadata" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_METADATA }, .unit = "flags" },
3166 static const AVClass class = {
3168 .item_name = av_default_item_name,
3170 .version = LIBAVUTIL_VERSION_INT,
3172 const AVClass *pclass = &class;
3174 ret = av_opt_eval_flags(&pclass, &opts[0], ost->disposition, &ost->st->disposition);
3180 /* open each encoder */
3181 for (i = 0; i < nb_output_streams; i++) {
3182 ret = init_output_stream(output_streams[i], error, sizeof(error));
3187 /* init input streams */
3188 for (i = 0; i < nb_input_streams; i++)
3189 if ((ret = init_input_stream(i, error, sizeof(error))) < 0) {
3190 for (i = 0; i < nb_output_streams; i++) {
3191 ost = output_streams[i];
3192 avcodec_close(ost->enc_ctx);
3197 /* discard unused programs */
3198 for (i = 0; i < nb_input_files; i++) {
3199 InputFile *ifile = input_files[i];
3200 for (j = 0; j < ifile->ctx->nb_programs; j++) {
3201 AVProgram *p = ifile->ctx->programs[j];
3202 int discard = AVDISCARD_ALL;
3204 for (k = 0; k < p->nb_stream_indexes; k++)
3205 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3206 discard = AVDISCARD_DEFAULT;
3209 p->discard = discard;
3213 /* open files and write file headers */
3214 for (i = 0; i < nb_output_files; i++) {
3215 oc = output_files[i]->ctx;
3216 oc->interrupt_callback = int_cb;
3217 if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
3218 snprintf(error, sizeof(error),
3219 "Could not write header for output file #%d "
3220 "(incorrect codec parameters ?): %s",
3221 i, av_err2str(ret));
3222 ret = AVERROR(EINVAL);
3225 // assert_avoptions(output_files[i]->opts);
3226 if (strcmp(oc->oformat->name, "rtp")) {
3232 /* dump the file output parameters - cannot be done before in case
3234 for (i = 0; i < nb_output_files; i++) {
3235 av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3238 /* dump the stream mapping */
3239 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3240 for (i = 0; i < nb_input_streams; i++) {
3241 ist = input_streams[i];
3243 for (j = 0; j < ist->nb_filters; j++) {
3244 if (ist->filters[j]->graph->graph_desc) {
3245 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
3246 ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3247 ist->filters[j]->name);
3248 if (nb_filtergraphs > 1)
3249 av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3250 av_log(NULL, AV_LOG_INFO, "\n");
3255 for (i = 0; i < nb_output_streams; i++) {
3256 ost = output_streams[i];
3258 if (ost->attachment_filename) {
3259 /* an attached file */
3260 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
3261 ost->attachment_filename, ost->file_index, ost->index);
3265 if (ost->filter && ost->filter->graph->graph_desc) {
3266 /* output from a complex graph */
3267 av_log(NULL, AV_LOG_INFO, " %s", ost->filter->name);
3268 if (nb_filtergraphs > 1)
3269 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3271 av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3272 ost->index, ost->enc ? ost->enc->name : "?");
3276 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
3277 input_streams[ost->source_index]->file_index,
3278 input_streams[ost->source_index]->st->index,
3281 if (ost->sync_ist != input_streams[ost->source_index])
3282 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3283 ost->sync_ist->file_index,
3284 ost->sync_ist->st->index);
3285 if (ost->stream_copy)
3286 av_log(NULL, AV_LOG_INFO, " (copy)");
3288 const AVCodec *in_codec = input_streams[ost->source_index]->dec;
3289 const AVCodec *out_codec = ost->enc;
3290 const char *decoder_name = "?";
3291 const char *in_codec_name = "?";
3292 const char *encoder_name = "?";
3293 const char *out_codec_name = "?";
3294 const AVCodecDescriptor *desc;
3297 decoder_name = in_codec->name;
3298 desc = avcodec_descriptor_get(in_codec->id);
3300 in_codec_name = desc->name;
3301 if (!strcmp(decoder_name, in_codec_name))
3302 decoder_name = "native";
3306 encoder_name = out_codec->name;
3307 desc = avcodec_descriptor_get(out_codec->id);
3309 out_codec_name = desc->name;
3310 if (!strcmp(encoder_name, out_codec_name))
3311 encoder_name = "native";
3314 av_log(NULL, AV_LOG_INFO, " (%s (%s) -> %s (%s))",
3315 in_codec_name, decoder_name,
3316 out_codec_name, encoder_name);
3318 av_log(NULL, AV_LOG_INFO, "\n");
3322 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3326 if (sdp_filename || want_sdp) {
3330 transcode_init_done = 1;
3335 /* Return 1 if there remain streams where more output is wanted, 0 otherwise. */
3336 static int need_output(void)
3340 for (i = 0; i < nb_output_streams; i++) {
3341 OutputStream *ost = output_streams[i];
3342 OutputFile *of = output_files[ost->file_index];
3343 AVFormatContext *os = output_files[ost->file_index]->ctx;
3345 if (ost->finished ||
3346 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3348 if (ost->frame_number >= ost->max_frames) {
3350 for (j = 0; j < of->ctx->nb_streams; j++)
3351 close_output_stream(output_streams[of->ost_index + j]);
3362 * Select the output stream to process.
3364 * @return selected output stream, or NULL if none available
3366 static OutputStream *choose_output(void)
3369 int64_t opts_min = INT64_MAX;
3370 OutputStream *ost_min = NULL;
3372 for (i = 0; i < nb_output_streams; i++) {
3373 OutputStream *ost = output_streams[i];
3374 int64_t opts = av_rescale_q(ost->st->cur_dts, ost->st->time_base,
3376 if (!ost->finished && opts < opts_min) {
3378 ost_min = ost->unavailable ? NULL : ost;
3384 static int check_keyboard_interaction(int64_t cur_time)
3387 static int64_t last_time;
3388 if (received_nb_signals)
3389 return AVERROR_EXIT;
3390 /* read_key() returns 0 on EOF */
3391 if(cur_time - last_time >= 100000 && !run_as_daemon){
3393 last_time = cur_time;
3397 return AVERROR_EXIT;
3398 if (key == '+') av_log_set_level(av_log_get_level()+10);
3399 if (key == '-') av_log_set_level(av_log_get_level()-10);
3400 if (key == 's') qp_hist ^= 1;
3403 do_hex_dump = do_pkt_dump = 0;
3404 } else if(do_pkt_dump){
3408 av_log_set_level(AV_LOG_DEBUG);
3410 if (key == 'c' || key == 'C'){
3411 char buf[4096], target[64], command[256], arg[256] = {0};
3414 fprintf(stderr, "\nEnter command: <target>|all <time>|-1 <command>[ <argument>]\n");
3416 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3421 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3422 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3423 target, time, command, arg);
3424 for (i = 0; i < nb_filtergraphs; i++) {
3425 FilterGraph *fg = filtergraphs[i];
3428 ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3429 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3430 fprintf(stderr, "Command reply for stream %d: ret:%d res:\n%s", i, ret, buf);
3431 } else if (key == 'c') {
3432 fprintf(stderr, "Queing commands only on filters supporting the specific command is unsupported\n");
3433 ret = AVERROR_PATCHWELCOME;
3435 ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3437 fprintf(stderr, "Queing command failed with error %s\n", av_err2str(ret));
3442 av_log(NULL, AV_LOG_ERROR,
3443 "Parse error, at least 3 arguments were expected, "
3444 "only %d given in string '%s'\n", n, buf);
3447 if (key == 'd' || key == 'D'){
3450 debug = input_streams[0]->st->codec->debug<<1;
3451 if(!debug) debug = 1;
3452 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3458 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3462 if (k <= 0 || sscanf(buf, "%d", &debug)!=1)
3463 fprintf(stderr,"error parsing debug value\n");
3465 for(i=0;i<nb_input_streams;i++) {
3466 input_streams[i]->st->codec->debug = debug;
3468 for(i=0;i<nb_output_streams;i++) {
3469 OutputStream *ost = output_streams[i];
3470 ost->enc_ctx->debug = debug;
3472 if(debug) av_log_set_level(AV_LOG_DEBUG);
3473 fprintf(stderr,"debug=%d\n", debug);
3476 fprintf(stderr, "key function\n"
3477 "? show this help\n"
3478 "+ increase verbosity\n"
3479 "- decrease verbosity\n"
3480 "c Send command to first matching filter supporting it\n"
3481 "C Send/Que command to all matching filters\n"
3482 "D cycle through available debug modes\n"
3483 "h dump packets/hex press to cycle through the 3 states\n"
3485 "s Show QP histogram\n"
3492 static void *input_thread(void *arg)
3495 unsigned flags = f->non_blocking ? AV_THREAD_MESSAGE_NONBLOCK : 0;
3500 ret = av_read_frame(f->ctx, &pkt);
3502 if (ret == AVERROR(EAGAIN)) {
3507 av_thread_message_queue_set_err_recv(f->in_thread_queue, ret);
3510 ret = av_thread_message_queue_send(f->in_thread_queue, &pkt, flags);
3511 if (flags && ret == AVERROR(EAGAIN)) {
3513 ret = av_thread_message_queue_send(f->in_thread_queue, &pkt, flags);
3514 av_log(f->ctx, AV_LOG_WARNING,
3515 "Thread message queue blocking; consider raising the "
3516 "thread_queue_size option (current value: %d)\n",
3517 f->thread_queue_size);
3520 if (ret != AVERROR_EOF)
3521 av_log(f->ctx, AV_LOG_ERROR,
3522 "Unable to send packet to main thread: %s\n",
3524 av_packet_unref(&pkt);
3525 av_thread_message_queue_set_err_recv(f->in_thread_queue, ret);
3533 static void free_input_threads(void)
3537 for (i = 0; i < nb_input_files; i++) {
3538 InputFile *f = input_files[i];
3541 if (!f || !f->in_thread_queue)
3543 av_thread_message_queue_set_err_send(f->in_thread_queue, AVERROR_EOF);
3544 while (av_thread_message_queue_recv(f->in_thread_queue, &pkt, 0) >= 0)
3545 av_packet_unref(&pkt);
3547 pthread_join(f->thread, NULL);
3549 av_thread_message_queue_free(&f->in_thread_queue);
3553 static int init_input_threads(void)
3557 if (nb_input_files == 1)
3560 for (i = 0; i < nb_input_files; i++) {
3561 InputFile *f = input_files[i];
3563 if (f->ctx->pb ? !f->ctx->pb->seekable :
3564 strcmp(f->ctx->iformat->name, "lavfi"))
3565 f->non_blocking = 1;
3566 ret = av_thread_message_queue_alloc(&f->in_thread_queue,
3567 f->thread_queue_size, sizeof(AVPacket));
3571 if ((ret = pthread_create(&f->thread, NULL, input_thread, f))) {
3572 av_log(NULL, AV_LOG_ERROR, "pthread_create failed: %s. Try to increase `ulimit -v` or decrease `ulimit -s`.\n", strerror(ret));
3573 av_thread_message_queue_free(&f->in_thread_queue);
3574 return AVERROR(ret);
3580 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
3582 return av_thread_message_queue_recv(f->in_thread_queue, pkt,
3584 AV_THREAD_MESSAGE_NONBLOCK : 0);
3588 static int get_input_packet(InputFile *f, AVPacket *pkt)
3592 for (i = 0; i < f->nb_streams; i++) {
3593 InputStream *ist = input_streams[f->ist_index + i];
3594 int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
3595 int64_t now = av_gettime_relative() - ist->start;
3597 return AVERROR(EAGAIN);
3602 if (nb_input_files > 1)
3603 return get_input_packet_mt(f, pkt);
3605 return av_read_frame(f->ctx, pkt);
3608 static int got_eagain(void)
3611 for (i = 0; i < nb_output_streams; i++)
3612 if (output_streams[i]->unavailable)
3617 static void reset_eagain(void)
3620 for (i = 0; i < nb_input_files; i++)
3621 input_files[i]->eagain = 0;
3622 for (i = 0; i < nb_output_streams; i++)
3623 output_streams[i]->unavailable = 0;
3626 // set duration to max(tmp, duration) in a proper time base and return duration's time_base
3627 static AVRational duration_max(int64_t tmp, int64_t *duration, AVRational tmp_time_base,
3628 AVRational time_base)
3634 return tmp_time_base;
3637 ret = av_compare_ts(*duration, time_base, tmp, tmp_time_base);
3640 return tmp_time_base;
3646 static int seek_to_start(InputFile *ifile, AVFormatContext *is)
3649 AVCodecContext *avctx;
3650 int i, ret, has_audio = 0;
3651 int64_t duration = 0;
3653 ret = av_seek_frame(is, -1, is->start_time, 0);
3657 for (i = 0; i < ifile->nb_streams; i++) {
3658 ist = input_streams[ifile->ist_index + i];
3659 avctx = ist->dec_ctx;
3662 if (ist->decoding_needed) {
3663 process_input_packet(ist, NULL, 1);
3664 avcodec_flush_buffers(avctx);
3667 /* duration is the length of the last frame in a stream
3668 * when audio stream is present we don't care about
3669 * last video frame length because it's not defined exactly */
3670 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && ist->nb_samples)
3674 for (i = 0; i < ifile->nb_streams; i++) {
3675 ist = input_streams[ifile->ist_index + i];
3676 avctx = ist->dec_ctx;
3679 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && ist->nb_samples) {
3680 AVRational sample_rate = {1, avctx->sample_rate};
3682 duration = av_rescale_q(ist->nb_samples, sample_rate, ist->st->time_base);
3686 if (ist->framerate.num) {
3687 duration = av_rescale_q(1, ist->framerate, ist->st->time_base);
3688 } else if (ist->st->avg_frame_rate.num) {
3689 duration = av_rescale_q(1, ist->st->avg_frame_rate, ist->st->time_base);
3690 } else duration = 1;
3692 if (!ifile->duration)
3693 ifile->time_base = ist->st->time_base;
3694 /* the total duration of the stream, max_pts - min_pts is
3695 * the duration of the stream without the last frame */
3696 duration += ist->max_pts - ist->min_pts;
3697 ifile->time_base = duration_max(duration, &ifile->duration, ist->st->time_base,
3708 * - 0 -- one packet was read and processed
3709 * - AVERROR(EAGAIN) -- no packets were available for selected file,
3710 * this function should be called again
3711 * - AVERROR_EOF -- this function should not be called again
3713 static int process_input(int file_index)
3715 InputFile *ifile = input_files[file_index];
3716 AVFormatContext *is;
3723 ret = get_input_packet(ifile, &pkt);
3725 if (ret == AVERROR(EAGAIN)) {
3729 if ((ret < 0) && (ifile->loop > 1)) {
3730 if ((ret = seek_to_start(ifile, is)) < 0)
3732 ret = get_input_packet(ifile, &pkt);
3735 if (ret != AVERROR_EOF) {
3736 print_error(is->filename, ret);
3741 for (i = 0; i < ifile->nb_streams; i++) {
3742 ist = input_streams[ifile->ist_index + i];
3743 if (ist->decoding_needed) {
3744 ret = process_input_packet(ist, NULL, 0);
3749 /* mark all outputs that don't go through lavfi as finished */
3750 for (j = 0; j < nb_output_streams; j++) {
3751 OutputStream *ost = output_streams[j];
3753 if (ost->source_index == ifile->ist_index + i &&
3754 (ost->stream_copy || ost->enc->type == AVMEDIA_TYPE_SUBTITLE))
3755 finish_output_stream(ost);
3759 ifile->eof_reached = 1;
3760 return AVERROR(EAGAIN);
3766 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3767 is->streams[pkt.stream_index]);
3769 /* the following test is needed in case new streams appear
3770 dynamically in stream : we ignore them */
3771 if (pkt.stream_index >= ifile->nb_streams) {
3772 report_new_stream(file_index, &pkt);
3773 goto discard_packet;
3776 ist = input_streams[ifile->ist_index + pkt.stream_index];
3778 ist->data_size += pkt.size;
3782 goto discard_packet;
3784 if (exit_on_error && (pkt.flags & AV_PKT_FLAG_CORRUPT)) {
3785 av_log(NULL, AV_LOG_FATAL, "%s: corrupt input packet in stream %d\n", is->filename, pkt.stream_index);
3790 av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3791 "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",
3792 ifile->ist_index + pkt.stream_index, av_get_media_type_string(ist->dec_ctx->codec_type),
3793 av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &AV_TIME_BASE_Q),
3794 av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &AV_TIME_BASE_Q),
3795 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3796 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3797 av_ts2str(input_files[ist->file_index]->ts_offset),
3798 av_ts2timestr(input_files[ist->file_index]->ts_offset, &AV_TIME_BASE_Q));
3801 if(!ist->wrap_correction_done && is->start_time != AV_NOPTS_VALUE && ist->st->pts_wrap_bits < 64){
3802 int64_t stime, stime2;
3803 // Correcting starttime based on the enabled streams
3804 // 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.
3805 // so we instead do it here as part of discontinuity handling
3806 if ( ist->next_dts == AV_NOPTS_VALUE
3807 && ifile->ts_offset == -is->start_time
3808 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
3809 int64_t new_start_time = INT64_MAX;
3810 for (i=0; i<is->nb_streams; i++) {
3811 AVStream *st = is->streams[i];
3812 if(st->discard == AVDISCARD_ALL || st->start_time == AV_NOPTS_VALUE)
3814 new_start_time = FFMIN(new_start_time, av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q));
3816 if (new_start_time > is->start_time) {
3817 av_log(is, AV_LOG_VERBOSE, "Correcting start time by %"PRId64"\n", new_start_time - is->start_time);
3818 ifile->ts_offset = -new_start_time;
3822 stime = av_rescale_q(is->start_time, AV_TIME_BASE_Q, ist->st->time_base);
3823 stime2= stime + (1ULL<<ist->st->pts_wrap_bits);
3824 ist->wrap_correction_done = 1;
3826 if(stime2 > stime && pkt.dts != AV_NOPTS_VALUE && pkt.dts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
3827 pkt.dts -= 1ULL<<ist->st->pts_wrap_bits;
3828 ist->wrap_correction_done = 0;
3830 if(stime2 > stime && pkt.pts != AV_NOPTS_VALUE && pkt.pts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
3831 pkt.pts -= 1ULL<<ist->st->pts_wrap_bits;
3832 ist->wrap_correction_done = 0;
3836 /* add the stream-global side data to the first packet */
3837 if (ist->nb_packets == 1) {
3838 if (ist->st->nb_side_data)
3839 av_packet_split_side_data(&pkt);
3840 for (i = 0; i < ist->st->nb_side_data; i++) {
3841 AVPacketSideData *src_sd = &ist->st->side_data[i];
3844 if (av_packet_get_side_data(&pkt, src_sd->type, NULL))
3846 if (ist->autorotate && src_sd->type == AV_PKT_DATA_DISPLAYMATRIX)
3849 dst_data = av_packet_new_side_data(&pkt, src_sd->type, src_sd->size);
3853 memcpy(dst_data, src_sd->data, src_sd->size);
3857 if (pkt.dts != AV_NOPTS_VALUE)
3858 pkt.dts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3859 if (pkt.pts != AV_NOPTS_VALUE)
3860 pkt.pts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3862 if (pkt.pts != AV_NOPTS_VALUE)
3863 pkt.pts *= ist->ts_scale;
3864 if (pkt.dts != AV_NOPTS_VALUE)
3865 pkt.dts *= ist->ts_scale;
3867 if ((ist->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3868 ist->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) &&
3869 pkt.dts != AV_NOPTS_VALUE && ist->next_dts == AV_NOPTS_VALUE && !copy_ts
3870 && (is->iformat->flags & AVFMT_TS_DISCONT) && ifile->last_ts != AV_NOPTS_VALUE) {
3871 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3872 int64_t delta = pkt_dts - ifile->last_ts;
3873 if (delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3874 delta > 1LL*dts_delta_threshold*AV_TIME_BASE){
3875 ifile->ts_offset -= delta;
3876 av_log(NULL, AV_LOG_DEBUG,
3877 "Inter stream timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3878 delta, ifile->ts_offset);
3879 pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3880 if (pkt.pts != AV_NOPTS_VALUE)
3881 pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3885 duration = av_rescale_q(ifile->duration, ifile->time_base, ist->st->time_base);
3886 if (pkt.pts != AV_NOPTS_VALUE) {
3887 pkt.pts += duration;
3888 ist->max_pts = FFMAX(pkt.pts, ist->max_pts);
3889 ist->min_pts = FFMIN(pkt.pts, ist->min_pts);
3892 if (pkt.dts != AV_NOPTS_VALUE)
3893 pkt.dts += duration;
3895 if ((ist->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3896 ist->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) &&
3897 pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE &&
3899 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3900 int64_t delta = pkt_dts - ist->next_dts;
3901 if (is->iformat->flags & AVFMT_TS_DISCONT) {
3902 if (delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3903 delta > 1LL*dts_delta_threshold*AV_TIME_BASE ||
3904 pkt_dts + AV_TIME_BASE/10 < FFMAX(ist->pts, ist->dts)) {
3905 ifile->ts_offset -= delta;
3906 av_log(NULL, AV_LOG_DEBUG,
3907 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3908 delta, ifile->ts_offset);
3909 pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3910 if (pkt.pts != AV_NOPTS_VALUE)
3911 pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3914 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3915 delta > 1LL*dts_error_threshold*AV_TIME_BASE) {
3916 av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3917 pkt.dts = AV_NOPTS_VALUE;
3919 if (pkt.pts != AV_NOPTS_VALUE){
3920 int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3921 delta = pkt_pts - ist->next_dts;
3922 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3923 delta > 1LL*dts_error_threshold*AV_TIME_BASE) {
3924 av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3925 pkt.pts = AV_NOPTS_VALUE;
3931 if (pkt.dts != AV_NOPTS_VALUE)
3932 ifile->last_ts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3935 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",
3936 ifile->ist_index + pkt.stream_index, av_get_media_type_string(ist->dec_ctx->codec_type),
3937 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3938 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3939 av_ts2str(input_files[ist->file_index]->ts_offset),
3940 av_ts2timestr(input_files[ist->file_index]->ts_offset, &AV_TIME_BASE_Q));
3943 sub2video_heartbeat(ist, pkt.pts);
3945 process_input_packet(ist, &pkt, 0);
3948 av_packet_unref(&pkt);
3954 * Perform a step of transcoding for the specified filter graph.
3956 * @param[in] graph filter graph to consider
3957 * @param[out] best_ist input stream where a frame would allow to continue
3958 * @return 0 for success, <0 for error
3960 static int transcode_from_filter(FilterGraph *graph, InputStream **best_ist)
3963 int nb_requests, nb_requests_max = 0;
3964 InputFilter *ifilter;
3968 ret = avfilter_graph_request_oldest(graph->graph);
3970 return reap_filters(0);
3972 if (ret == AVERROR_EOF) {
3973 ret = reap_filters(1);
3974 for (i = 0; i < graph->nb_outputs; i++)
3975 close_output_stream(graph->outputs[i]->ost);
3978 if (ret != AVERROR(EAGAIN))
3981 for (i = 0; i < graph->nb_inputs; i++) {
3982 ifilter = graph->inputs[i];
3984 if (input_files[ist->file_index]->eagain ||
3985 input_files[ist->file_index]->eof_reached)
3987 nb_requests = av_buffersrc_get_nb_failed_requests(ifilter->filter);
3988 if (nb_requests > nb_requests_max) {
3989 nb_requests_max = nb_requests;
3995 for (i = 0; i < graph->nb_outputs; i++)
3996 graph->outputs[i]->ost->unavailable = 1;
4002 * Run a single step of transcoding.
4004 * @return 0 for success, <0 for error
4006 static int transcode_step(void)
4012 ost = choose_output();
4019 av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
4024 if ((ret = transcode_from_filter(ost->filter->graph, &ist)) < 0)
4029 av_assert0(ost->source_index >= 0);
4030 ist = input_streams[ost->source_index];
4033 ret = process_input(ist->file_index);
4034 if (ret == AVERROR(EAGAIN)) {
4035 if (input_files[ist->file_index]->eagain)
4036 ost->unavailable = 1;
4041 return ret == AVERROR_EOF ? 0 : ret;
4043 return reap_filters(0);
4047 * The following code is the main loop of the file converter
4049 static int transcode(void)
4052 AVFormatContext *os;
4055 int64_t timer_start;
4056 int64_t total_packets_written = 0;
4058 ret = transcode_init();
4062 if (stdin_interaction) {
4063 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
4066 timer_start = av_gettime_relative();
4069 if ((ret = init_input_threads()) < 0)
4073 while (!received_sigterm) {
4074 int64_t cur_time= av_gettime_relative();
4076 /* if 'q' pressed, exits */
4077 if (stdin_interaction)
4078 if (check_keyboard_interaction(cur_time) < 0)
4081 /* check if there's any stream where output is still needed */
4082 if (!need_output()) {
4083 av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
4087 ret = transcode_step();
4089 if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN)) {
4093 av_strerror(ret, errbuf, sizeof(errbuf));
4095 av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", errbuf);
4100 /* dump report by using the output first video and audio streams */
4101 print_report(0, timer_start, cur_time);
4104 free_input_threads();
4107 /* at the end of stream, we must flush the decoder buffers */
4108 for (i = 0; i < nb_input_streams; i++) {
4109 ist = input_streams[i];
4110 if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
4111 process_input_packet(ist, NULL, 0);
4118 /* write the trailer if needed and close file */
4119 for (i = 0; i < nb_output_files; i++) {
4120 os = output_files[i]->ctx;
4121 if ((ret = av_write_trailer(os)) < 0) {
4122 av_log(NULL, AV_LOG_ERROR, "Error writing trailer of %s: %s", os->filename, av_err2str(ret));
4128 /* dump report by using the first video and audio streams */
4129 print_report(1, timer_start, av_gettime_relative());
4131 /* close each encoder */
4132 for (i = 0; i < nb_output_streams; i++) {
4133 ost = output_streams[i];
4134 if (ost->encoding_needed) {
4135 av_freep(&ost->enc_ctx->stats_in);
4137 total_packets_written += ost->packets_written;
4140 if (!total_packets_written && (abort_on_flags & ABORT_ON_FLAG_EMPTY_OUTPUT)) {
4141 av_log(NULL, AV_LOG_FATAL, "Empty output\n");
4145 /* close each decoder */
4146 for (i = 0; i < nb_input_streams; i++) {
4147 ist = input_streams[i];
4148 if (ist->decoding_needed) {
4149 avcodec_close(ist->dec_ctx);
4150 if (ist->hwaccel_uninit)
4151 ist->hwaccel_uninit(ist->dec_ctx);
4160 free_input_threads();
4163 if (output_streams) {
4164 for (i = 0; i < nb_output_streams; i++) {
4165 ost = output_streams[i];
4168 fclose(ost->logfile);
4169 ost->logfile = NULL;
4171 av_freep(&ost->forced_kf_pts);
4172 av_freep(&ost->apad);
4173 av_freep(&ost->disposition);
4174 av_dict_free(&ost->encoder_opts);
4175 av_dict_free(&ost->sws_dict);
4176 av_dict_free(&ost->swr_opts);
4177 av_dict_free(&ost->resample_opts);
4178 av_dict_free(&ost->bsf_args);
4186 static int64_t getutime(void)
4189 struct rusage rusage;
4191 getrusage(RUSAGE_SELF, &rusage);
4192 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4193 #elif HAVE_GETPROCESSTIMES
4195 FILETIME c, e, k, u;
4196 proc = GetCurrentProcess();
4197 GetProcessTimes(proc, &c, &e, &k, &u);
4198 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4200 return av_gettime_relative();
4204 static int64_t getmaxrss(void)
4206 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4207 struct rusage rusage;
4208 getrusage(RUSAGE_SELF, &rusage);
4209 return (int64_t)rusage.ru_maxrss * 1024;
4210 #elif HAVE_GETPROCESSMEMORYINFO
4212 PROCESS_MEMORY_COUNTERS memcounters;
4213 proc = GetCurrentProcess();
4214 memcounters.cb = sizeof(memcounters);
4215 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4216 return memcounters.PeakPagefileUsage;
4222 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4226 int main(int argc, char **argv)
4231 register_exit(ffmpeg_cleanup);
4233 setvbuf(stderr,NULL,_IONBF,0); /* win32 runtime needs this */
4235 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4236 parse_loglevel(argc, argv, options);
4238 if(argc>1 && !strcmp(argv[1], "-d")){
4240 av_log_set_callback(log_callback_null);
4245 avcodec_register_all();
4247 avdevice_register_all();
4249 avfilter_register_all();
4251 avformat_network_init();
4253 show_banner(argc, argv, options);
4257 /* parse options and open all input/output files */
4258 ret = ffmpeg_parse_options(argc, argv);
4262 if (nb_output_files <= 0 && nb_input_files == 0) {
4264 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4268 /* file converter / grab */
4269 if (nb_output_files <= 0) {
4270 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4274 // if (nb_input_files == 0) {
4275 // av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4279 current_time = ti = getutime();
4280 if (transcode() < 0)
4282 ti = getutime() - ti;
4284 av_log(NULL, AV_LOG_INFO, "bench: utime=%0.3fs\n", ti / 1000000.0);
4286 av_log(NULL, AV_LOG_DEBUG, "%"PRIu64" frames successfully decoded, %"PRIu64" decoding errors\n",
4287 decode_error_stat[0], decode_error_stat[1]);
4288 if ((decode_error_stat[0] + decode_error_stat[1]) * max_error_rate < decode_error_stat[1])
4291 exit_program(received_nb_signals ? 255 : main_return_code);
4292 return main_return_code;