X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=nageru%2Fffmpeg_capture.cpp;h=5cf1d8c9ec75f35a6932a6bd7a282914c3017d92;hb=cb1dcf409cde897b011e9d9d3cd3cf2974956190;hp=504eff24f59d5bc7bfa5ceda9345f92ffce8785f;hpb=ba3ea588faa8e7908bce832820c08e43a09863fe;p=nageru diff --git a/nageru/ffmpeg_capture.cpp b/nageru/ffmpeg_capture.cpp index 504eff2..5cf1d8c 100644 --- a/nageru/ffmpeg_capture.cpp +++ b/nageru/ffmpeg_capture.cpp @@ -26,6 +26,7 @@ extern "C" { #include #include #include +#include #include #include @@ -454,24 +455,63 @@ 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); + if (ctx->profile == FF_PROFILE_H264_BASELINE) { + fprintf(stderr, "WARNING: Stream claims to be H.264 Baseline, which is generally poorly supported in hardware decoders.\n"); + fprintf(stderr, " Consider encoding it as Constrained Baseline, Main or High instead.\n"); + fprintf(stderr, " Decoding might fail and fall back to software.\n"); + } 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)); + } - // We found no VA-API formats, so take the best software format. + 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 first software format. + for (const AVPixelFormat *fmt_ptr = fmt; *fmt_ptr != -1; ++fmt_ptr) { + if ((av_pix_fmt_desc_get(*fmt_ptr)->flags & AV_PIX_FMT_FLAG_HWACCEL) == 0) { + fprintf(stderr, "Falling back to software format %s.\n", av_get_pix_fmt_name(*fmt_ptr)); + return *fmt_ptr; + } + } + + // Fallback: Just return anything. (Should never really happen.) return fmt[0]; } @@ -544,14 +584,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) { @@ -591,6 +641,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; @@ -607,7 +658,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. @@ -891,7 +949,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.)