N-archive/suyu
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/suyu.git synced 2024-12-23 17:00:57 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

texture_cache: Move staging buffer into a generic implementation

Browse source
This commit is contained in:
ReinUsesLisp 2019-04-24 02:45:03 -03:00
parent 2787a0c287
commit 5f3aacdc37
4 changed files with 211 additions and 181 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

114
src/video_core/renderer_opengl/gl_texture_cache.cpp
View file

@ -15,7 +15,6 @@
namespace OpenGL {
using Tegra::Texture::ConvertFromGuestToHost;
using Tegra::Texture::SwizzleSource;
using VideoCore::MortonSwizzleMode;
@ -207,32 +206,6 @@ OGLTexture CreateTexture(const SurfaceParams& params, GLenum target, GLenum inte
return texture;
}
void SwizzleFunc(MortonSwizzleMode mode, u8* memory, const SurfaceParams& params, u8* buffer,
u32 level) {
const u32 width{params.GetMipWidth(level)};
const u32 height{params.GetMipHeight(level)};
const u32 block_height{params.GetMipBlockHeight(level)};
const u32 block_depth{params.GetMipBlockDepth(level)};
std::size_t guest_offset{params.GetGuestMipmapLevelOffset(level)};
if (params.IsLayered()) {
std::size_t host_offset{0};
const std::size_t guest_stride = params.GetGuestLayerSize();
const std::size_t host_stride = params.GetHostLayerSize(level);
for (u32 layer = 0; layer < params.GetNumLayers(); layer++) {
MortonSwizzle(mode, params.GetPixelFormat(), width, block_height, height, block_depth,
1, params.GetTileWidthSpacing(), buffer + host_offset,
memory + guest_offset);
guest_offset += guest_stride;
host_offset += host_stride;
}
} else {
MortonSwizzle(mode, params.GetPixelFormat(), width, block_height, height, block_depth,
params.GetMipDepth(level), params.GetTileWidthSpacing(), buffer,
memory + guest_offset);
}
}
} // Anonymous namespace
CachedSurface::CachedSurface(TextureCacheOpenGL& texture_cache, const SurfaceParams& params)
@ -245,54 +218,11 @@ CachedSurface::CachedSurface(TextureCacheOpenGL& texture_cache, const SurfacePar
is_compressed = tuple.compressed;
target = GetTextureTarget(params);
texture = CreateTexture(params, target, internal_format);
staging_buffer.resize(params.GetHostSizeInBytes());
}
CachedSurface::~CachedSurface() = default;
void CachedSurface::LoadBuffer() {
if (params.IsTiled()) {
ASSERT_MSG(params.GetBlockWidth() == 1, "Block width is defined as {} on texture target {}",
params.GetBlockWidth(), static_cast<u32>(params.GetTarget()));
for (u32 level = 0; level < params.GetNumLevels(); ++level) {
u8* const buffer{staging_buffer.data() + params.GetHostMipmapLevelOffset(level)};
SwizzleFunc(MortonSwizzleMode::MortonToLinear, GetHostPtr(), params, buffer, level);
}
} else {
ASSERT_MSG(params.GetNumLevels() == 1, "Linear mipmap loading is not implemented");
const u32 bpp{GetFormatBpp(params.GetPixelFormat()) / CHAR_BIT};
const u32 block_width{VideoCore::Surface::GetDefaultBlockWidth(params.GetPixelFormat())};
const u32 block_height{VideoCore::Surface::GetDefaultBlockHeight(params.GetPixelFormat())};
const u32 width{(params.GetWidth() + block_width - 1) / block_width};
const u32 height{(params.GetHeight() + block_height - 1) / block_height};
const u32 copy_size{width * bpp};
if (params.GetPitch() == copy_size) {
std::memcpy(staging_buffer.data(), GetHostPtr(), params.GetHostSizeInBytes());
} else {
const u8* start{GetHostPtr()};
u8* write_to{staging_buffer.data()};
for (u32 h = height; h > 0; --h) {
std::memcpy(write_to, start, copy_size);
start += params.GetPitch();
write_to += copy_size;
}
}
}
for (u32 level = 0; level < params.GetNumLevels(); ++level) {
ConvertFromGuestToHost(staging_buffer.data() + params.GetHostMipmapLevelOffset(level),
params.GetPixelFormat(), params.GetMipWidth(level),
params.GetMipHeight(level), params.GetMipDepth(level), true, true);
}
}
void CachedSurface::FlushBufferImpl() {
LOG_CRITICAL(Render_OpenGL, "Flushing");
if (!IsModified()) {
return;
}
void CachedSurface::DownloadTextureImpl() {
// TODO(Rodrigo): Optimize alignment
glPixelStorei(GL_PACK_ALIGNMENT, 1);
SCOPE_EXIT({ glPixelStorei(GL_PACK_ROW_LENGTH, 0); });
@ -300,60 +230,30 @@ void CachedSurface::FlushBufferImpl() {
for (u32 level = 0; level < params.GetNumLevels(); ++level) {
glPixelStorei(GL_PACK_ROW_LENGTH, static_cast<GLint>(params.GetMipWidth(level)));
if (is_compressed) {
glGetCompressedTextureImage(
texture.handle, level, static_cast<GLsizei>(params.GetHostMipmapSize(level)),
staging_buffer.data() + params.GetHostMipmapLevelOffset(level));
glGetCompressedTextureImage(texture.handle, level,
static_cast<GLsizei>(params.GetHostMipmapSize(level)),
GetStagingBufferLevelData(level));
} else {
glGetTextureImage(texture.handle, level, format, type,
static_cast<GLsizei>(params.GetHostMipmapSize(level)),
staging_buffer.data() + params.GetHostMipmapLevelOffset(level));
GetStagingBufferLevelData(level));
}
}
if (params.IsTiled()) {
ASSERT_MSG(params.GetBlockWidth() == 1, "Block width is defined as {}",
params.GetBlockWidth());
for (u32 level = 0; level < params.GetNumLevels(); ++level) {
u8* const buffer = staging_buffer.data() + params.GetHostMipmapLevelOffset(level);
SwizzleFunc(MortonSwizzleMode::LinearToMorton, GetHostPtr(), params, buffer, level);
}
} else {
UNIMPLEMENTED();
/*
ASSERT(params.GetTarget() == SurfaceTarget::Texture2D);
ASSERT(params.GetNumLevels() == 1);
const u32 bpp{params.GetFormatBpp() / 8};
const u32 copy_size{params.GetWidth() * bpp};
if (params.GetPitch() == copy_size) {
std::memcpy(host_ptr, staging_buffer.data(), GetSizeInBytes());
} else {
u8* start{host_ptr};
const u8* read_to{staging_buffer.data()};
for (u32 h = params.GetHeight(); h > 0; --h) {
std::memcpy(start, read_to, copy_size);
start += params.GetPitch();
read_to += copy_size;
}
}
*/
}
}
void CachedSurface::UploadTextureImpl() {
SCOPE_EXIT({ glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); });
for (u32 level = 0; level < params.GetNumLevels(); ++level) {
UploadTextureMipmap(level);
}
}
void CachedSurface::UploadTextureMipmap(u32 level) {
u8* buffer{staging_buffer.data() + params.GetHostMipmapLevelOffset(level)};
// TODO(Rodrigo): Optimize alignment
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glPixelStorei(GL_UNPACK_ROW_LENGTH, static_cast<GLint>(params.GetMipWidth(level)));
SCOPE_EXIT({ glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); });
u8* buffer{GetStagingBufferLevelData(level)};
if (is_compressed) {
const auto image_size{static_cast<GLsizei>(params.GetHostMipmapSize(level))};
switch (params.GetTarget()) {

7
src/video_core/renderer_opengl/gl_texture_cache.h
View file

@ -39,8 +39,6 @@ public:
explicit CachedSurface(TextureCacheOpenGL& texture_cache, const SurfaceParams& params);
~CachedSurface();
void LoadBuffer();
GLenum GetTarget() const {
return target;
}
@ -54,9 +52,8 @@ protected:
std::unique_ptr<CachedSurfaceView> CreateView(const ViewKey& view_key);
void FlushBufferImpl();
void UploadTextureImpl();
void DownloadTextureImpl();
private:
void UploadTextureMipmap(u32 level);
@ -68,8 +65,6 @@ private:
GLenum target{};
OGLTexture texture;
std::vector<u8> staging_buffer;
};
class CachedSurfaceView final {

110
src/video_core/texture_cache.cpp
View file

@ -7,14 +7,16 @@
#include "common/cityhash.h"
#include "common/common_types.h"
#include "core/core.h"
#include "video_core/morton.h"
#include "video_core/surface.h"
#include "video_core/texture_cache.h"
#include "video_core/textures/convert.h"
#include "video_core/textures/decoders.h"
#include "video_core/textures/texture.h"
namespace VideoCommon {
using VideoCore::Surface::SurfaceTarget;
using VideoCore::MortonSwizzleMode;
using VideoCore::Surface::ComponentTypeFromDepthFormat;
using VideoCore::Surface::ComponentTypeFromRenderTarget;
@ -22,12 +24,118 @@ using VideoCore::Surface::ComponentTypeFromTexture;
using VideoCore::Surface::PixelFormatFromDepthFormat;
using VideoCore::Surface::PixelFormatFromRenderTargetFormat;
using VideoCore::Surface::PixelFormatFromTextureFormat;
using VideoCore::Surface::SurfaceTarget;
using VideoCore::Surface::SurfaceTargetFromTextureType;
using Tegra::Texture::ConvertFromGuestToHost;
namespace {
constexpr u32 GetMipmapSize(bool uncompressed, u32 mip_size, u32 tile) {
return uncompressed ? mip_size : std::max(1U, (mip_size + tile - 1) / tile);
}
void SwizzleFunc(MortonSwizzleMode mode, u8* memory, const SurfaceParams& params, u8* buffer,
u32 level) {
const u32 width{params.GetMipWidth(level)};
const u32 height{params.GetMipHeight(level)};
const u32 block_height{params.GetMipBlockHeight(level)};
const u32 block_depth{params.GetMipBlockDepth(level)};
std::size_t guest_offset{params.GetGuestMipmapLevelOffset(level)};
if (params.IsLayered()) {
std::size_t host_offset{0};
const std::size_t guest_stride = params.GetGuestLayerSize();
const std::size_t host_stride = params.GetHostLayerSize(level);
for (u32 layer = 0; layer < params.GetNumLayers(); layer++) {
MortonSwizzle(mode, params.GetPixelFormat(), width, block_height, height, block_depth,
1, params.GetTileWidthSpacing(), buffer + host_offset,
memory + guest_offset);
guest_offset += guest_stride;
host_offset += host_stride;
}
} else {
MortonSwizzle(mode, params.GetPixelFormat(), width, block_height, height, block_depth,
params.GetMipDepth(level), params.GetTileWidthSpacing(), buffer,
memory + guest_offset);
}
}
} // Anonymous namespace
SurfaceBaseImpl::SurfaceBaseImpl(const SurfaceParams& params) : params{params} {
staging_buffer.resize(params.GetHostSizeInBytes());
}
SurfaceBaseImpl::~SurfaceBaseImpl() = default;
void SurfaceBaseImpl::LoadBuffer() {
if (params.IsTiled()) {
ASSERT_MSG(params.GetBlockWidth() == 1, "Block width is defined as {} on texture target {}",
params.GetBlockWidth(), static_cast<u32>(params.GetTarget()));
for (u32 level = 0; level < params.GetNumLevels(); ++level) {
u8* const buffer{GetStagingBufferLevelData(level)};
SwizzleFunc(MortonSwizzleMode::MortonToLinear, host_ptr, params, buffer, level);
}
} else {
ASSERT_MSG(params.GetNumLevels() == 1, "Linear mipmap loading is not implemented");
const u32 bpp{GetFormatBpp(params.GetPixelFormat()) / CHAR_BIT};
const u32 block_width{params.GetDefaultBlockWidth()};
const u32 block_height{params.GetDefaultBlockHeight()};
const u32 width{(params.GetWidth() + block_width - 1) / block_width};
const u32 height{(params.GetHeight() + block_height - 1) / block_height};
const u32 copy_size{width * bpp};
if (params.GetPitch() == copy_size) {
std::memcpy(staging_buffer.data(), host_ptr, params.GetHostSizeInBytes());
} else {
const u8* start{host_ptr};
u8* write_to{staging_buffer.data()};
for (u32 h = height; h > 0; --h) {
std::memcpy(write_to, start, copy_size);
start += params.GetPitch();
write_to += copy_size;
}
}
}
for (u32 level = 0; level < params.GetNumLevels(); ++level) {
ConvertFromGuestToHost(GetStagingBufferLevelData(level), params.GetPixelFormat(),
params.GetMipWidth(level), params.GetMipHeight(level),
params.GetMipDepth(level), true, true);
}
}
void SurfaceBaseImpl::FlushBuffer() {
if (params.IsTiled()) {
ASSERT_MSG(params.GetBlockWidth() == 1, "Block width is defined as {}",
params.GetBlockWidth());
for (u32 level = 0; level < params.GetNumLevels(); ++level) {
u8* const buffer = GetStagingBufferLevelData(level);
SwizzleFunc(MortonSwizzleMode::LinearToMorton, GetHostPtr(), params, buffer, level);
}
} else {
UNIMPLEMENTED();
/*
ASSERT(params.GetTarget() == SurfaceTarget::Texture2D);
ASSERT(params.GetNumLevels() == 1);
const u32 bpp{params.GetFormatBpp() / 8};
const u32 copy_size{params.GetWidth() * bpp};
if (params.GetPitch() == copy_size) {
std::memcpy(host_ptr, staging_buffer.data(), GetSizeInBytes());
} else {
u8* start{host_ptr};
const u8* read_to{staging_buffer.data()};
for (u32 h = params.GetHeight(); h > 0; --h) {
std::memcpy(start, read_to, copy_size);
start += params.GetPitch();
read_to += copy_size;
}
}
*/
}
}
SurfaceParams SurfaceParams::CreateForTexture(Core::System& system,
const Tegra::Texture::FullTextureInfo& config) {
SurfaceParams params;

161
src/video_core/texture_cache.h
View file

@ -273,37 +273,11 @@ struct hash<VideoCommon::ViewKey> {
namespace VideoCommon {
template <typename TTextureCache, typename TView, typename TExecutionContext>
class SurfaceBase {
static_assert(std::is_trivially_copyable_v<TExecutionContext>);
class SurfaceBaseImpl {
public:
virtual void LoadBuffer() = 0;
void LoadBuffer();
virtual TExecutionContext FlushBuffer(TExecutionContext exctx) = 0;
virtual TExecutionContext UploadTexture(TExecutionContext exctx) = 0;
TView* TryGetView(GPUVAddr view_addr, const SurfaceParams& view_params) {
if (view_addr < gpu_addr || !params.IsFamiliar(view_params)) {
// It can't be a view if it's in a prior address.
return {};
}
const auto relative_offset{static_cast<u64>(view_addr - gpu_addr)};
const auto it{view_offset_map.find(relative_offset)};
if (it == view_offset_map.end()) {
// Couldn't find an aligned view.
return {};
}
const auto [layer, level] = it->second;
if (!params.IsViewValid(view_params, layer, level)) {
return {};
}
return GetView(layer, view_params.GetNumLayers(), level, view_params.GetNumLevels());
}
void FlushBuffer();
GPUVAddr GetGpuAddr() const {
ASSERT(is_registered);
@ -325,27 +299,10 @@ public:
return cache_addr;
}
std::size_t GetSizeInBytes() const {
return params.GetGuestSizeInBytes();
}
void MarkAsModified(bool is_modified_) {
is_modified = is_modified_;
if (is_modified_) {
modification_tick = texture_cache.Tick();
}
}
const SurfaceParams& GetSurfaceParams() const {
return params;
}
TView* GetView(GPUVAddr view_addr, const SurfaceParams& view_params) {
TView* view{TryGetView(view_addr, view_params)};
ASSERT(view != nullptr);
return view;
}
void Register(GPUVAddr gpu_addr_, VAddr cpu_addr_, u8* host_ptr_) {
ASSERT(!is_registered);
is_registered = true;
@ -361,30 +318,95 @@ public:
is_registered = false;
}
u64 GetModificationTick() const {
return modification_tick;
}
bool IsRegistered() const {
return is_registered;
}
protected:
explicit SurfaceBase(TTextureCache& texture_cache, const SurfaceParams& params)
: params{params}, texture_cache{texture_cache}, view_offset_map{
params.CreateViewOffsetMap()} {}
std::size_t GetSizeInBytes() const {
return params.GetGuestSizeInBytes();
}
~SurfaceBase() = default;
u8* GetStagingBufferLevelData(u32 level) {
return staging_buffer.data() + params.GetHostMipmapLevelOffset(level);
}
protected:
explicit SurfaceBaseImpl(const SurfaceParams& params);
~SurfaceBaseImpl(); // non-virtual is intended
virtual void DecorateSurfaceName() = 0;
virtual std::unique_ptr<TView> CreateView(const ViewKey& view_key) = 0;
const SurfaceParams params;
private:
GPUVAddr gpu_addr{};
VAddr cpu_addr{};
u8* host_ptr{};
CacheAddr cache_addr{};
bool is_registered{};
std::vector<u8> staging_buffer;
};
template <typename TTextureCache, typename TView, typename TExecutionContext>
class SurfaceBase : public SurfaceBaseImpl {
static_assert(std::is_trivially_copyable_v<TExecutionContext>);
public:
virtual TExecutionContext UploadTexture(TExecutionContext exctx) = 0;
virtual TExecutionContext DownloadTexture(TExecutionContext exctx) = 0;
TView* TryGetView(GPUVAddr view_addr, const SurfaceParams& view_params) {
if (view_addr < GetGpuAddr() || !params.IsFamiliar(view_params)) {
// It can't be a view if it's in a prior address.
return {};
}
const auto relative_offset{static_cast<u64>(view_addr - GetGpuAddr())};
const auto it{view_offset_map.find(relative_offset)};
if (it == view_offset_map.end()) {
// Couldn't find an aligned view.
return {};
}
const auto [layer, level] = it->second;
if (!params.IsViewValid(view_params, layer, level)) {
return {};
}
return GetView(layer, view_params.GetNumLayers(), level, view_params.GetNumLevels());
}
void MarkAsModified(bool is_modified_) {
is_modified = is_modified_;
if (is_modified_) {
modification_tick = texture_cache.Tick();
}
}
TView* GetView(GPUVAddr view_addr, const SurfaceParams& view_params) {
TView* view{TryGetView(view_addr, view_params)};
ASSERT(view != nullptr);
return view;
}
bool IsModified() const {
return is_modified;
}
const SurfaceParams params;
u64 GetModificationTick() const {
return modification_tick;
}
protected:
explicit SurfaceBase(TTextureCache& texture_cache, const SurfaceParams& params)
: SurfaceBaseImpl{params}, texture_cache{texture_cache},
view_offset_map{params.CreateViewOffsetMap()} {}
~SurfaceBase() = default;
virtual std::unique_ptr<TView> CreateView(const ViewKey& view_key) = 0;
private:
TView* GetView(u32 base_layer, u32 num_layers, u32 base_level, u32 num_levels) {
@ -400,13 +422,8 @@ private:
TTextureCache& texture_cache;
const std::map<u64, std::pair<u32, u32>> view_offset_map;
GPUVAddr gpu_addr{};
VAddr cpu_addr{};
u8* host_ptr{};
CacheAddr cache_addr{};
u64 modification_tick{};
bool is_modified{};
bool is_registered{};
u64 modification_tick{};
std::unordered_map<ViewKey, std::unique_ptr<TView>> views;
};
@ -560,7 +577,7 @@ private:
if (!fast_view) {
// Flush even when we don't care about the contents, to preserve memory not
// written by the new surface.
exctx = surface->FlushBuffer(exctx);
exctx = FlushSurface(exctx, surface);
}
Unregister(surface);
}
@ -590,6 +607,16 @@ private:
return exctx;
}
TExecutionContext FlushSurface(TExecutionContext exctx,
const std::shared_ptr<TSurface>& surface) {
if (!surface->IsModified()) {
return exctx;
}
exctx = surface->DownloadTexture(exctx);
surface->FlushBuffer();
return exctx;
}
std::vector<std::shared_ptr<TSurface>> GetSurfacesInRegion(CacheAddr cache_addr,
std::size_t size) const {
if (size == 0) {
@ -701,8 +728,8 @@ private:
template <typename TTextureCache, typename TView>
class SurfaceBaseContextless : public SurfaceBase<TTextureCache, TView, DummyExecutionContext> {
public:
DummyExecutionContext FlushBuffer(DummyExecutionContext) {
FlushBufferImpl();
DummyExecutionContext DownloadTexture(DummyExecutionContext) {
DownloadTextureImpl();
return {};
}
@ -715,7 +742,7 @@ protected:
explicit SurfaceBaseContextless(TTextureCache& texture_cache, const SurfaceParams& params)
: SurfaceBase<TTextureCache, TView, DummyExecutionContext>{texture_cache, params} {}
virtual void FlushBufferImpl() = 0;
virtual void DownloadTextureImpl() = 0;
virtual void UploadTextureImpl() = 0;
};