// Main entry point
int main(int argc, char** argv)
{
LOG(INFO) << "EVS app starting";
// Register a signal handler
registerSigHandler();
// Set up default behavior, then check for command line options
bool useVehicleHal = true;
bool printHelp = false;
const char* evsServiceName = "default";
int displayId = -1;
bool useExternalMemory = false;
android_pixel_format_t extMemoryFormat = HAL_PIXEL_FORMAT_RGBA_8888;
int32_t mockGearSignal = static_cast<int32_t>(VehicleGear::GEAR_REVERSE);
for (int i = 1; i < argc; i++)
{
...
}
// Load our configuration information
ConfigManager config;
if (!config.initialize(CONFIG_OVERRIDE_PATH))
{
if (!config.initialize(CONFIG_DEFAULT_PATH))
{
return EXIT_FAILURE;
}
}
configureRpcThreadpool(1, false /* callerWillJoin */);
// Construct our async helper object
sp<EvsVehicleListener> pEvsListener = new EvsVehicleListener();
// Get the EVS manager service
LOG(INFO) << "Acquiring EVS Enumerator";
pEvs = IEvsEnumerator::getService(evsServiceName);
if (pEvs.get() == nullptr)
{
LOG(ERROR) << "getService(" << evsServiceName
<< ") returned NULL. Exiting.";
return EXIT_FAILURE;
}
// Request exclusive access to the EVS display
LOG(INFO) << "Acquiring EVS Display";
// We'll use an available display device.
displayId = config.setActiveDisplayId(displayId);
if (displayId < 0)
{
PLOG(ERROR) << "EVS Display is unknown. Exiting.";
return EXIT_FAILURE;
}
pDisplay = pEvs->openDisplay_1_1(displayId);
if (pDisplay.get() == nullptr)
{
LOG(ERROR) << "EVS Display unavailable. Exiting.";
return EXIT_FAILURE;
}
config.useExternalMemory(useExternalMemory);
config.setExternalMemoryFormat(extMemoryFormat);
// Set a mock gear signal for the test mode
config.setMockGearSignal(mockGearSignal);
// Connect to the Vehicle HAL so we can monitor state
sp<IVehicle> pVnet;
if (useVehicleHal)
{
LOG(INFO) << "Connecting to Vehicle HAL";
pVnet = IVehicle::getService();
if (pVnet.get() == nullptr)
{
LOG(ERROR) << "Vehicle HAL getService returned NULL. Exiting.";
return EXIT_FAILURE;
}
else
{
if (!subscribeToVHal(pVnet, pEvsListener, VehicleProperty::GEAR_SELECTION))
{
LOG(ERROR) << "Without gear notification, we can't support EVS. Exiting.";
return EXIT_FAILURE;
}
if (!subscribeToVHal(pVnet, pEvsListener, VehicleProperty::TURN_SIGNAL_STATE))
{
LOG(WARNING) << "Didn't get turn signal notifications, so we'll ignore those.";
}
}
}
else
{
LOG(WARNING) << "Test mode selected, so not talking to Vehicle HAL";
}
// Configure ourselves for the current vehicle state at startup
LOG(INFO) << "Constructing state controller";
pStateController = new EvsStateControl(pVnet, pEvs, pDisplay, config);
if (!pStateController->startUpdateLoop())
{
LOG(ERROR) << "Initial configuration failed. Exiting.";
return EXIT_FAILURE;
}
// Run forever, reacting to events as necessary
LOG(INFO) << "Entering running state";
pEvsListener->run(pStateController);
// In normal operation, we expect to run forever, but in some error conditions we'll quit.
// One known example is if another process preempts our registration for our service name.
LOG(ERROR) << "EVS Listener stopped. Exiting.";
return EXIT_SUCCESS;
}
/**
* This call returns a handle to a frame buffer associated with the display.
*
* @return buffer A handle to a frame buffer. The returned 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.
*/
getTargetBuffer() generates (BufferDesc buffer);
/**
* 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)
{
// ALOGD("%s Entered", __FUNCTION__);
std::lock_guard<std::mutex> lock(mAccessLock);
if (mRequestedState == EvsDisplayState::DEAD)
{
ALOGE("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
ALOGE("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)
{
// ALOGE << "Error " << result
// << " allocating " << mBuffer.width << " x " << mBuffer.height
// << " graphics buffer.";
ALOGE("allocating width:%d,height:%d graphics buffer error", mBuffer.width, mBuffer.height);
_hidl_cb({});
mGlWrapper.shutdown();
return Void();
}
if (!handle)
{
ALOGE("We didn't get a buffer handle back from the allocator");
_hidl_cb({});
mGlWrapper.shutdown();
return Void();
}
mBuffer.memHandle = handle;
ALOGD("Allocated new buffer %p with stride:%d ", mBuffer.memHandle.getNativeHandle(), 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
ALOGE("getTargetBuffer called while no buffers available.");
_hidl_cb({});
return Void();
}
else
{
// Mark our buffer as busy
mFrameBusy = true;
// Send the buffer to the client
ALOGV("Providing display buffer handle:%p as id %d ", mBuffer.memHandle.getNativeHandle(), mBuffer.bufferId);
_hidl_cb(mBuffer);
return Void();
}
}
/**
* Return a frame that was delivered by to the IEvsCameraStream.
*
* When done consuming a frame delivered to the IEvsCameraStream
* interface, it must be returned to the IEvsCamera for reuse.
* A small, finite number of buffers are available (possibly as small
* as one), and if the supply is exhausted, no further frames may be
* delivered until a buffer is returned.
*
* @param buffer A buffer to be returned.
*/
oneway doneWithFrame(BufferDesc buffer);
IEvsCameraStream.hal：
/**
* Receives calls from the HAL each time a video frame is ready for inspection.
* Buffer handles received by this method must be returned via calls to
* IEvsCamera::doneWithFrame(). When the video stream is stopped via a call
* to IEvsCamera::stopVideoStream(), this callback may continue to happen for
* some time as the pipeline drains. Each frame must still be returned.
* When the last frame in the stream has been delivered, a NULL bufferHandle
* must be delivered, signifying the end of the stream. No further frame
* deliveries may happen thereafter.
*
* @param buffer a buffer descriptor of a delivered image frame.
*/
oneway deliverFrame(BufferDesc buffer);
2
0
CN 
EN