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 #include "multimedia_audio_common.h"
18
19 namespace OHOS {
20 namespace AudioStandard {
OnInterrupt(const InterruptEvent & interruptEvent)21 void CjAudioCapturerCallback::OnInterrupt(const InterruptEvent &interruptEvent)
22 {
23 std::lock_guard<std::mutex> lock(cbMutex_);
24 if (interruptEventfunc_ == nullptr) {
25 return;
26 }
27 CInterruptEvent event{};
28 event.eventType = static_cast<int32_t>(interruptEvent.eventType);
29 event.forceType = static_cast<int32_t>(interruptEvent.forceType);
30 event.hintType = static_cast<int32_t>(interruptEvent.hintType);
31 interruptEventfunc_(event);
32 }
33
OnStateChange(const CapturerState state)34 void CjAudioCapturerCallback::OnStateChange(const CapturerState state)
35 {
36 std::lock_guard<std::mutex> lock(cbMutex_);
37 if (stateChangefunc_ == nullptr) {
38 return;
39 }
40 stateChangefunc_(static_cast<int32_t>(state));
41 }
42
RegisterInterruptFunc(std::function<void (CInterruptEvent)> cjCallback)43 void CjAudioCapturerCallback::RegisterInterruptFunc(std::function<void(CInterruptEvent)> cjCallback)
44 {
45 interruptEventfunc_ = cjCallback;
46 }
47
RegisterStateChangeFunc(std::function<void (int32_t)> cjCallback)48 void CjAudioCapturerCallback::RegisterStateChangeFunc(std::function<void(int32_t)> cjCallback)
49 {
50 stateChangefunc_ = cjCallback;
51 }
52
RegisterFunc(std::function<void (int64_t)> cjCallback)53 void CjCapturerPositionCallback::RegisterFunc(std::function<void(int64_t)> cjCallback)
54 {
55 func_ = cjCallback;
56 }
57
OnMarkReached(const int64_t & framePosition)58 void CjCapturerPositionCallback::OnMarkReached(const int64_t &framePosition)
59 {
60 std::lock_guard<std::mutex> lock(cbMutex_);
61 if (func_ != nullptr) {
62 func_(framePosition);
63 }
64 }
65
RegisterFunc(std::function<void (int64_t)> cjCallback)66 void CjCapturerPeriodPositionCallback::RegisterFunc(std::function<void(int64_t)> cjCallback)
67 {
68 func_ = cjCallback;
69 }
OnPeriodReached(const int64_t & frameNumber)70 void CjCapturerPeriodPositionCallback::OnPeriodReached(const int64_t &frameNumber)
71 {
72 std::lock_guard<std::mutex> lock(cbMutex_);
73 if (func_ != nullptr) {
74 func_(frameNumber);
75 }
76 }
77
RegisterFunc(std::function<void (CArrUI8)> cjCallback,std::shared_ptr<AudioCapturer> audioCapturer)78 void CjAudioCapturerReadCallback::RegisterFunc(std::function<void(CArrUI8)> cjCallback,
79 std::shared_ptr<AudioCapturer> audioCapturer)
80 {
81 func_ = cjCallback;
82 audioCapturer_ = audioCapturer;
83 }
84
OnReadData(size_t length)85 void CjAudioCapturerReadCallback::OnReadData(size_t length)
86 {
87 std::lock_guard<std::mutex> lock(cbMutex_);
88 if (func_ == nullptr) {
89 return;
90 }
91 CArrUI8 arr{};
92 BufferDesc buf{};
93 audioCapturer_->GetBufferDesc(buf);
94 if (buf.buffer == nullptr) {
95 return;
96 }
97 arr.size = std::min(length, buf.bufLength);
98 int32_t mallocSize = static_cast<int32_t>(sizeof(uint8_t)) * static_cast<int32_t>(arr.size);
99 if (mallocSize <= 0 || mallocSize > static_cast<int32_t>(sizeof(uint8_t) * MAX_MEM_MALLOC_SIZE)) {
100 FreeBufferDesc(buf);
101 return;
102 }
103 arr.head = static_cast<uint8_t *>(malloc(mallocSize));
104 if (arr.head == nullptr) {
105 FreeBufferDesc(buf);
106 return;
107 }
108 if (memset_s(arr.head, mallocSize, 0, mallocSize) != EOK) {
109 free(arr.head);
110 arr.head = nullptr;
111 FreeBufferDesc(buf);
112 return;
113 }
114 for (int32_t i = 0; i < static_cast<int32_t>(arr.size); i++) {
115 arr.head[i] = buf.buffer[i];
116 }
117 func_(arr);
118 free(arr.head);
119 arr.head = nullptr;
120 FreeBufferDesc(buf);
121 }
122
RegisterFunc(std::function<void (CAudioCapturerChangeInfo)> cjCallback)123 void CjAudioCapturerInfoChangeCallback::RegisterFunc(std::function<void(CAudioCapturerChangeInfo)> cjCallback)
124 {
125 func_ = cjCallback;
126 }
127
OnStateChange(const AudioCapturerChangeInfo & capturerChangeInfo)128 void CjAudioCapturerInfoChangeCallback::OnStateChange(const AudioCapturerChangeInfo &capturerChangeInfo)
129 {
130 std::lock_guard<std::mutex> lock(cbMutex_);
131 if (func_ == nullptr) {
132 return;
133 }
134 CAudioCapturerChangeInfo cInfo{};
135 int32_t errorCode = SUCCESS_CODE;
136 Convert2CAudioCapturerChangeInfo(cInfo, capturerChangeInfo, &errorCode);
137 if (errorCode != SUCCESS_CODE) {
138 FreeCArrDeviceDescriptor(cInfo.deviceDescriptors);
139 return;
140 }
141 func_(cInfo);
142 FreeCArrDeviceDescriptor(cInfo.deviceDescriptors);
143 }
144
RegisterFunc(std::function<void (CArrDeviceDescriptor)> cjCallback)145 void CjAudioCapturerDeviceChangeCallback::RegisterFunc(std::function<void(CArrDeviceDescriptor)> cjCallback)
146 {
147 func_ = cjCallback;
148 }
149
OnStateChange(const AudioDeviceDescriptor & deviceInfo)150 void CjAudioCapturerDeviceChangeCallback::OnStateChange(const AudioDeviceDescriptor &deviceInfo)
151 {
152 std::lock_guard<std::mutex> lock(cbMutex_);
153 if (func_ == nullptr) {
154 return;
155 }
156 CArrDeviceDescriptor arr{};
157 int32_t errorCode = SUCCESS_CODE;
158 Convert2CArrDeviceDescriptorByDeviceInfo(arr, deviceInfo, &errorCode);
159 if (errorCode != SUCCESS_CODE) {
160 FreeCArrDeviceDescriptor(arr);
161 return;
162 }
163 func_(arr);
164 FreeCArrDeviceDescriptor(arr);
165 }
166 } // namespace AudioStandard
167 } // namespace OHOS
168