More EntityScriptServer work

assignment-client/src/Agent.cpp

@@ -54,7 +54,6 @@ static const int RECEIVED_AUDIO_STREAM_CAPACITY_FRAMES = 10;
 
 Agent::Agent(ReceivedMessage& message) :
     ThreadedAssignment(message),
-    _entityEditSender(),
     _receivedAudioStream(RECEIVED_AUDIO_STREAM_CAPACITY_FRAMES, RECEIVED_AUDIO_STREAM_CAPACITY_FRAMES) {
     DependencyManager::get<EntityScriptingInterface>()->setPacketSender(&_entityEditSender);
 
@@ -144,7 +143,7 @@ void Agent::handleAudioPacket(QSharedPointer<ReceivedMessage> message) {
     _receivedAudioStream.clearBuffer();
 }
 
-const QString AGENT_LOGGING_NAME = "agent";
+static const QString AGENT_LOGGING_NAME = "agent";
 
 void Agent::run() {
 

assignment-client/src/assets/AssetServer.cpp

@@ -137,7 +137,7 @@ void AssetServer::completeSetup() {
             cleanupUnmappedFiles();
         }
 
-        nodeList->addNodeTypeToInterestSet(NodeType::Agent);
+        nodeList->addSetOfNodeTypesToNodeInterestSet({ NodeType::Agent, NodeType::EntityScriptServer });
     } else {
         qCritical() << "Asset Server assignment will not continue because mapping file could not be loaded.";
         setFinished(true);

assignment-client/src/audio/AudioMixer.cpp

@@ -398,7 +398,7 @@ void AudioMixer::start() {
     auto nodeList = DependencyManager::get<NodeList>();
 
     // prepare the NodeList
-    nodeList->addNodeTypeToInterestSet(NodeType::Agent);
+    nodeList->addSetOfNodeTypesToNodeInterestSet({ NodeType::Agent, NodeType::EntityScriptServer });
     nodeList->linkedDataCreateCallback = [&](Node* node) { getOrCreateClientData(node); };
 
     // parse out any AudioMixer settings

assignment-client/src/avatars/AvatarMixer.cpp

@@ -674,8 +674,8 @@ void AvatarMixer::run() {
 
 void AvatarMixer::domainSettingsRequestComplete() {
     auto nodeList = DependencyManager::get<NodeList>();
-    nodeList->addNodeTypeToInterestSet(NodeType::Agent);
-    
+    nodeList->addSetOfNodeTypesToNodeInterestSet({ NodeType::Agent, NodeType::EntityScriptServer });
+
     // parse the settings to pull out the values we need
     parseDomainServerSettings(nodeList->getDomainHandler().getSettingsObject());
 

assignment-client/src/messages/MessagesMixer.cpp

@@ -83,5 +83,6 @@ void MessagesMixer::sendStatsPacket() {
 
 void MessagesMixer::run() {
     ThreadedAssignment::commonInit(MESSAGES_MIXER_LOGGING_NAME, NodeType::MessagesMixer);
-    DependencyManager::get<NodeList>()->addNodeTypeToInterestSet(NodeType::Agent);
-}
+    auto nodeList = DependencyManager::get<NodeList>();
+    nodeList->addSetOfNodeTypesToNodeInterestSet({ NodeType::Agent, NodeType::EntityScriptServer });
+}

assignment-client/src/octree/OctreeServer.cpp

@@ -1136,8 +1136,8 @@ void OctreeServer::domainSettingsRequestComplete() {
     auto nodeList = DependencyManager::get<NodeList>();
     
     // we need to ask the DS about agents so we can ping/reply with them
-    nodeList->addNodeTypeToInterestSet(NodeType::Agent);
-    
+    nodeList->addSetOfNodeTypesToNodeInterestSet({ NodeType::Agent, NodeType::EntityScriptServer });
+
     auto& packetReceiver = DependencyManager::get<NodeList>()->getPacketReceiver();
     packetReceiver.registerListener(getMyQueryMessageType(), this, "handleOctreeQueryPacket");
     packetReceiver.registerListener(PacketType::OctreeDataNack, this, "handleOctreeDataNackPacket");

assignment-client/src/scripts/EntityScriptServer.cpp

@@ -11,7 +11,166 @@
 
 #include "EntityScriptServer.h"
 
-EntityScriptServer::EntityScriptServer(ReceivedMessage& message) : ThreadedAssignment(message) {
+#include <AudioInjectorManager.h>
+#include <EntityScriptingInterface.h>
+#include <MessagesClient.h>
+#include <plugins/CodecPlugin.h>
+#include <plugins/PluginManager.h>
+#include <ResourceManager.h>
+#include <ScriptCache.h>
+#include <ScriptEngines.h>
+#include <SoundCache.h>
 
+#include "../entities/AssignmentParentFinder.h"
+
+static const int RECEIVED_AUDIO_STREAM_CAPACITY_FRAMES = 10;
+
+EntityScriptServer::EntityScriptServer(ReceivedMessage& message) :
+    ThreadedAssignment(message),
+    _receivedAudioStream(RECEIVED_AUDIO_STREAM_CAPACITY_FRAMES, RECEIVED_AUDIO_STREAM_CAPACITY_FRAMES)
+{
+    DependencyManager::get<EntityScriptingInterface>()->setPacketSender(&_entityEditSender);
+
+    ResourceManager::init();
+
+    DependencyManager::registerInheritance<SpatialParentFinder, AssignmentParentFinder>();
+
+    DependencyManager::set<ResourceCacheSharedItems>();
+    DependencyManager::set<SoundCache>();
+    DependencyManager::set<AudioInjectorManager>();
+
+    DependencyManager::set<ScriptCache>();
+    DependencyManager::set<ScriptEngines>();
+
+
+    auto& packetReceiver = DependencyManager::get<NodeList>()->getPacketReceiver();
+
+    packetReceiver.registerListenerForTypes({ PacketType::MixedAudio, PacketType::SilentAudioFrame },
+                                            this, "handleAudioPacket");
+    packetReceiver.registerListenerForTypes({ PacketType::OctreeStats, PacketType::EntityData, PacketType::EntityErase },
+                                            this, "handleOctreePacket");
+    packetReceiver.registerListener(PacketType::Jurisdiction, this, "handleJurisdictionPacket");
+    packetReceiver.registerListener(PacketType::SelectedAudioFormat, this, "handleSelectedAudioFormat");
 
 }
+
+static const QString ENTITY_SCRIPT_SERVER_LOGGING_NAME = "entity-script-server";
+
+void EntityScriptServer::run() {
+    // make sure we request our script once the agent connects to the domain
+    auto nodeList = DependencyManager::get<NodeList>();
+
+    ThreadedAssignment::commonInit(ENTITY_SCRIPT_SERVER_LOGGING_NAME, NodeType::EntityScriptServer);
+
+    // Setup MessagesClient
+    auto messagesClient = DependencyManager::set<MessagesClient>();
+    QThread* messagesThread = new QThread;
+    messagesThread->setObjectName("Messages Client Thread");
+    messagesClient->moveToThread(messagesThread);
+    connect(messagesThread, &QThread::started, messagesClient.data(), &MessagesClient::init);
+    messagesThread->start();
+
+    // make sure we hear about connected nodes so we can grab an ATP script if a request is pending
+    connect(nodeList.data(), &LimitedNodeList::nodeActivated, this, &EntityScriptServer::nodeActivated);
+    connect(nodeList.data(), &LimitedNodeList::nodeKilled, this, &EntityScriptServer::nodeKilled);
+
+    nodeList->addSetOfNodeTypesToNodeInterestSet({
+        NodeType::AudioMixer, NodeType::AvatarMixer, NodeType::EntityServer, NodeType::MessagesMixer, NodeType::AssetServer
+    });
+}
+
+void EntityScriptServer::nodeActivated(SharedNodePointer activatedNode) {
+    if (activatedNode->getType() == NodeType::AudioMixer) {
+        negotiateAudioFormat();
+    }
+}
+
+void EntityScriptServer::negotiateAudioFormat() {
+    auto nodeList = DependencyManager::get<NodeList>();
+    auto negotiateFormatPacket = NLPacket::create(PacketType::NegotiateAudioFormat);
+    auto codecPlugins = PluginManager::getInstance()->getCodecPlugins();
+    quint8 numberOfCodecs = (quint8)codecPlugins.size();
+    negotiateFormatPacket->writePrimitive(numberOfCodecs);
+    for (auto& plugin : codecPlugins) {
+        auto codecName = plugin->getName();
+        negotiateFormatPacket->writeString(codecName);
+    }
+
+    // grab our audio mixer from the NodeList, if it exists
+    SharedNodePointer audioMixer = nodeList->soloNodeOfType(NodeType::AudioMixer);
+
+    if (audioMixer) {
+        // send off this mute packet
+        nodeList->sendPacket(std::move(negotiateFormatPacket), *audioMixer);
+    }
+}
+
+void EntityScriptServer::handleSelectedAudioFormat(QSharedPointer<ReceivedMessage> message) {
+    QString selectedCodecName = message->readString();
+    selectAudioFormat(selectedCodecName);
+}
+
+void EntityScriptServer::selectAudioFormat(const QString& selectedCodecName) {
+    _selectedCodecName = selectedCodecName;
+
+    qDebug() << "Selected Codec:" << _selectedCodecName;
+
+    // release any old codec encoder/decoder first...
+    if (_codec && _encoder) {
+        _codec->releaseEncoder(_encoder);
+        _encoder = nullptr;
+        _codec = nullptr;
+    }
+    _receivedAudioStream.cleanupCodec();
+
+    auto codecPlugins = PluginManager::getInstance()->getCodecPlugins();
+    for (auto& plugin : codecPlugins) {
+        if (_selectedCodecName == plugin->getName()) {
+            _codec = plugin;
+            _receivedAudioStream.setupCodec(plugin, _selectedCodecName, AudioConstants::STEREO);
+            _encoder = plugin->createEncoder(AudioConstants::SAMPLE_RATE, AudioConstants::MONO);
+            qDebug() << "Selected Codec Plugin:" << _codec.get();
+            break;
+        }
+    }
+}
+
+void EntityScriptServer::handleAudioPacket(QSharedPointer<ReceivedMessage> message) {
+    _receivedAudioStream.parseData(*message);
+
+    _lastReceivedAudioLoudness = _receivedAudioStream.getNextOutputFrameLoudness();
+    _receivedAudioStream.clearBuffer();
+}
+
+void EntityScriptServer::nodeKilled(SharedNodePointer killedNode) {
+
+}
+
+void EntityScriptServer::sendStatsPacket() {
+
+}
+
+void EntityScriptServer::handleOctreePacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode) {
+
+}
+
+void EntityScriptServer::handleJurisdictionPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode) {
+
+}
+
+void EntityScriptServer::aboutToFinish() {
+    // our entity tree is going to go away so tell that to the EntityScriptingInterface
+    DependencyManager::get<EntityScriptingInterface>()->setEntityTree(nullptr);
+
+    ResourceManager::cleanup();
+
+    // cleanup the AudioInjectorManager (and any still running injectors)
+    DependencyManager::destroy<AudioInjectorManager>();
+    DependencyManager::destroy<ScriptEngines>();
+
+    // cleanup codec & encoder
+    if (_codec && _encoder) {
+        _codec->releaseEncoder(_encoder);
+        _encoder = nullptr;
+    }
+}

assignment-client/src/scripts/EntityScriptServer.h

@@ -14,8 +14,11 @@
 
 #include <QtCore/QObject>
 
+#include <EntityEditPacketSender.h>
+#include <plugins/CodecPlugin.h>
 #include <ThreadedAssignment.h>
 
+#include "MixedAudioStream.h"
 
 class EntityScriptServer : public ThreadedAssignment {
     Q_OBJECT
@@ -23,6 +26,8 @@ class EntityScriptServer : public ThreadedAssignment {
 public:
     EntityScriptServer(ReceivedMessage& message);
 
+    virtual void aboutToFinish() override;
+
 public slots:
     void run() override;
     void nodeActivated(SharedNodePointer activatedNode);
@@ -30,14 +35,22 @@ public slots:
     void sendStatsPacket() override;
 
 private slots:
-    void handleAudioPacket(QSharedPointer<ReceivedMessage> message);
     void handleOctreePacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode);
     void handleJurisdictionPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode);
     void handleSelectedAudioFormat(QSharedPointer<ReceivedMessage> message);
-    
+    void handleAudioPacket(QSharedPointer<ReceivedMessage> message);
+
 private:
+    void negotiateAudioFormat();
+    void selectAudioFormat(const QString& selectedCodecName);
 
+    EntityEditPacketSender _entityEditSender;
 
+    QString _selectedCodecName;
+    CodecPluginPointer _codec;
+    Encoder* _encoder { nullptr };
+    MixedAudioStream _receivedAudioStream;
+    float _lastReceivedAudioLoudness;
 };
 
 #endif // hifi_EntityScriptServer_h

domain-server/src/DomainServer.cpp

@@ -808,9 +808,7 @@ void DomainServer::populateDefaultStaticAssignmentsExcludingTypes(const QSet<Ass
     for (Assignment::Type defaultedType = Assignment::AudioMixerType;
          defaultedType != Assignment::AllTypes;
          defaultedType =  static_cast<Assignment::Type>(static_cast<int>(defaultedType) + 1)) {
-        if (!excludedTypes.contains(defaultedType)
-            && defaultedType != Assignment::UNUSED_1
-            && defaultedType != Assignment::AgentType) {
+        if (!excludedTypes.contains(defaultedType) && defaultedType != Assignment::AgentType) {
             
             if (defaultedType == Assignment::AssetServerType) {
                 // Make sure the asset-server is enabled before adding it here.