cuda.h

Go to the documentation of this file.

 
#pragma once
 
#if defined(SUNSHINE_BUILD_CUDA)
  // standard includes
  #include <cstdint>
  #include <memory>
  #include <optional>
  #include <string>
  #include <vector>
 
  // local includes
  #include "src/video_colorspace.h"
 
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);
 
  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);
 
    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