1 /* 2 * Copyright (C) 2024 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 RENDER_ENVIRONMENT_H 17 #define RENDER_ENVIRONMENT_H 18 19 #include <external_window.h> 20 #include <GLES3/gl3.h> 21 22 #include "any.h" 23 #include "error_code.h" 24 25 #include "base/render_base.h" 26 #include "core/render_opengl_renderer.h" 27 #include "core/render_default_data.h" 28 #include "core/render_mesh.h" 29 #include "core/render_resource_cache.h" 30 #include "core/render_viewport.h" 31 #include "graphic/render_frame_buffer.h" 32 #include "graphic/render_general_program.h" 33 #include "effect_buffer.h" 34 #include "image_effect_marco_define.h" 35 36 namespace OHOS { 37 namespace Media { 38 namespace Effect { 39 class RenderParam { 40 public: 41 RenderContext *context_ = nullptr; 42 RenderOpenglRenderer *renderer_ = nullptr; 43 RenderMesh *meshBase_ = nullptr; 44 RenderMesh *meshBaseFlip_ = nullptr; 45 RenderMesh *meshBaseDMA_ = nullptr; 46 RenderMesh *meshBaseFlipYUVDMA_ = nullptr; 47 RenderMesh *meshBaseYUVDMA_ = nullptr; 48 RenderMesh *meshBaseDrawFrame_ = nullptr; 49 RenderMesh *meshBaseDrawFrameYUV_ = nullptr; 50 RenderGeneralProgram *shaderBase_ = nullptr; 51 RenderGeneralProgram *shaderBaseDMA_ = nullptr; 52 RenderGeneralProgram *shaderBaseYUVDMA_ = nullptr; 53 RenderGeneralProgram *shaderBaseYUVDMA2RGB2D_ = nullptr; 54 RenderGeneralProgram *shaderBaseRGB2D2YUVDMA_ = nullptr; 55 RenderGeneralProgram *shaderBaseDrawFrame_ = nullptr; 56 RenderGeneralProgram *shaderBaseDrawFrameYUV_ = nullptr; 57 ResourceCache *resCache_ = nullptr; 58 RenderViewport viewport_; 59 bool threadReady_ = false; 60 RenderParam()61 RenderParam() 62 { 63 resCache_ = new ResourceCache; 64 } 65 ~RenderParam()66 ~RenderParam() 67 { 68 if (renderer_) { 69 delete renderer_; 70 renderer_ = nullptr; 71 } 72 if (meshBase_) { 73 delete meshBase_; 74 meshBase_ = nullptr; 75 } 76 if (meshBaseFlip_) { 77 delete meshBaseFlip_; 78 meshBaseFlip_ = nullptr; 79 } 80 if (meshBaseDMA_) { 81 delete meshBaseDMA_; 82 meshBaseDMA_ = nullptr; 83 } 84 if (meshBaseFlipYUVDMA_) { 85 delete meshBaseFlipYUVDMA_; 86 meshBaseFlipYUVDMA_ = nullptr; 87 } 88 if (meshBaseYUVDMA_) { 89 delete meshBaseYUVDMA_; 90 meshBaseYUVDMA_ = nullptr; 91 } 92 if (meshBaseDrawFrame_) { 93 delete meshBaseDrawFrame_; 94 meshBaseDrawFrame_ = nullptr; 95 } 96 if (meshBaseDrawFrameYUV_) { 97 delete meshBaseDrawFrameYUV_; 98 meshBaseDrawFrameYUV_ = nullptr; 99 } 100 101 ReleaseShaderBase(); 102 103 if (resCache_) { 104 delete resCache_; 105 resCache_ = nullptr; 106 } 107 108 if (context_) { 109 context_->ReleaseCurrent(); 110 context_->Release(); 111 delete context_; 112 context_ = nullptr; 113 } 114 } 115 private: ReleaseShaderBase()116 void ReleaseShaderBase() 117 { 118 if (shaderBase_) { 119 shaderBase_->Release(); 120 delete shaderBase_; 121 shaderBase_ = nullptr; 122 } 123 if (shaderBaseDMA_) { 124 shaderBaseDMA_->Release(); 125 delete shaderBaseDMA_; 126 shaderBaseDMA_ = nullptr; 127 } 128 if (shaderBaseYUVDMA_) { 129 shaderBaseYUVDMA_->Release(); 130 delete shaderBaseYUVDMA_; 131 shaderBaseYUVDMA_ = nullptr; 132 } 133 if (shaderBaseYUVDMA2RGB2D_) { 134 shaderBaseYUVDMA2RGB2D_->Release(); 135 delete shaderBaseYUVDMA2RGB2D_; 136 shaderBaseYUVDMA2RGB2D_ = nullptr; 137 } 138 if (shaderBaseRGB2D2YUVDMA_) { 139 shaderBaseRGB2D2YUVDMA_->Release(); 140 delete shaderBaseRGB2D2YUVDMA_; 141 shaderBaseRGB2D2YUVDMA_ = nullptr; 142 } 143 if (shaderBaseDrawFrame_) { 144 shaderBaseDrawFrame_->Release(); 145 delete shaderBaseDrawFrame_; 146 shaderBaseDrawFrame_ = nullptr; 147 } 148 if (shaderBaseDrawFrameYUV_) { 149 shaderBaseDrawFrameYUV_->Release(); 150 delete shaderBaseDrawFrameYUV_; 151 shaderBaseDrawFrameYUV_ = nullptr; 152 } 153 } 154 }; 155 enum EGLStatus {READY, UNREADY}; 156 class RenderEnvironment { 157 public: 158 IMAGE_EFFECT_EXPORT RenderEnvironment() = default; 159 IMAGE_EFFECT_EXPORT ~RenderEnvironment() = default; 160 IMAGE_EFFECT_EXPORT void Init(bool isCustomEnv = false); 161 IMAGE_EFFECT_EXPORT void Prepare(); 162 void InitEngine(OHNativeWindow *window); 163 void NotifyInputChanged(); 164 IMAGE_EFFECT_EXPORT bool IfNeedGenMainTex() const; 165 RenderTexturePtr ReCreateTexture(RenderTexturePtr renderTex, int width, int height, bool isHdr10) const; 166 IMAGE_EFFECT_EXPORT std::unordered_map<std::string, RenderTexturePtr> GenHdr8GainMapTexs( 167 const std::shared_ptr<EffectBuffer> &source); 168 IMAGE_EFFECT_EXPORT RenderTexturePtr GenMainTex(const std::shared_ptr<EffectBuffer> &source, bool isHdr10 = false); 169 170 IMAGE_EFFECT_EXPORT void GenTex(const std::shared_ptr<EffectBuffer> &source, 171 std::shared_ptr<EffectBuffer> &output); 172 IMAGE_EFFECT_EXPORT std::shared_ptr<EffectBuffer> ConvertBufferToTexture(EffectBuffer *source); 173 IMAGE_EFFECT_EXPORT void ConvertTextureToBuffer(RenderTexturePtr source, EffectBuffer *output, 174 bool needProcessCache = false); 175 IMAGE_EFFECT_EXPORT RenderContext* GetContext(); 176 IMAGE_EFFECT_EXPORT ResourceCache* GetResourceCache(); 177 IMAGE_EFFECT_EXPORT bool BeginFrame(); 178 179 IMAGE_EFFECT_EXPORT void DrawFrameWithTransform(const std::shared_ptr<EffectBuffer> &buffer, 180 GraphicTransformType type); 181 IMAGE_EFFECT_EXPORT void DrawFrame(GLuint texId, GraphicTransformType type); 182 IMAGE_EFFECT_EXPORT void ConvertYUV2RGBA(std::shared_ptr<EffectBuffer> &source, std::shared_ptr<EffectBuffer> &out); 183 void ConvertRGBA2YUV(std::shared_ptr<EffectBuffer> &source, std::shared_ptr<EffectBuffer> &out); 184 void Draw2D2OES(RenderTexturePtr source, RenderTexturePtr output); 185 void UpdateCanvas(); 186 IMAGE_EFFECT_EXPORT EGLStatus GetEGLStatus() const; 187 IMAGE_EFFECT_EXPORT RenderTexturePtr RequestBuffer(int width, int height, GLenum format = GL_RGBA8); 188 bool IsPrepared() const; 189 IMAGE_EFFECT_EXPORT DataType GetOutputType() const; 190 void SetOutputType(DataType type); 191 void ReadPixelsFromTex(RenderTexturePtr tex, void *data, int width, int height, int stride); 192 void DrawBufferToTexture(RenderTexturePtr renderTex, const EffectBuffer *source); 193 IMAGE_EFFECT_EXPORT GLuint GenTextureWithPixels(void *data, int width, int height, int stride, 194 IEffectFormat format = IEffectFormat::RGBA8888); 195 IMAGE_EFFECT_EXPORT void DrawFlipSurfaceBufferFromTex(RenderTexturePtr tex, 196 SurfaceBuffer *buffer, IEffectFormat format); 197 IMAGE_EFFECT_EXPORT void DrawOesTexture2DFromTexture(RenderTexturePtr inputTex, GLuint outputTex, int32_t width, 198 int32_t height, IEffectFormat format); 199 IMAGE_EFFECT_EXPORT void DrawSurfaceBufferFromSurfaceBuffer(SurfaceBuffer *inBuffer, SurfaceBuffer *outBuffer, 200 IEffectFormat format) const; 201 IMAGE_EFFECT_EXPORT void DrawSurfaceBufferFromTex(RenderTexturePtr tex, 202 SurfaceBuffer *buffer, IEffectFormat format); 203 IMAGE_EFFECT_EXPORT bool GetOrCreateTextureFromCache(RenderTexturePtr &renderTex, const std::string &texName, 204 int width, int height, bool isHdr10) const; 205 IMAGE_EFFECT_EXPORT void DrawTexFromSurfaceBuffer(RenderTexturePtr tex, SurfaceBuffer *buffer, 206 IEffectFormat format = IEffectFormat::RGBA8888); 207 IMAGE_EFFECT_EXPORT void DrawFlipTex(RenderTexturePtr input, RenderTexturePtr output); 208 IMAGE_EFFECT_EXPORT void DrawTex(RenderTexturePtr input, RenderTexturePtr output); 209 static std::shared_ptr<EffectBuffer> GenTexEffectBuffer(const std::shared_ptr<EffectBuffer>& input); 210 IMAGE_EFFECT_EXPORT GLuint ConvertFromYUVToRGB(const EffectBuffer *source, IEffectFormat format); 211 IMAGE_EFFECT_EXPORT void ConvertFromRGBToYUV(RenderTexturePtr input, IEffectFormat format, void *data); 212 IMAGE_EFFECT_EXPORT void ReleaseParam(); 213 IMAGE_EFFECT_EXPORT void Release(); 214 void SetNativeWindowColorSpace(EffectColorSpace colorSpace); 215 216 private: 217 RenderParam *param_{ nullptr }; 218 RenderAttribute attribute_; 219 RenderSurface *screenSurface_{ nullptr }; 220 OHNativeWindow *window_{ nullptr }; 221 bool hasInputChanged = true; 222 int canvasWidth = 0; 223 int canvasHeight = 0; 224 EGLStatus isEGLReady = EGLStatus::UNREADY; 225 DataType outType_ = DataType::UNKNOWN; 226 bool isCustomEnv_ = false; 227 bool needTerminate_ = false; 228 void InitDefaultMeshMT(RenderParam *param); 229 void InitDefaultShaderMT(RenderParam *param); 230 RenderMesh *CreateMeshMT(RenderParam *param, bool isBackGround, RenderGeneralProgram *shader); 231 }; 232 } // namespace Effect 233 } // namespace Media 234 } // namespace OHOS 235 236 #endif