1 /* 2 * Copyright (c) 2025 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 HPAE_MSG_CHANNEL_H 16 #define HPAE_MSG_CHANNEL_H 17 18 #include <any> 19 #include "i_stream.h" 20 #include "hpae_info.h" 21 #include "hpae_pcm_buffer.h" 22 23 namespace OHOS { 24 namespace AudioStandard { 25 namespace HPAE { 26 enum HpaeMsgCode { 27 UPDATE_STATUS, 28 INIT_DEVICE_RESULT, 29 MOVE_SINK_INPUT, 30 MOVE_ALL_SINK_INPUT, 31 MOVE_SOURCE_OUTPUT, 32 MOVE_ALL_SOURCE_OUTPUT, 33 DUMP_SINK_INFO, 34 DUMP_SOURCE_INFO, 35 MOVE_SESSION_FAILED, 36 RELOAD_AUDIO_SINK_RESULT, 37 CONNECT_CO_BUFFER_NODE, 38 DISCONNECT_CO_BUFFER_NODE, 39 INIT_SOURCE_RESULT, 40 }; 41 42 enum NodeOperation { UNDERFLOW, FADED, DRAINED }; 43 44 class ISendMsgCallback { 45 public: 46 virtual void Invoke(HpaeMsgCode cmdID, const std::any &args) = 0; 47 }; 48 49 class CallbackSender { 50 protected: 51 std::weak_ptr<ISendMsgCallback> weakCallback_; 52 53 public: RegisterSendMsgCallback(std::weak_ptr<ISendMsgCallback> cb)54 void RegisterSendMsgCallback(std::weak_ptr<ISendMsgCallback> cb) 55 { 56 weakCallback_ = cb; 57 } 58 59 template <typename... Args> TriggerCallback(HpaeMsgCode cmdID,Args &&...args)60 void TriggerCallback(HpaeMsgCode cmdID, Args &&...args) 61 { 62 if (auto callback = weakCallback_.lock()) { 63 // pack the arguments into a tuple 64 auto packed = std::make_tuple(std::forward<Args>(args)...); 65 callback->Invoke(cmdID, packed); 66 } 67 } 68 }; 69 70 enum HpaeProcessorType { 71 HPAE_SCENE_DEFAULT = 0, 72 HPAE_SCENE_MUSIC = 1, 73 HPAE_SCENE_GAME = 2, 74 HPAE_SCENE_MOVIE = 3, 75 HPAE_SCENE_SPEECH = 4, 76 HPAE_SCENE_RING = 5, 77 HPAE_SCENE_VOIP_DOWN = 6, 78 HPAE_SCENE_OTHERS = 7, 79 HPAE_SCENE_EFFECT_NONE = 8, 80 HPAE_SCENE_EFFECT_OUT = 9, 81 82 // special scene for split 83 HPAE_SCENE_SPLIT_MEDIA = 10, 84 HPAE_SCENE_SPLIT_NAVIGATION = 11, 85 HPAE_SCENE_SPLIT_COMMUNICATION = 12, 86 87 // up processor scene 88 HPAE_SCENE_VOIP_UP = 20, 89 HPAE_SCENE_RECORD = 21, 90 HPAE_SCENE_PRE_ENHANCE = 22, 91 HPAE_SCENE_ASR = 23, 92 HPAE_SCENE_VOICE_MESSAGE = 24, 93 94 // scene for collaboration 95 HPAE_SCENE_COLLABORATIVE = 25, 96 HPAE_SCENE_RECOGNITION = 26, 97 }; 98 99 // mark sourceInputNode(cluster) 100 enum HpaeSourceInputNodeType { 101 HPAE_SOURCE_DEFAULT, 102 HPAE_SOURCE_MIC, 103 HPAE_SOURCE_MIC_EC, 104 HPAE_SOURCE_EC, 105 HPAE_SOURCE_MICREF, 106 }; 107 108 struct HpaeDfxNodeInfo { 109 uint32_t nodeId; 110 uint32_t sessionId; 111 uint32_t frameLen; 112 size_t historyFrameCount; 113 AudioSamplingRate samplingRate; 114 AudioSampleFormat format = AudioSampleFormat::SAMPLE_F32LE; 115 AudioChannel channels; 116 AudioChannelLayout channelLayout = AudioChannelLayout::CH_LAYOUT_UNKNOWN; 117 FadeType fadeType = NONE_FADE; 118 AudioStreamType streamType; 119 HpaeProcessorType sceneType; 120 std::string deviceClass; 121 std::string deviceNetId; 122 std::string nodeName; 123 SourceType sourceType; 124 }; 125 126 class INodeCallback { 127 public: OnNodeStatusUpdate(uint32_t sessionId,IOperation operation)128 virtual void OnNodeStatusUpdate(uint32_t sessionId, IOperation operation){}; OnFadeDone(uint32_t sessionId,IOperation operation)129 virtual void OnFadeDone(uint32_t sessionId, IOperation operation){}; OnRequestLatency(uint32_t sessionId,uint64_t & latency)130 virtual void OnRequestLatency(uint32_t sessionId, uint64_t &latency){}; 131 virtual void OnRewindAndFlush(uint64_t rewindTime, uint64_t hdiFramePosition = 0){}; OnNotifyQueue()132 virtual void OnNotifyQueue(){}; OnDisConnectProcessCluster(HpaeProcessorType sceneType)133 virtual void OnDisConnectProcessCluster(HpaeProcessorType sceneType){}; OnNotifyDfxNodeInfo(bool isConnect,uint32_t preNodeId,HpaeDfxNodeInfo & nodeInfo)134 virtual void OnNotifyDfxNodeInfo(bool isConnect, uint32_t preNodeId, HpaeDfxNodeInfo &nodeInfo){}; OnNotifyDfxNodeInfoChanged(uint32_t NodeId,const HpaeDfxNodeInfo & nodeInfo)135 virtual void OnNotifyDfxNodeInfoChanged(uint32_t NodeId, const HpaeDfxNodeInfo &nodeInfo){}; 136 }; 137 138 struct HpaeNodeInfo : HpaeDfxNodeInfo { 139 HpaeEffectInfo effectInfo; 140 std::weak_ptr<INodeCallback> statusCallback; 141 HpaeSourceBufferType sourceBufferType = HpaeSourceBufferType::HPAE_SOURCE_BUFFER_TYPE_DEFAULT; 142 HpaeSourceInputNodeType sourceInputNodeType = HpaeSourceInputNodeType::HPAE_SOURCE_DEFAULT; 143 GetSplitStreamTypeHpaeNodeInfo144 HpaeSplitStreamType GetSplitStreamType() const 145 { 146 static const auto splitTypeMap = [] { 147 std::unordered_map<HpaeProcessorType, HpaeSplitStreamType> map; 148 map[HPAE_SCENE_SPLIT_NAVIGATION] = STREAM_TYPE_NAVIGATION; 149 map[HPAE_SCENE_SPLIT_COMMUNICATION] = STREAM_TYPE_COMMUNICATION; 150 map[HPAE_SCENE_SPLIT_MEDIA] = STREAM_TYPE_MEDIA; 151 return map; 152 } (); 153 auto it = splitTypeMap.find(sceneType); 154 return (it != splitTypeMap.end()) ? it->second : STREAM_TYPE_DEFAULT; 155 } 156 }; 157 158 class INodeFormatInfoCallback { 159 public: 160 virtual int32_t GetNodeInputFormatInfo(uint32_t sessionId, AudioBasicFormat &basicFormat) = 0; 161 }; 162 163 } // namespace HPAE 164 } // namespace AudioStandard 165 } // namespace OHOS 166 167 #endif