mxvk_ff_capture.cpp

Go to the documentation of this file.

/**
 * @file mxvk_ff_capture.cpp
 * @brief Implementation of mxvk::VK_FF_Capture.
 */
#include "mxvk/mxvk_ff_capture.hpp"
#include "mxvk/mxvk_opencv_compat.hpp"
 
#include <algorithm>
#include <cstring>
#include <format>
#include <iostream>
#ifdef MXVK_CUDA
#include <cuda_runtime_api.h>
#include <opencv2/cudaarithm.hpp>
#ifdef MXVK_CUDA_NPP
#include <nppi_color_conversion.h>
#include <nppi_data_exchange_and_initialization.h>
#endif
#endif
 
namespace mxvk {
 
    namespace {
        [[nodiscard]] double rationalToDouble(AVRational rational) {
            if (rational.num <= 0 || rational.den <= 0) {
                return 0.0;
            }
            return av_q2d(rational);
        }
 
        [[nodiscard]] bool convertBt2020Yuv10LimitedToRgba16(const AVFrame *source, std::vector<uint16_t> &rgba, int &width, int &height, int &pitch, bool flipY) {
            if (source == nullptr || source->data[0] == nullptr || source->data[1] == nullptr) {
                return false;
            }
            const bool p010 = source->format == AV_PIX_FMT_P010LE;
            if (!p010 && (source->format != AV_PIX_FMT_YUV420P10LE || source->data[2] == nullptr)) {
                return false;
            }
 
            width = source->width;
            height = source->height;
            pitch = width * 8;
            if (width <= 0 || height <= 0) {
                return false;
            }
            rgba.resize(static_cast<size_t>(width) * static_cast<size_t>(height) * 4U);
 
            const int sampleShift = p010 ? 6 : 0;
            const auto sample10 = [sampleShift](const uint8_t *plane, int stride, int x, int y) {
                uint16_t raw = 0;
                std::memcpy(&raw, plane + static_cast<size_t>(y) * stride + static_cast<size_t>(x) * 2U, sizeof(raw));
                return static_cast<int>(raw >> sampleShift);
            };
 
            constexpr float CR_R = 1.4746F;
            constexpr float CB_G = -0.16455312684366F;
            constexpr float CR_G = -0.57135313725490F;
            constexpr float CB_B = 1.8814F;
            constexpr float INV_Y = 1.0F / 876.0F;
            constexpr float INV_C = 1.0F / 896.0F;
 
            for (int y = 0; y < height; ++y) {
                uint16_t *destination = rgba.data() + static_cast<size_t>(y) * width * 4U;
                const int chromaY = y >> 1;
                for (int x = 0; x < width; ++x) {
                    const int chromaX = x >> 1;
                    const int ySample = sample10(source->data[0], source->linesize[0], x, y);
                    int cbSample = 0;
                    int crSample = 0;
                    if (p010) {
                        cbSample = sample10(source->data[1], source->linesize[1], chromaX * 2, chromaY);
                        crSample = sample10(source->data[1], source->linesize[1], chromaX * 2 + 1, chromaY);
                    } else {
                        cbSample = sample10(source->data[1], source->linesize[1], chromaX, chromaY);
                        crSample = sample10(source->data[2], source->linesize[2], chromaX, chromaY);
                    }
 
                    const float yValue = (ySample - 64) * INV_Y;
                    const float cb = (cbSample - 512) * INV_C;
                    const float cr = (crSample - 512) * INV_C;
                    const float red = std::clamp(yValue + CR_R * cr, 0.0F, 1.0F);
                    const float green = std::clamp(yValue + CB_G * cb + CR_G * cr, 0.0F, 1.0F);
                    const float blue = std::clamp(yValue + CB_B * cb, 0.0F, 1.0F);
 
                    destination[x * 4 + 0] = static_cast<uint16_t>(red * 65535.0F + 0.5F);
                    destination[x * 4 + 1] = static_cast<uint16_t>(green * 65535.0F + 0.5F);
                    destination[x * 4 + 2] = static_cast<uint16_t>(blue * 65535.0F + 0.5F);
                    destination[x * 4 + 3] = UINT16_MAX;
                }
            }
 
            if (flipY) {
                std::vector<uint16_t> row(static_cast<size_t>(width) * 4U);
                for (int y = 0; y < height / 2; ++y) {
                    uint16_t *top = rgba.data() + static_cast<size_t>(y) * width * 4U;
                    uint16_t *bottom = rgba.data() + static_cast<size_t>(height - 1 - y) * width * 4U;
                    std::copy_n(top, row.size(), row.data());
                    std::copy_n(bottom, row.size(), top);
                    std::copy_n(row.data(), row.size(), bottom);
                }
            }
            return true;
        }
 
#if defined(MXVK_CUDA) && defined(MXVK_CUDA_NPP)
        [[nodiscard]] NppStreamContext makeNppStreamContext(cudaStream_t stream) {
            NppStreamContext context{};
            context.hStream = stream;
            cudaGetDevice(&context.nCudaDeviceId);
 
            cudaDeviceProp properties{};
            cudaGetDeviceProperties(&properties, context.nCudaDeviceId);
            context.nMultiProcessorCount = properties.multiProcessorCount;
            context.nMaxThreadsPerMultiProcessor = properties.maxThreadsPerMultiProcessor;
            context.nMaxThreadsPerBlock = properties.maxThreadsPerBlock;
            context.nSharedMemPerBlock = properties.sharedMemPerBlock;
 
            cudaDeviceGetAttribute(&context.nCudaDevAttrComputeCapabilityMajor, cudaDevAttrComputeCapabilityMajor, context.nCudaDeviceId);
            cudaDeviceGetAttribute(&context.nCudaDevAttrComputeCapabilityMinor, cudaDevAttrComputeCapabilityMinor, context.nCudaDeviceId);
            cudaStreamGetFlags(stream, &context.nStreamFlags);
            return context;
        }
#endif
    } // namespace
 
