1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License")
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "multimedia_audio_capturer_callback.h"
17
18 #include "multimedia_audio_common.h"
19
20 namespace OHOS {
21 namespace AudioStandard {
OnInterrupt(const InterruptEvent & interruptEvent)22 void CjAudioCapturerCallback::OnInterrupt(const InterruptEvent& interruptEvent)
23 {
24 std::lock_guard<std::mutex> lock(cbMutex_);
25 if (interruptEventfunc_ == nullptr) {
26 return;
27 }
28 CInterruptEvent event {};
29 event.eventType = static_cast<int32_t>(interruptEvent.eventType);
30 event.forceType = static_cast<int32_t>(interruptEvent.forceType);
31 event.hintType = static_cast<int32_t>(interruptEvent.hintType);
32 interruptEventfunc_(event);
33 }
34
OnStateChange(const CapturerState state)35 void CjAudioCapturerCallback::OnStateChange(const CapturerState state)
36 {
37 std::lock_guard<std::mutex> lock(cbMutex_);
38 if (stateChangefunc_ == nullptr) {
39 return;
40 }
41 stateChangefunc_(static_cast<int32_t>(state));
42 }
43
RegisterInterruptFunc(std::function<void (CInterruptEvent)> cjCallback)44 void CjAudioCapturerCallback::RegisterInterruptFunc(std::function<void(CInterruptEvent)> cjCallback)
45 {
46 std::lock_guard<std::mutex> lock(cbMutex_);
47 interruptEventfunc_ = cjCallback;
48 }
49
RegisterStateChangeFunc(std::function<void (int32_t)> cjCallback)50 void CjAudioCapturerCallback::RegisterStateChangeFunc(std::function<void(int32_t)> cjCallback)
51 {
52 std::lock_guard<std::mutex> lock(cbMutex_);
53 stateChangefunc_ = cjCallback;
54 }
55
RegisterFunc(std::function<void (int64_t)> cjCallback)56 void CjCapturerPositionCallback::RegisterFunc(std::function<void(int64_t)> cjCallback)
57 {
58 std::lock_guard<std::mutex> lock(cbMutex_);
59 func_ = cjCallback;
60 }
61
OnMarkReached(const int64_t & framePosition)62 void CjCapturerPositionCallback::OnMarkReached(const int64_t& framePosition)
63 {
64 std::lock_guard<std::mutex> lock(cbMutex_);
65 if (func_ != nullptr) {
66 func_(framePosition);
67 }
68 }
69
RegisterFunc(std::function<void (int64_t)> cjCallback)70 void CjCapturerPeriodPositionCallback::RegisterFunc(std::function<void(int64_t)> cjCallback)
71 {
72 std::lock_guard<std::mutex> lock(cbMutex_);
73 func_ = cjCallback;
74 }
OnPeriodReached(const int64_t & frameNumber)75 void CjCapturerPeriodPositionCallback::OnPeriodReached(const int64_t& frameNumber)
76 {
77 std::lock_guard<std::mutex> lock(cbMutex_);
78 if (func_ != nullptr) {
79 func_(frameNumber);
80 }
81 }
82
RegisterFunc(std::function<void (CArrUI8)> cjCallback,std::shared_ptr<AudioCapturer> audioCapturer)83 void CjAudioCapturerReadCallback::RegisterFunc(
84 std::function<void(CArrUI8)> cjCallback, std::shared_ptr<AudioCapturer> audioCapturer)
85 {
86 std::lock_guard<std::mutex> lock(cbMutex_);
87 func_ = cjCallback;
88 audioCapturer_ = audioCapturer;
89 }
90
OnReadData(size_t length)91 void CjAudioCapturerReadCallback::OnReadData(size_t length)
92 {
93 std::lock_guard<std::mutex> lock(cbMutex_);
94 if (func_ == nullptr) {
95 return;
96 }
97 CArrUI8 arr {};
98 BufferDesc buf {};
99 audioCapturer_->GetBufferDesc(buf);
100 if (buf.buffer == nullptr) {
101 return;
102 }
103 arr.size = std::min(length, buf.bufLength);
104 int32_t mallocSize = static_cast<int32_t>(sizeof(uint8_t)) * static_cast<int32_t>(arr.size);
105 if (mallocSize <= 0 || mallocSize > static_cast<int32_t>(sizeof(uint8_t) * MAX_MEM_MALLOC_SIZE)) {
106 return;
107 }
108 arr.head = static_cast<uint8_t*>(malloc(mallocSize));
109 if (arr.head == nullptr) {
110 return;
111 }
112 if (memset_s(arr.head, mallocSize, 0, mallocSize) != EOK) {
113 free(arr.head);
114 arr.head = nullptr;
115 return;
116 }
117 for (int32_t i = 0; i < static_cast<int32_t>(arr.size); i++) {
118 arr.head[i] = buf.buffer[i];
119 }
120 func_(arr);
121 free(arr.head);
122 arr.head = nullptr;
123 }
124
RegisterFunc(std::function<void (CAudioCapturerChangeInfo)> cjCallback)125 void CjAudioCapturerInfoChangeCallback::RegisterFunc(std::function<void(CAudioCapturerChangeInfo)> cjCallback)
126 {
127 std::lock_guard<std::mutex> lock(cbMutex_);
128 func_ = cjCallback;
129 }
130
OnStateChange(const AudioCapturerChangeInfo & capturerChangeInfo)131 void CjAudioCapturerInfoChangeCallback::OnStateChange(const AudioCapturerChangeInfo& capturerChangeInfo)
132 {
133 std::lock_guard<std::mutex> lock(cbMutex_);
134 if (func_ == nullptr) {
135 return;
136 }
137 CAudioCapturerChangeInfo cInfo {};
138 int32_t errorCode = SUCCESS_CODE;
139 Convert2CAudioCapturerChangeInfo(cInfo, capturerChangeInfo, &errorCode);
140 if (errorCode != SUCCESS_CODE) {
141 FreeCArrDeviceDescriptor(cInfo.deviceDescriptors);
142 return;
143 }
144 func_(cInfo);
145 FreeCArrDeviceDescriptor(cInfo.deviceDescriptors);
146 }
147
RegisterFunc(std::function<void (CArrDeviceDescriptor)> cjCallback)148 void CjAudioCapturerDeviceChangeCallback::RegisterFunc(std::function<void(CArrDeviceDescriptor)> cjCallback)
149 {
150 std::lock_guard<std::mutex> lock(cbMutex_);
151 func_ = cjCallback;
152 }
153
OnStateChange(const AudioDeviceDescriptor & deviceInfo)154 void CjAudioCapturerDeviceChangeCallback::OnStateChange(const AudioDeviceDescriptor& deviceInfo)
155 {
156 std::lock_guard<std::mutex> lock(cbMutex_);
157 if (func_ == nullptr) {
158 return;
159 }
160 CArrDeviceDescriptor arr {};
161 int32_t errorCode = SUCCESS_CODE;
162 Convert2CArrDeviceDescriptorByDeviceInfo(arr, deviceInfo, &errorCode);
163 if (errorCode != SUCCESS_CODE) {
164 FreeCArrDeviceDescriptor(arr);
165 return;
166 }
167 func_(arr);
168 FreeCArrDeviceDescriptor(arr);
169 }
170 } // namespace AudioStandard
171 } // namespace OHOS
172