X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=nageru%2Fffmpeg_capture.cpp;h=863f4fba4feaecc40b14d07b4662a04740c1894c;hb=3fb867fa45d24d5f67ee1b070533f46c1f1f5462;hp=a8b6f612a06a470eb7427648497dffc4aaf47295;hpb=9948aa3cbbf9e0eaa7e0f92852498195e287e235;p=nageru diff --git a/nageru/ffmpeg_capture.cpp b/nageru/ffmpeg_capture.cpp index a8b6f61..863f4fb 100644 --- a/nageru/ffmpeg_capture.cpp +++ b/nageru/ffmpeg_capture.cpp @@ -26,6 +26,7 @@ extern "C" { #include #include #include +#include #include #include @@ -438,9 +439,11 @@ void FFmpegCapture::send_disconnected_frame() memset(video_frame.data + frame_width * frame_height, 128, frame_width * frame_height); // Valid for both NV12 and planar. } - frame_callback(-1, AVRational{1, TIMEBASE}, -1, AVRational{1, TIMEBASE}, timecode++, - video_frame, /*video_offset=*/0, video_format, - FrameAllocator::Frame(), /*audio_offset=*/0, AudioFormat()); + if (frame_callback != nullptr) { + frame_callback(-1, AVRational{1, TIMEBASE}, -1, AVRational{1, TIMEBASE}, timecode++, + video_frame, /*video_offset=*/0, video_format, + FrameAllocator::Frame(), /*audio_offset=*/0, AudioFormat()); + } last_frame_was_connected = false; } @@ -452,21 +455,47 @@ void FFmpegCapture::send_disconnected_frame() } } -AVPixelFormat get_vaapi_hw_format(AVCodecContext *ctx, const AVPixelFormat *fmt) +template +AVPixelFormat get_hw_format(AVCodecContext *ctx, const AVPixelFormat *fmt) { - for (const AVPixelFormat *fmt_ptr = fmt; *fmt_ptr != -1; ++fmt_ptr) { - for (int i = 0;; ++i) { // Termination condition inside loop. - const AVCodecHWConfig *config = avcodec_get_hw_config(ctx->codec, i); - if (config == nullptr) { // End of list. - fprintf(stderr, "Decoder %s does not support device.\n", ctx->codec->name); - break; - } - if (config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX && - config->device_type == AV_HWDEVICE_TYPE_VAAPI && - config->pix_fmt == *fmt_ptr) { + bool found_config_of_right_type = false; + for (int i = 0;; ++i) { // Termination condition inside loop. + const AVCodecHWConfig *config = avcodec_get_hw_config(ctx->codec, i); + if (config == nullptr) { // End of list. + break; + } + if (!(config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX) || + config->device_type != type) { + // Not interesting for us. + continue; + } + + // We have a config of the right type, but does it actually support + // the pixel format we want? (Seemingly, FFmpeg's way of signaling errors + // is to just replace the pixel format with a software-decoded one, + // such as yuv420p.) + found_config_of_right_type = true; + for (const AVPixelFormat *fmt_ptr = fmt; *fmt_ptr != -1; ++fmt_ptr) { + if (config->pix_fmt == *fmt_ptr) { + fprintf(stderr, "Initialized '%s' hardware decoding for codec '%s'.\n", + av_hwdevice_get_type_name(type), ctx->codec->name); return config->pix_fmt; } } + fprintf(stderr, "Decoder '%s' supports only these pixel formats:", ctx->codec->name); + unordered_set seen; + for (const AVPixelFormat *fmt_ptr = fmt; *fmt_ptr != -1; ++fmt_ptr) { + if (!seen.count(*fmt_ptr)) { + fprintf(stderr, " %s", av_get_pix_fmt_name(*fmt_ptr)); + seen.insert(*fmt_ptr); + } + } + fprintf(stderr, " (wanted %s for hardware acceleration)\n", av_get_pix_fmt_name(config->pix_fmt)); + + } + + if (!found_config_of_right_type) { + fprintf(stderr, "Decoder '%s' does not support device type '%s'.\n", ctx->codec->name, av_hwdevice_get_type_name(type)); } // We found no VA-API formats, so take the best software format. @@ -498,7 +527,7 @@ bool FFmpegCapture::play_video(const string &pathname) } else { #ifdef HAVE_SRT // SRT socket, already opened. - AVInputFormat *mpegts_fmt = av_find_input_format("mpegts"); + const AVInputFormat *mpegts_fmt = av_find_input_format("mpegts"); format_ctx = avformat_open_input_unique(&FFmpegCapture::read_srt_thunk, this, mpegts_fmt, /*options=*/nullptr, AVIOInterruptCB{ &FFmpegCapture::interrupt_cb_thunk, this }); @@ -528,7 +557,7 @@ bool FFmpegCapture::play_video(const string &pathname) // Open video decoder. const AVCodecParameters *video_codecpar = format_ctx->streams[video_stream_index]->codecpar; - AVCodec *video_codec = avcodec_find_decoder(video_codecpar->codec_id); + const AVCodec *video_codec = avcodec_find_decoder(video_codecpar->codec_id); video_timebase = format_ctx->streams[video_stream_index]->time_base; AVCodecContextWithDeleter video_codec_ctx = avcodec_alloc_context3_unique(nullptr); @@ -542,14 +571,24 @@ bool FFmpegCapture::play_video(const string &pathname) } // Seemingly, it's not too easy to make something that just initializes - // “whatever goes”, so we don't get VDPAU or CUDA here without enumerating - // through several different types. VA-API will do for now. + // “whatever goes”, so we don't get CUDA or VULKAN or whatever here + // without enumerating through several different types. + // VA-API and VDPAU will do for now. We prioritize VDPAU for the + // simple reason that there's a VA-API-via-VDPAU emulation for NVidia + // cards that seems to work, but just hangs when trying to transfer the frame. + // + // Note that we don't actually check codec support beforehand, + // so if you have a low-end VDPAU device but a high-end VA-API device, + // you lose out on the extra codec support from the latter. AVBufferRef *hw_device_ctx = nullptr; - if (av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI, nullptr, nullptr, 0) < 0) { - fprintf(stderr, "Failed to initialize VA-API for FFmpeg acceleration. Decoding video in software.\n"); - } else { + if (av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VDPAU, nullptr, nullptr, 0) >= 0) { video_codec_ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx); - video_codec_ctx->get_format = get_vaapi_hw_format; + video_codec_ctx->get_format = get_hw_format; + } else if (av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI, nullptr, nullptr, 0) >= 0) { + video_codec_ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx); + video_codec_ctx->get_format = get_hw_format; + } else { + fprintf(stderr, "Failed to initialize VA-API or VDPAU for FFmpeg acceleration. Decoding video in software.\n"); } if (avcodec_open2(video_codec_ctx.get(), video_codec, nullptr) < 0) { @@ -572,7 +611,7 @@ bool FFmpegCapture::play_video(const string &pathname) fprintf(stderr, "%s: Cannot fill audio codec parameters\n", pathname.c_str()); return false; } - AVCodec *audio_codec = avcodec_find_decoder(audio_codecpar->codec_id); + const AVCodec *audio_codec = avcodec_find_decoder(audio_codecpar->codec_id); if (audio_codec == nullptr) { fprintf(stderr, "%s: Cannot find audio decoder\n", pathname.c_str()); return false; @@ -589,6 +628,7 @@ bool FFmpegCapture::play_video(const string &pathname) // Main loop. bool first_frame = true; + int consecutive_errors = 0; while (!producer_thread_should_quit.should_quit()) { if (process_queued_commands(format_ctx.get(), pathname, last_modified, /*rewound=*/nullptr)) { return true; @@ -605,7 +645,14 @@ bool FFmpegCapture::play_video(const string &pathname) AVFrameWithDeleter frame = decode_frame(format_ctx.get(), video_codec_ctx.get(), audio_codec_ctx.get(), pathname, video_stream_index, audio_stream_index, subtitle_stream_index, audio_frame.get(), &audio_format, &audio_pts, &error); if (error) { - return false; + if (++consecutive_errors >= 100) { + fprintf(stderr, "More than 100 consecutive video frames, aborting playback.\n"); + return false; + } else { + continue; + } + } else { + consecutive_errors = 0; } if (frame == nullptr) { // EOF. Loop back to the start if we can. @@ -713,7 +760,7 @@ bool FFmpegCapture::play_video(const string &pathname) 1e3 * duration(now - next_frame_start).count()); pts_origin = frame->pts; start = next_frame_start = now; - timecode += MAX_FPS * 2 + 1; + timecode += TYPICAL_FPS * 2 + 1; } } bool finished_wakeup; @@ -731,12 +778,14 @@ bool FFmpegCapture::play_video(const string &pathname) // Make sure to get the audio resampler reset. (This is a hack; // ideally, the frame callback should just accept a way to signal // audio discontinuity.) - timecode += MAX_FPS * 2 + 1; + timecode += TYPICAL_FPS * 2 + 1; } last_neutral_color = get_neutral_color(frame->metadata); - frame_callback(frame->pts, video_timebase, audio_pts, audio_timebase, timecode++, - video_frame.get_and_release(), 0, video_format, - audio_frame.get_and_release(), 0, audio_format); + if (frame_callback != nullptr) { + frame_callback(frame->pts, video_timebase, audio_pts, audio_timebase, timecode++, + video_frame.get_and_release(), 0, video_format, + audio_frame.get_and_release(), 0, audio_format); + } first_frame = false; last_frame = steady_clock::now(); last_frame_was_connected = true; @@ -841,13 +890,16 @@ AVFrameWithDeleter FFmpegCapture::decode_frame(AVFormatContext *format_ctx, AVCo if (pkt.stream_index == audio_stream_index && audio_callback != nullptr) { audio_callback(&pkt, format_ctx->streams[audio_stream_index]->time_base); } - if (pkt.stream_index == video_stream_index) { + if (pkt.stream_index == video_stream_index && video_callback != nullptr) { + video_callback(&pkt, format_ctx->streams[video_stream_index]->time_base); + } + if (pkt.stream_index == video_stream_index && global_flags.transcode_video) { if (avcodec_send_packet(video_codec_ctx, &pkt) < 0) { fprintf(stderr, "%s: Cannot send packet to video codec.\n", pathname.c_str()); *error = true; return AVFrameWithDeleter(nullptr); } - } else if (pkt.stream_index == audio_stream_index) { + } else if (pkt.stream_index == audio_stream_index && global_flags.transcode_audio) { has_audio = true; if (avcodec_send_packet(audio_codec_ctx, &pkt) < 0) { fprintf(stderr, "%s: Cannot send packet to audio codec.\n", pathname.c_str()); @@ -884,7 +936,8 @@ AVFrameWithDeleter FFmpegCapture::decode_frame(AVFormatContext *format_ctx, AVCo // Decode video, if we have a frame. int err = avcodec_receive_frame(video_codec_ctx, video_avframe.get()); if (err == 0) { - if (video_avframe->format == AV_PIX_FMT_VAAPI) { + if (video_avframe->format == AV_PIX_FMT_VAAPI || + video_avframe->format == AV_PIX_FMT_VDPAU) { // Get the frame down to the CPU. (TODO: See if we can keep it // on the GPU all the way, since it will be going up again later. // However, this only works if the OpenGL GPU is the same one.)