floraachy
/
ImageKnife
mirror of https://gitee.com/openharmony-tpc/ImageKnife.git
1
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

updae code of codecheck 

Signed-off-by: tyBrave <tianyong13@huawei.com>
This commit is contained in:
tyBrave 2023-02-03 10:48:56 +08:00
parent 91f022516f
commit 57d773e582
5 changed files with 185 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
gpu_transform/src/main/cpp/constant/constant_shape.h
View File

@ -22,6 +22,41 @@
#ifndef GPU_ImageETS_constant_shape_H #ifndef GPU_ImageETS_constant_shape_H
#define GPU_ImageETS_constant_shape_H #define GPU_ImageETS_constant_shape_H
const int UNIFORM_TYPE_2FV_SIZE = 10;
const int UNIFORM_TYPE_FV = 1;
const int UNIFORM_TYPE_2FV = 2;
const int UNIFORM_TYPE_3FV = 3;
const int UNIFORM_TYPE_4FV = 4;
const int UNIFORM_TYPE_2F = 21;
const int DEFAULT_ZERO = 0;
const int DEFAULT_ONE = 1;
const int DEFAULT_TWO = 2;
const int DEFAULT_THREE = 3;
const int DEFAULT_FOUR = 4;
const float DEFAULT_ONE_HALF = 1.5;
const int UNIFORM_TYPE_ZERO = 0;
const int UNIFORM_TYPE_ONE = 1;
const int UNIFORM_TYPE_THREE = 3;
const int UNIFORM_TYPE_FOUR = 4;
const int SHADER_TYPE_BRIGHT = 0;
const int SHADER_TYPE_CONTRAST = 1;
const int SHADER_TYPE_INVERT = 2;
const int SHADER_TYPE_KUWAHARA = 4;
const int SHADER_TYPE_PIXELATION = 3;
const int SHADER_TYPE_SKETCH = 6;
const int SHADER_TYPE_SWIRL = 7;
const int SHADER_TYPE_TOON = 8;
const int SHADER_TYPE_VIGNETTE = 9;
const int SHADER_TYPE_SEPIA = 5;
const int SHADER_TYPE_GRAYSCALE = 10;
const int SHADER_TYPE_BLUR = 12;
const char vShaderStr[] = const char vShaderStr[] =
"#version 300 es \n" "#version 300 es \n"
"layout(location = 0) in vec4 a_position; \n" "layout(location = 0) in vec4 a_position; \n"

176
gpu_transform/src/main/cpp/render/EGLRender.cpp
View File

