blob: 52d7961b6d4f7ce99e07e0af3252097c7b01bf29 [file] [log] [blame]
/*
* Copyright 2019 Google LLC
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef skgpu_AsyncReadTypes_DEFINED
#define skgpu_AsyncReadTypes_DEFINED
#include "include/core/SkData.h"
#include "include/core/SkImage.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSize.h"
#include "include/private/base/SkAssert.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkTArray.h"
#include "src/core/SkMessageBus.h"
#include <cstddef>
#include <forward_list>
#include <utility>
namespace skgpu {
/**
* We sometimes hand clients objects that contain mapped buffers. The client may consume
* the mapped buffer on another thread. This object manages receiving messages that buffers are
* ready to be unmapped (on the owner's thread). It also handles cleaning up mapped
* buffers if the owner is destroyed before the client has finished with the buffer.
*
* Buffers are first registered using insert() before being passed the client. process() should be
* called periodically on the owner's thread to poll for messages and process them.
*/
template <typename T, typename IDType>
class TClientMappedBufferManager {
public:
/**
* The message type that internal users of this should post to unmap the buffer.
* Set fInboxID to inboxID(). fBuffer must have been previously passed to insert().
*/
struct BufferFinishedMessage {
BufferFinishedMessage(sk_sp<T> buffer,
IDType intendedRecipient)
: fBuffer(std::move(buffer)), fIntendedRecipient(intendedRecipient) {}
BufferFinishedMessage(BufferFinishedMessage&& other) {
fBuffer = std::move(other.fBuffer);
fIntendedRecipient = other.fIntendedRecipient;
other.fIntendedRecipient.makeInvalid();
}
sk_sp<T> fBuffer;
IDType fIntendedRecipient;
};
using BufferFinishedMessageBus = SkMessageBus<BufferFinishedMessage,
IDType,
false>;
TClientMappedBufferManager(IDType ownerID)
: fFinishedBufferInbox(ownerID) {}
TClientMappedBufferManager(const TClientMappedBufferManager&) = delete;
TClientMappedBufferManager(TClientMappedBufferManager&&) = delete;
~TClientMappedBufferManager() {
this->process();
if (!fAbandoned) {
// If we're going down before we got the messages we go ahead and unmap all the buffers.
// It's up to the client to ensure that they aren't being accessed on another thread
// while this is happening (or afterwards on any thread).
for (auto& b : fClientHeldBuffers) {
b->unmap();
}
}
}
TClientMappedBufferManager& operator=(const TClientMappedBufferManager&) = delete;
TClientMappedBufferManager& operator=(TClientMappedBufferManager&&) = delete;
/** Initialize BufferFinishedMessage::fIntendedRecipient to this value. It is the
* unique ID of the object that owns this buffer manager.
*/
IDType ownerID() const {
return fFinishedBufferInbox.uniqueID();
}
/**
* Let the manager know to expect a message with buffer 'b'. It's illegal for a buffer to be
* inserted again before it is unmapped by process().
*/
void insert(sk_sp<T> b) {
SkDEBUGCODE(auto end = fClientHeldBuffers.end());
SkASSERT(std::find(fClientHeldBuffers.begin(), end, b) == end);
fClientHeldBuffers.emplace_front(std::move(b));
}
/** Poll for messages and unmap any incoming buffers. */
void process() {
skia_private::STArray<4, BufferFinishedMessage> messages;
fFinishedBufferInbox.poll(&messages);
if (!fAbandoned) {
for (auto& m : messages) {
this->remove(m.fBuffer);
m.fBuffer->unmap();
}
}
}
/** Notifies the manager that the context has been abandoned. No more unmaps() will occur.*/
void abandon() {
fAbandoned = true;
fClientHeldBuffers.clear();
}
private:
typename BufferFinishedMessageBus::Inbox fFinishedBufferInbox;
std::forward_list<sk_sp<T>> fClientHeldBuffers;
bool fAbandoned = false;
void remove(const sk_sp<T>& b) {
// There is no convenient remove only the first element that equals a value functionality in
// std::forward_list.
auto prev = fClientHeldBuffers.before_begin();
auto end = fClientHeldBuffers.end();
SkASSERT(std::find(fClientHeldBuffers.begin(), end, b) != end);
for (auto cur = fClientHeldBuffers.begin(); cur != end; prev = cur++) {
if (*cur == b) {
fClientHeldBuffers.erase_after(prev);
break;
}
}
SkASSERT(std::find(fClientHeldBuffers.begin(), end, b) == end);
}
};
////////////////////////////////////////////////////////////////////////////////
template <typename T, typename IDType, typename TransferResultType>
class TAsyncReadResult : public SkImage::AsyncReadResult {
public:
TAsyncReadResult(IDType intendedRecipient)
: fIntendedRecipient(intendedRecipient) {
}
~TAsyncReadResult() override {
for (int i = 0; i < fPlanes.size(); ++i) {
fPlanes[i].releaseMappedBuffer(fIntendedRecipient);
}
}
int count() const override { return fPlanes.size(); }
const void* data(int i) const override { return fPlanes[i].data(); }
size_t rowBytes(int i) const override { return fPlanes[i].rowBytes(); }
bool addTransferResult(const TransferResultType& result,
SkISize dimensions,
size_t rowBytes,
TClientMappedBufferManager<T, IDType>* manager) {
const void* mappedData = result.fTransferBuffer->map();
if (!mappedData) {
return false;
}
if (result.fPixelConverter) {
size_t size = rowBytes*dimensions.height();
sk_sp<SkData> data = SkData::MakeUninitialized(size);
result.fPixelConverter(data->writable_data(), mappedData);
this->addCpuPlane(std::move(data), rowBytes);
result.fTransferBuffer->unmap();
} else {
manager->insert(result.fTransferBuffer);
this->addMappedPlane(mappedData, rowBytes, std::move(result.fTransferBuffer));
}
return true;
}
void addCpuPlane(sk_sp<SkData> data, size_t rowBytes) {
SkASSERT(data);
SkASSERT(rowBytes > 0);
fPlanes.emplace_back(std::move(data), rowBytes);
}
private:
void addMappedPlane(const void* data, size_t rowBytes, sk_sp<T> mappedBuffer) {
SkASSERT(data);
SkASSERT(rowBytes > 0);
SkASSERT(mappedBuffer);
SkASSERT(mappedBuffer->isMapped());
fPlanes.emplace_back(std::move(mappedBuffer), rowBytes);
}
class Plane {
public:
Plane(sk_sp<T> buffer, size_t rowBytes)
: fMappedBuffer(std::move(buffer)), fRowBytes(rowBytes) {}
Plane(sk_sp<SkData> data, size_t rowBytes) : fData(std::move(data)), fRowBytes(rowBytes) {}
Plane(Plane&&) = default;
~Plane() { SkASSERT(!fMappedBuffer); }
Plane& operator=(const Plane&) = delete;
Plane& operator=(Plane&&) = default;
void releaseMappedBuffer(IDType intendedRecipient) {
if (fMappedBuffer) {
TClientMappedBufferManager<T, IDType>::BufferFinishedMessageBus::Post(
{std::move(fMappedBuffer), intendedRecipient});
}
}
const void* data() const {
if (fMappedBuffer) {
SkASSERT(!fData);
SkASSERT(fMappedBuffer->isMapped());
return fMappedBuffer->map();
}
SkASSERT(fData);
return fData->data();
}
size_t rowBytes() const { return fRowBytes; }
private:
sk_sp<SkData> fData;
sk_sp<T> fMappedBuffer;
size_t fRowBytes;
};
skia_private::STArray<4, Plane> fPlanes;
IDType fIntendedRecipient;
};
} // namespace skgpu
#endif // skgpu_AsyncReadTypes_DEFINED