blob: 20541a69a5e4cf63c05aba8038738a332a173349 [file] [log] [blame]
#include <assert.h>
#include <tuple>
#include <libbroadcastring/broadcast_ring.h>
#include <private/dvr/display_client.h>
namespace android {
namespace dvr {
// The buffer usage type for mapped shared buffers.
// Holds the memory for the mapped shared buffer. Unlocks and releases the
// underlying IonBuffer in destructor.
class CPUMappedBuffer {
// This constructor will create a display client and get the buffer from it.
CPUMappedBuffer(DvrGlobalBufferKey key, CPUUsageMode mode);
// If you already have the IonBuffer, use this. It will take ownership.
CPUMappedBuffer(std::unique_ptr<IonBuffer> buffer, CPUUsageMode mode);
// Use this if you do not want to take ownership.
CPUMappedBuffer(IonBuffer* buffer, CPUUsageMode mode);
// Getters.
size_t Size() const { return size_; }
void* Address() const { return address_; }
bool IsMapped() const { return Address() != nullptr; }
// Attempt mapping this buffer to the CPU addressable space.
// This will create a display client and see if the buffer exists.
// If the buffer has not been setup yet, you will need to try again later.
void TryMapping();
// The memory area if we managed to map it.
size_t size_ = 0;
void* address_ = nullptr;
// If we are polling the display client, the buffer key here.
DvrGlobalBufferKey buffer_key_;
// If we just own the IonBuffer outright, it's here.
std::unique_ptr<IonBuffer> owned_buffer_ = nullptr;
// The last time we connected to the display service.
int64_t last_display_service_connection_ns_ = 0;
// If we do not own the IonBuffer, it's here
IonBuffer* buffer_ = nullptr;
// The usage mode.
CPUUsageMode usage_mode_ = CPUUsageMode::READ_OFTEN;
// Represents a broadcast ring inside a mapped shared memory buffer.
// If has the same set of constructors as CPUMappedBuffer.
// The template argument is the concrete BroadcastRing class that this buffer
// holds.
template <class RingType>
class CPUMappedBroadcastRing : public CPUMappedBuffer {
CPUMappedBroadcastRing(DvrGlobalBufferKey key, CPUUsageMode mode)
: CPUMappedBuffer(key, mode) {}
CPUMappedBroadcastRing(std::unique_ptr<IonBuffer> buffer, CPUUsageMode mode)
: CPUMappedBuffer(std::move(buffer), mode) {}
CPUMappedBroadcastRing(IonBuffer* buffer, CPUUsageMode mode)
: CPUMappedBuffer(buffer, mode) {}
// Helper function for publishing records in the ring.
void Publish(const typename RingType::Record& record) {
assert((usage_mode_ == CPUUsageMode::WRITE_OFTEN) ||
(usage_mode_ == CPUUsageMode::WRITE_RARELY));
auto ring = Ring();
if (ring) {
// Helper function for getting records from the ring.
// Returns true if we were able to retrieve the latest.
bool GetNewest(typename RingType::Record* record) {
assert((usage_mode_ == CPUUsageMode::READ_OFTEN) ||
(usage_mode_ == CPUUsageMode::READ_RARELY));
auto ring = Ring();
if (ring) {
return ring->GetNewest(&sequence_, record);
return false;
// Try obtaining the ring. If the named buffer has not been created yet, it
// will return nullptr.
RingType* Ring() {
// No ring created yet?
if (ring_ == nullptr) {
// Not mapped the memory yet?
if (IsMapped() == false) {
// If have the memory mapped, allocate the ring.
if (IsMapped()) {
switch (usage_mode_) {
case CPUUsageMode::READ_OFTEN:
case CPUUsageMode::READ_RARELY: {
RingType ring;
bool import_ok;
std::tie(ring, import_ok) = RingType::Import(address_, size_);
if (import_ok) {
ring_ = std::make_unique<RingType>(ring);
} break;
case CPUUsageMode::WRITE_OFTEN:
case CPUUsageMode::WRITE_RARELY:
ring_ =
std::make_unique<RingType>(RingType::Create(address_, size_));
return ring_.get();
std::unique_ptr<RingType> ring_ = nullptr;
uint32_t sequence_ = 0;
} // namespace dvr
} // namespace android