evs/apps/default/RenderDirectView.cpp - platform/packages/services/Car - Gitiles

 /*
  * Copyright (C) 2017 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 "RenderDirectView.h"

 #include "VideoTex.h"
 #include "glError.h"
 #include "shader.h"
 #include "shader_simpleTex.h"

 #include <android-base/logging.h>
 #include <android/hardware/camera/device/3.2/ICameraDevice.h>
 #include <math/mat4.h>
 #include <system/camera_metadata.h>

 using ::android::hardware::camera::device::V3_2::Stream;
 using ::android::hardware::graphics::common::V1_0::PixelFormat;


 typedef struct {
     int32_t id;
     int32_t width;
     int32_t height;
     int32_t format;
     int32_t direction;
     int32_t framerate;
 } RawStreamConfig;

 const size_t kStreamCfgSz = sizeof(RawStreamConfig) / sizeof(int32_t);


 RenderDirectView::RenderDirectView(sp<IEvsEnumerator> enumerator,
                                    const CameraDesc& camDesc,
                                    const ConfigManager& config) :
     mEnumerator(enumerator),
     mCameraDesc(camDesc),
     mConfig(config) {
     // Find and store the target camera configuration
     const auto& camList = mConfig.getCameras();
     const auto target = std::find_if(camList.begin(), camList.end(),
                                      [this](const ConfigManager::CameraInfo& info) {
                                          return info.cameraId == mCameraDesc.v1.cameraId;
                                      });
     if (target != camList.end()) {
         // Store the info
         mCameraInfo = *target;

         // Calculate a rotation matrix
         float sinRoll, cosRoll;
         sincosf(mCameraInfo.roll, &sinRoll, &cosRoll);
         mRotationMat = {cosRoll, -sinRoll, sinRoll, cosRoll};
     }
 }


 bool RenderDirectView::activate() {
     // Ensure GL is ready to go...
     if (!prepareGL()) {
         LOG(ERROR) << "Error initializing GL";
         return false;
     }

     // Load our shader program if we don't have it already
     if (!mShaderProgram) {
         mShaderProgram = buildShaderProgram(vtxShader_simpleTexture,
                                             pixShader_simpleTexture,
                                             "simpleTexture");
         if (!mShaderProgram) {
             LOG(ERROR) << "Error building shader program";
             return false;
         }
     }

     bool foundCfg = false;
     std::unique_ptr<Stream> targetCfg(new Stream());

     if (!foundCfg) {
         // This logic picks the first configuration in the list among them that
         // support RGBA8888 format and its frame rate is faster than minReqFps.
         const int32_t minReqFps = 15;
         int32_t maxArea = 0;
         camera_metadata_entry_t streamCfgs;
         if (!find_camera_metadata_entry(
                  reinterpret_cast<camera_metadata_t *>(mCameraDesc.metadata.data()),
                  ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
                  &streamCfgs)) {
             // Stream configurations are found in metadata
             RawStreamConfig *ptr = reinterpret_cast<RawStreamConfig *>(streamCfgs.data.i32);
             for (unsigned idx = 0; idx < streamCfgs.count; idx += kStreamCfgSz) {
                 if (ptr->direction == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT &&
                     ptr->format == HAL_PIXEL_FORMAT_RGBA_8888) {

                     if (ptr->framerate >= minReqFps &&
                         ptr->width * ptr->height > maxArea) {
                         targetCfg->id = ptr->id;
                         targetCfg->width = ptr->width;
                         targetCfg->height = ptr->height;

                         maxArea = ptr->width * ptr->height;

                         foundCfg = true;
                     }
                 }
                 ++ptr;
             }
         } else {
             LOG(WARNING) << "No stream configuration data is found; "
                          << "default parameters will be used.";
         }
     }

     // This client always wants below input data format
     targetCfg->format =
         static_cast<PixelFormat>(HAL_PIXEL_FORMAT_RGBA_8888);

     // Construct our video texture
     mTexture.reset(createVideoTexture(mEnumerator,
                                       mCameraDesc.v1.cameraId.c_str(),
                                       foundCfg ? std::move(targetCfg) : nullptr,
                                       sDisplay,
                                       mConfig.getUseExternalMemory(),
                                       mConfig.getExternalMemoryFormat()));
     if (!mTexture) {
         LOG(ERROR) << "Failed to set up video texture for " << mCameraDesc.v1.cameraId;
 // TODO:  For production use, we may actually want to fail in this case, but not yet...
 //       return false;
     }

     return true;
 }


 void RenderDirectView::deactivate() {
     // Release our video texture
     // We can't hold onto it because some other Render object might need the same camera
     // TODO(b/131492626):  investigate whether sharing video textures can save
     // the time.
   mTexture = nullptr;
 }


 bool RenderDirectView::drawFrame(const BufferDesc& tgtBuffer) {
     // Tell GL to render to the given buffer
     if (!attachRenderTarget(tgtBuffer)) {
         LOG(ERROR) << "Failed to attached render target";
         return false;
     }

     // Select our screen space simple texture shader
     glUseProgram(mShaderProgram);

     // Set up the model to clip space transform (identity matrix if we're modeling in screen space)
     android::vec2 leftTop = {-0.5f, 0.5f};
     android::vec2 rightTop = {0.5f, 0.5f};
     android::vec2 leftBottom = {-0.5f, -0.5f};
     android::vec2 rightBottom = {0.5f, -0.5f};
     GLint loc = glGetUniformLocation(mShaderProgram, "cameraMat");
     if (loc < 0) {
         LOG(ERROR) << "Couldn't set shader parameter 'cameraMat'";
         return false;
     } else {
         const android::mat4 identityMatrix;
         glUniformMatrix4fv(loc, 1, false, identityMatrix.asArray());

         // Rotate the preview
         leftTop     = mRotationMat * leftTop;
         leftBottom  = mRotationMat * leftBottom;
         rightTop    = mRotationMat * rightTop;
         rightBottom = mRotationMat * rightBottom;
     }

     // Bind the texture and assign it to the shader's sampler
     mTexture->refresh();
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, mTexture->glId());


     GLint sampler = glGetUniformLocation(mShaderProgram, "tex");
     if (sampler < 0) {
         LOG(ERROR) << "Couldn't set shader parameter 'tex'";
         return false;
     } else {
         // Tell the sampler we looked up from the shader to use texture slot 0 as its source
         glUniform1i(sampler, 0);
     }

     // We want our image to show up opaque regardless of alpha values
     glDisable(GL_BLEND);


     // Draw a rectangle on the screen
     GLfloat vertsCarPos[] = { -1.0,  1.0, 0.0f,   // left top in window space
                                1.0,  1.0, 0.0f,   // right top
                               -1.0, -1.0, 0.0f,   // left bottom
                                1.0, -1.0, 0.0f    // right bottom
     };

     // Flip the preview if needed
     if (mCameraInfo.hflip) {
         std::swap(leftTop.x, rightTop.x);
         std::swap(leftBottom.x, rightBottom.x);
     }

     if (mCameraInfo.vflip) {
         std::swap(leftTop.y, leftBottom.y);
         std::swap(rightTop.y, rightBottom.y);
     }

     GLfloat vertsCarTex[] = { leftTop.x + 0.5f, leftTop.y + 0.5f,
                               rightTop.x + 0.5f, rightTop.y + 0.5f,
                               leftBottom.x + 0.5f, leftBottom.y + 0.5f,
                               rightBottom.x + 0.5f, rightBottom.y + 0.5f
     };
     glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vertsCarPos);
     glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, vertsCarTex);
     glEnableVertexAttribArray(0);
     glEnableVertexAttribArray(1);

     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

     glDisableVertexAttribArray(0);
     glDisableVertexAttribArray(1);


     // Now that everything is submitted, release our hold on the texture resource
     detachRenderTarget();

     // Wait for the rendering to finish
     glFinish();
     detachRenderTarget();
     return true;
 }
	/*
	* Copyright (C) 2017 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 "RenderDirectView.h"

	#include "VideoTex.h"
	#include "glError.h"
	#include "shader.h"
	#include "shader_simpleTex.h"

	#include <android-base/logging.h>
	#include <android/hardware/camera/device/3.2/ICameraDevice.h>
	#include <math/mat4.h>
	#include <system/camera_metadata.h>

	using ::android::hardware::camera::device::V3_2::Stream;
	using ::android::hardware::graphics::common::V1_0::PixelFormat;


	typedef struct {
	int32_t id;
	int32_t width;
	int32_t height;
	int32_t format;
	int32_t direction;
	int32_t framerate;
	} RawStreamConfig;

	const size_t kStreamCfgSz = sizeof(RawStreamConfig) / sizeof(int32_t);


	RenderDirectView::RenderDirectView(sp<IEvsEnumerator> enumerator,
	const CameraDesc& camDesc,
	const ConfigManager& config) :
	mEnumerator(enumerator),
	mCameraDesc(camDesc),
	mConfig(config) {
	// Find and store the target camera configuration
	const auto& camList = mConfig.getCameras();
	const auto target = std::find_if(camList.begin(), camList.end(),
	[this](const ConfigManager::CameraInfo& info) {
	return info.cameraId == mCameraDesc.v1.cameraId;
	});
	if (target != camList.end()) {
	// Store the info
	mCameraInfo = *target;

	// Calculate a rotation matrix
	float sinRoll, cosRoll;
	sincosf(mCameraInfo.roll, &sinRoll, &cosRoll);
	mRotationMat = {cosRoll, -sinRoll, sinRoll, cosRoll};
	}
	}


	bool RenderDirectView::activate() {
	// Ensure GL is ready to go...
	if (!prepareGL()) {
	LOG(ERROR) << "Error initializing GL";
	return false;
	}

	// Load our shader program if we don't have it already
	if (!mShaderProgram) {
	mShaderProgram = buildShaderProgram(vtxShader_simpleTexture,
	pixShader_simpleTexture,
	"simpleTexture");
	if (!mShaderProgram) {
	LOG(ERROR) << "Error building shader program";
	return false;
	}
	}

	bool foundCfg = false;
	std::unique_ptr<Stream> targetCfg(new Stream());

	if (!foundCfg) {
	// This logic picks the first configuration in the list among them that
	// support RGBA8888 format and its frame rate is faster than minReqFps.
	const int32_t minReqFps = 15;
	int32_t maxArea = 0;
	camera_metadata_entry_t streamCfgs;
	if (!find_camera_metadata_entry(
	reinterpret_cast<camera_metadata_t *>(mCameraDesc.metadata.data()),
	ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
	&streamCfgs)) {
	// Stream configurations are found in metadata
	RawStreamConfig ptr = reinterpret_cast<RawStreamConfig >(streamCfgs.data.i32);
	for (unsigned idx = 0; idx < streamCfgs.count; idx += kStreamCfgSz) {
	if (ptr->direction == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT &&
	ptr->format == HAL_PIXEL_FORMAT_RGBA_8888) {

	if (ptr->framerate >= minReqFps &&
	ptr->width * ptr->height > maxArea) {
	targetCfg->id = ptr->id;
	targetCfg->width = ptr->width;
	targetCfg->height = ptr->height;

	maxArea = ptr->width * ptr->height;

	foundCfg = true;
	}
	}
	++ptr;
	}
	} else {
	LOG(WARNING) << "No stream configuration data is found; "
	<< "default parameters will be used.";
	}
	}

	// This client always wants below input data format
	targetCfg->format =
	static_cast<PixelFormat>(HAL_PIXEL_FORMAT_RGBA_8888);

	// Construct our video texture
	mTexture.reset(createVideoTexture(mEnumerator,
	mCameraDesc.v1.cameraId.c_str(),
	foundCfg ? std::move(targetCfg) : nullptr,
	sDisplay,
	mConfig.getUseExternalMemory(),
	mConfig.getExternalMemoryFormat()));
	if (!mTexture) {
	LOG(ERROR) << "Failed to set up video texture for " << mCameraDesc.v1.cameraId;
	// TODO: For production use, we may actually want to fail in this case, but not yet...
	// return false;
	}

	return true;
	}


	void RenderDirectView::deactivate() {
	// Release our video texture
	// We can't hold onto it because some other Render object might need the same camera
	// TODO(b/131492626): investigate whether sharing video textures can save
	// the time.
	mTexture = nullptr;
	}


	bool RenderDirectView::drawFrame(const BufferDesc& tgtBuffer) {
	// Tell GL to render to the given buffer
	if (!attachRenderTarget(tgtBuffer)) {
	LOG(ERROR) << "Failed to attached render target";
	return false;
	}

	// Select our screen space simple texture shader
	glUseProgram(mShaderProgram);

	// Set up the model to clip space transform (identity matrix if we're modeling in screen space)
	android::vec2 leftTop = {-0.5f, 0.5f};
	android::vec2 rightTop = {0.5f, 0.5f};
	android::vec2 leftBottom = {-0.5f, -0.5f};
	android::vec2 rightBottom = {0.5f, -0.5f};
	GLint loc = glGetUniformLocation(mShaderProgram, "cameraMat");
	if (loc < 0) {
	LOG(ERROR) << "Couldn't set shader parameter 'cameraMat'";
	return false;
	} else {
	const android::mat4 identityMatrix;
	glUniformMatrix4fv(loc, 1, false, identityMatrix.asArray());

	// Rotate the preview
	leftTop = mRotationMat * leftTop;
	leftBottom = mRotationMat * leftBottom;
	rightTop = mRotationMat * rightTop;
	rightBottom = mRotationMat * rightBottom;
	}

	// Bind the texture and assign it to the shader's sampler
	mTexture->refresh();
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, mTexture->glId());


	GLint sampler = glGetUniformLocation(mShaderProgram, "tex");
	if (sampler < 0) {
	LOG(ERROR) << "Couldn't set shader parameter 'tex'";
	return false;
	} else {
	// Tell the sampler we looked up from the shader to use texture slot 0 as its source
	glUniform1i(sampler, 0);
	}

	// We want our image to show up opaque regardless of alpha values
	glDisable(GL_BLEND);


	// Draw a rectangle on the screen
	GLfloat vertsCarPos[] = { -1.0, 1.0, 0.0f, // left top in window space
	1.0, 1.0, 0.0f, // right top
	-1.0, -1.0, 0.0f, // left bottom
	1.0, -1.0, 0.0f // right bottom
	};

	// Flip the preview if needed
	if (mCameraInfo.hflip) {
	std::swap(leftTop.x, rightTop.x);
	std::swap(leftBottom.x, rightBottom.x);
	}

	if (mCameraInfo.vflip) {
	std::swap(leftTop.y, leftBottom.y);
	std::swap(rightTop.y, rightBottom.y);
	}

	GLfloat vertsCarTex[] = { leftTop.x + 0.5f, leftTop.y + 0.5f,
	rightTop.x + 0.5f, rightTop.y + 0.5f,
	leftBottom.x + 0.5f, leftBottom.y + 0.5f,
	rightBottom.x + 0.5f, rightBottom.y + 0.5f
	};
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vertsCarPos);
	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, vertsCarTex);
	glEnableVertexAttribArray(0);
	glEnableVertexAttribArray(1);

	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

	glDisableVertexAttribArray(0);
	glDisableVertexAttribArray(1);


	// Now that everything is submitted, release our hold on the texture resource
	detachRenderTarget();

	// Wait for the rendering to finish
	glFinish();
	detachRenderTarget();
	return true;
	}