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 #include "include/gpu/GrTypes.h" 21 #include "pixel_map_gl_context.h" 22 23 namespace OHOS { 24 namespace Media { 25 namespace PixelMapGlShader { 26 class PixelMap; 27 enum ShaderType { 28 SHADER_INVALID = -1, 29 SHADER_VERTEX, 30 SHADER_ROTATE, 31 SHADER_SLR, 32 SHADER_LAP, 33 SHADER_MAX, 34 }; 35 36 class Shader { 37 public: 38 Shader(); 39 virtual ~Shader(); 40 Build()41 virtual bool Build() { return false; } LoadProgram()42 virtual bool LoadProgram() { return false; } SetParams(GPUTransformData transformData)43 virtual bool SetParams(GPUTransformData transformData) 44 { 45 transformData_ = transformData; 46 targetSize_ = transformData_.targetInfo_.size; 47 sourceSize_ = transformData_.sourceInfo_.size; 48 return true; 49 } Use()50 virtual bool Use() { return false; } 51 virtual bool Clear() = 0; GetReadTexId()52 GLuint &GetReadTexId() 53 { 54 return readTexId_; 55 } SetReadTexId(GLuint readTexId)56 void SetReadTexId(GLuint readTexId) 57 { 58 readTexId_ = readTexId; 59 } GetWriteTexId()60 GLuint &GetWriteTexId() 61 { 62 return writeTexId_; 63 } SetWriteTexId(GLuint writeTexId)64 void SetWriteTexId(GLuint writeTexId) 65 { 66 writeTexId_ = writeTexId; 67 } GetWriteFbo()68 GLuint &GetWriteFbo() 69 { 70 return writeFbo_; 71 } 72 bool BuildWriteTexture(); GetShaderType()73 ShaderType GetShaderType() 74 { 75 return type_; 76 } 77 78 protected: 79 GLuint loadShader(GLenum type, const char *shaderSrc); 80 bool buildFromSource(); 81 bool buildFromBinary(unsigned char*& shaderBinary, GLenum &binaryFormat, GLuint &binarySize); 82 83 ShaderType type_ = SHADER_INVALID; 84 GLuint programId_ = 0U; 85 GLuint vShader_ = 0U; 86 GLuint fShader_ = 0U; 87 GLuint readTexId_ = 0U; 88 GLuint writeFbo_ = 0U; 89 GLuint writeTexId_ = 0U; 90 EGLImageKHR eglImage_ = EGL_NO_IMAGE_KHR; 91 Size targetSize_; 92 Size sourceSize_; 93 GPUTransformData transformData_; 94 }; 95 96 class VertexShader : public Shader { 97 public: 98 VertexShader(); 99 ~VertexShader(); 100 101 bool Build() override; 102 bool LoadProgram() override; 103 bool Clear() override; 104 private: 105 GLuint vbo_ = 0U; 106 }; 107 108 class RotateShader : public Shader { 109 public: 110 RotateShader(); 111 ~RotateShader() override; 112 113 bool Build() override; 114 bool Use() override; 115 bool Clear() override; 116 bool LoadProgram() override; SetParams(GPUTransformData transformData)117 bool SetParams(GPUTransformData transformData) override 118 { 119 rotateDegreeZ_ = transformData.rotateDegreeZ; 120 rotateTrans_ = transformData.rotateTrans; 121 return Shader::SetParams(transformData); 122 } 123 124 private: 125 static unsigned char *shaderBinary_; 126 static GLenum binaryFormat_; 127 static GLuint binarySize_; 128 GLuint transformLoc_ = 0U; 129 GLuint texClipRatioLoc_ = 0U; 130 GLuint useNativeLoc_ = 0U; 131 float rotateDegreeZ_; 132 GlCommon::Mat4 rotateTrans_ = GlCommon::Mat4(1.0f); 133 }; 134 135 class SLRShader : public Shader { 136 public: 137 SLRShader(); 138 ~SLRShader() override; 139 140 bool Build() override; 141 bool LoadProgram() override; 142 bool SetParams(GPUTransformData transformData) override; 143 bool Use() override; 144 bool Clear() override; SetEglImage(EGLImageKHR eglImage)145 void SetEglImage(EGLImageKHR eglImage) 146 { 147 eglImage_ = eglImage; 148 } 149 150 private: 151 static unsigned char *shaderBinary_; 152 static GLenum binaryFormat_; 153 static GLuint binarySize_; 154 GLuint utexture_ = 0U; 155 GLuint utexturew_ = 0U; 156 GLuint utextureh_ = 0U; 157 GLuint slrA_ = 0U; 158 GLuint slrAMax_ = 0U; 159 GLuint slrCoeff_ = 0U; 160 GLuint slrCoeffTao_ = 0U; 161 GLuint texture_[2] = {0U, 0U}; 162 EGLImageKHR eglImage_ = EGL_NO_IMAGE; 163 }; 164 165 class LapShader : public Shader { 166 public: 167 LapShader(); 168 ~LapShader() override; 169 170 bool Build() override; 171 bool LoadProgram() override; 172 bool SetParams(GPUTransformData transformData) override; 173 bool Use() override; 174 bool Clear() override; 175 176 private: 177 static unsigned char *shaderBinary_; 178 static GLenum binaryFormat_; 179 static GLuint binarySize_; 180 GLuint utexture_ = 0U; 181 GLuint alpha_ = 0U; 182 float param_ = 0.15; 183 }; 184 185 class ShaderFactory { 186 public: GetInstance()187 static ShaderFactory &GetInstance() noexcept 188 { 189 static ShaderFactory instance; 190 return instance; 191 } Get(ShaderType type)192 std::shared_ptr<PixelMapGlShader::Shader> Get(ShaderType type) 193 { 194 std::shared_ptr<PixelMapGlShader::Shader> shader {nullptr}; 195 switch (type) { 196 case SHADER_VERTEX: { 197 shader = std::make_shared<PixelMapGlShader::VertexShader>(); 198 break; 199 } 200 case SHADER_ROTATE: { 201 shader = std::make_shared<PixelMapGlShader::RotateShader>(); 202 break; 203 } 204 case SHADER_SLR: { 205 shader = std::make_shared<PixelMapGlShader::SLRShader>(); 206 break; 207 } 208 case SHADER_LAP: { 209 shader = std::make_shared<PixelMapGlShader::LapShader>(); 210 break; 211 } 212 default: { 213 break; 214 } 215 } 216 return shader; 217 } 218 }; 219 220 } 221 } // namespace Media 222 } // namespace OHOS 223 #endif // FRAMEWORKS_INNERKITSIMPL_EGL_IMAGE_INCLUDE_PIXEL_MAP_GL_SHADER_H 224