blob: 086ceab6164c7dae5f284441b1aeec69e92cfc59 [file] [log] [blame]
Prabhanjan Kandula96e92342016-03-24 21:03:35 +05301/*
Saurabh Shahc5b2b702016-10-24 17:16:01 -07002 * Copyright (c) 2011-2017 The Linux Foundation. All rights reserved.
Prabhanjan Kandula96e92342016-03-24 21:03:35 +05303 * Not a Contribution
4 *
5 * Copyright (C) 2010 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 */
19
Naseer Ahmed699b4572017-03-09 12:28:45 -050020#define DEBUG 0
Naseer Ahmeddc918132017-03-07 15:25:14 -050021#include <iomanip>
Prabhanjan Kandula96e92342016-03-24 21:03:35 +053022#include <utility>
Naseer Ahmede69031e2016-11-22 20:05:16 -050023#include <vector>
Naseer Ahmeddc918132017-03-07 15:25:14 -050024#include <sstream>
Prabhanjan Kandula96e92342016-03-24 21:03:35 +053025
26#include "qd_utils.h"
27#include "gr_priv_handle.h"
28#include "gr_buf_descriptor.h"
29#include "gr_utils.h"
30#include "gr_buf_mgr.h"
31#include "qdMetaData.h"
32
33namespace gralloc1 {
Naseer Ahmede69031e2016-11-22 20:05:16 -050034std::atomic<gralloc1_buffer_descriptor_t> BufferDescriptor::next_id_(1);
Prabhanjan Kandula96e92342016-03-24 21:03:35 +053035
Naseer Ahmede69031e2016-11-22 20:05:16 -050036BufferManager::BufferManager() : next_id_(0) {
Prabhanjan Kandula96e92342016-03-24 21:03:35 +053037 char property[PROPERTY_VALUE_MAX];
38
39 // Map framebuffer memory
40 if ((property_get("debug.gralloc.map_fb_memory", property, NULL) > 0) &&
41 (!strncmp(property, "1", PROPERTY_VALUE_MAX) ||
42 (!strncasecmp(property, "true", PROPERTY_VALUE_MAX)))) {
43 map_fb_mem_ = true;
44 }
45
46 // Enable UBWC for framebuffer
47 if ((property_get("debug.gralloc.enable_fb_ubwc", property, NULL) > 0) &&
48 (!strncmp(property, "1", PROPERTY_VALUE_MAX) ||
49 (!strncasecmp(property, "true", PROPERTY_VALUE_MAX)))) {
50 ubwc_for_fb_ = true;
51 }
52
53 handles_map_.clear();
Naseer Ahmede69031e2016-11-22 20:05:16 -050054 allocator_ = new Allocator();
55 allocator_->Init();
56}
57
58
59gralloc1_error_t BufferManager::CreateBufferDescriptor(
60 gralloc1_buffer_descriptor_t *descriptor_id) {
61 std::lock_guard<std::mutex> lock(locker_);
62 auto descriptor = std::make_shared<BufferDescriptor>();
63 descriptors_map_.emplace(descriptor->GetId(), descriptor);
64 *descriptor_id = descriptor->GetId();
65 return GRALLOC1_ERROR_NONE;
66}
67
68gralloc1_error_t BufferManager::DestroyBufferDescriptor(
69 gralloc1_buffer_descriptor_t descriptor_id) {
70 std::lock_guard<std::mutex> lock(locker_);
71 const auto descriptor = descriptors_map_.find(descriptor_id);
72 if (descriptor == descriptors_map_.end()) {
73 return GRALLOC1_ERROR_BAD_DESCRIPTOR;
74 }
75 descriptors_map_.erase(descriptor);
76 return GRALLOC1_ERROR_NONE;
Prabhanjan Kandula96e92342016-03-24 21:03:35 +053077}
78
79BufferManager::~BufferManager() {
80 if (allocator_) {
81 delete allocator_;
82 }
83}
84
Prabhanjan Kandula96e92342016-03-24 21:03:35 +053085gralloc1_error_t BufferManager::AllocateBuffers(uint32_t num_descriptors,
Naseer Ahmede69031e2016-11-22 20:05:16 -050086 const gralloc1_buffer_descriptor_t *descriptor_ids,
Prabhanjan Kandula96e92342016-03-24 21:03:35 +053087 buffer_handle_t *out_buffers) {
88 bool shared = true;
89 gralloc1_error_t status = GRALLOC1_ERROR_NONE;
90
91 // since GRALLOC1_CAPABILITY_TEST_ALLOCATE capability is supported
92 // client can ask to test the allocation by passing NULL out_buffers
93 bool test_allocate = !out_buffers;
94
Naseer Ahmede69031e2016-11-22 20:05:16 -050095 // Validate descriptors
96 std::vector<std::shared_ptr<BufferDescriptor>> descriptors;
97 for (uint32_t i = 0; i < num_descriptors; i++) {
98 const auto map_descriptor = descriptors_map_.find(descriptor_ids[i]);
99 if (map_descriptor == descriptors_map_.end()) {
100 return GRALLOC1_ERROR_BAD_DESCRIPTOR;
101 } else {
102 descriptors.push_back(map_descriptor->second);
103 }
104 }
105
106 // Resolve implementation defined formats
107 for (auto &descriptor : descriptors) {
108 descriptor->SetColorFormat(allocator_->GetImplDefinedFormat(descriptor->GetProducerUsage(),
109 descriptor->GetConsumerUsage(),
110 descriptor->GetFormat()));
111 }
112
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530113 // Check if input descriptors can be supported AND
114 // Find out if a single buffer can be shared for all the given input descriptors
115 uint32_t i = 0;
Naseer Ahmede69031e2016-11-22 20:05:16 -0500116 ssize_t max_buf_index = -1;
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530117 shared = allocator_->CheckForBufferSharing(num_descriptors, descriptors, &max_buf_index);
118
119 if (test_allocate) {
120 status = shared ? GRALLOC1_ERROR_NOT_SHARED : status;
121 return status;
122 }
123
124 if (shared && (max_buf_index >= 0)) {
125 // Allocate one and duplicate/copy the handles for each descriptor
Naseer Ahmede69031e2016-11-22 20:05:16 -0500126 if (AllocateBuffer(*descriptors[UINT(max_buf_index)], &out_buffers[max_buf_index])) {
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530127 return GRALLOC1_ERROR_NO_RESOURCES;
128 }
129
130 for (i = 0; i < num_descriptors; i++) {
131 // Create new handle for a given descriptor.
132 // Current assumption is even MetaData memory would be same
133 // Need to revisit if there is a need for own metadata memory
134 if (i != UINT(max_buf_index)) {
Naseer Ahmede69031e2016-11-22 20:05:16 -0500135 CreateSharedHandle(out_buffers[max_buf_index], *descriptors[i], &out_buffers[i]);
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530136 }
137 }
138 } else {
139 // Buffer sharing is not feasible.
Naseer Ahmede69031e2016-11-22 20:05:16 -0500140 // Allocate separate buffer for each descriptor
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530141 for (i = 0; i < num_descriptors; i++) {
Naseer Ahmede69031e2016-11-22 20:05:16 -0500142 if (AllocateBuffer(*descriptors[i], &out_buffers[i])) {
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530143 return GRALLOC1_ERROR_NO_RESOURCES;
144 }
145 }
146 }
147
148 // Allocation is successful. If backstore is not shared inform the client.
149 if (!shared) {
150 return GRALLOC1_ERROR_NOT_SHARED;
151 }
152
153 return status;
154}
155
156void BufferManager::CreateSharedHandle(buffer_handle_t inbuffer, const BufferDescriptor &descriptor,
157 buffer_handle_t *outbuffer) {
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400158 // TODO(user): This path is not verified
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530159 private_handle_t const *input = reinterpret_cast<private_handle_t const *>(inbuffer);
160
161 // Get Buffer attributes or dimension
162 unsigned int alignedw = 0, alignedh = 0;
163 allocator_->GetAlignedWidthAndHeight(descriptor, &alignedw, &alignedh);
164
165 // create new handle from input reference handle and given descriptor
166 int flags = GetHandleFlags(descriptor.GetFormat(), descriptor.GetProducerUsage(),
167 descriptor.GetConsumerUsage());
168 int buffer_type = GetBufferType(descriptor.GetFormat());
169
170 // Duplicate the fds
Saurabh Shah7d476ed2016-06-27 16:40:58 -0700171 // TODO(user): Not sure what to do for fb_id. Use duped fd and new dimensions?
Naseer Ahmede69031e2016-11-22 20:05:16 -0500172 private_handle_t *out_hnd = new private_handle_t(dup(input->fd),
173 dup(input->fd_metadata),
174 flags,
175 INT(alignedw),
176 INT(alignedh),
177 descriptor.GetWidth(),
178 descriptor.GetHeight(),
179 descriptor.GetFormat(),
180 buffer_type,
181 input->size,
182 descriptor.GetProducerUsage(),
183 descriptor.GetConsumerUsage());
184 out_hnd->id = ++next_id_;
185 // TODO(user): Base address of shared handle and ion handles
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400186 RegisterHandle(out_hnd, -1, -1);
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530187 *outbuffer = out_hnd;
188}
189
Naseer Ahmede69031e2016-11-22 20:05:16 -0500190gralloc1_error_t BufferManager::FreeBuffer(std::shared_ptr<Buffer> buf) {
191 auto hnd = buf->handle;
Naseer Ahmed49f2e9c2017-03-23 22:13:17 -0400192 ALOGD_IF(DEBUG, "FreeBuffer handle:%p id: %" PRIu64, hnd, hnd->id);
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530193 if (allocator_->FreeBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset,
Naseer Ahmede69031e2016-11-22 20:05:16 -0500194 hnd->fd, buf->ion_handle_main) != 0) {
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530195 return GRALLOC1_ERROR_BAD_HANDLE;
196 }
197
198 unsigned int meta_size = ALIGN((unsigned int)sizeof(MetaData_t), PAGE_SIZE);
199 if (allocator_->FreeBuffer(reinterpret_cast<void *>(hnd->base_metadata), meta_size,
Naseer Ahmede69031e2016-11-22 20:05:16 -0500200 hnd->offset_metadata, hnd->fd_metadata, buf->ion_handle_meta) != 0) {
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530201 return GRALLOC1_ERROR_BAD_HANDLE;
202 }
203
Naseer Ahmede69031e2016-11-22 20:05:16 -0500204 // TODO(user): delete handle once framework bug around this is confirmed
Naseer Ahmed29a86dd2017-03-16 14:09:46 -0400205 // to be resolved. This is tracked in bug 36355756
206 private_handle_t * handle = const_cast<private_handle_t *>(hnd);
207 handle->fd = -1;
208 handle->fd_metadata = -1;
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530209 return GRALLOC1_ERROR_NONE;
210}
211
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400212void BufferManager::RegisterHandle(const private_handle_t *hnd,
213 int ion_handle,
214 int ion_handle_meta) {
215 auto buffer = std::make_shared<Buffer>(hnd, ion_handle, ion_handle_meta);
216 handles_map_.emplace(std::make_pair(hnd, buffer));
217}
218
219gralloc1_error_t BufferManager::ImportHandle(private_handle_t* hnd) {
Naseer Ahmed49f2e9c2017-03-23 22:13:17 -0400220 ALOGD_IF(DEBUG, "Importing handle:%p id: %" PRIu64, hnd, hnd->id);
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400221 int ion_handle = allocator_->ImportBuffer(hnd->fd);
222 if (ion_handle < 0) {
223 ALOGE("Failed to import ion buffer: hnd: %p, fd:%d, id:%" PRIu64, hnd, hnd->fd, hnd->id);
224 return GRALLOC1_ERROR_BAD_HANDLE;
225 }
226 int ion_handle_meta = allocator_->ImportBuffer(hnd->fd_metadata);
227 if (ion_handle_meta < 0) {
228 ALOGE("Failed to import ion metadata buffer: hnd: %p, fd:%d, id:%" PRIu64, hnd,
229 hnd->fd, hnd->id);
230 return GRALLOC1_ERROR_BAD_HANDLE;
231 }
232 // Set base pointers to NULL since the data here was received over binder
233 hnd->base = 0;
234 hnd->base_metadata = 0;
235 RegisterHandle(hnd, ion_handle, ion_handle_meta);
236 return GRALLOC1_ERROR_NONE;
237}
238
239std::shared_ptr<BufferManager::Buffer>
240BufferManager::GetBufferFromHandle(const private_handle_t *hnd) {
241 auto it = handles_map_.find(hnd);
242 if (it != handles_map_.end()) {
243 return it->second;
244 } else {
245 return nullptr;
246 }
247}
248
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530249gralloc1_error_t BufferManager::MapBuffer(private_handle_t const *handle) {
250 private_handle_t *hnd = const_cast<private_handle_t *>(handle);
Naseer Ahmed49f2e9c2017-03-23 22:13:17 -0400251 ALOGD_IF(DEBUG, "Map buffer handle:%p id: %" PRIu64, hnd, hnd->id);
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530252
253 hnd->base = 0;
254 hnd->base_metadata = 0;
Naseer Ahmed49f2e9c2017-03-23 22:13:17 -0400255
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530256 if (allocator_->MapBuffer(reinterpret_cast<void **>(&hnd->base), hnd->size, hnd->offset,
257 hnd->fd) != 0) {
258 return GRALLOC1_ERROR_BAD_HANDLE;
259 }
260
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400261 unsigned int size = ALIGN((unsigned int)sizeof(MetaData_t), getpagesize());
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530262 if (allocator_->MapBuffer(reinterpret_cast<void **>(&hnd->base_metadata), size,
263 hnd->offset_metadata, hnd->fd_metadata) != 0) {
264 return GRALLOC1_ERROR_BAD_HANDLE;
265 }
266
267 return GRALLOC1_ERROR_NONE;
268}
269
270gralloc1_error_t BufferManager::RetainBuffer(private_handle_t const *hnd) {
Naseer Ahmede69031e2016-11-22 20:05:16 -0500271 std::lock_guard<std::mutex> lock(locker_);
Naseer Ahmed699b4572017-03-09 12:28:45 -0500272 ALOGD_IF(DEBUG, "Retain buffer handle:%p id: %" PRIu64, hnd, hnd->id);
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400273 gralloc1_error_t err = GRALLOC1_ERROR_NONE;
274 auto buf = GetBufferFromHandle(hnd);
275 if (buf != nullptr) {
276 buf->IncRef();
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530277 } else {
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400278 private_handle_t *handle = const_cast<private_handle_t *>(hnd);
279 err = ImportHandle(handle);
280 if (err == GRALLOC1_ERROR_NONE) {
Naseer Ahmed49f2e9c2017-03-23 22:13:17 -0400281 // TODO(user): See bug 35955598
282 if (hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_BUFFER) {
283 return GRALLOC1_ERROR_NONE; // Don't map secure buffer
284 }
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400285 err = MapBuffer(hnd);
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530286 }
287 }
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400288 return err;
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530289}
290
291gralloc1_error_t BufferManager::ReleaseBuffer(private_handle_t const *hnd) {
Naseer Ahmede69031e2016-11-22 20:05:16 -0500292 std::lock_guard<std::mutex> lock(locker_);
Naseer Ahmed699b4572017-03-09 12:28:45 -0500293 ALOGD_IF(DEBUG, "Release buffer handle:%p id: %" PRIu64, hnd, hnd->id);
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400294 auto buf = GetBufferFromHandle(hnd);
295 if (buf == nullptr) {
296 ALOGE("Could not find handle: %p id: %" PRIu64, hnd, hnd->id);
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530297 return GRALLOC1_ERROR_BAD_HANDLE;
298 } else {
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400299 if (buf->DecRef()) {
300 handles_map_.erase(hnd);
301 // Unmap, close ion handle and close fd
Naseer Ahmede69031e2016-11-22 20:05:16 -0500302 FreeBuffer(buf);
303 }
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530304 }
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530305 return GRALLOC1_ERROR_NONE;
306}
307
308gralloc1_error_t BufferManager::LockBuffer(const private_handle_t *hnd,
309 gralloc1_producer_usage_t prod_usage,
310 gralloc1_consumer_usage_t cons_usage) {
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400311 std::lock_guard<std::mutex> lock(locker_);
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530312 gralloc1_error_t err = GRALLOC1_ERROR_NONE;
Naseer Ahmed49f2e9c2017-03-23 22:13:17 -0400313 ALOGD_IF(DEBUG, "LockBuffer buffer handle:%p id: %" PRIu64, hnd, hnd->id);
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530314
315 // If buffer is not meant for CPU return err
316 if (!CpuCanAccess(prod_usage, cons_usage)) {
317 return GRALLOC1_ERROR_BAD_VALUE;
318 }
319
320 if (hnd->base == 0) {
321 // we need to map for real
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530322 err = MapBuffer(hnd);
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400323 }
324
325 auto buf = GetBufferFromHandle(hnd);
326 if (buf == nullptr) {
327 return GRALLOC1_ERROR_BAD_HANDLE;
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530328 }
329
330 // Invalidate if CPU reads in software and there are non-CPU
331 // writers. No need to do this for the metadata buffer as it is
332 // only read/written in software.
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400333
334 // todo use handle here
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530335 if (!err && (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION) &&
336 (hnd->flags & private_handle_t::PRIV_FLAGS_CACHED)) {
337 if (allocator_->CleanBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset,
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400338 buf->ion_handle_main, CACHE_INVALIDATE)) {
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530339 return GRALLOC1_ERROR_BAD_HANDLE;
340 }
341 }
342
343 // Mark the buffer to be flushed after CPU write.
344 if (!err && CpuCanWrite(prod_usage)) {
345 private_handle_t *handle = const_cast<private_handle_t *>(hnd);
346 handle->flags |= private_handle_t::PRIV_FLAGS_NEEDS_FLUSH;
347 }
348
349 return err;
350}
351
352gralloc1_error_t BufferManager::UnlockBuffer(const private_handle_t *handle) {
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400353 std::lock_guard<std::mutex> lock(locker_);
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530354 gralloc1_error_t status = GRALLOC1_ERROR_NONE;
355
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530356 private_handle_t *hnd = const_cast<private_handle_t *>(handle);
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400357 auto buf = GetBufferFromHandle(hnd);
358 if (buf == nullptr) {
359 return GRALLOC1_ERROR_BAD_HANDLE;
360 }
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530361
362 if (hnd->flags & private_handle_t::PRIV_FLAGS_NEEDS_FLUSH) {
363 if (allocator_->CleanBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset,
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400364 buf->ion_handle_main, CACHE_CLEAN) != 0) {
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530365 status = GRALLOC1_ERROR_BAD_HANDLE;
366 }
367 hnd->flags &= ~private_handle_t::PRIV_FLAGS_NEEDS_FLUSH;
368 }
369
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530370 return status;
371}
372
Naseer Ahmede69031e2016-11-22 20:05:16 -0500373uint32_t BufferManager::GetDataAlignment(int format, gralloc1_producer_usage_t prod_usage,
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530374 gralloc1_consumer_usage_t cons_usage) {
Naseer Ahmede69031e2016-11-22 20:05:16 -0500375 uint32_t align = UINT(getpagesize());
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530376 if (format == HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED) {
377 align = 8192;
378 }
379
380 if (prod_usage & GRALLOC1_PRODUCER_USAGE_PROTECTED) {
Sushil Chauhandfe55a22016-09-12 15:48:29 -0700381 if ((prod_usage & GRALLOC1_PRODUCER_USAGE_CAMERA) ||
382 (cons_usage & GRALLOC1_CONSUMER_USAGE_PRIVATE_SECURE_DISPLAY)) {
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530383 // The alignment here reflects qsee mmu V7L/V8L requirement
384 align = SZ_2M;
385 } else {
386 align = SECURE_ALIGN;
387 }
388 }
389
390 return align;
391}
392
393int BufferManager::GetHandleFlags(int format, gralloc1_producer_usage_t prod_usage,
394 gralloc1_consumer_usage_t cons_usage) {
395 int flags = 0;
396 if (cons_usage & GRALLOC1_CONSUMER_USAGE_PRIVATE_EXTERNAL_ONLY) {
397 flags |= private_handle_t::PRIV_FLAGS_EXTERNAL_ONLY;
398 }
399
400 if (cons_usage & GRALLOC1_CONSUMER_USAGE_PRIVATE_INTERNAL_ONLY) {
401 flags |= private_handle_t::PRIV_FLAGS_INTERNAL_ONLY;
402 }
403
404 if (cons_usage & GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER) {
405 flags |= private_handle_t::PRIV_FLAGS_VIDEO_ENCODER;
406 }
407
408 if (prod_usage & GRALLOC1_PRODUCER_USAGE_CAMERA) {
409 flags |= private_handle_t::PRIV_FLAGS_CAMERA_WRITE;
410 }
411
412 if (prod_usage & GRALLOC1_CONSUMER_USAGE_CAMERA) {
413 flags |= private_handle_t::PRIV_FLAGS_CAMERA_READ;
414 }
415
416 if (cons_usage & GRALLOC1_CONSUMER_USAGE_HWCOMPOSER) {
417 flags |= private_handle_t::PRIV_FLAGS_HW_COMPOSER;
418 }
419
420 if (prod_usage & GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE) {
421 flags |= private_handle_t::PRIV_FLAGS_HW_TEXTURE;
422 }
423
424 if (prod_usage & GRALLOC1_CONSUMER_USAGE_PRIVATE_SECURE_DISPLAY) {
425 flags |= private_handle_t::PRIV_FLAGS_SECURE_DISPLAY;
426 }
427
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530428 if (allocator_->IsUBwcEnabled(format, prod_usage, cons_usage)) {
429 flags |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
430 }
431
432 if (prod_usage & (GRALLOC1_PRODUCER_USAGE_CPU_READ | GRALLOC1_PRODUCER_USAGE_CPU_WRITE)) {
433 flags |= private_handle_t::PRIV_FLAGS_CPU_RENDERED;
434 }
435
436 // TODO(user): is this correct???
437 if ((cons_usage &
438 (GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER | GRALLOC1_CONSUMER_USAGE_CLIENT_TARGET)) ||
439 (prod_usage & (GRALLOC1_PRODUCER_USAGE_CAMERA | GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET))) {
440 flags |= private_handle_t::PRIV_FLAGS_NON_CPU_WRITER;
441 }
442
443 if (cons_usage & GRALLOC1_CONSUMER_USAGE_HWCOMPOSER) {
444 flags |= private_handle_t::PRIV_FLAGS_DISP_CONSUMER;
445 }
446
447 if (!allocator_->UseUncached(prod_usage)) {
448 flags |= private_handle_t::PRIV_FLAGS_CACHED;
449 }
450
451 return flags;
452}
453
Ramkumar Radhakrishnanba55eac2016-08-26 22:33:48 -0700454int BufferManager::AllocateBuffer(unsigned int size, int aligned_w, int aligned_h, int unaligned_w,
455 int unaligned_h, int format, int bufferType,
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530456 gralloc1_producer_usage_t prod_usage,
457 gralloc1_consumer_usage_t cons_usage, buffer_handle_t *handle) {
Naseer Ahmede69031e2016-11-22 20:05:16 -0500458 auto page_size = UINT(getpagesize());
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530459 int err = 0;
460 int flags = 0;
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530461 AllocData data;
Naseer Ahmede69031e2016-11-22 20:05:16 -0500462 data.align = GetDataAlignment(format, prod_usage, cons_usage);
463 data.size = ALIGN(size, data.align);
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530464 data.handle = (uintptr_t)handle;
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530465 data.uncached = allocator_->UseUncached(prod_usage);
Naseer Ahmede69031e2016-11-22 20:05:16 -0500466
467 // Allocate buffer memory
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530468 err = allocator_->AllocateMem(&data, prod_usage, cons_usage);
469 if (err) {
470 ALOGE("gralloc failed to allocate err=%s", strerror(-err));
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530471 return err;
472 }
473
Naseer Ahmede69031e2016-11-22 20:05:16 -0500474 // Allocate memory for MetaData
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530475 AllocData e_data;
Naseer Ahmede69031e2016-11-22 20:05:16 -0500476 e_data.size = ALIGN(UINT(sizeof(MetaData_t)), page_size);
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530477 e_data.handle = data.handle;
Naseer Ahmede69031e2016-11-22 20:05:16 -0500478 e_data.align = page_size;
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530479
480 err =
481 allocator_->AllocateMem(&e_data, GRALLOC1_PRODUCER_USAGE_NONE, GRALLOC1_CONSUMER_USAGE_NONE);
Naseer Ahmede69031e2016-11-22 20:05:16 -0500482 if (err) {
483 ALOGE("gralloc failed to allocate metadata error=%s", strerror(-err));
484 return err;
485 }
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530486
487 flags = GetHandleFlags(format, prod_usage, cons_usage);
488 flags |= data.alloc_type;
489
490 // Create handle
Naseer Ahmede69031e2016-11-22 20:05:16 -0500491 private_handle_t *hnd = new private_handle_t(data.fd,
492 e_data.fd,
493 flags,
494 aligned_w,
495 aligned_h,
496 unaligned_w,
497 unaligned_h,
498 format,
499 bufferType,
500 size,
501 prod_usage,
502 cons_usage);
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530503
Naseer Ahmede69031e2016-11-22 20:05:16 -0500504 hnd->id = ++next_id_;
Naseer Ahmed49f2e9c2017-03-23 22:13:17 -0400505 hnd->base = 0;
506 hnd->base_metadata = 0;
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530507
Naseer Ahmede69031e2016-11-22 20:05:16 -0500508 ColorSpace_t colorSpace = ITU_R_601;
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530509 setMetaData(hnd, UPDATE_COLOR_SPACE, reinterpret_cast<void *>(&colorSpace));
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530510 *handle = hnd;
Naseer Ahmed3a9d53a2017-03-15 19:21:40 -0400511 RegisterHandle(hnd, data.ion_handle, e_data.ion_handle);
Naseer Ahmed699b4572017-03-09 12:28:45 -0500512 ALOGD_IF(DEBUG, "Allocated buffer handle: %p id: %" PRIu64, hnd, hnd->id);
513 if (DEBUG) {
514 private_handle_t::Dump(hnd);
515 }
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530516 return err;
517}
518
519int BufferManager::GetBufferType(int inputFormat) {
520 int buffer_type = BUFFER_TYPE_VIDEO;
521 if (IsUncompressedRGBFormat(inputFormat)) {
522 // RGB formats
523 buffer_type = BUFFER_TYPE_UI;
524 }
525
526 return buffer_type;
527}
528
529int BufferManager::AllocateBuffer(const BufferDescriptor &descriptor, buffer_handle_t *handle,
530 unsigned int bufferSize) {
531 if (!handle)
532 return -EINVAL;
533
534 int format = descriptor.GetFormat();
535 gralloc1_producer_usage_t prod_usage = descriptor.GetProducerUsage();
536 gralloc1_consumer_usage_t cons_usage = descriptor.GetConsumerUsage();
537
538 // Get implementation defined format
539 int gralloc_format = allocator_->GetImplDefinedFormat(prod_usage, cons_usage, format);
540
541 bool use_fb_mem = false;
542 if ((cons_usage & GRALLOC1_CONSUMER_USAGE_CLIENT_TARGET) && map_fb_mem_) {
543 use_fb_mem = true;
544 }
545
546 if ((cons_usage & GRALLOC1_CONSUMER_USAGE_CLIENT_TARGET) && ubwc_for_fb_) {
547 prod_usage =
548 (gralloc1_producer_usage_t)(prod_usage | GRALLOC1_PRODUCER_USAGE_PRIVATE_ALLOC_UBWC);
549 }
550
551 unsigned int size;
552 unsigned int alignedw, alignedh;
553 int buffer_type = GetBufferType(gralloc_format);
554 allocator_->GetBufferSizeAndDimensions(descriptor, &size, &alignedw, &alignedh);
555
556 size = (bufferSize >= size) ? bufferSize : size;
557
558 int err = 0;
559 if (use_fb_mem) {
560 // TODO(user): TBD Framebuffer specific implementation in a seperate file/class
561 } else {
562 err = AllocateBuffer(size, INT(alignedw), INT(alignedh), descriptor.GetWidth(),
563 descriptor.GetHeight(), format, buffer_type, descriptor.GetProducerUsage(),
564 descriptor.GetConsumerUsage(), handle);
565 }
566
567 if (err < 0) {
568 return err;
569 }
570
571 return 0;
572}
573
574gralloc1_error_t BufferManager::Perform(int operation, va_list args) {
575 switch (operation) {
576 case GRALLOC_MODULE_PERFORM_CREATE_HANDLE_FROM_BUFFER: {
577 int fd = va_arg(args, int);
578 unsigned int size = va_arg(args, unsigned int);
579 unsigned int offset = va_arg(args, unsigned int);
580 void *base = va_arg(args, void *);
581 int width = va_arg(args, int);
582 int height = va_arg(args, int);
583 int format = va_arg(args, int);
584
585 native_handle_t **handle = va_arg(args, native_handle_t **);
586 private_handle_t *hnd = reinterpret_cast<private_handle_t *>(
587 native_handle_create(private_handle_t::kNumFds, private_handle_t::NumInts()));
588 if (hnd) {
Ramkumar Radhakrishnanba55eac2016-08-26 22:33:48 -0700589 unsigned int alignedw = 0, alignedh = 0;
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530590 hnd->magic = private_handle_t::kMagic;
591 hnd->fd = fd;
592 hnd->flags = private_handle_t::PRIV_FLAGS_USES_ION;
593 hnd->size = size;
594 hnd->offset = offset;
595 hnd->base = uint64_t(base) + offset;
596 hnd->gpuaddr = 0;
Ramkumar Radhakrishnanba55eac2016-08-26 22:33:48 -0700597 BufferDescriptor descriptor(width, height, format);
598 allocator_->GetAlignedWidthAndHeight(descriptor, &alignedw, &alignedh);
599 hnd->unaligned_width = width;
600 hnd->unaligned_height = height;
Naseer Ahmede69031e2016-11-22 20:05:16 -0500601 hnd->width = INT(alignedw);
602 hnd->height = INT(alignedh);
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530603 hnd->format = format;
604 *handle = reinterpret_cast<native_handle_t *>(hnd);
605 }
606 } break;
607
608 case GRALLOC_MODULE_PERFORM_GET_STRIDE: {
609 int width = va_arg(args, int);
610 int format = va_arg(args, int);
611 int *stride = va_arg(args, int *);
612 unsigned int alignedw = 0, alignedh = 0;
613 BufferDescriptor descriptor(width, width, format);
614 allocator_->GetAlignedWidthAndHeight(descriptor, &alignedw, &alignedh);
615 *stride = INT(alignedw);
616 } break;
617
618 case GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_FROM_HANDLE: {
619 private_handle_t *hnd = va_arg(args, private_handle_t *);
620 int *stride = va_arg(args, int *);
621 if (private_handle_t::validate(hnd) != 0) {
622 return GRALLOC1_ERROR_BAD_HANDLE;
623 }
624
Naseer Ahmed49f2e9c2017-03-23 22:13:17 -0400625 BufferDim_t buffer_dim;
626 if (getMetaData(hnd, GET_BUFFER_GEOMETRY, &buffer_dim) == 0) {
627 *stride = buffer_dim.sliceWidth;
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530628 } else {
629 *stride = hnd->width;
630 }
631 } break;
632
633 // TODO(user) : this alone should be sufficient, ask gfx to get rid of above
634 case GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_AND_HEIGHT_FROM_HANDLE: {
635 private_handle_t *hnd = va_arg(args, private_handle_t *);
636 int *stride = va_arg(args, int *);
637 int *height = va_arg(args, int *);
638 if (private_handle_t::validate(hnd) != 0) {
639 return GRALLOC1_ERROR_BAD_HANDLE;
640 }
641
Naseer Ahmed49f2e9c2017-03-23 22:13:17 -0400642 BufferDim_t buffer_dim;
643 if (getMetaData(hnd, GET_BUFFER_GEOMETRY, &buffer_dim) == 0) {
644 *stride = buffer_dim.sliceWidth;
645 *height = buffer_dim.sliceHeight;
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530646 } else {
647 *stride = hnd->width;
648 *height = hnd->height;
649 }
650 } break;
651
652 case GRALLOC_MODULE_PERFORM_GET_ATTRIBUTES: {
653 // TODO(user): Usage is split now. take care of it from Gfx client.
654 // see if we can directly expect descriptor from gfx client.
655 int width = va_arg(args, int);
656 int height = va_arg(args, int);
657 int format = va_arg(args, int);
658 uint64_t producer_usage = va_arg(args, uint64_t);
659 uint64_t consumer_usage = va_arg(args, uint64_t);
660 gralloc1_producer_usage_t prod_usage = static_cast<gralloc1_producer_usage_t>(producer_usage);
661 gralloc1_consumer_usage_t cons_usage = static_cast<gralloc1_consumer_usage_t>(consumer_usage);
662
663 int *aligned_width = va_arg(args, int *);
664 int *aligned_height = va_arg(args, int *);
665 int *tile_enabled = va_arg(args, int *);
666 unsigned int alignedw, alignedh;
667 BufferDescriptor descriptor(width, height, format, prod_usage, cons_usage);
Saurabh Shahc5b2b702016-10-24 17:16:01 -0700668 *tile_enabled = allocator_->IsUBwcEnabled(format, prod_usage, cons_usage);
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530669
670 allocator_->GetAlignedWidthAndHeight(descriptor, &alignedw, &alignedh);
671 *aligned_width = INT(alignedw);
672 *aligned_height = INT(alignedh);
673 } break;
674
675 case GRALLOC_MODULE_PERFORM_GET_COLOR_SPACE_FROM_HANDLE: {
676 private_handle_t *hnd = va_arg(args, private_handle_t *);
677 int *color_space = va_arg(args, int *);
678 if (private_handle_t::validate(hnd) != 0) {
679 return GRALLOC1_ERROR_BAD_HANDLE;
680 }
Naseer Ahmed49f2e9c2017-03-23 22:13:17 -0400681 *color_space = 0;
Arun Kumar K.Rb2771bf2016-10-03 21:38:23 -0700682#ifdef USE_COLOR_METADATA
Naseer Ahmed49f2e9c2017-03-23 22:13:17 -0400683 ColorMetaData color_metadata;
684 if (getMetaData(hnd, GET_COLOR_METADATA, &color_metadata) == 0) {
685 switch (color_metadata.colorPrimaries) {
686 case ColorPrimaries_BT709_5:
687 *color_space = HAL_CSC_ITU_R_709;
688 break;
689 case ColorPrimaries_BT601_6_525:
690 *color_space = ((color_metadata.range) ? HAL_CSC_ITU_R_601_FR : HAL_CSC_ITU_R_601);
691 break;
692 case ColorPrimaries_BT2020:
693 *color_space = (color_metadata.range) ? HAL_CSC_ITU_R_2020_FR : HAL_CSC_ITU_R_2020;
694 break;
695 default:
696 ALOGE("Unknown Color Space = %d", color_metadata.colorPrimaries);
697 break;
Arun Kumar K.Rb2771bf2016-10-03 21:38:23 -0700698 }
Naseer Ahmed49f2e9c2017-03-23 22:13:17 -0400699 break;
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530700 }
Naseer Ahmed49f2e9c2017-03-23 22:13:17 -0400701 if (getMetaData(hnd, GET_COLOR_SPACE, &color_metadata) != 0) {
702 *color_space = 0;
703 }
704#endif
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530705 } break;
706 case GRALLOC_MODULE_PERFORM_GET_YUV_PLANE_INFO: {
707 private_handle_t *hnd = va_arg(args, private_handle_t *);
708 android_ycbcr *ycbcr = va_arg(args, struct android_ycbcr *);
709 if (private_handle_t::validate(hnd) != 0) {
710 return GRALLOC1_ERROR_BAD_HANDLE;
711 }
712 if (allocator_->GetYUVPlaneInfo(hnd, ycbcr)) {
713 return GRALLOC1_ERROR_UNDEFINED;
714 }
715 } break;
716
717 case GRALLOC_MODULE_PERFORM_GET_MAP_SECURE_BUFFER_INFO: {
718 private_handle_t *hnd = va_arg(args, private_handle_t *);
719 int *map_secure_buffer = va_arg(args, int *);
720 if (private_handle_t::validate(hnd) != 0) {
721 return GRALLOC1_ERROR_BAD_HANDLE;
722 }
Naseer Ahmed49f2e9c2017-03-23 22:13:17 -0400723
724 if (getMetaData(hnd, GET_MAP_SECURE_BUFFER, map_secure_buffer) == 0) {
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530725 *map_secure_buffer = 0;
726 }
727 } break;
728
729 case GRALLOC_MODULE_PERFORM_GET_UBWC_FLAG: {
730 private_handle_t *hnd = va_arg(args, private_handle_t *);
731 int *flag = va_arg(args, int *);
732 if (private_handle_t::validate(hnd) != 0) {
733 return GRALLOC1_ERROR_BAD_HANDLE;
734 }
735 *flag = hnd->flags &private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
736 } break;
737
738 case GRALLOC_MODULE_PERFORM_GET_RGB_DATA_ADDRESS: {
739 private_handle_t *hnd = va_arg(args, private_handle_t *);
740 void **rgb_data = va_arg(args, void **);
741 if (private_handle_t::validate(hnd) != 0) {
742 return GRALLOC1_ERROR_BAD_HANDLE;
743 }
744 if (allocator_->GetRgbDataAddress(hnd, rgb_data)) {
745 return GRALLOC1_ERROR_UNDEFINED;
746 }
747 } break;
748
Naseer Ahmede69031e2016-11-22 20:05:16 -0500749 case GRALLOC1_MODULE_PERFORM_GET_BUFFER_SIZE_AND_DIMENSIONS: {
750 int width = va_arg(args, int);
751 int height = va_arg(args, int);
752 int format = va_arg(args, int);
753 uint64_t p_usage = va_arg(args, uint64_t);
754 uint64_t c_usage = va_arg(args, uint64_t);
755 gralloc1_producer_usage_t producer_usage = static_cast<gralloc1_producer_usage_t>(p_usage);
756 gralloc1_consumer_usage_t consumer_usage = static_cast<gralloc1_consumer_usage_t>(c_usage);
757 uint32_t *aligned_width = va_arg(args, uint32_t *);
758 uint32_t *aligned_height = va_arg(args, uint32_t *);
759 uint32_t *size = va_arg(args, uint32_t *);
760 auto descriptor = BufferDescriptor(width, height, format, producer_usage, consumer_usage);
761 allocator_->GetBufferSizeAndDimensions(descriptor, size, aligned_width, aligned_height);
762 // Align size
763 auto align = GetDataAlignment(format, producer_usage, consumer_usage);
764 *size = ALIGN(*size, align);
765 } break;
766
767 // TODO(user): Break out similar functionality, preferably moving to a common lib.
768
769 case GRALLOC1_MODULE_PERFORM_ALLOCATE_BUFFER: {
770 int width = va_arg(args, int);
771 int height = va_arg(args, int);
772 int format = va_arg(args, int);
773 uint64_t p_usage = va_arg(args, uint64_t);
774 uint64_t c_usage = va_arg(args, uint64_t);
775 buffer_handle_t *hnd = va_arg(args, buffer_handle_t*);
776 gralloc1_producer_usage_t producer_usage = static_cast<gralloc1_producer_usage_t>(p_usage);
777 gralloc1_consumer_usage_t consumer_usage = static_cast<gralloc1_consumer_usage_t>(c_usage);
778 BufferDescriptor descriptor(width, height, format, producer_usage, consumer_usage);
779 unsigned int size;
780 unsigned int alignedw, alignedh;
781 allocator_->GetBufferSizeAndDimensions(descriptor, &size, &alignedw, &alignedh);
782 AllocateBuffer(descriptor, hnd, size);
783 } break;
784
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530785 default:
786 break;
787 }
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530788 return GRALLOC1_ERROR_NONE;
789}
790
Naseer Ahmede69031e2016-11-22 20:05:16 -0500791static bool IsYuvFormat(const private_handle_t *hnd) {
792 switch (hnd->format) {
793 case HAL_PIXEL_FORMAT_YCbCr_420_SP:
794 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
795 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
796 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: // Same as YCbCr_420_SP_VENUS
797 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
798 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
799 case HAL_PIXEL_FORMAT_YCrCb_422_SP:
800 case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
801 case HAL_PIXEL_FORMAT_NV21_ZSL:
802 case HAL_PIXEL_FORMAT_RAW16:
Naseer Ahmed92998622017-03-20 12:39:17 -0400803 case HAL_PIXEL_FORMAT_RAW12:
Naseer Ahmede69031e2016-11-22 20:05:16 -0500804 case HAL_PIXEL_FORMAT_RAW10:
805 case HAL_PIXEL_FORMAT_YV12:
806 return true;
807 default:
808 return false;
809 }
810}
811
812gralloc1_error_t BufferManager::GetNumFlexPlanes(const private_handle_t *hnd,
813 uint32_t *out_num_planes) {
814 if (!IsYuvFormat(hnd)) {
815 return GRALLOC1_ERROR_UNSUPPORTED;
816 } else {
817 *out_num_planes = 3;
818 }
819 return GRALLOC1_ERROR_NONE;
820}
821
822gralloc1_error_t BufferManager::GetFlexLayout(const private_handle_t *hnd,
823 struct android_flex_layout *layout) {
824 if (!IsYuvFormat(hnd)) {
825 return GRALLOC1_ERROR_UNSUPPORTED;
826 }
827
828 android_ycbcr ycbcr;
829 int err = allocator_->GetYUVPlaneInfo(hnd, &ycbcr);
830
831 if (err != 0) {
832 return GRALLOC1_ERROR_BAD_HANDLE;
833 }
834
835 layout->format = FLEX_FORMAT_YCbCr;
836 layout->num_planes = 3;
837
838 for (uint32_t i = 0; i < layout->num_planes; i++) {
839 layout->planes[i].bits_per_component = 8;
840 layout->planes[i].bits_used = 8;
841 layout->planes[i].h_increment = 1;
842 layout->planes[i].v_increment = 1;
843 layout->planes[i].h_subsampling = 2;
844 layout->planes[i].v_subsampling = 2;
845 }
846
847 layout->planes[0].top_left = static_cast<uint8_t *>(ycbcr.y);
848 layout->planes[0].component = FLEX_COMPONENT_Y;
849 layout->planes[0].v_increment = static_cast<int32_t>(ycbcr.ystride);
850
851 layout->planes[1].top_left = static_cast<uint8_t *>(ycbcr.cb);
852 layout->planes[1].component = FLEX_COMPONENT_Cb;
853 layout->planes[1].h_increment = static_cast<int32_t>(ycbcr.chroma_step);
854 layout->planes[1].v_increment = static_cast<int32_t>(ycbcr.cstride);
855
856 layout->planes[2].top_left = static_cast<uint8_t *>(ycbcr.cr);
857 layout->planes[2].component = FLEX_COMPONENT_Cr;
858 layout->planes[2].h_increment = static_cast<int32_t>(ycbcr.chroma_step);
859 layout->planes[2].v_increment = static_cast<int32_t>(ycbcr.cstride);
860 return GRALLOC1_ERROR_NONE;
861}
Naseer Ahmeddc918132017-03-07 15:25:14 -0500862
863gralloc1_error_t BufferManager::Dump(std::ostringstream *os) {
864 for (auto it : handles_map_) {
865 auto buf = it.second;
866 auto hnd = buf->handle;
867 *os << "handle id: " << std::setw(4) << hnd->id;
868 *os << " fd: " << std::setw(3) << hnd->fd;
869 *os << " fd_meta: " << std::setw(3) << hnd->fd_metadata;
870 *os << " wxh: " << std::setw(4) << hnd->width <<" x " << std::setw(4) << hnd->height;
871 *os << " uwxuh: " << std::setw(4) << hnd->unaligned_width << " x ";
872 *os << std::setw(4) << hnd->unaligned_height;
873 *os << " size: " << std::setw(9) << hnd->size;
874 *os << std::hex << std::setfill('0');
875 *os << " priv_flags: " << "0x" << std::setw(8) << hnd->flags;
876 *os << " prod_usage: " << "0x" << std::setw(8) << hnd->producer_usage;
877 *os << " cons_usage: " << "0x" << std::setw(8) << hnd->consumer_usage;
878 // TODO(user): get format string from qdutils
879 *os << " format: " << "0x" << std::setw(8) << hnd->format;
880 *os << std::dec << std::setfill(' ') << std::endl;
881 }
882 return GRALLOC1_ERROR_NONE;
883}
Prabhanjan Kandula96e92342016-03-24 21:03:35 +0530884} // namespace gralloc1