merge Leo's ID additions to DS

CMakeLists.txt

@@ -6,4 +6,5 @@ add_subdirectory(space)
 add_subdirectory(domain)
 add_subdirectory(mixer)
 add_subdirectory(voxel)
-add_subdirectory(interface)
+add_subdirectory(interface)
+add_subdirectory(injector)

domain/src/main.cpp

@@ -50,6 +50,7 @@ AgentList agentList('D', DOMAIN_LISTEN_PORT);
 unsigned char * addAgentToBroadcastPacket(unsigned char *currentPosition, Agent *agentToAdd) {
     *currentPosition++ = agentToAdd->getType();
     
+    currentPosition += packAgentId(currentPosition, agentToAdd->getAgentId());
     currentPosition += packSocket(currentPosition, agentToAdd->getPublicSocket());
     currentPosition += packSocket(currentPosition, agentToAdd->getLocalSocket());
     
@@ -92,7 +93,14 @@ int main(int argc, const char * argv[])
                 agentPublicAddress.sin_addr.s_addr = 895283510;
             }
             
-            agentList.addOrUpdateAgent((sockaddr *)&agentPublicAddress, (sockaddr *)&agentLocalAddress, agentType);
+            if (agentList.addOrUpdateAgent((sockaddr *)&agentPublicAddress,
+                                           (sockaddr *)&agentLocalAddress,
+                                           agentType,
+                                           agentList.getLastAgentId())) {
+                
+                agentList.increaseAgentId();
+            
+            }
             
             currentBufferPos = broadcastPacket + 1;
             startPointer = currentBufferPos;

injector/CMakeLists.txt

