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();
161     IMAGE_EFFECT_EXPORT void Prepare();
162     void InitEngine(OHNativeWindow *window);
163     void NotifyInputChanged();
164     IMAGE_EFFECT_EXPORT bool IfNeedGenMainTex() const;
165     IMAGE_EFFECT_EXPORT void GenMainTex(const std::shared_ptr<EffectBuffer> &source,
166         std::shared_ptr<EffectBuffer> &output);
167     IMAGE_EFFECT_EXPORT std::shared_ptr<EffectBuffer> ConvertBufferToTexture(EffectBuffer *source);
168     IMAGE_EFFECT_EXPORT void ConvertTextureToBuffer(RenderTexturePtr source, EffectBuffer *output);
169     IMAGE_EFFECT_EXPORT RenderContext* GetContext();
170     IMAGE_EFFECT_EXPORT ResourceCache* GetResourceCache();
171     IMAGE_EFFECT_EXPORT bool BeginFrame();
172     IMAGE_EFFECT_EXPORT void DrawFrameWithTransform(const std::shared_ptr<EffectBuffer> &buffer,
173         GraphicTransformType type);
174     IMAGE_EFFECT_EXPORT void DrawFrame(GLuint texId, GraphicTransformType type);
175     IMAGE_EFFECT_EXPORT void ConvertYUV2RGBA(std::shared_ptr<EffectBuffer> &source, std::shared_ptr<EffectBuffer> &out);
176     IMAGE_EFFECT_EXPORT void ConvertRGBA2YUV(std::shared_ptr<EffectBuffer> &source, std::shared_ptr<EffectBuffer> &out);
177     IMAGE_EFFECT_EXPORT void Draw2D2OES(RenderTexturePtr source, RenderTexturePtr output);
178     IMAGE_EFFECT_EXPORT void UpdateCanvas();
179     EGLStatus GetEGLStatus() const;
180     IMAGE_EFFECT_EXPORT RenderTexturePtr RequestBuffer(int width, int height);
181     bool IsPrepared() const;
182     DataType GetOutputType() const;
183     void SetOutputType(DataType type);
184     void ReadPixelsFromTex(RenderTexturePtr tex, void *data, int width, int height, int stride);
185     IMAGE_EFFECT_EXPORT void DrawFlipSurfaceBufferFromTex(RenderTexturePtr tex,
186         SurfaceBuffer *buffer, IEffectFormat format);
187     IMAGE_EFFECT_EXPORT void DrawSurfaceBufferFromTex(RenderTexturePtr tex,
188         SurfaceBuffer *buffer, IEffectFormat format);
189     IMAGE_EFFECT_EXPORT void DrawTexFromSurfaceBuffer(RenderTexturePtr tex, SurfaceBuffer *buffer);
190     IMAGE_EFFECT_EXPORT void DrawFlipTex(RenderTexturePtr input, RenderTexturePtr output);
191     std::shared_ptr<EffectBuffer> GenTexEffectBuffer(std::shared_ptr<EffectBuffer> input);
192     IMAGE_EFFECT_EXPORT GLuint GenTexFromEffectBuffer(const EffectBuffer *source);
193     IMAGE_EFFECT_EXPORT GLuint ConvertFromYUVToRGB(const EffectBuffer *source, IEffectFormat format);
194     IMAGE_EFFECT_EXPORT void ConvertFromRGBToYUV(RenderTexturePtr input, IEffectFormat format, void *data);
195     IMAGE_EFFECT_EXPORT void ReleaseParam();
196     IMAGE_EFFECT_EXPORT void Release();
197 
198 private:
199     RenderParam *param_{ nullptr };
200     RenderAttribute attribute_;
201     RenderSurface *screenSurface_{ nullptr };
202     OHNativeWindow *window_{ nullptr };
203     bool hasInputChanged = true;
204     int canvasWidth = 0;
205     int canvasHeight = 0;
206     EGLStatus isEGLReady = EGLStatus::UNREADY;
207     DataType outType_ = DataType::UNKNOWN;
208     bool needTerminate_ = false;
209     void DrawImageToFBO(RenderTexturePtr renderTex, const EffectBuffer *source);
210     void InitDefaultMeshMT(RenderParam *param);
211     void InitDefaultShaderMT(RenderParam *param);
212     RenderMesh *CreateMeshMT(RenderParam *param, bool isBackGround, RenderGeneralProgram *shader);
213 };
214 } // namespace Effect
215 } // namespace Media
216 } // namespace OHOS
217 
218 #endif