1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "av_receiver_engine_transport.h"
17
18 #include <securec.h>
19 #include "daudio_constants.h"
20 #include "daudio_errorcode.h"
21 #include "daudio_log.h"
22 #include "daudio_util.h"
23
24 #undef DH_LOG_TAG
25 #define DH_LOG_TAG "AVTransReceiverTransport"
26
27 namespace OHOS {
28 namespace DistributedHardware {
InitEngine(IAVEngineProvider * providerPtr)29 int32_t AVTransReceiverTransport::InitEngine(IAVEngineProvider *providerPtr)
30 {
31 DHLOGI("Init av receiver engine.");
32 if (receiverAdapter_ == nullptr) {
33 receiverAdapter_ = std::make_shared<AVTransReceiverAdapter>();
34 }
35 int32_t ret = receiverAdapter_->Initialize(providerPtr, devId_);
36 if (ret != DH_SUCCESS) {
37 DHLOGE("Init av receiver adapter failed.");
38 return ret;
39 }
40 if (receiverAdapter_->RegisterAdapterCallback(shared_from_this()) != DH_SUCCESS) {
41 DHLOGE("Register callback error.");
42 }
43 return ret;
44 }
45
SetUp(const AudioParam & localParam,const AudioParam & remoteParam,const std::shared_ptr<IAudioDataTransCallback> & callback,const PortCapType capType)46 int32_t AVTransReceiverTransport::SetUp(const AudioParam &localParam, const AudioParam &remoteParam,
47 const std::shared_ptr<IAudioDataTransCallback> &callback, const PortCapType capType)
48 {
49 (void)remoteParam;
50 (void)callback;
51 (void)capType;
52 return SetParameter(localParam);
53 }
54
CreateCtrl()55 int32_t AVTransReceiverTransport::CreateCtrl()
56 {
57 DHLOGI("Create ctrl enter.");
58 CHECK_NULL_RETURN(receiverAdapter_, ERR_DH_AUDIO_NULLPTR);
59 return receiverAdapter_->CreateControlChannel(devId_);
60 }
61
Start()62 int32_t AVTransReceiverTransport::Start()
63 {
64 DHLOGI("Start av receiver engine.");
65 CHECK_NULL_RETURN(receiverAdapter_, ERR_DH_AUDIO_NULLPTR);
66 return receiverAdapter_->Start();
67 }
68
Stop()69 int32_t AVTransReceiverTransport::Stop()
70 {
71 DHLOGI("Stop av receiver engine.");
72 CHECK_NULL_RETURN(receiverAdapter_, ERR_DH_AUDIO_NULLPTR);
73 return receiverAdapter_->Stop();
74 }
75
Release()76 int32_t AVTransReceiverTransport::Release()
77 {
78 DHLOGI("Release av receiver engine.");
79 CHECK_NULL_RETURN(receiverAdapter_, ERR_DH_AUDIO_NULLPTR);
80 return receiverAdapter_->Release();
81 }
82
Pause()83 int32_t AVTransReceiverTransport::Pause()
84 {
85 DHLOGI("Pause av receiver engine.");
86 CHECK_NULL_RETURN(receiverAdapter_, ERR_DH_AUDIO_NULLPTR);
87 return receiverAdapter_->SetParameter(AVTransTag::ENGINE_PAUSE, "");
88 }
89
Restart(const AudioParam & localParam,const AudioParam & remoteParam)90 int32_t AVTransReceiverTransport::Restart(const AudioParam &localParam, const AudioParam &remoteParam)
91 {
92 DHLOGI("Restart av receiver engine.");
93 (void)localParam;
94 (void)remoteParam;
95 CHECK_NULL_RETURN(receiverAdapter_, ERR_DH_AUDIO_NULLPTR);
96 return receiverAdapter_->SetParameter(AVTransTag::ENGINE_RESUME, "");
97 }
98
FeedAudioData(std::shared_ptr<AudioData> & audioData)99 int32_t AVTransReceiverTransport::FeedAudioData(std::shared_ptr<AudioData> &audioData)
100 {
101 DHLOGI("Receiver engine not support.");
102 (void)audioData;
103 return DH_SUCCESS;
104 }
105
SendMessage(uint32_t type,std::string content,std::string dstDevId)106 int32_t AVTransReceiverTransport::SendMessage(uint32_t type, std::string content, std::string dstDevId)
107 {
108 DHLOGI("Send message to remote. type: %{public}u, content: %{public}s.", type, content.c_str());
109 CHECK_NULL_RETURN(receiverAdapter_, ERR_DH_AUDIO_NULLPTR);
110 auto message = std::make_shared<AVTransMessage>(type, content, dstDevId);
111 return receiverAdapter_->SendMessageToRemote(message);
112 }
113
OnEngineEvent(const AVTransEvent & event)114 void AVTransReceiverTransport::OnEngineEvent(const AVTransEvent &event)
115 {
116 CHECK_NULL_VOID(transCallback_);
117 transCallback_->OnEngineTransEvent(event);
118 }
119
OnEngineMessage(const std::shared_ptr<AVTransMessage> & message)120 void AVTransReceiverTransport::OnEngineMessage(const std::shared_ptr<AVTransMessage> &message)
121 {
122 CHECK_NULL_VOID(message);
123 CHECK_NULL_VOID(transCallback_);
124 transCallback_->OnEngineTransMessage(message);
125 }
126
OnEngineDataAvailable(const std::shared_ptr<AVTransBuffer> & buffer)127 void AVTransReceiverTransport::OnEngineDataAvailable(const std::shared_ptr<AVTransBuffer> &buffer)
128 {
129 DHLOGD("On data availabled.");
130 CHECK_NULL_VOID(buffer);
131 auto bufferData = buffer->GetBufferData(0);
132 CHECK_NULL_VOID(bufferData);
133 std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>(bufferData->GetSize());
134 int32_t ret = memcpy_s(audioData->Data(), audioData->Capacity(), bufferData->GetAddress(), bufferData->GetSize());
135 if (ret != EOK) {
136 DHLOGE("Copy audio data failed, error code %{public}d.", ret);
137 return;
138 }
139 CHECK_NULL_VOID(transCallback_);
140 transCallback_->OnEngineTransDataAvailable(audioData);
141 }
142
SetParameter(const AudioParam & audioParam)143 int32_t AVTransReceiverTransport::SetParameter(const AudioParam &audioParam)
144 {
145 DHLOGI("SetParameter.");
146 CHECK_NULL_RETURN(receiverAdapter_, ERR_DH_AUDIO_NULLPTR);
147 receiverAdapter_->SetParameter(AVTransTag::AUDIO_SAMPLE_RATE, std::to_string(audioParam.comParam.sampleRate));
148 receiverAdapter_->SetParameter(AVTransTag::AUDIO_SAMPLE_FORMAT, std::to_string(AudioSampleFormat::SAMPLE_F32LE));
149 receiverAdapter_->SetParameter(AVTransTag::AUDIO_CHANNEL_MASK, std::to_string(audioParam.comParam.channelMask));
150 receiverAdapter_->SetParameter(AVTransTag::AUDIO_CHANNEL_LAYOUT, std::to_string(audioParam.comParam.channelMask));
151 receiverAdapter_->SetParameter(AVTransTag::AUDIO_BIT_RATE, std::to_string(AUDIO_SET_HISTREAMER_BIT_RATE));
152 receiverAdapter_->SetParameter(AVTransTag::AUDIO_FRAME_SIZE, std::to_string(audioParam.comParam.frameSize));
153 receiverAdapter_->SetParameter(AVTransTag::AUDIO_CODEC_TYPE, std::to_string(audioParam.comParam.codecType));
154 receiverAdapter_->SetParameter(AVTransTag::ENGINE_READY, OWNER_NAME_D_SPEAKER);
155 return DH_SUCCESS;
156 }
157 } // namespace DistributedHardware
158 } // namespace OHOS