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 FCODEC_H 17 #define FCODEC_H 18 19 #include <atomic> 20 #include <list> 21 #include <map> 22 #include <shared_mutex> 23 #include <functional> 24 #include <fstream> 25 #include <tuple> 26 #include <vector> 27 #include <optional> 28 #include <algorithm> 29 #include "av_common.h" 30 #include "avcodec_common.h" 31 #include "avcodec_info.h" 32 #include "block_queue.h" 33 #include "codec_utils.h" 34 #include "codecbase.h" 35 #include "dma_swap.h" 36 #include "media_description.h" 37 #include "fsurface_memory.h" 38 #include "surface_tools.h" 39 #include "task_thread.h" 40 41 namespace OHOS { 42 namespace MediaAVCodec { 43 namespace Codec { 44 using AVBuffer = Media::AVBuffer; 45 using AVAllocator = Media::AVAllocator; 46 using AVAllocatorFactory = Media::AVAllocatorFactory; 47 using MemoryFlag = Media::MemoryFlag; 48 using FormatDataType = Media::FormatDataType; 49 class FCodec : public CodecBase, public RefBase { 50 public: 51 explicit FCodec(const std::string &name); 52 ~FCodec() override; 53 int32_t Init(Media::Meta &callerInfo) override; 54 int32_t Configure(const Format &format) override; 55 int32_t Start() override; 56 int32_t Stop() override; 57 int32_t Flush() override; 58 int32_t Reset() override; 59 int32_t Release() override; 60 int32_t SetParameter(const Format &format) override; 61 int32_t GetOutputFormat(Format &format) override; 62 63 int32_t QueueInputBuffer(uint32_t index) override; 64 int32_t ReleaseOutputBuffer(uint32_t index) override; 65 int32_t SetCallback(const std::shared_ptr<MediaCodecCallback> &callback) override; 66 int32_t SetOutputSurface(sptr<Surface> surface) override; 67 int32_t RenderOutputBuffer(uint32_t index) override; 68 int32_t NotifyMemoryRecycle() override; 69 int32_t NotifyMemoryWriteBack() override; 70 static int32_t GetCodecCapability(std::vector<CapabilityData> &capaArray); 71 72 private: 73 int32_t Initialize(); 74 struct FBuffer { 75 public: 76 FBuffer() = default; 77 ~FBuffer() = default; 78 std::shared_ptr<AVBuffer> avBuffer_ = nullptr; 79 std::shared_ptr<FSurfaceMemory> sMemory_ = nullptr; 80 std::atomic<Owner> owner_ = Owner::OWNED_BY_US; 81 int32_t width_ = 0; 82 int32_t height_ = 0; 83 bool hasSwapedOut_ = false; 84 }; 85 86 enum struct State : int32_t { 87 UNINITIALIZED, 88 INITIALIZED, 89 CONFIGURED, 90 STOPPING, 91 RUNNING, 92 FLUSHED, 93 FLUSHING, 94 EOS, 95 ERROR, 96 FREEZING, 97 FROZEN, 98 }; 99 void DumpOutputBuffer(); 100 bool IsActive() const; 101 void ResetContext(bool isFlush = false); 102 void CalculateBufferSize(); 103 int32_t AllocateBuffers(); 104 void InitBuffers(); 105 void FlushBuffers(); 106 void ResetData(); 107 void ReleaseBuffers(); 108 void StopThread(); 109 void ReleaseResource(); 110 int32_t UpdateBuffers(uint32_t index, int32_t bufferSize, uint32_t bufferType); 111 int32_t UpdateSurfaceMemory(uint32_t index); 112 void SendFrame(); 113 void ReceiveFrame(); 114 void FindAvailIndex(uint32_t index); 115 void ConfigureSurface(const Format &format, const std::string_view &formatKey, FormatDataType formatType); 116 void ConfigureDefaultVal(const Format &format, const std::string_view &formatKey, int32_t minVal = 0, 117 int32_t maxVal = INT_MAX); 118 int32_t ConfigureContext(const Format &format); 119 static void GetMpeg2CapProf(std::vector<CapabilityData> &capaArray); 120 static void GetMpeg4esCapProf(std::vector<CapabilityData> &capaArray); 121 static void SetMpeg4LevelsProfileGroup1(CapabilityData& capsData); 122 static void SetMpeg4LevelsProfileGroup2(CapabilityData& capsData); 123 static void SetMpeg4Profiles(CapabilityData& capsData); 124 static void GetAvcCapProf(std::vector<CapabilityData> &capaArray); 125 static void GetH263CapProf(std::vector<CapabilityData> &capaArray); 126 #if (defined SUPPORT_CODEC_RV) || (defined SUPPORT_CODEC_MP4V_ES) 127 int32_t SetCodecExtradata(const Format &format); 128 #endif 129 void FramePostProcess(std::shared_ptr<FBuffer> &frameBuffer, uint32_t index, int32_t status, int ret); 130 int32_t AllocateInputBuffer(int32_t bufferCnt, int32_t inBufferSize); 131 int32_t AllocateOutputBuffer(int32_t bufferCnt, int32_t outBufferSize); 132 int32_t ClearSurfaceAndSetQueueSize(const sptr<Surface> &surface, int32_t bufferCnt); 133 int32_t AllocateOutputBuffersFromSurface(int32_t bufferCnt); 134 int32_t FillFrameBuffer(const std::shared_ptr<FBuffer> &frameBuffer); 135 int32_t CheckFormatChange(uint32_t index, int width, int height); 136 void SetSurfaceParameter(const Format &format, const std::string_view &formatKey, FormatDataType formatType); 137 int32_t ReplaceOutputSurfaceWhenRunning(sptr<Surface> newSurface); 138 int32_t SetQueueSize(const sptr<Surface> &surface, uint32_t targetSize); 139 int32_t SwitchBetweenSurface(const sptr<Surface> &newSurface); 140 int32_t RenderNewSurfaceWithOldBuffer(const sptr<Surface> &newSurface, uint32_t index); 141 int32_t FlushSurfaceMemory(std::shared_ptr<FSurfaceMemory> &surfaceMemory, uint32_t index); 142 int32_t SetSurfaceCfg(); 143 int32_t Attach(sptr<SurfaceBuffer> surfaceBuffer); 144 int32_t Detach(sptr<SurfaceBuffer> surfaceBuffer); 145 void CombineConsumerUsage(); 146 // surface listener callback 147 GSError BufferReleasedByConsumer(uint64_t surfaceId); 148 int32_t RegisterListenerToSurface(const sptr<Surface> &surface); 149 void UnRegisterListenerToSurface(const sptr<Surface> &surface); 150 void RequestSurfaceBufferThread(); 151 void StartRequestSurfaceBufferThread(); 152 void StopRequestSurfaceBufferThread(); 153 bool RequestSurfaceBufferOnce(uint32_t index); 154 // for memory recycle 155 int32_t FreezeBuffers(State curState); 156 int32_t ActiveBuffers(); 157 bool CanSwapOut(bool isOutputBuffer, std::shared_ptr<FBuffer> &fBuffer); 158 int32_t SwapOutBuffers(bool isOutputBuffer, State curState); 159 int32_t SwapInBuffers(bool isOutputBuffer); 160 bool disableDmaSwap_ = false; 161 int32_t pid_ = -1; 162 163 int32_t instanceId_ = -1; 164 std::string decName_; 165 std::string codecName_; 166 std::atomic<State> state_ = State::UNINITIALIZED; 167 Format format_; 168 int32_t width_ = 0; 169 int32_t height_ = 0; 170 int32_t inputBufferSize_ = 0; 171 int32_t outputBufferSize_ = 0; 172 int32_t inputBufferCnt_ = 0; 173 int32_t outputBufferCnt_ = 0; 174 // INIT 175 std::shared_ptr<AVCodec> avCodec_ = nullptr; 176 CallerInfo fDecInfo_; 177 // Config 178 std::shared_ptr<AVCodecContext> avCodecContext_ = nullptr; 179 // Start 180 std::shared_ptr<AVPacket> avPacket_ = nullptr; 181 std::shared_ptr<AVFrame> cachedFrame_ = nullptr; 182 // Receive frame 183 uint8_t *scaleData_[AV_NUM_DATA_POINTERS] = {nullptr}; 184 int32_t scaleLineSize_[AV_NUM_DATA_POINTERS] = {0}; 185 std::shared_ptr<Scale> scale_ = nullptr; 186 bool isConverted_ = false; 187 bool isOutBufSetted_ = false; 188 VideoPixelFormat outputPixelFmt_ = VideoPixelFormat::UNKNOWN; 189 // Running 190 std::vector<std::shared_ptr<FBuffer>> buffers_[2]; 191 std::vector<std::shared_ptr<AVBuffer>> outAVBuffer4Surface_; 192 std::shared_ptr<BlockQueue<uint32_t>> inputAvailQue_; 193 std::shared_ptr<BlockQueue<uint32_t>> codecAvailQue_; 194 std::shared_ptr<BlockQueue<uint32_t>> renderAvailQue_; 195 std::shared_ptr<BlockQueue<uint32_t>> requestSurfaceBufferQue_; 196 std::map<uint32_t, std::pair<sptr<SurfaceBuffer>, OHOS::BufferFlushConfig>> renderSurfaceBufferMap_; 197 std::optional<uint32_t> synIndex_ = std::nullopt; 198 SurfaceControl sInfo_; 199 std::shared_ptr<TaskThread> sendTask_ = nullptr; 200 std::shared_ptr<TaskThread> receiveTask_ = nullptr; 201 std::mutex inputMutex_; 202 std::mutex outputMutex_; 203 std::mutex sendMutex_; 204 std::mutex recvMutex_; 205 std::mutex syncMutex_; 206 std::mutex surfaceMutex_; 207 std::mutex formatMutex_; 208 std::mutex requestBufferMutex_; 209 std::mutex renderBufferMapMutex_; 210 std::condition_variable requestBufferCV_; 211 std::condition_variable requestBufferOnceDoneCV_; 212 std::condition_variable sendCv_; 213 std::condition_variable recvCv_; 214 std::shared_ptr<MediaCodecCallback> callback_; 215 std::atomic<bool> isSendWait_ = false; 216 std::atomic<bool> isSendEos_ = false; 217 std::atomic<bool> isBufferAllocated_ = false; 218 std::atomic<bool> requestSucceed_ = false; 219 std::atomic<bool> requestBufferFinished_ = true; 220 std::atomic<bool> requestBufferThreadExit_ = false; 221 std::thread mRequestSurfaceBufferThread_; 222 uint32_t decNum_ = 0; 223 // dump 224 #ifdef BUILD_ENG_VERSION 225 void OpenDumpFile(); 226 std::shared_ptr<std::ofstream> dumpInFile_ = nullptr; 227 std::shared_ptr<std::ofstream> dumpOutFile_ = nullptr; 228 #endif // BUILD_ENG_VERSION 229 }; 230 } // namespace Codec 231 } // namespace MediaAVCodec 232 } // namespace OHOS 233 #endif // FCODEC_H