experimental support for mirrored audio packets to other mixers

assignment-client/src/audio/AudioMixer.cpp

@@ -92,6 +92,14 @@ AudioMixer::AudioMixer(ReceivedMessage& message) :
     packetReceiver.registerListener(PacketType::NodeMuteRequest, this, "handleNodeMuteRequestPacket");
     packetReceiver.registerListener(PacketType::KillAvatar, this, "handleKillAvatarPacket");
 
+    packetReceiver.registerListenerForTypes({
+        PacketType::MirroredMicrophoneAudioNoEcho,
+        PacketType::MirroredMicrophoneAudioWithEcho,
+        PacketType::MirroredInjectAudio,
+        PacketType::MirroredSilentAudioFrame },
+        this, "queueMirroredAudioPacket"
+    );
+
     connect(nodeList.data(), &NodeList::nodeKilled, this, &AudioMixer::handleNodeKilled);
 }
 
@@ -103,6 +111,17 @@ void AudioMixer::queueAudioPacket(QSharedPointer<ReceivedMessage> message, Share
     getOrCreateClientData(node.data())->queuePacket(message, node);
 }
 
+void AudioMixer::queueMirroredAudioPacket(QSharedPointer<ReceivedMessage> message) {
+    // make sure we have a mirrored node for the original sender of the packet
+    auto nodeList = DependencyManager::get<NodeList>();
+
+    auto node = nodeList->addOrUpdateNode(message->getSourceID(), NodeType::Agent,
+                                          message->getSenderSockAddr(), message->getSenderSockAddr());
+    node->setIsMirror(true);
+
+    getOrCreateClientData(node.data())->queuePacket(message, node);
+}
+
 void AudioMixer::handleMuteEnvironmentPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode) {
     auto nodeList = DependencyManager::get<NodeList>();
 

assignment-client/src/audio/AudioMixer.h

@@ -63,6 +63,7 @@ private slots:
     void handleKillAvatarPacket(QSharedPointer<ReceivedMessage> packet, SharedNodePointer sendingNode);
 
     void queueAudioPacket(QSharedPointer<ReceivedMessage> packet, SharedNodePointer sendingNode);
+    void queueMirroredAudioPacket(QSharedPointer<ReceivedMessage> packet);
     void removeHRTFsForFinishedInjector(const QUuid& streamID);
     void start();
 

assignment-client/src/audio/AudioMixerClientData.cpp

@@ -71,6 +71,9 @@ void AudioMixerClientData::processPackets() {
             case PacketType::SilentAudioFrame: {
                 QMutexLocker lock(&getMutex());
                 parseData(*packet);
+
+                potentiallyMirrorPacket(*packet);
+
                 break;
             }
             case PacketType::NegotiateAudioFormat:
@@ -97,6 +100,35 @@ void AudioMixerClientData::processPackets() {
     assert(_packetQueue.empty());
 }
 
+void AudioMixerClientData::potentiallyMirrorPacket(ReceivedMessage& message) {
+    auto nodeList = DependencyManager::get<NodeList>();
+    if (!nodeList->getMirrorSocket().isNull()) {
+        PacketType mirroredType;
+
+        if (message.getType() == PacketType::MicrophoneAudioNoEcho) {
+            mirroredType = PacketType::MirroredMicrophoneAudioNoEcho;
+        } else if (message.getType() == PacketType::MicrophoneAudioWithEcho) {
+            mirroredType = PacketType::MirroredMicrophoneAudioNoEcho;
+        } else if (message.getType() == PacketType::InjectAudio) {
+            mirroredType = PacketType::MirroredInjectAudio;
+        } else if (message.getType() == PacketType::SilentAudioFrame) {
+            mirroredType = PacketType::MirroredSilentAudioFrame;
+        } else {
+            return;
+        }
+
+        // construct an NLPacket to send to the mirror that has the contents of the received packet
+        std::unique_ptr<char[]> messageData { new char[message.getSize()] };
+        memcpy(messageData.get(), message.getMessage().data(), message.getSize());
+        auto packet = NLPacket::fromReceivedPacket(std::move(messageData), message.getSize(),
+                                                   message.getSenderSockAddr());
+
+        packet->setType(mirroredType);
+
+        nodeList->sendPacket(std::move(packet), nodeList->getMirrorSocket());
+    }
+}
+
 void AudioMixerClientData::negotiateAudioFormat(ReceivedMessage& message, const SharedNodePointer& node) {
     quint8 numberOfCodecs;
     message.readPrimitive(&numberOfCodecs);

assignment-client/src/audio/AudioMixerClientData.h

@@ -124,6 +124,8 @@ private:
     QReadWriteLock _streamsLock;
     AudioStreamMap _audioStreams; // microphone stream from avatar is stored under key of null UUID
 
+    void potentiallyMirrorPacket(ReceivedMessage& packet);
+
     using IgnoreZone = AABox;
     class IgnoreZoneMemo {
     public:

libraries/networking/src/LimitedNodeList.h

@@ -278,6 +278,12 @@ public:
     void sendFakedHandshakeRequestToNode(SharedNodePointer node);
 #endif
 
+    void setMirrorSocket(const HifiSockAddr& mirrorSocket) { _mirrorSocket = mirrorSocket; }
+    const HifiSockAddr& getMirrorSocket() { return _mirrorSocket; }
+
+    void setMasterSocket(const HifiSockAddr& masterSocket) { _masterSocket = masterSocket; }
+    const HifiSockAddr& getMasterSocket() { return _masterSocket; }
+
 public slots:
     void reset();
     void eraseAllNodes();
@@ -386,6 +392,10 @@ protected:
         }
     }
 
+
+    HifiSockAddr _mirrorSocket;
+    HifiSockAddr _masterSocket;
+
 private slots:
     void flagTimeForConnectionStep(ConnectionStep connectionStep, quint64 timestamp);
     void possiblyTimeoutSTUNAddressLookup();

libraries/networking/src/NLPacket.h

@@ -42,6 +42,7 @@ public:
     
     static std::unique_ptr<NLPacket> fromReceivedPacket(std::unique_ptr<char[]> data, qint64 size,
                                                         const HifiSockAddr& senderSockAddr);
+
     static std::unique_ptr<NLPacket> fromBase(std::unique_ptr<Packet> packet);
     
     // Provided for convenience, try to limit use

libraries/networking/src/Node.h

@@ -80,6 +80,9 @@ public:
 
     bool isIgnoreRadiusEnabled() const { return _ignoreRadiusEnabled; }
 
+    bool isMirror() const { return _isMirror; }
+    void setIsMirror(bool isMirror) { _isMirror = isMirror; }
+
 private:
     // privatize copy and assignment operator to disallow Node copying
     Node(const Node &otherNode);
@@ -98,6 +101,8 @@ private:
     mutable QReadWriteLock _ignoredNodeIDSetLock;
 
     std::atomic_bool _ignoreRadiusEnabled;
+
+    bool _isMirror { false };
 };
 
 Q_DECLARE_METATYPE(Node*)

libraries/networking/src/udt/PacketHeaders.cpp

@@ -39,7 +39,9 @@ const QSet<PacketType> NON_SOURCED_PACKETS = QSet<PacketType>()
     << PacketType::ICEServerPeerInformation << PacketType::ICEServerQuery << PacketType::ICEServerHeartbeat
     << PacketType::ICEServerHeartbeatACK << PacketType::ICEPing << PacketType::ICEPingReply
     << PacketType::ICEServerHeartbeatDenied << PacketType::AssignmentClientStatus << PacketType::StopNode
-    << PacketType::DomainServerRemovedNode << PacketType::UsernameFromIDReply << PacketType::OctreeFileReplacement;
+    << PacketType::DomainServerRemovedNode << PacketType::UsernameFromIDReply << PacketType::OctreeFileReplacement
+    << PacketType::MirroredMicrophoneAudioNoEcho << PacketType::MirroredMicrophoneAudioWithEcho
+    << PacketType::MirroredInjectAudio << PacketType::MirroredSilentAudioFrame;
 
 PacketVersion versionForPacketType(PacketType packetType) {
     switch (packetType) {

libraries/networking/src/udt/PacketHeaders.h

@@ -115,7 +115,12 @@ public:
         AdjustAvatarSorting,
         OctreeFileReplacement,
         CollisionEventChanges,
-        LAST_PACKET_TYPE = CollisionEventChanges
+        MirroredMicrophoneAudioNoEcho,
+        MirroredMicrophoneAudioWithEcho,
+        MirroredInjectAudio,
+        MirroredSilentAudioFrame,
+        LAST_PACKET_TYPE = MirroredSilentAudioFrame,
+
     };
 };