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 IMAGE_EFFECT_SURFACE_ADAPTER_H 17 #define IMAGE_EFFECT_SURFACE_ADAPTER_H 18 19 #include <cstdint> 20 #include <functional> 21 #include <iconsumer_surface.h> 22 #include <refbase.h> 23 24 #include "error_code.h" 25 #include "image_effect_marco_define.h" 26 27 namespace OHOS { 28 namespace Media { 29 namespace Effect { 30 using ConsumerBufferAvailable = std::function<void()>; 31 32 /** 33 * Adapter class for image effect surface operation. 34 */ 35 class EffectSurfaceAdapter : public IBufferConsumerListenerClazz { 36 public: 37 IMAGE_EFFECT_EXPORT EffectSurfaceAdapter(); 38 IMAGE_EFFECT_EXPORT ~EffectSurfaceAdapter(); 39 40 /** 41 * Retrieves the producer surface. 42 * @return Smart pointer to the producer surface. 43 */ 44 IMAGE_EFFECT_EXPORT sptr<Surface> GetProducerSurface(); 45 46 /** 47 * Checks if the effect surface is valid. 48 * @return True if valid, false otherwise. 49 */ 50 bool CheckEffectSurface() const; 51 52 /** 53 * Retrieves the consumer surface. 54 * @return Smart pointer to the consumer surface. 55 */ 56 IMAGE_EFFECT_EXPORT sptr<IConsumerSurface> GetConsumerSurface(); 57 58 /** 59 * Acquires a consumer surface buffer. 60 * @param buffer Smart pointer to the surface buffer. 61 * @param syncFence Smart pointer to the sync fence. 62 * @param timestamp Timestamp of the buffer. 63 * @param damages Damages rectangle. 64 * @return Error code indicating the result. 65 */ 66 GSError AcquireConsumerSurfaceBuffer(sptr<SurfaceBuffer>& buffer, sptr<SyncFence>& syncFence, 67 int64_t& timestamp, OHOS::Rect& damages) const; 68 69 /** 70 * Releases a consumer surface buffer. 71 * @param buffer Smart pointer to the surface buffer. 72 * @param syncFence Smart pointer to the sync fence. 73 * @return Error code indicating the result. 74 */ 75 IMAGE_EFFECT_EXPORT GSError ReleaseConsumerSurfaceBuffer(sptr<SurfaceBuffer>& buffer, 76 const sptr<SyncFence>& syncFence) const; 77 78 /** 79 * Detaches a consumer surface buffer. 80 * @param buffer Smart pointer to the surface buffer. 81 * @return Error code indicating the result. 82 */ 83 IMAGE_EFFECT_EXPORT GSError DetachConsumerSurfaceBuffer(sptr<SurfaceBuffer>& buffer) const; 84 85 /** 86 * Attaches a consumer surface buffer. 87 * @param buffer Smart pointer to the surface buffer. 88 * @return Error code indicating the result. 89 */ 90 IMAGE_EFFECT_EXPORT GSError AttachConsumerSurfaceBuffer(sptr<SurfaceBuffer>& buffer) const; 91 92 /** 93 * Sets the consumer surface buffer. 94 * @param consumerBufferAvailable Function to be called when buffer is available. 95 * @return Error code indicating the result. 96 */ 97 IMAGE_EFFECT_EXPORT ErrorCode SetConsumerListener(ConsumerBufferAvailable &&consumerBufferAvailable); 98 99 /** 100 * Retrieves the transformation type. 101 * @return Transformation type. 102 */ 103 IMAGE_EFFECT_EXPORT GraphicTransformType GetTransform() const; 104 105 /** 106 * Sets the default usage for the output surface. 107 * @param usage Usage value. 108 */ 109 void SetOutputSurfaceDefaultUsage(uint64_t usage); 110 111 /** 112 * Requests CPU access for the consumer. 113 * @param isCpuAccess True if CPU access is requested, false otherwise. 114 */ 115 void ConsumerRequestCpuAccess(bool isCpuAccess); 116 117 // Implementation of IBufferConsumerListener interface begin 118 /** 119 * Buffer available callback. 120 */ 121 void OnBufferAvailable() override; 122 123 /** 124 * Tunnel handle change callback. 125 */ 126 void OnTunnelHandleChange() override; 127 128 /** 129 * Go background callback. 130 */ 131 void OnGoBackground() override; 132 133 /** 134 * Clean cache callback. 135 * @param bufSeqNum Buffer sequence number. 136 */ 137 void OnCleanCache(uint32_t* bufSeqNum) override; 138 // Implementation of IBufferConsumerListener interface end 139 140 private: 141 /** 142 * Initializes the EffectSurfaceAdapter. 143 * @return Error code indicating the result. 144 */ 145 ErrorCode Initialize(); 146 147 OHOS::sptr<IConsumerSurface> receiverConsumerSurface_ = nullptr; // Consumer surface interface pointer 148 OHOS::sptr<Surface> fromProducerSurface_ = nullptr; // Producer surface pointer 149 ConsumerBufferAvailable consumerBufferAvailable_; // Consumer buffer available callback 150 uint64_t outputSurfaceDefaultUsage_ = 0; // Default usage for output surface 151 volatile int32_t effectSurfaceFlag_ = 0; // Flag for effect surface validity 152 }; 153 } 154 } 155 } 156 157 #endif // IMAGE_EFFECT_SURFACE_ADAPTER_H