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 #ifndef FAST_AUDIO_STREAM_H
16 #define FAST_AUDIO_STREAM_H
17
18 #ifndef LOG_TAG
19 #define LOG_TAG "CapturerInClientInner"
20 #endif
21
22 #include "capturer_in_client.h"
23
24 #include <atomic>
25 #include <cinttypes>
26 #include <condition_variable>
27 #include <sstream>
28 #include <string>
29 #include <mutex>
30 #include <thread>
31 #include "iservice_registry.h"
32 #include "system_ability_definition.h"
33 #include "securec.h"
34 #include "ipc_stream.h"
35 #include "audio_capturer_log.h"
36 #include "audio_errors.h"
37 #include "audio_log_utils.h"
38 #include "audio_manager_base.h"
39 #include "audio_ring_cache.h"
40 #include "audio_utils.h"
41 #include "audio_policy_manager.h"
42 #include "audio_server_death_recipient.h"
43 #include "audio_stream_tracker.h"
44 #include "audio_system_manager.h"
45 #include "audio_process_config.h"
46 #include "ipc_stream_listener_impl.h"
47 #include "ipc_stream_listener_stub.h"
48 #include "callback_handler.h"
49
50 namespace OHOS {
51 namespace AudioStandard {
52 namespace {
53 static const size_t MAX_CLIENT_READ_SIZE = 20 * 1024 * 1024; // 20M
54 static const int32_t CREATE_TIMEOUT_IN_SECOND = 9; // 9S
55 static const int32_t OPERATION_TIMEOUT_IN_MS = 1000; // 1000ms
56 static const int32_t LOGLITMITTIMES = 20;
57 const uint64_t AUDIO_US_PER_MS = 1000;
58 const uint64_t AUDIO_US_PER_S = 1000000;
59 const uint64_t DEFAULT_BUF_DURATION_IN_USEC = 20000; // 20ms
60 const uint64_t MAX_BUF_DURATION_IN_USEC = 2000000; // 2S
61 const int64_t INVALID_FRAME_SIZE = -1;
62 static const int32_t HALF_FACTOR = 2;
63 static const int32_t SHORT_TIMEOUT_IN_MS = 20; // ms
64 static constexpr int CB_QUEUE_CAPACITY = 3;
65 }
66
67 class CapturerInClientInner : public CapturerInClient, public IStreamListener, public IHandler,
68 public std::enable_shared_from_this<CapturerInClientInner> {
69 public:
70 CapturerInClientInner(AudioStreamType eStreamType, int32_t appUid);
71 ~CapturerInClientInner();
72
73 // IStreamListener
74 int32_t OnOperationHandled(Operation operation, int64_t result) override;
75
76 void SetClientID(int32_t clientPid, int32_t clientUid, uint32_t appTokenId, uint64_t fullTokenId) override;
77
78 int32_t UpdatePlaybackCaptureConfig(const AudioPlaybackCaptureConfig &config) override;
79 void SetRendererInfo(const AudioRendererInfo &rendererInfo) override;
80 void SetCapturerInfo(const AudioCapturerInfo &capturerInfo) override;
81 int32_t GetAudioStreamInfo(AudioStreamParams &info) override;
82 int32_t SetAudioStreamInfo(const AudioStreamParams info,
83 const std::shared_ptr<AudioClientTracker> &proxyObj) override;
84 bool CheckRecordingCreate(uint32_t appTokenId, uint64_t appFullTokenId, int32_t appUid, SourceType sourceType =
85 SOURCE_TYPE_MIC) override;
86 bool CheckRecordingStateChange(uint32_t appTokenId, uint64_t appFullTokenId, int32_t appUid,
87 AudioPermissionState state) override;
88 State GetState() override;
89 int32_t GetAudioSessionID(uint32_t &sessionID) override;
90 void GetAudioPipeType(AudioPipeType &pipeType) override;
91 bool GetAudioTime(Timestamp ×tamp, Timestamp::Timestampbase base) override;
92 bool GetAudioPosition(Timestamp ×tamp, Timestamp::Timestampbase base) override;
93 int32_t GetBufferSize(size_t &bufferSize) override;
94 int32_t GetFrameCount(uint32_t &frameCount) override;
95 int32_t GetLatency(uint64_t &latency) override;
96 int32_t SetAudioStreamType(AudioStreamType audioStreamType) override;
97 float GetVolume() override;
98 int32_t SetVolume(float volume) override;
99 int32_t SetDuckVolume(float volume) override;
100 int32_t SetRenderRate(AudioRendererRate renderRate) override;
101 AudioRendererRate GetRenderRate() override;
102 int32_t SetStreamCallback(const std::shared_ptr<AudioStreamCallback> &callback) override;
103 int32_t SetSpeed(float speed) override;
104 float GetSpeed() override;
105 int32_t ChangeSpeed(uint8_t *buffer, int32_t bufferSize, std::unique_ptr<uint8_t[]> &outBuffer,
106 int32_t &outBufferSize) override;
107
108 // callback mode api
109 AudioRenderMode GetRenderMode() override;
110 int32_t SetRenderMode(AudioRenderMode renderMode) override;
111 int32_t SetRendererWriteCallback(const std::shared_ptr<AudioRendererWriteCallback> &callback) override;
112 int32_t SetCaptureMode(AudioCaptureMode captureMode) override;
113 AudioCaptureMode GetCaptureMode() override;
114 int32_t SetCapturerReadCallback(const std::shared_ptr<AudioCapturerReadCallback> &callback) override;
115 int32_t GetBufferDesc(BufferDesc &bufDesc) override;
116 int32_t Clear() override;
117 int32_t GetBufQueueState(BufferQueueState &bufState) override;
118 int32_t Enqueue(const BufferDesc &bufDesc) override;
119
120 int32_t SetLowPowerVolume(float volume) override;
121 float GetLowPowerVolume() override;
122 int32_t UnsetOffloadMode() override;
123 int32_t SetOffloadMode(int32_t state, bool isAppBack) override;
124 float GetSingleStreamVolume() override;
125 AudioEffectMode GetAudioEffectMode() override;
126 int32_t SetAudioEffectMode(AudioEffectMode effectMode) override;
127 int64_t GetFramesRead() override;
128 int64_t GetFramesWritten() override;
129
130 void SetInnerCapturerState(bool isInnerCapturer) override;
131 void SetWakeupCapturerState(bool isWakeupCapturer) override;
132 void SetPrivacyType(AudioPrivacyType privacyType) override;
133 void SetCapturerSource(int capturerSource) override;
134
135 // Common APIs
136 bool StartAudioStream(StateChangeCmdType cmdType = CMD_FROM_CLIENT,
137 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReasonExt::ExtEnum::UNKNOWN) override;
138 bool PauseAudioStream(StateChangeCmdType cmdType = CMD_FROM_CLIENT) override;
139 bool StopAudioStream() override;
140 bool FlushAudioStream() override;
141 bool ReleaseAudioStream(bool releaseRunner = true, bool isSwitchStream = false) override;
142
143 // Playback related APIs
144 bool DrainAudioStream(bool stopFlag = false) override;
145 int32_t Write(uint8_t *buffer, size_t bufferSize) override;
146 int32_t Write(uint8_t *pcmBuffer, size_t pcmBufferSize, uint8_t *metaBuffer, size_t metaBufferSize) override;
147 void SetPreferredFrameSize(int32_t frameSize) override;
148 void UpdateLatencyTimestamp(std::string ×tamp, bool isRenderer) override;
149 int32_t SetRendererFirstFrameWritingCallback(
150 const std::shared_ptr<AudioRendererFirstFrameWritingCallback> &callback) override;
151 void OnFirstFrameWriting() override;
152
153 // Recording related APIs
154 int32_t Read(uint8_t &buffer, size_t userSize, bool isBlockingRead) override;
155
156 // Position and period callbacks
157 void SetCapturerPositionCallback(int64_t markPosition,
158 const std::shared_ptr<CapturerPositionCallback> &callback) override;
159 void UnsetCapturerPositionCallback() override;
160 void SetCapturerPeriodPositionCallback(int64_t periodPosition,
161 const std::shared_ptr<CapturerPeriodPositionCallback> &callback) override;
162 void UnsetCapturerPeriodPositionCallback() override;
163 void SetRendererPositionCallback(int64_t markPosition,
164 const std::shared_ptr<RendererPositionCallback> &callback) override;
165 void UnsetRendererPositionCallback() override;
166 void SetRendererPeriodPositionCallback(int64_t periodPosition,
167 const std::shared_ptr<RendererPeriodPositionCallback> &callback) override;
168 void UnsetRendererPeriodPositionCallback() override;
169
170 uint32_t GetUnderflowCount() override;
171 uint32_t GetOverflowCount() override;
172 void SetUnderflowCount(uint32_t underflowCount) override;
173 void SetOverflowCount(uint32_t overflowCount) override;
174
175 uint32_t GetRendererSamplingRate() override;
176 int32_t SetRendererSamplingRate(uint32_t sampleRate) override;
177 int32_t SetBufferSizeInMsec(int32_t bufferSizeInMsec) override;
178 void SetApplicationCachePath(const std::string cachePath) override;
179 int32_t SetChannelBlendMode(ChannelBlendMode blendMode) override;
180 int32_t SetVolumeWithRamp(float volume, int32_t duration) override;
181
182 void SetStreamTrackerState(bool trackerRegisteredState) override;
183 void GetSwitchInfo(IAudioStream::SwitchInfo& info) override;
184
185 IAudioStream::StreamClass GetStreamClass() override;
186
187 void SetSilentModeAndMixWithOthers(bool on) override;
188
189 bool GetSilentModeAndMixWithOthers() override;
190
191 static void AudioServerDied(pid_t pid);
192
193 void OnHandle(uint32_t code, int64_t data) override;
194 void InitCallbackHandler();
195 void SafeSendCallbackEvent(uint32_t eventCode, int64_t data);
196
197 void SendCapturerMarkReachedEvent(int64_t capturerMarkPosition);
198 void SendCapturerPeriodReachedEvent(int64_t capturerPeriodSize);
199
200 void HandleCapturerPositionChanges(size_t bytesRead);
201 void HandleStateChangeEvent(int64_t data);
202 void HandleCapturerMarkReachedEvent(int64_t capturerMarkPosition);
203 void HandleCapturerPeriodReachedEvent(int64_t capturerPeriodNumber);
204
205 static const sptr<IStandardAudioService> GetAudioServerProxy();
206
207 bool RestoreAudioStream(bool needStoreState = true) override;
208
209 bool GetOffloadEnable() override;
210 bool GetSpatializationEnabled() override;
211 bool GetHighResolutionEnabled() override;
212
213 private:
214 void RegisterTracker(const std::shared_ptr<AudioClientTracker> &proxyObj);
215 void UpdateTracker(const std::string &updateCase);
216
217 int32_t DeinitIpcStream();
218
219 int32_t InitIpcStream();
220
221 const AudioProcessConfig ConstructConfig();
222
223 int32_t InitCacheBuffer(size_t targetSize);
224 int32_t InitSharedBuffer();
225 int32_t FlushRingCache();
226
227 void GetStreamSwitchInfo(IAudioStream::SwitchInfo& info);
228
229 int32_t StateCmdTypeToParams(int64_t ¶ms, State state, StateChangeCmdType cmdType);
230 int32_t ParamsToStateCmdType(int64_t params, State &state, StateChangeCmdType &cmdType);
231
232 void InitCallbackBuffer(uint64_t bufferDurationInUs);
233 void ReadCallbackFunc();
234 // for callback mode. Check status if not running, wait for start or release.
235 bool WaitForRunning();
236
237 int32_t HandleCapturerRead(size_t &readSize, size_t &userSize, uint8_t &buffer, bool isBlockingRead);
238 void DfxOperation(BufferDesc &buffer, AudioSampleFormat format, AudioChannel channel) const;
239 int32_t RegisterCapturerInClientPolicyServerDiedCb();
240 int32_t UnregisterCapturerInClientPolicyServerDiedCb();
241 private:
242 AudioStreamType eStreamType_;
243 int32_t appUid_;
244 uint32_t sessionId_ = 0;
245 int32_t clientUid_ = -1;
246 int32_t clientPid_ = -1;
247 uint32_t appTokenId_ = 0;
248 uint64_t fullTokenId_ = 0;
249
250 std::atomic<uint32_t> readLogTimes_ = 0;
251
252 std::unique_ptr<AudioStreamTracker> audioStreamTracker_ = nullptr;
253 bool streamTrackerRegistered_ = false;
254
255 AudioRendererInfo rendererInfo_ = {}; // not in use
256 AudioCapturerInfo capturerInfo_ = {};
257
258 int32_t bufferSizeInMsec_ = 20; // 20ms
259 std::string cachePath_ = "";
260
261 // callback mode
262 AudioCaptureMode capturerMode_ = CAPTURE_MODE_NORMAL;
263 std::thread callbackLoop_; // thread for callback to client and write.
264 std::atomic<bool> cbThreadReleased_ = true;
265 std::mutex readCbMutex_; // lock for change or use callback
266 std::condition_variable cbThreadCv_;
267 std::shared_ptr<AudioCapturerReadCallback> readCb_ = nullptr;
268 std::mutex cbBufferMutex_;
269 std::unique_ptr<uint8_t[]> cbBuffer_ {nullptr};
270 size_t cbBufferSize_ = 0;
271 AudioSafeBlockQueue<BufferDesc> cbBufferQueue_; // only one cbBuffer_
272
273 AudioPlaybackCaptureConfig filterConfig_ = {{{}, FilterMode::INCLUDE, {}, FilterMode::INCLUDE}, false};
274 bool isInnerCapturer_ = false;
275 bool isWakeupCapturer_ = false;
276
277 bool needSetThreadPriority_ = true;
278
279 AudioStreamParams streamParams_; // in plan: replace it with AudioCapturerParams
280
281 // callbacks
282 std::mutex streamCbMutex_;
283 std::weak_ptr<AudioStreamCallback> streamCallback_;
284
285 size_t cacheSizeInByte_ = 0;
286 uint32_t spanSizeInFrame_ = 0;
287 size_t clientSpanSizeInByte_ = 0;
288 size_t sizePerFrameInByte_ = 4; // 16bit 2ch as default
289
290 // using this lock when change status_
291 std::mutex statusMutex_;
292 std::atomic<State> state_ = INVALID;
293 // for status operation wait and notify
294 std::mutex callServerMutex_;
295 std::condition_variable callServerCV_;
296
297 Operation notifiedOperation_ = MAX_OPERATION_CODE;
298 int64_t notifiedResult_ = 0;
299
300 // read data
301 std::mutex readDataMutex_;
302 std::condition_variable readDataCV_;
303
304 uint32_t overflowCount_ = 0;
305 // ipc stream related
306 AudioProcessConfig clientConfig_;
307 sptr<IpcStreamListenerImpl> listener_ = nullptr;
308 sptr<IpcStream> ipcStream_ = nullptr;
309 std::shared_ptr<OHAudioBuffer> clientBuffer_ = nullptr;
310
311 // buffer handle
312 std::unique_ptr<AudioRingCache> ringCache_ = nullptr;
313 std::mutex readMutex_; // used for prevent multi thread call read
314
315 // Mark reach and period reach callback
316 uint64_t totalBytesRead_ = 0;
317 std::mutex markReachMutex_;
318 bool capturerMarkReached_ = false;
319 int64_t capturerMarkPosition_ = 0;
320 std::shared_ptr<CapturerPositionCallback> capturerPositionCallback_ = nullptr;
321
322 std::mutex periodReachMutex_;
323 int64_t capturerPeriodSize_ = 0;
324 int64_t capturerPeriodRead_ = 0;
325 std::shared_ptr<CapturerPeriodPositionCallback> capturerPeriodPositionCallback_ = nullptr;
326
327 mutable int64_t volumeDataCount_ = 0;
328 std::string logUtilsTag_ = "";
329
330 // Event handler
331 bool runnerReleased_ = false;
332 std::mutex runnerMutex_;
333 std::shared_ptr<CallbackHandler> callbackHandler_ = nullptr;
334
335 std::shared_ptr<AudioClientTracker> proxyObj_ = nullptr;
336
337 bool paramsIsSet_ = false;
338
339 enum {
340 STATE_CHANGE_EVENT = 0,
341 RENDERER_MARK_REACHED_EVENT,
342 RENDERER_PERIOD_REACHED_EVENT,
343 CAPTURER_PERIOD_REACHED_EVENT,
344 CAPTURER_MARK_REACHED_EVENT,
345 };
346
347 enum : int64_t {
348 HANDLER_PARAM_INVALID = -1,
349 HANDLER_PARAM_NEW = 0,
350 HANDLER_PARAM_PREPARED,
351 HANDLER_PARAM_RUNNING,
352 HANDLER_PARAM_STOPPED,
353 HANDLER_PARAM_RELEASED,
354 HANDLER_PARAM_PAUSED,
355 HANDLER_PARAM_STOPPING,
356 HANDLER_PARAM_RUNNING_FROM_SYSTEM,
357 HANDLER_PARAM_PAUSED_FROM_SYSTEM,
358 };
359 };
360
GetInstance(AudioStreamType eStreamType,int32_t appUid)361 std::shared_ptr<CapturerInClient> CapturerInClient::GetInstance(AudioStreamType eStreamType, int32_t appUid)
362 {
363 return std::make_shared<CapturerInClientInner>(eStreamType, appUid);
364 }
365
CapturerInClientInner(AudioStreamType eStreamType,int32_t appUid)366 CapturerInClientInner::CapturerInClientInner(AudioStreamType eStreamType, int32_t appUid) : eStreamType_(eStreamType),
367 appUid_(appUid), cbBufferQueue_(CB_QUEUE_CAPACITY)
368 {
369 AUDIO_INFO_LOG("Create with StreamType:%{public}d appUid:%{public}d ", eStreamType_, appUid_);
370 audioStreamTracker_ = std::make_unique<AudioStreamTracker>(AUDIO_MODE_RECORD, appUid);
371 state_ = NEW;
372 }
373
~CapturerInClientInner()374 CapturerInClientInner::~CapturerInClientInner()
375 {
376 AUDIO_INFO_LOG("~CapturerInClientInner()");
377 CapturerInClientInner::ReleaseAudioStream(true);
378 AUDIO_INFO_LOG("[%{public}s] volume data counts: %{public}" PRId64, logUtilsTag_.c_str(), volumeDataCount_);
379 }
380
OnOperationHandled(Operation operation,int64_t result)381 int32_t CapturerInClientInner::OnOperationHandled(Operation operation, int64_t result)
382 {
383 // read/write operation may print many log, use debug.
384 if (operation == UPDATE_STREAM) {
385 AUDIO_DEBUG_LOG("OnOperationHandled() UPDATE_STREAM result:%{public}" PRId64".", result);
386 // notify write if blocked
387 readDataCV_.notify_all();
388 return SUCCESS;
389 }
390
391 if (operation == BUFFER_OVERFLOW) {
392 AUDIO_WARNING_LOG("recv overflow %{public}d", overflowCount_);
393 // in plan next: do more to reduce overflow
394 readDataCV_.notify_all();
395 return SUCCESS;
396 }
397
398 AUDIO_INFO_LOG("OnOperationHandled() recv operation:%{public}d result:%{public}" PRId64".", operation, result);
399 std::unique_lock<std::mutex> lock(callServerMutex_);
400 notifiedOperation_ = operation;
401 notifiedResult_ = result;
402 callServerCV_.notify_all();
403 return SUCCESS;
404 }
405
SetClientID(int32_t clientPid,int32_t clientUid,uint32_t appTokenId,uint64_t fullTokenId)406 void CapturerInClientInner::SetClientID(int32_t clientPid, int32_t clientUid, uint32_t appTokenId, uint64_t fullTokenId)
407 {
408 AUDIO_INFO_LOG("PID:%{public}d UID:%{public}d.", clientPid, clientUid);
409 clientPid_ = clientPid;
410 clientUid_ = clientUid;
411 appTokenId_ = appTokenId;
412 fullTokenId_ = fullTokenId;
413 return;
414 }
415
UpdatePlaybackCaptureConfig(const AudioPlaybackCaptureConfig & config)416 int32_t CapturerInClientInner::UpdatePlaybackCaptureConfig(const AudioPlaybackCaptureConfig &config)
417 {
418 AUDIO_INFO_LOG("client set %{public}s", ProcessConfig::DumpInnerCapConfig(config).c_str());
419 CHECK_AND_RETURN_RET_LOG(ipcStream_ != nullptr, ERR_ILLEGAL_STATE, "IpcStream is already nullptr");
420 int32_t ret = ipcStream_->UpdatePlaybackCaptureConfig(config);
421 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "failed: %{public}d", ret);
422
423 filterConfig_ = config;
424 return SUCCESS;
425 }
426
SetRendererInfo(const AudioRendererInfo & rendererInfo)427 void CapturerInClientInner::SetRendererInfo(const AudioRendererInfo &rendererInfo)
428 {
429 AUDIO_WARNING_LOG("SetRendererInfo is not supported");
430 return;
431 }
432
SetCapturerInfo(const AudioCapturerInfo & capturerInfo)433 void CapturerInClientInner::SetCapturerInfo(const AudioCapturerInfo &capturerInfo)
434 {
435 capturerInfo_ = capturerInfo;
436 capturerInfo_.samplingRate = static_cast<AudioSamplingRate>(streamParams_.samplingRate);
437 capturerInfo_.encodingType = streamParams_.encoding;
438 capturerInfo_.channelLayout = streamParams_.channelLayout;
439 AUDIO_INFO_LOG("SetCapturerInfo with SourceType %{public}d flag %{public}d", capturerInfo_.sourceType,
440 capturerInfo_.capturerFlags);
441 return;
442 }
443
RegisterTracker(const std::shared_ptr<AudioClientTracker> & proxyObj)444 void CapturerInClientInner::RegisterTracker(const std::shared_ptr<AudioClientTracker> &proxyObj)
445 {
446 if (audioStreamTracker_ && audioStreamTracker_.get() && !streamTrackerRegistered_) {
447 // make sure sessionId_ is set before.
448 AUDIO_INFO_LOG("Calling register tracker, sessionid = %{public}d", sessionId_);
449 AudioRegisterTrackerInfo registerTrackerInfo;
450
451 capturerInfo_.samplingRate = static_cast<AudioSamplingRate>(streamParams_.samplingRate);
452 registerTrackerInfo.sessionId = sessionId_;
453 registerTrackerInfo.clientPid = clientPid_;
454 registerTrackerInfo.state = state_;
455 registerTrackerInfo.rendererInfo = rendererInfo_;
456 registerTrackerInfo.capturerInfo = capturerInfo_;
457 registerTrackerInfo.appTokenId = appTokenId_;
458
459 audioStreamTracker_->RegisterTracker(registerTrackerInfo, proxyObj);
460 streamTrackerRegistered_ = true;
461 }
462 }
463
UpdateTracker(const std::string & updateCase)464 void CapturerInClientInner::UpdateTracker(const std::string &updateCase)
465 {
466 if (audioStreamTracker_ && audioStreamTracker_.get()) {
467 AUDIO_DEBUG_LOG("Capturer:Calling Update tracker for %{public}s", updateCase.c_str());
468 audioStreamTracker_->UpdateTracker(sessionId_, state_, clientPid_, rendererInfo_, capturerInfo_);
469 }
470 }
471
SetAudioStreamInfo(const AudioStreamParams info,const std::shared_ptr<AudioClientTracker> & proxyObj)472 int32_t CapturerInClientInner::SetAudioStreamInfo(const AudioStreamParams info,
473 const std::shared_ptr<AudioClientTracker> &proxyObj)
474 {
475 AUDIO_INFO_LOG("AudioStreamInfo, Sampling rate: %{public}d, channels: %{public}d, format: %{public}d, stream type:"
476 " %{public}d, encoding type: %{public}d", info.samplingRate, info.channels, info.format, eStreamType_,
477 info.encoding);
478 AudioXCollie guard("CapturerInClientInner::SetAudioStreamInfo", CREATE_TIMEOUT_IN_SECOND);
479 if (!IsFormatValid(info.format) || !IsEncodingTypeValid(info.encoding) || !IsSamplingRateValid(info.samplingRate)) {
480 AUDIO_ERR_LOG("CapturerInClient: Unsupported audio parameter");
481 return ERR_NOT_SUPPORTED;
482 }
483 if (!IsRecordChannelRelatedInfoValid(info.channels, info.channelLayout)) {
484 AUDIO_ERR_LOG("Invalid sink channel %{public}d or channel layout %{public}" PRIu64, info.channels,
485 info.channelLayout);
486 return ERR_NOT_SUPPORTED;
487 }
488
489 CHECK_AND_RETURN_RET_LOG(IAudioStream::GetByteSizePerFrame(info, sizePerFrameInByte_) == SUCCESS,
490 ERROR_INVALID_PARAM, "GetByteSizePerFrame failed with invalid params");
491
492 if (state_ != NEW) {
493 AUDIO_INFO_LOG("State is %{public}d, not new, release existing stream and recreate.", state_.load());
494 int32_t ret = DeinitIpcStream();
495 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "release existing stream failed.");
496 }
497
498 streamParams_ = info; // keep it for later use
499 paramsIsSet_ = true;
500 int32_t initRet = InitIpcStream();
501 CHECK_AND_RETURN_RET_LOG(initRet == SUCCESS, initRet, "Init stream failed: %{public}d", initRet);
502 state_ = PREPARED;
503 logUtilsTag_ = "[" + std::to_string(sessionId_) + "]NormalCapturer";
504
505 proxyObj_ = proxyObj;
506 RegisterTracker(proxyObj);
507 return SUCCESS;
508 }
509
510 std::mutex g_serverMutex;
511 sptr<IStandardAudioService> g_ServerProxy = nullptr;
GetAudioServerProxy()512 const sptr<IStandardAudioService> CapturerInClientInner::GetAudioServerProxy()
513 {
514 std::lock_guard<std::mutex> lock(g_serverMutex);
515 if (g_ServerProxy == nullptr) {
516 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
517 if (samgr == nullptr) {
518 AUDIO_ERR_LOG("GetAudioServerProxy: get sa manager failed");
519 return nullptr;
520 }
521 sptr<IRemoteObject> object = samgr->GetSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID);
522 if (object == nullptr) {
523 AUDIO_ERR_LOG("GetAudioServerProxy: get audio service remote object failed");
524 return nullptr;
525 }
526 g_ServerProxy = iface_cast<IStandardAudioService>(object);
527 if (g_ServerProxy == nullptr) {
528 AUDIO_ERR_LOG("GetAudioServerProxy: get audio service proxy failed");
529 return nullptr;
530 }
531
532 // register death recipent to restore proxy
533 sptr<AudioServerDeathRecipient> asDeathRecipient = new(std::nothrow) AudioServerDeathRecipient(getpid());
534 if (asDeathRecipient != nullptr) {
535 asDeathRecipient->SetNotifyCb([] (pid_t pid) { AudioServerDied(pid); });
536 bool result = object->AddDeathRecipient(asDeathRecipient);
537 if (!result) {
538 AUDIO_ERR_LOG("GetAudioServerProxy: failed to add deathRecipient");
539 }
540 }
541 }
542 sptr<IStandardAudioService> gasp = g_ServerProxy;
543 return gasp;
544 }
545
AudioServerDied(pid_t pid)546 void CapturerInClientInner::AudioServerDied(pid_t pid)
547 {
548 AUDIO_INFO_LOG("audio server died clear proxy, will restore proxy in next call");
549 std::lock_guard<std::mutex> lock(g_serverMutex);
550 g_ServerProxy = nullptr;
551 }
552
OnHandle(uint32_t code,int64_t data)553 void CapturerInClientInner::OnHandle(uint32_t code, int64_t data)
554 {
555 AUDIO_DEBUG_LOG("On handle event, event code: %{public}d, data: %{public}" PRIu64 "", code, data);
556 switch (code) {
557 case STATE_CHANGE_EVENT:
558 HandleStateChangeEvent(data);
559 break;
560 case RENDERER_MARK_REACHED_EVENT:
561 HandleCapturerMarkReachedEvent(data);
562 break;
563 case RENDERER_PERIOD_REACHED_EVENT:
564 HandleCapturerPeriodReachedEvent(data);
565 break;
566 default:
567 break;
568 }
569 }
570
HandleStateChangeEvent(int64_t data)571 void CapturerInClientInner::HandleStateChangeEvent(int64_t data)
572 {
573 State state = INVALID;
574 StateChangeCmdType cmdType = CMD_FROM_CLIENT;
575 ParamsToStateCmdType(data, state, cmdType);
576 std::unique_lock<std::mutex> lock(streamCbMutex_);
577 std::shared_ptr<AudioStreamCallback> streamCb = streamCallback_.lock();
578 if (streamCb != nullptr) {
579 state = state != STOPPING ? state : STOPPED; // client only need STOPPED
580 streamCb->OnStateChange(state, cmdType);
581 }
582 }
583
HandleCapturerMarkReachedEvent(int64_t capturerMarkPosition)584 void CapturerInClientInner::HandleCapturerMarkReachedEvent(int64_t capturerMarkPosition)
585 {
586 AUDIO_DEBUG_LOG("Start HandleCapturerMarkReachedEvent");
587 std::unique_lock<std::mutex> lock(markReachMutex_);
588 if (capturerPositionCallback_) {
589 capturerPositionCallback_->OnMarkReached(capturerMarkPosition);
590 }
591 }
592
HandleCapturerPeriodReachedEvent(int64_t capturerPeriodNumber)593 void CapturerInClientInner::HandleCapturerPeriodReachedEvent(int64_t capturerPeriodNumber)
594 {
595 AUDIO_DEBUG_LOG("Start HandleCapturerPeriodReachedEvent");
596 std::unique_lock<std::mutex> lock(periodReachMutex_);
597 if (capturerPeriodPositionCallback_) {
598 capturerPeriodPositionCallback_->OnPeriodReached(capturerPeriodNumber);
599 }
600 }
601
602 // OnCapturerMarkReach by eventHandler
SendCapturerMarkReachedEvent(int64_t capturerMarkPosition)603 void CapturerInClientInner::SendCapturerMarkReachedEvent(int64_t capturerMarkPosition)
604 {
605 SafeSendCallbackEvent(RENDERER_MARK_REACHED_EVENT, capturerMarkPosition);
606 }
607
608 // OnCapturerPeriodReach by eventHandler
SendCapturerPeriodReachedEvent(int64_t capturerPeriodSize)609 void CapturerInClientInner::SendCapturerPeriodReachedEvent(int64_t capturerPeriodSize)
610 {
611 SafeSendCallbackEvent(RENDERER_PERIOD_REACHED_EVENT, capturerPeriodSize);
612 }
613
ParamsToStateCmdType(int64_t params,State & state,StateChangeCmdType & cmdType)614 int32_t CapturerInClientInner::ParamsToStateCmdType(int64_t params, State &state, StateChangeCmdType &cmdType)
615 {
616 cmdType = CMD_FROM_CLIENT;
617 switch (params) {
618 case HANDLER_PARAM_NEW:
619 state = NEW;
620 break;
621 case HANDLER_PARAM_PREPARED:
622 state = PREPARED;
623 break;
624 case HANDLER_PARAM_RUNNING:
625 state = RUNNING;
626 break;
627 case HANDLER_PARAM_STOPPED:
628 state = STOPPED;
629 break;
630 case HANDLER_PARAM_RELEASED:
631 state = RELEASED;
632 break;
633 case HANDLER_PARAM_PAUSED:
634 state = PAUSED;
635 break;
636 case HANDLER_PARAM_STOPPING:
637 state = STOPPING;
638 break;
639 case HANDLER_PARAM_RUNNING_FROM_SYSTEM:
640 state = RUNNING;
641 cmdType = CMD_FROM_SYSTEM;
642 break;
643 case HANDLER_PARAM_PAUSED_FROM_SYSTEM:
644 state = PAUSED;
645 cmdType = CMD_FROM_SYSTEM;
646 break;
647 default:
648 state = INVALID;
649 break;
650 }
651 return SUCCESS;
652 }
653
StateCmdTypeToParams(int64_t & params,State state,StateChangeCmdType cmdType)654 int32_t CapturerInClientInner::StateCmdTypeToParams(int64_t ¶ms, State state, StateChangeCmdType cmdType)
655 {
656 if (cmdType == CMD_FROM_CLIENT) {
657 params = static_cast<int64_t>(state);
658 return SUCCESS;
659 }
660 switch (state) {
661 case RUNNING:
662 params = HANDLER_PARAM_RUNNING_FROM_SYSTEM;
663 break;
664 case PAUSED:
665 params = HANDLER_PARAM_PAUSED_FROM_SYSTEM;
666 break;
667 default:
668 params = HANDLER_PARAM_INVALID;
669 break;
670 }
671 return SUCCESS;
672 }
673
SafeSendCallbackEvent(uint32_t eventCode,int64_t data)674 void CapturerInClientInner::SafeSendCallbackEvent(uint32_t eventCode, int64_t data)
675 {
676 std::lock_guard<std::mutex> lock(runnerMutex_);
677 AUDIO_INFO_LOG("Send callback event, code: %{public}u, data: %{public}" PRId64 "", eventCode, data);
678 CHECK_AND_RETURN_LOG(callbackHandler_ != nullptr && runnerReleased_ == false, "Runner is Released");
679 callbackHandler_->SendCallbackEvent(eventCode, data);
680 }
681
InitCallbackHandler()682 void CapturerInClientInner::InitCallbackHandler()
683 {
684 if (callbackHandler_ == nullptr) {
685 callbackHandler_ = CallbackHandler::GetInstance(shared_from_this(), "OS_AudioStateCB");
686 }
687 }
688
689 // call this without lock, we should be able to call deinit in any case.
DeinitIpcStream()690 int32_t CapturerInClientInner::DeinitIpcStream()
691 {
692 CHECK_AND_RETURN_RET_LOG(ipcStream_ != nullptr, SUCCESS, "IpcStream is already nullptr");
693 ipcStream_->Release();
694 // in plan:
695 ipcStream_ = nullptr;
696 ringCache_->ResetBuffer();
697 return SUCCESS;
698 }
699
ConstructConfig()700 const AudioProcessConfig CapturerInClientInner::ConstructConfig()
701 {
702 AudioProcessConfig config = {};
703 // in plan: get token id
704 config.appInfo.appPid = clientPid_;
705 config.appInfo.appUid = clientUid_;
706 config.appInfo.appTokenId = appTokenId_;
707 config.appInfo.appFullTokenId = fullTokenId_;
708
709 config.streamInfo.channels = static_cast<AudioChannel>(streamParams_.channels);
710 config.streamInfo.encoding = static_cast<AudioEncodingType>(streamParams_.encoding);
711 config.streamInfo.format = static_cast<AudioSampleFormat>(streamParams_.format);
712 config.streamInfo.samplingRate = static_cast<AudioSamplingRate>(streamParams_.samplingRate);
713 config.streamInfo.channelLayout = static_cast<AudioChannelLayout>(streamParams_.channelLayout);
714 config.originalSessionId = streamParams_.originalSessionId;
715
716 config.audioMode = AUDIO_MODE_RECORD;
717
718 if (capturerInfo_.capturerFlags != 0) {
719 AUDIO_WARNING_LOG("ConstructConfig find Capturer flag invalid:%{public}d", capturerInfo_.capturerFlags);
720 capturerInfo_.capturerFlags = 0;
721 }
722 config.capturerInfo = capturerInfo_;
723
724 config.rendererInfo = {};
725
726 config.streamType = eStreamType_;
727
728 config.isInnerCapturer = isInnerCapturer_;
729 config.isWakeupCapturer = isWakeupCapturer_;
730
731 clientConfig_ = config;
732 return config;
733 }
734
InitSharedBuffer()735 int32_t CapturerInClientInner::InitSharedBuffer()
736 {
737 CHECK_AND_RETURN_RET_LOG(ipcStream_ != nullptr, ERR_OPERATION_FAILED, "InitSharedBuffer failed, null ipcStream_.");
738 int32_t ret = ipcStream_->ResolveBuffer(clientBuffer_);
739 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS && clientBuffer_ != nullptr, ret, "ResolveBuffer failed:%{public}d", ret);
740
741 uint32_t totalSizeInFrame = 0;
742 uint32_t byteSizePerFrame = 0;
743 ret = clientBuffer_->GetSizeParameter(totalSizeInFrame, spanSizeInFrame_, byteSizePerFrame);
744
745 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS && byteSizePerFrame == sizePerFrameInByte_, ret, "ResolveBuffer failed"
746 ":%{public}d", ret);
747
748 clientSpanSizeInByte_ = spanSizeInFrame_ * byteSizePerFrame;
749
750 AUDIO_INFO_LOG("totalSizeInFrame_[%{public}u] spanSizeInFrame_[%{public}u] sizePerFrameInByte_["
751 "%{public}zu] clientSpanSizeInByte_[%{public}zu]", totalSizeInFrame, spanSizeInFrame_, sizePerFrameInByte_,
752 clientSpanSizeInByte_);
753
754 return SUCCESS;
755 }
756
757 // InitCacheBuffer should be able to modify the cache size between clientSpanSizeInByte_ and 4 * clientSpanSizeInByte_
InitCacheBuffer(size_t targetSize)758 int32_t CapturerInClientInner::InitCacheBuffer(size_t targetSize)
759 {
760 CHECK_AND_RETURN_RET_LOG(clientSpanSizeInByte_ != 0, ERR_OPERATION_FAILED, "clientSpanSizeInByte_ invalid");
761
762 AUDIO_INFO_LOG("old size:%{public}zu, new size:%{public}zu", cacheSizeInByte_, targetSize);
763 cacheSizeInByte_ = targetSize;
764
765 if (ringCache_ == nullptr) {
766 ringCache_ = AudioRingCache::Create(cacheSizeInByte_);
767 } else {
768 OptResult result = ringCache_->ReConfig(cacheSizeInByte_, false); // false --> clear buffer
769 if (result.ret != OPERATION_SUCCESS) {
770 AUDIO_ERR_LOG("ReConfig AudioRingCache to size %{public}u failed:ret%{public}zu", result.ret, targetSize);
771 return ERR_OPERATION_FAILED;
772 }
773 }
774
775 return SUCCESS;
776 }
777
InitIpcStream()778 int32_t CapturerInClientInner::InitIpcStream()
779 {
780 AUDIO_INFO_LOG("Init Ipc stream");
781 AudioProcessConfig config = ConstructConfig();
782
783 sptr<IStandardAudioService> gasp = CapturerInClientInner::GetAudioServerProxy();
784 CHECK_AND_RETURN_RET_LOG(gasp != nullptr, ERR_OPERATION_FAILED, "Create failed, can not get service.");
785 int32_t errorCode = 0;
786 sptr<IRemoteObject> ipcProxy = gasp->CreateAudioProcess(config, errorCode);
787 CHECK_AND_RETURN_RET_LOG(errorCode == SUCCESS, errorCode, "failed with create audio stream fail.");
788 CHECK_AND_RETURN_RET_LOG(ipcProxy != nullptr, ERR_OPERATION_FAILED, "failed with null ipcProxy.");
789 ipcStream_ = iface_cast<IpcStream>(ipcProxy);
790 CHECK_AND_RETURN_RET_LOG(ipcStream_ != nullptr, ERR_OPERATION_FAILED, "failed when iface_cast.");
791
792 // in plan: old listener_ is destoried here, will server receive dieth notify?
793 listener_ = sptr<IpcStreamListenerImpl>::MakeSptr(shared_from_this());
794 int32_t ret = ipcStream_->RegisterStreamListener(listener_->AsObject());
795 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "RegisterStreamListener failed:%{public}d", ret);
796
797 ret = InitSharedBuffer();
798 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "InitSharedBuffer failed:%{public}d", ret);
799
800 ret = InitCacheBuffer(clientSpanSizeInByte_);
801 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "InitCacheBuffer failed:%{public}d", ret);
802
803 ret = ipcStream_->GetAudioSessionID(sessionId_);
804 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ret, "GetAudioSessionID failed:%{public}d", ret);
805
806 InitCallbackHandler();
807 return SUCCESS;
808 }
809
GetAudioStreamInfo(AudioStreamParams & info)810 int32_t CapturerInClientInner::GetAudioStreamInfo(AudioStreamParams &info)
811 {
812 CHECK_AND_RETURN_RET_LOG(paramsIsSet_ == true, ERR_OPERATION_FAILED, "Params is not set");
813 info = streamParams_;
814 return SUCCESS;
815 }
816
CheckRecordingCreate(uint32_t appTokenId,uint64_t appFullTokenId,int32_t appUid,SourceType sourceType)817 bool CapturerInClientInner::CheckRecordingCreate(uint32_t appTokenId, uint64_t appFullTokenId, int32_t appUid,
818 SourceType sourceType)
819 {
820 return AudioPolicyManager::GetInstance().CheckRecordingCreate(appTokenId, appFullTokenId, appUid, sourceType);
821 }
822
CheckRecordingStateChange(uint32_t appTokenId,uint64_t appFullTokenId,int32_t appUid,AudioPermissionState state)823 bool CapturerInClientInner::CheckRecordingStateChange(uint32_t appTokenId, uint64_t appFullTokenId, int32_t appUid,
824 AudioPermissionState state)
825 {
826 return AudioPolicyManager::GetInstance().CheckRecordingStateChange(appTokenId, appFullTokenId, appUid, state);
827 }
828
GetAudioSessionID(uint32_t & sessionID)829 int32_t CapturerInClientInner::GetAudioSessionID(uint32_t &sessionID)
830 {
831 CHECK_AND_RETURN_RET_LOG((state_ != RELEASED) && (state_ != NEW), ERR_ILLEGAL_STATE,
832 "State error %{public}d", state_.load());
833 sessionID = sessionId_;
834 return SUCCESS;
835 }
836
GetAudioPipeType(AudioPipeType & pipeType)837 void CapturerInClientInner::GetAudioPipeType(AudioPipeType &pipeType)
838 {
839 pipeType = capturerInfo_.pipeType;
840 }
841
GetState()842 State CapturerInClientInner::GetState()
843 {
844 return state_;
845 }
846
GetAudioTime(Timestamp & timestamp,Timestamp::Timestampbase base)847 bool CapturerInClientInner::GetAudioTime(Timestamp ×tamp, Timestamp::Timestampbase base)
848 {
849 CHECK_AND_RETURN_RET_LOG(paramsIsSet_ == true, false, "Params is not set");
850 CHECK_AND_RETURN_RET_LOG(state_ != STOPPED, false, "Invalid status:%{public}d", state_.load());
851 uint64_t currentReadPos = totalBytesRead_ / sizePerFrameInByte_;
852 timestamp.framePosition = currentReadPos;
853
854 uint64_t writePos = 0;
855 int64_t handleTime = 0;
856 CHECK_AND_RETURN_RET_LOG(clientBuffer_ != nullptr, false, "invalid buffer status");
857 clientBuffer_->GetHandleInfo(writePos, handleTime);
858 if (writePos == 0 || handleTime == 0) {
859 AUDIO_WARNING_LOG("GetHandleInfo may failed");
860 }
861
862 int64_t deltaPos = writePos >= currentReadPos ? static_cast<int64_t>(writePos - currentReadPos) : 0;
863 int64_t tempLatency = 25000000; // 25000000 -> 25 ms
864 int64_t deltaTime = deltaPos * AUDIO_MS_PER_SECOND /
865 static_cast<int64_t>(streamParams_.samplingRate) * AUDIO_US_PER_S;
866
867 handleTime = handleTime + deltaTime + tempLatency;
868 timestamp.time.tv_sec = static_cast<time_t>(handleTime / AUDIO_NS_PER_SECOND);
869 timestamp.time.tv_nsec = static_cast<time_t>(handleTime % AUDIO_NS_PER_SECOND);
870
871 return true;
872 }
873
GetAudioPosition(Timestamp & timestamp,Timestamp::Timestampbase base)874 bool CapturerInClientInner::GetAudioPosition(Timestamp ×tamp, Timestamp::Timestampbase base)
875 {
876 return GetAudioTime(timestamp, base);
877 }
878
GetBufferSize(size_t & bufferSize)879 int32_t CapturerInClientInner::GetBufferSize(size_t &bufferSize)
880 {
881 CHECK_AND_RETURN_RET_LOG(state_ != RELEASED, ERR_ILLEGAL_STATE, "Capturer stream is released");
882 bufferSize = clientSpanSizeInByte_;
883 if (capturerMode_ == CAPTURE_MODE_CALLBACK) {
884 bufferSize = cbBufferSize_;
885 }
886 AUDIO_DEBUG_LOG("Buffer size is %{public}zu, mode is %{public}s", bufferSize, capturerMode_ == CAPTURE_MODE_NORMAL ?
887 "CAPTURE_MODE_NORMAL" : "CAPTURE_MODE_CALLBACK");
888 return SUCCESS;
889 }
890
GetFrameCount(uint32_t & frameCount)891 int32_t CapturerInClientInner::GetFrameCount(uint32_t &frameCount)
892 {
893 CHECK_AND_RETURN_RET_LOG(state_ != RELEASED, ERR_ILLEGAL_STATE, "Capturer stream is released");
894 CHECK_AND_RETURN_RET_LOG(sizePerFrameInByte_ != 0, ERR_ILLEGAL_STATE, "sizePerFrameInByte_ is 0!");
895 frameCount = spanSizeInFrame_;
896 if (capturerMode_ == CAPTURE_MODE_CALLBACK) {
897 frameCount = cbBufferSize_ / sizePerFrameInByte_;
898 }
899 AUDIO_INFO_LOG("Frame count is %{public}u, mode is %{public}s", frameCount, capturerMode_ == CAPTURE_MODE_NORMAL ?
900 "CAPTURE_MODE_NORMAL" : "CAPTURE_MODE_CALLBACK");
901 return SUCCESS;
902 }
903
GetLatency(uint64_t & latency)904 int32_t CapturerInClientInner::GetLatency(uint64_t &latency)
905 {
906 // GetLatency is never called in audio_capturer.cpp
907 latency = 150000; // unit is us, 150000 is 150ms
908 return ERROR;
909 }
910
SetAudioStreamType(AudioStreamType audioStreamType)911 int32_t CapturerInClientInner::SetAudioStreamType(AudioStreamType audioStreamType)
912 {
913 AUDIO_ERR_LOG("Change stream type %{public}d to %{public}d is not supported", eStreamType_, audioStreamType);
914 return ERROR;
915 }
916
SetVolume(float volume)917 int32_t CapturerInClientInner::SetVolume(float volume)
918 {
919 AUDIO_WARNING_LOG("SetVolume is only for renderer");
920 return ERROR;
921 }
922
GetVolume()923 float CapturerInClientInner::GetVolume()
924 {
925 AUDIO_WARNING_LOG("GetVolume is only for renderer");
926 return 0.0;
927 }
928
SetDuckVolume(float volume)929 int32_t CapturerInClientInner::SetDuckVolume(float volume)
930 {
931 AUDIO_WARNING_LOG("only for renderer");
932 return ERROR;
933 }
934
SetSpeed(float speed)935 int32_t CapturerInClientInner::SetSpeed(float speed)
936 {
937 AUDIO_ERR_LOG("SetSpeed is not supported");
938 return ERROR;
939 }
940
GetSpeed()941 float CapturerInClientInner::GetSpeed()
942 {
943 AUDIO_ERR_LOG("GetSpeed is not supported");
944 return 1.0;
945 }
946
ChangeSpeed(uint8_t * buffer,int32_t bufferSize,std::unique_ptr<uint8_t[]> & outBuffer,int32_t & outBufferSize)947 int32_t CapturerInClientInner::ChangeSpeed(uint8_t *buffer, int32_t bufferSize, std::unique_ptr<uint8_t []> &outBuffer,
948 int32_t &outBufferSize)
949 {
950 AUDIO_ERR_LOG("ChangeSpeed is not supported");
951 return ERROR;
952 }
953
SetRenderRate(AudioRendererRate renderRate)954 int32_t CapturerInClientInner::SetRenderRate(AudioRendererRate renderRate)
955 {
956 AUDIO_WARNING_LOG("SetRenderRate is only for renderer");
957 return ERROR;
958 }
959
GetRenderRate()960 AudioRendererRate CapturerInClientInner::GetRenderRate()
961 {
962 AUDIO_WARNING_LOG("GetRenderRate is only for renderer");
963 return RENDER_RATE_NORMAL; // not supported
964 }
965
SetStreamCallback(const std::shared_ptr<AudioStreamCallback> & callback)966 int32_t CapturerInClientInner::SetStreamCallback(const std::shared_ptr<AudioStreamCallback> &callback)
967 {
968 if (callback == nullptr) {
969 AUDIO_ERR_LOG("SetStreamCallback failed. callback == nullptr");
970 return ERR_INVALID_PARAM;
971 }
972
973 std::unique_lock<std::mutex> lock(streamCbMutex_);
974 streamCallback_ = callback;
975 lock.unlock();
976
977 if (state_ != PREPARED) {
978 return SUCCESS;
979 }
980 SafeSendCallbackEvent(STATE_CHANGE_EVENT, PREPARED);
981 return SUCCESS;
982 }
983
SetRenderMode(AudioRenderMode renderMode)984 int32_t CapturerInClientInner::SetRenderMode(AudioRenderMode renderMode)
985 {
986 AUDIO_WARNING_LOG("SetRenderMode is only for renderer");
987 return ERROR;
988 }
989
GetRenderMode()990 AudioRenderMode CapturerInClientInner::GetRenderMode()
991 {
992 AUDIO_WARNING_LOG("GetRenderMode is only for renderer");
993 return RENDER_MODE_NORMAL; // not supported
994 }
995
SetRendererWriteCallback(const std::shared_ptr<AudioRendererWriteCallback> & callback)996 int32_t CapturerInClientInner::SetRendererWriteCallback(const std::shared_ptr<AudioRendererWriteCallback> &callback)
997 {
998 AUDIO_WARNING_LOG("SetRendererWriteCallback is only for renderer");
999 return ERROR;
1000 }
1001
InitCallbackBuffer(uint64_t bufferDurationInUs)1002 void CapturerInClientInner::InitCallbackBuffer(uint64_t bufferDurationInUs)
1003 {
1004 if (bufferDurationInUs > MAX_BUF_DURATION_IN_USEC) {
1005 AUDIO_ERR_LOG("InitCallbackBuffer with invalid duration %{public}" PRIu64", use default instead.",
1006 bufferDurationInUs);
1007 bufferDurationInUs = DEFAULT_BUF_DURATION_IN_USEC;
1008 }
1009 // Calculate buffer size based on duration.
1010 cbBufferSize_ = static_cast<size_t>(bufferDurationInUs * streamParams_.samplingRate / AUDIO_US_PER_S) *
1011 sizePerFrameInByte_;
1012 AUDIO_INFO_LOG("InitCallbackBuffer with duration %{public}" PRIu64", size: %{public}zu", bufferDurationInUs,
1013 cbBufferSize_);
1014 std::lock_guard<std::mutex> lock(cbBufferMutex_);
1015 cbBuffer_ = std::make_unique<uint8_t[]>(cbBufferSize_);
1016 BufferDesc temp = {cbBuffer_.get(), cbBufferSize_, cbBufferSize_};
1017 cbBufferQueue_.Clear();
1018 cbBufferQueue_.Push(temp);
1019 }
1020
SetCaptureMode(AudioCaptureMode captureMode)1021 int32_t CapturerInClientInner::SetCaptureMode(AudioCaptureMode captureMode)
1022 {
1023 AUDIO_INFO_LOG("Set mode to %{public}s", captureMode == CAPTURE_MODE_NORMAL ? "CAPTURE_MODE_NORMAL" :
1024 "CAPTURE_MODE_CALLBACK");
1025 if (capturerMode_ == captureMode) {
1026 return SUCCESS;
1027 }
1028
1029 // capturerMode_ is inited as CAPTURE_MODE_NORMAL, can only be set to CAPTURE_MODE_CALLBACK.
1030 if (capturerMode_ == CAPTURE_MODE_CALLBACK && captureMode == CAPTURE_MODE_NORMAL) {
1031 AUDIO_ERR_LOG("Set capturer mode from callback to normal is not supported.");
1032 return ERR_INCORRECT_MODE;
1033 }
1034
1035 // state check
1036 if (state_ != PREPARED && state_ != NEW) {
1037 AUDIO_ERR_LOG("Set capturer mode failed. invalid state:%{public}d", state_.load());
1038 return ERR_ILLEGAL_STATE;
1039 }
1040 capturerMode_ = captureMode;
1041
1042 // init callbackLoop_
1043 callbackLoop_ = std::thread([this] { this->ReadCallbackFunc(); });
1044 pthread_setname_np(callbackLoop_.native_handle(), "OS_AudioReadCB");
1045
1046 std::unique_lock<std::mutex> threadStartlock(statusMutex_);
1047 bool stopWaiting = cbThreadCv_.wait_for(threadStartlock, std::chrono::milliseconds(SHORT_TIMEOUT_IN_MS), [this] {
1048 return cbThreadReleased_ == false; // When thread is started, cbThreadReleased_ will be false. So stop waiting.
1049 });
1050 if (!stopWaiting) {
1051 AUDIO_WARNING_LOG("Init OS_AudioReadCB thread time out");
1052 }
1053
1054 CHECK_AND_RETURN_RET_LOG(streamParams_.samplingRate != 0, ERR_ILLEGAL_STATE, "invalid sample rate");
1055
1056 uint64_t bufferDurationInUs = spanSizeInFrame_ * AUDIO_US_PER_S / streamParams_.samplingRate;
1057 InitCallbackBuffer(bufferDurationInUs);
1058 return SUCCESS;
1059 }
1060
GetCaptureMode()1061 AudioCaptureMode CapturerInClientInner::GetCaptureMode()
1062 {
1063 AUDIO_INFO_LOG("capturer mode is %{public}s", capturerMode_ == CAPTURE_MODE_NORMAL ? "CAPTURE_MODE_NORMAL" :
1064 "CAPTURE_MODE_CALLBACK");
1065 return capturerMode_;
1066 }
1067
SetCapturerReadCallback(const std::shared_ptr<AudioCapturerReadCallback> & callback)1068 int32_t CapturerInClientInner::SetCapturerReadCallback(const std::shared_ptr<AudioCapturerReadCallback> &callback)
1069 {
1070 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "Invalid null callback");
1071 CHECK_AND_RETURN_RET_LOG(capturerMode_ == CAPTURE_MODE_CALLBACK, ERR_INCORRECT_MODE, "incorrect capturer mode");
1072 std::lock_guard<std::mutex> lock(readCbMutex_);
1073 readCb_ = callback;
1074 return SUCCESS;
1075 }
1076
WaitForRunning()1077 bool CapturerInClientInner::WaitForRunning()
1078 {
1079 Trace trace("CapturerInClientInner::WaitForRunning");
1080 // check capturer state_: call client write only in running else wait on statusMutex_
1081 std::unique_lock<std::mutex> stateLock(statusMutex_);
1082 if (state_ != RUNNING) {
1083 bool stopWaiting = cbThreadCv_.wait_for(stateLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
1084 return state_ == RUNNING || cbThreadReleased_;
1085 });
1086 if (cbThreadReleased_) {
1087 AUDIO_INFO_LOG("CBThread end in non-running status, sessionID :%{public}d", sessionId_);
1088 return false;
1089 }
1090 if (!stopWaiting) {
1091 AUDIO_INFO_LOG("Wait timeout, current state_ is %{public}d", state_.load()); // wait 0.5s
1092 return false;
1093 }
1094 }
1095 return true;
1096 }
1097
ReadCallbackFunc()1098 void CapturerInClientInner::ReadCallbackFunc()
1099 {
1100 AUDIO_INFO_LOG("Thread start, sessionID :%{public}d", sessionId_);
1101 cbThreadReleased_ = false;
1102
1103 // Modify thread priority is not need as first call read will do these work.
1104 cbThreadCv_.notify_one();
1105
1106 // start loop
1107 while (!cbThreadReleased_) {
1108 Trace traceLoop("CapturerInClientInner::WriteCallbackFunc");
1109 if (!WaitForRunning()) {
1110 continue;
1111 }
1112
1113 // If client didn't call GetBufferDesc/Enqueue in OnReadData, pop will block here.
1114 BufferDesc temp = cbBufferQueue_.Pop();
1115 if (temp.buffer == nullptr) {
1116 AUDIO_WARNING_LOG("Queue pop error: get nullptr.");
1117 break;
1118 }
1119
1120 std::unique_lock<std::mutex> lockBuffer(cbBufferMutex_);
1121 // call read here.
1122 int32_t result = Read(*temp.buffer, temp.bufLength, true); // blocking read
1123 if (result < 0 || result != static_cast<int32_t>(cbBufferSize_)) {
1124 AUDIO_WARNING_LOG("Call read error, ret:%{public}d, cbBufferSize_:%{public}zu", result, cbBufferSize_);
1125 }
1126 if (state_ != RUNNING) { continue; }
1127 lockBuffer.unlock();
1128
1129 // call client read
1130 Trace traceCb("CapturerInClientInner::OnReadData");
1131 std::unique_lock<std::mutex> lockCb(readCbMutex_);
1132 if (readCb_ != nullptr) {
1133 readCb_->OnReadData(cbBufferSize_);
1134 }
1135 lockCb.unlock();
1136 traceCb.End();
1137 }
1138 AUDIO_INFO_LOG("CBThread end sessionID :%{public}d", sessionId_);
1139 }
1140
1141
GetBufferDesc(BufferDesc & bufDesc)1142 int32_t CapturerInClientInner::GetBufferDesc(BufferDesc &bufDesc)
1143 {
1144 Trace trace("CapturerInClientInner::GetBufferDesc");
1145 if (capturerMode_ != CAPTURE_MODE_CALLBACK) {
1146 AUDIO_ERR_LOG("Not supported. mode is not callback.");
1147 return ERR_INCORRECT_MODE;
1148 }
1149 std::lock_guard<std::mutex> lock(cbBufferMutex_);
1150 bufDesc.buffer = cbBuffer_.get();
1151 bufDesc.bufLength = cbBufferSize_;
1152 bufDesc.dataLength = cbBufferSize_;
1153 return SUCCESS;
1154 }
1155
GetBufQueueState(BufferQueueState & bufState)1156 int32_t CapturerInClientInner::GetBufQueueState(BufferQueueState &bufState)
1157 {
1158 Trace trace("CapturerInClientInner::GetBufQueueState");
1159 if (capturerMode_ != CAPTURE_MODE_CALLBACK) {
1160 AUDIO_ERR_LOG("Not supported, mode is not callback.");
1161 return ERR_INCORRECT_MODE;
1162 }
1163 // only one buffer in queue.
1164 bufState.numBuffers = 1;
1165 bufState.currentIndex = 0;
1166 return SUCCESS;
1167 }
1168
Enqueue(const BufferDesc & bufDesc)1169 int32_t CapturerInClientInner::Enqueue(const BufferDesc &bufDesc)
1170 {
1171 Trace trace("CapturerInClientInner::Enqueue");
1172 if (capturerMode_ != CAPTURE_MODE_CALLBACK) {
1173 AUDIO_ERR_LOG("Not supported, mode is not callback.");
1174 return ERR_INCORRECT_MODE;
1175 }
1176 std::lock_guard<std::mutex> lock(cbBufferMutex_);
1177
1178 if (bufDesc.bufLength != cbBufferSize_ || bufDesc.dataLength != cbBufferSize_) {
1179 AUDIO_ERR_LOG("Enqueue invalid bufLength:%{public}zu or dataLength:%{public}zu, should be %{public}zu",
1180 bufDesc.bufLength, bufDesc.dataLength, cbBufferSize_);
1181 return ERR_INVALID_INDEX;
1182 }
1183 if (bufDesc.buffer != cbBuffer_.get()) {
1184 AUDIO_WARNING_LOG("Enqueue buffer is not from us.");
1185 }
1186
1187 // if Enqueue is not called in OnReadData, loop thread will block on pop, wait for the Push call here.
1188 BufferDesc temp = {cbBuffer_.get(), cbBufferSize_, cbBufferSize_};
1189 cbBufferQueue_.Push(temp);
1190 // Call read may block, so put it in loop callbackLoop_
1191 return SUCCESS;
1192 }
1193
Clear()1194 int32_t CapturerInClientInner::Clear()
1195 {
1196 Trace trace("CapturerInClientInner::Clear");
1197 if (capturerMode_ != CAPTURE_MODE_CALLBACK) {
1198 AUDIO_ERR_LOG("Not supported, mode is not callback.");
1199 return ERR_INCORRECT_MODE;
1200 }
1201 std::lock_guard<std::mutex> lock(cbBufferMutex_);
1202 int32_t ret = memset_s(cbBuffer_.get(), cbBufferSize_, 0, cbBufferSize_);
1203 CHECK_AND_RETURN_RET_LOG(ret == EOK, ERR_OPERATION_FAILED, "Clear buffer fail, ret %{public}d.", ret);
1204 return SUCCESS;
1205 }
1206
SetLowPowerVolume(float volume)1207 int32_t CapturerInClientInner::SetLowPowerVolume(float volume)
1208 {
1209 AUDIO_WARNING_LOG("SetLowPowerVolume is only for renderer");
1210 return ERROR;
1211 }
1212
GetLowPowerVolume()1213 float CapturerInClientInner::GetLowPowerVolume()
1214 {
1215 AUDIO_WARNING_LOG("GetLowPowerVolume is only for renderer");
1216 return 0.0;
1217 }
1218
SetOffloadMode(int32_t state,bool isAppBack)1219 int32_t CapturerInClientInner::SetOffloadMode(int32_t state, bool isAppBack)
1220 {
1221 AUDIO_WARNING_LOG("SetOffloadMode is only for renderer");
1222 return ERROR;
1223 }
1224
UnsetOffloadMode()1225 int32_t CapturerInClientInner::UnsetOffloadMode()
1226 {
1227 AUDIO_WARNING_LOG("UnsetOffloadMode is only for renderer");
1228 return ERROR;
1229 }
1230
GetSingleStreamVolume()1231 float CapturerInClientInner::GetSingleStreamVolume()
1232 {
1233 AUDIO_WARNING_LOG("GetSingleStreamVolume is only for renderer");
1234 return 0.0;
1235 }
1236
GetAudioEffectMode()1237 AudioEffectMode CapturerInClientInner::GetAudioEffectMode()
1238 {
1239 AUDIO_WARNING_LOG("GetAudioEffectMode is only for renderer");
1240 return EFFECT_NONE;
1241 }
1242
SetAudioEffectMode(AudioEffectMode effectMode)1243 int32_t CapturerInClientInner::SetAudioEffectMode(AudioEffectMode effectMode)
1244 {
1245 AUDIO_WARNING_LOG("SetAudioEffectMode is only for renderer");
1246 return ERROR;
1247 }
1248
GetFramesWritten()1249 int64_t CapturerInClientInner::GetFramesWritten()
1250 {
1251 AUDIO_WARNING_LOG("GetFramesWritten is only for renderer");
1252 return -1;
1253 }
1254
GetFramesRead()1255 int64_t CapturerInClientInner::GetFramesRead()
1256 {
1257 CHECK_AND_RETURN_RET_LOG(sizePerFrameInByte_ != 0, INVALID_FRAME_SIZE, "sizePerFrameInByte_ is 0!");
1258 uint64_t readFrameNumber = totalBytesRead_ / sizePerFrameInByte_;
1259 return readFrameNumber;
1260 }
1261
1262 // Will only take effect before SetAudioStreaminfo
SetInnerCapturerState(bool isInnerCapturer)1263 void CapturerInClientInner::SetInnerCapturerState(bool isInnerCapturer)
1264 {
1265 isInnerCapturer_ = isInnerCapturer;
1266 AUDIO_INFO_LOG("SetInnerCapturerState %{public}s", (isInnerCapturer_ ? "true" : "false"));
1267 return;
1268 }
1269
1270 // Will only take effect before SetAudioStreaminfo
SetWakeupCapturerState(bool isWakeupCapturer)1271 void CapturerInClientInner::SetWakeupCapturerState(bool isWakeupCapturer)
1272 {
1273 isWakeupCapturer_ = isWakeupCapturer;
1274 AUDIO_INFO_LOG("SetWakeupCapturerState %{public}s", (isWakeupCapturer_ ? "true" : "false"));
1275 return;
1276 }
1277
SetCapturerSource(int capturerSource)1278 void CapturerInClientInner::SetCapturerSource(int capturerSource)
1279 {
1280 // capturerSource is kept in capturerInfo_, no need to be set again.
1281 (void)capturerSource;
1282 return;
1283 }
1284
SetPrivacyType(AudioPrivacyType privacyType)1285 void CapturerInClientInner::SetPrivacyType(AudioPrivacyType privacyType)
1286 {
1287 AUDIO_WARNING_LOG("SetPrivacyType is only for renderer");
1288 return;
1289 }
1290
StartAudioStream(StateChangeCmdType cmdType,AudioStreamDeviceChangeReasonExt reason)1291 bool CapturerInClientInner::StartAudioStream(StateChangeCmdType cmdType, AudioStreamDeviceChangeReasonExt reason)
1292 {
1293 Trace trace("CapturerInClientInner::StartAudioStream " + std::to_string(sessionId_));
1294 std::unique_lock<std::mutex> statusLock(statusMutex_);
1295 if (state_ != PREPARED && state_ != STOPPED && state_ != PAUSED) {
1296 AUDIO_ERR_LOG("Start failed Illegal state: %{public}d", state_.load());
1297 return false;
1298 }
1299
1300 if (audioStreamTracker_ && audioStreamTracker_.get()) {
1301 audioStreamTracker_->FetchInputDeviceForTrack(sessionId_, RUNNING, clientPid_, capturerInfo_);
1302 }
1303
1304 CHECK_AND_RETURN_RET_LOG(ipcStream_ != nullptr, false, "ipcStream is not inited!");
1305 int32_t ret = ipcStream_->Start();
1306 if (ret != SUCCESS) {
1307 AUDIO_ERR_LOG("Start call server failed: %{public}u", ret);
1308 return false;
1309 }
1310
1311 std::unique_lock<std::mutex> waitLock(callServerMutex_);
1312 bool stopWaiting = callServerCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
1313 return notifiedOperation_ == START_STREAM; // will be false when got notified.
1314 });
1315
1316 if (notifiedOperation_ != START_STREAM || notifiedResult_ != SUCCESS) {
1317 AUDIO_ERR_LOG("Start failed: %{public}s Operation:%{public}d result:%{public}" PRId64".",
1318 (!stopWaiting ? "timeout" : "no timeout"), notifiedOperation_, notifiedResult_);
1319 return false;
1320 }
1321 waitLock.unlock();
1322
1323 state_ = RUNNING; // change state_ to RUNNING, then notify cbThread
1324 if (capturerMode_ == CAPTURE_MODE_CALLBACK) {
1325 if (cbBufferQueue_.IsEmpty()) {
1326 cbBufferQueue_.Push({cbBuffer_.get(), cbBufferSize_, cbBufferSize_});
1327 }
1328 // start the callback-write thread
1329 cbThreadCv_.notify_all();
1330 }
1331 statusLock.unlock();
1332 // in plan: call HiSysEventWrite
1333 int64_t param = -1;
1334 StateCmdTypeToParams(param, state_, cmdType);
1335 SafeSendCallbackEvent(STATE_CHANGE_EVENT, param);
1336
1337 AUDIO_INFO_LOG("Start SUCCESS, sessionId: %{public}d, uid: %{public}d", sessionId_, clientUid_);
1338 UpdateTracker("RUNNING");
1339 return true;
1340 }
1341
PauseAudioStream(StateChangeCmdType cmdType)1342 bool CapturerInClientInner::PauseAudioStream(StateChangeCmdType cmdType)
1343 {
1344 Trace trace("CapturerInClientInner::PauseAudioStream " + std::to_string(sessionId_));
1345 std::unique_lock<std::mutex> statusLock(statusMutex_);
1346 if (state_ != RUNNING) {
1347 AUDIO_ERR_LOG("Pause State is not RUNNING. Illegal state:%{public}u", state_.load());
1348 return false;
1349 }
1350
1351 CHECK_AND_RETURN_RET_LOG(ipcStream_ != nullptr, false, "ipcStream is not inited!");
1352 int32_t ret = ipcStream_->Pause();
1353 if (ret != SUCCESS) {
1354 AUDIO_ERR_LOG("Pause call server failed:%{public}u", ret);
1355 return false;
1356 }
1357 std::unique_lock<std::mutex> waitLock(callServerMutex_);
1358 bool stopWaiting = callServerCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
1359 return notifiedOperation_ == PAUSE_STREAM; // will be false when got notified.
1360 });
1361
1362 if (notifiedOperation_ != PAUSE_STREAM || notifiedResult_ != SUCCESS) {
1363 AUDIO_ERR_LOG("Pause failed: %{public}s Operation:%{public}d result:%{public}" PRId64".",
1364 (!stopWaiting ? "timeout" : "no timeout"), notifiedOperation_, notifiedResult_);
1365 return false;
1366 }
1367 waitLock.unlock();
1368
1369 state_ = PAUSED;
1370 statusLock.unlock();
1371
1372 // waiting for review: use send event to clent with cmdType | call OnStateChange | call HiSysEventWrite
1373 int64_t param = -1;
1374 StateCmdTypeToParams(param, state_, cmdType);
1375 SafeSendCallbackEvent(STATE_CHANGE_EVENT, param);
1376
1377 AUDIO_INFO_LOG("Pause SUCCESS, sessionId: %{public}d, uid: %{public}d, mode %{public}s", sessionId_, clientUid_,
1378 capturerMode_ == CAPTURE_MODE_NORMAL ? "CAPTURE_MODE_NORMAL" : "CAPTURE_MODE_CALLBACK");
1379 UpdateTracker("PAUSED");
1380 return true;
1381 }
1382
StopAudioStream()1383 bool CapturerInClientInner::StopAudioStream()
1384 {
1385 Trace trace("CapturerInClientInner::StopAudioStream " + std::to_string(sessionId_));
1386 AUDIO_INFO_LOG("Stop begin for sessionId %{public}d uid: %{public}d", sessionId_, clientUid_);
1387 std::unique_lock<std::mutex> statusLock(statusMutex_);
1388 if (state_ == STOPPED) {
1389 AUDIO_INFO_LOG("Capturer in client is already stopped");
1390 return true;
1391 }
1392 if ((state_ != RUNNING) && (state_ != PAUSED)) {
1393 AUDIO_ERR_LOG("Stop failed. Illegal state:%{public}u", state_.load());
1394 return false;
1395 }
1396
1397 CHECK_AND_RETURN_RET_LOG(ipcStream_ != nullptr, false, "ipcStream is not inited!");
1398 int32_t ret = ipcStream_->Stop();
1399 if (ret != SUCCESS) {
1400 AUDIO_ERR_LOG("Stop call server failed:%{public}u", ret);
1401 return false;
1402 }
1403
1404 if (capturerMode_ == CAPTURE_MODE_CALLBACK) {
1405 state_ = STOPPING;
1406 AUDIO_INFO_LOG("Stop begin in callback mode sessionId %{public}d uid: %{public}d", sessionId_, clientUid_);
1407 }
1408
1409 std::unique_lock<std::mutex> waitLock(callServerMutex_);
1410 bool stopWaiting = callServerCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
1411 return notifiedOperation_ == STOP_STREAM; // will be false when got notified.
1412 });
1413
1414 if (notifiedOperation_ != STOP_STREAM || notifiedResult_ != SUCCESS) {
1415 AUDIO_ERR_LOG("Stop failed: %{public}s Operation:%{public}d result:%{public}" PRId64".",
1416 (!stopWaiting ? "timeout" : "no timeout"), notifiedOperation_, notifiedResult_);
1417 state_ = INVALID;
1418 return false;
1419 }
1420 waitLock.unlock();
1421
1422 state_ = STOPPED;
1423 statusLock.unlock();
1424
1425 SafeSendCallbackEvent(STATE_CHANGE_EVENT, state_);
1426
1427 AUDIO_INFO_LOG("Stop SUCCESS, sessionId: %{public}d, uid: %{public}d", sessionId_, clientUid_);
1428 UpdateTracker("STOPPED");
1429 return true;
1430 }
1431
ReleaseAudioStream(bool releaseRunner,bool isSwitchStream)1432 bool CapturerInClientInner::ReleaseAudioStream(bool releaseRunner, bool isSwitchStream)
1433 {
1434 (void)isSwitchStream;
1435 std::unique_lock<std::mutex> statusLock(statusMutex_);
1436 if (state_ == RELEASED) {
1437 AUDIO_WARNING_LOG("Already released, do nothing");
1438 return true;
1439 }
1440 state_ = RELEASED;
1441 statusLock.unlock();
1442
1443 Trace trace("CapturerInClientInner::ReleaseAudioStream " + std::to_string(sessionId_));
1444 if (ipcStream_ != nullptr) {
1445 ipcStream_->Release();
1446 } else {
1447 AUDIO_WARNING_LOG("Release while ipcStream is null");
1448 }
1449
1450 // no lock, call release in any case, include blocked case.
1451 {
1452 std::lock_guard<std::mutex> runnerlock(runnerMutex_);
1453 if (releaseRunner && callbackHandler_ != nullptr) {
1454 AUDIO_INFO_LOG("runner remove");
1455 callbackHandler_->ReleaseEventRunner();
1456 runnerReleased_ = true;
1457 callbackHandler_ = nullptr;
1458 }
1459 }
1460
1461 // clear write callback
1462 if (capturerMode_ == CAPTURE_MODE_CALLBACK) {
1463 cbThreadReleased_ = true; // stop loop
1464 if (cbBufferQueue_.IsEmpty()) {
1465 cbBufferQueue_.PushNoWait({nullptr, 0, 0});
1466 }
1467 cbThreadCv_.notify_all();
1468 readDataCV_.notify_all();
1469 if (callbackLoop_.joinable()) {
1470 callbackLoop_.join();
1471 }
1472 }
1473 paramsIsSet_ = false;
1474
1475 std::unique_lock<std::mutex> lock(streamCbMutex_);
1476 std::shared_ptr<AudioStreamCallback> streamCb = streamCallback_.lock();
1477 if (streamCb != nullptr) {
1478 AUDIO_INFO_LOG("Notify client the state is released");
1479 streamCb->OnStateChange(RELEASED, CMD_FROM_CLIENT);
1480 }
1481 lock.unlock();
1482
1483 UpdateTracker("RELEASED");
1484 AUDIO_INFO_LOG("Release end, sessionId: %{public}d, uid: %{public}d", sessionId_, clientUid_);
1485 return true;
1486 }
1487
FlushAudioStream()1488 bool CapturerInClientInner::FlushAudioStream()
1489 {
1490 Trace trace("CapturerInClientInner::FlushAudioStream " + std::to_string(sessionId_));
1491 std::unique_lock<std::mutex> statusLock(statusMutex_);
1492 if ((state_ != RUNNING) && (state_ != PAUSED) && (state_ != STOPPED)) {
1493 AUDIO_ERR_LOG("Flush failed. Illegal state:%{public}u", state_.load());
1494 return false;
1495 }
1496 CHECK_AND_RETURN_RET_LOG(FlushRingCache() == SUCCESS, false, "Flush cache failed");
1497
1498 CHECK_AND_RETURN_RET_LOG(ipcStream_ != nullptr, false, "ipcStream is not inited!");
1499 int32_t ret = ipcStream_->Flush();
1500 if (ret != SUCCESS) {
1501 AUDIO_ERR_LOG("Flush call server failed:%{public}u", ret);
1502 return false;
1503 }
1504 std::unique_lock<std::mutex> waitLock(callServerMutex_);
1505 bool stopWaiting = callServerCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
1506 return notifiedOperation_ == FLUSH_STREAM; // will be false when got notified.
1507 });
1508
1509 if (notifiedOperation_ != FLUSH_STREAM || notifiedResult_ != SUCCESS) {
1510 AUDIO_ERR_LOG("Flush failed: %{public}s Operation:%{public}d result:%{public}" PRId64".",
1511 (!stopWaiting ? "timeout" : "no timeout"), notifiedOperation_, notifiedResult_);
1512 notifiedOperation_ = MAX_OPERATION_CODE;
1513 return false;
1514 }
1515 notifiedOperation_ = MAX_OPERATION_CODE;
1516 waitLock.unlock();
1517 AUDIO_INFO_LOG("Flush stream SUCCESS, sessionId: %{public}d", sessionId_);
1518 return true;
1519 }
1520
FlushRingCache()1521 int32_t CapturerInClientInner::FlushRingCache()
1522 {
1523 ringCache_->ResetBuffer();
1524 return SUCCESS;
1525 }
1526
DrainAudioStream(bool stopFlag)1527 bool CapturerInClientInner::DrainAudioStream(bool stopFlag)
1528 {
1529 AUDIO_ERR_LOG("Drain is not supported");
1530 return false;
1531 }
1532
SetPreferredFrameSize(int32_t frameSize)1533 void CapturerInClientInner::SetPreferredFrameSize(int32_t frameSize)
1534 {
1535 AUDIO_WARNING_LOG("Not Supported Yet");
1536 }
1537
UpdateLatencyTimestamp(std::string & timestamp,bool isRenderer)1538 void CapturerInClientInner::UpdateLatencyTimestamp(std::string ×tamp, bool isRenderer)
1539 {
1540 sptr<IStandardAudioService> gasp = CapturerInClientInner::GetAudioServerProxy();
1541 if (gasp == nullptr) {
1542 AUDIO_ERR_LOG("LatencyMeas failed to get AudioServerProxy");
1543 return;
1544 }
1545 gasp->UpdateLatencyTimestamp(timestamp, isRenderer);
1546 }
1547
SetRendererFirstFrameWritingCallback(const std::shared_ptr<AudioRendererFirstFrameWritingCallback> & callback)1548 int32_t CapturerInClientInner::SetRendererFirstFrameWritingCallback(
1549 const std::shared_ptr<AudioRendererFirstFrameWritingCallback> &callback)
1550 {
1551 AUDIO_ERR_LOG("SetRendererFirstFrameWritingCallback is not supported for capturer");
1552 return ERR_INVALID_OPERATION;
1553 }
1554
OnFirstFrameWriting()1555 void CapturerInClientInner::OnFirstFrameWriting()
1556 {
1557 AUDIO_ERR_LOG("OnFirstFrameWriting is not supported for capturer");
1558 }
1559
Write(uint8_t * pcmBuffer,size_t pcmBufferSize,uint8_t * metaBuffer,size_t metaBufferSize)1560 int32_t CapturerInClientInner::Write(uint8_t *pcmBuffer, size_t pcmBufferSize, uint8_t *metaBuffer,
1561 size_t metaBufferSize)
1562 {
1563 AUDIO_ERR_LOG("Write is not supported");
1564 return ERR_INVALID_OPERATION;
1565 }
1566
Write(uint8_t * buffer,size_t bufferSize)1567 int32_t CapturerInClientInner::Write(uint8_t *buffer, size_t bufferSize)
1568 {
1569 AUDIO_ERR_LOG("Write is not supported");
1570 return ERR_INVALID_OPERATION;
1571 }
1572
HandleCapturerRead(size_t & readSize,size_t & userSize,uint8_t & buffer,bool isBlockingRead)1573 int32_t CapturerInClientInner::HandleCapturerRead(size_t &readSize, size_t &userSize, uint8_t &buffer,
1574 bool isBlockingRead)
1575 {
1576 Trace trace("CapturerInClientInner::HandleCapturerRead " + std::to_string(userSize));
1577 while (readSize < userSize) {
1578 AUDIO_DEBUG_LOG("readSize %{public}zu < userSize %{public}zu", readSize, userSize);
1579 OptResult result = ringCache_->GetReadableSize();
1580 CHECK_AND_RETURN_RET_LOG(result.ret == OPERATION_SUCCESS, ERROR, "GetReadableSize err %{public}d", result.ret);
1581 size_t readableSize = std::min(result.size, userSize - readSize);
1582 if (readSize + result.size >= userSize) { // If ringCache is sufficient
1583 result = ringCache_->Dequeue({&buffer + (readSize), readableSize});
1584 CHECK_AND_RETURN_RET_LOG(result.ret == OPERATION_SUCCESS, ERROR, "DequeueCache err %{public}d", result.ret);
1585 readSize += readableSize;
1586 return readSize; // data size
1587 }
1588 if (result.size != 0) {
1589 result = ringCache_->Dequeue({&buffer + readSize, result.size});
1590 CHECK_AND_RETURN_RET_LOG(result.ret == OPERATION_SUCCESS, ERROR, "Dequeue failed %{public}d", result.ret);
1591 readSize += result.size;
1592 }
1593 uint64_t availableSizeInFrame = clientBuffer_->GetCurWriteFrame() - clientBuffer_->GetCurReadFrame();
1594 AUDIO_DEBUG_LOG("availableSizeInFrame %{public}" PRId64 "", availableSizeInFrame);
1595 if (availableSizeInFrame > 0) { // If OHAudioBuffer has data
1596 BufferDesc currentOHBuffer_ = {};
1597 clientBuffer_->GetReadbuffer(clientBuffer_->GetCurReadFrame(), currentOHBuffer_);
1598 BufferWrap bufferWrap = {currentOHBuffer_.buffer, clientSpanSizeInByte_};
1599 ringCache_->Enqueue(bufferWrap);
1600 memset_s(static_cast<void *>(bufferWrap.dataPtr), bufferWrap.dataSize, 0, bufferWrap.dataSize);
1601 clientBuffer_->SetCurReadFrame(clientBuffer_->GetCurReadFrame() + spanSizeInFrame_);
1602 } else {
1603 if (!isBlockingRead) {
1604 return readSize; // Return buffer immediately
1605 }
1606 // wait for server read some data
1607 std::unique_lock<std::mutex> readLock(readDataMutex_);
1608 bool isTimeout = !readDataCV_.wait_for(readLock,
1609 std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
1610 return clientBuffer_->GetCurWriteFrame() > clientBuffer_->GetCurReadFrame() || state_ != RUNNING;
1611 });
1612 CHECK_AND_RETURN_RET_LOG(state_ == RUNNING, ERR_ILLEGAL_STATE, "State is not running");
1613 CHECK_AND_RETURN_RET_LOG(isTimeout == false, ERROR, "Wait timeout");
1614 }
1615 }
1616 return readSize;
1617 }
1618
Read(uint8_t & buffer,size_t userSize,bool isBlockingRead)1619 int32_t CapturerInClientInner::Read(uint8_t &buffer, size_t userSize, bool isBlockingRead)
1620 {
1621 Trace trace("CapturerInClientInner::Read " + std::to_string(userSize));
1622
1623 CHECK_AND_RETURN_RET_LOG(userSize < MAX_CLIENT_READ_SIZE && userSize > 0,
1624 ERR_INVALID_PARAM, "invalid size %{public}zu", userSize);
1625
1626 std::unique_lock<std::mutex> statusLock(statusMutex_); // status check
1627 if (state_ != RUNNING) {
1628 if (readLogTimes_ < LOGLITMITTIMES) {
1629 readLogTimes_.fetch_add(1);
1630 AUDIO_ERR_LOG("Illegal state:%{public}u", state_.load());
1631 } else {
1632 AUDIO_DEBUG_LOG("Illegal state:%{public}u", state_.load());
1633 }
1634 return ERR_ILLEGAL_STATE;
1635 } else {
1636 readLogTimes_ = 0;
1637 }
1638
1639 statusLock.unlock();
1640
1641 std::lock_guard<std::mutex> lock(readMutex_);
1642 // if first call, call set thread priority. if thread tid change recall set thread priority
1643 if (needSetThreadPriority_) {
1644 CHECK_AND_RETURN_RET_LOG(ipcStream_ != nullptr, ERROR, "ipcStream_ is null");
1645 ipcStream_->RegisterThreadPriority(gettid(),
1646 AudioSystemManager::GetInstance()->GetSelfBundleName(clientConfig_.appInfo.appUid));
1647 needSetThreadPriority_ = false;
1648 }
1649
1650 size_t readSize = 0;
1651 int32_t res = HandleCapturerRead(readSize, userSize, buffer, isBlockingRead);
1652 CHECK_AND_RETURN_RET_LOG(res >= 0, ERROR, "HandleCapturerRead err : %{public}d", res);
1653 BufferDesc tmpBuffer = {reinterpret_cast<uint8_t *>(&buffer), userSize, userSize};
1654 DfxOperation(tmpBuffer, clientConfig_.streamInfo.format, clientConfig_.streamInfo.channels);
1655 HandleCapturerPositionChanges(readSize);
1656 return readSize;
1657 }
1658
DfxOperation(BufferDesc & buffer,AudioSampleFormat format,AudioChannel channel) const1659 void CapturerInClientInner::DfxOperation(BufferDesc &buffer, AudioSampleFormat format, AudioChannel channel) const
1660 {
1661 ChannelVolumes vols = VolumeTools::CountVolumeLevel(buffer, format, channel);
1662 if (channel == MONO) {
1663 Trace::Count(logUtilsTag_, vols.volStart[0]);
1664 } else {
1665 Trace::Count(logUtilsTag_, (vols.volStart[0] + vols.volStart[1]) / HALF_FACTOR);
1666 }
1667 AudioLogUtils::ProcessVolumeData(logUtilsTag_, vols, volumeDataCount_);
1668 }
1669
HandleCapturerPositionChanges(size_t bytesRead)1670 void CapturerInClientInner::HandleCapturerPositionChanges(size_t bytesRead)
1671 {
1672 totalBytesRead_ += bytesRead;
1673 if (sizePerFrameInByte_ == 0) {
1674 AUDIO_ERR_LOG("HandleCapturerPositionChanges: sizePerFrameInByte_ is 0");
1675 return;
1676 }
1677 uint64_t readFrameNumber = totalBytesRead_ / sizePerFrameInByte_;
1678 AUDIO_DEBUG_LOG("totalBytesRead_ %{public}" PRId64 ", frame size: %{public}zu", totalBytesRead_,
1679 sizePerFrameInByte_);
1680 {
1681 std::lock_guard<std::mutex> lock(markReachMutex_);
1682 if (!capturerMarkReached_) {
1683 AUDIO_DEBUG_LOG("Frame mark position: %{public}" PRId64 ", Total frames read: %{public}" PRId64,
1684 capturerMarkPosition_, static_cast<int64_t>(readFrameNumber));
1685 if (readFrameNumber >= static_cast<uint64_t>(capturerMarkPosition_)) {
1686 AUDIO_DEBUG_LOG("capturerInClient OnMarkReached");
1687 SendCapturerMarkReachedEvent(capturerMarkPosition_);
1688 capturerMarkReached_ = true;
1689 }
1690 }
1691 }
1692
1693 {
1694 std::lock_guard<std::mutex> lock(periodReachMutex_);
1695 capturerPeriodRead_ += static_cast<int64_t>(bytesRead / sizePerFrameInByte_);
1696 AUDIO_DEBUG_LOG("Frame period number: %{public}" PRId64 ", Total frames written: %{public}" PRId64,
1697 static_cast<int64_t>(capturerPeriodRead_), static_cast<int64_t>(totalBytesRead_));
1698 if (capturerPeriodRead_ >= capturerPeriodSize_ && capturerPeriodSize_ > 0) {
1699 capturerPeriodRead_ %= capturerPeriodSize_;
1700 AUDIO_DEBUG_LOG("OnPeriodReached, remaining frames: %{public}" PRId64,
1701 static_cast<int64_t>(capturerPeriodRead_));
1702 SendCapturerPeriodReachedEvent(capturerPeriodSize_);
1703 }
1704 }
1705 }
1706
GetUnderflowCount()1707 uint32_t CapturerInClientInner::GetUnderflowCount()
1708 {
1709 // not supported for capturer
1710 AUDIO_WARNING_LOG("No Underflow in Capturer");
1711 return 0;
1712 }
1713
GetOverflowCount()1714 uint32_t CapturerInClientInner::GetOverflowCount()
1715 {
1716 return overflowCount_;
1717 }
1718
SetUnderflowCount(uint32_t underflowCount)1719 void CapturerInClientInner::SetUnderflowCount(uint32_t underflowCount)
1720 {
1721 // not supported for capturer
1722 AUDIO_WARNING_LOG("No Underflow in Capturer");
1723 return;
1724 }
1725
SetOverflowCount(uint32_t overflowCount)1726 void CapturerInClientInner::SetOverflowCount(uint32_t overflowCount)
1727 {
1728 overflowCount_ = overflowCount;
1729 }
1730
SetCapturerPositionCallback(int64_t markPosition,const std::shared_ptr<CapturerPositionCallback> & callback)1731 void CapturerInClientInner::SetCapturerPositionCallback(int64_t markPosition, const
1732 std::shared_ptr<CapturerPositionCallback> &callback)
1733 {
1734 std::lock_guard<std::mutex> lock(markReachMutex_);
1735 CHECK_AND_RETURN_LOG(callback != nullptr, "CapturerPositionCallback is nullptr");
1736 capturerPositionCallback_ = callback;
1737 capturerMarkPosition_ = markPosition;
1738 capturerMarkReached_ = false;
1739 }
1740
UnsetCapturerPositionCallback()1741 void CapturerInClientInner::UnsetCapturerPositionCallback()
1742 {
1743 std::lock_guard<std::mutex> lock(markReachMutex_);
1744 capturerPositionCallback_ = nullptr;
1745 capturerMarkPosition_ = 0;
1746 capturerMarkReached_ = false;
1747 }
1748
SetCapturerPeriodPositionCallback(int64_t periodPosition,const std::shared_ptr<CapturerPeriodPositionCallback> & callback)1749 void CapturerInClientInner::SetCapturerPeriodPositionCallback(int64_t periodPosition,
1750 const std::shared_ptr<CapturerPeriodPositionCallback> &callback)
1751 {
1752 std::lock_guard<std::mutex> lock(periodReachMutex_);
1753 CHECK_AND_RETURN_LOG(callback != nullptr, "CapturerPeriodPositionCallback is nullptr");
1754 capturerPeriodPositionCallback_ = callback;
1755 capturerPeriodSize_ = periodPosition;
1756 totalBytesRead_ = 0;
1757 capturerPeriodRead_ = 0;
1758 }
1759
UnsetCapturerPeriodPositionCallback()1760 void CapturerInClientInner::UnsetCapturerPeriodPositionCallback()
1761 {
1762 std::lock_guard<std::mutex> lock(periodReachMutex_);
1763 capturerPeriodPositionCallback_ = nullptr;
1764 capturerPeriodSize_ = 0;
1765 totalBytesRead_ = 0;
1766 capturerPeriodRead_ = 0;
1767 }
1768
SetRendererPositionCallback(int64_t markPosition,const std::shared_ptr<RendererPositionCallback> & callback)1769 void CapturerInClientInner::SetRendererPositionCallback(int64_t markPosition,
1770 const std::shared_ptr<RendererPositionCallback> &callback)
1771 {
1772 AUDIO_ERR_LOG("SetRendererPositionCallback is not supported");
1773 return;
1774 }
1775
UnsetRendererPositionCallback()1776 void CapturerInClientInner::UnsetRendererPositionCallback()
1777 {
1778 AUDIO_ERR_LOG("UnsetRendererPositionCallback is not supported");
1779 return;
1780 }
1781
SetRendererPeriodPositionCallback(int64_t periodPosition,const std::shared_ptr<RendererPeriodPositionCallback> & callback)1782 void CapturerInClientInner::SetRendererPeriodPositionCallback(int64_t periodPosition,
1783 const std::shared_ptr<RendererPeriodPositionCallback> &callback)
1784 {
1785 AUDIO_ERR_LOG("SetRendererPeriodPositionCallback is not supported");
1786 return;
1787 }
1788
UnsetRendererPeriodPositionCallback()1789 void CapturerInClientInner::UnsetRendererPeriodPositionCallback()
1790 {
1791 AUDIO_ERR_LOG("UnsetRendererPeriodPositionCallback is not supported");
1792 return;
1793 }
1794
SetRendererSamplingRate(uint32_t sampleRate)1795 int32_t CapturerInClientInner::SetRendererSamplingRate(uint32_t sampleRate)
1796 {
1797 // in plan
1798 return ERROR;
1799 }
1800
GetRendererSamplingRate()1801 uint32_t CapturerInClientInner::GetRendererSamplingRate()
1802 {
1803 // in plan
1804 return 0; // not supported
1805 }
1806
SetBufferSizeInMsec(int32_t bufferSizeInMsec)1807 int32_t CapturerInClientInner::SetBufferSizeInMsec(int32_t bufferSizeInMsec)
1808 {
1809 // bufferSizeInMsec is checked between 5ms and 20ms.
1810 bufferSizeInMsec_ = bufferSizeInMsec;
1811 AUDIO_INFO_LOG("SetBufferSizeInMsec to %{public}d", bufferSizeInMsec_);
1812 if (capturerMode_ == CAPTURE_MODE_CALLBACK) {
1813 uint64_t bufferDurationInUs = static_cast<uint64_t>(bufferSizeInMsec_ * AUDIO_US_PER_MS);
1814 InitCallbackBuffer(bufferDurationInUs);
1815 }
1816 return SUCCESS;
1817 }
1818
SetApplicationCachePath(const std::string cachePath)1819 void CapturerInClientInner::SetApplicationCachePath(const std::string cachePath)
1820 {
1821 cachePath_ = cachePath;
1822 AUDIO_INFO_LOG("SetApplicationCachePath to %{public}s", cachePath_.c_str());
1823 }
1824
SetChannelBlendMode(ChannelBlendMode blendMode)1825 int32_t CapturerInClientInner::SetChannelBlendMode(ChannelBlendMode blendMode)
1826 {
1827 AUDIO_WARNING_LOG("not supported in capturer");
1828 return ERROR;
1829 }
1830
SetVolumeWithRamp(float volume,int32_t duration)1831 int32_t CapturerInClientInner::SetVolumeWithRamp(float volume, int32_t duration)
1832 {
1833 AUDIO_WARNING_LOG("not supported in capturer");
1834 return ERROR;
1835 }
1836
SetStreamTrackerState(bool trackerRegisteredState)1837 void CapturerInClientInner::SetStreamTrackerState(bool trackerRegisteredState)
1838 {
1839 streamTrackerRegistered_ = trackerRegisteredState;
1840 }
1841
GetSwitchInfo(IAudioStream::SwitchInfo & info)1842 void CapturerInClientInner::GetSwitchInfo(IAudioStream::SwitchInfo& info)
1843 {
1844 info.params = streamParams_;
1845
1846 info.rendererInfo = rendererInfo_;
1847 info.capturerInfo = capturerInfo_;
1848 info.eStreamType = eStreamType_;
1849 info.state = state_;
1850 info.sessionId = sessionId_;
1851 info.streamTrackerRegistered = streamTrackerRegistered_;
1852 GetStreamSwitchInfo(info);
1853 }
1854
GetStreamSwitchInfo(IAudioStream::SwitchInfo & info)1855 void CapturerInClientInner::GetStreamSwitchInfo(IAudioStream::SwitchInfo& info)
1856 {
1857 info.cachePath = cachePath_;
1858 info.overFlowCount = overflowCount_;
1859 info.clientPid = clientPid_;
1860 info.clientUid = clientUid_;
1861
1862 info.frameMarkPosition = static_cast<uint64_t>(capturerMarkPosition_);
1863 info.capturePositionCb = capturerPositionCallback_;
1864
1865 info.framePeriodNumber = static_cast<uint64_t>(capturerPeriodSize_);
1866 info.capturePeriodPositionCb = capturerPeriodPositionCallback_;
1867
1868 info.capturerReadCallback = readCb_;
1869 }
1870
GetOffloadEnable()1871 bool CapturerInClientInner::GetOffloadEnable()
1872 {
1873 AUDIO_WARNING_LOG("not supported in capturer");
1874 return false;
1875 }
1876
GetSpatializationEnabled()1877 bool CapturerInClientInner::GetSpatializationEnabled()
1878 {
1879 AUDIO_WARNING_LOG("not supported in capturer");
1880 return false;
1881 }
1882
GetHighResolutionEnabled()1883 bool CapturerInClientInner::GetHighResolutionEnabled()
1884 {
1885 AUDIO_WARNING_LOG("not supported in capturer");
1886 return false;
1887 }
1888
GetStreamClass()1889 IAudioStream::StreamClass CapturerInClientInner::GetStreamClass()
1890 {
1891 return PA_STREAM;
1892 }
1893
SetSilentModeAndMixWithOthers(bool on)1894 void CapturerInClientInner::SetSilentModeAndMixWithOthers(bool on)
1895 {
1896 AUDIO_WARNING_LOG("not supported in capturer");
1897 return;
1898 }
1899
GetSilentModeAndMixWithOthers()1900 bool CapturerInClientInner::GetSilentModeAndMixWithOthers()
1901 {
1902 AUDIO_WARNING_LOG("not supported in capturer");
1903 return false;
1904 }
1905
RestoreAudioStream(bool needStoreState)1906 bool CapturerInClientInner::RestoreAudioStream(bool needStoreState)
1907 {
1908 CHECK_AND_RETURN_RET_LOG(proxyObj_ != nullptr, false, "proxyObj_ is null");
1909 CHECK_AND_RETURN_RET_LOG(state_ != NEW && state_ != INVALID && state_ != RELEASED, true,
1910 "state_ is %{public}d, no need for restore", state_.load());
1911 bool result = false;
1912 State oldState = state_;
1913 state_ = NEW;
1914 SetStreamTrackerState(false);
1915
1916 int32_t ret = SetAudioStreamInfo(streamParams_, proxyObj_);
1917 if (ret != SUCCESS) {
1918 goto error;
1919 }
1920
1921 // for inner-capturer
1922 if (capturerInfo_.sourceType == SOURCE_TYPE_PLAYBACK_CAPTURE) {
1923 ret = UpdatePlaybackCaptureConfig(filterConfig_);
1924 if (ret != SUCCESS) {
1925 goto error;
1926 }
1927 }
1928
1929 switch (oldState) {
1930 case RUNNING:
1931 result = StartAudioStream();
1932 break;
1933 case PAUSED:
1934 result = StartAudioStream() && PauseAudioStream();
1935 break;
1936 case STOPPED:
1937 case STOPPING:
1938 result = StartAudioStream() && StopAudioStream();
1939 break;
1940 default:
1941 break;
1942 }
1943 if (!result) {
1944 goto error;
1945 }
1946 return result;
1947
1948 error:
1949 AUDIO_ERR_LOG("RestoreAudioStream failed");
1950 state_ = oldState;
1951 return false;
1952 }
1953 } // namespace AudioStandard
1954 } // namespace OHOS
1955 #endif // FAST_AUDIO_STREAM_H
1956