Mirrors/overte-lubosz
3
0
Fork 0
mirror of https://github.com/lubosz/overte.git synced 2025-08-07 17:41:12 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

hook up the injector to the new AudioInjector class

Browse source
This commit is contained in:
Stephen Birarda 2013-04-23 11:48:01 -07:00
parent beee875e88
commit 88fe04bcd1
2 changed files with 57 additions and 95 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

129
injector/src/injector.cpp
View file

@ -1,5 +1,5 @@
// //
// injector.cpp // main.cpp
// Audio Injector // Audio Injector
// //
// Created by Leonardo Murillo on 3/5/13. // Created by Leonardo Murillo on 3/5/13.
@ -11,39 +11,27 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
#include <vector>
#include <fstream>
#include <algorithm>
#include <arpa/inet.h> #include <arpa/inet.h>
#include <string.h> #include <string.h>
#include <sstream> #include <sstream>
#include "UDPSocket.h"
#include "UDPSocket.cpp"
#include <SharedUtil.h> #include <SharedUtil.h>
#include <PacketHeaders.h> #include <PacketHeaders.h>
#include <UDPSocket.h>
#include <AudioInjector.h>
char EC2_WEST_AUDIO_SERVER[] = "54.241.92.53"; char EC2_WEST_AUDIO_SERVER[] = "54.241.92.53";
const int AUDIO_UDP_LISTEN_PORT = 55443; 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 // Command line parameter defaults
bool loopAudio = true; bool loopAudio = true;
float sleepIntervalMin = 1.00; float sleepIntervalMin = 1.00;
float sleepIntervalMax = 2.00; float sleepIntervalMax = 2.00;
float positionInUniverse[] = {0, 0, 0, 0}; char *sourceAudioFile = NULL;
unsigned char attenuationModifier = 255;
char *sourceAudioFile;
const char *allowedParameters = ":rb::t::c::a::f:"; const char *allowedParameters = ":rb::t::c::a::f:";
float floatArguments[4] = {0.0f, 0.0f, 0.0f, 0.0f};
char *charBuffer; unsigned char attenuationModifier = 255;
int16_t *buffer;
long length;
UDPSocket *streamSocket;
void usage(void) void usage(void)
{ {
@ -62,19 +50,19 @@ bool processParameters(int parameterCount, char* parameterData[])
while ((p = getopt(parameterCount, parameterData, allowedParameters)) != -1) { while ((p = getopt(parameterCount, parameterData, allowedParameters)) != -1) {
switch (p) { switch (p) {
case 'r': case 'r':
loopAudio = false; ::loopAudio = false;
std::cout << "[DEBUG] Random sleep mode enabled" << std::endl; std::cout << "[DEBUG] Random sleep mode enabled" << std::endl;
break; break;
case 'b': case 'b':
sleepIntervalMin = atof(optarg); ::sleepIntervalMin = atof(optarg);
std::cout << "[DEBUG] Min delay between plays " << sleepIntervalMin << "sec" << std::endl; std::cout << "[DEBUG] Min delay between plays " << sleepIntervalMin << "sec" << std::endl;
break; break;
case 't': case 't':
sleepIntervalMax = atof(optarg); ::sleepIntervalMax = atof(optarg);
std::cout << "[DEBUG] Max delay between plays " << sleepIntervalMax << "sec" << std::endl; std::cout << "[DEBUG] Max delay between plays " << sleepIntervalMax << "sec" << std::endl;
break; break;
case 'f': case 'f':
sourceAudioFile = optarg; ::sourceAudioFile = optarg;
std::cout << "[DEBUG] Opening file: " << sourceAudioFile << std::endl; std::cout << "[DEBUG] Opening file: " << sourceAudioFile << std::endl;
break; break;
case 'c': case 'c':
@ -84,7 +72,7 @@ bool processParameters(int parameterCount, char* parameterData[])
int i = 0; int i = 0;
while (std::getline(ss, token, ',')) { while (std::getline(ss, token, ',')) {
positionInUniverse[i] = atof(token.c_str()); ::floatArguments[i] = atof(token.c_str());
++i; ++i;
if (i == 4) { if (i == 4) {
break; break;
@ -94,7 +82,7 @@ bool processParameters(int parameterCount, char* parameterData[])
break; break;
} }
case 'a': case 'a':
attenuationModifier = atoi(optarg); ::attenuationModifier = atoi(optarg);
std::cout << "[DEBUG] Attenuation modifier: " << optarg << std::endl; std::cout << "[DEBUG] Attenuation modifier: " << optarg << std::endl;
break; break;
default: default:
@ -105,77 +93,42 @@ bool processParameters(int parameterCount, char* parameterData[])
return true; return true;
}; };
void loadFile(void) { int main(int argc, char* argv[]) {
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] = PACKET_HEADER_INJECT_AUDIO;
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)); srand(time(0));
int AUDIO_UDP_SEND_PORT = 1500 + (rand() % (int)(1500 - 2000 + 1)); int AUDIO_UDP_SEND_PORT = 1500 + (rand() % (int)(1500 - 2000 + 1));
streamSocket = new UDPSocket(AUDIO_UDP_SEND_PORT); UDPSocket streamSocket = UDPSocket(AUDIO_UDP_SEND_PORT);
if (processParameters(argc, argv)) { sockaddr_in mixerSocket;
if (sourceAudioFile) { mixerSocket.sin_family = AF_INET;
loadFile(); mixerSocket.sin_addr.s_addr = inet_addr(EC2_WEST_AUDIO_SERVER);
} else { mixerSocket.sin_port = htons((uint16_t)AUDIO_UDP_LISTEN_PORT);
if (processParameters(argc, argv)) {
if (::sourceAudioFile == NULL) {
std::cout << "[FATAL] Source audio file not specified" << std::endl; std::cout << "[FATAL] Source audio file not specified" << std::endl;
exit(-1); exit(-1);
} } else {
AudioInjector injector = AudioInjector(sourceAudioFile);
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) { injector.setPosition(::floatArguments);
delay = 0; injector.setBearing(*(::floatArguments + 3));
} else { injector.setAttenuationModifier(::attenuationModifier);
delay = randFloatInRange(sleepIntervalMin, sleepIntervalMax);
float delay = 0;
int usecDelay = 0;
while (true) {
injector.injectAudio(&streamSocket, (sockaddr*) &mixerSocket);
if (!::loopAudio) {
delay = randFloatInRange(::sleepIntervalMin, ::sleepIntervalMax);
usecDelay = delay * 1000 * 1000;
usleep(usecDelay);
}
} }
usecDelay = delay * 1000 * 1000; }
usleep(usecDelay);
}
} }
return 0; return 0;
} }

23
libraries/shared/src/AudioInjector.cpp
View file

@ -65,19 +65,28 @@ void AudioInjector::injectAudio(UDPSocket *injectorSocket, sockaddr *destination
currentPacketPtr += sizeof(float); currentPacketPtr += sizeof(float);
} }
memcpy(currentPacketPtr, &_bearing, sizeof(float));
currentPacketPtr += sizeof(float);
*currentPacketPtr = _attenuationModifier; *currentPacketPtr = _attenuationModifier;
currentPacketPtr++; currentPacketPtr++;
for (int i = 0; i < _numTotalBytesAudio; i += BUFFER_LENGTH_SAMPLES) { memcpy(currentPacketPtr, &_bearing, sizeof(float));
currentPacketPtr += sizeof(float);
for (int i = 0; i < _numTotalBytesAudio; i += BUFFER_LENGTH_BYTES) {
gettimeofday(&startTime, NULL); gettimeofday(&startTime, NULL);
memcpy(currentPacketPtr, _audioSampleArray + i, BUFFER_LENGTH_BYTES); int numBytesToCopy = BUFFER_LENGTH_BYTES;
if (_numTotalBytesAudio - i < BUFFER_LENGTH_BYTES) {
numBytesToCopy = _numTotalBytesAudio - i;
memset(currentPacketPtr + numBytesToCopy, 0, BUFFER_LENGTH_BYTES - numBytesToCopy);
}
memcpy(currentPacketPtr, _audioSampleArray + (i / 2), numBytesToCopy);
injectorSocket->send(destinationSocket, dataPacket, sizeof(dataPacket)); injectorSocket->send(destinationSocket, dataPacket, sizeof(dataPacket));
double usecToSleep = usecTimestamp(&startTime) + BUFFER_SEND_INTERVAL_USECS - usecTimestampNow(); double usecToSleep = BUFFER_SEND_INTERVAL_USECS - (usecTimestampNow() - usecTimestamp(&startTime));
usleep(usecToSleep); if (usecToSleep > 0) {
usleep(usecToSleep);
}
} }
} }