You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
297 lines
11 KiB
297 lines
11 KiB
#include <private/dvr/producer_buffer.h>
|
|
|
|
using android::pdx::LocalChannelHandle;
|
|
using android::pdx::LocalHandle;
|
|
using android::pdx::Status;
|
|
|
|
namespace android {
|
|
namespace dvr {
|
|
|
|
ProducerBuffer::ProducerBuffer(uint32_t width, uint32_t height, uint32_t format,
|
|
uint64_t usage, size_t user_metadata_size)
|
|
: BASE(BufferHubRPC::kClientPath) {
|
|
ATRACE_NAME("ProducerBuffer::ProducerBuffer");
|
|
ALOGD_IF(TRACE,
|
|
"ProducerBuffer::ProducerBuffer: fd=%d width=%u height=%u format=%u "
|
|
"usage=%" PRIx64 " user_metadata_size=%zu",
|
|
event_fd(), width, height, format, usage, user_metadata_size);
|
|
|
|
auto status = InvokeRemoteMethod<BufferHubRPC::CreateBuffer>(
|
|
width, height, format, usage, user_metadata_size);
|
|
if (!status) {
|
|
ALOGE(
|
|
"ProducerBuffer::ProducerBuffer: Failed to create producer buffer: %s",
|
|
status.GetErrorMessage().c_str());
|
|
Close(-status.error());
|
|
return;
|
|
}
|
|
|
|
const int ret = ImportBuffer();
|
|
if (ret < 0) {
|
|
ALOGE(
|
|
"ProducerBuffer::ProducerBuffer: Failed to import producer buffer: %s",
|
|
strerror(-ret));
|
|
Close(ret);
|
|
}
|
|
}
|
|
|
|
ProducerBuffer::ProducerBuffer(uint64_t usage, size_t size)
|
|
: BASE(BufferHubRPC::kClientPath) {
|
|
ATRACE_NAME("ProducerBuffer::ProducerBuffer");
|
|
ALOGD_IF(TRACE, "ProducerBuffer::ProducerBuffer: usage=%" PRIx64 " size=%zu",
|
|
usage, size);
|
|
const int width = static_cast<int>(size);
|
|
const int height = 1;
|
|
const int format = HAL_PIXEL_FORMAT_BLOB;
|
|
const size_t user_metadata_size = 0;
|
|
|
|
auto status = InvokeRemoteMethod<BufferHubRPC::CreateBuffer>(
|
|
width, height, format, usage, user_metadata_size);
|
|
if (!status) {
|
|
ALOGE("ProducerBuffer::ProducerBuffer: Failed to create blob: %s",
|
|
status.GetErrorMessage().c_str());
|
|
Close(-status.error());
|
|
return;
|
|
}
|
|
|
|
const int ret = ImportBuffer();
|
|
if (ret < 0) {
|
|
ALOGE(
|
|
"ProducerBuffer::ProducerBuffer: Failed to import producer buffer: %s",
|
|
strerror(-ret));
|
|
Close(ret);
|
|
}
|
|
}
|
|
|
|
ProducerBuffer::ProducerBuffer(LocalChannelHandle channel)
|
|
: BASE(std::move(channel)) {
|
|
const int ret = ImportBuffer();
|
|
if (ret < 0) {
|
|
ALOGE(
|
|
"ProducerBuffer::ProducerBuffer: Failed to import producer buffer: %s",
|
|
strerror(-ret));
|
|
Close(ret);
|
|
}
|
|
}
|
|
|
|
int ProducerBuffer::LocalPost(const DvrNativeBufferMetadata* meta,
|
|
const LocalHandle& ready_fence) {
|
|
if (const int error = CheckMetadata(meta->user_metadata_size))
|
|
return error;
|
|
|
|
// The buffer can be posted iff the buffer state for this client is gained.
|
|
uint32_t current_buffer_state =
|
|
buffer_state_->load(std::memory_order_acquire);
|
|
if (!BufferHubDefs::isClientGained(current_buffer_state,
|
|
client_state_mask())) {
|
|
ALOGE("%s: not gained, id=%d state=%" PRIx32 ".", __FUNCTION__, id(),
|
|
current_buffer_state);
|
|
return -EBUSY;
|
|
}
|
|
|
|
// Set the producer client buffer state to released, that of all other clients
|
|
// (both existing and non-existing clients) to posted.
|
|
uint32_t updated_buffer_state =
|
|
(~client_state_mask()) & BufferHubDefs::kHighBitsMask;
|
|
while (!buffer_state_->compare_exchange_weak(
|
|
current_buffer_state, updated_buffer_state, std::memory_order_acq_rel,
|
|
std::memory_order_acquire)) {
|
|
if (!BufferHubDefs::isClientGained(current_buffer_state,
|
|
client_state_mask())) {
|
|
ALOGE(
|
|
"%s: Failed to post the buffer. The buffer is no longer gained, "
|
|
"id=%d state=%" PRIx32 ".",
|
|
__FUNCTION__, id(), current_buffer_state);
|
|
return -EBUSY;
|
|
}
|
|
}
|
|
|
|
// Copy the canonical metadata.
|
|
void* metadata_ptr = reinterpret_cast<void*>(&metadata_header_->metadata);
|
|
memcpy(metadata_ptr, meta, sizeof(DvrNativeBufferMetadata));
|
|
// Copy extra user requested metadata.
|
|
if (meta->user_metadata_ptr && meta->user_metadata_size) {
|
|
void* metadata_src = reinterpret_cast<void*>(meta->user_metadata_ptr);
|
|
memcpy(user_metadata_ptr_, metadata_src, meta->user_metadata_size);
|
|
}
|
|
|
|
// Send out the acquire fence through the shared epoll fd. Note that during
|
|
// posting no consumer is not expected to be polling on the fence.
|
|
if (const int error = UpdateSharedFence(ready_fence, shared_acquire_fence_))
|
|
return error;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ProducerBuffer::Post(const LocalHandle& ready_fence, const void* meta,
|
|
size_t user_metadata_size) {
|
|
ATRACE_NAME("ProducerBuffer::Post");
|
|
|
|
// Populate cononical metadata for posting.
|
|
DvrNativeBufferMetadata canonical_meta;
|
|
canonical_meta.user_metadata_ptr = reinterpret_cast<uint64_t>(meta);
|
|
canonical_meta.user_metadata_size = user_metadata_size;
|
|
|
|
if (const int error = LocalPost(&canonical_meta, ready_fence))
|
|
return error;
|
|
|
|
return ReturnStatusOrError(InvokeRemoteMethod<BufferHubRPC::ProducerPost>(
|
|
BorrowedFence(ready_fence.Borrow())));
|
|
}
|
|
|
|
int ProducerBuffer::PostAsync(const DvrNativeBufferMetadata* meta,
|
|
const LocalHandle& ready_fence) {
|
|
ATRACE_NAME("ProducerBuffer::PostAsync");
|
|
|
|
if (const int error = LocalPost(meta, ready_fence))
|
|
return error;
|
|
|
|
return ReturnStatusOrError(SendImpulse(BufferHubRPC::ProducerPost::Opcode));
|
|
}
|
|
|
|
int ProducerBuffer::LocalGain(DvrNativeBufferMetadata* out_meta,
|
|
LocalHandle* out_fence, bool gain_posted_buffer) {
|
|
if (!out_meta)
|
|
return -EINVAL;
|
|
|
|
uint32_t current_buffer_state =
|
|
buffer_state_->load(std::memory_order_acquire);
|
|
ALOGD_IF(TRACE, "%s: buffer=%d, state=%" PRIx32 ".", __FUNCTION__, id(),
|
|
current_buffer_state);
|
|
|
|
if (BufferHubDefs::isClientGained(current_buffer_state,
|
|
client_state_mask())) {
|
|
ALOGV("%s: already gained id=%d.", __FUNCTION__, id());
|
|
return 0;
|
|
}
|
|
if (BufferHubDefs::isAnyClientAcquired(current_buffer_state) ||
|
|
BufferHubDefs::isAnyClientGained(current_buffer_state) ||
|
|
(BufferHubDefs::isAnyClientPosted(
|
|
current_buffer_state &
|
|
active_clients_bit_mask_->load(std::memory_order_acquire)) &&
|
|
!gain_posted_buffer)) {
|
|
ALOGE("%s: not released id=%d state=%" PRIx32 ".", __FUNCTION__, id(),
|
|
current_buffer_state);
|
|
return -EBUSY;
|
|
}
|
|
// Change the buffer state to gained state.
|
|
uint32_t updated_buffer_state = client_state_mask();
|
|
while (!buffer_state_->compare_exchange_weak(
|
|
current_buffer_state, updated_buffer_state, std::memory_order_acq_rel,
|
|
std::memory_order_acquire)) {
|
|
if (BufferHubDefs::isAnyClientAcquired(current_buffer_state) ||
|
|
BufferHubDefs::isAnyClientGained(current_buffer_state) ||
|
|
(BufferHubDefs::isAnyClientPosted(
|
|
current_buffer_state &
|
|
active_clients_bit_mask_->load(std::memory_order_acquire)) &&
|
|
!gain_posted_buffer)) {
|
|
ALOGE(
|
|
"%s: Failed to gain the buffer. The buffer is no longer released. "
|
|
"id=%d state=%" PRIx32 ".",
|
|
__FUNCTION__, id(), current_buffer_state);
|
|
return -EBUSY;
|
|
}
|
|
}
|
|
|
|
// Canonical metadata is undefined on Gain. Except for user_metadata and
|
|
// release_fence_mask. Fill in the user_metadata_ptr in address space of the
|
|
// local process.
|
|
if (metadata_header_->metadata.user_metadata_size && user_metadata_ptr_) {
|
|
out_meta->user_metadata_size =
|
|
metadata_header_->metadata.user_metadata_size;
|
|
out_meta->user_metadata_ptr =
|
|
reinterpret_cast<uint64_t>(user_metadata_ptr_);
|
|
} else {
|
|
out_meta->user_metadata_size = 0;
|
|
out_meta->user_metadata_ptr = 0;
|
|
}
|
|
|
|
uint32_t current_fence_state = fence_state_->load(std::memory_order_acquire);
|
|
uint32_t current_active_clients_bit_mask =
|
|
active_clients_bit_mask_->load(std::memory_order_acquire);
|
|
// If there are release fence(s) from consumer(s), we need to return it to the
|
|
// consumer(s).
|
|
// TODO(b/112007999) add an atomic variable in metadata header in shared
|
|
// memory to indicate which client is the last producer of the buffer.
|
|
// Currently, assume the first client is the only producer to the buffer.
|
|
if (current_fence_state & current_active_clients_bit_mask &
|
|
(~BufferHubDefs::kFirstClientBitMask)) {
|
|
*out_fence = shared_release_fence_.Duplicate();
|
|
out_meta->release_fence_mask = current_fence_state &
|
|
current_active_clients_bit_mask &
|
|
(~BufferHubDefs::kFirstClientBitMask);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ProducerBuffer::Gain(LocalHandle* release_fence, bool gain_posted_buffer) {
|
|
ATRACE_NAME("ProducerBuffer::Gain");
|
|
|
|
DvrNativeBufferMetadata meta;
|
|
if (const int error = LocalGain(&meta, release_fence, gain_posted_buffer))
|
|
return error;
|
|
|
|
auto status = InvokeRemoteMethod<BufferHubRPC::ProducerGain>();
|
|
if (!status)
|
|
return -status.error();
|
|
return 0;
|
|
}
|
|
|
|
int ProducerBuffer::GainAsync(DvrNativeBufferMetadata* out_meta,
|
|
LocalHandle* release_fence,
|
|
bool gain_posted_buffer) {
|
|
ATRACE_NAME("ProducerBuffer::GainAsync");
|
|
|
|
if (const int error = LocalGain(out_meta, release_fence, gain_posted_buffer))
|
|
return error;
|
|
|
|
return ReturnStatusOrError(SendImpulse(BufferHubRPC::ProducerGain::Opcode));
|
|
}
|
|
|
|
int ProducerBuffer::GainAsync() {
|
|
DvrNativeBufferMetadata meta;
|
|
LocalHandle fence;
|
|
return GainAsync(&meta, &fence);
|
|
}
|
|
|
|
std::unique_ptr<ProducerBuffer> ProducerBuffer::Import(
|
|
LocalChannelHandle channel) {
|
|
ALOGD_IF(TRACE, "ProducerBuffer::Import: channel=%d", channel.value());
|
|
return ProducerBuffer::Create(std::move(channel));
|
|
}
|
|
|
|
std::unique_ptr<ProducerBuffer> ProducerBuffer::Import(
|
|
Status<LocalChannelHandle> status) {
|
|
return Import(status ? status.take()
|
|
: LocalChannelHandle{nullptr, -status.error()});
|
|
}
|
|
|
|
Status<LocalChannelHandle> ProducerBuffer::Detach() {
|
|
// TODO(b/112338294) remove after migrate producer buffer to binder
|
|
ALOGW("ProducerBuffer::Detach: not supported operation during migration");
|
|
return {};
|
|
|
|
// TODO(b/112338294) Keep here for reference. Remove it after new logic is
|
|
// written.
|
|
/* uint32_t buffer_state = buffer_state_->load(std::memory_order_acquire);
|
|
if (!BufferHubDefs::isClientGained(
|
|
buffer_state, BufferHubDefs::kFirstClientStateMask)) {
|
|
// Can only detach a ProducerBuffer when it's in gained state.
|
|
ALOGW("ProducerBuffer::Detach: The buffer (id=%d, state=0x%" PRIx32
|
|
") is not in gained state.",
|
|
id(), buffer_state);
|
|
return {};
|
|
}
|
|
|
|
Status<LocalChannelHandle> status =
|
|
InvokeRemoteMethod<BufferHubRPC::ProducerBufferDetach>();
|
|
ALOGE_IF(!status,
|
|
"ProducerBuffer::Detach: Failed to detach buffer (id=%d): %s.", id(),
|
|
status.GetErrorMessage().c_str());
|
|
return status; */
|
|
}
|
|
|
|
} // namespace dvr
|
|
} // namespace android
|