rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/vendor/rockchip/hardware/interfaces/rockit/direct/RTSubtitleSink.cpp

714 lines
22 KiB
C++
Executable File
Raw Blame History

/*
* Copyright 2018 Rockchip Electronics Co. LTD
*
* 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.
*
* author: xhr@rock-chips.com
* date: 2019/12/24
*/
//#define LOG_NDEBUG 0
#define LOG_TAG "RTSubteSink"
#include "RTSubtitleSink.h"
#include "RTGraphicWindowApi.h"
#include "HdmiDefine.h"
#include <ui/DisplayMode.h>
#include <ui/DisplayState.h>
#include <input/DisplayViewport.h>
#include <utils/Log.h>
#include <cutils/properties.h> // for property_get
#include "RTChips.h"
using namespace ::android;
enum RkGpuType {
RK_GPU_G6110,
RK_GPU_MALI,
};
RTSubteSink::RTSubteSink() {
mInitialized = false;
mGpuType = RK_GPU_MALI;
// the gpu' ip of 3368 is g6110, and other chips is mali
RKChipInfo *chipInfo = getChipName();
if (chipInfo != NULL && (chipInfo->type == RK_CHIP_3368 || chipInfo->type == RK_CHIP_3368H)) {
mGpuType = RK_GPU_G6110;
}
}
RTSubteSink::~RTSubteSink() {
destroy();
}
void RTSubteSink::create(int renderType, int display) {
if (mInitialized) {
return;
}
mDisplay = EGL_NO_DISPLAY;
mEGLSurface = EGL_NO_SURFACE;
mContext = EGL_NO_CONTEXT;
mRenderType = renderType;
mClient = NULL;
mSurfaceControl = NULL;
mSubtitleZOrder = INT_MAX-2;
mSurfaceShow = false;
mDisplayMode = DISPLAY_ALL;
mDisplayDev = display;
mBindThread = false;
mHdmiMode = HDMI_3D_NONE;
createSubitleSurface();
if(mSurface != NULL) {
createEGLSurface();
}
if (mEGLSurface != EGL_NO_SURFACE) {
mInitialized = true;
show();
}
}
void RTSubteSink::destroy() {
if (mInitialized) {
clean();
destoryEGLSurface();
}
if (mClient != NULL) {
mClient->dispose();
mClient = NULL;
}
mInitialized = false;
}
void RTSubteSink::createEGLSurface() {
Mutex::Autolock autoLock(mRenderLock);
if ((mSurfaceControl == NULL) || (mSurfaceControl->getSurface() == NULL)) {
return ;
}
EGLint defaultConfigAttribs[] = {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, 0,
EGL_NONE
};
EGLint w, h;
EGLint numConfigs;
EGLConfig config;
mDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (mDisplay == EGL_NO_DISPLAY) {
ALOGE("eglGetDisplay error: %#x\n", eglGetError());
}
EGLint majorVersion;
EGLint minorVersion;
eglInitialize(mDisplay, &majorVersion, &minorVersion);
eglChooseConfig(mDisplay,defaultConfigAttribs , &config, 1, &numConfigs);//attribs
mEGLSurface = eglCreateWindowSurface(mDisplay, config,mSurface.get(), NULL);
if (mEGLSurface == EGL_NO_SURFACE) {
ALOGE("eglCreateWindowSurface error: %#x\n", eglGetError());
return;
}
mContext = eglCreateContext(mDisplay, config, EGL_NO_CONTEXT, NULL);
if (mContext == EGL_NO_CONTEXT) {
ALOGE("eglCreateWindowSurface error: %#x\n", eglGetError());
return;
}
eglQuerySurface(mDisplay, mEGLSurface, EGL_WIDTH, &w);
eglQuerySurface(mDisplay, mEGLSurface, EGL_HEIGHT, &h);
mRect.width = w;
mRect.height = h;
ALOGD("create egl surface(width=%d, height=%d)", w, h);
}
void RTSubteSink::destoryEGLSurface() {
Mutex::Autolock autoLock(mRenderLock);
if(mRenderType == RENDER_RGA) {
return ;
}
ALOGD("destoryEGLSurface");
if (mClient != NULL) {
mClient->dispose();
}
if (mDisplay != EGL_NO_DISPLAY) {
eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
}
if (mContext != EGL_NO_CONTEXT) {
eglDestroyContext(mDisplay, mContext);
}
if (mEGLSurface != EGL_NO_SURFACE) {
eglDestroySurface(mDisplay, mEGLSurface);
}
if (mSurface != NULL) {
mSurface.clear();
mSurface = NULL;
}
if (mDisplay != EGL_NO_DISPLAY) {
eglTerminate(mDisplay);
}
mContext = EGL_NO_CONTEXT;
mEGLSurface = EGL_NO_SURFACE;
mDisplay = EGL_NO_DISPLAY;
}
bool RTSubteSink::bindSurfaceToThread() {
Mutex::Autolock autoLock(mRenderLock);
if (mRenderType == RENDER_RGA) {
return false;
}
if (mEGLSurface != EGL_NO_SURFACE) {
if (eglMakeCurrent(mDisplay, mEGLSurface, mEGLSurface, mContext) == EGL_FALSE) {
ALOGD("failed to bind surface to thread");
return false;
}
mBindThread = true;
ALOGD("succeed to bind surface to thread");
return true;
}
ALOGD("failed to bind surface to thread");
return false;
}
void RTSubteSink::initScene() {
Mutex::Autolock autoLock(mRenderLock);
if ((mRenderType == RENDER_GPU) && (mEGLSurface != EGL_NO_SURFACE)) {
glDisable(GL_DITHER);
glEnable(GL_CULL_FACE);
glViewport(0, 0, mRect.width, mRect.height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glOrthof(0,mRect.width,0,mRect.height,0,1);
glEnable(GL_TEXTURE_2D);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
}
}
void RTSubteSink::showScene() {
if (!mInitialized) {
return;
}
if (mRenderType == RENDER_GPU) {
if (mEGLSurface != EGL_NO_SURFACE) {
eglSwapBuffers(mDisplay, mEGLSurface);
}
}
}
void RTSubteSink::render(RTSubFrame *frame) {
if (!mInitialized) {
return;
}
if(!mBindThread) {
bindSurfaceToThread();
}
if(mRenderType == RENDER_GPU) {
gpuRender(frame);
} else {
ALOGE("render: not support");
}
}
void RTSubteSink::gpuRender(RTSubFrame *frame) {
if (mEGLSurface == EGL_NO_SURFACE) {
return;
}
Mutex::Autolock autoLock(mRenderLock);
if (frame != NULL && frame->data != NULL) {
GLuint texture;
int x = frame->x;
int y = frame->y;
int width = frame->width;
int height = frame->height;
initTexture(frame->data,width,height,texture);
float widthScale = ((float)mRect.width/(float)frame->subWidth);
float heightScale = ((float)mRect.height/(float)frame->subHeight);
#if 0
if (mHdmiManager != NULL) {
mode = mHdmiManager->getCurrentMode();
}
#endif
if (mHdmiMode == HDMI_3D_SIDE_BY_SIDE_HALT) {
widthScale = widthScale/2;
} else if (mHdmiMode == HDMI_3D_TOP_BOTTOM) {
heightScale = heightScale/2;
}
float realWidth = ((float)width)*widthScale;
float realHight = ((float)height)*heightScale;
float realX = ((float)x)*widthScale;
float realY = ((float)(frame->subHeight - y))*heightScale-realHight;
if (realY < 0) {
realY = 20;
if (realX*2 + realWidth > mRect.width) {
realX = (mRect.width - realWidth) / 2;
}
if (y + height > frame->subHeight) {
realHight = height * (widthScale >= 2 ? 2 : 1);
}
ALOGD("gpuRender origin coordinate: x = %d,y = %d,width = %d,height = %d", x, y, width, height);
}
GLfloat texCoords[] = {
0, 1,
1.0, 1,
1.0, 0,
0, 0
};
bool changed = false;
if (frame->needcrop && (mDisplayMode == DISPLAY_LEFT_HALF)) {
float texX = 1.0f;
if ((realX < (mRect.width/2)) && ((realX+realWidth) > (mRect.width/2))) {
texX = (((float)(mRect.width/2)-realX))/realWidth;
realX *= 2;
realWidth *= 2;
changed = true;
}
texCoords[2] = texX;//0.5;
texCoords[4] = texX;//0.5;
} else if (frame->needcrop && (mDisplayMode == DISPLAY_TOP_HALF)) {
float texY= 1.0f;
if ((realY < (mRect.height/2)) && ((realY+realHight) > (mRect.height/2))) {
texY = 0.5f;
changed = true;
}
texCoords[1] = texY;
texCoords[3] = texY;
}
const GLushort indices[] = { 0, 1, 2, 0, 2, 3 };
int nelem = sizeof(indices)/sizeof(indices[0]);
// 2D
if (mHdmiMode == HDMI_3D_NONE) {
GLfloat vertices[] = {
realX, realY, 0,
realX+realWidth, realY, 0,
realX+realWidth, realY+realHight, 0,
realX, realY+realHight, 0
};
if (changed) {
if (mDisplayMode == DISPLAY_LEFT_HALF) {
vertices[3] = (realX+realWidth)/2;
vertices[6] = (realX+realWidth)/2;
} else if (mDisplayMode == DISPLAY_TOP_HALF) {
vertices[7] = realY + realHight/2;
vertices[10] = realY + realHight/2;
}
}
glVertexPointer(3, GL_FLOAT, 0, vertices);
glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
glDrawElements(GL_TRIANGLES, nelem, GL_UNSIGNED_SHORT, indices);
} else if (mHdmiMode == HDMI_3D_SIDE_BY_SIDE_HALT) {
float realLeftX = ((float)x)*widthScale;
float realRightX = ((float)x)*widthScale+mRect.width/2;
const GLfloat leftVertices[] = {
realLeftX, realY, 0,
realLeftX+realWidth, realY, 0,
realLeftX+realWidth, realY+realHight, 0,
realLeftX, realY+realHight, 0
};
const GLfloat RightVertices[] = {
realRightX, realY, 0,
realRightX+realWidth, realY, 0,
realRightX+realWidth, realY+realHight, 0,
realRightX, realY+realHight, 0
};
// left
glVertexPointer(3, GL_FLOAT, 0, leftVertices);
glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
glDrawElements(GL_TRIANGLES, nelem, GL_UNSIGNED_SHORT, indices);
// right
glVertexPointer(3, GL_FLOAT, 0, RightVertices);
glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
glDrawElements(GL_TRIANGLES, nelem, GL_UNSIGNED_SHORT, indices);
} else if (mHdmiMode == HDMI_3D_TOP_BOTTOM) {
float realTopY = (float)mRect.height/2 - ((float)y)*heightScale - realHight;
float realBottomY = (float)mRect.height - ((float)y)*heightScale - realHight;
const GLfloat topVertices[] = {
realX, realTopY, 0,
realX+realWidth, realTopY, 0,
realX+realWidth, realTopY+realHight, 0,
realX, realTopY+realHight, 0
};
const GLfloat bottomVertices[] = {
realX, realBottomY, 0,
realX+realWidth, realBottomY, 0,
realX+realWidth, realBottomY+realHight, 0,
realX, realBottomY+realHight, 0
};
// top
glVertexPointer(3, GL_FLOAT, 0, topVertices);
glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
glDrawElements(GL_TRIANGLES, nelem, GL_UNSIGNED_SHORT, indices);
// bottom
glVertexPointer(3, GL_FLOAT, 0, bottomVertices);
glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
glDrawElements(GL_TRIANGLES, nelem, GL_UNSIGNED_SHORT, indices);
}
glDeleteTextures(1, &texture);
}
}
int RTSubteSink::initTexture(void* data,int width,int height,GLuint& texture) {
GLint crop[4] = { 0, height, width, -height };
glEnable(GL_TEXTURE_2D);
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
if (RK_GPU_G6110 == mGpuType) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
return NO_ERROR;
}
void RTSubteSink::clean() {
if (!mInitialized) {
return;
}
if (mRenderType == RENDER_RGA) {
ANativeWindow_Buffer mSurfaceInfo;
unsigned char* mSurfaceBuf = NULL;
ARect dirtyregion;
dirtyregion.left = 0;
dirtyregion.right = 0x3fff;
dirtyregion.top = 0;
dirtyregion.bottom = 0x3fff;
int status = mSurface->lock(&mSurfaceInfo, &dirtyregion);
if (status != 0) {
return ;
}
mSurfaceBuf = reinterpret_cast<unsigned char*>(mSurfaceInfo.bits);
if (mSurfaceBuf != NULL) {
memset(mSurfaceBuf,0, mSurfaceInfo.width* mSurfaceInfo.height*sizeof(int));
}
mSurface->unlockAndPost();
} else if (mRenderType == RENDER_GPU) {
if (mEGLSurface != EGL_NO_SURFACE) {
initScene();
eglSwapBuffers(mDisplay, mEGLSurface);
}
}
}
void RTSubteSink::show() {
if (!mInitialized || mSurfaceShow) {
return;
}
Mutex::Autolock autoLock(mRenderLock);
if (mSurfaceControl != NULL) {
GraphicWindowApi::OpenSurfaceTransaction();
Transaction t;
GraphicWindowApi::ShowSurface(mSurfaceControl, &t);
GraphicWindowApi::CloseSurfaceTransaction(&t);
mSurfaceShow = true;
}
}
void RTSubteSink::hide() {
if (!mInitialized || !mSurfaceShow) {
return;
}
Mutex::Autolock autoLock(mRenderLock);
if (mSurfaceControl != NULL) {
GraphicWindowApi::OpenSurfaceTransaction();
Transaction t;
GraphicWindowApi::HideSurface(mSurfaceControl, &t);
GraphicWindowApi::CloseSurfaceTransaction(&t);
mSurfaceShow = false;
}
}
bool RTSubteSink::isShowing() {
return mSurfaceShow;
}
void RTSubteSink::createSubitleSurface() {
if(mClient == NULL) {
mClient = new SurfaceComposerClient();
if (mClient != NULL) {
ui::DisplayMode mode;
ui::DisplayState state;
getSurfaceMaxWidthAndHeight(mode,state, 0);
// create the native surface
mSurfaceControl = mClient->createSurface(String8("SubtitleSurface"),mode.resolution.getWidth(),mode.resolution.getHeight(),PIXEL_FORMAT_RGBA_8888);
if (mSurfaceControl != NULL) {
GraphicWindowApi::OpenSurfaceTransaction();
Transaction t;
GraphicWindowApi::SetSurfaceLayer(mSurfaceControl, &t, mSubtitleZOrder);
GraphicWindowApi::SetSurfacePosition(mSurfaceControl, &t, 0, 0);
GraphicWindowApi::SetSurfaceSize(mSurfaceControl, &t,mode.resolution.getWidth(),mode.resolution.getHeight());
GraphicWindowApi::CloseSurfaceTransaction(&t);
mSurface = mSurfaceControl->getSurface();
mRect.x = 0;
mRect.y = 0;
mRect.width = mode.resolution.getWidth();
mRect.height = mode.resolution.getHeight();
mRect.rotation = (int)state.orientation;
} else {
ALOGE("createSubitleSurface:mSurfaceControl == NULL");
}
} else {
ALOGE("createSubitleSurface:mClient == NULL");
}
}
}
int RTSubteSink::setLayerStack(int display) {
int status = -1;
Mutex::Autolock autoLock(mRenderLock);
if (mSurfaceControl != NULL) {
GraphicWindowApi::OpenSurfaceTransaction();
Transaction t;
GraphicWindowApi::SetSurfaceLayerStack(mSurfaceControl, &t, display);
GraphicWindowApi::CloseSurfaceTransaction(&t);
status = 0;
}
return status;
}
int RTSubteSink::setSubtitleSurfaceZOrder(int order) {
Mutex::Autolock autoLock(mRenderLock);
if(mSubtitleZOrder != order) {
if (mClient != NULL && mSurfaceControl != NULL) {
GraphicWindowApi::OpenSurfaceTransaction();
Transaction t;
GraphicWindowApi::SetSurfaceLayer(mSurfaceControl, &t, order);
mSubtitleZOrder = order;
GraphicWindowApi::CloseSurfaceTransaction(&t);
return 0;
}
}
return -1;
}
int RTSubteSink::setSubtitleSurfacePosition(int x,int y,int width,int height) {
Mutex::Autolock autoLock(mRenderLock);
if (mClient != NULL && mSurfaceControl != NULL) {
ui::DisplayMode mode;
ui::DisplayState state;
getSurfaceMaxWidthAndHeight(mode,state,0);
int maxWidth = mode.resolution.getWidth();
int maxHeight = mode.resolution.getHeight();
maxWidth = (maxWidth>=width)?width:maxWidth;
maxHeight = (maxHeight>=height)?height:maxHeight;
if((x != mRect.x) || (y != mRect.y) || (maxWidth != mRect.width) || (maxHeight != mRect.height)) {
GraphicWindowApi::OpenSurfaceTransaction();
Transaction t;
GraphicWindowApi::SetSurfacePosition(mSurfaceControl, &t, x, y);
GraphicWindowApi::SetSurfaceSize(mSurfaceControl, &t, maxWidth, maxHeight);
GraphicWindowApi::CloseSurfaceTransaction(&t);
mRect.x = x;
mRect.y = y;
mRect.width = maxWidth;
mRect.height= maxHeight;
}
return 0;
}
return -1;
}
void RTSubteSink::setSubtitleSurfaceVisibility(int visible) {
if (visible == 1) {
show();
} else {
hide();
}
}
void RTSubteSink::displayPgsSubtitle() {
}
SurfaceRect& RTSubteSink::getSurfaceRect() {
return mRect;
}
int RTSubteSink::getSurfaceZOrder() {
return mSubtitleZOrder;
}
void RTSubteSink::setSubtitleMode(int mode) {
mDisplayMode = mode;
}
void RTSubteSink::setHdmiMode(int mode) {
mHdmiMode = mode;
}
bool RTSubteSink::checkRotation() {
Mutex::Autolock autoLock(mRenderLock);
ui::DisplayMode mode;
ui::DisplayState state;
getSurfaceMaxWidthAndHeight(mode, state, mDisplayDev);
if((mode.resolution.getWidth() != mRect.width) || (mode.resolution.getHeight() != mRect.height) || ((int)state.orientation != mRect.rotation)){
mRect.width = mode.resolution.getWidth();
mRect.height = mode.resolution.getHeight();
mRect.rotation = (int)state.orientation;
// if rotation is happend, must set new position and size
GraphicWindowApi::OpenSurfaceTransaction();
Transaction t;
GraphicWindowApi::SetSurfacePosition(mSurfaceControl, &t, mRect.x, mRect.y);
GraphicWindowApi::SetSurfaceSize(mSurfaceControl, &t, mRect.width, mRect.height);
GraphicWindowApi::CloseSurfaceTransaction(&t);
return true;
}
return false;
}
void RTSubteSink::getSurfaceMaxWidthAndHeight(ui::DisplayMode& mode, ui::DisplayState& state, int displayId)
{
int width = 1920;
int height = 1080;
int orientation = DISPLAY_ORIENTATION_0;
status_t err;
// set default value
mode.resolution.set(width,height);
state.orientation = (android::ui::Rotation)orientation;
if(0 /*ISurfaceComposer::eDisplayIdMain*/ != displayId && 1 /*ISurfaceComposer::eDisplayIdHdmi*/ != displayId){
ALOGE("getSurfaceMaxWidthAndHeight: displayId = %d in not suppport, set default widht = 1920,height = 1080", displayId);
return ;
}
// sp<IBinder> display(SurfaceComposerClient::getBuiltInDisplay(displayId));
const auto display = SurfaceComposerClient::getInternalDisplayToken();
if(display == nullptr){
ALOGE("error: no display");
return;
}
err = SurfaceComposerClient::getDisplayState(display, &state);
if(err != NO_ERROR){
ALOGE("error: unable to get display state");
return;
}
err = SurfaceComposerClient::getActiveDisplayMode(display, &mode);
if(err != NO_ERROR){
ALOGE("error: unable to get display mode");
return;
}
char value[PROPERTY_VALUE_MAX];
if((state.orientation == (android::ui::Rotation)DISPLAY_ORIENTATION_90) || (state.orientation == (android::ui::Rotation)DISPLAY_ORIENTATION_270)){
width = mode.resolution.getWidth();
height = mode.resolution.getHeight();
orientation = (int)state.orientation;
}else{
property_get("ro.sf.fakerotation", value, "false");
if (strcmp(value,"true") == 0) {
property_get("ro.sf.hwrotation", value, "0");
if ((strcmp(value,"90") == 0) || (strcmp(value,"270") == 0)) {
width = mode.resolution.getWidth();
height = mode.resolution.getHeight();
orientation = (strcmp(value,"90") == 0)?DISPLAY_ORIENTATION_90:DISPLAY_ORIENTATION_270;
} else {
width = mode.resolution.getWidth();
height = mode.resolution.getHeight();
}
} else {
width = mode.resolution.getWidth();
height = mode.resolution.getHeight();
}
}
if(0 /*ISurfaceComposer::eDisplayIdMain*/ == displayId){
property_get("persist.sys.display.policy", value, "");
if (strcasecmp(value,"auto") == 0) {
property_get("sys.fb.cursize", value, "1280x720");
sscanf(value,"%dx%d",&width,&height);
}
}
mode.resolution.set(width,height);
state.orientation = (android::ui::Rotation)orientation;
}
Reference in New Issue View Git Blame Copy Permalink