1 /*
2 * Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
3 */
4 /*
5 * Copyright (C) 2024 Huawei Device Co., Ltd.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18
19 #include "lpp_audio_streamer.h"
20 #include "lppCallback.h"
21 #include "multimedia/player_framework/lowpower_audio_sink.h"
22 #include "multimedia/player_framework/lowpower_audio_sink_base.h"
23
24 #undef LOG_TAG
25 #define LOG_TAG "LppAudioStreamer"
26
~LppAudioStreamer()27 LppAudioStreamer::~LppAudioStreamer()
28 {
29 if (lppAudioStreamer_ != nullptr) {
30 AVCODEC_SAMPLE_LOGI("lppAudioStreamer_ is nullptr");
31 Release();
32 }
33 }
34
Create(const std::string & codecMime)35 int32_t LppAudioStreamer::Create(const std::string &codecMime)
36 {
37 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ Create ======");
38 lppAudioStreamer_ = OH_LowPowerAudioSink_CreateByMime(codecMime.c_str());
39 AVCODEC_SAMPLE_LOGI("codecMime.c_str() %{public}s", codecMime.c_str());
40 CHECK_AND_RETURN_RET_LOG(lppAudioStreamer_ != nullptr, AVCODEC_SAMPLE_ERR_ERROR, "Create failed");
41 return AVCODEC_SAMPLE_ERR_OK;
42 }
43
SetCallbackCreateNull(LppUserData * lppUserData)44 int32_t LppAudioStreamer::SetCallbackCreateNull(LppUserData *lppUserData)
45 {
46 int32_t ret = AV_ERR_OK;
47 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ SetCallbackCreateNull ======");
48 lppAudioStreamerCallback_ = OH_LowPowerAudioSinkCallback_Create();
49 lppAudioStreamerCallback_ = nullptr;
50 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ RegisterCallbackNull ======");
51 ret = OH_LowPowerAudioSink_RegisterCallback(lppAudioStreamer_, lppAudioStreamerCallback_);
52 AVCODEC_SAMPLE_LOGI("RegisterCallbackNull ret:::%{public}d ", ret);
53 return ret;
54 }
SetCallbackCreate(LppUserData * lppUserData)55 int32_t LppAudioStreamer::SetCallbackCreate(LppUserData *lppUserData)
56 {
57 int32_t ret = AV_ERR_OK;
58 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ SetCallbackCreate ======");
59 lppAudioStreamerCallback_ = OH_LowPowerAudioSinkCallback_Create();
60 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ RegisterCallback ======");
61 ret = OH_LowPowerAudioSink_RegisterCallback(lppAudioStreamer_, lppAudioStreamerCallback_);
62 CHECK_AND_RETURN_RET_LOG(ret == AV_ERR_OK, ret, "Set callback failed, ret::: %{public}d", ret);
63
64 AVCODEC_SAMPLE_LOGI("RegisterCallback ret:::%{public}d ", ret);
65 return ret;
66 }
SetDataNeededListener(LppUserData * lppUserData)67 int32_t LppAudioStreamer::SetDataNeededListener(LppUserData *lppUserData)
68 {
69 int32_t ret = AV_ERR_OK;
70 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ SetDataNeededListener ======");
71 ret = OH_LowPowerAudioSinkCallback_SetDataNeededListener(lppAudioStreamerCallback_,
72 LppCallback::OnDataNeeded, lppUserData);
73 AVCODEC_SAMPLE_LOGI("SetDataNeededListener ret:::%{public}d ", ret);
74 return ret;
75 }
SetPositionUpdateListener(LppUserData * lppUserData)76 int32_t LppAudioStreamer::SetPositionUpdateListener(LppUserData *lppUserData)
77 {
78 int32_t ret = AV_ERR_OK;
79 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ SetPositionUpdateListener ======");
80 ret = OH_LowPowerAudioSinkCallback_SetPositionUpdateListener(lppAudioStreamerCallback_,
81 LppCallback::OnPositionUpdated, lppUserData);
82 AVCODEC_SAMPLE_LOGI("SetPositionUpdateListener ret:::%{public}d ", ret);
83 return ret;
84 }
SetCallback(LppUserData * lppUserData)85 int32_t LppAudioStreamer::SetCallback(LppUserData *lppUserData)
86 {
87 int32_t ret = AV_ERR_OK;
88 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ SetCallback ======");
89 lppAudioStreamerCallback_ = OH_LowPowerAudioSinkCallback_Create();
90 ret = OH_LowPowerAudioSinkCallback_SetDataNeededListener(lppAudioStreamerCallback_,
91 LppCallback::OnDataNeeded, lppUserData);
92 AVCODEC_SAMPLE_LOGI("SetDataNeededListener ret:::%{public}d ", ret);
93 ret = OH_LowPowerAudioSinkCallback_SetPositionUpdateListener(lppAudioStreamerCallback_,
94 LppCallback::OnPositionUpdated, lppUserData);
95 AVCODEC_SAMPLE_LOGI("SetPositionUpdateListener ret:::%{public}d ", ret);
96 ret = OH_LowPowerAudioSink_RegisterCallback(lppAudioStreamer_, lppAudioStreamerCallback_);
97 CHECK_AND_RETURN_RET_LOG(ret == AV_ERR_OK, ret, "Set callback failed, ret::: %{public}d", ret);
98
99 AVCODEC_SAMPLE_LOGI("RegisterCallback ret:::%{public}d ", ret);
100 return ret;
101 }
102
SetErrorCallback(LppUserData * lppUserData)103 int32_t LppAudioStreamer::SetErrorCallback(LppUserData *lppUserData)
104 {
105 int32_t ret = AV_ERR_OK;
106 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ SetErrorCallback ======");
107 ret = OH_LowPowerAudioSinkCallback_SetErrorListener(lppAudioStreamerCallback_, LppCallback::OnAudioError,
108 lppUserData);
109 CHECK_AND_RETURN_RET_LOG(ret == AV_ERR_OK, ret, "Set callback failed, ret::: %{public}d", ret);
110 AVCODEC_SAMPLE_LOGI("OnAudioError ret:::%{public}d ", ret);
111 return ret;
112 }
SetInterruptListener(LppUserData * lppUserData)113 int32_t LppAudioStreamer::SetInterruptListener(LppUserData *lppUserData)
114 {
115 int32_t ret = AV_ERR_OK;
116 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ SetInterruptListener ======");
117 ret = OH_LowPowerAudioSinkCallback_SetInterruptListener(lppAudioStreamerCallback_,
118 LppCallback::OnInterrupted, lppUserData);
119 CHECK_AND_RETURN_RET_LOG(ret == AV_ERR_OK, ret, "Set callback failed, ret::: %{public}d", ret);
120 AVCODEC_SAMPLE_LOGI("OnInterrupted ret:::%{public}d ", ret);
121 return ret;
122 }
123
SetEosCallback(LppUserData * lppUserData)124 int32_t LppAudioStreamer::SetEosCallback(LppUserData *lppUserData)
125 {
126 int32_t ret = AV_ERR_OK;
127 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ SetEosCallback ======");
128 ret = OH_LowPowerAudioSinkCallback_SetEosListener(lppAudioStreamerCallback_, LppCallback::OnEos,
129 lppUserData);
130 CHECK_AND_RETURN_RET_LOG(ret == AV_ERR_OK, ret, "Set callback failed, ret::: %{public}d", ret);
131 AVCODEC_SAMPLE_LOGI("OnEos ret:::%{public}d ", ret);
132 return ret;
133 }
134
SetOnDeviceChanged(LppUserData * lppUserData)135 int32_t LppAudioStreamer::SetOnDeviceChanged(LppUserData *lppUserData)
136 {
137 int32_t ret = AV_ERR_OK;
138 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ SetOnDeviceChanged ======");
139 ret = OH_LowPowerAudioSinkCallback_SetDeviceChangeListener(lppAudioStreamerCallback_, LppCallback::OnDeviceChanged,
140 lppUserData);
141 CHECK_AND_RETURN_RET_LOG(ret == AV_ERR_OK, ret, "Set callback failed, ret::: %{public}d", ret);
142 AVCODEC_SAMPLE_LOGI("OnDeviceChanged ret:::%{public}d ", ret);
143 return ret;
144 }
145
Configure(const SampleInfo & sampleInfo)146 int32_t LppAudioStreamer::Configure(const SampleInfo &sampleInfo)
147 {
148 OH_AVFormat *format = OH_AVFormat_Create();
149 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ Configure ======");
150 if (sampleInfo.audioCodecConfig != nullptr) {
151 OH_AVFormat_SetBuffer(format, "codec_config", sampleInfo.audioCodecConfig, sampleInfo.audioCodecSize);
152 }
153 const int STREAM_USAGE_ASYNC = 10;
154 OH_AVFormat_SetIntValue(format, "STREAM_USAGE", STREAM_USAGE_ASYNC);
155 OH_AVFormat_SetIntValue(format, "SAMPLE_RATE", sampleInfo.audioSampleRate);
156 AVCODEC_SAMPLE_LOGI("audioSampleRate %{public}d", sampleInfo.audioSampleRate);
157 const int RENDERER_FLAG_ASYNC = 5;
158 OH_AVFormat_SetIntValue(format, "RENDERER_FLAG", RENDERER_FLAG_ASYNC);
159 // ENCODING_PCM = 0,
160 const int ENCODING_PCM = 0;
161 OH_AVFormat_SetIntValue(format, "ENCODING", ENCODING_PCM);
162 // SAMPLE_S16LE = 1,
163 OH_AVFormat_SetIntValue(format, "SAMPLE_FORMAT", SAMPLE_S16LE);
164 // CHANNEL_6 = 6,
165 OH_AVFormat_SetIntValue(format, "CHANNEL", sampleInfo.audioChannelCount);
166
167 // 音频解码
168 OH_AVFormat_SetIntValue(format, "audio_sample_format", SAMPLE_S16LE);
169
170 OH_AVFormat_SetIntValue(format, "channel_count", sampleInfo.audioChannelCount);
171 AVCODEC_SAMPLE_LOGI("audioChannelCount %{public}d", sampleInfo.audioChannelCount);
172 OH_AVFormat_SetIntValue(format, "sample_rate", sampleInfo.audioSampleRate);
173 OH_AVFormat_SetLongValue(format, "channel_layout", sampleInfo.audioChannelLayout);
174 int ret = OH_LowPowerAudioSink_Configure(lppAudioStreamer_, format);
175 CHECK_AND_RETURN_RET_LOG(ret == AV_ERR_OK, ret, "Configure failed, ret::: %{public}d", ret);
176 return ret;
177 }
178
SetVolume(const float volume)179 int32_t LppAudioStreamer::SetVolume(const float volume)
180 {
181 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ SetVolume ======");
182 int ret = OH_LowPowerAudioSink_SetVolume(lppAudioStreamer_, volume);
183 CHECK_AND_RETURN_RET_LOG(ret == AV_ERR_OK, ret, "SetVolume failed, ret::: %{public}d", ret);
184 return ret;
185 }
186
SetPlayBackSpeed(const float speed)187 int32_t LppAudioStreamer::SetPlayBackSpeed(const float speed)
188 {
189 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ SetPlayBackSpeed ======");
190 int ret = OH_LowPowerAudioSink_SetPlaybackSpeed(lppAudioStreamer_, speed);
191 CHECK_AND_RETURN_RET_LOG(ret == AV_ERR_OK, ret, "SetSpeed failed, ret::: %{public}d", ret);
192 return ret;
193 }
194
195
Start()196 int32_t LppAudioStreamer::Start()
197 {
198 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ Start ======");
199 int ret = OH_LowPowerAudioSink_Start(lppAudioStreamer_);
200 CHECK_AND_RETURN_RET_LOG(ret == AV_ERR_OK, ret, "Start failed, ret::: %{public}d", ret);
201 return ret;
202 }
203
returnFrames(LppUserData * lppUserData)204 int32_t LppAudioStreamer::returnFrames(LppUserData *lppUserData)
205 {
206 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ returnFrames ======");
207 int ret = OH_LowPowerAudioSink_ReturnSamples(lppAudioStreamer_, lppUserData->framePacket_);
208 return ret;
209 }
210
SetParameter(const SampleInfo & sampleInfo)211 int32_t LppAudioStreamer::SetParameter(const SampleInfo &sampleInfo)
212 {
213 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ SetParameter ======");
214 OH_AVFormat *format = OH_AVFormat_Create();
215 if (sampleInfo.audioCodecConfig != nullptr) {
216 OH_AVFormat_SetBuffer(format, "codec_config", sampleInfo.audioCodecConfig, sampleInfo.audioCodecSize);
217 }
218 const int STREAM_USAGE_ASYNC = 10;
219 OH_AVFormat_SetIntValue(format, "STREAM_USAGE", STREAM_USAGE_ASYNC);
220 OH_AVFormat_SetIntValue(format, "SAMPLE_RATE", sampleInfo.audioSampleRate);
221 AVCODEC_SAMPLE_LOGI("audioSampleRate %{public}d", sampleInfo.audioSampleRate);
222 const int RENDERER_FLAG_ASYNC = 5;
223 OH_AVFormat_SetIntValue(format, "RENDERER_FLAG", RENDERER_FLAG_ASYNC);
224 // ENCODING_PCM = 0,
225 const int ENCODING_PCM = 0;
226 OH_AVFormat_SetIntValue(format, "ENCODING", ENCODING_PCM);
227 // SAMPLE_S16LE = 1,
228 OH_AVFormat_SetIntValue(format, "SAMPLE_FORMAT", SAMPLE_S16LE);
229 // CHANNEL_6 = 6,
230 OH_AVFormat_SetIntValue(format, "CHANNEL", sampleInfo.audioChannelCount);
231
232 // 音频解码
233 OH_AVFormat_SetIntValue(format, "audio_sample_format", SAMPLE_S16LE);
234 OH_AVFormat_SetIntValue(format, "channel_count", sampleInfo.audioChannelCount);
235 AVCODEC_SAMPLE_LOGI("audioChannelCount %{public}d", sampleInfo.audioChannelCount);
236 OH_AVFormat_SetIntValue(format, "sample_rate", sampleInfo.audioSampleRate);
237 OH_AVFormat_SetLongValue(format, "channel_layout", sampleInfo.audioChannelLayout);
238 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ SetParameter ======");
239 int ret = OH_LowPowerAudioSink_SetParameter(lppAudioStreamer_, format);
240 return ret;
241 }
242
GetParameter(const SampleInfo & sampleInfo)243 int32_t LppAudioStreamer::GetParameter(const SampleInfo &sampleInfo)
244 {
245 AVCODEC_SAMPLE_LOGI("====== LppAudioStreamer GetParameter ======");
246 OH_AVFormat *format = OH_AVFormat_Create();
247 CHECK_AND_RETURN_RET_LOG(format != nullptr, AVCODEC_SAMPLE_ERR_ERROR, "AVFormat create failed");
248 int ret = OH_LowPowerAudioSink_GetParameter(lppAudioStreamer_, format);
249 CHECK_AND_RETURN_RET_LOG(ret == AV_ERR_OK, ret, "Configure failed, ret::: %{public}d", ret);
250 return ret;
251 }
Prepare()252 int32_t LppAudioStreamer::Prepare()
253 {
254 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ Prepare ======");
255 int ret = OH_LowPowerAudioSink_Prepare(lppAudioStreamer_);
256 return ret;
257 }
258
Pause()259 int32_t LppAudioStreamer::Pause()
260 {
261 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ Pause ======");
262 int ret = OH_LowPowerAudioSink_Pause(lppAudioStreamer_);
263 return ret;
264 }
265
Resume()266 int32_t LppAudioStreamer::Resume()
267 {
268 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ Resume ======");
269 int ret = OH_LowPowerAudioSink_Resume(lppAudioStreamer_);
270 return ret;
271 }
272
Flush()273 int32_t LppAudioStreamer::Flush()
274 {
275 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ Flush ======");
276 int ret = OH_LowPowerAudioSink_Flush(lppAudioStreamer_);
277 return ret;
278 }
279
Stop()280 int32_t LppAudioStreamer::Stop()
281 {
282 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ Stop ======");
283 int ret = OH_LowPowerAudioSink_Stop(lppAudioStreamer_);
284 return ret;
285 }
286
Reset()287 int32_t LppAudioStreamer::Reset()
288 {
289 AVCODEC_SAMPLE_LOGI("====== lppAudioStreamer_ Reset ======");
290 AVCODEC_SAMPLE_LOGI("reset in3");
291 int ret = OH_LowPowerAudioSink_Reset(lppAudioStreamer_);
292 AVCODEC_SAMPLE_LOGI("reset in6");
293 return ret;
294 }
295
Destroy()296 int32_t LppAudioStreamer::Destroy()
297 {
298 AVCODEC_SAMPLE_LOGI("====== LppAudioStreamer Destroy ======");
299 int ret = OH_LowPowerAudioSink_Destroy(lppAudioStreamer_);
300 AVCODEC_SAMPLE_LOGW("LppAudioStreamer Destroy ret:::%{public}d", ret);
301 lppAudioStreamer_ = nullptr;
302 return ret;
303 }
CallbackDestroy()304 int32_t LppAudioStreamer::CallbackDestroy()
305 {
306 AVCODEC_SAMPLE_LOGI("====== LppAudioStreamer Destroy ======");
307 int ret = OH_LowPowerAudioSinkCallback_Destroy(lppAudioStreamerCallback_);
308 AVCODEC_SAMPLE_LOGW("LppAudioStreamer CallbackDestroy ret:::%{public}d", ret);
309 lppAudioStreamerCallback_ = nullptr;
310 return ret;
311 }
312
Release()313 int32_t LppAudioStreamer::Release()
314 {
315 Destroy();
316 CallbackDestroy();
317 return AVCODEC_SAMPLE_ERR_OK;
318 }
319