@ -36,10 +36,10 @@
#include "../util/NapiUtil.h" #include "../util/NapiUtil.h"
#define PARAM_TYPE_SHADER_INDEX 300 const int PARAM_TYPE_SHADER_INDEX = 300;
#define VERTEX_POS_LOC 0 const int VERTEX_POS_LOC = 0;
#define TEXTURE_POS_LOC 1 const int TEXTURE_POS_LOC = 1;
const int32_t STR_DEFAULT_SIZE = 1024; const int32_t STR_DEFAULT_SIZE = 1024;
EGLRender *EGLRender::sInstance = nullptr; EGLRender *EGLRender::sInstance = nullptr;
@ -162,14 +162,14 @@ napi_value EGLRender::GetPixelMapOfSurface(napi_env env, napi_callback_info info
return nullptr; return nullptr;
} }
uint8_t* pixels = (uint8_t*) malloc(surfaceWidth * surfaceHeight * 4); uint8_t* pixels = (uint8_t*) malloc(surfaceWidth * surfaceHeight * DEFAULT_FOUR);
glPixelStorei(GL_PACK_ALIGNMENT, 1); glPixelStorei(GL_PACK_ALIGNMENT, 1);
glReadPixels(x, y, surfaceWidth, surfaceHeight, GL_RGBA, GL_UNSIGNED_BYTE, pixels); glReadPixels(x, y, surfaceWidth, surfaceHeight, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
NativeImageUtil::flip(&pixels, surfaceWidth, surfaceHeight); NativeImageUtil::flip(&pixels, surfaceWidth, surfaceHeight);
napi_value array; napi_value array;
int byte_length = surfaceWidth * surfaceHeight * 4; int byte_length = surfaceWidth * surfaceHeight * DEFAULT_FOUR;
if (!NativeImageUtil::CreateArrayBuffer(env, pixels, byte_length, &array)) { if (!NativeImageUtil::CreateArrayBuffer(env, pixels, byte_length, &array)) {
LOGI("gl--> GetPixelMapOfSurface error"); LOGI("gl--> GetPixelMapOfSurface error");
} }
@ -217,12 +217,12 @@ napi_value EGLRender::setTypeArrayOfFloat(napi_env env, napi_callback_info info)
napi_get_cb_info(env, info, &argc, args, nullptr, nullptr); napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
std::string locationContent; std::string locationContent;
NapiUtil::JsValueToString(env, args[0], 1024, locationContent); NapiUtil::JsValueToString(env, args[0], STR_DEFAULT_SIZE, locationContent);
char* location = (char*)locationContent.c_str(); char* location = (char*)locationContent.c_str();
std::string content; std::string content;
NapiUtil::JsValueToString(env, args[1], 1024, content); NapiUtil::JsValueToString(env, args[1], STR_DEFAULT_SIZE, content);
char* key = (char*)content.c_str(); char* key = (char*)content.c_str();
@ -240,15 +240,15 @@ napi_value EGLRender::setTypeArrayOfFloat(napi_env env, napi_callback_info info)
int uniformType; int uniformType;
if (strcmp(key, "glUniform2fv") == 0) { if (strcmp(key, "glUniform2fv") == 0) {
uniformType = 2; uniformType = UNIFORM_TYPE_2FV;
}else if (strcmp(key, "glUniform3fv") == 0) { }else if (strcmp(key, "glUniform3fv") == 0) {
uniformType = 3; uniformType = UNIFORM_TYPE_3FV;
}else if (strcmp(key, "glUniform4fv") == 0) { }else if (strcmp(key, "glUniform4fv") == 0) {
uniformType = 4; uniformType = UNIFORM_TYPE_4FV;
}else if (strcmp(key, "glUniform1fv") == 0) { }else if (strcmp(key, "glUniform1fv") == 0) {
uniformType = 1; uniformType = UNIFORM_TYPE_FV;
}else if (strcmp(key, "glUniform2f") == 0) { }else if (strcmp(key, "glUniform2f") == 0) {
uniformType = 21; uniformType = UNIFORM_TYPE_2F;
} }
EGLRender::GetInstance() -> GlUniformArray(location, value, uniformType); EGLRender::GetInstance() -> GlUniformArray(location, value, uniformType);
@ -261,7 +261,7 @@ napi_value EGLRender::setTypeArrayOfMatrix3f(napi_env env, napi_callback_info in
napi_get_cb_info(env, info, &argc, args, nullptr, nullptr); napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
std::string locationContent; std::string locationContent;
NapiUtil::JsValueToString(env, args[0], 1024, locationContent); NapiUtil::JsValueToString(env, args[0], STR_DEFAULT_SIZE, locationContent);
char* location = (char*)locationContent.c_str(); char* location = (char*)locationContent.c_str();
@ -276,7 +276,7 @@ napi_value EGLRender::setTypeArrayOfMatrix3f(napi_env env, napi_callback_info in
float* value = reinterpret_cast<float *>(buffer); float* value = reinterpret_cast<float *>(buffer);
EGLRender::GetInstance() -> GlUniformMatrix(location, value, 3); EGLRender::GetInstance() -> GlUniformMatrix(location, value, UNIFORM_TYPE_THREE);
return nullptr; return nullptr;
} }
@ -287,7 +287,7 @@ napi_value EGLRender::setTypeArrayOfMatrix4f(napi_env env, napi_callback_info in
napi_get_cb_info(env, info, &argc, args, nullptr, nullptr); napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
std::string locationContent; std::string locationContent;
NapiUtil::JsValueToString(env, args[0], 1024, locationContent); NapiUtil::JsValueToString(env, args[0], STR_DEFAULT_SIZE, locationContent);
char* location = (char*)locationContent.c_str(); char* location = (char*)locationContent.c_str();
@ -302,7 +302,7 @@ napi_value EGLRender::setTypeArrayOfMatrix4f(napi_env env, napi_callback_info in
float* value = reinterpret_cast<float *>(buffer); float* value = reinterpret_cast<float *>(buffer);
EGLRender::GetInstance() -> GlUniformMatrix(location, value, 4); EGLRender::GetInstance() -> GlUniformMatrix(location, value, UNIFORM_TYPE_FOUR);
return nullptr; return nullptr;
} }
@ -313,13 +313,13 @@ napi_value EGLRender::RenderGlUniform1i(napi_env env, napi_callback_info info) {
napi_get_cb_info(env, info, &argc, args, nullptr, nullptr); napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
std::string content; std::string content;
NapiUtil::JsValueToString(env, args[0], 1024, content); NapiUtil::JsValueToString(env, args[0], STR_DEFAULT_SIZE, content);
uint32_t value; uint32_t value;
napi_status status = napi_get_value_uint32(env, args[1], &value); napi_status status = napi_get_value_uint32(env, args[1], &value);
if (status != napi_ok) { if (status != napi_ok) {
return nullptr; return nullptr;
} }
EGLRender::GetInstance() -> GlUniform((char*)content.c_str(), value, 0); EGLRender::GetInstance() -> GlUniform((char*)content.c_str(), value, UNIFORM_TYPE_ZERO);
return nullptr; return nullptr;
} }
@ -330,13 +330,13 @@ napi_value EGLRender::RenderGlUniform1f(napi_env env, napi_callback_info info) {
napi_get_cb_info(env, info, &argc, args, nullptr, nullptr); napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
std::string content; std::string content;
NapiUtil::JsValueToString(env, args[0], 1024, content); NapiUtil::JsValueToString(env, args[0], STR_DEFAULT_SIZE, content);
double value; double value;
napi_status status = napi_get_value_double(env, args[1], &value); napi_status status = napi_get_value_double(env, args[1], &value);
if (status != napi_ok) { if (status != napi_ok) {
return nullptr; return nullptr;
} }
EGLRender::GetInstance() -> GlUniform((char*)content.c_str(), value, 1); EGLRender::GetInstance() -> GlUniform((char*)content.c_str(), value, UNIFORM_TYPE_ONE);
return nullptr; return nullptr;
} }
@ -347,7 +347,7 @@ napi_value EGLRender::RenderGlUniform2fv(napi_env env, napi_callback_info info)
napi_get_cb_info(env, info, &argc, args, nullptr, nullptr); napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
std::string content; std::string content;
NapiUtil::JsValueToString(env, args[0], 1024, content); NapiUtil::JsValueToString(env, args[0], STR_DEFAULT_SIZE, content);
double value; double value;
napi_status status = napi_get_value_double(env, args[1], &value); napi_status status = napi_get_value_double(env, args[1], &value);
@ -363,7 +363,7 @@ napi_value EGLRender::RenderGlUniform2fv(napi_env env, napi_callback_info info)
float vce2[2]; float vce2[2];
vce2[0] = value; vce2[0] = value;
vce2[1] = value2; vce2[1] = value2;
EGLRender::GetInstance() -> GlUniformArray((char*)content.c_str(), vce2, 10); EGLRender::GetInstance() -> GlUniformArray((char*)content.c_str(), vce2, UNIFORM_TYPE_2FV_SIZE);
return nullptr; return nullptr;
} }
@ -418,33 +418,33 @@ void EGLRender::Init() {
} }
// Generate VBO Ids and load the VBOs width data // Generate VBO Ids and load the VBOs width data
glGenBuffers(3, m_VboIds); glGenBuffers(DEFAULT_THREE, m_VboIds);
glBindBuffer(GL_ARRAY_BUFFER, m_VboIds[0]); glBindBuffer(GL_ARRAY_BUFFER, m_VboIds[DEFAULT_ZERO]);
glBufferData(GL_ARRAY_BUFFER, sizeof(vVertices), vVertices, GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, sizeof(vVertices), vVertices, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, m_VboIds[1]); glBindBuffer(GL_ARRAY_BUFFER, m_VboIds[DEFAULT_ONE]);
glBufferData(GL_ARRAY_BUFFER, sizeof(vFboTexCoors), vTexCoors, GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, sizeof(vFboTexCoors), vTexCoors, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_VboIds[2]); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_VboIds[DEFAULT_TWO]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
// Generate VAO Ids // Generate VAO Ids
glGenVertexArrays(1, m_VaoIds); glGenVertexArrays(DEFAULT_ONE, m_VaoIds);
// FBO off screen rendering VAO // FBO off screen rendering VAO
glBindVertexArray(m_VaoIds[0]); glBindVertexArray(m_VaoIds[DEFAULT_ZERO]);
glBindBuffer(GL_ARRAY_BUFFER, m_VboIds[0]); glBindBuffer(GL_ARRAY_BUFFER, m_VboIds[DEFAULT_ZERO]);
glEnableVertexAttribArray(VERTEX_POS_LOC); glEnableVertexAttribArray(VERTEX_POS_LOC);
glVertexAttribPointer(VERTEX_POS_LOC, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (const void *)0); glVertexAttribPointer(VERTEX_POS_LOC, DEFAULT_THREE, GL_FLOAT, GL_FALSE, DEFAULT_THREE * sizeof(GLfloat), (const void *)DEFAULT_ZERO);
glBindBuffer(GL_ARRAY_BUFFER,GL_NONE); glBindBuffer(GL_ARRAY_BUFFER,GL_NONE);
glBindBuffer(GL_ARRAY_BUFFER, m_VboIds[1]); glBindBuffer(GL_ARRAY_BUFFER, m_VboIds[DEFAULT_ONE]);
glEnableVertexAttribArray(TEXTURE_POS_LOC); glEnableVertexAttribArray(TEXTURE_POS_LOC);
glVertexAttribPointer(TEXTURE_POS_LOC, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (const void *)0); glVertexAttribPointer(TEXTURE_POS_LOC, DEFAULT_TWO, GL_FLOAT, GL_FALSE, DEFAULT_TWO * sizeof(GLfloat), (const void *)DEFAULT_ZERO);
glBindBuffer(GL_ARRAY_BUFFER,GL_NONE); glBindBuffer(GL_ARRAY_BUFFER,GL_NONE);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_VboIds[2]); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_VboIds[DEFAULT_TWO]);
glBindVertexArray(GL_NONE); glBindVertexArray(GL_NONE);
} }
@ -514,6 +514,9 @@ int EGLRender::CreateGlEnv() {
case EGL_BAD_MATCH: case EGL_BAD_MATCH:
LOGI("gl-->::CreateGlesEnv Check window and EGLConfig attributes"); LOGI("gl-->::CreateGlesEnv Check window and EGLConfig attributes");
break; break;
default:
LOGI("gl-->::CreateGlesEnv happen default error");
break;
} }
} }
@ -559,7 +562,7 @@ void EGLRender::SetImageData(uint8_t *pData, int width, int height) {
m_RenderImage.height = height; m_RenderImage.height = height;
m_RenderImage.format = IMAGE_FORMAT_RGBA; m_RenderImage.format = IMAGE_FORMAT_RGBA;
NativeImageUtil::AllocNativeImage(&m_RenderImage); NativeImageUtil::AllocNativeImage(&m_RenderImage);
memcpy(m_RenderImage.ppPlane[0], pData, width * height *4); memcpy(m_RenderImage.ppPlane[0], pData, width * height * DEFAULT_FOUR);
glBindTexture(GL_TEXTURE_2D, m_ImageTextureId); glBindTexture(GL_TEXTURE_2D, m_ImageTextureId);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_RenderImage.width, m_RenderImage.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_RenderImage.ppPlane[0]); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_RenderImage.width, m_RenderImage.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_RenderImage.ppPlane[0]);
@ -601,68 +604,71 @@ void EGLRender::SetIntParams(int paramType, int param) {
const char* fShader[1]; const char* fShader[1];
switch(param) switch(param)
{ {
case 4: case SHADER_TYPE_KUWAHARA:
{ {
fShader[0] = fShaderStr3; fShader[0] = fShaderStr3;
break; break;
} }
case 7: case SHADER_TYPE_SWIRL:
{ {
fShader[0] = swirlFShaderStr; fShader[0] = swirlFShaderStr;
break; break;
} }
case 0: case SHADER_TYPE_BRIGHT:
{ {
fShader[0] = brightFShaderStr; fShader[0] = brightFShaderStr;
break; break;
} }
case 1: case SHADER_TYPE_CONTRAST:
{ {
fShader[0] = contrastFShaderStr; fShader[0] = contrastFShaderStr;
break; break;
} }
case 2: case SHADER_TYPE_INVERT:
{ {
fShader[0] = invertFShaderStr; fShader[0] = invertFShaderStr;
break; break;
} }
case 3: case SHADER_TYPE_PIXELATION:
{ {
fShader[0] = pixelFShaderStr; fShader[0] = pixelFShaderStr;
break; break;
} }
case 5: case SHADER_TYPE_SEPIA:
{ {
fShader[0] = colorMatrixFShaderStr; fShader[0] = colorMatrixFShaderStr;
break; break;
} }
case 6: case SHADER_TYPE_SKETCH:
{ {
fShader[0] = sketchShaderStr; fShader[0] = sketchShaderStr;
vShader[0] = v3x3ShaderStr; vShader[0] = v3x3ShaderStr;
break; break;
} }
case 8: case SHADER_TYPE_TOON:
{ {
fShader[0] = toonFShaderStr; fShader[0] = toonFShaderStr;
vShader[0] = v3x3ShaderStr; vShader[0] = v3x3ShaderStr;
break; break;
} }
case 9: case SHADER_TYPE_VIGNETTE:
{ {
fShader[0] = vignetteFShaderStr; fShader[0] = vignetteFShaderStr;
break; break;
} }
case 10: case SHADER_TYPE_GRAYSCALE:
{ {
fShader[0] = grayScaleShaderStr; fShader[0] = grayScaleShaderStr;
break; break;
} }
case 12: case SHADER_TYPE_BLUR:
{ {
fShader[0] = blurShaderStr; fShader[0] = blurShaderStr;
break; break;
} }
default:
vShader[0] = vShaderStr;
break;
} }
m_ProgramObj = GLUtils::CreateProgram(vShader[0], fShader[0], m_VertexShader, m_ProgramObj = GLUtils::CreateProgram(vShader[0], fShader[0], m_VertexShader,
@ -708,56 +714,62 @@ void EGLRender::UseProgram() {
} }
} }
void EGLRender::GlUniform(char* strLocation, float value, int unType) { void EGLRender::GlUniform(char* location, float value, int unType) {
GLint location = glGetUniformLocation(m_ProgramObj, strLocation); GLint ll = glGetUniformLocation(m_ProgramObj, location);
switch(unType) switch(unType)
{ {
case 0: case UNIFORM_TYPE_ZERO:
glUniform1i(location, (int)value); glUniform1i(ll, (int)value);
break; break;
case 1: case UNIFORM_TYPE_ONE:
glUniform1f(location, value); glUniform1f(ll, value);
break;
default:
break; break;
} }
} }
void EGLRender::GlUniformArray(char* strLocation, float* value, int unType) { void EGLRender::GlUniformArray(char* location, float* value, int unType) {
GLint location = glGetUniformLocation(m_ProgramObj, strLocation); GLint ll = glGetUniformLocation(m_ProgramObj, location);
switch(unType) switch(unType)
{ {
case 10: case UNIFORM_TYPE_2FV_SIZE:
GLfloat vec2[2]; GLfloat vec2[2];
vec2[0] = value[0] * m_RenderImage.width; vec2[0] = value[0] * m_RenderImage.width;
vec2[1] = value[1] * m_RenderImage.height; vec2[1] = value[1] * m_RenderImage.height;
glUniform2fv(location, 1, vec2); glUniform2fv(ll, 1, vec2);
break; break;
case 21: case UNIFORM_TYPE_2F:
glUniform2f(location, value[0], value[1]); glUniform2f(ll, value[0], value[1]);
break; break;
case 1: case UNIFORM_TYPE_FV:
glUniform1fv(location, 1, value); glUniform1fv(ll, 1, value);
break; break;
case 2: case UNIFORM_TYPE_2FV:
glUniform2fv(location, 1, value); glUniform2fv(ll, 1, value);
break; break;
case 3: case UNIFORM_TYPE_3FV:
glUniform3fv(location, 1, value); glUniform3fv(ll, 1, value);
break; break;
case 4: case UNIFORM_TYPE_4FV:
glUniform4fv(location, 1, value); glUniform4fv(ll, 1, value);
break;
default:
break; break;
} }
} }
void EGLRender::GlUniformMatrix(char* strLocation, float* value, int unType) { void EGLRender::GlUniformMatrix(char* location, float* value, int unType) {
GLint location = glGetUniformLocation(m_ProgramObj, strLocation); GLint ll = glGetUniformLocation(m_ProgramObj, location);
switch(unType) switch(unType)
{ {
case 3: case UNIFORM_TYPE_THREE:
glUniformMatrix3fv(location, 1, false,value); glUniformMatrix3fv(ll, 1, false,value);
break; break;
case 4: case UNIFORM_TYPE_FOUR:
glUniformMatrix4fv(location, 1, false, value); glUniformMatrix4fv(ll, 1, false, value);
break;
default:
break; break;
} }
} }
@ -771,28 +783,28 @@ void EGLRender::UnInit() {
if(m_ImageTextureId) if(m_ImageTextureId)
{ {
glDeleteTextures(1, &m_ImageTextureId); glDeleteTextures(DEFAULT_ONE, &m_ImageTextureId);
m_ImageTextureId = GL_NONE; m_ImageTextureId = GL_NONE;
} }
if (m_FboTextureId) if (m_FboTextureId)
{ {
glDeleteTextures(1, &m_FboTextureId); glDeleteTextures(DEFAULT_ONE, &m_FboTextureId);
m_FboTextureId = GL_NONE; m_FboTextureId = GL_NONE;
} }
if (m_VboIds[0]) if (m_VboIds[DEFAULT_ZERO])
{ {
glDeleteBuffers(3, m_VboIds); glDeleteBuffers(DEFAULT_THREE, m_VboIds);
m_VboIds[0] = GL_NONE; m_VboIds[DEFAULT_ZERO] = GL_NONE;
m_VboIds[1] = GL_NONE; m_VboIds[DEFAULT_ONE] = GL_NONE;
m_VboIds[2] = GL_NONE; m_VboIds[DEFAULT_TWO] = GL_NONE;
} }
if (m_VaoIds[0]) if (m_VaoIds[DEFAULT_ZERO])
{ {
glDeleteVertexArrays(1, m_VaoIds); glDeleteVertexArrays(DEFAULT_ONE, m_VaoIds);
m_VaoIds[0] = GL_NONE; m_VaoIds[DEFAULT_ZERO] = GL_NONE;
} }
if (m_FboId) if (m_FboId)

2
gpu_transform/src/main/cpp/render/EGLRender.h
View File

@ -28,7 +28,7 @@
#include <stdint.h> #include <stdint.h>
#include "NativeImage.h" #include "NativeImage.h"
#define EGL_FEATURE_NUM 7 const int EGL_FEATURE_NUM = 7;
class EGLRender { class EGLRender {

79
gpu_transform/src/main/cpp/util/NativeImage.h
View File

@ -30,6 +30,7 @@
#include <unistd.h> #include <unistd.h>
#include "DebugLog.h" #include "DebugLog.h"
#include <string.h> #include <string.h>
#include "constant/constant_shape.h"
#define IMAGE_FORMAT_RGBA 0x01 #define IMAGE_FORMAT_RGBA 0x01
#define IMAGE_FORMAT_NV21 0x02 #define IMAGE_FORMAT_NV21 0x02
@ -55,16 +56,16 @@ struct NativeImage
int width; int width;
int height; int height;
int format; int format;
uint8_t *ppPlane[3]; uint8_t *ppPlane[DEFAULT_THREE];
NativeImage() NativeImage()
{ {
width = 0; width = DEFAULT_ZERO;
height = 0; height = DEFAULT_ZERO;
format = 0; format = DEFAULT_ZERO;
ppPlane[0] = nullptr; ppPlane[DEFAULT_ZERO] = nullptr;
ppPlane[1] = nullptr; ppPlane[DEFAULT_ONE] = nullptr;
ppPlane[2] = nullptr; ppPlane[DEFAULT_TWO] = nullptr;
} }
}; };
@ -73,49 +74,49 @@ class NativeImageUtil
public: public:
static void AllocNativeImage(NativeImage *pImage) static void AllocNativeImage(NativeImage *pImage)
{ {
if (pImage ->height ==0 || pImage ->width == 0) return; if (pImage ->height == DEFAULT_ZERO || pImage ->width == DEFAULT_ZERO) return;
switch(pImage -> format) switch(pImage -> format)
{ {
case IMAGE_FORMAT_RGBA: case IMAGE_FORMAT_RGBA:
{ {
pImage->ppPlane[0] = static_cast<uint8_t *>(malloc(pImage->width * pImage ->height * 4)); pImage->ppPlane[DEFAULT_ZERO] = static_cast<uint8_t *>(malloc(pImage->width * pImage ->height * DEFAULT_FOUR));
} }
break; break;
case IMAGE_FORMAT_YUYV: case IMAGE_FORMAT_YUYV:
{ {
pImage->ppPlane[0] = static_cast<uint8_t *>(malloc(pImage->width * pImage ->height * 2)); pImage->ppPlane[DEFAULT_ZERO] = static_cast<uint8_t *>(malloc(pImage->width * pImage ->height * DEFAULT_TWO));
} }
break; break;
case IMAGE_FORMAT_NV12: case IMAGE_FORMAT_NV12:
case IMAGE_FORMAT_NV21: case IMAGE_FORMAT_NV21:
{ {
pImage->ppPlane[0] = static_cast<uint8_t *>(malloc(pImage->width * pImage ->height * 1.5)); pImage->ppPlane[DEFAULT_ZERO] = static_cast<uint8_t *>(malloc(pImage->width * pImage ->height * DEFAULT_ONE_HALF));
pImage->ppPlane[1] = pImage->ppPlane[0] + pImage->width * pImage->height; pImage->ppPlane[DEFAULT_ONE] = pImage->ppPlane[DEFAULT_ZERO] + pImage->width * pImage->height;
} }
break; break;
case IMAGE_FORMAT_I420: case IMAGE_FORMAT_I420:
{ {
pImage->ppPlane[0] = static_cast<uint8_t *>(malloc(pImage->width * pImage ->height * 1.5)); pImage->ppPlane[DEFAULT_ZERO] = static_cast<uint8_t *>(malloc(pImage->width * pImage ->height * DEFAULT_ONE_HALF));
pImage->ppPlane[1] = pImage->ppPlane[0] + pImage->width * pImage->height; pImage->ppPlane[DEFAULT_ONE] = pImage->ppPlane[DEFAULT_ZERO] + pImage->width * pImage->height;
pImage->ppPlane[2] = pImage->ppPlane[1] + pImage->width * (pImage->height >> 2); pImage->ppPlane[DEFAULT_TWO] = pImage->ppPlane[DEFAULT_ONE] + pImage->width * (pImage->height >> DEFAULT_TWO);
} }
break; break;
case IMAGE_FORMAT_GRAY: case IMAGE_FORMAT_GRAY:
{ {
pImage->ppPlane[0] = static_cast<uint8_t *>(malloc(pImage->width * pImage ->height)); pImage->ppPlane[DEFAULT_ZERO] = static_cast<uint8_t *>(malloc(pImage->width * pImage ->height));
} }
break; break;
case IMAGE_FORMAT_I444: case IMAGE_FORMAT_I444:
{ {
pImage->ppPlane[0] = static_cast<uint8_t *>(malloc(pImage->width * pImage ->height * 3)); pImage->ppPlane[DEFAULT_ZERO] = static_cast<uint8_t *>(malloc(pImage->width * pImage ->height * DEFAULT_THREE));
} }
break; break;
case IMAGE_FORMAT_P010: case IMAGE_FORMAT_P010:
{ {
pImage->ppPlane[0] = static_cast<uint8_t *>(malloc(pImage->width * pImage ->height * 3)); pImage->ppPlane[DEFAULT_ZERO] = static_cast<uint8_t *>(malloc(pImage->width * pImage ->height * DEFAULT_THREE));
pImage->ppPlane[1] = pImage->ppPlane[0] + pImage->width * pImage->height * 2; pImage->ppPlane[DEFAULT_ONE] = pImage->ppPlane[DEFAULT_ZERO] + pImage->width * pImage->height * DEFAULT_TWO;
} }
break; break;
default: default:
break; break;
} }
@ -123,22 +124,20 @@ class NativeImageUtil
static void FreeNativeImage(NativeImage *pImage) static void FreeNativeImage(NativeImage *pImage)
{ {
if (pImage == nullptr || pImage->ppPlane[0] == nullptr) return; if (pImage == nullptr || pImage->ppPlane[DEFAULT_ZERO] == nullptr) return;
free(pImage->ppPlane[0]); free(pImage->ppPlane[DEFAULT_ZERO]);
pImage->ppPlane[0] = nullptr; pImage->ppPlane[DEFAULT_ZERO] = nullptr;
pImage->ppPlane[1] = nullptr; pImage->ppPlane[DEFAULT_ONE] = nullptr;
pImage->ppPlane[2] = nullptr; pImage->ppPlane[DEFAULT_TWO] = nullptr;
} }
static bool CreateArrayBuffer(napi_env env, void* src, size_t srcLen, napi_value *res) static bool CreateArrayBuffer(napi_env env, void* src, size_t srcLen, napi_value *res)
{ {
if (src == nullptr || srcLen == 0) if (src == nullptr || srcLen == DEFAULT_ZERO) {
{
return false; return false;
} }
void *nativePtr = nullptr; void *nativePtr = nullptr;
if (napi_create_arraybuffer(env, srcLen, &nativePtr, res) != napi_ok || nativePtr == nullptr) if (napi_create_arraybuffer(env, srcLen, &nativePtr, res) != napi_ok || nativePtr == nullptr) {
{
return false; return false;
} }
memcpy(nativePtr, src, srcLen); memcpy(nativePtr, src, srcLen);
@ -147,16 +146,16 @@ class NativeImageUtil
static void flip(uint8_t** buf, int width, int height) static void flip(uint8_t** buf, int width, int height)
{ {
int totalLength = width * height * 4; int totalLength = width * height * DEFAULT_FOUR;
int oneLineLength = width * 4; int oneLineLength = width * DEFAULT_FOUR;
uint8_t* tmp = (uint8_t*)malloc(totalLength); uint8_t* tmp = (uint8_t*)malloc(totalLength);
memcpy(tmp, *buf, totalLength); memcpy(tmp, *buf, totalLength);
memset(*buf, 0, sizeof(uint8_t)*totalLength); memset(*buf, DEFAULT_ZERO, sizeof(uint8_t)*totalLength);
for(int i = 0; i < height; i++) { for (int i = 0; i < height; i++) {
memcpy(*buf + oneLineLength * i, tmp + totalLength - oneLineLength * (i+1), oneLineLength); memcpy(*buf + oneLineLength * i, tmp + totalLength - oneLineLength * (i+1), oneLineLength);
} }
free(tmp); free(tmp);
} }
}; };
#endif //GPU_ImageETS_NativeImage_H #endif // GPU_ImageETS_NativeImage_H

32
package.json
View File

@ -1,19 +1,19 @@
{ {
"license": "ISC", "license":"ISC",
"devDependencies": {}, "devDependencies":{},
"name": "imageknife", "name":"imageknife",
"ohos": { "ohos":{
"org": "huawei", "org":"huawei",
"directoryLevel": "project", "directoryLevel":"project",
"buildTool": "hvigor" "buildTool":"hvigor"
}, },
"description": "example description", "description":"example description",
"repository": {}, "repository":{},
"version": "1.0.0", "version":"1.0.0",
"dependencies": { "dependencies":{
"@ohos/hypium": "1.0.3", "@ohos/hypium":"1.0.3",
"@ohos/hvigor-ohos-plugin": "1.3.1", "@ohos/hvigor-ohos-plugin":"1.3.1",
"hypium": "^1.0.0", "hypium":"^1.0.0",
"@ohos/hvigor": "1.3.1" "@ohos/hvigor":"1.3.1"
} }
} }