Rename VirtGpuBlob -> VirtGpuResource
... as this is more generic and "VirglBlob" is not actually a blob.
find . -type f -name "*.cpp" -print0 | \
xargs -0 sed -i '' -e 's/VirtGpuBlob/VirtGpuResource/g'
find . -type f -name "*.h" -print0 | \
xargs -0 sed -i '' -e 's/VirtGpuBlob/VirtGpuResource/g'
find . -type f -name "*.cpp" -print0 | \
xargs -0 sed -i '' -e 's/createVirglBlob/createResource/g'
find . -type f -name "*.h" -print0 | \
xargs -0 sed -i '' -e 's/createVirglBlob/createResource/g'
Bug: b/283005889
Test: cd hardware/google/gfxstream && mma
Change-Id: Ic3ecae7f692a6e22de183626f0dd8f69148edc33
diff --git a/guest/GoldfishAddressSpace/VirtioGpuAddressSpaceStream.cpp b/guest/GoldfishAddressSpace/VirtioGpuAddressSpaceStream.cpp
index 7f6023e..03acca8 100644
--- a/guest/GoldfishAddressSpace/VirtioGpuAddressSpaceStream.cpp
+++ b/guest/GoldfishAddressSpace/VirtioGpuAddressSpaceStream.cpp
@@ -76,8 +76,8 @@
AddressSpaceStream* createVirtioGpuAddressSpaceStream(enum VirtGpuCapset capset,
HealthMonitor<>* healthMonitor) {
- VirtGpuBlobPtr pipe, blob;
- VirtGpuBlobMappingPtr pipeMapping, blobMapping;
+ VirtGpuResourcePtr pipe, blob;
+ VirtGpuResourceMappingPtr pipeMapping, blobMapping;
struct VirtGpuExecBuffer exec = {};
struct VirtGpuCreateBlob blobCreate = {};
struct gfxstreamContextCreate contextCreate = {};
diff --git a/guest/GoldfishAddressSpace/include/AddressSpaceStream.h b/guest/GoldfishAddressSpace/include/AddressSpaceStream.h
index a2063cf..d602598 100644
--- a/guest/GoldfishAddressSpace/include/AddressSpaceStream.h
+++ b/guest/GoldfishAddressSpace/include/AddressSpaceStream.h
@@ -46,9 +46,7 @@
virtual int writeFullyAsync(const void *buf, size_t len);
virtual const unsigned char *commitBufferAndReadFully(size_t size, void *buf, size_t len);
- void setMapping(VirtGpuBlobMappingPtr mapping) {
- m_mapping = mapping;
- }
+ void setMapping(VirtGpuResourceMappingPtr mapping) { m_mapping = mapping; }
void setResourceId(uint32_t id) {
m_resourceId = id;
@@ -68,7 +66,7 @@
void backoff();
void resetBackoff();
- VirtGpuBlobMappingPtr m_mapping = nullptr;
+ VirtGpuResourceMappingPtr m_mapping = nullptr;
struct address_space_ops m_ops;
unsigned char* m_tmpBuf;
diff --git a/guest/OpenglSystemCommon/VirtioGpuPipeStream.cpp b/guest/OpenglSystemCommon/VirtioGpuPipeStream.cpp
index 6d7add5..e8998c9 100644
--- a/guest/OpenglSystemCommon/VirtioGpuPipeStream.cpp
+++ b/guest/OpenglSystemCommon/VirtioGpuPipeStream.cpp
@@ -68,7 +68,7 @@
return -1;
}
- m_resource = m_device->createVirglBlob(kTransferBufferSize, 1, VIRGL_FORMAT_R8_UNORM);
+ m_resource = m_device->createResource(kTransferBufferSize, 1, VIRGL_FORMAT_R8_UNORM);
if (!m_resource) {
ALOGE("Failed to create VirtioGpuPipeStream resource.");
return -1;
diff --git a/guest/OpenglSystemCommon/VirtioGpuPipeStream.h b/guest/OpenglSystemCommon/VirtioGpuPipeStream.h
index 7afdf6e..7756ab9 100644
--- a/guest/OpenglSystemCommon/VirtioGpuPipeStream.h
+++ b/guest/OpenglSystemCommon/VirtioGpuPipeStream.h
@@ -58,8 +58,8 @@
int m_fd = -1;
std::unique_ptr<VirtGpuDevice> m_device;
- VirtGpuBlobPtr m_resource;
- VirtGpuBlobMappingPtr m_resourceMapping;
+ VirtGpuResourcePtr m_resource;
+ VirtGpuResourceMappingPtr m_resourceMapping;
unsigned char* m_virtio_mapped; // user mapping of bo
// intermediate buffer
diff --git a/guest/android/GrallocEmulated.cpp b/guest/android/GrallocEmulated.cpp
index d120700..e0ff11f 100644
--- a/guest/android/GrallocEmulated.cpp
+++ b/guest/android/GrallocEmulated.cpp
@@ -85,7 +85,7 @@
} // namespace
EmulatedAHardwareBuffer::EmulatedAHardwareBuffer(uint32_t width, uint32_t height,
- VirtGpuBlobPtr resource)
+ VirtGpuResourcePtr resource)
: mRefCount(1), mWidth(width), mHeight(height), mResource(resource) {}
EmulatedAHardwareBuffer::~EmulatedAHardwareBuffer() {}
@@ -196,7 +196,7 @@
return nullptr;
}
- auto resource = device->createVirglBlob(width, height, *virglFormat);
+ auto resource = device->createResource(width, height, *virglFormat);
if (!resource) {
ALOGE("Failed to allocate: failed to create virtio resource.");
return nullptr;
diff --git a/guest/android/GrallocEmulated.h b/guest/android/GrallocEmulated.h
index ded73f5..10892f7 100644
--- a/guest/android/GrallocEmulated.h
+++ b/guest/android/GrallocEmulated.h
@@ -26,7 +26,7 @@
class EmulatedAHardwareBuffer {
public:
- EmulatedAHardwareBuffer(uint32_t width, uint32_t height, VirtGpuBlobPtr resource);
+ EmulatedAHardwareBuffer(uint32_t width, uint32_t height, VirtGpuResourcePtr resource);
~EmulatedAHardwareBuffer();
@@ -56,8 +56,8 @@
uint32_t mRefCount;
uint32_t mWidth;
uint32_t mHeight;
- VirtGpuBlobPtr mResource;
- std::optional<VirtGpuBlobMappingPtr> mMapped;
+ VirtGpuResourcePtr mResource;
+ std::optional<VirtGpuResourceMappingPtr> mMapped;
};
class EmulatedGralloc : public Gralloc {
diff --git a/guest/magma/magma.cpp b/guest/magma/magma.cpp
index 6f256a6..4f4fa2c 100644
--- a/guest/magma/magma.cpp
+++ b/guest/magma/magma.cpp
@@ -224,7 +224,7 @@
VirtGpuExternalHandle handle{};
int result = blob->exportBlob(handle);
if (result != 0 || handle.osHandle < 0) {
- ALOGE("VirtGpuBlob::exportBlob failed\n");
+ ALOGE("VirtGpuResource::exportBlob failed\n");
return MAGMA_STATUS_INTERNAL_ERROR;
}
diff --git a/guest/platform/fuchsia/FuchsiaVirtGpu.h b/guest/platform/fuchsia/FuchsiaVirtGpu.h
index eef3e5c..7c91fbe 100644
--- a/guest/platform/fuchsia/FuchsiaVirtGpu.h
+++ b/guest/platform/fuchsia/FuchsiaVirtGpu.h
@@ -20,12 +20,12 @@
#include "VirtGpu.h"
-class FuchsiaVirtGpuBlob : public std::enable_shared_from_this<FuchsiaVirtGpuBlob>,
- public VirtGpuBlob {
+class FuchsiaVirtGpuResource : public std::enable_shared_from_this<FuchsiaVirtGpuResource>,
+ public VirtGpuResource {
public:
- FuchsiaVirtGpuBlob(int64_t deviceHandle, uint32_t blobHandle, uint32_t resourceHandle,
- uint64_t size);
- ~FuchsiaVirtGpuBlob();
+ FuchsiaVirtGpuResource(int64_t deviceHandle, uint32_t blobHandle, uint32_t resourceHandle,
+ uint64_t size);
+ ~FuchsiaVirtGpuResource();
uint32_t getResourceHandle() const override;
uint32_t getBlobHandle() const override;
@@ -35,13 +35,13 @@
int transferFromHost(uint32_t offset, uint32_t size) override;
int transferToHost(uint32_t offset, uint32_t size) override;
- VirtGpuBlobMappingPtr createMapping(void) override;
+ VirtGpuResourceMappingPtr createMapping(void) override;
};
-class FuchsiaVirtGpuBlobMapping : public VirtGpuBlobMapping {
+class FuchsiaVirtGpuResourceMapping : public VirtGpuResourceMapping {
public:
- FuchsiaVirtGpuBlobMapping(VirtGpuBlobPtr blob, uint8_t* ptr, uint64_t size);
- ~FuchsiaVirtGpuBlobMapping(void);
+ FuchsiaVirtGpuResourceMapping(VirtGpuResourcePtr blob, uint8_t* ptr, uint64_t size);
+ ~FuchsiaVirtGpuResourceMapping(void);
uint8_t* asRawPtr(void) override;
};
@@ -55,11 +55,11 @@
struct VirtGpuCaps getCaps(void) override;
- VirtGpuBlobPtr createBlob(const struct VirtGpuCreateBlob& blobCreate) override;
- VirtGpuBlobPtr createVirglBlob(uint32_t width, uint32_t height, uint32_t format) override;
- VirtGpuBlobPtr importBlob(const struct VirtGpuExternalHandle& handle) override;
+ VirtGpuResourcePtr createBlob(const struct VirtGpuCreateBlob& blobCreate) override;
+ VirtGpuResourcePtr createResource(uint32_t width, uint32_t height, uint32_t format) override;
+ VirtGpuResourcePtr importBlob(const struct VirtGpuExternalHandle& handle) override;
- int execBuffer(struct VirtGpuExecBuffer& execbuffer, const VirtGpuBlob* blob) override;
+ int execBuffer(struct VirtGpuExecBuffer& execbuffer, const VirtGpuResource* blob) override;
private:
magma_device_t device_;
diff --git a/guest/platform/fuchsia/FuchsiaVirtGpuBlob.cpp b/guest/platform/fuchsia/FuchsiaVirtGpuBlob.cpp
index 8e512a7..1e99459 100644
--- a/guest/platform/fuchsia/FuchsiaVirtGpuBlob.cpp
+++ b/guest/platform/fuchsia/FuchsiaVirtGpuBlob.cpp
@@ -18,39 +18,39 @@
#include "FuchsiaVirtGpu.h"
-FuchsiaVirtGpuBlob::FuchsiaVirtGpuBlob(int64_t deviceHandle, uint32_t blobHandle,
- uint32_t resourceHandle, uint64_t size) {}
+FuchsiaVirtGpuResource::FuchsiaVirtGpuResource(int64_t deviceHandle, uint32_t blobHandle,
+ uint32_t resourceHandle, uint64_t size) {}
-FuchsiaVirtGpuBlob::~FuchsiaVirtGpuBlob(void) {}
+FuchsiaVirtGpuResource::~FuchsiaVirtGpuResource(void) {}
-uint32_t FuchsiaVirtGpuBlob::getBlobHandle() const {
+uint32_t FuchsiaVirtGpuResource::getBlobHandle() const {
ALOGE("%s: unimplemented", __func__);
return 0;
}
-uint32_t FuchsiaVirtGpuBlob::getResourceHandle() const {
+uint32_t FuchsiaVirtGpuResource::getResourceHandle() const {
ALOGE("%s: unimplemented", __func__);
return 0;
}
-VirtGpuBlobMappingPtr FuchsiaVirtGpuBlob::createMapping(void) {
+VirtGpuResourceMappingPtr FuchsiaVirtGpuResource::createMapping(void) {
ALOGE("%s: unimplemented", __func__);
return nullptr;
}
-int FuchsiaVirtGpuBlob::wait() { return -1; }
+int FuchsiaVirtGpuResource::wait() { return -1; }
-int FuchsiaVirtGpuBlob::exportBlob(struct VirtGpuExternalHandle& handle) {
+int FuchsiaVirtGpuResource::exportBlob(struct VirtGpuExternalHandle& handle) {
ALOGE("%s: unimplemented", __func__);
return 0;
}
-int FuchsiaVirtGpuBlob::transferFromHost(uint32_t offset, uint32_t size) {
+int FuchsiaVirtGpuResource::transferFromHost(uint32_t offset, uint32_t size) {
ALOGE("%s: unimplemented", __func__);
return 0;
}
-int FuchsiaVirtGpuBlob::transferToHost(uint32_t offset, uint32_t size) {
+int FuchsiaVirtGpuResource::transferToHost(uint32_t offset, uint32_t size) {
ALOGE("%s: unimplemented", __func__);
return 0;
}
diff --git a/guest/platform/fuchsia/FuchsiaVirtGpuBlobMapping.cpp b/guest/platform/fuchsia/FuchsiaVirtGpuBlobMapping.cpp
index 9eb58dc..453aa5b 100644
--- a/guest/platform/fuchsia/FuchsiaVirtGpuBlobMapping.cpp
+++ b/guest/platform/fuchsia/FuchsiaVirtGpuBlobMapping.cpp
@@ -16,9 +16,9 @@
#include "FuchsiaVirtGpu.h"
-FuchsiaVirtGpuBlobMapping::FuchsiaVirtGpuBlobMapping(VirtGpuBlobPtr blob, uint8_t* ptr,
- uint64_t size) {}
+FuchsiaVirtGpuResourceMapping::FuchsiaVirtGpuResourceMapping(VirtGpuResourcePtr blob, uint8_t* ptr,
+ uint64_t size) {}
-FuchsiaVirtGpuBlobMapping::~FuchsiaVirtGpuBlobMapping(void) {}
+FuchsiaVirtGpuResourceMapping::~FuchsiaVirtGpuResourceMapping(void) {}
-uint8_t* FuchsiaVirtGpuBlobMapping::asRawPtr(void) { return nullptr; }
+uint8_t* FuchsiaVirtGpuResourceMapping::asRawPtr(void) { return nullptr; }
diff --git a/guest/platform/fuchsia/FuchsiaVirtGpuDevice.cpp b/guest/platform/fuchsia/FuchsiaVirtGpuDevice.cpp
index 000ebb3..23bca2d 100644
--- a/guest/platform/fuchsia/FuchsiaVirtGpuDevice.cpp
+++ b/guest/platform/fuchsia/FuchsiaVirtGpuDevice.cpp
@@ -32,24 +32,24 @@
int64_t FuchsiaVirtGpuDevice::getDeviceHandle(void) { return device_; }
-VirtGpuBlobPtr FuchsiaVirtGpuDevice::createBlob(const struct VirtGpuCreateBlob& blobCreate) {
+VirtGpuResourcePtr FuchsiaVirtGpuDevice::createBlob(const struct VirtGpuCreateBlob& blobCreate) {
ALOGE("%s: unimplemented", __func__);
return nullptr;
}
-VirtGpuBlobPtr FuchsiaVirtGpuDevice::createVirglBlob(uint32_t width, uint32_t height,
- uint32_t virglFormat) {
+VirtGpuResourcePtr FuchsiaVirtGpuDevice::createResource(uint32_t width, uint32_t height,
+ uint32_t virglFormat) {
ALOGE("%s: unimplemented", __func__);
return nullptr;
}
-VirtGpuBlobPtr FuchsiaVirtGpuDevice::importBlob(const struct VirtGpuExternalHandle& handle) {
+VirtGpuResourcePtr FuchsiaVirtGpuDevice::importBlob(const struct VirtGpuExternalHandle& handle) {
ALOGE("%s: unimplemented", __func__);
return nullptr;
}
int FuchsiaVirtGpuDevice::execBuffer(struct VirtGpuExecBuffer& execbuffer,
- const VirtGpuBlob* blob) {
+ const VirtGpuResource* blob) {
ALOGE("%s: unimplemented", __func__);
return 0;
}
diff --git a/guest/platform/include/VirtGpu.h b/guest/platform/include/VirtGpu.h
index b9e039a..54f8394 100644
--- a/guest/platform/include/VirtGpu.h
+++ b/guest/platform/include/VirtGpu.h
@@ -30,6 +30,8 @@
#define VIRGL_BIND_RENDER_TARGET (1 << 1)
#define VIRGL_BIND_CUSTOM (1 << 17)
+#define VIRGL_BIND_LINEAR (1 << 22)
+
#define PIPE_BUFFER 0
#define PIPE_TEXTURE_2D 2
@@ -78,14 +80,14 @@
kFenceHandleZircon = 0x0080,
};
-enum VirtGpuBlobFlags : uint32_t {
+enum VirtGpuResourceFlags : uint32_t {
kBlobFlagMappable = 0x0001,
kBlobFlagShareable = 0x0002,
kBlobFlagCrossDevice = 0x0004,
kBlobFlagCreateGuestHandle = 0x0008,
};
-enum VirtGpuBlobMem {
+enum VirtGpuResourceMem {
kBlobMemGuest = 0x0001,
kBlobMemHost3d = 0x0002,
kBlobMemHost3dGuest = 0x0003,
@@ -112,8 +114,8 @@
struct VirtGpuCreateBlob {
uint64_t size;
- enum VirtGpuBlobFlags flags;
- enum VirtGpuBlobMem blobMem;
+ enum VirtGpuResourceFlags flags;
+ enum VirtGpuResourceMem blobMem;
uint64_t blobId;
};
@@ -125,20 +127,20 @@
struct composerCapset composerCapset;
};
-class VirtGpuBlobMapping;
-class VirtGpuBlob;
-using VirtGpuBlobPtr = std::shared_ptr<VirtGpuBlob>;
-using VirtGpuBlobMappingPtr = std::shared_ptr<VirtGpuBlobMapping>;
+class VirtGpuResourceMapping;
+class VirtGpuResource;
+using VirtGpuResourcePtr = std::shared_ptr<VirtGpuResource>;
+using VirtGpuResourceMappingPtr = std::shared_ptr<VirtGpuResourceMapping>;
-class VirtGpuBlob {
- public:
- virtual ~VirtGpuBlob() {}
+class VirtGpuResource {
+ public:
+ virtual ~VirtGpuResource() {}
virtual uint32_t getResourceHandle() const = 0;
virtual uint32_t getBlobHandle() const = 0;
virtual int wait() = 0;
- virtual VirtGpuBlobMappingPtr createMapping(void) = 0;
+ virtual VirtGpuResourceMappingPtr createMapping(void) = 0;
virtual int exportBlob(struct VirtGpuExternalHandle& handle) = 0;
virtual int transferFromHost(uint32_t x, uint32_t y, uint32_t w, uint32_t h) = 0;
@@ -152,9 +154,9 @@
}
};
-class VirtGpuBlobMapping {
- public:
- virtual ~VirtGpuBlobMapping(void) {}
+class VirtGpuResourceMapping {
+ public:
+ virtual ~VirtGpuResourceMapping(void) {}
virtual uint8_t* asRawPtr(void) = 0;
};
@@ -175,11 +177,12 @@
virtual struct VirtGpuCaps getCaps(void) = 0;
- virtual VirtGpuBlobPtr createBlob(const struct VirtGpuCreateBlob& blobCreate) = 0;
- virtual VirtGpuBlobPtr createVirglBlob(uint32_t width, uint32_t height, uint32_t virglFormat) = 0;
- virtual VirtGpuBlobPtr importBlob(const struct VirtGpuExternalHandle& handle) = 0;
+ virtual VirtGpuResourcePtr createBlob(const struct VirtGpuCreateBlob& blobCreate) = 0;
+ virtual VirtGpuResourcePtr createResource(uint32_t width, uint32_t height,
+ uint32_t virglFormat) = 0;
+ virtual VirtGpuResourcePtr importBlob(const struct VirtGpuExternalHandle& handle) = 0;
- virtual int execBuffer(struct VirtGpuExecBuffer& execbuffer, const VirtGpuBlob* blob) = 0;
+ virtual int execBuffer(struct VirtGpuExecBuffer& execbuffer, const VirtGpuResource* blob) = 0;
private:
enum VirtGpuCapset mCapset;
@@ -190,9 +193,9 @@
// HACK: We can use gfxstream::guest::EnumFlags, but we'll have to do more guest
// refactorings to figure out our end goal. We can either depend more on base or
// try to transition to something else (b:202552093) [atleast for guests].
-constexpr enum VirtGpuBlobFlags operator |(const enum VirtGpuBlobFlags self,
- const enum VirtGpuBlobFlags other) {
- return (enum VirtGpuBlobFlags)(uint32_t(self) | uint32_t(other));
+constexpr enum VirtGpuResourceFlags operator|(const enum VirtGpuResourceFlags self,
+ const enum VirtGpuResourceFlags other) {
+ return (enum VirtGpuResourceFlags)(uint32_t(self) | uint32_t(other));
}
constexpr enum VirtGpuExecBufferFlags operator |(const enum VirtGpuExecBufferFlags self,
diff --git a/guest/platform/linux/LinuxVirtGpu.h b/guest/platform/linux/LinuxVirtGpu.h
index 8533280..e8bdc78 100644
--- a/guest/platform/linux/LinuxVirtGpu.h
+++ b/guest/platform/linux/LinuxVirtGpu.h
@@ -18,17 +18,18 @@
#include "VirtGpu.h"
-class LinuxVirtGpuBlob : public std::enable_shared_from_this<LinuxVirtGpuBlob>, public VirtGpuBlob {
+class LinuxVirtGpuResource : public std::enable_shared_from_this<LinuxVirtGpuResource>,
+ public VirtGpuResource {
public:
- LinuxVirtGpuBlob(int64_t deviceHandle, uint32_t blobHandle, uint32_t resourceHandle,
- uint64_t size);
- ~LinuxVirtGpuBlob();
+ LinuxVirtGpuResource(int64_t deviceHandle, uint32_t blobHandle, uint32_t resourceHandle,
+ uint64_t size);
+ ~LinuxVirtGpuResource();
uint32_t getResourceHandle() const override;
uint32_t getBlobHandle() const override;
int wait() override;
- VirtGpuBlobMappingPtr createMapping(void) override;
+ VirtGpuResourceMappingPtr createMapping(void) override;
int exportBlob(struct VirtGpuExternalHandle& handle) override;
int transferFromHost(uint32_t x, uint32_t y, uint32_t w, uint32_t h) override;
@@ -44,15 +45,15 @@
uint64_t mSize;
};
-class LinuxVirtGpuBlobMapping : public VirtGpuBlobMapping {
+class LinuxVirtGpuResourceMapping : public VirtGpuResourceMapping {
public:
- LinuxVirtGpuBlobMapping(VirtGpuBlobPtr blob, uint8_t* ptr, uint64_t size);
- ~LinuxVirtGpuBlobMapping(void);
+ LinuxVirtGpuResourceMapping(VirtGpuResourcePtr blob, uint8_t* ptr, uint64_t size);
+ ~LinuxVirtGpuResourceMapping(void);
uint8_t* asRawPtr(void) override;
private:
- VirtGpuBlobPtr mBlob;
+ VirtGpuResourcePtr mBlob;
uint8_t* mPtr;
uint64_t mSize;
};
@@ -66,11 +67,12 @@
virtual struct VirtGpuCaps getCaps(void);
- VirtGpuBlobPtr createBlob(const struct VirtGpuCreateBlob& blobCreate) override;
- VirtGpuBlobPtr createVirglBlob(uint32_t width, uint32_t height, uint32_t virglFormat) override;
+ VirtGpuResourcePtr createBlob(const struct VirtGpuCreateBlob& blobCreate) override;
+ VirtGpuResourcePtr createResource(uint32_t width, uint32_t height,
+ uint32_t virglFormat) override;
- virtual VirtGpuBlobPtr importBlob(const struct VirtGpuExternalHandle& handle);
- virtual int execBuffer(struct VirtGpuExecBuffer& execbuffer, const VirtGpuBlob* blob);
+ virtual VirtGpuResourcePtr importBlob(const struct VirtGpuExternalHandle& handle);
+ virtual int execBuffer(struct VirtGpuExecBuffer& execbuffer, const VirtGpuResource* blob);
private:
int64_t mDeviceHandle;
diff --git a/guest/platform/linux/LinuxVirtGpuBlob.cpp b/guest/platform/linux/LinuxVirtGpuBlob.cpp
index bbf3d36..1b6e07d 100644
--- a/guest/platform/linux/LinuxVirtGpuBlob.cpp
+++ b/guest/platform/linux/LinuxVirtGpuBlob.cpp
@@ -26,14 +26,14 @@
#include "LinuxVirtGpu.h"
#include "virtgpu_drm.h"
-LinuxVirtGpuBlob::LinuxVirtGpuBlob(int64_t deviceHandle, uint32_t blobHandle,
- uint32_t resourceHandle, uint64_t size)
+LinuxVirtGpuResource::LinuxVirtGpuResource(int64_t deviceHandle, uint32_t blobHandle,
+ uint32_t resourceHandle, uint64_t size)
: mDeviceHandle(deviceHandle),
mBlobHandle(blobHandle),
mResourceHandle(resourceHandle),
mSize(size) {}
-LinuxVirtGpuBlob::~LinuxVirtGpuBlob() {
+LinuxVirtGpuResource::~LinuxVirtGpuResource() {
struct drm_gem_close gem_close {
.handle = mBlobHandle, .pad = 0,
};
@@ -45,11 +45,11 @@
}
}
-uint32_t LinuxVirtGpuBlob::getBlobHandle() const { return mBlobHandle; }
+uint32_t LinuxVirtGpuResource::getBlobHandle() const { return mBlobHandle; }
-uint32_t LinuxVirtGpuBlob::getResourceHandle() const { return mResourceHandle; }
+uint32_t LinuxVirtGpuResource::getResourceHandle() const { return mResourceHandle; }
-VirtGpuBlobMappingPtr LinuxVirtGpuBlob::createMapping() {
+VirtGpuResourceMappingPtr LinuxVirtGpuResource::createMapping() {
int ret;
struct drm_virtgpu_map map {
.handle = mBlobHandle, .pad = 0,
@@ -69,10 +69,10 @@
return nullptr;
}
- return std::make_shared<LinuxVirtGpuBlobMapping>(shared_from_this(), ptr, mSize);
+ return std::make_shared<LinuxVirtGpuResourceMapping>(shared_from_this(), ptr, mSize);
}
-int LinuxVirtGpuBlob::exportBlob(struct VirtGpuExternalHandle& handle) {
+int LinuxVirtGpuResource::exportBlob(struct VirtGpuExternalHandle& handle) {
int ret, fd;
uint32_t flags = DRM_CLOEXEC;
@@ -87,7 +87,7 @@
return 0;
}
-int LinuxVirtGpuBlob::wait() {
+int LinuxVirtGpuResource::wait() {
int ret;
struct drm_virtgpu_3d_wait wait_3d = {0};
@@ -109,7 +109,7 @@
return 0;
}
-int LinuxVirtGpuBlob::transferToHost(uint32_t x, uint32_t y, uint32_t w, uint32_t h) {
+int LinuxVirtGpuResource::transferToHost(uint32_t x, uint32_t y, uint32_t w, uint32_t h) {
int ret;
struct drm_virtgpu_3d_transfer_to_host xfer = {0};
@@ -129,7 +129,7 @@
return 0;
}
-int LinuxVirtGpuBlob::transferFromHost(uint32_t x, uint32_t y, uint32_t w, uint32_t h) {
+int LinuxVirtGpuResource::transferFromHost(uint32_t x, uint32_t y, uint32_t w, uint32_t h) {
int ret;
struct drm_virtgpu_3d_transfer_from_host xfer = {0};
diff --git a/guest/platform/linux/LinuxVirtGpuBlobMapping.cpp b/guest/platform/linux/LinuxVirtGpuBlobMapping.cpp
index 69e0e18..d977d99 100644
--- a/guest/platform/linux/LinuxVirtGpuBlobMapping.cpp
+++ b/guest/platform/linux/LinuxVirtGpuBlobMapping.cpp
@@ -18,9 +18,10 @@
#include "LinuxVirtGpu.h"
-LinuxVirtGpuBlobMapping::LinuxVirtGpuBlobMapping(VirtGpuBlobPtr blob, uint8_t* ptr, uint64_t size)
+LinuxVirtGpuResourceMapping::LinuxVirtGpuResourceMapping(VirtGpuResourcePtr blob, uint8_t* ptr,
+ uint64_t size)
: mBlob(blob), mPtr(ptr), mSize(size) {}
-LinuxVirtGpuBlobMapping::~LinuxVirtGpuBlobMapping(void) { munmap(mPtr, mSize); }
+LinuxVirtGpuResourceMapping::~LinuxVirtGpuResourceMapping(void) { munmap(mPtr, mSize); }
-uint8_t* LinuxVirtGpuBlobMapping::asRawPtr(void) { return mPtr; }
+uint8_t* LinuxVirtGpuResourceMapping::asRawPtr(void) { return mPtr; }
diff --git a/guest/platform/linux/LinuxVirtGpuDevice.cpp b/guest/platform/linux/LinuxVirtGpuDevice.cpp
index 0157115..856b3b4 100644
--- a/guest/platform/linux/LinuxVirtGpuDevice.cpp
+++ b/guest/platform/linux/LinuxVirtGpuDevice.cpp
@@ -149,8 +149,8 @@
int64_t LinuxVirtGpuDevice::getDeviceHandle(void) { return mDeviceHandle; }
-VirtGpuBlobPtr LinuxVirtGpuDevice::createVirglBlob(uint32_t width, uint32_t height,
- uint32_t virglFormat) {
+VirtGpuResourcePtr LinuxVirtGpuDevice::createResource(uint32_t width, uint32_t height,
+ uint32_t virglFormat) {
uint32_t target = 0;
uint32_t bind = 0;
uint32_t bpp = 0;
@@ -192,11 +192,11 @@
return nullptr;
}
- return std::make_shared<LinuxVirtGpuBlob>(mDeviceHandle, create.bo_handle, create.res_handle,
- static_cast<uint64_t>(create.size));
+ return std::make_shared<LinuxVirtGpuResource>(
+ mDeviceHandle, create.bo_handle, create.res_handle, static_cast<uint64_t>(create.size));
}
-VirtGpuBlobPtr LinuxVirtGpuDevice::createBlob(const struct VirtGpuCreateBlob& blobCreate) {
+VirtGpuResourcePtr LinuxVirtGpuDevice::createBlob(const struct VirtGpuCreateBlob& blobCreate) {
int ret;
struct drm_virtgpu_resource_create_blob create = {0};
@@ -211,11 +211,11 @@
return nullptr;
}
- return std::make_shared<LinuxVirtGpuBlob>(mDeviceHandle, create.bo_handle, create.res_handle,
- blobCreate.size);
+ return std::make_shared<LinuxVirtGpuResource>(mDeviceHandle, create.bo_handle,
+ create.res_handle, blobCreate.size);
}
-VirtGpuBlobPtr LinuxVirtGpuDevice::importBlob(const struct VirtGpuExternalHandle& handle) {
+VirtGpuResourcePtr LinuxVirtGpuDevice::importBlob(const struct VirtGpuExternalHandle& handle) {
struct drm_virtgpu_resource_info info = {0};
uint32_t blobHandle;
int ret;
@@ -234,11 +234,12 @@
return nullptr;
}
- return std::make_shared<LinuxVirtGpuBlob>(mDeviceHandle, blobHandle, info.res_handle,
- static_cast<uint64_t>(info.size));
+ return std::make_shared<LinuxVirtGpuResource>(mDeviceHandle, blobHandle, info.res_handle,
+ static_cast<uint64_t>(info.size));
}
-int LinuxVirtGpuDevice::execBuffer(struct VirtGpuExecBuffer& execbuffer, const VirtGpuBlob* blob) {
+int LinuxVirtGpuDevice::execBuffer(struct VirtGpuExecBuffer& execbuffer,
+ const VirtGpuResource* blob) {
int ret;
struct drm_virtgpu_execbuffer exec = {0};
uint32_t blobHandle;
diff --git a/guest/platform/rutabaga/RutabagaVirtGpu.h b/guest/platform/rutabaga/RutabagaVirtGpu.h
index 2e605e6..b806bcf 100644
--- a/guest/platform/rutabaga/RutabagaVirtGpu.h
+++ b/guest/platform/rutabaga/RutabagaVirtGpu.h
@@ -26,25 +26,26 @@
class RutabagaVirtGpuDevice;
-class RutabagaVirtGpuBlobMapping : public VirtGpuBlobMapping {
- public:
- RutabagaVirtGpuBlobMapping(std::shared_ptr<EmulatedVirtioGpu> emulation, VirtGpuBlobPtr blob,
- uint8_t* mapped);
- ~RutabagaVirtGpuBlobMapping();
+class RutabagaVirtGpuResourceMapping : public VirtGpuResourceMapping {
+ public:
+ RutabagaVirtGpuResourceMapping(std::shared_ptr<EmulatedVirtioGpu> emulation,
+ VirtGpuResourcePtr blob, uint8_t* mapped);
+ ~RutabagaVirtGpuResourceMapping();
- uint8_t* asRawPtr(void) override;
+ uint8_t* asRawPtr(void) override;
- private:
- const std::shared_ptr<EmulatedVirtioGpu> mEmulation;
- const VirtGpuBlobPtr mBlob;
- uint8_t* mMapped = nullptr;
+ private:
+ const std::shared_ptr<EmulatedVirtioGpu> mEmulation;
+ const VirtGpuResourcePtr mBlob;
+ uint8_t* mMapped = nullptr;
};
-class RutabagaVirtGpuResource : public std::enable_shared_from_this<RutabagaVirtGpuResource>, public VirtGpuBlob {
- public:
+class RutabagaVirtGpuResource : public std::enable_shared_from_this<RutabagaVirtGpuResource>,
+ public VirtGpuResource {
+ public:
~RutabagaVirtGpuResource();
- VirtGpuBlobMappingPtr createMapping(void) override;
+ VirtGpuResourceMappingPtr createMapping(void) override;
uint32_t getResourceHandle() const override;
uint32_t getBlobHandle() const override;
@@ -86,13 +87,14 @@
VirtGpuCaps getCaps() override;
- VirtGpuBlobPtr createBlob(const struct VirtGpuCreateBlob& blobCreate) override;
+ VirtGpuResourcePtr createBlob(const struct VirtGpuCreateBlob& blobCreate) override;
- VirtGpuBlobPtr createVirglBlob(uint32_t width, uint32_t height, uint32_t virglFormat) override;
+ VirtGpuResourcePtr createResource(uint32_t width, uint32_t height,
+ uint32_t virglFormat) override;
- VirtGpuBlobPtr importBlob(const struct VirtGpuExternalHandle& handle) override;
+ VirtGpuResourcePtr importBlob(const struct VirtGpuExternalHandle& handle) override;
- int execBuffer(struct VirtGpuExecBuffer& execbuffer, const VirtGpuBlob* blob) override;
+ int execBuffer(struct VirtGpuExecBuffer& execbuffer, const VirtGpuResource* blob) override;
private:
const std::shared_ptr<EmulatedVirtioGpu> mEmulation;
diff --git a/guest/platform/rutabaga/RutabagaVirtGpuBlob.cpp b/guest/platform/rutabaga/RutabagaVirtGpuBlob.cpp
index d9392f0..e2a5310 100644
--- a/guest/platform/rutabaga/RutabagaVirtGpuBlob.cpp
+++ b/guest/platform/rutabaga/RutabagaVirtGpuBlob.cpp
@@ -33,9 +33,9 @@
mEmulation->DestroyResource(mContextId, mResourceId);
}
-VirtGpuBlobMappingPtr RutabagaVirtGpuResource::createMapping(void) {
+VirtGpuResourceMappingPtr RutabagaVirtGpuResource::createMapping(void) {
uint8_t* mapped = mEmulation->Map(mResourceId);
- return std::make_shared<RutabagaVirtGpuBlobMapping>(mEmulation, shared_from_this(), mapped);
+ return std::make_shared<RutabagaVirtGpuResourceMapping>(mEmulation, shared_from_this(), mapped);
}
uint32_t RutabagaVirtGpuResource::getResourceHandle() const { return mResourceId; }
diff --git a/guest/platform/rutabaga/RutabagaVirtGpuBlobMapping.cpp b/guest/platform/rutabaga/RutabagaVirtGpuBlobMapping.cpp
index 750ddee..928532b 100644
--- a/guest/platform/rutabaga/RutabagaVirtGpuBlobMapping.cpp
+++ b/guest/platform/rutabaga/RutabagaVirtGpuBlobMapping.cpp
@@ -19,14 +19,14 @@
namespace gfxstream {
-RutabagaVirtGpuBlobMapping::RutabagaVirtGpuBlobMapping(std::shared_ptr<EmulatedVirtioGpu> emulation,
- VirtGpuBlobPtr blob, uint8_t* mapped)
+RutabagaVirtGpuResourceMapping::RutabagaVirtGpuResourceMapping(
+ std::shared_ptr<EmulatedVirtioGpu> emulation, VirtGpuResourcePtr blob, uint8_t* mapped)
: mEmulation(emulation), mBlob(blob), mMapped(mapped) {}
-RutabagaVirtGpuBlobMapping::~RutabagaVirtGpuBlobMapping(void) {
+RutabagaVirtGpuResourceMapping::~RutabagaVirtGpuResourceMapping(void) {
mEmulation->Unmap(mBlob->getResourceHandle());
}
-uint8_t* RutabagaVirtGpuBlobMapping::asRawPtr(void) { return mMapped; }
+uint8_t* RutabagaVirtGpuResourceMapping::asRawPtr(void) { return mMapped; }
} // namespace gfxstream
diff --git a/guest/platform/rutabaga/RutabagaVirtGpuDevice.cpp b/guest/platform/rutabaga/RutabagaVirtGpuDevice.cpp
index b3cc05d..f534adc 100644
--- a/guest/platform/rutabaga/RutabagaVirtGpuDevice.cpp
+++ b/guest/platform/rutabaga/RutabagaVirtGpuDevice.cpp
@@ -92,7 +92,7 @@
VirtGpuCaps RutabagaVirtGpuDevice::getCaps() { return mCaps; }
-VirtGpuBlobPtr RutabagaVirtGpuDevice::createBlob(const struct VirtGpuCreateBlob& blobCreate) {
+VirtGpuResourcePtr RutabagaVirtGpuDevice::createBlob(const struct VirtGpuCreateBlob& blobCreate) {
const auto resourceIdOpt = mEmulation->CreateBlob(
mContextId, static_cast<uint32_t>(blobCreate.blobMem),
static_cast<uint32_t>(blobCreate.flags), blobCreate.blobId, blobCreate.size);
@@ -100,12 +100,12 @@
return nullptr;
}
- return VirtGpuBlobPtr(new RutabagaVirtGpuResource(
+ return VirtGpuResourcePtr(new RutabagaVirtGpuResource(
mEmulation, *resourceIdOpt, RutabagaVirtGpuResource::ResourceType::kBlob, mContextId));
}
-VirtGpuBlobPtr RutabagaVirtGpuDevice::createVirglBlob(uint32_t width, uint32_t height,
- uint32_t virglFormat) {
+VirtGpuResourcePtr RutabagaVirtGpuDevice::createResource(uint32_t width, uint32_t height,
+ uint32_t virglFormat) {
uint32_t target = 0;
uint32_t bind = 0;
uint32_t bpp = 0;
@@ -146,12 +146,12 @@
return nullptr;
}
- return VirtGpuBlobPtr(new RutabagaVirtGpuResource(
+ return VirtGpuResourcePtr(new RutabagaVirtGpuResource(
mEmulation, *resourceIdOpt, RutabagaVirtGpuResource::ResourceType::kPipe, mContextId));
}
int RutabagaVirtGpuDevice::execBuffer(struct VirtGpuExecBuffer& execbuffer,
- const VirtGpuBlob* blob) {
+ const VirtGpuResource* blob) {
std::optional<uint32_t> blobResourceId;
uint32_t fenceId = 0;
VirtioGpuFenceFlags fenceFlags = kFlagNone;
@@ -175,7 +175,7 @@
return ret;
}
-VirtGpuBlobPtr RutabagaVirtGpuDevice::importBlob(const struct VirtGpuExternalHandle&) {
+VirtGpuResourcePtr RutabagaVirtGpuDevice::importBlob(const struct VirtGpuExternalHandle&) {
ALOGE("Unimplemented %s", __FUNCTION__);
return nullptr;
}
diff --git a/guest/platform/stub/StubVirtGpu.h b/guest/platform/stub/StubVirtGpu.h
index 6a00a4a..a7ad086 100644
--- a/guest/platform/stub/StubVirtGpu.h
+++ b/guest/platform/stub/StubVirtGpu.h
@@ -18,16 +18,18 @@
#include "VirtGpu.h"
-class StubVirtGpuBlob : public std::enable_shared_from_this<StubVirtGpuBlob>, public VirtGpuBlob {
- public:
- StubVirtGpuBlob(int64_t deviceHandle, uint32_t blobHandle, uint32_t resourceHandle, uint64_t size);
- ~StubVirtGpuBlob();
+class StubVirtGpuResource : public std::enable_shared_from_this<StubVirtGpuResource>,
+ public VirtGpuResource {
+ public:
+ StubVirtGpuResource(int64_t deviceHandle, uint32_t blobHandle, uint32_t resourceHandle,
+ uint64_t size);
+ ~StubVirtGpuResource();
uint32_t getResourceHandle() const override;
uint32_t getBlobHandle() const override;
int wait(void) override;
- VirtGpuBlobMappingPtr createMapping(void) override;
+ VirtGpuResourceMappingPtr createMapping(void) override;
int exportBlob(struct VirtGpuExternalHandle& handle) override;
int transferFromHost(uint32_t x, uint32_t y, uint32_t w, uint32_t h) override;
@@ -43,17 +45,17 @@
uint64_t mSize;
};
-class StubVirtGpuBlobMapping : public VirtGpuBlobMapping {
- public:
- StubVirtGpuBlobMapping(VirtGpuBlobPtr blob, uint8_t* ptr, uint64_t size);
- ~StubVirtGpuBlobMapping(void);
+class StubVirtGpuResourceMapping : public VirtGpuResourceMapping {
+ public:
+ StubVirtGpuResourceMapping(VirtGpuResourcePtr blob, uint8_t* ptr, uint64_t size);
+ ~StubVirtGpuResourceMapping(void);
uint8_t* asRawPtr(void) override;
private:
- VirtGpuBlobPtr mBlob;
- uint8_t* mPtr;
- uint64_t mSize;
+ VirtGpuResourcePtr mBlob;
+ uint8_t* mPtr;
+ uint64_t mSize;
};
class StubVirtGpuDevice : public VirtGpuDevice {
@@ -65,16 +67,16 @@
struct VirtGpuCaps getCaps(void) override;
- VirtGpuBlobPtr createBlob(const struct VirtGpuCreateBlob& blobCreate) override;
- VirtGpuBlobPtr createVirglBlob(uint32_t width, uint32_t height, uint32_t virglFormat);
- VirtGpuBlobPtr importBlob(const struct VirtGpuExternalHandle& handle) override;
+ VirtGpuResourcePtr createBlob(const struct VirtGpuCreateBlob& blobCreate) override;
+ VirtGpuResourcePtr createResource(uint32_t width, uint32_t height, uint32_t virglFormat);
+ VirtGpuResourcePtr importBlob(const struct VirtGpuExternalHandle& handle) override;
- int execBuffer(struct VirtGpuExecBuffer& execbuffer, const VirtGpuBlob* blob) override;
+ int execBuffer(struct VirtGpuExecBuffer& execbuffer, const VirtGpuResource* blob) override;
- virtual VirtGpuBlobPtr createColorBuffer(int width, int height, uint32_t glFormat);
- virtual VirtGpuBlobPtr createColorBuffer(int size);
+ virtual VirtGpuResourcePtr createColorBuffer(int width, int height, uint32_t glFormat);
+ virtual VirtGpuResourcePtr createColorBuffer(int size);
- private:
+ private:
int64_t mDeviceHandle;
struct VirtGpuCaps mCaps;
diff --git a/guest/platform/stub/StubVirtGpuBlob.cpp b/guest/platform/stub/StubVirtGpuBlob.cpp
index fb4c789..588d49b 100644
--- a/guest/platform/stub/StubVirtGpuBlob.cpp
+++ b/guest/platform/stub/StubVirtGpuBlob.cpp
@@ -16,27 +16,25 @@
#include "StubVirtGpu.h"
-StubVirtGpuBlob::StubVirtGpuBlob(int64_t deviceHandle, uint32_t blobHandle, uint32_t resourceHandle,
- uint64_t size)
+StubVirtGpuResource::StubVirtGpuResource(int64_t deviceHandle, uint32_t blobHandle,
+ uint32_t resourceHandle, uint64_t size)
: mDeviceHandle(deviceHandle),
mBlobHandle(blobHandle),
mResourceHandle(resourceHandle),
mSize(size) {}
-StubVirtGpuBlob::~StubVirtGpuBlob() {
+StubVirtGpuResource::~StubVirtGpuResource() {
// Unimplemented stub
}
-uint32_t StubVirtGpuBlob::getBlobHandle() const { return 0; }
+uint32_t StubVirtGpuResource::getBlobHandle() const { return 0; }
-uint32_t StubVirtGpuBlob::getResourceHandle() const { return 0; }
+uint32_t StubVirtGpuResource::getResourceHandle() const { return 0; }
-VirtGpuBlobMappingPtr StubVirtGpuBlob::createMapping() { return nullptr; }
+VirtGpuResourceMappingPtr StubVirtGpuResource::createMapping() { return nullptr; }
-int StubVirtGpuBlob::wait() {
- return -1;
-}
+int StubVirtGpuResource::wait() { return -1; }
-int StubVirtGpuBlob::transferFromHost(uint32_t, uint32_t, uint32_t, uint32_t) { return -1; }
+int StubVirtGpuResource::transferFromHost(uint32_t, uint32_t, uint32_t, uint32_t) { return -1; }
-int StubVirtGpuBlob::transferToHost(uint32_t, uint32_t, uint32_t, uint32_t) { return -1; }
+int StubVirtGpuResource::transferToHost(uint32_t, uint32_t, uint32_t, uint32_t) { return -1; }
diff --git a/guest/platform/stub/StubVirtGpuBlobMapping.cpp b/guest/platform/stub/StubVirtGpuBlobMapping.cpp
index f7e845b..a17f052 100644
--- a/guest/platform/stub/StubVirtGpuBlobMapping.cpp
+++ b/guest/platform/stub/StubVirtGpuBlobMapping.cpp
@@ -16,16 +16,15 @@
#include "StubVirtGpu.h"
-StubVirtGpuBlobMapping::StubVirtGpuBlobMapping(VirtGpuBlobPtr blob, uint8_t* ptr, uint64_t size)
+StubVirtGpuResourceMapping::StubVirtGpuResourceMapping(VirtGpuResourcePtr blob, uint8_t* ptr,
+ uint64_t size)
: mBlob(blob), mPtr(ptr), mSize(size) {}
-StubVirtGpuBlobMapping::~StubVirtGpuBlobMapping(void) {
+StubVirtGpuResourceMapping::~StubVirtGpuResourceMapping(void) {
// Unimplemented for now
(void) mPtr;
(void) mSize;
(void) mBlob;
}
-uint8_t* StubVirtGpuBlobMapping::asRawPtr(void) {
- return nullptr;
-}
+uint8_t* StubVirtGpuResourceMapping::asRawPtr(void) { return nullptr; }
diff --git a/guest/platform/stub/StubVirtGpuDevice.cpp b/guest/platform/stub/StubVirtGpuDevice.cpp
index 7908c85..aac19c0 100644
--- a/guest/platform/stub/StubVirtGpuDevice.cpp
+++ b/guest/platform/stub/StubVirtGpuDevice.cpp
@@ -26,30 +26,27 @@
return mDeviceHandle;
}
-VirtGpuBlobPtr StubVirtGpuDevice::createVirglBlob(uint32_t width, uint32_t height, uint32_t virglFormat) {
+VirtGpuResourcePtr StubVirtGpuDevice::createResource(uint32_t width, uint32_t height,
+ uint32_t virglFormat) {
(void)width;
(void)height;
(void)virglFormat;
return nullptr;
}
-VirtGpuBlobPtr StubVirtGpuDevice::createBlob(const struct VirtGpuCreateBlob&) {
+VirtGpuResourcePtr StubVirtGpuDevice::createBlob(const struct VirtGpuCreateBlob&) {
return nullptr;
}
-VirtGpuBlobPtr StubVirtGpuDevice::importBlob(const struct VirtGpuExternalHandle&) {
+VirtGpuResourcePtr StubVirtGpuDevice::importBlob(const struct VirtGpuExternalHandle&) {
return nullptr;
}
-int StubVirtGpuDevice::execBuffer(struct VirtGpuExecBuffer&, const VirtGpuBlob*) { return -1; }
+int StubVirtGpuDevice::execBuffer(struct VirtGpuExecBuffer&, const VirtGpuResource*) { return -1; }
-VirtGpuBlobPtr createColorBuffer(int, int, uint32_t) {
- return nullptr;
-}
+VirtGpuResourcePtr createColorBuffer(int, int, uint32_t) { return nullptr; }
-VirtGpuBlobPtr createColorBuffer(int) {
- return nullptr;
-}
+VirtGpuResourcePtr createColorBuffer(int) { return nullptr; }
StubVirtGpuDevice::~StubVirtGpuDevice() {
// Unimplemented stub
diff --git a/guest/vulkan_enc/HostVisibleMemoryVirtualization.cpp b/guest/vulkan_enc/HostVisibleMemoryVirtualization.cpp
index dcf9f65..025e7c0 100644
--- a/guest/vulkan_enc/HostVisibleMemoryVirtualization.cpp
+++ b/guest/vulkan_enc/HostVisibleMemoryVirtualization.cpp
@@ -33,8 +33,8 @@
return memoryProps->memoryTypes[index].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
}
-CoherentMemory::CoherentMemory(VirtGpuBlobMappingPtr blobMapping, uint64_t size, VkDevice device,
- VkDeviceMemory memory)
+CoherentMemory::CoherentMemory(VirtGpuResourceMappingPtr blobMapping, uint64_t size,
+ VkDevice device, VkDeviceMemory memory)
: mSize(size), mBlobMapping(blobMapping), mDevice(device), mMemory(memory) {
mAllocator =
std::make_unique<gfxstream::guest::SubAllocator>(blobMapping->asRawPtr(), mSize, 4096);
diff --git a/guest/vulkan_enc/HostVisibleMemoryVirtualization.h b/guest/vulkan_enc/HostVisibleMemoryVirtualization.h
index 92acd5e..50b6259 100644
--- a/guest/vulkan_enc/HostVisibleMemoryVirtualization.h
+++ b/guest/vulkan_enc/HostVisibleMemoryVirtualization.h
@@ -41,7 +41,7 @@
class CoherentMemory {
public:
- CoherentMemory(VirtGpuBlobMappingPtr blobMapping, uint64_t size, VkDevice device,
+ CoherentMemory(VirtGpuResourceMappingPtr blobMapping, uint64_t size, VkDevice device,
VkDeviceMemory memory);
#if defined(__ANDROID__)
@@ -61,7 +61,7 @@
void operator=(CoherentMemory const&);
uint64_t mSize;
- VirtGpuBlobMappingPtr mBlobMapping = nullptr;
+ VirtGpuResourceMappingPtr mBlobMapping = nullptr;
GoldfishAddressSpaceBlockPtr mBlock = nullptr;
VkDevice mDevice;
VkDeviceMemory mMemory;
diff --git a/guest/vulkan_enc/ResourceTracker.cpp b/guest/vulkan_enc/ResourceTracker.cpp
index 7a568fd..dcbef3c 100644
--- a/guest/vulkan_enc/ResourceTracker.cpp
+++ b/guest/vulkan_enc/ResourceTracker.cpp
@@ -1342,7 +1342,7 @@
VkDeviceSize allocationSize, uint8_t* ptr,
uint32_t memoryTypeIndex, AHardwareBuffer* ahw,
bool imported, zx_handle_t vmoHandle,
- VirtGpuBlobPtr blobPtr) {
+ VirtGpuResourcePtr blobPtr) {
AutoLock<RecursiveLock> lock(mLock);
auto& info = info_VkDeviceMemory[memory];
@@ -2953,7 +2953,7 @@
return coherentMemory;
}
- VirtGpuBlobMappingPtr mapping = blob->createMapping();
+ VirtGpuResourceMappingPtr mapping = blob->createMapping();
if (!mapping) {
ALOGE("Failed to create coherent memory: failed to create blob mapping.");
res = VK_ERROR_OUT_OF_DEVICE_MEMORY;
@@ -2979,7 +2979,7 @@
VkMemoryAllocateFlagsInfo allocFlagsInfo;
VkMemoryOpaqueCaptureAddressAllocateInfo opaqueCaptureAddressAllocInfo;
VkCreateBlobGOOGLE createBlobInfo;
- VirtGpuBlobPtr guestBlob = nullptr;
+ VirtGpuResourcePtr guestBlob = nullptr;
memset(&createBlobInfo, 0, sizeof(struct VkCreateBlobGOOGLE));
createBlobInfo.sType = VK_STRUCTURE_TYPE_CREATE_BLOB_GOOGLE;
@@ -3741,7 +3741,7 @@
}
#endif
- VirtGpuBlobPtr colorBufferBlob = nullptr;
+ VirtGpuResourcePtr colorBufferBlob = nullptr;
#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
if (exportDmabuf) {
VirtGpuDevice* instance = VirtGpuDevice::getInstance();
@@ -3776,8 +3776,8 @@
imageCreateInfo.format);
return VK_ERROR_FORMAT_NOT_SUPPORTED;
}
- colorBufferBlob = instance->createVirglBlob(imageCreateInfo.extent.width,
- imageCreateInfo.extent.height, virglFormat);
+ colorBufferBlob = instance->createResource(imageCreateInfo.extent.width,
+ imageCreateInfo.extent.height, virglFormat);
if (!colorBufferBlob) {
ALOGE("%s: Failed to create colorBuffer resource for Image memory\n", __func__);
return VK_ERROR_OUT_OF_DEVICE_MEMORY;
@@ -3798,8 +3798,8 @@
const auto& bufferInfo = it->second;
bufferCreateInfo = bufferInfo.createInfo;
}
- colorBufferBlob = instance->createVirglBlob(bufferCreateInfo.size / 4, 1,
- VIRGL_FORMAT_R8G8B8A8_UNORM);
+ colorBufferBlob =
+ instance->createResource(bufferCreateInfo.size / 4, 1, VIRGL_FORMAT_R8G8B8A8_UNORM);
if (!colorBufferBlob) {
ALOGE("%s: Failed to create colorBuffer resource for Buffer memory\n", __func__);
return VK_ERROR_OUT_OF_DEVICE_MEMORY;
@@ -3952,7 +3952,7 @@
if (info.blobId && !info.coherentMemory && !mCaps.params[kParamCreateGuestHandle]) {
VkEncoder* enc = (VkEncoder*)context;
- VirtGpuBlobMappingPtr mapping;
+ VirtGpuResourceMappingPtr mapping;
VirtGpuDevice* instance = VirtGpuDevice::getInstance();
uint64_t offset;
diff --git a/guest/vulkan_enc/ResourceTracker.h b/guest/vulkan_enc/ResourceTracker.h
index a40ea58..bda7d91 100644
--- a/guest/vulkan_enc/ResourceTracker.h
+++ b/guest/vulkan_enc/ResourceTracker.h
@@ -619,7 +619,7 @@
void setDeviceMemoryInfo(VkDevice device, VkDeviceMemory memory, VkDeviceSize allocationSize,
uint8_t* ptr, uint32_t memoryTypeIndex, AHardwareBuffer* ahw,
- bool imported, zx_handle_t vmoHandle, VirtGpuBlobPtr blobPtr);
+ bool imported, zx_handle_t vmoHandle, VirtGpuResourcePtr blobPtr);
void setImageInfo(VkImage image, VkDevice device, const VkImageCreateInfo* pCreateInfo);
@@ -748,7 +748,7 @@
GoldfishAddressSpaceBlockPtr goldfishBlock = nullptr;
#endif // defined(__ANDROID__)
CoherentMemoryPtr coherentMemory = nullptr;
- VirtGpuBlobPtr blobPtr = nullptr;
+ VirtGpuResourcePtr blobPtr = nullptr;
};
struct VkCommandBuffer_Info {
