mxvk::VK_FF_Capture Class Reference

FFmpeg-backed video-file capture source. More...

#include <mxvk/include/mxvk/mxvk_ff_capture.hpp>

Public Member Functions
void	close ()
	Close the active file and release decoder resources.
double	fps () const
	Source frame rate, falling back to 30 fps when unknown.
int	hardware_decode_device () const
	Selected CUDA hardware-decode device, or -1 for FFmpeg's default.
int	height () const
	Source height in pixels.
bool	is_open () const
	Check whether a decoder is open.
bool	open (const std::string &filename)
	Open a video file.
bool	open (const std::string &filename, int cuda_device)
	Open a video file on a selected CUDA decode device.
VK_FF_Capture &	operator= (const VK_FF_Capture &)=delete
VK_FF_Capture &	operator= (VK_FF_Capture &&)=delete
bool	readRgba (std::vector< uint8_t > &rgba, int &width, int &height, int &pitch, bool flipY=false)
	Decode the next frame as tightly packed RGBA8.
bool	seek_start ()
	Seek the active video stream back to its beginning.
bool	skip ()
	Decode and discard the next video frame.
bool	using_hardware_decode () const
	True when CUDA hardware decode is active.
	VK_FF_Capture ()=default
	Construct a closed capture source.
	VK_FF_Capture (const VK_FF_Capture &)=delete
	VK_FF_Capture (VK_FF_Capture &&)=delete
int	width () const
	Source width in pixels.
	~VK_FF_Capture ()
	Close and release FFmpeg resources.

Detailed Description

FFmpeg-backed video-file capture source.

VK_FF_Capture opens video files directly through FFmpeg, prefers CUDA hardware decoding when available, and returns tightly packed RGBA8 frames suitable for Vulkan staging uploads or encoder input.

Definition at line 33 of file mxvk_ff_capture.hpp.

Constructor & Destructor Documentation

VK_FF_Capture() [1/3]

mxvk::VK_FF_Capture::VK_FF_Capture ( )

default

Construct a closed capture source.

~VK_FF_Capture()

mxvk::VK_FF_Capture::~VK_FF_Capture

(

)

Close and release FFmpeg resources.

Definition at line 58 of file mxvk_ff_capture.cpp.

                                  {
        close();
    }

VK_FF_Capture() [2/3]

mxvk::VK_FF_Capture::VK_FF_Capture ( const VK_FF_Capture & )

delete

VK_FF_Capture() [3/3]

mxvk::VK_FF_Capture::VK_FF_Capture ( VK_FF_Capture && )

delete

Member Function Documentation

close()

void mxvk::VK_FF_Capture::close

(

)

Close the active file and release decoder resources.

Definition at line 182 of file mxvk_ff_capture.cpp.

                              {
#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;
        }
        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;
    }

fps()

double mxvk::VK_FF_Capture::fps ( ) const

inlinenodiscard

Source frame rate, falling back to 30 fps when unknown.

Definition at line 105 of file mxvk_ff_capture.hpp.

{ return frameFps; }

hardware_decode_device()

int mxvk::VK_FF_Capture::hardware_decode_device ( ) const

inlinenodiscard

Selected CUDA hardware-decode device, or -1 for FFmpeg's default.

Definition at line 109 of file mxvk_ff_capture.hpp.

{ return hardwareDecodeDevice; }

height()

int mxvk::VK_FF_Capture::height ( ) const

inlinenodiscard

Source height in pixels.

Definition at line 103 of file mxvk_ff_capture.hpp.

{ return frameHeight; }

is_open()

bool mxvk::VK_FF_Capture::is_open ( ) const

inlinenodiscard

Check whether a decoder is open.

Definition at line 77 of file mxvk_ff_capture.hpp.

{ return formatCtx != nullptr && codecCtx != nullptr; }

open() [1/2]

bool mxvk::VK_FF_Capture::open

(

const std::string &

filename

)

Open a video file.

Parameters

filename

Path to the input video file.

Returns

true on success.

Definition at line 62 of file mxvk_ff_capture.cpp.

                                                      {
        return open(filename, -1);
    }

open() [2/2]

bool mxvk::VK_FF_Capture::open	(	const std::string &	filename,
		int	cuda_device )

Open a video file on a selected CUDA decode device.

Parameters

filename	Path to the input video file.
cuda_device	CUDA device index used for hardware decode; a negative value lets FFmpeg select its default device.

Returns

true on success.

Definition at line 66 of file mxvk_ff_capture.cpp.

                                                                       {
        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;
    }

operator=() [1/2]

VK_FF_Capture & mxvk::VK_FF_Capture::operator= ( const VK_FF_Capture & )

delete

operator=() [2/2]

VK_FF_Capture & mxvk::VK_FF_Capture::operator= ( VK_FF_Capture && )

delete

readRgba()

bool mxvk::VK_FF_Capture::readRgba	(	std::vector< uint8_t > &	rgba,
		int &	width,
		int &	height,
		int &	pitch,
		bool	flipY = false )

Decode the next frame as tightly packed RGBA8.

Parameters

rgba	Output byte buffer, resized to pitch * height.
width	Output frame width in pixels.
height	Output frame height in pixels.
pitch	Output row pitch in bytes.
flipY	Flip rows vertically after conversion when true.

Returns

true when a frame was decoded, false on EOF or failure.

Definition at line 221 of file mxvk_ff_capture.cpp.

                                                                                                          {
        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;
    }

seek_start()

bool mxvk::VK_FF_Capture::seek_start

(

)

Seek the active video stream back to its beginning.

The decoder and optional hardware-device context remain active.

Returns

true when the input was sought and the decoder was flushed.

Definition at line 152 of file mxvk_ff_capture.cpp.

                                   {
        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;
    }

skip()

bool mxvk::VK_FF_Capture::skip

(

)

Decode and discard the next video frame.

Hardware frames remain on the decoder device and no RGBA conversion or host transfer is performed. This is intended for media-clock catch-up when a late source frame must not be rendered.

Returns

true when a frame was decoded and discarded.

Definition at line 174 of file mxvk_ff_capture.cpp.

                             {
        if (!is_open() || !decodeNextFrame()) {
            return false;
        }
        av_frame_unref(frame);
        return true;
    }

using_hardware_decode()

bool mxvk::VK_FF_Capture::using_hardware_decode ( ) const

inlinenodiscard

True when CUDA hardware decode is active.

Definition at line 107 of file mxvk_ff_capture.hpp.

{ return hardwareDecode; }

width()

int mxvk::VK_FF_Capture::width ( ) const

inlinenodiscard

Source width in pixels.

Definition at line 101 of file mxvk_ff_capture.hpp.

{ return frameWidth; }

---

The documentation for this class was generated from the following files:

• mxvk/include/mxvk/mxvk_ff_capture.hpp
• mxvk/src/mxvk_ff_capture.cpp