event_fd(), width, height, format, producer_usage, consumer_usage,
metadata_size, slice_count);
+ // (b/37881101) Deprecate producer/consumer usage
auto status = InvokeRemoteMethod<BufferHubRPC::CreateBuffer>(
- width, height, format, producer_usage, consumer_usage, metadata_size,
+ width, height, format, (producer_usage | consumer_usage), metadata_size,
slice_count);
if (!status) {
ALOGE(
event_fd(), name.c_str(), user_id, group_id, width, height, format,
producer_usage, consumer_usage, meta_size_bytes, slice_count);
+ // (b/37881101) Deprecate producer/consumer usage
auto status = InvokeRemoteMethod<BufferHubRPC::CreatePersistentBuffer>(
- name, user_id, group_id, width, height, format, producer_usage,
- consumer_usage, meta_size_bytes, slice_count);
+ name, user_id, group_id, width, height, format,
+ (producer_usage | consumer_usage), meta_size_bytes, slice_count);
if (!status) {
ALOGE(
"BufferProducer::BufferProducer: Failed to create/get persistent "
const int format = HAL_PIXEL_FORMAT_BLOB;
const size_t meta_size_bytes = 0;
const size_t slice_count = 1;
+
+ // (b/37881101) Deprecate producer/consumer usage
auto status = InvokeRemoteMethod<BufferHubRPC::CreateBuffer>(
- width, height, format, producer_usage, consumer_usage, meta_size_bytes,
+ width, height, format, (producer_usage | consumer_usage), meta_size_bytes,
slice_count);
if (!status) {
ALOGE("BufferProducer::BufferProducer: Failed to create blob: %s",
const int format = HAL_PIXEL_FORMAT_BLOB;
const size_t meta_size_bytes = 0;
const size_t slice_count = 1;
+
+ // (b/37881101) Deprecate producer/consumer usage
auto status = InvokeRemoteMethod<BufferHubRPC::CreatePersistentBuffer>(
- name, user_id, group_id, width, height, format, producer_usage,
- consumer_usage, meta_size_bytes, slice_count);
+ name, user_id, group_id, width, height, format,
+ (producer_usage | consumer_usage), meta_size_bytes, slice_count);
if (!status) {
ALOGE(
"BufferProducer::BufferProducer: Failed to create persistent "
width_(buffer.width()),
height_(buffer.height()),
format_(buffer.format()),
- producer_usage_(buffer.usage()),
- consumer_usage_(buffer.usage()) {
+ usage_(buffer.usage()) {
// Populate the fd and int vectors: native_handle->data[] is an array of fds
// followed by an array of opaque ints.
const int fd_count = buffer.handle()->numFds;
for (const auto& fd : fds_)
fd_ints.push_back(fd.Get());
- // TODO(b/37881101) Get rid of producer/consumer usage.
- const int ret =
- buffer->Import(fd_ints.data(), fd_ints.size(), opaque_ints_.data(),
- opaque_ints_.size(), width_, height_, stride_, format_,
- (producer_usage_ | consumer_usage_));
+ const int ret = buffer->Import(fd_ints.data(), fd_ints.size(),
+ opaque_ints_.data(), opaque_ints_.size(),
+ width_, height_, stride_, format_, usage_);
if (ret < 0)
return ret;
uint32_t width_;
uint32_t height_;
uint32_t format_;
- uint64_t producer_usage_;
- uint64_t consumer_usage_;
+ uint64_t usage_;
std::vector<int> opaque_ints_;
std::vector<FileHandleType> fds_;
void Clear() {
id_ = -1;
- stride_ = width_ = height_ = format_ = producer_usage_ = consumer_usage_ =
- 0;
+ stride_ = width_ = height_ = format_ = usage_ = 0;
}
PDX_SERIALIZABLE_MEMBERS(NativeBufferHandle<FileHandleType>, id_, stride_,
- width_, height_, format_, producer_usage_,
- consumer_usage_, opaque_ints_, fds_);
+ width_, height_, format_, usage_, opaque_ints_,
+ fds_);
NativeBufferHandle(const NativeBufferHandle&) = delete;
void operator=(const NativeBufferHandle&) = delete;
};
struct UsagePolicy {
- uint64_t producer_set_mask;
- uint64_t producer_clear_mask;
- uint64_t producer_deny_set_mask;
- uint64_t producer_deny_clear_mask;
- uint64_t consumer_set_mask;
- uint64_t consumer_clear_mask;
- uint64_t consumer_deny_set_mask;
- uint64_t consumer_deny_clear_mask;
+ uint64_t usage_set_mask;
+ uint64_t usage_clear_mask;
+ uint64_t usage_deny_set_mask;
+ uint64_t usage_deny_clear_mask;
private:
- PDX_SERIALIZABLE_MEMBERS(UsagePolicy, producer_set_mask, producer_clear_mask,
- producer_deny_set_mask, producer_deny_clear_mask,
- consumer_set_mask, consumer_clear_mask,
- consumer_deny_set_mask, consumer_deny_clear_mask);
+ PDX_SERIALIZABLE_MEMBERS(UsagePolicy, usage_set_mask, usage_clear_mask,
+ usage_deny_set_mask, usage_deny_clear_mask);
};
// BufferHub Service RPC interface. Defines the endpoints, op codes, and method
// Methods.
PDX_REMOTE_METHOD(CreateBuffer, kOpCreateBuffer,
void(uint32_t width, uint32_t height, uint32_t format,
- uint64_t producer_usage, uint64_t consumer_usage,
- size_t meta_size_bytes, size_t slice_count));
+ uint64_t usage, size_t meta_size_bytes,
+ size_t slice_count));
PDX_REMOTE_METHOD(CreatePersistentBuffer, kOpCreatePersistentBuffer,
void(const std::string& name, int user_id, int group_id,
uint32_t width, uint32_t height, uint32_t format,
- uint64_t producer_usage, uint64_t consumer_usage,
- size_t meta_size_bytes, size_t slice_count));
+ uint64_t usage, size_t meta_size_bytes,
+ size_t slice_count));
PDX_REMOTE_METHOD(GetPersistentBuffer, kOpGetPersistentBuffer,
void(const std::string& name));
PDX_REMOTE_METHOD(GetBuffer, kOpGetBuffer,
kOpProducerQueueAllocateBuffers,
std::vector<std::pair<LocalChannelHandle, size_t>>(
uint32_t width, uint32_t height, uint32_t format,
- uint64_t producer_usage, uint64_t consumer_usage,
- size_t slice_count, size_t buffer_count));
+ uint64_t usage, size_t slice_count,
+ size_t buffer_count));
PDX_REMOTE_METHOD(ProducerQueueDetachBuffer, kOpProducerQueueDetachBuffer,
void(size_t slot));
PDX_REMOTE_METHOD(ConsumerQueueImportBuffers, kOpConsumerQueueImportBuffers,
}
ProducerQueue::ProducerQueue(size_t meta_size)
- : ProducerQueue(meta_size, 0, 0, 0, 0, 0, 0, 0, 0) {}
+ : ProducerQueue(meta_size, 0, 0, 0, 0) {}
ProducerQueue::ProducerQueue(LocalChannelHandle handle)
: BASE(std::move(handle)) {
}
}
-ProducerQueue::ProducerQueue(size_t meta_size, uint64_t producer_usage_set_mask,
- uint64_t producer_usage_clear_mask,
- uint64_t producer_usage_deny_set_mask,
- uint64_t producer_usage_deny_clear_mask,
- uint64_t consumer_usage_set_mask,
- uint64_t consumer_usage_clear_mask,
- uint64_t consumer_usage_deny_set_mask,
- uint64_t consumer_usage_deny_clear_mask)
+ProducerQueue::ProducerQueue(size_t meta_size, uint64_t usage_set_mask,
+ uint64_t usage_clear_mask,
+ uint64_t usage_deny_set_mask,
+ uint64_t usage_deny_clear_mask)
: BASE(BufferHubRPC::kClientPath) {
auto status = InvokeRemoteMethod<BufferHubRPC::CreateProducerQueue>(
- meta_size,
- UsagePolicy{producer_usage_set_mask, producer_usage_clear_mask,
- producer_usage_deny_set_mask, producer_usage_deny_clear_mask,
- consumer_usage_set_mask, consumer_usage_clear_mask,
- consumer_usage_deny_set_mask,
- consumer_usage_deny_clear_mask});
+ meta_size, UsagePolicy{usage_set_mask, usage_clear_mask,
+ usage_deny_set_mask, usage_deny_clear_mask});
if (!status) {
ALOGE("ProducerQueue::ProducerQueue: Failed to create producer queue: %s",
status.GetErrorMessage().c_str());
}
int ProducerQueue::AllocateBuffer(uint32_t width, uint32_t height,
- uint32_t format, uint32_t usage,
+ uint32_t format, uint64_t usage,
size_t slice_count, size_t* out_slot) {
- return AllocateBuffer(width, height, format, usage, usage, slice_count,
- out_slot);
-}
-
-int ProducerQueue::AllocateBuffer(uint32_t width, uint32_t height,
- uint32_t format, uint64_t producer_usage,
- uint64_t consumer_usage, size_t slice_count,
- size_t* out_slot) {
if (out_slot == nullptr) {
ALOGE("ProducerQueue::AllocateBuffer: Parameter out_slot cannot be null.");
return -EINVAL;
}
const size_t kBufferCount = 1U;
-
Status<std::vector<std::pair<LocalChannelHandle, size_t>>> status =
InvokeRemoteMethod<BufferHubRPC::ProducerQueueAllocateBuffers>(
- width, height, format, producer_usage, consumer_usage, slice_count,
- kBufferCount);
+ width, height, format, usage, slice_count, kBufferCount);
if (!status) {
ALOGE(
"ProducerQueue::AllocateBuffer failed to create producer buffer "
uint32_t usage_deny_set_mask,
uint32_t usage_deny_clear_mask) {
return BASE::Create(sizeof(Meta), usage_set_mask, usage_clear_mask,
- usage_deny_set_mask, usage_deny_clear_mask,
- usage_set_mask, usage_clear_mask, usage_deny_set_mask,
- usage_deny_clear_mask);
- }
- template <typename Meta>
- static std::unique_ptr<ProducerQueue> Create(
- uint64_t producer_usage_set_mask, uint64_t producer_usage_clear_mask,
- uint64_t producer_usage_deny_set_mask,
- uint64_t producer_usage_deny_clear_mask, uint64_t consumer_usage_set_mask,
- uint64_t consumer_usage_clear_mask, uint64_t consumer_usage_deny_set_mask,
- uint64_t consumer_usage_deny_clear_mask) {
- return BASE::Create(sizeof(Meta), producer_usage_set_mask,
- producer_usage_clear_mask, producer_usage_deny_set_mask,
- producer_usage_deny_clear_mask, consumer_usage_set_mask,
- consumer_usage_clear_mask, consumer_usage_deny_set_mask,
- consumer_usage_deny_clear_mask);
+ usage_deny_set_mask, usage_deny_clear_mask);
}
// Import a |ProducerQueue| from a channel handle.
// Returns Zero on success and negative error code when buffer allocation
// fails.
int AllocateBuffer(uint32_t width, uint32_t height, uint32_t format,
- uint32_t usage, size_t slice_count, size_t* out_slot);
- int AllocateBuffer(uint32_t width, uint32_t height, uint32_t format,
- uint64_t producer_usage, uint64_t consumer_usage,
- size_t slice_count, size_t* out_slot);
+ uint64_t usage, size_t slice_count, size_t* out_slot);
// Add a producer buffer to populate the queue. Once added, a producer buffer
// is available to use (i.e. in |Gain|'ed mode).
// arguments as the constructors.
explicit ProducerQueue(size_t meta_size);
ProducerQueue(LocalChannelHandle handle);
- ProducerQueue(size_t meta_size, uint64_t producer_usage_set_mask,
- uint64_t producer_usage_clear_mask,
- uint64_t producer_usage_deny_set_mask,
- uint64_t producer_usage_deny_clear_mask,
- uint64_t consumer_usage_set_mask,
- uint64_t consumer_usage_clear_mask,
- uint64_t consumer_usage_deny_set_mask,
- uint64_t consumer_usage_deny_clear_mask);
+ ProducerQueue(size_t meta_size, uint64_t usage_set_mask,
+ uint64_t usage_clear_mask, uint64_t usage_deny_set_mask,
+ uint64_t usage_deny_clear_mask);
int OnBufferReady(std::shared_ptr<BufferHubBuffer> buf,
LocalHandle* release_fence) override;
}
std::unique_ptr<IonBuffer> DisplayManagerClient::SetupNamedBuffer(
- const std::string& name, size_t size, uint64_t producer_usage,
- uint64_t consumer_usage) {
+ const std::string& name, size_t size, uint64_t usage) {
auto status = InvokeRemoteMethod<DisplayManagerRPC::SetupNamedBuffer>(
- name, size, producer_usage, consumer_usage);
+ name, size, usage);
if (!status) {
ALOGE(
"DisplayManagerClient::SetupNamedBuffer: Failed to create the named "
std::unique_ptr<IonBuffer> SetupNamedBuffer(const std::string& name,
size_t size,
- uint64_t producer_usage,
- uint64_t consumer_usage);
+ uint64_t usage);
using Client::event_fd;
using Client::GetChannel;
int(const std::map<int, DisplaySurfaceAttributes>& updates));
PDX_REMOTE_METHOD(SetupNamedBuffer, kOpSetupNamedBuffer,
LocalNativeBufferHandle(const std::string& name,
- size_t size,
- uint64_t producer_usage,
- uint64_t consumer_usage));
+ size_t size, uint64_t usage));
};
struct ScreenshotData {
android_convertGralloc0To1Usage((uint32_t)gralloc_usage, &producer_usage,
&consumer_usage);
- auto ion_buffer = client->client->SetupNamedBuffer(name, size, producer_usage,
- consumer_usage);
+ auto ion_buffer = client->client->SetupNamedBuffer(
+ name, size, (producer_usage | consumer_usage));
if (ion_buffer) {
return CreateDvrBufferFromIonBuffer(std::move(ion_buffer));
}
ASSERT_EQ(0, e3);
AHardwareBuffer* hardware_buffer3 = nullptr;
- int e4 = dvrBufferGetAHardwareBuffer(buffer2, &hardware_buffer3);
+ int e4 = dvrBufferGetAHardwareBuffer(buffer3, &hardware_buffer3);
ASSERT_EQ(0, e4);
ASSERT_NE(nullptr, hardware_buffer3);
pdx::Status<BorrowedNativeBufferHandle>
DisplayManagerService::OnSetupNamedBuffer(pdx::Message& message,
const std::string& name, size_t size,
- uint64_t producer_usage,
- uint64_t consumer_usage) {
+ uint64_t usage) {
if (message.GetEffectiveUserId() != AID_ROOT &&
!IsTrustedUid(message.GetEffectiveUserId())) {
// Only trusted users can setup named buffers.
message.GetEffectiveUserId());
return {};
}
- return display_service_->SetupNamedBuffer(name, size, producer_usage,
- consumer_usage);
+ return display_service_->SetupNamedBuffer(name, size, usage);
}
void DisplayManagerService::OnDisplaySurfaceChange() {
pdx::Status<BorrowedNativeBufferHandle> OnSetupNamedBuffer(
pdx::Message& message, const std::string& name, size_t size,
- uint64_t producer_usage, uint64_t consumer_usage);
+ uint64_t usage);
// Called by the display service to indicate changes to display surfaces that
// the display manager should evaluate.
}
pdx::Status<BorrowedNativeBufferHandle> DisplayService::SetupNamedBuffer(
- const std::string& name, size_t size, int producer_usage,
- int consumer_usage) {
+ const std::string& name, size_t size, int usage) {
auto named_buffer = named_buffers_.find(name);
if (named_buffer == named_buffers_.end()) {
- auto ion_buffer = std::make_unique<IonBuffer>(
- static_cast<int>(size), 1, HAL_PIXEL_FORMAT_BLOB,
- (producer_usage | consumer_usage));
+ auto ion_buffer = std::make_unique<IonBuffer>(static_cast<int>(size), 1,
+ HAL_PIXEL_FORMAT_BLOB, usage);
named_buffer =
named_buffers_.insert(std::make_pair(name, std::move(ion_buffer)))
.first;
void UpdateActiveDisplaySurfaces();
pdx::Status<BorrowedNativeBufferHandle> SetupNamedBuffer(
- const std::string& name, size_t size, int producer_usage,
- int consumer_usage);
+ const std::string& name, size_t size, int usage);
template <class A>
void ForEachDisplaySurface(A action) const {
stream << " ";
stream << std::setw(6) << "Format";
stream << " ";
- stream << std::setw(21) << "Usage";
+ stream << std::setw(11) << "Usage";
stream << " ";
stream << "Name";
stream << std::endl;
stream << std::setw(6) << info.format;
stream << " ";
stream << "0x" << std::hex << std::setfill('0');
- stream << std::setw(8) << info.producer_usage;
- stream << "0x";
- stream << std::setw(8) << info.consumer_usage;
+ stream << std::setw(8) << info.usage;
stream << std::dec << std::setfill(' ');
stream << " ";
stream << info.name;
stream << " UsageClearMask";
stream << " UsageDenySetMask";
stream << " UsageDenyClearMask";
- stream << " UsageSetMask";
- stream << " UsageClearMask";
- stream << " UsageDenySetMask";
- stream << " UsageDenyClearMask";
stream << " ";
stream << std::endl;
stream << std::right << std::setw(12) << info.consumer_count;
stream << std::setw(5) << std::setfill(' ') << "0x";
stream << std::hex << std::setfill('0');
- stream << std::setw(8) << info.usage_policy.producer_set_mask;
- stream << std::setw(7) << std::setfill(' ') << "0x";
- stream << std::hex << std::setfill('0');
- stream << std::setw(8) << info.usage_policy.producer_clear_mask;
- stream << std::setw(9) << std::setfill(' ') << "0x";
- stream << std::hex << std::setfill('0');
- stream << std::setw(8) << info.usage_policy.producer_deny_set_mask;
- stream << std::setw(11) << std::setfill(' ') << "0x";
- stream << std::hex << std::setfill('0');
- stream << std::setw(8) << info.usage_policy.producer_deny_clear_mask;
- stream << std::setw(5) << std::setfill(' ') << "0x";
- stream << std::hex << std::setfill('0');
- stream << std::setw(8) << info.usage_policy.consumer_set_mask;
+ stream << std::setw(8) << info.usage_policy.usage_set_mask;
stream << std::setw(7) << std::setfill(' ') << "0x";
stream << std::hex << std::setfill('0');
- stream << std::setw(8) << info.usage_policy.consumer_clear_mask;
+ stream << std::setw(8) << info.usage_policy.usage_clear_mask;
stream << std::setw(9) << std::setfill(' ') << "0x";
stream << std::hex << std::setfill('0');
- stream << std::setw(8) << info.usage_policy.consumer_deny_set_mask;
+ stream << std::setw(8) << info.usage_policy.usage_deny_set_mask;
stream << std::setw(11) << std::setfill(' ') << "0x";
stream << std::hex << std::setfill('0');
- stream << std::setw(8) << info.usage_policy.consumer_deny_clear_mask;
+ stream << std::setw(8) << info.usage_policy.usage_deny_clear_mask;
stream << std::hex << std::setfill('0');
stream << std::endl;
}
Status<void> BufferHubService::OnCreateBuffer(Message& message, uint32_t width,
uint32_t height, uint32_t format,
- uint64_t producer_usage,
- uint64_t consumer_usage,
+ uint64_t usage,
size_t meta_size_bytes,
size_t slice_count) {
// Use the producer channel id as the global buffer id.
const int buffer_id = message.GetChannelId();
ALOGD_IF(TRACE,
"BufferHubService::OnCreateBuffer: buffer_id=%d width=%u height=%u "
- "format=%u producer_usage=%" PRIx64 " consumer_usage=%" PRIx64
- " meta_size_bytes=%zu slice_count=%zu",
- buffer_id, width, height, format, producer_usage, consumer_usage,
- meta_size_bytes, slice_count);
+ "format=%u usage=%" PRIx64 " meta_size_bytes=%zu slice_count=%zu",
+ buffer_id, width, height, format, usage, meta_size_bytes,
+ slice_count);
// See if this channel is already attached to a buffer.
if (const auto channel = message.GetChannel<BufferHubChannel>()) {
}
auto status = ProducerChannel::Create(this, buffer_id, width, height, format,
- producer_usage, consumer_usage,
- meta_size_bytes, slice_count);
+ usage, meta_size_bytes, slice_count);
if (status) {
message.SetChannel(status.take());
return {};
Status<void> BufferHubService::OnCreatePersistentBuffer(
Message& message, const std::string& name, int user_id, int group_id,
- uint32_t width, uint32_t height, uint32_t format, uint64_t producer_usage,
- uint64_t consumer_usage, size_t meta_size_bytes, size_t slice_count) {
+ uint32_t width, uint32_t height, uint32_t format, uint64_t usage,
+ size_t meta_size_bytes, size_t slice_count) {
const int channel_id = message.GetChannelId();
ALOGD_IF(TRACE,
"BufferHubService::OnCreatePersistentBuffer: channel_id=%d name=%s "
"user_id=%d group_id=%d width=%u height=%u format=%u "
- "producer_usage=%" PRIx64 " consumer_usage=%" PRIx64
- " meta_size_bytes=%zu slice_count=%zu",
+ "usage=%" PRIx64 " meta_size_bytes=%zu slice_count=%zu",
channel_id, name.c_str(), user_id, group_id, width, height, format,
- producer_usage, consumer_usage, meta_size_bytes, slice_count);
+ usage, meta_size_bytes, slice_count);
// See if this channel is already attached to a buffer.
if (const auto channel = message.GetChannel<BufferHubChannel>()) {
"not have permission to access named buffer: name=%s euid=%d egid=%d",
name.c_str(), euid, euid);
return ErrorStatus(EPERM);
- } else if (!buffer->CheckParameters(width, height, format, producer_usage,
- consumer_usage, meta_size_bytes,
- slice_count)) {
+ } else if (!buffer->CheckParameters(width, height, format, usage,
+ meta_size_bytes, slice_count)) {
ALOGE(
"BufferHubService::OnCreatePersistentBuffer: Requested an existing "
"buffer with different parameters: name=%s",
return {};
}
} else {
- auto status = ProducerChannel::Create(
- this, channel_id, width, height, format, producer_usage, consumer_usage,
- meta_size_bytes, slice_count);
+ auto status =
+ ProducerChannel::Create(this, channel_id, width, height, format, usage,
+ meta_size_bytes, slice_count);
if (!status) {
ALOGE("BufferHubService::OnCreateBuffer: Failed to create producer!!");
return status.error_status();
uint32_t width = 0;
uint32_t height = 0;
uint32_t format = 0;
- uint64_t producer_usage = 0;
- uint64_t consumer_usage = 0;
+ uint64_t usage = 0;
size_t slice_count = 0;
std::string name;
// Data filed for producer queue.
size_t capacity = 0;
- UsagePolicy usage_policy{0, 0, 0, 0, 0, 0, 0, 0};
+ UsagePolicy usage_policy{0, 0, 0, 0};
BufferInfo(int id, size_t consumer_count, uint32_t width, uint32_t height,
- uint32_t format, uint64_t producer_usage,
- uint64_t consumer_usage, size_t slice_count,
+ uint32_t format, uint64_t usage, size_t slice_count,
const std::string& name)
: id(id),
type(kProducerType),
width(width),
height(height),
format(format),
- producer_usage(producer_usage),
- consumer_usage(consumer_usage),
+ usage(usage),
slice_count(slice_count),
name(name) {}
std::unordered_map<std::string, std::shared_ptr<ProducerChannel>>
named_buffers_;
- pdx::Status<void> OnCreateBuffer(pdx::Message& message, uint32_t width, uint32_t height,
- uint32_t format, uint64_t producer_usage,
- uint64_t consumer_usage, size_t meta_size_bytes,
- size_t slice_count);
- pdx::Status<void> OnCreatePersistentBuffer(pdx::Message& message, const std::string& name,
- int user_id, int group_id, uint32_t width,
- uint32_t height, uint32_t format,
- uint64_t producer_usage, uint64_t consumer_usage,
- size_t meta_size_bytes, size_t slice_count);
- pdx::Status<void> OnGetPersistentBuffer(pdx::Message& message, const std::string& name);
+ pdx::Status<void> OnCreateBuffer(pdx::Message& message, uint32_t width,
+ uint32_t height, uint32_t format,
+ uint64_t usage, size_t meta_size_bytes,
+ size_t slice_count);
+ pdx::Status<void> OnCreatePersistentBuffer(
+ pdx::Message& message, const std::string& name, int user_id, int group_id,
+ uint32_t width, uint32_t height, uint32_t format, uint64_t usage,
+ size_t meta_size_bytes, size_t slice_count);
+ pdx::Status<void> OnGetPersistentBuffer(pdx::Message& message,
+ const std::string& name);
pdx::Status<QueueInfo> OnCreateProducerQueue(pdx::Message& message,
size_t meta_size_bytes,
const UsagePolicy& usage_policy);
ProducerChannel::ProducerChannel(BufferHubService* service, int channel_id,
uint32_t width, uint32_t height,
- uint32_t format, uint64_t producer_usage,
- uint64_t consumer_usage,
+ uint32_t format, uint64_t usage,
size_t meta_size_bytes, size_t slice_count,
int* error)
: BufferHubChannel(service, channel_id, channel_id, kProducerType),
meta_size_bytes_(meta_size_bytes),
meta_(meta_size_bytes ? new uint8_t[meta_size_bytes] : nullptr) {
for (auto& ion_buffer : slices_) {
- const int ret = ion_buffer.Alloc(width, height, format,
- (producer_usage | consumer_usage));
+ const int ret = ion_buffer.Alloc(width, height, format, usage);
if (ret < 0) {
ALOGE("ProducerChannel::ProducerChannel: Failed to allocate buffer: %s",
strerror(-ret));
Status<std::shared_ptr<ProducerChannel>> ProducerChannel::Create(
BufferHubService* service, int channel_id, uint32_t width, uint32_t height,
- uint32_t format, uint64_t producer_usage, uint64_t consumer_usage,
- size_t meta_size_bytes, size_t slice_count) {
+ uint32_t format, uint64_t usage, size_t meta_size_bytes,
+ size_t slice_count) {
int error;
- std::shared_ptr<ProducerChannel> producer(new ProducerChannel(
- service, channel_id, width, height, format, producer_usage,
- consumer_usage, meta_size_bytes, slice_count, &error));
+ std::shared_ptr<ProducerChannel> producer(
+ new ProducerChannel(service, channel_id, width, height, format, usage,
+ meta_size_bytes, slice_count, &error));
if (error < 0)
return ErrorStatus(-error);
else
BufferHubChannel::BufferInfo ProducerChannel::GetBufferInfo() const {
return BufferInfo(buffer_id(), consumer_channels_.size(), slices_[0].width(),
slices_[0].height(), slices_[0].format(),
- slices_[0].usage(), slices_[0].usage(),
- slices_.size(), name_);
+ slices_[0].usage(), slices_.size(), name_);
}
void ProducerChannel::HandleImpulse(Message& message) {
// Returns true if the given parameters match the underlying buffer parameters.
bool ProducerChannel::CheckParameters(uint32_t width, uint32_t height,
- uint32_t format, uint64_t producer_usage,
- uint64_t consumer_usage,
+ uint32_t format, uint64_t usage,
size_t meta_size_bytes,
size_t slice_count) {
return slices_.size() == slice_count && meta_size_bytes == meta_size_bytes_ &&
slices_[0].width() == width && slices_[0].height() == height &&
- slices_[0].format() == format &&
- slices_[0].usage() == (producer_usage | consumer_usage);
+ slices_[0].format() == format && slices_[0].usage() == usage;
}
} // namespace dvr
static pdx::Status<std::shared_ptr<ProducerChannel>> Create(
BufferHubService* service, int channel_id, uint32_t width,
- uint32_t height, uint32_t format, uint64_t producer_usage,
- uint64_t consumer_usage, size_t meta_size_bytes, size_t slice_count);
+ uint32_t height, uint32_t format, uint64_t usage, size_t meta_size_bytes,
+ size_t slice_count);
~ProducerChannel() override;
bool CheckAccess(int euid, int egid);
bool CheckParameters(uint32_t width, uint32_t height, uint32_t format,
- uint64_t producer_usage, uint64_t consumer_usage,
- size_t meta_size_bytes, size_t slice_count);
+ uint64_t usage, size_t meta_size_bytes,
+ size_t slice_count);
pdx::Status<void> OnProducerMakePersistent(Message& message,
const std::string& name,
std::string name_;
ProducerChannel(BufferHubService* service, int channel, uint32_t width,
- uint32_t height, uint32_t format, uint64_t producer_usage,
- uint64_t consumer_usage, size_t meta_size_bytes,
- size_t slice_count, int* error);
+ uint32_t height, uint32_t format, uint64_t usage,
+ size_t meta_size_bytes, size_t slice_count, int* error);
pdx::Status<void> OnProducerPost(
Message& message, LocalFence acquire_fence,
const UsagePolicy& usage_policy) {
// Configuration between |usage_deny_set_mask| and |usage_deny_clear_mask|
// should be mutually exclusive.
- if ((usage_policy.producer_deny_set_mask &
- usage_policy.producer_deny_clear_mask) ||
- (usage_policy.consumer_deny_set_mask &
- usage_policy.consumer_deny_clear_mask)) {
+ if ((usage_policy.usage_deny_set_mask &
+ usage_policy.usage_deny_clear_mask)) {
ALOGE(
"BufferHubService::OnCreateProducerQueue: illegal usage mask "
- "configuration: producer_deny_set_mask=%" PRIx64
- " producer_deny_clear_mask=%" PRIx64 " consumer_deny_set_mask=%" PRIx64
- " consumer_deny_clear_mask=%" PRIx64,
- usage_policy.producer_deny_set_mask,
- usage_policy.producer_deny_clear_mask,
- usage_policy.consumer_deny_set_mask,
- usage_policy.consumer_deny_clear_mask);
+ "configuration: usage_deny_set_mask=%" PRIx64
+ " usage_deny_clear_mask=%" PRIx64,
+ usage_policy.usage_deny_set_mask,
+ usage_policy.usage_deny_clear_mask);
return ErrorStatus(EINVAL);
}
Status<std::vector<std::pair<RemoteChannelHandle, size_t>>>
ProducerQueueChannel::OnProducerQueueAllocateBuffers(
Message& message, uint32_t width, uint32_t height, uint32_t format,
- uint64_t producer_usage, uint64_t consumer_usage, size_t slice_count,
- size_t buffer_count) {
+ uint64_t usage, size_t slice_count, size_t buffer_count) {
ATRACE_NAME("ProducerQueueChannel::OnProducerQueueAllocateBuffers");
ALOGD_IF(TRACE,
"ProducerQueueChannel::OnProducerQueueAllocateBuffers: "
std::vector<std::pair<RemoteChannelHandle, size_t>> buffer_handles;
// Deny buffer allocation violating preset rules.
- if (producer_usage & usage_policy_.producer_deny_set_mask) {
+ if (usage & usage_policy_.usage_deny_set_mask) {
ALOGE(
- "ProducerQueueChannel::OnProducerQueueAllocateBuffers: producer_usage: "
- "%" PRIx64
- " is not permitted. Violating producer_deny_set_mask, the following "
- "bits shall not be set: %" PRIx64 ".",
- producer_usage, usage_policy_.producer_deny_set_mask);
+ "ProducerQueueChannel::OnProducerQueueAllocateBuffers: usage: %" PRIx64
+ " is not permitted. Violating usage_deny_set_mask, the following bits "
+ "shall not be set: %" PRIx64 ".",
+ usage, usage_policy_.usage_deny_set_mask);
return ErrorStatus(EINVAL);
}
- if (consumer_usage & usage_policy_.consumer_deny_set_mask) {
+ if (~usage & usage_policy_.usage_deny_clear_mask) {
ALOGE(
- "ProducerQueueChannel::OnProducerQueueAllocateBuffers: consumer_usage: "
- "%" PRIx64
- " is not permitted. Violating consumer_deny_set_mask, the following "
- "bits shall not be set: %" PRIx64 ".",
- consumer_usage, usage_policy_.consumer_deny_set_mask);
- return ErrorStatus(EINVAL);
- }
-
- if (~producer_usage & usage_policy_.producer_deny_clear_mask) {
- ALOGE(
- "ProducerQueueChannel::OnProducerQueueAllocateBuffers: producer_usage: "
- "%" PRIx64
- " is not permitted. Violating producer_deny_clear_mask, the following "
+ "ProducerQueueChannel::OnProducerQueueAllocateBuffers: usage: %" PRIx64
+ " is not permitted. Violating usage_deny_clear_mask, the following "
"bits must be set: %" PRIx64 ".",
- producer_usage, usage_policy_.producer_deny_clear_mask);
+ usage, usage_policy_.usage_deny_clear_mask);
return ErrorStatus(EINVAL);
}
- if (~consumer_usage & usage_policy_.consumer_deny_clear_mask) {
- ALOGE(
- "ProducerQueueChannel::OnProducerQueueAllocateBuffers: consumer_usage: "
- "%" PRIx64
- " is not permitted. Violating consumer_deny_clear_mask, the following "
- "bits must be set: %" PRIx64 ".",
- consumer_usage, usage_policy_.consumer_deny_clear_mask);
- return ErrorStatus(EINVAL);
- }
- // Force set mask and clear mask. Note that |usage_policy_.X_set_mask_| takes
- // precedence and will overwrite |usage_policy_.X_clear_mask|.
- uint64_t effective_producer_usage =
- (producer_usage & ~usage_policy_.producer_clear_mask) |
- usage_policy_.producer_set_mask;
- uint64_t effective_consumer_usage =
- (consumer_usage & ~usage_policy_.consumer_clear_mask) |
- usage_policy_.consumer_set_mask;
+ // Force set mask and clear mask. Note that |usage_policy_.usage_set_mask_|
+ // takes precedence and will overwrite |usage_policy_.usage_clear_mask|.
+ uint64_t effective_usage =
+ (usage & ~usage_policy_.usage_clear_mask) | usage_policy_.usage_set_mask;
for (size_t i = 0; i < buffer_count; i++) {
- auto status =
- AllocateBuffer(message, width, height, format, effective_producer_usage,
- effective_consumer_usage, slice_count);
+ auto status = AllocateBuffer(message, width, height, format,
+ effective_usage, slice_count);
if (!status) {
ALOGE(
"ProducerQueueChannel::OnProducerQueueAllocateBuffers: Failed to "
Status<std::pair<RemoteChannelHandle, size_t>>
ProducerQueueChannel::AllocateBuffer(Message& message, uint32_t width,
uint32_t height, uint32_t format,
- uint64_t producer_usage,
- uint64_t consumer_usage,
- size_t slice_count) {
+ uint64_t usage, size_t slice_count) {
ATRACE_NAME("ProducerQueueChannel::AllocateBuffer");
ALOGD_IF(TRACE,
"ProducerQueueChannel::AllocateBuffer: producer_channel_id=%d",
ALOGD_IF(TRACE,
"ProducerQueueChannel::AllocateBuffer: buffer_id=%d width=%u "
- "height=%u format=%u producer_usage=%" PRIx64
- " consumer_usage=%" PRIx64 " slice_count=%zu",
- buffer_id, width, height, format, producer_usage, consumer_usage,
- slice_count);
+ "height=%u format=%u usage=%" PRIx64 " slice_count=%zu",
+ buffer_id, width, height, format, usage, slice_count);
auto buffer_handle = status.take();
- auto producer_channel_status = ProducerChannel::Create(
- service(), buffer_id, width, height, format, producer_usage,
- consumer_usage, meta_size_bytes_, slice_count);
+ auto producer_channel_status =
+ ProducerChannel::Create(service(), buffer_id, width, height, format,
+ usage, meta_size_bytes_, slice_count);
if (!producer_channel_status) {
ALOGE(
"ProducerQueueChannel::AllocateBuffer: Failed to create producer "
pdx::Status<std::vector<std::pair<pdx::RemoteChannelHandle, size_t>>>
OnProducerQueueAllocateBuffers(pdx::Message& message, uint32_t width,
uint32_t height, uint32_t format,
- uint64_t producer_usage,
- uint64_t consumer_usage, size_t slice_count,
+ uint64_t usage, size_t slice_count,
size_t buffer_count);
// Detach a BufferHubProducer indicated by |slot|. Note that the buffer must
// allocated buffer.
pdx::Status<std::pair<pdx::RemoteChannelHandle, size_t>> AllocateBuffer(
pdx::Message& message, uint32_t width, uint32_t height, uint32_t format,
- uint64_t producer_usage, uint64_t consumer_usage, size_t slice_count);
+ uint64_t usage, size_t slice_count);
// Size of the meta data associated with all the buffers allocated from the
// queue. Now we assume the metadata size is immutable once the queue is