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 MessageSelect::processMessage(int inletIndex, PdMessage *message) {
switch (inletIndex) {
case 0: {
MessageElement *messageElement = message->getElement(0);
for (int i = 0; i < messageElementList->getNumElements(); i++) {
MessageElement *selector = (MessageElement *) messageElementList->get(i);
if (messageElement->equals(selector)) {
PdMessage *outgoingMessage = getNextOutgoingMessage(i);
outgoingMessage->setBlockIndex(message->getBlockIndex());
return;
}
}
setNextOutgoingMessage(messageElementList->getNumElements(), message);
break;
}
case 1: {
// TODO(mhroth): be able to set the selctor
break;
}
default: {
break;
}
}
}
PdMessage *MessagePack::newCanonicalMessage() {
PdMessage *message = new PdMessage();
for (int i = 0; i < messageElementList->getNumElements(); i++) {
MessageElement *messageElement = (MessageElement *) messageElementList->get(i);
message->addElement(messageElement->copy());
}
return message;
}
inline void DspSig::processMessage(int inletIndex, PdMessage *message) {
if (inletIndex == 0) {
MessageElement *messageElement = message->getElement(0);
if (messageElement != NULL && messageElement->getType() == FLOAT) {
processDspToIndex(message->getBlockIndex());
constWasReset = constant != messageElement->getFloat();
constant = messageElement->getFloat();
}
}
}
inline void MessageAbsoluteValue::processMessage(int inletIndex, PdMessage *message) {
if (inletIndex == 0) {
MessageElement *messageElement = message->getElement(0);
if (messageElement != NULL && messageElement->getType() == FLOAT) {
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->setBlockIndex(message->getBlockIndex());
outgoingMessage->getElement(0)->setFloat(fabsf(messageElement->getFloat()));
}
}
}
void MessageUnaryOperationObject::processMessage(int inletIndex, PdMessage *message) {
if (inletIndex == 0) {
// TODO(mhroth): do we need to be able to handle a list of numbers?
MessageElement *messageElement = message->getElement(0);
if (messageElement->getType() == FLOAT) {
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->setBlockIndex(message->getBlockIndex());
outgoingMessage->getElement(0)->setFloat(performUnaryOperation(messageElement->getFloat()));
}
}
}
void MessageArcTangent::processMessage(int inletIndex, PdMessage *message) {
if (inletIndex == 0) {
MessageElement *messageElement = message->getElement(0);
if (messageElement->getType() == FLOAT) {
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->getElement(0)->setFloat(atanf(messageElement->getFloat()));
outgoingMessage->setTimestamp(message->getTimestamp());
sendMessage(0, outgoingMessage); // send a message from outlet 0
}
}
}
Dimension MessageBubble::GetPlaceholderSize() {
int width = 0, height = 0;
for (int i=0; i<pElements->GetCount(); i++) {
MessageElement *pElement = static_cast<MessageElement *>(pElements->GetAt(i));
if (width < pElement->GetWidth())
width = pElement->GetWidth();
height += pElement->GetHeight();
if (i+1 < pElements->GetCount())
height += BUBBLE_ITEM_SPACING;
}
return Dimension(width, height);
}
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;
}
}
}
void DspPhasor::processMessage(int inletIndex, PdMessage *message) {
switch (inletIndex) {
case 0: { // update the frequency
MessageElement *messageElement = message->getElement(0);
if (messageElement->getType() == FLOAT) {
processDspToIndex(message->getBlockIndex(graph->getBlockStartTimestamp(), graph->getSampleRate()));
frequency = messageElement->getFloat();
}
break;
}
case 1: { // update the phase
// TODO(mhroth)
break;
}
default: {
break;
}
}
}
inline void MessageFloat::processMessage(int inletIndex, PdMessage *message) {
if (inletIndex == 0) {
MessageElement *messageElement = message->getElement(0);
switch (messageElement->getType()) {
case FLOAT: {
constant = messageElement->getFloat();
// allow fallthrough
}
case BANG: {
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->getElement(0)->setFloat(constant);
outgoingMessage->setBlockIndex(message->getBlockIndex());
break;
}
default: {
break;
}
}
}
}
void
nsConsoleService::ClearMessagesForWindowID(const uint64_t innerID)
{
MOZ_RELEASE_ASSERT(NS_IsMainThread());
MutexAutoLock lock(mLock);
for (MessageElement* e = mMessages.getFirst(); e != nullptr; ) {
// Only messages implementing nsIScriptError interface expose the
// inner window ID.
nsCOMPtr<nsIScriptError> scriptError = do_QueryInterface(e->Get());
if (!scriptError) {
e = e->getNext();
continue;
}
uint64_t innerWindowID;
nsresult rv = scriptError->GetInnerWindowID(&innerWindowID);
if (NS_FAILED(rv) || innerWindowID != innerID) {
e = e->getNext();
continue;
}
MessageElement* next = e->getNext();
e->remove();
delete e;
mCurrentSize--;
MOZ_ASSERT(mCurrentSize < mMaximumSize);
e = next;
}
}
inline void DspLine::processMessage(int inletIndex, PdMessage *message) {
if (inletIndex == 0) { // not sure what the right inlet is for
switch (message->getNumElements()) {
case 0: {
break; // nothing to do
}
case 1: {
// jump to value
MessageElement *messageElement = message->getElement(0);
if (messageElement->getType() == FLOAT) {
processDspToIndex(message->getBlockIndex());
blockIndexOfLastMessage = message->getBlockIndex();
target = messageElement->getFloat();
lastOutputSample = target;
slope = 0.0f;
numSamplesToTarget = 0;
}
break;
}
default: { // at least two inputs
// new ramp
MessageElement *messageElement0 = message->getElement(0);
MessageElement *messageElement1 = message->getElement(1);
if (messageElement0 != NULL && messageElement0->getType() == FLOAT &&
messageElement1 != NULL && messageElement1->getType() == FLOAT) {
processDspToIndex(message->getBlockIndex());
blockIndexOfLastMessage = message->getBlockIndex();
target = messageElement0->getFloat();
float timeToTargetMs = messageElement1->getFloat(); // no negative time to targets!
float fractionalSamplesToTarget = StaticUtils::millisecondsToSamples(
(timeToTargetMs < 1.0f) ? 1.0f : timeToTargetMs, sampleRate);
slope = (target - lastOutputSample) / fractionalSamplesToTarget;
numSamplesToTarget = (int) fractionalSamplesToTarget;
}
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();
}
}
}
}
void MessageTimer::processMessage(int inletIndex, PdMessage *message) {
switch (inletIndex) {
case 0: {
MessageElement *messageElement = message->getElement(0);
if (messageElement->getType() == BANG) {
processDspToIndex(message->getBlockIndex());
elapsedSamples = 0.0f;
}
break;
}
case 1: {
// return the elapsed number milliseconds
processDspToIndex(message->getBlockIndex());
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->getElement(0)->setFloat(1000.0f * elapsedSamples / sampleRate);
outgoingMessage->setBlockIndexAsFloat(message->getBlockIndexAsFloat());
break;
}
default: {
break;
}
}
}
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 MessageSwap::processMessage(int inletIndex, PdMessage *message) {
switch (inletIndex) {
case 0: {
MessageElement *messageElement = message->getElement(0);
switch (messageElement->getType()) {
case FLOAT: {
left = messageElement->getFloat();
PdMessage *outgoingMessageRight = getNextOutgoingMessage(0);
outgoingMessageRight->getElement(0)->setFloat(left);
outgoingMessageRight->setTimestamp(message->getTimestamp());
sendMessage(1, outgoingMessageRight); // send a message from outlet 1
PdMessage *outgoingMessageLeft = getNextOutgoingMessage(1);
outgoingMessageLeft->getElement(0)->setFloat(right);
outgoingMessageLeft->setTimestamp(message->getTimestamp());
sendMessage(0, outgoingMessageLeft); // send a message from outlet 0
break;
}
case BANG: {
PdMessage *outgoingMessageRight = getNextOutgoingMessage(0);
outgoingMessageRight->getElement(0)->setFloat(left);
outgoingMessageRight->setTimestamp(message->getTimestamp());
sendMessage(0, outgoingMessageRight); // send a message from outlet 1
PdMessage *outgoingMessageLeft = getNextOutgoingMessage(1);
outgoingMessageLeft->getElement(0)->setFloat(right);
outgoingMessageLeft->setTimestamp(message->getTimestamp());
sendMessage(1, outgoingMessageLeft); // send a message from outlet 0
break;
}
default: {
break;
}
}
break;
}
case 1: {
MessageElement *messageElement = message->getElement(0);
if (messageElement->getType() == FLOAT) {
right = messageElement->getFloat();
}
break;
}
default: {
break;
}
}
}
void MessageSubtract::processMessage(int inletIndex, PdMessage *message) {
switch (inletIndex) {
case 0: {
MessageElement *messageElement = message->getElement(0);
if (messageElement->getType() == FLOAT) {
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->getElement(0)->setFloat(messageElement->getFloat() - constant);
outgoingMessage->setTimestamp(message->getTimestamp());
sendMessage(0, outgoingMessage); // send a message from outlet 0
}
break;
}
case 1: {
MessageElement *messageElement = message->getElement(0);
if (messageElement->getType() == FLOAT) {
constant = messageElement->getFloat();
}
break;
}
default: {
break;
}
}
}
TableViewItem* VKUMessagesListItemProvider::CreateItem(int index, int itemWidth) {
result r;
AppLog("VKUMessagesListItemProvider::CreateItem");
RoundedAvatar *pAvatar; // NOTE: used only if chat and message is out==0
MessageBubble* pMessageBubble;
RelativeLayout itemLayout;
Color bgColor;
JsonObject *itemObject;
IJsonValue *itemValue;
TableViewItem* pItem;
JsonNumber outNumber;
ArrayList *pMessageElements;
Label *pTimeStamp;
String timespampText;
int timestampValue;
String messageText(L"no text????");
int out = 0, readState = 0;
// reverse list
int reversedIndex = _messagesJson->GetCount() - 1 - index;
AppLog("Item %d of %d", reversedIndex, GetItemCount());
// get message string
r = _messagesJson->GetAt(reversedIndex, itemValue);
TryCatch(r == E_SUCCESS, , "Failed GetAt");
itemObject = static_cast<JsonObject *>(itemValue);
JsonParseUtils::GetInteger(*itemObject, L"out", out);
JsonParseUtils::GetInteger(*itemObject, L"date", timestampValue);
JsonParseUtils::GetInteger(*itemObject, L"read_state", readState);
TimeUtils::GetDialogsTime(timestampValue, timespampText);
// create rich text panel
AppLog("Message is %d == out", out);
pMessageBubble = new MessageBubble();
r = pMessageBubble->Construct(Dimension(itemWidth, LIST_HEIGHT));
TryCatch(r == E_SUCCESS, , "Failed Construct RichTextPanel");
pMessageBubble->SetOut(out);
AppLog("RTPanel created and constructed");
itemLayout.Construct();
// get available elements
pMessageElements = GetMessageElementsN(itemObject, itemWidth);
// message text element
for (int i=0; i<pMessageElements->GetCount(); i++) {
AppLog("Adding element %d to pItem", i);
MessageElement *pElement = static_cast<MessageElement *>(pMessageElements->GetAt(i));
pMessageBubble->AddElement(pElement);
AppLog("Added element %d to pItem with size of %dx%d", i, pElement->GetWidth(), pElement->GetHeight());
}
// timestamp label
pTimeStamp = new Label();
pTimeStamp->Construct(Rectangle(0, 0, 100, 28), timespampText);
pTimeStamp->SetTextConfig(28, LABEL_TEXT_STYLE_NORMAL);
pTimeStamp->SetTextColor(Color(TIMESTAMP_TEXT_COLOR, false));
// create table item
pItem = new TableViewItem();
r = pItem->Construct(itemLayout, Dimension(itemWidth, pMessageBubble->GetHeight() + 2*BUBBLE_VERTICAL_MARGIN));
TryCatch(r == E_SUCCESS, , "Failed GetAt");
if (out == 0 && _peerId > 2000000000) {
int fromId;
JsonParseUtils::GetInteger(*itemObject, L"from_id", fromId);
AppLog("Finding avatar for %d", fromId);
pAvatar = new RoundedAvatar(AVATAR_NORMAL);
String * avatarUrl = static_cast<String *>(_pUserIdAvatarMap->GetValue(Integer(fromId)));
pAvatar->Construct(Rectangle(0, 0, 80, 80), *avatarUrl);
r = pItem->AddControl(pAvatar);
itemLayout.SetRelation(*pAvatar, pItem, RECT_EDGE_RELATION_LEFT_TO_LEFT);
itemLayout.SetRelation(*pAvatar, pItem, RECT_EDGE_RELATION_TOP_TO_TOP);
itemLayout.SetMargin(*pAvatar, 10, 0, 10, 0);
}
// add rich text panel to table item
r = pItem->AddControl(pMessageBubble);
TryCatch(r == E_SUCCESS, , "Failed AddControl");
r = pItem->AddControl(pTimeStamp);
itemLayout.SetCenterAligned(*pMessageBubble, CENTER_ALIGN_VERTICAL);
itemLayout.SetHorizontalFitPolicy(*pTimeStamp, FIT_POLICY_CONTENT);
if (out == 1) {
itemLayout.SetRelation(*pMessageBubble, *pItem, RECT_EDGE_RELATION_RIGHT_TO_RIGHT);
itemLayout.SetMargin(*pMessageBubble, 0, 10, 0, 0);
itemLayout.SetRelation(*pTimeStamp, *pMessageBubble, RECT_EDGE_RELATION_RIGHT_TO_LEFT);
itemLayout.SetRelation(*pTimeStamp, *pItem, RECT_EDGE_RELATION_BOTTOM_TO_BOTTOM);
itemLayout.SetMargin(*pTimeStamp, 0, 10, 0, 30);
} else {
if (_peerId > 2000000000) {
itemLayout.SetRelation(*pMessageBubble, pAvatar, RECT_EDGE_RELATION_LEFT_TO_RIGHT);
itemLayout.SetMargin(*pMessageBubble, 10, 0, 0, 0);
} else {
itemLayout.SetRelation(*pMessageBubble, *pItem, RECT_EDGE_RELATION_LEFT_TO_LEFT);
itemLayout.SetMargin(*pMessageBubble, 10, 0, 0, 0);
}
itemLayout.SetRelation(*pTimeStamp, *pMessageBubble, RECT_EDGE_RELATION_LEFT_TO_RIGHT);
itemLayout.SetRelation(*pTimeStamp, *pItem, RECT_EDGE_RELATION_BOTTOM_TO_BOTTOM);
itemLayout.SetMargin(*pTimeStamp, 10, 0, 0, 30);
}
// colors
if (out == 1 && readState == 0) {
bgColor = Color(LIST_ITEM_UNREAD_COLOR, false);
} else {
bgColor = Color::GetColor(COLOR_ID_BLACK);
}
pItem->SetBackgroundColor(bgColor, TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL);
pItem->SetBackgroundColor(bgColor, TABLE_VIEW_ITEM_DRAWING_STATUS_PRESSED);
pItem->SetBackgroundColor(bgColor, TABLE_VIEW_ITEM_DRAWING_STATUS_HIGHLIGHTED);
pItem->RequestRedraw(true);
AppLog("Returning item");
return pItem;
CATCH:
AppLogException("$${Function:CreateItem} is failed. %s", GetErrorMessage(r));
return null;
}
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.");
}
}