    VK_FF_Capture::~VK_FF_Capture() { close(); }
 
    bool VK_FF_Capture::open(const std::string &filename) { return open(filename, -1); }
 
    bool VK_FF_Capture::open(const std::string &filename, int cuda_device) {
        close();
 
        if (avformat_open_input(&formatCtx, filename.c_str(), nullptr, nullptr) < 0) {
            std::cout << std::format("mxvk_ff_capture: failed to open file: {}\n", filename);
            close();
            return false;
        }
 
        if (avformat_find_stream_info(formatCtx, nullptr) < 0) {
            std::cout << std::format("mxvk_ff_capture: failed to read stream info: {}\n", filename);
            close();
            return false;
        }
 
        const int streamIndex = av_find_best_stream(formatCtx, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
        if (streamIndex < 0) {
            std::cout << std::format("mxvk_ff_capture: no video stream found: {}\n", filename);
            close();
            return false;
        }
        videoStream = streamIndex;
 
        AVStream *stream = formatCtx->streams[videoStream];
        const AVCodecParameters *codecParams = stream->codecpar;
        const AVCodec *decoder = avcodec_find_decoder(codecParams->codec_id);
        if (decoder == nullptr) {
            std::cout << "mxvk_ff_capture: no decoder found for video stream\n";
            close();
            return false;
        }
 
        codecCtx = avcodec_alloc_context3(decoder);
        if (codecCtx == nullptr || avcodec_parameters_to_context(codecCtx, codecParams) < 0) {
            std::cout << "mxvk_ff_capture: failed to create decoder context\n";
            close();
            return false;
        }
 
        codecCtx->opaque = this;
        if (initHardwareDevice(decoder, cuda_device)) {
            codecCtx->get_format = &VK_FF_Capture::chooseHwFormat;
            codecCtx->hw_device_ctx = av_buffer_ref(hwDeviceCtx);
            hardwareDecode = codecCtx->hw_device_ctx != nullptr;
        }
 
        if (avcodec_open2(codecCtx, decoder, nullptr) < 0) {
            std::cout << "mxvk_ff_capture: failed to open decoder\n";
            close();
            return false;
        }
 
        packet = av_packet_alloc();
        frame = av_frame_alloc();
        swFrame = av_frame_alloc();
        if (packet == nullptr || frame == nullptr || swFrame == nullptr) {
            std::cout << "mxvk_ff_capture: failed to allocate decoder frames\n";
            close();
            return false;
        }
 
        frameWidth = codecCtx->width;
        frameHeight = codecCtx->height;
        frameFps = rationalToDouble(stream->avg_frame_rate);
        if (frameFps <= 0.0) {
            frameFps = rationalToDouble(stream->r_frame_rate);
        }
        if (frameFps <= 0.0) {
            frameFps = 30.0;
        }
 
        const std::string decodeMode = hardwareDecode && hardwareDecodeDevice >= 0 ? std::format("cuda:{}", hardwareDecodeDevice) : hardwareDecode ? "cuda" : "software";
        std::cout << std::format("mxvk_ff_capture: opened {} ({}x{}, {:.3f} fps, decode={})\n", filename, frameWidth, frameHeight, frameFps, decodeMode);
        return true;
    }
 
    bool VK_FF_Capture::seek_start() {
        if (!is_open() || videoStream < 0) {
            return false;
        }
 
        AVStream *stream = formatCtx->streams[videoStream];
        const int64_t timestamp = stream->start_time == AV_NOPTS_VALUE ? 0 : stream->start_time;
        if (av_seek_frame(formatCtx, videoStream, timestamp, AVSEEK_FLAG_BACKWARD) < 0) {
            std::cout << "mxvk_ff_capture: failed to seek to start\n";
            return false;
        }
 
        avcodec_flush_buffers(codecCtx);
        av_packet_unref(packet);
        av_frame_unref(frame);
        av_frame_unref(swFrame);
        return true;
    }
 
    bool VK_FF_Capture::skip() {
        if (!is_open() || !decodeNextFrame()) {
            return false;
        }
        av_frame_unref(frame);
        return true;
    }
 
    void VK_FF_Capture::close() {
#ifdef MXVK_CUDA
        if (decoder_surface_copy_event != nullptr) {
            cudaEventDestroy(decoder_surface_copy_event);
            decoder_surface_copy_event = nullptr;
        }
        decoder_surface_barrier_logged = false;
#endif
        if (swsCtx != nullptr) {
            sws_freeContext(swsCtx);
            swsCtx = nullptr;
        }
        rgba16_conversion_logged = false;
        if (hwDeviceCtx != nullptr) {
            av_buffer_unref(&hwDeviceCtx);
        }
        if (swFrame != nullptr) {
            av_frame_free(&swFrame);
        }
        if (frame != nullptr) {
            av_frame_free(&frame);
        }
        if (packet != nullptr) {
            av_packet_free(&packet);
        }
        if (codecCtx != nullptr) {
            avcodec_free_context(&codecCtx);
        }
        if (formatCtx != nullptr) {
            avformat_close_input(&formatCtx);
        }
        videoStream = -1;
        frameWidth = 0;
        frameHeight = 0;
        frameFps = 30.0;
        hwPixFmt = AV_PIX_FMT_NONE;
        hardwareDecode = false;
        hardwareDecodeDevice = -1;
    }
 
    bool VK_FF_Capture::readRgba(std::vector<uint8_t> &rgba, int &width, int &height, int &pitch, bool flipY) {
        if (!is_open()) {
            return false;
        }
 
        if (!decodeNextFrame()) {
            return false;
        }
        const bool converted = convertFrameToRgba(frame, rgba, width, height, pitch, flipY);
        av_frame_unref(frame);
        return converted;
    }
 
    bool VK_FF_Capture::readRgba16(std::vector<uint16_t> &rgba, int &width, int &height, int &pitch, bool flipY) {
        if (!is_open()) {
            return false;
        }
 
        if (!decodeNextFrame()) {
            return false;
        }
        const bool converted = convertFrameToRgba16(frame, rgba, width, height, pitch, flipY);
        av_frame_unref(frame);
        return converted;
    }
 
#ifdef MXVK_CUDA
    bool VK_FF_Capture::readGpuRgba(cv::cuda::GpuMat &rgba, cv::cuda::Stream &stream, bool flipY) {
        if (!is_open()) {
            return false;
        }
 
        if (!decodeNextFrame()) {
            return false;
        }
        const bool converted = convertFrameToGpuRgba(frame, rgba, stream, flipY);
        av_frame_unref(frame);
        return converted;
    }
#endif
 
    bool VK_FF_Capture::decodeNextFrame() {
        bool draining = false;
        while (true) {
            const int receiveResult = avcodec_receive_frame(codecCtx, frame);
            if (receiveResult == 0) {
                return true;
            }
            if (receiveResult == AVERROR_EOF) {
                return false;
            }
            if (receiveResult != AVERROR(EAGAIN)) {
                return false;
            }
            if (draining) {
                return false;
            }
 
            while (true) {
                const int readResult = av_read_frame(formatCtx, packet);
                if (readResult < 0) {
                    draining = true;
                    avcodec_send_packet(codecCtx, nullptr);
                    break;
                }
 
                if (packet->stream_index == videoStream) {
                    const int sendResult = avcodec_send_packet(codecCtx, packet);
                    av_packet_unref(packet);
                    if (sendResult == 0 || sendResult == AVERROR(EAGAIN)) {
                        break;
                    }
                    return false;
                }
                av_packet_unref(packet);
            }
        }
    }
 
    AVPixelFormat VK_FF_Capture::chooseHwFormat(AVCodecContext *ctx, const AVPixelFormat *formats) {
        const auto *capture = static_cast<const VK_FF_Capture *>(ctx->opaque);
        if (capture == nullptr) {
            return formats[0];
        }
        return capture->selectHwFormat(formats);
    }
 
    AVPixelFormat VK_FF_Capture::selectHwFormat(const AVPixelFormat *formats) const {
        for (const AVPixelFormat *format = formats; *format != AV_PIX_FMT_NONE; ++format) {
            if (*format == hwPixFmt) {
                return *format;
            }
        }
        std::cout << "mxvk_ff_capture: requested CUDA pixel format is unavailable; decoder will use software frames\n";
        return formats[0];
    }
 
    bool VK_FF_Capture::initHardwareDevice(const AVCodec *decoder, int cuda_device) {
        const AVHWDeviceType deviceType = av_hwdevice_find_type_by_name("cuda");
        if (deviceType == AV_HWDEVICE_TYPE_NONE) {
            return false;
        }
 
        for (int index = 0;; ++index) {
            const AVCodecHWConfig *config = avcodec_get_hw_config(decoder, index);
            if (config == nullptr) {
                return false;
            }
            const bool hasDeviceCtx = (config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX) != 0;
            if (hasDeviceCtx && config->device_type == deviceType) {
                hwPixFmt = config->pix_fmt;
                break;
            }
        }
 
        const std::string deviceName = cuda_device >= 0 ? std::to_string(cuda_device) : std::string{};
        const char *device = deviceName.empty() ? nullptr : deviceName.c_str();
        if (av_hwdevice_ctx_create(&hwDeviceCtx, deviceType, device, nullptr, 0) < 0) {
            hwPixFmt = AV_PIX_FMT_NONE;
            return false;
        }
 
        hardwareDecodeDevice = cuda_device;
        return true;
    }
 
    bool VK_FF_Capture::convertFrameToRgba(const AVFrame *decodedFrame, std::vector<uint8_t> &rgba, int &width, int &height, int &pitch, bool flipY) {
        const AVFrame *sourceFrame = decodedFrame;
        if (decodedFrame->format == hwPixFmt && hwPixFmt != AV_PIX_FMT_NONE) {
            av_frame_unref(swFrame);
            if (av_hwframe_transfer_data(swFrame, decodedFrame, 0) < 0) {
                std::cout << "mxvk_ff_capture: failed to transfer CUDA decoded frame to host memory\n";
                return false;
            }
            sourceFrame = swFrame;
        }
 
        width = sourceFrame->width;
        height = sourceFrame->height;
        pitch = width * 4;
        if (width <= 0 || height <= 0) {
            return false;
        }
 
        rgba.resize(static_cast<size_t>(pitch) * static_cast<size_t>(height));
        uint8_t *dstData[4] = {rgba.data(), nullptr, nullptr, nullptr};
        int dstLinesize[4] = {pitch, 0, 0, 0};
 
        swsCtx = sws_getCachedContext(swsCtx, sourceFrame->width, sourceFrame->height, static_cast<AVPixelFormat>(sourceFrame->format), width, height, AV_PIX_FMT_RGBA, SWS_BILINEAR, nullptr, nullptr, nullptr);
        if (swsCtx == nullptr) {
            return false;
        }
 
        const int scaledRows = sws_scale(swsCtx, sourceFrame->data, sourceFrame->linesize, 0, sourceFrame->height, dstData, dstLinesize);
        if (scaledRows != height) {
            return false;
        }
        if (flipY) {
            flipRows(rgba, pitch);
        }
        return true;
    }
 
    bool VK_FF_Capture::convertFrameToRgba16(const AVFrame *decodedFrame, std::vector<uint16_t> &rgba, int &width, int &height, int &pitch, bool flipY) {
        const AVFrame *sourceFrame = decodedFrame;
        if (decodedFrame->format == hwPixFmt && hwPixFmt != AV_PIX_FMT_NONE) {
            av_frame_unref(swFrame);
            if (av_hwframe_transfer_data(swFrame, decodedFrame, 0) < 0) {
                std::cout << "mxvk_ff_capture: failed to transfer CUDA decoded "
                             "HDR frame to host memory\n";
                return false;
            }
            sourceFrame = swFrame;
        }
 
        const AVColorSpace colorSpace = sourceFrame->colorspace != AVCOL_SPC_UNSPECIFIED ? sourceFrame->colorspace : codecCtx->colorspace;
        const AVColorRange colorRange = sourceFrame->color_range != AVCOL_RANGE_UNSPECIFIED ? sourceFrame->color_range : codecCtx->color_range;
        if (colorSpace == AVCOL_SPC_BT2020_NCL && colorRange != AVCOL_RANGE_JPEG && convertBt2020Yuv10LimitedToRgba16(sourceFrame, rgba, width, height, pitch, flipY)) {
            if (!rgba16_conversion_logged) {
                std::cout << "mxvk_ff_capture: preserving 10-bit BT.2020 NCL input "
                             "through native RGBA16 conversion\n";
                rgba16_conversion_logged = true;
            }
            return true;
        }
 
        width = sourceFrame->width;
        height = sourceFrame->height;
        pitch = width * 8;
        if (width <= 0 || height <= 0) {
            return false;
        }
 
        rgba.resize(static_cast<size_t>(width) * static_cast<size_t>(height) * 4U);
        auto *bytes = reinterpret_cast<uint8_t *>(rgba.data());
        uint8_t *dstData[4] = {bytes, nullptr, nullptr, nullptr};
        int dstLinesize[4] = {pitch, 0, 0, 0};
 
        swsCtx = sws_getCachedContext(swsCtx, sourceFrame->width, sourceFrame->height, static_cast<AVPixelFormat>(sourceFrame->format), width, height, AV_PIX_FMT_RGBA64, SWS_BILINEAR, nullptr, nullptr, nullptr);
        if (swsCtx == nullptr) {
            return false;
        }
 
        int sourceColorSpace = SWS_CS_DEFAULT;
        switch (colorSpace) {
        case AVCOL_SPC_BT2020_NCL:
        case AVCOL_SPC_BT2020_CL:
            sourceColorSpace = SWS_CS_BT2020;
            break;
        case AVCOL_SPC_BT709:
            sourceColorSpace = SWS_CS_ITU709;
            break;
        case AVCOL_SPC_SMPTE170M:
        case AVCOL_SPC_BT470BG:
            sourceColorSpace = SWS_CS_ITU601;
            break;
        default:
            break;
        }
        const int *sourceCoefficients = sws_getCoefficients(sourceColorSpace);
        const int *destinationCoefficients = sws_getCoefficients(SWS_CS_BT2020);
        sws_setColorspaceDetails(swsCtx, sourceCoefficients, colorRange == AVCOL_RANGE_JPEG ? 1 : 0, destinationCoefficients, 1, 0, 1 << 16, 1 << 16);
        if (!rgba16_conversion_logged) {
            std::cout << "mxvk_ff_capture: preserving high-bit-depth input through "
                         "FFmpeg RGBA64 conversion\n";
            rgba16_conversion_logged = true;
        }
 
        const int scaledRows = sws_scale(swsCtx, sourceFrame->data, sourceFrame->linesize, 0, sourceFrame->height, dstData, dstLinesize);
        if (scaledRows != height) {
            return false;
        }
        if (flipY) {
            std::vector<uint8_t> row(static_cast<size_t>(pitch));
            for (int y = 0; y < height / 2; ++y) {
                uint8_t *top = bytes + static_cast<size_t>(y) * pitch;
                uint8_t *bottom = bytes + static_cast<size_t>(height - 1 - y) * pitch;
                std::memcpy(row.data(), top, static_cast<size_t>(pitch));
                std::memcpy(top, bottom, static_cast<size_t>(pitch));
                std::memcpy(bottom, row.data(), static_cast<size_t>(pitch));
            }
        }
        return true;
    }
 
#ifdef MXVK_CUDA
    bool VK_FF_Capture::convertFrameToGpuRgba(const AVFrame *decodedFrame, cv::cuda::GpuMat &rgba, cv::cuda::Stream &stream, bool flipY) {
        if (decodedFrame->format == hwPixFmt && hwPixFmt != AV_PIX_FMT_NONE && decodedFrame->hw_frames_ctx != nullptr) {
            const auto *framesContext = reinterpret_cast<const AVHWFramesContext *>(decodedFrame->hw_frames_ctx->data);
            if (framesContext != nullptr && framesContext->sw_format == AV_PIX_FMT_NV12) {
                const int width = decodedFrame->width;
                const int height = decodedFrame->height;
                if (width <= 0 || height <= 0 || decodedFrame->data[0] == nullptr || decodedFrame->data[1] == nullptr) {
                    return false;
                }
 
                gpuNv12.create(height + (height / 2), width, CV_8UC1);
                cudaStream_t cudaStream = mxvk::cuda_stream_handle(stream);
                if (decoder_surface_copy_event == nullptr) {
                    const cudaError_t event_result = cudaEventCreateWithFlags(&decoder_surface_copy_event, cudaEventDisableTiming);
                    if (event_result != cudaSuccess) {
                        std::cout << "mxvk_ff_capture: CUDA decoder-surface event creation failed: " << cudaGetErrorString(event_result) << "\n";
                        return false;
                    }
                }
 
                const auto synchronize_decoder_surface_copy = [&]() {
                    cudaError_t result = cudaEventSynchronize(decoder_surface_copy_event);
                    if (result != cudaSuccess) {
                        std::cout << "mxvk_ff_capture: CUDA decoder-surface copy barrier failed: " << cudaGetErrorString(result) << "\n";
                        result = cudaStreamSynchronize(cudaStream);
                        if (result != cudaSuccess) {
                            std::cout << "mxvk_ff_capture: CUDA capture-stream synchronization failed: " << cudaGetErrorString(result) << "\n";
                            return false;
                        }
                    }
                    if (!decoder_surface_barrier_logged) {
                        std::cout << "mxvk_ff_capture: asynchronous NVDEC surface-copy barrier active\n";
                        decoder_surface_barrier_logged = true;
                    }
                    return true;
                };
 
                cudaError_t result = cudaMemcpy2DAsync(gpuNv12.ptr(), gpuNv12.step, decodedFrame->data[0], static_cast<size_t>(decodedFrame->linesize[0]), static_cast<size_t>(width), static_cast<size_t>(height), cudaMemcpyDeviceToDevice, cudaStream);
                if (result != cudaSuccess) {
                    std::cout << "mxvk_ff_capture: CUDA NV12 luma copy failed: " << cudaGetErrorString(result) << "\n";
                    cudaStreamSynchronize(cudaStream);
                    return false;
                }
 
                result = cudaMemcpy2DAsync(gpuNv12.ptr(height), gpuNv12.step, decodedFrame->data[1], static_cast<size_t>(decodedFrame->linesize[1]), static_cast<size_t>(width), static_cast<size_t>(height / 2), cudaMemcpyDeviceToDevice, cudaStream);
                if (result != cudaSuccess) {
                    std::cout << "mxvk_ff_capture: CUDA NV12 chroma copy failed: " << cudaGetErrorString(result) << "\n";
                    cudaStreamSynchronize(cudaStream);
                    return false;
                }
 
                result = cudaEventRecord(decoder_surface_copy_event, cudaStream);
                if (result != cudaSuccess) {
                    std::cout << "mxvk_ff_capture: CUDA decoder-surface event record failed: " << cudaGetErrorString(result) << "\n";
                    cudaStreamSynchronize(cudaStream);
                    return false;
                }
 
#ifdef MXVK_CUDA_NPP
                gpuRgb.create(height, width, CV_8UC3);
                gpuRgba.create(height, width, CV_8UC4);
 
                const Npp8u *srcPlanes[2] = {
                    static_cast<const Npp8u *>(gpuNv12.ptr()),
                    static_cast<const Npp8u *>(gpuNv12.ptr(height)),
                };
                const NppiSize roi{width, height};
                const NppStreamContext nppContext = makeNppStreamContext(cudaStream);
                NppStatus nppStatus = nppiNV12ToRGB_8u_P2C3R_Ctx(srcPlanes, static_cast<int>(gpuNv12.step), static_cast<Npp8u *>(gpuRgb.ptr()), static_cast<int>(gpuRgb.step), roi, nppContext);
                if (nppStatus != NPP_SUCCESS) {
                    std::cout << "mxvk_ff_capture: NPP NV12 to RGB conversion failed: " << static_cast<int>(nppStatus) << "\n";
                    synchronize_decoder_surface_copy();
                    return false;
                }
 
                const int rgbaOrder[4] = {0, 1, 2, 3};
                nppStatus = nppiSwapChannels_8u_C3C4R_Ctx(static_cast<const Npp8u *>(gpuRgb.ptr()), static_cast<int>(gpuRgb.step), static_cast<Npp8u *>(gpuRgba.ptr()), static_cast<int>(gpuRgba.step), roi, rgbaOrder, 255, nppContext);
                if (nppStatus != NPP_SUCCESS) {
                    std::cout << "mxvk_ff_capture: NPP RGB to RGBA conversion failed: " << static_cast<int>(nppStatus) << "\n";
                    synchronize_decoder_surface_copy();
                    return false;
                }
 
                if (flipY) {
                    cv::cuda::flip(gpuRgba, gpuFlippedRgba, 0, stream);
                    rgba = gpuFlippedRgba;
                } else {
                    rgba = gpuRgba;
                }
                if (!synchronize_decoder_surface_copy()) {
                    return false;
                }
                return true;
#else
                try {
                    cv::cuda::cvtColor(gpuNv12, gpuRgba, cv::COLOR_YUV2RGBA_NV12, 0, stream);
                    if (flipY) {
                        cv::cuda::flip(gpuRgba, gpuFlippedRgba, 0, stream);
                        rgba = gpuFlippedRgba;
                    } else {
                        rgba = gpuRgba;
                    }
                    if (!synchronize_decoder_surface_copy()) {
                        return false;
                    }
                    return true;
                } catch (const cv::Exception &e) {
                    if (!synchronize_decoder_surface_copy()) {
                        return false;
                    }
                    std::cout << "mxvk_ff_capture: CUDA NV12 to RGBA conversion failed; falling back to host conversion: " << e.what() << "\n";
                }
#endif
            }
        }
 
        std::vector<uint8_t> hostRgba;
        int width = 0;
        int height = 0;
        int pitch = 0;
        if (!convertFrameToRgba(decodedFrame, hostRgba, width, height, pitch, flipY) || pitch != width * 4) {
            return false;
        }
        cv::Mat hostFrame(height, width, CV_8UC4, hostRgba.data(), static_cast<size_t>(pitch));
        gpuRgba.upload(hostFrame, stream);
        stream.waitForCompletion();
        rgba = gpuRgba;
        return true;
    }
#endif
 
    void VK_FF_Capture::flipRows(std::vector<uint8_t> &rgba, int pitch) const {
        std::vector<uint8_t> row(static_cast<size_t>(pitch));
        for (int top = 0, bottom = frameHeight - 1; top < bottom; ++top, --bottom) {
            auto *topPtr = rgba.data() + static_cast<size_t>(top) * static_cast<size_t>(pitch);
            auto *bottomPtr = rgba.data() + static_cast<size_t>(bottom) * static_cast<size_t>(pitch);
            std::memcpy(row.data(), topPtr, static_cast<size_t>(pitch));
            std::memcpy(topPtr, bottomPtr, static_cast<size_t>(pitch));
            std::memcpy(bottomPtr, row.data(), static_cast<size_t>(pitch));
        }
    }
 
} // namespace mxvk