void data_edit_array(TTPtr self, TTValue& array)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue keys, object, grab, t;
TTSymbol key, type;
TTObject aData;
// get each value from the data object itself
for (EXTRA->objectsSorted->begin();
EXTRA->objectsSorted->end();
EXTRA->objectsSorted->next()) {
aData = EXTRA->objectsSorted->current()[0];
// try to get the value or the value default
if (aData.get(kTTSym_value, grab))
aData.get(kTTSym_valueDefault, grab);
// if there is no value
if (grab.size() == 0) {
aData.get(kTTSym_type, t);
type = t[0];
if (type == kTTSym_string)
grab = kTTSym_none;
else
grab = 0;
}
array.prepend(grab);
}
}
void
DemoApp::SetupScore()
{
TTValue args, out;
TTObject xmlHandler("XmlHandler");
TTLogMessage("\n*** Initialisation of Score environnement ***\n");
/////////////////////////////////////////////////////////////////////
// Init the Score library (passing the folder path where all the dylibs are)
TTScoreInit("/usr/local/jamoma");
TTLogMessage("\n*** Reading of an interactive scenario file ***\n");
/////////////////////////////////////////////////////////////////////
// Create an empty Scenario
mScenario = TTObject("Scenario");
// Read DemoScenario1.score file to fill mScenario
xmlHandler.set("object", mScenario);
xmlHandler.send("Read", "../DemoScenario.score", out);
TTLogMessage("\n*** Prepare scenario observation ***\n");
/////////////////////////////////////////////////////////////////////
// Create a callback for the "EventStatusChanged" notification sent by each event
mEventStatusChangedCallback = TTObject("callback");
mEventStatusChangedCallback.set("baton", TTPtr(this));
mEventStatusChangedCallback.set("function", TTPtr(&DemoAppEventStatusChangedCallback));
mEventStatusChangedCallback.set("notification", TTSymbol("EventStatusChanged"));
// Get all events of the scenario and attach a callback to them
TTValue timeEvents;
mScenario.get("timeEvents", timeEvents);
for (TTElementIter it = timeEvents.begin() ; it != timeEvents.end() ; it++) {
TTObject event = TTElement(*it);
event.registerObserverForNotifications(mEventStatusChangedCallback);
}
TTLogMessage("\n*** Start scenario execution ***\n");
/////////////////////////////////////////////////////////////////////
// Set the execution speed of the scenario
mScenario.set("speed", 2.);
// Start the scenario
mScenario.send("Start");
// Poll Scenario information
mPollingThread = new TTThread(TTThreadCallbackType(DemoAppScenarioPollingThread), this);
}
TTErr
DemoAppEventStatusChangedCallback(const TTValue& baton, const TTValue& value)
{
DemoApp* demoApp = (DemoApp*)TTPtr(baton[0]);
TTObject event = value[0];
TTSymbol newStatus = value[1];
TTSymbol oldStatus = value[2];
// get the name of the event
TTSymbol name;
event.get("name", name);
// print the event status
TTLogMessage("%s status : %s \n", name.c_str(), newStatus.c_str());
return kTTErrNone;
}
void cue_get(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTHashPtr allCues;
TTValue v;
TTSymbol name, attribute;
TTObject cue;
long ac = 0;
t_atom *av = NULL;
if (argc == 2) {
if (atom_gettype(argv) == A_SYM && atom_gettype(argv+1) == A_SYM) {
attribute = TTSymbol((char*)atom_getsym(argv)->s_name);
name = TTSymbol((char*)atom_getsym(argv+1)->s_name);
// get cue object table
x->wrappedObject.get("cues", v);
allCues = TTHashPtr((TTPtr)v[0]);
if (allCues) {
// get cue
if (!allCues->lookup(name, v)) {
cue = v[0];
if (!cue.get(attribute, v)) {
v.prepend(name);
jamoma_ttvalue_to_Atom(v, &ac, &av);
object_obex_dumpout(self, atom_getsym(argv), ac, av);
}
else
object_error((t_object*)x, "%s attribute doesn't exist", atom_getsym(argv)->s_name);
}
else
object_error((t_object*)x, "%s cue doesn't exist", atom_getsym(argv+1)->s_name);
}
}
}
}
TTErr TTSoundfileLoader::test(TTValue& returnedTestInfo)
{
int errorCount = 0;
int testAssertionCount = 0;
// assemble the full path of the target sound file
TTString testSoundPath = TTFoundationBinaryPath;
int pos = testSoundPath.find_last_of('/');
testSoundPath = testSoundPath.substr(0,pos+1);
testSoundPath += TESTFILE;
std::cout << "We will be using the following path for testing: " << testSoundPath << "\n";
try {
TTTestLog("\n");
TTTestLog("Testing TTSoundfileLoader Basics...");
// TEST 0: establish our objects & pointers
TTObject* testTargetMatrix = new TTObject("samplematrix");
TTObject* testNonSampleMatrix = new TTObject("delay");
TTObjectBase* objectBasePtrToSampleMatrix;
TTObjectBase* ptrToNonSampleMatrix;
// TEST 1: set the filepath
TTBoolean result1 = { this->setFilePath(TT(testSoundPath)) == kTTErrNone };
TTTestAssertion("setFilePath operates successfully",
result1,
testAssertionCount,
errorCount);
// TEST 2: set up the samplematrix first
int channelsSend = 1; // compiler complained about TTInt32 being ambiguous here
int lengthSend = 22050; // compiler complained about TTInt32 being ambiguous here
testTargetMatrix->set("numChannels", channelsSend);
testTargetMatrix->set("lengthInSamples", lengthSend);
TTInt32 channelsReturn, lengthReturn;
testTargetMatrix->get("numChannels", channelsReturn);
testTargetMatrix->get("lengthInSamples", lengthReturn);
// now for the actual test
TTBoolean result2a = { channelsSend == channelsReturn };
TTTestAssertion("numChannels attribute set successfully",
result2a,
testAssertionCount,
errorCount);
TTBoolean result2b = { lengthSend == lengthReturn };
TTTestAssertion("lengthInSamples attribute set successfully",
result2b,
testAssertionCount,
errorCount);
//
// TEST 3: set the target via an objectBasePtr
objectBasePtrToSampleMatrix = testTargetMatrix->instance(); // is there a better syntax for this?
TTBoolean result3 = { this->setTargetMatrix(objectBasePtrToSampleMatrix) == kTTErrNone };
TTTestAssertion("setTargetMatrix via ObjectBasePtr operates successfully",
result3,
testAssertionCount,
errorCount);
// TEST 4: set the target to a non-SampleMatrix, should FAIL
ptrToNonSampleMatrix = testNonSampleMatrix->instance();
TTBoolean result4 = { this->setTargetMatrix(ptrToNonSampleMatrix) == kTTErrInvalidValue };
TTTestAssertion("setTargetMatrix returns error when not a SampleMatrix",
result4,
testAssertionCount,
errorCount);
// TEST 5: copy samplevalues until samplematrix is filled
TTBoolean result5 = { this->copyUntilFilled() == kTTErrNone };
TTTestAssertion("copyUntilFilled operates successfully",
result5,
testAssertionCount,
errorCount);
// releasing objects
objectBasePtrToSampleMatrix = NULL;
ptrToNonSampleMatrix = NULL;
delete testTargetMatrix;
delete testNonSampleMatrix;
// TEST 6: use TTSampleMatrix's load message, then compare 5 random sample values for equivalence
// create a new TTSampleMatrix
TTObject newTargetMatrix("samplematrix");
// set the length and channel count
newTargetMatrix.set("numChannels", TESTNUMCHANNELS);
newTargetMatrix.set("lengthInSamples", TESTDURATIONINSAMPLES);
// prepare necessary TTValues
TTValue loadInput6 = TT(testSoundPath); // we cannot pass the naked TTString, it needs to be part of a TTValue
TTValue aReturnWeDontCareAbout6;
// send message
TTBoolean result6a = { newTargetMatrix.send("load", loadInput6, aReturnWeDontCareAbout6) == kTTErrNone };
TTTestAssertion("TTSampleMatrix load operates successfully",
result6a,
testAssertionCount,
errorCount);
// now let's test some values!
int randomIndex6, randomChannel6;
TTSampleValue testValueSoundFile6;
TTBoolean result6b = true;
for (int i = 0; i<10; i++)
{
randomIndex6 = lengthReturn * TTRandom64();
randomChannel6 = i % TESTNUMCHANNELS;
//std::cout << "let's look at index " << randomIndex6 << " & channel " << randomChannel6 << "\n";
TTValue peekInput6(randomIndex6);
peekInput6.append(randomChannel6);
TTValue peekOutput6;
this->peek(randomIndex6,randomChannel6,testValueSoundFile6);
newTargetMatrix.send("peek",peekInput6,peekOutput6);
//std::cout << "Does " << testValueSoundFile6 << " = " << double(peekOutput6) << " ?\n";
if (result6b) // allows test to keep variable false once it is false
result6b = TTTestFloatEquivalence(testValueSoundFile6, double(peekOutput6), true, 0.0000001);
}
TTTestAssertion("comparing values @ 10 random indexes for equivalence",
result6b,
testAssertionCount,
errorCount);
// TEST 7: now use TTBuffer's load message, and again compare 5 random sample values for equivalence
// create a new TTBuffer with convenience syntax
TTAudioBuffer aBufferByAnyOtherName(TESTNUMCHANNELS, TESTDURATIONINSAMPLES);
// prepare necessary TTValues
TTValue loadInput7 = TT(testSoundPath); // we cannot pass the naked TTString, it needs to be part of a TTValue
// send message
TTBoolean result7a = { aBufferByAnyOtherName.load(loadInput7) == kTTErrNone };
TTTestAssertion("TTBuffer load operates successfully",
result7a,
testAssertionCount,
errorCount);
// setup pointer to samplematrix
TTSampleMatrixPtr myMatrix7;
// check out samplematrix
TTBoolean result7b = { aBufferByAnyOtherName.checkOutMatrix(myMatrix7) == kTTErrNone };
TTTestAssertion("TTBuffer checks out SampleMatrix successfully",
result7b,
testAssertionCount,
errorCount);
TTValue testChannel, testSample;
myMatrix7->getNumChannels(testChannel);
myMatrix7->getLengthInSamples(testSample);
//std::cout << "Samplematrix has " << int(testChannel) << " channels & " << int(testSample) << " samples\n";
// now let's test some values!
int randomIndex7, randomChannel7;
double testValueSoundFile7, testValueSampleMatrix7;
TTBoolean result7c = true;
for (int i = 0; i<10; i++)
{
randomIndex7 = lengthReturn * TTRandom64();
randomChannel7 = i % TESTNUMCHANNELS;
//std::cout << "let's look at index " << randomIndex7 << " & channel " << randomChannel7 << "\n";
this->peek(randomIndex7,randomChannel7,testValueSoundFile7);
myMatrix7->peek(randomIndex7,randomChannel7,testValueSampleMatrix7);
//std::cout << "Does " << testValueSoundFile7 << " = " << testValueSampleMatrix7 << " ?\n";
if (result7c) // allows test to keep variable false once it is false
result7c = TTTestFloatEquivalence(testValueSoundFile7, testValueSampleMatrix7, true, 0.0000001);
}
TTTestAssertion("comparing values @ 10 random indexes for equivalence",
result7c,
testAssertionCount,
errorCount);
// check in samplematrix
TTBoolean result7d = { aBufferByAnyOtherName.checkInMatrix(myMatrix7) == kTTErrNone };
TTTestAssertion("TTBuffer checks in SampleMatrix successfully",
result7d,
testAssertionCount,
errorCount);
// TEST 8: use optional load parameters to copy samples 5 to 15 from channel 0
// resize
aBufferByAnyOtherName.set("numChannels", 1);
aBufferByAnyOtherName.set("lengthInSamples", 10);
// prepare necessary TTValues
int copyChannel8 = 0; // first channel
int startIndex8 = 5; // start @ sample 5
int endIndex8 = 15; // end @ sample 15
TTValue loadInput8 = TT(testSoundPath); // we cannot pass the naked TTString, it needs to be part of a TTValue
loadInput8.append(copyChannel8);
loadInput8.append(startIndex8);
loadInput8.append(endIndex8);
// send message
TTBoolean result8a = { aBufferByAnyOtherName.load(loadInput8) == kTTErrNone };
TTTestAssertion("TTBuffer load operates successfully w optional parameters",
result8a,
testAssertionCount,
errorCount);
// setup pointer to samplematrix
TTSampleMatrixPtr myMatrix8;
// check out samplematrix
TTBoolean result8b = { aBufferByAnyOtherName.checkOutMatrix(myMatrix8) == kTTErrNone };
TTTestAssertion("TTBuffer checks out SampleMatrix successfully",
result8b,
testAssertionCount,
errorCount);
// now let's test some values!
double testValueSoundFile8, testValueSampleMatrix8;
TTBoolean result8c = true;
for (int i = 0; i<10; i++)
{
//std::cout << "let's look at index " << i << "\n";
this->peek(i+startIndex8,copyChannel8,testValueSoundFile8);
myMatrix8->peek(i,copyChannel8,testValueSampleMatrix8);
//std::cout << "Does " << testValueSoundFile8 << " = " << testValueSampleMatrix8 << " ?\n";
if (result8c) // allows test to keep variable false once it is false
result8c = TTTestFloatEquivalence(testValueSoundFile8, testValueSampleMatrix8, true, 0.0000001);
}
TTTestAssertion("comparing all 10 copied values for equivalence",
result8c,
testAssertionCount,
errorCount);
// check in samplematrix
TTBoolean result8d = { aBufferByAnyOtherName.checkInMatrix(myMatrix8) == kTTErrNone };
TTTestAssertion("TTBuffer checks in SampleMatrix successfully",
result8d,
testAssertionCount,
errorCount);
// TEST 9: load soundfile into buffer/samplematrix with different sample rate
TTValue testChannel9in = 2;
TTValue testSampleRate9in = 88200;
TTValue testLengthSec9in = 0.25;
aBufferByAnyOtherName.set("numChannels", testChannel9in);
aBufferByAnyOtherName.set("sampleRate", testSampleRate9in);
aBufferByAnyOtherName.set("lengthInSeconds", testLengthSec9in);
TTValue loadInput9 = TT(testSoundPath); // we cannot pass the naked TTString, it needs to be part of a TTValue
// send message
TTBoolean result9a = { aBufferByAnyOtherName.load(loadInput9) == kTTErrNone };
TTTestAssertion("TTBuffer load operates successfully when sample rates differ",
result9a,
testAssertionCount,
errorCount);
// setup pointer to samplematrix
TTSampleMatrixPtr myMatrix9;
// check out samplematrix
TTBoolean result9b = { aBufferByAnyOtherName.checkOutMatrix(myMatrix9) == kTTErrNone };
TTTestAssertion("TTBuffer checks out SampleMatrix successfully",
result9b,
testAssertionCount,
errorCount);
TTValue testChannel9, testSampleCount9, testSampleRate9;
myMatrix9->getAttributeValue("numChannels", testChannel9);
myMatrix9->getAttributeValue("lengthInSamples", testSampleCount9);
myMatrix9->getAttributeValue("sampleRate", testSampleRate9);
/*std::cout << "Samplematrix has " << TTInt32(testChannel9) << " channels & " << TTInt32(testSampleCount9) << " samples @ " << TTInt32(testSampleRate9) << " Hz\n";*/
// check out samplematrix
TTBoolean result9c = { TTInt32(testChannel9) == TTInt32(testChannel9in) &&
TTInt32(testSampleRate9) == TTInt32(testSampleRate9in) &&
TTInt32(testSampleCount9) == (TTInt32(testSampleRate9in) * TTFloat64(testLengthSec9in)) };
TTTestAssertion("SampleMatrix has same attributes set via TTBuffer",
result9c,
testAssertionCount,
errorCount);
// let's test some values
int randomIndex9, randomChannel9;
TTSampleValue testSoundFileValue9, testSampleMatrixValue9;
TTBoolean result9d = true;
for (int i = 0; i<10; i++)
{
randomIndex9 = int(testSampleCount9) * TTRandom64();
randomChannel9 = i % TESTNUMCHANNELS;
//std::cout << "let's look at index " << randomIndex9 << " & channel " << randomChannel9 << "\n";
this->peeki(float(randomIndex9)/2.0, randomChannel9, testSoundFileValue9);
myMatrix9->peek(randomIndex9, randomChannel9, testSampleMatrixValue9);
//std::cout << "Does " << testSoundFileValue9 << " = " << testSampleMatrixValue9 << " ?\n";
if (result9d) // allows test to keep variable false once it is false
result9d = TTTestFloatEquivalence(testSoundFileValue9, testSampleMatrixValue9, true, 0.0000001);
}
TTTestAssertion("comparing values @ 10 random indexes for equivalence",
result9d,
testAssertionCount,
errorCount);
// check in samplematrix
TTBoolean result9e = { aBufferByAnyOtherName.checkInMatrix(myMatrix9) == kTTErrNone };
TTTestAssertion("TTBuffer checks in SampleMatrix successfully",
result9e,
testAssertionCount,
errorCount);
// TEST 10: use resizeThenLoad message and test that TTSampleMatrix conforms to sound file loaded
TTAudioBuffer bufferForTest10(1,1); // start by making the buffer really tiny
TTValue loadInput10 = TT(testSoundPath);
// send message
TTBoolean result10a = { bufferForTest10.resizeThenLoad(loadInput10) == kTTErrNone };
TTTestAssertion("TTBuffer resizeThenLoad operates successfully",
result10a,
testAssertionCount,
errorCount);
// setup pointer to samplematrix
TTSampleMatrixPtr myMatrix10;
// check out samplematrix
TTBoolean result10b = { bufferForTest10.checkOutMatrix(myMatrix10) == kTTErrNone };
TTTestAssertion("TTBuffer checks out SampleMatrix successfully",
result10b,
testAssertionCount,
errorCount);
// do some more tests here
TTValue testChannel10, testLengthSec10, testLengthSample10;
myMatrix10->getAttributeValue("numChannels", testChannel10);
myMatrix10->getAttributeValue("lengthInSeconds", testLengthSec10);
myMatrix10->getAttributeValue("lengthInSamples", testLengthSample10);
/*std::cout << "Samplematrix has " << TTInt32(testChannel10) << " channels & " << TTInt32(testLengthSample10) << " samples and is " << TTFloat64(testLengthSec10) << " secs long\n";*/
TTBoolean result10c = { TTInt32(testChannel10) == TESTNUMCHANNELS &&
TTInt32(testLengthSample10) == TESTDURATIONINSAMPLES };
TTTestAssertion("TTBuffer.resizeThenLoad results in properly sized TTSampleMatrix",
result10c,
testAssertionCount,
errorCount);
// check in samplematrix
TTBoolean result10e = { bufferForTest10.checkInMatrix(myMatrix10) == kTTErrNone };
TTTestAssertion("TTBuffer checks in SampleMartix successfully",
result10e,
testAssertionCount,
errorCount);
} catch (...) {
TTTestAssertion("FAILED to run tests -- likely that necessary objects did not instantiate",
0,
testAssertionCount,
errorCount);
}
return TTTestFinish(testAssertionCount, errorCount, returnedTestInfo);
}
