1 /* 2 * Copyright (C) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef FRAMEWORKS_INNERKITSIMPL_EGL_IMAGE_INCLUDE_PIXEL_MAP_GL_SHADER_H 17 #define FRAMEWORKS_INNERKITSIMPL_EGL_IMAGE_INCLUDE_PIXEL_MAP_GL_SHADER_H 18 19 #include <iostream> 20 #ifdef USE_M133_SKIA 21 #include "include/gpu/ganesh/GrTypes.h" 22 #else 23 #include "include/gpu/GrTypes.h" 24 #endif 25 #include "pixel_map_gl_context.h" 26 27 namespace OHOS { 28 namespace Media { 29 namespace PixelMapGlShader { 30 class PixelMap; 31 enum ShaderType { 32 SHADER_INVALID = -1, 33 SHADER_VERTEX, 34 SHADER_ROTATE, 35 SHADER_SLR, 36 SHADER_LAP, 37 SHADER_MAX, 38 }; 39 40 class Shader { 41 public: 42 Shader(); 43 virtual ~Shader(); 44 Build()45 virtual bool Build() { return false; } LoadProgram()46 virtual bool LoadProgram() { return false; } SetParams(GPUTransformData transformData)47 virtual bool SetParams(GPUTransformData transformData) 48 { 49 transformData_ = transformData; 50 targetSize_ = transformData_.targetInfo_.size; 51 sourceSize_ = transformData_.sourceInfo_.size; 52 return true; 53 } Use()54 virtual bool Use() { return false; } 55 virtual bool Clear() = 0; GetReadTexId()56 GLuint &GetReadTexId() 57 { 58 return readTexId_; 59 } SetReadTexId(GLuint readTexId)60 void SetReadTexId(GLuint readTexId) 61 { 62 readTexId_ = readTexId; 63 } GetWriteTexId()64 GLuint &GetWriteTexId() 65 { 66 return writeTexId_; 67 } SetWriteTexId(GLuint writeTexId)68 void SetWriteTexId(GLuint writeTexId) 69 { 70 writeTexId_ = writeTexId; 71 } GetWriteFbo()72 GLuint &GetWriteFbo() 73 { 74 return writeFbo_; 75 } 76 bool BuildWriteTexture(); GetShaderType()77 ShaderType GetShaderType() 78 { 79 return type_; 80 } 81 82 protected: 83 GLuint loadShader(GLenum type, const char *shaderSrc); 84 bool buildFromSource(); 85 bool buildFromBinary(unsigned char*& shaderBinary, GLenum &binaryFormat, GLuint &binarySize); 86 87 ShaderType type_ = SHADER_INVALID; 88 GLuint programId_ = 0U; 89 GLuint vShader_ = 0U; 90 GLuint fShader_ = 0U; 91 GLuint readTexId_ = 0U; 92 GLuint writeFbo_ = 0U; 93 GLuint writeTexId_ = 0U; 94 EGLImageKHR eglImage_ = EGL_NO_IMAGE_KHR; 95 Size targetSize_; 96 Size sourceSize_; 97 GPUTransformData transformData_; 98 }; 99 100 class VertexShader : public Shader { 101 public: 102 VertexShader(); 103 ~VertexShader(); 104 105 bool Build() override; 106 bool LoadProgram() override; 107 bool Clear() override; 108 private: 109 GLuint vbo_ = 0U; 110 }; 111 112 class RotateShader : public Shader { 113 public: 114 RotateShader(); 115 ~RotateShader() override; 116 117 bool Build() override; 118 bool Use() override; 119 bool Clear() override; 120 bool LoadProgram() override; SetParams(GPUTransformData transformData)121 bool SetParams(GPUTransformData transformData) override 122 { 123 rotateDegreeZ_ = transformData.rotateDegreeZ; 124 rotateTrans_ = transformData.rotateTrans; 125 return Shader::SetParams(transformData); 126 } 127 128 private: 129 static unsigned char *shaderBinary_; 130 static GLenum binaryFormat_; 131 static GLuint binarySize_; 132 GLint transformLoc_ = 0; 133 GLint texClipRatioLoc_ = 0; 134 GLint useNativeLoc_ = 0; 135 float rotateDegreeZ_ = 0.0f; 136 GlCommon::Mat4 rotateTrans_ = GlCommon::Mat4(1.0f); 137 }; 138 139 class SLRShader : public Shader { 140 public: 141 SLRShader(); 142 ~SLRShader() override; 143 144 bool Build() override; 145 bool LoadProgram() override; 146 bool SetParams(GPUTransformData transformData) override; 147 bool Use() override; 148 bool Clear() override; SetEglImage(EGLImageKHR eglImage)149 void SetEglImage(EGLImageKHR eglImage) 150 { 151 eglImage_ = eglImage; 152 } 153 154 private: 155 static unsigned char *shaderBinary_; 156 static GLenum binaryFormat_; 157 static GLuint binarySize_; 158 GLint utexture_ = 0; 159 GLint utexturew_ = 0; 160 GLint utextureh_ = 0; 161 GLint slrA_ = 0; 162 GLint slrAMax_ = 0; 163 GLint slrCoeff_ = 0; 164 GLint slrCoeffTao_ = 0; 165 GLuint texture_[2] = {0U, 0U}; 166 EGLImageKHR eglImage_ = EGL_NO_IMAGE; 167 }; 168 169 class LapShader : public Shader { 170 public: 171 LapShader(); 172 ~LapShader() override; 173 174 bool Build() override; 175 bool LoadProgram() override; 176 bool SetParams(GPUTransformData transformData) override; 177 bool Use() override; 178 bool Clear() override; 179 180 private: 181 static unsigned char *shaderBinary_; 182 static GLenum binaryFormat_; 183 static GLuint binarySize_; 184 GLint utexture_ = 0; 185 GLint alpha_ = 0; 186 float param_ = 0.15; 187 }; 188 189 class ShaderFactory { 190 public: GetInstance()191 static ShaderFactory &GetInstance() noexcept 192 { 193 static ShaderFactory instance; 194 return instance; 195 } Get(ShaderType type)196 std::shared_ptr<PixelMapGlShader::Shader> Get(ShaderType type) 197 { 198 std::shared_ptr<PixelMapGlShader::Shader> shader {nullptr}; 199 switch (type) { 200 case SHADER_VERTEX: { 201 shader = std::make_shared<PixelMapGlShader::VertexShader>(); 202 break; 203 } 204 case SHADER_ROTATE: { 205 shader = std::make_shared<PixelMapGlShader::RotateShader>(); 206 break; 207 } 208 case SHADER_SLR: { 209 shader = std::make_shared<PixelMapGlShader::SLRShader>(); 210 break; 211 } 212 case SHADER_LAP: { 213 shader = std::make_shared<PixelMapGlShader::LapShader>(); 214 break; 215 } 216 default: { 217 break; 218 } 219 } 220 return shader; 221 } 222 }; 223 224 } 225 } // namespace Media 226 } // namespace OHOS 227 #endif // FRAMEWORKS_INNERKITSIMPL_EGL_IMAGE_INCLUDE_PIXEL_MAP_GL_SHADER_H 228