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	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.
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	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 32 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 143 of file mxvk_ff_capture.cpp.

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

fps()

double mxvk::VK_FF_Capture::fps ( ) const

inlinenodiscard

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

Definition at line 80 of file mxvk_ff_capture.hpp.

{ return frameFps; }

height()

int mxvk::VK_FF_Capture::height ( ) const

inlinenodiscard

Source height in pixels.

Definition at line 78 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 52 of file mxvk_ff_capture.hpp.

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

open()

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.

                                                      {
        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)) {
            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;
        }
 
        std::cout << std::format(
            "mxvk_ff_capture: opened {} ({}x{}, {:.3f} fps, decode={})\n",
            filename,
            frameWidth,
            frameHeight,
            frameFps,
            hardwareDecode ? "cuda" : "software");
        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 174 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;
    }

using_hardware_decode()

bool mxvk::VK_FF_Capture::using_hardware_decode ( ) const

inlinenodiscard

True when CUDA hardware decode is active.

Definition at line 82 of file mxvk_ff_capture.hpp.

{ return hardwareDecode; }

width()

int mxvk::VK_FF_Capture::width ( ) const

inlinenodiscard

Source width in pixels.

Definition at line 76 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