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.
325 lines
11 KiB
325 lines
11 KiB
/*
|
|
* 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.
|
|
*/
|
|
|
|
#include "EvsGlDisplay.h"
|
|
|
|
#include <ui/GraphicBufferAllocator.h>
|
|
#include <ui/GraphicBufferMapper.h>
|
|
#include <utils/SystemClock.h>
|
|
|
|
using ::android::frameworks::automotive::display::V1_0::HwDisplayConfig;
|
|
using ::android::frameworks::automotive::display::V1_0::HwDisplayState;
|
|
|
|
namespace android {
|
|
namespace hardware {
|
|
namespace automotive {
|
|
namespace evs {
|
|
namespace V1_1 {
|
|
namespace implementation {
|
|
|
|
#ifdef EVS_DEBUG
|
|
static bool sDebugFirstFrameDisplayed = false;
|
|
#endif
|
|
|
|
|
|
EvsGlDisplay::EvsGlDisplay(sp<IAutomotiveDisplayProxyService> pDisplayProxy, uint64_t displayId)
|
|
: mDisplayProxy(pDisplayProxy),
|
|
mDisplayId(displayId) {
|
|
LOG(DEBUG) << "EvsGlDisplay instantiated";
|
|
|
|
// Set up our self description
|
|
// NOTE: These are arbitrary values chosen for testing
|
|
mInfo.displayId = "Mock Display";
|
|
mInfo.vendorFlags = 3870;
|
|
}
|
|
|
|
|
|
EvsGlDisplay::~EvsGlDisplay() {
|
|
LOG(DEBUG) << "EvsGlDisplay being destroyed";
|
|
forceShutdown();
|
|
}
|
|
|
|
|
|
/**
|
|
* This gets called if another caller "steals" ownership of the display
|
|
*/
|
|
void EvsGlDisplay::forceShutdown()
|
|
{
|
|
LOG(DEBUG) << "EvsGlDisplay forceShutdown";
|
|
std::lock_guard<std::mutex> lock(mAccessLock);
|
|
|
|
// If the buffer isn't being held by a remote client, release it now as an
|
|
// optimization to release the resources more quickly than the destructor might
|
|
// get called.
|
|
if (mBuffer.memHandle) {
|
|
// Report if we're going away while a buffer is outstanding
|
|
if (mFrameBusy) {
|
|
LOG(ERROR) << "EvsGlDisplay going down while client is holding a buffer";
|
|
}
|
|
|
|
// Drop the graphics buffer we've been using
|
|
GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
|
|
alloc.free(mBuffer.memHandle);
|
|
mBuffer.memHandle = nullptr;
|
|
|
|
mGlWrapper.hideWindow(mDisplayProxy, mDisplayId);
|
|
mGlWrapper.shutdown();
|
|
}
|
|
|
|
// Put this object into an unrecoverable error state since somebody else
|
|
// is going to own the display now.
|
|
mRequestedState = EvsDisplayState::DEAD;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns basic information about the EVS display provided by the system.
|
|
* See the description of the DisplayDesc structure for details.
|
|
*/
|
|
Return<void> EvsGlDisplay::getDisplayInfo(getDisplayInfo_cb _hidl_cb) {
|
|
LOG(DEBUG) << __FUNCTION__;
|
|
|
|
// Send back our self description
|
|
_hidl_cb(mInfo);
|
|
return Void();
|
|
}
|
|
|
|
|
|
/**
|
|
* Clients may set the display state to express their desired state.
|
|
* The HAL implementation must gracefully accept a request for any state
|
|
* while in any other state, although the response may be to ignore the request.
|
|
* The display is defined to start in the NOT_VISIBLE state upon initialization.
|
|
* The client is then expected to request the VISIBLE_ON_NEXT_FRAME state, and
|
|
* then begin providing video. When the display is no longer required, the client
|
|
* is expected to request the NOT_VISIBLE state after passing the last video frame.
|
|
*/
|
|
Return<EvsResult> EvsGlDisplay::setDisplayState(EvsDisplayState state) {
|
|
LOG(DEBUG) << __FUNCTION__;
|
|
std::lock_guard<std::mutex> lock(mAccessLock);
|
|
|
|
if (mRequestedState == EvsDisplayState::DEAD) {
|
|
// This object no longer owns the display -- it's been superceeded!
|
|
return EvsResult::OWNERSHIP_LOST;
|
|
}
|
|
|
|
// Ensure we recognize the requested state so we don't go off the rails
|
|
if (state >= EvsDisplayState::NUM_STATES) {
|
|
return EvsResult::INVALID_ARG;
|
|
}
|
|
|
|
switch (state) {
|
|
case EvsDisplayState::NOT_VISIBLE:
|
|
mGlWrapper.hideWindow(mDisplayProxy, mDisplayId);
|
|
break;
|
|
case EvsDisplayState::VISIBLE:
|
|
mGlWrapper.showWindow(mDisplayProxy, mDisplayId);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// Record the requested state
|
|
mRequestedState = state;
|
|
|
|
return EvsResult::OK;
|
|
}
|
|
|
|
|
|
/**
|
|
* The HAL implementation should report the actual current state, which might
|
|
* transiently differ from the most recently requested state. Note, however, that
|
|
* the logic responsible for changing display states should generally live above
|
|
* the device layer, making it undesirable for the HAL implementation to
|
|
* spontaneously change display states.
|
|
*/
|
|
Return<EvsDisplayState> EvsGlDisplay::getDisplayState() {
|
|
LOG(DEBUG) << __FUNCTION__;
|
|
std::lock_guard<std::mutex> lock(mAccessLock);
|
|
|
|
return mRequestedState;
|
|
}
|
|
|
|
|
|
/**
|
|
* This call returns a handle to a frame buffer associated with the display.
|
|
* This buffer may be locked and written to by software and/or GL. This buffer
|
|
* must be returned via a call to returnTargetBufferForDisplay() even if the
|
|
* display is no longer visible.
|
|
*/
|
|
Return<void> EvsGlDisplay::getTargetBuffer(getTargetBuffer_cb _hidl_cb) {
|
|
LOG(DEBUG) << __FUNCTION__;
|
|
std::lock_guard<std::mutex> lock(mAccessLock);
|
|
|
|
if (mRequestedState == EvsDisplayState::DEAD) {
|
|
LOG(ERROR) << "Rejecting buffer request from object that lost ownership of the display.";
|
|
_hidl_cb({});
|
|
return Void();
|
|
}
|
|
|
|
// If we don't already have a buffer, allocate one now
|
|
if (!mBuffer.memHandle) {
|
|
// Initialize our display window
|
|
// NOTE: This will cause the display to become "VISIBLE" before a frame is actually
|
|
// returned, which is contrary to the spec and will likely result in a black frame being
|
|
// (briefly) shown.
|
|
if (!mGlWrapper.initialize(mDisplayProxy, mDisplayId)) {
|
|
// Report the failure
|
|
LOG(ERROR) << "Failed to initialize GL display";
|
|
_hidl_cb({});
|
|
return Void();
|
|
}
|
|
|
|
// Assemble the buffer description we'll use for our render target
|
|
mBuffer.width = mGlWrapper.getWidth();
|
|
mBuffer.height = mGlWrapper.getHeight();
|
|
mBuffer.format = HAL_PIXEL_FORMAT_RGBA_8888;
|
|
mBuffer.usage = GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_COMPOSER;
|
|
mBuffer.bufferId = 0x3870; // Arbitrary magic number for self recognition
|
|
mBuffer.pixelSize = 4;
|
|
|
|
// Allocate the buffer that will hold our displayable image
|
|
buffer_handle_t handle = nullptr;
|
|
GraphicBufferAllocator& alloc(GraphicBufferAllocator::get());
|
|
status_t result = alloc.allocate(mBuffer.width, mBuffer.height,
|
|
mBuffer.format, 1,
|
|
mBuffer.usage, &handle,
|
|
&mBuffer.stride,
|
|
0, "EvsGlDisplay");
|
|
if (result != NO_ERROR) {
|
|
LOG(ERROR) << "Error " << result
|
|
<< " allocating " << mBuffer.width << " x " << mBuffer.height
|
|
<< " graphics buffer.";
|
|
_hidl_cb({});
|
|
mGlWrapper.shutdown();
|
|
return Void();
|
|
}
|
|
if (!handle) {
|
|
LOG(ERROR) << "We didn't get a buffer handle back from the allocator";
|
|
_hidl_cb({});
|
|
mGlWrapper.shutdown();
|
|
return Void();
|
|
}
|
|
|
|
mBuffer.memHandle = handle;
|
|
LOG(DEBUG) << "Allocated new buffer " << mBuffer.memHandle.getNativeHandle()
|
|
<< " with stride " << mBuffer.stride;
|
|
mFrameBusy = false;
|
|
}
|
|
|
|
// Do we have a frame available?
|
|
if (mFrameBusy) {
|
|
// This means either we have a 2nd client trying to compete for buffers
|
|
// (an unsupported mode of operation) or else the client hasn't returned
|
|
// a previously issued buffer yet (they're behaving badly).
|
|
// NOTE: We have to make the callback even if we have nothing to provide
|
|
LOG(ERROR) << "getTargetBuffer called while no buffers available.";
|
|
_hidl_cb({});
|
|
return Void();
|
|
} else {
|
|
// Mark our buffer as busy
|
|
mFrameBusy = true;
|
|
|
|
// Send the buffer to the client
|
|
LOG(VERBOSE) << "Providing display buffer handle " << mBuffer.memHandle.getNativeHandle()
|
|
<< " as id " << mBuffer.bufferId;
|
|
_hidl_cb(mBuffer);
|
|
return Void();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* This call tells the display that the buffer is ready for display.
|
|
* The buffer is no longer valid for use by the client after this call.
|
|
*/
|
|
Return<EvsResult> EvsGlDisplay::returnTargetBufferForDisplay(const BufferDesc_1_0& buffer) {
|
|
LOG(VERBOSE) << __FUNCTION__ << " " << buffer.memHandle.getNativeHandle();
|
|
std::lock_guard<std::mutex> lock(mAccessLock);
|
|
|
|
// Nobody should call us with a null handle
|
|
if (!buffer.memHandle.getNativeHandle()) {
|
|
LOG(ERROR) << __FUNCTION__
|
|
<< " called without a valid buffer handle.";
|
|
return EvsResult::INVALID_ARG;
|
|
}
|
|
if (buffer.bufferId != mBuffer.bufferId) {
|
|
LOG(ERROR) << "Got an unrecognized frame returned.";
|
|
return EvsResult::INVALID_ARG;
|
|
}
|
|
if (!mFrameBusy) {
|
|
LOG(ERROR) << "A frame was returned with no outstanding frames.";
|
|
return EvsResult::BUFFER_NOT_AVAILABLE;
|
|
}
|
|
|
|
mFrameBusy = false;
|
|
|
|
// If we've been displaced by another owner of the display, then we can't do anything else
|
|
if (mRequestedState == EvsDisplayState::DEAD) {
|
|
return EvsResult::OWNERSHIP_LOST;
|
|
}
|
|
|
|
// If we were waiting for a new frame, this is it!
|
|
if (mRequestedState == EvsDisplayState::VISIBLE_ON_NEXT_FRAME) {
|
|
mRequestedState = EvsDisplayState::VISIBLE;
|
|
mGlWrapper.showWindow(mDisplayProxy, mDisplayId);
|
|
}
|
|
|
|
// Validate we're in an expected state
|
|
if (mRequestedState != EvsDisplayState::VISIBLE) {
|
|
// Not sure why a client would send frames back when we're not visible.
|
|
LOG(WARNING) << "Got a frame returned while not visible - ignoring.";
|
|
} else {
|
|
// Update the texture contents with the provided data
|
|
// TODO: Why doesn't it work to pass in the buffer handle we got from HIDL?
|
|
// if (!mGlWrapper.updateImageTexture(buffer)) {
|
|
if (!mGlWrapper.updateImageTexture(mBuffer)) {
|
|
return EvsResult::UNDERLYING_SERVICE_ERROR;
|
|
}
|
|
|
|
// Put the image on the screen
|
|
mGlWrapper.renderImageToScreen();
|
|
#ifdef EVS_DEBUG
|
|
if (!sDebugFirstFrameDisplayed) {
|
|
LOG(DEBUG) << "EvsFirstFrameDisplayTiming start time: "
|
|
<< elapsedRealtime() << " ms.";
|
|
sDebugFirstFrameDisplayed = true;
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
return EvsResult::OK;
|
|
}
|
|
|
|
|
|
Return<void> EvsGlDisplay::getDisplayInfo_1_1(getDisplayInfo_1_1_cb _info_cb) {
|
|
if (mDisplayProxy != nullptr) {
|
|
return mDisplayProxy->getDisplayInfo(mDisplayId, _info_cb);
|
|
} else {
|
|
_info_cb({}, {});
|
|
return Void();
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace implementation
|
|
} // namespace V1_1
|
|
} // namespace evs
|
|
} // namespace automotive
|
|
} // namespace hardware
|
|
} // namespace android
|