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 HISTREAMER_AU_SERVER_SINK_PLUGIN_H 17 #define HISTREAMER_AU_SERVER_SINK_PLUGIN_H 18 19 #include <atomic> 20 #include <memory> 21 #include <unordered_map> 22 23 #include "audio_info.h" 24 #include "audio_renderer.h" 25 #include "osal/task/mutex.h" 26 #include "meta/audio_types.h" 27 #include "plugin/audio_sink_plugin.h" 28 #include "ffmpeg_utils.h" 29 #include "ffmpeg_convert.h" 30 #include "timestamp.h" 31 32 namespace OHOS { 33 namespace Media { 34 namespace Plugins { 35 class AudioServerSinkPlugin : public Plugins::AudioSinkPlugin { 36 public: 37 explicit AudioServerSinkPlugin(std::string name); 38 39 ~AudioServerSinkPlugin() override; 40 41 Status Init() override; 42 43 __attribute__((no_sanitize("cfi"))) Status Deinit() override; 44 45 Status Prepare() override; 46 47 Status Reset() override; 48 49 Status Start() override; 50 51 Status Stop() override; 52 53 Status GetParameter(std::shared_ptr<Meta> &meta) override; 54 55 Status SetParameter(const std::shared_ptr<Meta> &meta) override; 56 SetCallback(Callback * cb)57 Status SetCallback(Callback *cb) override 58 { 59 callback_ = cb; 60 return Status::OK; 61 } 62 GetMute(bool & mute)63 Status GetMute(bool &mute) override 64 { 65 return Status::OK; 66 } 67 SetMute(bool mute)68 Status SetMute(bool mute) override 69 { 70 return Status::OK; 71 } 72 73 Status GetVolume(float &volume) override; 74 75 Status SetVolume(float volume) override; 76 77 Status GetSpeed(float &speed) override; 78 79 Status SetSpeed(float speed) override; 80 81 Status Pause() override; 82 83 Status PauseTransitent() override; 84 85 Status Resume() override; 86 87 Status GetLatency(uint64_t &hstTime) override; 88 GetFrameSize(size_t & size)89 Status GetFrameSize(size_t &size) override 90 { 91 return Status::OK; 92 } 93 GetFrameCount(uint32_t & count)94 Status GetFrameCount(uint32_t &count) override 95 { 96 return Status::OK; 97 } 98 99 Status Write(const std::shared_ptr<OHOS::Media::AVBuffer> &inputBuffer) override; 100 101 int32_t WriteAudioVivid(const std::shared_ptr<OHOS::Media::AVBuffer> &inputBuffer); 102 103 Status Flush() override; 104 105 Status Drain() override; 106 107 int64_t GetPlayedOutDurationUs(int64_t nowUs) override; 108 109 Status GetFramePosition(int32_t &framePosition) override; 110 111 void SetEventReceiver(const std::shared_ptr<Pipeline::EventReceiver>& receiver) override; 112 113 int32_t SetVolumeWithRamp(float targetVolume, int32_t duration) override; 114 115 Status GetAudioEffectMode(int32_t &effectMode) override; 116 117 Status SetAudioEffectMode(int32_t effectMode) override; 118 119 Status SetMuted(bool isMuted) override; 120 121 AudioSampleFormat GetSampleFormat() override; 122 123 int64_t GetWriteDurationMs() override; 124 private: 125 class AudioRendererCallbackImpl : public OHOS::AudioStandard::AudioRendererCallback, 126 public OHOS::AudioStandard::AudioRendererOutputDeviceChangeCallback { 127 public: 128 AudioRendererCallbackImpl(const std::shared_ptr<Pipeline::EventReceiver> &receiver, const bool &isPaused); 129 void OnInterrupt(const OHOS::AudioStandard::InterruptEvent &interruptEvent) override; 130 void OnStateChange(const OHOS::AudioStandard::RendererState state, 131 const OHOS::AudioStandard::StateChangeCmdType cmdType) override; 132 void OnOutputDeviceChange(const AudioStandard::DeviceInfo &deviceInfo, 133 const AudioStandard::AudioStreamDeviceChangeReason reason) override; 134 private: 135 std::shared_ptr<Pipeline::EventReceiver> playerEventReceiver_; 136 bool isPaused_{false}; 137 }; 138 class AudioServiceDiedCallbackImpl : public OHOS::AudioStandard::AudioRendererPolicyServiceDiedCallback { 139 public: 140 explicit AudioServiceDiedCallbackImpl(std::shared_ptr<Pipeline::EventReceiver> &receiver); 141 void OnAudioPolicyServiceDied() override; 142 private: 143 std::shared_ptr<Pipeline::EventReceiver> playerEventReceiver_; 144 }; 145 class AudioFirstFrameCallbackImpl : public OHOS::AudioStandard::AudioRendererFirstFrameWritingCallback { 146 public: 147 explicit AudioFirstFrameCallbackImpl(std::shared_ptr<Pipeline::EventReceiver> &receiver); 148 void OnFirstFrameWriting(uint64_t latency) override; 149 150 private: 151 std::shared_ptr<Pipeline::EventReceiver> playerEventReceiver_; 152 }; 153 void ReleaseRender(); 154 __attribute__((no_sanitize("cfi"))) void ReleaseFile(); 155 bool StopRender(); 156 bool AssignSampleRateIfSupported(uint32_t sampleRate); 157 bool AssignChannelNumIfSupported(uint32_t channelNum); 158 bool AssignSampleFmtIfSupported(AudioSampleFormat sampleFormat); 159 void SetInterruptMode(AudioStandard::InterruptMode interruptMode); 160 161 void SetUpParamsSetterMap(); 162 void SetUpMimeTypeSetter(); 163 void SetUpSampleRateSetter(); 164 void SetUpAudioOutputChannelsSetter(); 165 void SetUpMediaBitRateSetter(); 166 void SetUpAudioSampleFormatSetter(); 167 void SetUpAudioOutputChannelLayoutSetter(); 168 void SetUpAudioSamplePerFrameSetter(); 169 void SetUpBitsPerCodedSampleSetter(); 170 void SetUpMediaSeekableSetter(); 171 void SetUpAppPidSetter(); 172 void SetUpAppUidSetter(); 173 void SetUpAudioRenderInfoSetter(); 174 void SetUpAudioInterruptModeSetter(); 175 void SetUpAudioRenderSetFlagSetter(); 176 void SetAudioDumpBySysParam(); 177 void DumpEntireAudioBuffer(uint8_t* buffer, const size_t& bytesSingle); 178 void DumpSliceAudioBuffer(uint8_t* buffer, const size_t& bytesSingle); 179 void CacheData(uint8_t* inputBuffer, size_t bufferSize); 180 Status DrainCacheData(bool render); 181 //return value is the remained buffer size 182 size_t WriteAudioBuffer(uint8_t* inputBuffer, size_t bufferSize, bool& shouldDrop); 183 184 OHOS::Media::Mutex renderMutex_{}; 185 Callback *callback_{}; 186 AudioRenderInfo audioRenderInfo_{}; 187 AudioStandard::AudioRendererOptions rendererOptions_{}; 188 AudioStandard::InterruptMode audioInterruptMode_{AudioStandard::InterruptMode::SHARE_MODE}; 189 std::unique_ptr<AudioStandard::AudioRenderer> audioRenderer_{nullptr}; 190 std::shared_ptr<AudioRendererCallbackImpl> audioRendererCallback_{nullptr}; 191 std::shared_ptr<OHOS::AudioStandard::AudioRendererFirstFrameWritingCallback> audioFirstFrameCallback_{nullptr}; 192 std::shared_ptr<OHOS::AudioStandard::AudioRendererPolicyServiceDiedCallback> audioServiceDiedCallback_{nullptr}; 193 AudioStandard::AudioRendererParams rendererParams_{}; 194 195 std::shared_ptr<Pipeline::EventReceiver> playerEventReceiver_; 196 bool fmtSupported_{false}; 197 bool isForcePaused_{false}; 198 std::shared_ptr<Meta> meta_; 199 AVSampleFormat reSrcFfFmt_{AV_SAMPLE_FMT_NONE}; 200 const AudioStandard::AudioSampleFormat reStdDestFmt_{AudioStandard::AudioSampleFormat::SAMPLE_S16LE}; 201 AudioChannelLayout channelLayout_{}; 202 std::string mimeType_; 203 uint32_t channels_{}; 204 uint32_t samplesPerFrame_{}; 205 uint32_t bitsPerSample_{0}; 206 uint32_t sampleRate_{}; 207 int64_t bitRate_{0}; 208 int32_t appPid_{0}; 209 int32_t appUid_{0}; 210 bool needReformat_{false}; 211 Plugins::Seekable seekable_{Plugins::Seekable::INVALID}; 212 std::shared_ptr<Ffmpeg::Resample> resample_{nullptr}; 213 214 std::unordered_map<TagType, std::function<Status(const ValueType ¶)>> paramsSetterMap_; 215 float audioRendererVolume_ = 1.0; 216 217 FILE* entireDumpFile_ = nullptr; 218 FILE* sliceDumpFile_ = nullptr; 219 int32_t sliceCount_ {0}; 220 int32_t curCount_ {-1}; 221 bool enableEntireDump_ {false}; 222 bool enableDumpSlice_ {false}; 223 bool audioRenderSetFlag_ {false}; 224 std::list<std::vector<uint8_t>> cachedBuffers_; 225 int64_t writeDuration_ = 0; 226 }; 227 } // namespace Plugin 228 } // namespace Media 229 } // namespace OHOS 230 #endif // HISTREAMER_AU_SERVER_SINK_PLUGIN_H 231