void MessagePipe::processMessage(int inletIndex, PdMessage *message) {
switch (inletIndex) {
case 0: {
MessageElement *messageElement = message->getElement(0);
switch (messageElement->getType()) {
case SYMBOL: {
if (strcmp(messageElement->getSymbol(), "flush") == 0) {
// TODO(mhroth): output all stored messages immediately
break;
} else if (strcmp(messageElement->getSymbol(), "clear") == 0) {
// TODO(mhroth): forget all stored messages
break;
}
// allow fall-through
}
case FLOAT:
case BANG: {
message->setTimestamp(message->getTimestamp() + delayMs);
graph->scheduleMessage(this, 0, message);
break;
}
default: {
break;
}
}
}
default: {
break;
}
}
}
void MessageLine::processMessage(int inletIndex, PdMessage *message) {
switch (inletIndex) {
case 0: {
MessageElement *messageElement = message->getElement(0);
switch (messageElement->getType()) {
case FLOAT: {
MessageElement *messageElement1 = message->getElement(1);
if (messageElement1 != NULL && messageElement1->getType() == FLOAT) {
// start a new line
processDspToIndex(message->getBlockIndex());
float delayInMs = StaticUtils::millisecondsToSamples(
messageElement1->getFloat(), sampleRate);
samplesToTarget = lrintf(delayInMs);
target = messageElement->getFloat();
slope = (target - lastValue) / delayInMs;
} else {
// set the current value
processDspToIndex(message->getBlockIndex());
target = messageElement->getFloat();
lastValue = target;
slope = 0.0f;
samplesToTarget = -1;
}
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->getElement(0)->setFloat(lastValue);
outgoingMessage->setBlockIndex(message->getBlockIndex());
break;
}
case SYMBOL: {
MessageElement *messageElement = message->getElement(0);
if (strcmp(messageElement->getSymbol(), "stop") == 0) {
processDspToIndex(message->getBlockIndex());
samplesToTarget = -1;
} else if (strcmp(messageElement->getSymbol(), "set") == 0) {
MessageElement *messageElement1 = message->getElement(0);
if (messageElement1 != NULL && messageElement1->getType() == FLOAT) {
processDspToIndex(message->getBlockIndex());
target = messageElement1->getFloat();
lastValue = target;
samplesToTarget = -1;
}
}
break;
}
default: {
break;
}
}
break;
}
case 1: {
// not sure what to do in this case
break;
}
default: {
break;
}
}
}
MessagePack::MessagePack(List *messageElementList, char *initString) :
MessageInputMessageOutputObject(messageElementList->getNumElements(), 1, initString) {
this->messageElementList = messageElementList;
for (int i = 0; i < messageElementList->getNumElements(); i++) {
MessageElement *messageElement = (MessageElement *) messageElementList->get(i);
if (messageElement->getType() == SYMBOL) {
if (StaticUtils::isNumeric(messageElement->getSymbol())) {
float constant = (float) atof(messageElement->getSymbol());
messageElement->setFloat(constant);
} else if (strcmp(messageElement->getSymbol(), "float") == 0 ||
strcmp(messageElement->getSymbol(), "f") == 0) {
messageElement->setFloat(0.0f);
} else if (strcmp(messageElement->getSymbol(), "bang") == 0 ||
strcmp(messageElement->getSymbol(), "b") == 0) {
messageElement->setBang();
}
}
}
}
inline void MessagePack::processMessage(int inletIndex, PdMessage *message) {
MessageElement *messageElement = message->getElement(0);
MessageElement *outgoingMessageElement = (MessageElement *) messageElementList->get(inletIndex);
switch (outgoingMessageElement->getType()) {
case FLOAT: {
outgoingMessageElement->setFloat(messageElement->getFloat());
break;
}
case SYMBOL: {
outgoingMessageElement->setSymbol(messageElement->getSymbol());
break;
}
default: {
break;
}
}
if (inletIndex == 0) {
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->setBlockIndex(message->getBlockIndex());
for (int i = 0; i < messageElementList->getNumElements(); i++) {
messageElement = (MessageElement *) messageElementList->get(i);
switch (messageElement->getType()) {
case FLOAT: {
outgoingMessage->getElement(i)->setFloat(messageElement->getFloat());
break;
}
case SYMBOL: {
outgoingMessage->getElement(i)->setSymbol(messageElement->getSymbol());
break;
}
default: {
break;
}
}
}
}
}
void MessageSoundfiler::processMessage(int inletIndex, PdMessage *message) {
if (message->isSymbol(0) && strcmp(message->getSymbol(0), "read") == 0) {
int currentElementIndex = 1;
bool shouldResizeTable = false;
while (currentElementIndex < message->getNumElements()) {
MessageElement *messageElement = message->getElement(currentElementIndex++);
if (messageElement->getType() == SYMBOL) {
// only the -resize flag is supported for now
if (strcmp(messageElement->getSymbol(), "-resize") == 0) {
shouldResizeTable = true;
} else {
// all of the flags should have been seen now and now we expect the last two parameters,
// which are file location and destination table name
MessageElement *tableNameElement = message->getElement(currentElementIndex++);
if (messageElement != NULL && messageElement->getType() == SYMBOL &&
tableNameElement != NULL && tableNameElement->getType() == SYMBOL) {
MessageTable *table = graph->getTable(tableNameElement->getSymbol());
if (table != NULL) {
// use libsndfile to load and read the file (also converting the samples to [-1,1] float)
SF_INFO sfInfo;
char *fullPath = graph->resolveFullPath(messageElement->getSymbol());
SNDFILE *sndFile = sf_open(fullPath, SFM_READ, &sfInfo);
if (sndFile == NULL) {
graph->printErr("soundfiler can't open %s.", fullPath);
free(fullPath);
return; // there was an error reading the file. Move on with life.
}
free(fullPath);
// It is assumed that the channels are interleaved.
int samplesPerChannel = sfInfo.frames;
int bufferLength = samplesPerChannel * sfInfo.channels;
// create a buffer in memory for the file data
float *buffer = (float *) malloc(bufferLength * sizeof(float));
sf_read_float(sndFile, buffer, bufferLength); // read the whole file into memory
sf_close(sndFile); // release the handle to the file
if (sfInfo.channels > 0) { // sanity check
// get the table's buffer. Resize the buffer if necessary.
int tableLength = samplesPerChannel;
float *tableBuffer = shouldResizeTable ? table->resizeBuffer(samplesPerChannel) :
table->getBuffer(&tableLength);
if (tableLength > samplesPerChannel) {
// avoid trying to read more into the table buffer than is available
tableLength = samplesPerChannel;
}
// extract the first channel
for (int i = 0, j = 0; i < bufferLength; i+=sfInfo.channels, j++) {
tableBuffer[j] = buffer[i];
}
// extract the second channel (if it exists and if there is a table to write it to)
if (sfInfo.channels > 1 &&
(tableNameElement = message->getElement(currentElementIndex++)) != NULL &&
tableNameElement->getType() == SYMBOL &&
(table = graph->getTable(tableNameElement->getSymbol())) != NULL) {
tableLength = samplesPerChannel;
tableBuffer = shouldResizeTable ? table->resizeBuffer(samplesPerChannel) :
table->getBuffer(&tableLength);
if (tableLength > samplesPerChannel) {
// avoid trying to read more into the table buffer than is available
tableLength = samplesPerChannel;
}
for (int i = 1, j = 0; i < bufferLength; i+=sfInfo.channels, j++) {
tableBuffer[j] = buffer[i];
}
}
}
free(buffer);
// send message with sample length when all tables have been filled
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->setFloat(0, (float) samplesPerChannel);
outgoingMessage->setTimestamp(message->getTimestamp());
sendMessage(0, outgoingMessage);
}
}
}
}
}
} else if (message->isSymbol(0) && strcmp(message->getSymbol(0), "write") == 0) {
// TODO(mhroth): not supported yet
graph->printErr("The \"write\" command to soundfiler is not supported.");
}
}
