| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define ATRACE_TAG ATRACE_TAG_GRAPHICS |
| #define LOG_TAG "hwc-drm-utils" |
| |
| #include "drmhwcomposer.h" |
| #include "platform.h" |
| |
| #include <cutils/log.h> |
| |
| namespace android { |
| |
| const hwc_drm_bo *DrmHwcBuffer::operator->() const { |
| if (importer_ == NULL) { |
| ALOGE("Access of non-existent BO"); |
| exit(1); |
| return NULL; |
| } |
| return &bo_; |
| } |
| |
| void DrmHwcBuffer::Clear() { |
| if (importer_ != NULL) { |
| importer_->ReleaseBuffer(&bo_); |
| importer_ = NULL; |
| } |
| } |
| |
| int DrmHwcBuffer::ImportBuffer(buffer_handle_t handle, Importer *importer) { |
| hwc_drm_bo tmp_bo; |
| |
| int ret = importer->ImportBuffer(handle, &tmp_bo); |
| if (ret) |
| return ret; |
| |
| if (importer_ != NULL) { |
| importer_->ReleaseBuffer(&bo_); |
| } |
| |
| importer_ = importer; |
| |
| bo_ = tmp_bo; |
| |
| return 0; |
| } |
| |
| static native_handle_t *dup_buffer_handle(buffer_handle_t handle) { |
| native_handle_t *new_handle = |
| native_handle_create(handle->numFds, handle->numInts); |
| if (new_handle == NULL) |
| return NULL; |
| |
| const int *old_data = handle->data; |
| int *new_data = new_handle->data; |
| for (int i = 0; i < handle->numFds; i++) { |
| *new_data = dup(*old_data); |
| old_data++; |
| new_data++; |
| } |
| memcpy(new_data, old_data, sizeof(int) * handle->numInts); |
| |
| return new_handle; |
| } |
| |
| static void free_buffer_handle(native_handle_t *handle) { |
| int ret = native_handle_close(handle); |
| if (ret) |
| ALOGE("Failed to close native handle %d", ret); |
| ret = native_handle_delete(handle); |
| if (ret) |
| ALOGE("Failed to delete native handle %d", ret); |
| } |
| |
| int DrmHwcNativeHandle::CopyBufferHandle(buffer_handle_t handle, |
| const gralloc_module_t *gralloc) { |
| native_handle_t *handle_copy = dup_buffer_handle(handle); |
| if (handle_copy == NULL) { |
| ALOGE("Failed to duplicate handle"); |
| return -ENOMEM; |
| } |
| |
| int ret = gralloc->registerBuffer(gralloc, handle_copy); |
| if (ret) { |
| ALOGE("Failed to register buffer handle %d", ret); |
| free_buffer_handle(handle_copy); |
| return ret; |
| } |
| |
| Clear(); |
| |
| gralloc_ = gralloc; |
| handle_ = handle_copy; |
| |
| return 0; |
| } |
| |
| DrmHwcNativeHandle::~DrmHwcNativeHandle() { |
| Clear(); |
| } |
| |
| void DrmHwcNativeHandle::Clear() { |
| if (gralloc_ != NULL && handle_ != NULL) { |
| gralloc_->unregisterBuffer(gralloc_, handle_); |
| free_buffer_handle(handle_); |
| gralloc_ = NULL; |
| handle_ = NULL; |
| } |
| } |
| |
| int DrmHwcLayer::InitFromHwcLayer(hwc_layer_1_t *sf_layer, Importer *importer, |
| const gralloc_module_t *gralloc) { |
| alpha = sf_layer->planeAlpha; |
| |
| SetSourceCrop(sf_layer->sourceCropf); |
| SetDisplayFrame(sf_layer->displayFrame); |
| SetTransform(sf_layer->transform); |
| |
| switch (sf_layer->blending) { |
| case HWC_BLENDING_NONE: |
| blending = DrmHwcBlending::kNone; |
| break; |
| case HWC_BLENDING_PREMULT: |
| blending = DrmHwcBlending::kPreMult; |
| break; |
| case HWC_BLENDING_COVERAGE: |
| blending = DrmHwcBlending::kCoverage; |
| break; |
| default: |
| ALOGE("Invalid blending in hwc_layer_1_t %d", sf_layer->blending); |
| return -EINVAL; |
| } |
| |
| sf_handle = sf_layer->handle; |
| |
| return ImportBuffer(importer, gralloc); |
| } |
| |
| int DrmHwcLayer::ImportBuffer(Importer *importer, |
| const gralloc_module_t *gralloc) { |
| int ret = buffer.ImportBuffer(sf_handle, importer); |
| if (ret) |
| return ret; |
| |
| ret = handle.CopyBufferHandle(sf_handle, gralloc); |
| if (ret) |
| return ret; |
| |
| ret = gralloc->perform(gralloc, GRALLOC_MODULE_PERFORM_GET_USAGE, |
| handle.get(), &gralloc_buffer_usage); |
| if (ret) { |
| ALOGE("Failed to get usage for buffer %p (%d)", handle.get(), ret); |
| return ret; |
| } |
| return 0; |
| } |
| |
| void DrmHwcLayer::SetSourceCrop(hwc_frect_t const &crop) { |
| source_crop = DrmHwcRect<float>(crop.left, crop.top, crop.right, crop.bottom); |
| } |
| |
| void DrmHwcLayer::SetDisplayFrame(hwc_rect_t const &frame) { |
| display_frame = |
| DrmHwcRect<int>(frame.left, frame.top, frame.right, frame.bottom); |
| } |
| |
| void DrmHwcLayer::SetTransform(int32_t sf_transform) { |
| transform = 0; |
| // 270* and 180* cannot be combined with flips. More specifically, they |
| // already contain both horizontal and vertical flips, so those fields are |
| // redundant in this case. 90* rotation can be combined with either horizontal |
| // flip or vertical flip, so treat it differently |
| if (sf_transform == HWC_TRANSFORM_ROT_270) { |
| transform = DrmHwcTransform::kRotate270; |
| } else if (sf_transform == HWC_TRANSFORM_ROT_180) { |
| transform = DrmHwcTransform::kRotate180; |
| } else { |
| if (sf_transform & HWC_TRANSFORM_FLIP_H) |
| transform |= DrmHwcTransform::kFlipH; |
| if (sf_transform & HWC_TRANSFORM_FLIP_V) |
| transform |= DrmHwcTransform::kFlipV; |
| if (sf_transform & HWC_TRANSFORM_ROT_90) |
| transform |= DrmHwcTransform::kRotate90; |
| } |
| } |
| } |