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 AUDIO_PROCESS_IN_SERVER_H 17 #define AUDIO_PROCESS_IN_SERVER_H 18 19 #include <mutex> 20 #include <sstream> 21 22 #include "audio_process_stub.h" 23 #include "i_audio_process_stream.h" 24 #include "i_process_status_listener.h" 25 26 namespace OHOS { 27 namespace AudioStandard { 28 class ProcessReleaseCallback { 29 public: 30 virtual ~ProcessReleaseCallback() = default; 31 32 virtual int32_t OnProcessRelease(IAudioProcessStream *process) = 0; 33 }; 34 class AudioProcessInServer; 35 class ProcessDeathRecipient : public IRemoteObject::DeathRecipient { 36 public: 37 ProcessDeathRecipient(AudioProcessInServer *processInServer, ProcessReleaseCallback *processHolder); 38 virtual ~ProcessDeathRecipient() = default; 39 // overridde for DeathRecipient 40 void OnRemoteDied(const wptr<IRemoteObject> &remote) override; 41 private: 42 ProcessReleaseCallback *processHolder_ = nullptr; 43 AudioProcessInServer *processInServer_ = nullptr; 44 }; 45 46 class AudioProcessInServer : public AudioProcessStub, public IAudioProcessStream { 47 public: 48 static sptr<AudioProcessInServer> Create(const AudioProcessConfig &processConfig, 49 ProcessReleaseCallback *releaseCallback); 50 virtual ~AudioProcessInServer(); 51 52 // override for AudioProcess 53 int32_t ResolveBuffer(std::shared_ptr<OHAudioBuffer> &buffer) override; 54 55 int32_t Start() override; 56 57 int32_t Pause(bool isFlush) override; 58 59 int32_t Resume() override; 60 61 int32_t Stop() override; 62 63 int32_t RequestHandleInfo() override; 64 65 int32_t Release() override; 66 67 int32_t RegisterProcessCb(sptr<IRemoteObject> object) override; 68 69 // override for IAudioProcessStream, used in endpoint 70 std::shared_ptr<OHAudioBuffer> GetStreamBuffer() override; 71 AudioStreamInfo GetStreamInfo() override; 72 AudioStreamType GetAudioStreamType() override; 73 74 int Dump(int fd, const std::vector<std::u16string> &args) override; 75 void Dump(std::stringstream &dumpStringStream); 76 77 int32_t ConfigProcessBuffer(uint32_t &totalSizeInframe, uint32_t &spanSizeInframe); 78 79 int32_t AddProcessStatusListener(std::shared_ptr<IProcessStatusListener> listener); 80 int32_t RemoveProcessStatusListener(std::shared_ptr<IProcessStatusListener> listener); 81 82 private: 83 AudioProcessInServer(const AudioProcessConfig &processConfig, ProcessReleaseCallback *releaseCallback); 84 int32_t InitBufferStatus(); 85 86 private: 87 AudioProcessConfig processConfig_; 88 ProcessReleaseCallback *releaseCallback_ = nullptr; 89 90 bool isInited_ = false; 91 std::atomic<StreamStatus> *streamStatus_ = nullptr; 92 std::mutex statusLock_; 93 94 uint32_t totalSizeInframe_ = 0; 95 uint32_t spanSizeInframe_ = 0; 96 uint32_t byteSizePerFrame_ = 0; 97 bool isBufferConfiged_ = false; 98 std::shared_ptr<OHAudioBuffer> processBuffer_ = nullptr; 99 std::mutex listenerListLock_; 100 std::vector<std::shared_ptr<IProcessStatusListener>> listenerList_; 101 }; 102 } // namespace AudioStandard 103 } // namespace OHOS 104 #endif // AUDIO_PROCESS_IN_SERVER_H 105