@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 2.8)
+
+project(injector)
+
+# grab the implemenation and header files
+file(GLOB INJECTOR_SRCS src/*.cpp src/*.h)
+
+# add the executable
+add_executable(injector ${INJECTOR_SRCS})
+
+# link the shared hifi library
+include(../LinkHifiShared.cmake)
+link_hifi_shared_library(injector)
+
+# link the threads library
+find_package(Threads REQUIRED)
+target_link_libraries(injector ${CMAKE_THREAD_LIBS_INIT})

injector/src/injector.cpp

@@ -0,0 +1,181 @@
+//
+//  injector.cpp
+//  Audio Injector
+//
+//  Created by Leonardo Murillo on 3/5/13.
+//  Copyright (c) 2013 Leonardo Murillo. All rights reserved.
+//
+
+
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <vector>
+#include <fstream>
+#include <algorithm>
+#include <arpa/inet.h>
+#include <string.h>
+#include <sstream>
+#include "UDPSocket.h"
+#include "UDPSocket.cpp"
+#include <SharedUtil.h>
+
+char EC2_WEST_AUDIO_SERVER[] = "54.241.92.53";
+const int AUDIO_UDP_LISTEN_PORT = 55443;
+const int BUFFER_LENGTH_BYTES = 512;
+const int BUFFER_LENGTH_SAMPLES = BUFFER_LENGTH_BYTES / sizeof(int16_t);
+const float SAMPLE_RATE = 22050.0;
+const float BUFFER_SEND_INTERVAL_USECS = (BUFFER_LENGTH_SAMPLES / SAMPLE_RATE) * 1000000;
+
+// Command line parameter defaults
+bool loopAudio = true;
+float sleepIntervalMin = 1.00;
+float sleepIntervalMax = 2.00;
+float positionInUniverse[] = {0, 0, 0, 0};
+unsigned char attenuationModifier = 255;
+char *sourceAudioFile;
+const char *allowedParameters = ":rb::t::c::a::f:";
+
+char *charBuffer;
+int16_t *buffer;
+long length;
+
+UDPSocket *streamSocket;
+
+void usage(void)
+{
+    std::cout << "High Fidelity - Interface audio injector" << std::endl;
+    std::cout << "   -r                             Random sleep mode. If not specified will default to constant loop." << std::endl;
+    std::cout << "   -b FLOAT                       Min. number of seconds to sleep. Only valid in random sleep mode. Default 1.0" << std::endl;
+    std::cout << "   -t FLOAT                       Max. number of seconds to sleep. Only valid in random sleep mode. Default 2.0" << std::endl;
+    std::cout << "   -c FLOAT,FLOAT,FLOAT,FLOAT     X,Y,Z,YAW position in universe where audio will be originating from and direction. Defaults to 0,0,0,0" << std::endl;
+    std::cout << "   -a 0-255                       Attenuation curve modifier, defaults to 255" << std::endl;
+    std::cout << "   -f FILENAME                    Name of audio source file. Required - RAW format, 22050hz 16bit signed mono" << std::endl;
+};
+
+bool processParameters(int parameterCount, char* parameterData[])
+{
+    int p;
+    while ((p = getopt(parameterCount, parameterData, allowedParameters)) != -1) {
+        switch (p) {
+            case 'r':
+                loopAudio = false;
+                std::cout << "[DEBUG] Random sleep mode enabled" << std::endl;
+                break;
+            case 'b':
+                sleepIntervalMin = atof(optarg);
+                std::cout << "[DEBUG] Min delay between plays " << sleepIntervalMin << "sec" << std::endl;
+                break;
+            case 't':
+                sleepIntervalMax = atof(optarg);
+                std::cout << "[DEBUG] Max delay between plays " << sleepIntervalMax << "sec" << std::endl;
+                break;
+            case 'f':
+                sourceAudioFile = optarg;
+                std::cout << "[DEBUG] Opening file: " << sourceAudioFile << std::endl;
+                break;
+            case 'c':
+            {
+                std::istringstream ss(optarg);
+                std::string token;
+                
+                int i = 0;
+                while (std::getline(ss, token, ',')) {
+                    positionInUniverse[i] = atof(token.c_str());
+                    ++i;
+                    if (i == 4) {
+                        break;
+                    }
+                }
+                 
+                break;
+            }
+            case 'a':
+                attenuationModifier = atoi(optarg);
+                std::cout << "[DEBUG] Attenuation modifier: " << optarg << std::endl;
+                break;
+            default:
+                usage();
+                return false;
+        }
+    }
+    return true;
+};
+
+void loadFile(void) {
+    std::fstream sourceFile;
+    sourceFile.open(sourceAudioFile, std::ios::in | std::ios::binary);
+    sourceFile.seekg(0, std::ios::end);
+    length = sourceFile.tellg();
+    sourceFile.seekg(0, std::ios::beg);
+    long sizeOfShortArray = length / 2;
+    buffer = new int16_t[sizeOfShortArray];
+    sourceFile.read((char *)buffer, length);
+}
+
+void stream(void)
+{
+    timeval startTime;
+    
+    int leadingBytes = 1 + (sizeof(float) * 4);
+    unsigned char dataPacket[BUFFER_LENGTH_BYTES + leadingBytes];
+    
+    dataPacket[0] = 'I';
+    unsigned char *currentPacketPtr = dataPacket + 1;
+    
+    for (int p = 0; p < 4; p++) {
+        memcpy(currentPacketPtr, &positionInUniverse[p], sizeof(float));
+        currentPacketPtr += sizeof(float);
+    }
+    
+    *currentPacketPtr = attenuationModifier;
+    currentPacketPtr++;
+    
+    for (int i = 0; i < length; i += BUFFER_LENGTH_SAMPLES) {
+        gettimeofday(&startTime, NULL);
+        memcpy(currentPacketPtr, &buffer[i], BUFFER_LENGTH_BYTES);
+        streamSocket->send(EC2_WEST_AUDIO_SERVER, AUDIO_UDP_LISTEN_PORT, dataPacket, sizeof(dataPacket));
+        double usecToSleep = usecTimestamp(&startTime) + BUFFER_SEND_INTERVAL_USECS - usecTimestampNow();
+        usleep(usecToSleep);
+    }
+};
+
+int main(int argc, char* argv[])
+{
+
+    srand(time(0));
+    int AUDIO_UDP_SEND_PORT = 1500 + (rand() % (int)(1500 - 2000 + 1));
+    
+    UDPSocket *streamSocket = new UDPSocket(AUDIO_UDP_SEND_PORT);
+    
+    if (processParameters(argc, argv)) {
+        if (sourceAudioFile) {
+            loadFile();
+        } else {
+            std::cout << "[FATAL] Source audio file not specified" << std::endl;
+            exit(-1);
+        }
+        
+        for (int i = 0; i < sizeof(positionInUniverse)/sizeof(positionInUniverse[0]); ++i) {
+            std::cout << "Position " << positionInUniverse[i] << std::endl;
+        }
+
+        float delay;
+        int usecDelay;
+        while (true) {
+            stream();
+            
+            if (loopAudio) {
+                delay = 0;
+            } else {
+                delay = randFloatInRange(sleepIntervalMin, sleepIntervalMax);
+            }
+            usecDelay = delay * 1000 * 1000;
+            usleep(usecDelay);
+        }
+    }
+    return 0;
+}
+
+

shared/src/Agent.cpp

@@ -19,7 +19,7 @@
 
 Agent::Agent() {}
 
-Agent::Agent(sockaddr *agentPublicSocket, sockaddr *agentLocalSocket, char agentType) {
+Agent::Agent(sockaddr *agentPublicSocket, sockaddr *agentLocalSocket, char agentType, uint16_t thisAgentId) {
     publicSocket = new sockaddr;
     memcpy(publicSocket, agentPublicSocket, sizeof(sockaddr));
     
@@ -27,6 +27,7 @@ Agent::Agent(sockaddr *agentPublicSocket, sockaddr *agentLocalSocket, char agent
     memcpy(localSocket, agentLocalSocket, sizeof(sockaddr));
     
     type = agentType;
+    agentId = thisAgentId;
     
     firstRecvTimeUsecs = usecTimestampNow();
     lastRecvTimeUsecs = usecTimestampNow();
@@ -42,6 +43,8 @@ Agent::Agent(const Agent &otherAgent) {
     localSocket = new sockaddr;
     memcpy(localSocket, otherAgent.localSocket, sizeof(sockaddr));
     
+    agentId = otherAgent.agentId;
+    
     if (otherAgent.activeSocket == otherAgent.publicSocket) {
         activeSocket = publicSocket;
     } else if (otherAgent.activeSocket == otherAgent.localSocket) {
@@ -80,6 +83,14 @@ void Agent::setType(char newType) {
     type = newType;
 }
 
+uint16_t Agent::getAgentId() {
+    return agentId;
+}
+
+void Agent::setAgentId(uint16_t thisAgentId) {
+    agentId = thisAgentId;
+}
+
 double Agent::getFirstRecvTimeUsecs() {
     return firstRecvTimeUsecs;
 }
@@ -144,6 +155,7 @@ void Agent::swap(Agent &first, Agent &second) {
     swap(first.activeSocket, second.activeSocket);
     swap(first.type, second.type);
     swap(first.linkedData, second.linkedData);
+    swap(first.agentId, second.agentId);
 }
 
 bool Agent::matches(sockaddr *otherPublicSocket, sockaddr *otherLocalSocket, char otherAgentType) {

shared/src/Agent.h

@@ -21,7 +21,7 @@
 class Agent {
     public:
         Agent();
-        Agent(sockaddr *agentPublicSocket, sockaddr *agentLocalSocket, char agentType);
+        Agent(sockaddr *agentPublicSocket, sockaddr *agentLocalSocket, char agentType, uint16_t thisAgentId);
         Agent(const Agent &otherAgent);
         ~Agent();
         Agent& operator=(Agent otherAgent);
@@ -30,6 +30,8 @@ class Agent {
         bool matches(sockaddr *otherPublicSocket, sockaddr *otherLocalSocket, char otherAgentType);
         char getType();
         void setType(char newType);
+        uint16_t getAgentId();
+        void setAgentId(uint16_t thisAgentId);
         double getFirstRecvTimeUsecs();
         void setFirstRecvTimeUsecs(double newTimeUsecs);
         double getLastRecvTimeUsecs();
@@ -49,6 +51,7 @@ class Agent {
         void swap(Agent &first, Agent &second);
         sockaddr *publicSocket, *localSocket, *activeSocket;
         char type;
+        uint16_t agentId;
         double firstRecvTimeUsecs;
         double lastRecvTimeUsecs;
         AgentData *linkedData;

shared/src/AgentList.cpp

@@ -25,11 +25,20 @@ bool silentAgentThreadStopFlag = false;
 bool domainServerCheckinStopFlag = false;
 pthread_mutex_t vectorChangeMutex = PTHREAD_MUTEX_INITIALIZER;
 
+int unpackAgentId(unsigned char *packedData, uint16_t *agentId) {
+    memcpy(packedData, agentId, sizeof(uint16_t));
+    return sizeof(uint16_t);
+}
+
+int packAgentId(unsigned char *packStore, uint16_t agentId) {
+    memcpy(&agentId, packStore, sizeof(uint16_t));
+    return sizeof(uint16_t);
+}
+
 AgentList::AgentList(char newOwnerType, unsigned int newSocketListenPort) : agentSocket(newSocketListenPort) {
     ownerType = newOwnerType;
     socketListenPort = newSocketListenPort;
-    linkedDataCreateCallback = NULL;
+    lastAgentId = 0;
-    audioMixerSocketUpdate = NULL;
 }
 
 AgentList::~AgentList() {
@@ -116,10 +125,19 @@ int AgentList::indexOfMatchingAgent(sockaddr *senderAddress) {
     return -1;
 }
 
+uint16_t AgentList::getLastAgentId() {
+    return lastAgentId;
+}
+
+void AgentList::increaseAgentId() {
+    ++lastAgentId;
+}
+
 int AgentList::updateList(unsigned char *packetData, size_t dataBytes) {
     int readAgents = 0;
 
     char agentType;
+    uint16_t agentId;
     
     // assumes only IPv4 addresses
     sockaddr_in agentPublicSocket;
@@ -132,19 +150,20 @@ int AgentList::updateList(unsigned char *packetData, size_t dataBytes) {
     
     while((readPtr - startPtr) < dataBytes) {
         agentType = *readPtr++;
+        readPtr += unpackAgentId(readPtr, (uint16_t *)&agentId);
         readPtr += unpackSocket(readPtr, (sockaddr *)&agentPublicSocket);
         readPtr += unpackSocket(readPtr, (sockaddr *)&agentLocalSocket);
         
-        addOrUpdateAgent((sockaddr *)&agentPublicSocket, (sockaddr *)&agentLocalSocket, agentType);
+        addOrUpdateAgent((sockaddr *)&agentPublicSocket, (sockaddr *)&agentLocalSocket, agentType, agentId);
     }  
 
     return readAgents;
 }
 
-bool AgentList::addOrUpdateAgent(sockaddr *publicSocket, sockaddr *localSocket, char agentType) {
+bool AgentList::addOrUpdateAgent(sockaddr *publicSocket, sockaddr *localSocket, char agentType, uint16_t agentId) {
     std::vector<Agent>::iterator agent;
     
-    for(agent = agents.begin(); agent != agents.end(); agent++) {
+    for (agent = agents.begin(); agent != agents.end(); agent++) {
         if (agent->matches(publicSocket, localSocket, agentType)) {
             // we already have this agent, stop checking
             break;
@@ -153,7 +172,8 @@ bool AgentList::addOrUpdateAgent(sockaddr *publicSocket, sockaddr *localSocket,
     
     if (agent == agents.end()) {
         // we didn't have this agent, so add them
-        Agent newAgent = Agent(publicSocket, localSocket, agentType);
+        
+        Agent newAgent = Agent(publicSocket, localSocket, agentType, agentId);
         
         if (socketMatch(publicSocket, localSocket)) {
             // likely debugging scenario with DS + agent on local network

shared/src/AgentList.h

@@ -28,10 +28,12 @@ extern char DOMAIN_IP[100];    //  IP Address will be re-set by lookup on startu
 extern const int DOMAINSERVER_PORT;
 
 class AgentList {
+
     UDPSocket agentSocket;
     char ownerType;
     unsigned int socketListenPort;
     std::vector<Agent> agents;
+    uint16_t lastAgentId;
     pthread_t removeSilentAgentsThread;
     pthread_t checkInWithDomainServerThread;
     
@@ -42,13 +44,15 @@ public:
     
     void(*linkedDataCreateCallback)(Agent *);
     void(*audioMixerSocketUpdate)(in_addr_t, in_port_t);
-
+    
     std::vector<Agent>& getAgents();
     UDPSocket& getAgentSocket();
-
+    
     int updateList(unsigned char *packetData, size_t dataBytes);
     int indexOfMatchingAgent(sockaddr *senderAddress);
-    bool addOrUpdateAgent(sockaddr *publicSocket, sockaddr *localSocket, char agentType);
+    uint16_t getLastAgentId();
+    void increaseAgentId();
+    bool addOrUpdateAgent(sockaddr *publicSocket, sockaddr *localSocket, char agentType, uint16_t agentId);
     void processAgentData(sockaddr *senderAddress, void *packetData, size_t dataBytes);
     void updateAgentWithData(sockaddr *senderAddress, void *packetData, size_t dataBytes);
     void broadcastToAgents(char *broadcastData, size_t dataBytes);
@@ -63,4 +67,7 @@ public:
     void stopDomainServerCheckInThread();
 };
 
+int unpackAgentId(unsigned char *packedData, uint16_t *agentId);
+int packAgentId(unsigned char *packStore, uint16_t agentId);
+
 #endif /* defined(__hifi__AgentList__) */