141 lines
3.4 KiB
C++
141 lines
3.4 KiB
C++
/**
|
|
* @file src/platform/linux/cuda.h
|
|
* @brief todo
|
|
*/
|
|
#pragma once
|
|
|
|
#if defined(SUNSHINE_BUILD_CUDA)
|
|
|
|
#include "src/video_colorspace.h"
|
|
|
|
#include <cstdint>
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace platf {
|
|
class avcodec_encode_device_t;
|
|
class img_t;
|
|
} // namespace platf
|
|
|
|
namespace cuda {
|
|
|
|
namespace nvfbc {
|
|
std::vector<std::string>
|
|
display_names();
|
|
}
|
|
std::unique_ptr<platf::avcodec_encode_device_t>
|
|
make_avcodec_encode_device(int width, int height, bool vram);
|
|
|
|
/**
|
|
* @brief Create a GL->CUDA encoding device for consuming captured dmabufs.
|
|
* @param in_width Width of captured frames.
|
|
* @param in_height Height of captured frames.
|
|
* @param offset_x Offset of content in captured frame.
|
|
* @param offset_y Offset of content in captured frame.
|
|
* @return FFmpeg encoding device context.
|
|
*/
|
|
std::unique_ptr<platf::avcodec_encode_device_t>
|
|
make_avcodec_gl_encode_device(int width, int height, int offset_x, int offset_y);
|
|
|
|
int
|
|
init();
|
|
} // namespace cuda
|
|
|
|
typedef struct cudaArray *cudaArray_t;
|
|
|
|
#if !defined(__CUDACC__)
|
|
typedef struct CUstream_st *cudaStream_t;
|
|
typedef unsigned long long cudaTextureObject_t;
|
|
#else /* defined(__CUDACC__) */
|
|
typedef __location__(device_builtin) struct CUstream_st *cudaStream_t;
|
|
typedef __location__(device_builtin) unsigned long long cudaTextureObject_t;
|
|
#endif /* !defined(__CUDACC__) */
|
|
|
|
namespace cuda {
|
|
|
|
class freeCudaPtr_t {
|
|
public:
|
|
void
|
|
operator()(void *ptr);
|
|
};
|
|
|
|
class freeCudaStream_t {
|
|
public:
|
|
void
|
|
operator()(cudaStream_t ptr);
|
|
};
|
|
|
|
using ptr_t = std::unique_ptr<void, freeCudaPtr_t>;
|
|
using stream_t = std::unique_ptr<CUstream_st, freeCudaStream_t>;
|
|
|
|
stream_t
|
|
make_stream(int flags = 0);
|
|
|
|
struct viewport_t {
|
|
int width, height;
|
|
int offsetX, offsetY;
|
|
};
|
|
|
|
class tex_t {
|
|
public:
|
|
static std::optional<tex_t>
|
|
make(int height, int pitch);
|
|
|
|
tex_t();
|
|
tex_t(tex_t &&);
|
|
|
|
tex_t &
|
|
operator=(tex_t &&other);
|
|
|
|
~tex_t();
|
|
|
|
int
|
|
copy(std::uint8_t *src, int height, int pitch);
|
|
|
|
cudaArray_t array;
|
|
|
|
struct texture {
|
|
cudaTextureObject_t point;
|
|
cudaTextureObject_t linear;
|
|
} texture;
|
|
};
|
|
|
|
class sws_t {
|
|
public:
|
|
sws_t() = default;
|
|
sws_t(int in_width, int in_height, int out_width, int out_height, int pitch, int threadsPerBlock, ptr_t &&color_matrix);
|
|
|
|
/**
|
|
* in_width, in_height -- The width and height of the captured image in pixels
|
|
* out_width, out_height -- the width and height of the NV12 image in pixels
|
|
*
|
|
* pitch -- The size of a single row of pixels in bytes
|
|
*/
|
|
static std::optional<sws_t>
|
|
make(int in_width, int in_height, int out_width, int out_height, int pitch);
|
|
|
|
// Converts loaded image into a CUDevicePtr
|
|
int
|
|
convert(std::uint8_t *Y, std::uint8_t *UV, std::uint32_t pitchY, std::uint32_t pitchUV, cudaTextureObject_t texture, stream_t::pointer stream);
|
|
int
|
|
convert(std::uint8_t *Y, std::uint8_t *UV, std::uint32_t pitchY, std::uint32_t pitchUV, cudaTextureObject_t texture, stream_t::pointer stream, const viewport_t &viewport);
|
|
|
|
void
|
|
apply_colorspace(const video::sunshine_colorspace_t &colorspace);
|
|
|
|
int
|
|
load_ram(platf::img_t &img, cudaArray_t array);
|
|
|
|
ptr_t color_matrix;
|
|
|
|
int threadsPerBlock;
|
|
|
|
viewport_t viewport;
|
|
|
|
float scale;
|
|
};
|
|
} // namespace cuda
|
|
|
|
#endif |