NSPStatus
Namespace::namespaceValueSend(std::string address, TTSymbolPtr attribute, TTValue value, int instance)
{
TTSenderPtr sender = NULL;
// prepare arguments : see TTSender.h to know which args are needed
TTValue args;
args.clear();
args.append(GalamusApplication);
// add Application name to the address
std::string absAddress = AppName + address;
// add instance number
if (instance != 0) {
absAddress += ".";
stringstream st;
st << instance;
absAddress += st.str();
}
args.append(TT(absAddress));
args.append(attribute);
TTObjectInstantiate(TTSymbol("Sender"), TTObjectHandle(&sender), args);
sender->sendMessage(kTTSym_Send, value);
// note : the value is returned by the Data and the Receiver
//TTObjectRelease(TTObjectHandle(&sender));// throw an exception on windows
return NSP_NO_ERROR;
}
TTErr TTScoreTimeProcessCreate(TTTimeProcessPtr *timeProcess, const std::string timeProcessClass, TTTimeEventPtr startEvent, TTTimeEventPtr endEvent, TTTimeContainerPtr timeContainer)
{
TTValue args;
*timeProcess = NULL;
if (timeContainer) {
TTValue out;
TTErr err;
args = TTSymbol(timeProcessClass);
args.append(TTObjectBasePtr(startEvent));
args.append(TTObjectBasePtr(endEvent));
err = timeContainer->sendMessage(TTSymbol("TimeProcessCreate"), args, out);
if (!err)
*timeProcess = TTTimeProcessPtr(TTObjectBasePtr(out[0]));
return err;
}
else {
args = TTObjectBasePtr(startEvent);
args.append(TTObjectBasePtr(endEvent));
return TTObjectBaseInstantiate(timeProcessClass.c_str(), TTObjectBaseHandle(timeProcess), args);
}
}
NSPStatus
Namespace::namespaceInit(bool useDeviceManager)
{
// Initialise TT environments
TTModularInit(m_appName, "");
GalamusApplication = (TTApplicationPtr)TTModularGetApplication(TT(m_appName));
if (NSPDirectory == NULL) {
return NSP_INIT_ERROR;
}
if (useDeviceManager) {
// Initialise DeviceManager if wanted
/*TTDeviceManagerPtr */m_deMan = NULL;
TTValue args;
// Make a TTDeviceManager object
args.append(GalamusApplication);
args.append(TT(m_appName));
TTObjectInstantiate(TTSymbol("DeviceManager"), TTObjectHandle(&m_deMan), args);
// Load plugins and config with xml
TTValue value;
value.append(TT(PLUGINS_PATH));
value.append(TT(XML_CONFIG_PATH));
m_deMan->LoadPlugins(value);
// Load devices with xml
m_deMan->LoadDeviceXmlConfig(TT(XML_CONFIG_PATH));
}
return NSP_NO_ERROR;
}
void ramp_setFunctionParameter(t_ramp *obj, t_symbol *msg, long argc, t_atom *argv)
{
TTSymbol* parameterName;
TTValue newValue;
int i;
TTValue v;
if (argc < 2) {
error("jcom.map: not enough arguments to setParameter");
return;
}
// get the correct TT name for the parameter given the Max name
parameterName = TT(atom_getsym(argv)->s_name);
obj->parameterNames->lookup(parameterName, v);
v.get(0, ¶meterName);
for (i=1; i<=(argc-1); i++) {
if (argv[i].a_type == A_SYM)
newValue.append(TT(atom_getsym(argv+1)->s_name));
else
newValue.append(atom_getfloat(argv+i));
}
obj->rampUnit->setFunctionParameterValue(parameterName, newValue);
}
TTErr TTData::rampSetup()
{
TTValue args;
// 1. destroy the old ramp object
if (mRamper.valid()) {
mRamper = TTObject();
externalRampTime = 0;
}
// 2. create the new ramp object
// For some types ramping doesn't make sense, so they will be set to none
if (mType == kTTSym_none || mType == kTTSym_string || mType == kTTSym_generic)
mRampDrive = kTTSym_none;
else {
// don't create ramper for external ramp drive
if (mRampDrive == kTTSym_external || mRampDrive == kTTSym_none)
return kTTErrNone;
args.append((TTPtr)&TTDataRampCallback);
args.append((TTPtr)this); // we have to store this as a pointer
mRamper = TTObject("Ramp", args);
mRamper.set("drive", mRampDrive);
}
#ifndef TT_NO_DSP
// 3. reset the ramp function
return setRampFunction(mRampFunction);
#else
return kTTErrNone;
#endif
}
void RampLib::getUnitNames(TTValue& unitNames)
{
unitNames.clear();
unitNames.append(TT("async"));
unitNames.append(TT("none"));
unitNames.append(TT("queue"));
unitNames.append(TT("scheduler"));
}
NSPStatus
Namespace::namespaceParameterCreate(std::string address, int instanceNumber, void* object, void (*returnValueCallback) (TTPtr, TTValue&)
, void (*returnAddressCallback)(TTPtr, TTValue&))
{
// Create a TTData
TTDataPtr data = NULL;
TTCallbackPtr p_returnValueCallback, p_returnAddressCallback;
TTValuePtr p_returnValueBaton, p_returnAddressBaton;
// prepare arguments : see TTData.h to know which args are needed
TTValue args;
args.clear();
p_returnValueCallback = NULL;
TTObjectInstantiate(TTSymbol("callback"), TTObjectHandle(&p_returnValueCallback), kTTValNONE);
p_returnValueBaton = new TTValue(TTPtr(object));
p_returnValueCallback->setAttributeValue(kTTSym_baton, TTPtr(p_returnValueBaton));
p_returnValueCallback->setAttributeValue(kTTSym_function, TTPtr(returnValueCallback));
args.append(p_returnValueCallback);
p_returnAddressCallback = NULL;
TTObjectInstantiate(TTSymbol("callback"), TTObjectHandle(&p_returnAddressCallback), kTTValNONE);
p_returnAddressBaton = new TTValue(TTPtr(object));
p_returnAddressCallback->setAttributeValue(kTTSym_baton, TTPtr(p_returnAddressBaton));
p_returnAddressCallback->setAttributeValue(kTTSym_function, TTPtr(p_returnAddressCallback));
args.append(p_returnAddressCallback);
// Register a TTObject into the NSPDirectory
TTNodePtr returnedNode;
TTBoolean newInstanceCreated;
for (int i = 0; i < instanceNumber; i++) {
data = NULL;
returnedNode = NULL;
newInstanceCreated = NULL;
// create an instance of TTData
TTObjectInstantiate(TTSymbol("Data"), TTObjectHandle(&data), args);
std::string absAddress = AppName + address;
// add instance number
if (i != 0) {
absAddress += ".";
stringstream st;
st << i;
absAddress += st.str();
}
// add the parameter data in the namespace directory
NSPDirectory->TTNodeCreate(TT(absAddress), (TTObjectPtr)data, NULL, &returnedNode, &newInstanceCreated);
// note : our myRegistrationObserver is informed if declared
}
return NSP_NO_ERROR;
}
TTErr TTAttribute::getrange(TTValue& currentRange)
{
currentRange.clear();
currentRange.push_back(rangeLowBound);
currentRange.append(rangeHighBound);
return kTTErrNone;
}
TTErr TTData::returnValue()
{
// used a new value to protect the internal value
TTValue v = mValue;;
// COMMENT: This is a temporary solution to have audio rate ramping outside the #TTData
// TODO: JamomaCore #212 : when Trond ports dataspace ramp we need to think about how that works with audio rate ramps
if (mRampDrive == kTTSym_external) {
if (externalRampTime > 0)
v.append(externalRampTime);
}
// we have had our value set at least once
// only parameters notify their initialisation
if (mService == kTTSym_parameter && !mInitialized) {
mInitialized = YES;
initializedAttribute->sendNotification(kTTSym_notify, YES); // we use kTTSym_notify because we know that observers are TTCallback
}
else if (!mInitialized)
mInitialized = YES;
// return the value to his owner
this->deliver(v);
// notify each observers
valueAttribute->sendNotification(kTTSym_notify, v); // we use kTTSym_notify because we know that observers are TTCallback
return kTTErrNone;
}
int TTCLASSWRAPPERMAX_EXPORT main(void)
{
WrappedClassOptionsPtr options = new WrappedClassOptions;
TTValue value;
TTDSPInit();
value.clear();
value.append(TT("srRatio"));
value.append(TT("bitdepth"));
// TODO: experimental:
// options->append(TT("additionalSignalInputSetsAttribute"), value);
return wrapTTClassAsMaxClass(TT("degrade"), "jcom.degrade~", NULL, options);
}
TTErr TTAudioObjectBase::calculate(const TTValue& x, TTValue& y)
{
TTErr err = kTTErrGeneric;
if (valid) {
TTFloat64 in;
TTFloat64 out;
TTUInt32 size;
lock();
// at the moment we are iterating through the values using the same call to the object
// however, if the calculation involves the history of previous input or output
// then this will not work --
// TODO: there needs to be a way to request a calculation of a list on the object if it defines such a method
y.clear();
size = x.size();
for (TTUInt32 i=0; i<size; i++) {
x.get(i, in);
err = (this->*currentCalculateMethod)(in, out, NULL);
y.append(out);
}
unlock();
}
return err;
}
NSPStatus
Namespace::namespaceObserverCreate(std::string address, TTSymbolPtr attribute, void* object, void (*returnValueCallback) (TTPtr, TTValue&)
, void (*returnAddressCallback) (TTPtr, TTValue&)
, int instance)
{
TTReceiverPtr myReceiver = NULL;
TTCallbackPtr r_returnAddressCallback;
TTCallbackPtr r_returnValueCallback;
TTValuePtr r_returnAddressBaton, r_returnValueBaton;
// prepare arguments : see TTReceiver.h to know which args are needed
TTValue args;
args.clear();
args.append(GalamusApplication);
// add Application name to the address
std::string absAddress = AppName + address;
// add instance number
if (instance != 0) {
absAddress += ".";
stringstream st;
st << instance;
absAddress += st.str();
}
args.append(TT(absAddress));
args.append(attribute);
r_returnAddressCallback = NULL;
TTObjectInstantiate(TTSymbol("callback"), TTObjectHandle(&r_returnAddressCallback), kTTValNONE);
r_returnAddressBaton = new TTValue(TTPtr(object));
r_returnAddressCallback->setAttributeValue(kTTSym_baton, TTPtr(r_returnAddressBaton));
r_returnAddressCallback->setAttributeValue(kTTSym_function, TTPtr(returnAddressCallback));
args.append(r_returnAddressCallback);
r_returnValueCallback = NULL;
TTObjectInstantiate(TTSymbol("callback"), TTObjectHandle(&r_returnValueCallback), kTTValNONE);
r_returnValueBaton = new TTValue(TTPtr(object));
r_returnValueCallback->setAttributeValue(kTTSym_baton, TTPtr(r_returnValueBaton));
r_returnValueCallback->setAttributeValue(kTTSym_function, TTPtr(returnValueCallback));
args.append(r_returnValueCallback);
TTObjectInstantiate(TTSymbol("Receiver"), TTObjectHandle(&myReceiver), args);
return NSP_NO_ERROR;
}
TTErr TTValueFromAtoms(TTValue& v, long ac, t_atom* av)
{
v.clear();
// For now we assume floats for speed (e.g. in the performance sensitive j.unit object)
for (int i=0; i<ac; i++)
v.append((TTFloat64)atom_getfloat(av+i));
return kTTErrNone;
}
TTObjectBasePtr OSCSenderManager::add(TTSymbol applicationName, TTSymbol ip, TTUInt16 port)
{
TTValue v;
TTObjectBasePtr anObject = NULL;
TTErr err;
err = TTObjectBaseInstantiate(TTSymbol("osc.send"), &anObject, kTTValNONE);
if (!err) {
anObject->setAttributeValue(TTSymbol("address"), ip);
anObject->setAttributeValue(TTSymbol("port"), port);
v.append(anObject);
v.append(ip);
v.append(port);
mSenders->append(applicationName, v);
}
return anObject;
}
void ramp_attrset(t_ramp *x, t_symbol *msg, long argc, t_atom *argv)
{
TTSymbol* parameterName;
TTValue newValue;
int i;
if (argc < 2) {
error("jcom.ramp: not enough arguments to setParameter");
return;
}
parameterName = TT(atom_getsym(argv)->s_name);
for (i=1; i<=(argc-1); i++) {
if (argv[i].a_type == A_SYM)
newValue.append(TT(atom_getsym(argv+1)->s_name));
else
newValue.append(atom_getfloat(argv+i));
}
x->rampUnit->setAttributeValue(parameterName, newValue);
}
void TTList::assignToValue(TTValue& value)
{
TTListIter iter;
value.clear();
lock();
for (iter = theList.begin(); iter != theList.end(); iter++) {
value.append(*iter);
}
unlock();
}
int C74_EXPORT main(void)
{
WrappedClassOptionsPtr options = new WrappedClassOptions;
TTValue value;
TTDSPInit();
value.clear();
value.append(TT("drive"));
options->append(TT("additionalSignalInputSetsAttribute"), value);
return wrapTTClassAsMaxClass(TT("overdrive"), "j.overdrive~", NULL, options);
}
TTErr TTHash::getKeysSorted(TTValue& hashKeysSorted, TTBoolean(comparisonFunction)(TTValue&, TTValue&))
{
lock();
TTList listToSort;
TTValue v;
TTSymbol key;
// fill a list to sort
for (TTHashMapIter iter = HASHMAP->begin(); iter != HASHMAP->end(); iter++) {
TTPtrSizedInt a = iter->first;
TTSymbol b((TTSymbolBase*)a);
if (comparisonFunction) {
v = b; // the key
v.append(TTPtr(iter->second)); // a pointer to the stored value
listToSort.append(v);
}
else
listToSort.append(b);
}
listToSort.sort(comparisonFunction);
// fill the result
hashKeysSorted.clear();
for (listToSort.begin(); listToSort.end(); listToSort.next()) {
if (comparisonFunction) {
key = listToSort.current()[0];
hashKeysSorted.append(key);
}
else
hashKeysSorted.append(listToSort.current());
}
unlock();
return kTTErrNone;
}
TTErr TTProtocolDirectoryCallback(const TTValue& baton, const TTValue& data)
{
TTObject aProtocol;
TTSymbol anApplicationName;
TTAddress anAddress;
TTNodePtr aNode;
TTUInt8 flag;
TTObject anObserver;
TTValue v;
// unpack baton
aProtocol = baton[0];
anApplicationName = baton[1];
// unpack data (anAddress, aNode, flag, anObserver)
anAddress = data[0];
aNode = TTNodePtr((TTPtr)data[1]);
flag = data[2];
anObserver = data[3];
if (flag == kAddressCreated) {
if (aNode->getObject().valid())
v.append(aNode->getObject().name());
else
v.append(kTTSym_none);
}
else if (flag == kAddressDestroyed) {
v.append(TTSymbol("delete"));
}
if (TTProtocolPtr(aProtocol.instance())->mRunning)
return TTProtocolPtr(aProtocol.instance())->SendListenAnswer(anApplicationName, anAddress.appendAttribute(TTSymbol("life")), v);
else
return kTTErrGeneric;
}
TTErr TTDictionaryBase::getKeys(TTValue& hashKeys)
{
// lock();
hashKeys.clear();
for (TTDictionaryBaseMapIter iter = mMap.begin(); iter != mMap.end(); iter++) {
TTPtrSizedInt a = iter->first;
TTSymbol b((TTSymbolBase*)a);
//TTValue v = iter->second;
//hashKeys.append(TTSymbolRef(*(TTSymbol*)iter->first));
hashKeys.append(b);
}
// unlock();
return kTTErrNone;
}
int TTCLASSWRAPPERMAX_EXPORT main(void)
{
WrappedClassOptionsPtr options = new WrappedClassOptions;
TTValue value;
WrappedClassPtr c = NULL;
TTFoundationInit();
value.clear();
value.append(0);
options->append(TT("fixedNumChannels"), value);
wrapTTClassAsMaxClass(TT("net.send"), "jcom.net.send", &c, options);
CLASS_ATTR_ENUM(c->maxClass, "mode", 0, "tcp udp");
return 0;
}
TTErr TTSampleMatrix::getValueAtIndex(const TTValue& index, TTValue &output)
{
TTRowID sampleIndex;
TTColumnID sampleChannel = 0;
TTSampleValue sampleValue;
TTErr err;
sampleIndex = index[0];
if (index.size() > 1) {
sampleChannel = index[1];
}
err = peek(sampleIndex, sampleChannel, sampleValue);
if (!err)
output.clear();
output.append(sampleValue);
return err;
}
TTErr TTHash::getKeys(TTValue& hashKeys)
{
lock();
hashKeys.clear();
//#define HASHMAP ((TTHashMap*)(mHashMap))
//#define mHASHMAP (*HASHMAP)
TTHashMap* theMap = (TTHashMap*)mHashMap;
for (TTHashMapIter iter = theMap->begin(); iter != theMap->end(); iter++) {
TTPtrSizedInt a = iter->first;
TTSymbol b((TTSymbolBase*)a);
//TTValue v = iter->second;
//hashKeys.append(TTSymbolRef(*(TTSymbol*)iter->first));
hashKeys.append(b);
}
unlock();
return kTTErrNone;
}
void TTObjectBase::getMessageNames(TTValue& messageNameList)
{
TTValue unfilteredNameList;
TTUInt32 messageCount;
messages->getKeys(unfilteredNameList);
messageCount = unfilteredNameList.size();
messageNameList.clear();
for (TTUInt32 i=0; i<messageCount; i++) {
TTMessagePtr message = NULL;
TTSymbol messageName(kTTSymEmpty);
messageName = unfilteredNameList[i];
getMessage(messageName, &message);
if (message->hidden == NO)
messageNameList.append(messageName);
}
}
void TTObjectBase::getAttributeNames(TTValue& attributeNameList)
{
TTValue unfilteredNameList;
TTUInt32 attributeCount;
attributes->getKeys(unfilteredNameList);
attributeCount = unfilteredNameList.size();
attributeNameList.clear();
for (TTUInt32 i=0; i<attributeCount; i++) {
TTAttributePtr attribute = NULL;
TTSymbol attributeName = kTTSymEmpty;
attributeName = unfilteredNameList[i];
// getAttribute(attributeName, &attribute);
findAttribute(attributeName, &attribute);
if (attribute->hidden == NO)
attributeNameList.append(attributeName);
}
}
void TTClockLib::getClockNames(TTValue& ClockNames)
{
ClockNames.clear();
ClockNames.append(TTSymbol("max"));
ClockNames.append(TTSymbol("system"));
}
int main(int argc, const char * argv[])
{
// parsing arguments (ignoring the first)
TTValue args;
for (TTUInt8 i = 1; i < argc; i++)
{
TTSymbol arg(argv[i]);
args.append(arg);
}
// check for file path
if (args.size() == 1)
{
if (args[0].type() == kTypeSymbol)
{
TTSymbol filepath = args[0]; // .score file to load
// initialisation of Modular environnement (passing the folder path where all the dylibs are)
TTModularInit("/usr/local/jamoma", true);
// create an application manager
TTObject applicationManager("ApplicationManager");
// create a local application named i-score
TTObject applicationLocal = applicationManager.send("ApplicationInstantiateLocal", "i-score");
// loads protocol unit
// TODO : when parsing project file
{
// create Minuit protocol unit
TTObject protocolMinuit = applicationManager.send("ProtocolInstantiate", "Minuit");
// create OSC protocol unit
TTObject protocolOSC = applicationManager.send("ProtocolInstantiate", "OSC");
// create WebSocket protocol unit
TTObject protocolWebSocket = applicationManager.send("ProtocolInstantiate", "WebSocket");
}
// initialisation of Score environnement (passing the folder path where all the dylibs are)
TTScoreInit("/usr/local/jamoma");
// create a scenario
TTObject scenario("Scenario");
// load project file
TTObject xmlHandler("XmlHandler");
xmlHandler.set("object", TTValue(applicationManager, scenario));
xmlHandler.send("Read", filepath);
// run scenario
scenario.send("Start");
// wait for scenario
TTBoolean running;
do
{
sleep(1);
scenario.get("running", running);
}
while (running);
return EXIT_SUCCESS;
}
}
return EXIT_FAILURE;
}
void data_new_address(TTPtr self, t_symbol *relativeAddress)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
long argc = 0;
t_atom *argv = NULL;
TTUInt32 number;
TTUInt32 i;
TTAddress newAddress = relativeAddress->s_name;
TTAddress returnedAddress;
TTNodePtr returnedNode = NULL;
TTNodePtr returnedContextNode = NULL;
t_symbol *instanceAddress;
TTObject anObject;
TTObject aSubscriber;
TTValue v;
x->useInternals = YES;
x->internals->clear();
x->internals->setThreadProtection(YES);
x->cursor = kTTSymEmpty;
x->arrayAddress = newAddress;
if (x->arrayAddress.getType() == kAddressRelative) {
number = jamoma_parse_bracket(relativeAddress, x->arrayFormatInteger, x->arrayFormatString);
// don't resize to 0
if (number && number <= MAX_ARRAY_SIZE) {
// Starts iteration on internals
x->iterateInternals = YES;
x->arraySize = number;
EXTRA->objectsSorted->clear();
for (i = 1; i <= x->arraySize; i++) {
jamoma_edit_numeric_instance(x->arrayFormatInteger, &instanceAddress, i);
// create a data
#ifdef JMOD_MESSAGE
data_array_create(self, anObject, kTTSym_message, i);
#endif
#if JMOD_RETURN
data_array_create(self, anObject, kTTSym_return, i);
#endif
#ifndef JMOD_MESSAGE
#ifndef JMOD_RETURN
data_array_create(self, anObject, kTTSym_parameter, i);
#endif
#endif
if (!jamoma_subscriber_create((t_object*)x, anObject, TTAddress(instanceAddress->s_name), aSubscriber, returnedAddress, &returnedNode, &returnedContextNode)) {
if (aSubscriber.valid()) {
// append the data to the internals table
v = TTValue(anObject);
v.append(TTSymbol(instanceAddress->s_name));
v.append(aSubscriber);
x->internals->append(TTSymbol(instanceAddress->s_name), v);
// inverse objects order for iteration purpose (see in data_array_return_value : array mode)
EXTRA->objectsSorted->insert(0, anObject);
}
}
}
// Ends iteration on internals
x->iterateInternals = NO;
// handle args
jamoma_ttvalue_to_Atom(x->arrayArgs, &argc, &argv);
if (argc && argv)
attr_args_process(x, argc, argv);
// select all datas
wrappedModularClass_ArraySelect(self, gensym("*"), 0, NULL);
#ifndef JMOD_MESSAGE
// init all datas created dynamically
if (!EXTRA->firstArray)
defer((t_object*)x, (method)wrappedModularClass_anything, _sym_init, 0, NULL);
#endif
}
else if (number > MAX_ARRAY_SIZE)
object_error((t_object*)x, "the size is greater than the maximum array size (%d)", MAX_ARRAY_SIZE);
EXTRA->firstArray = NO;
}
else
object_error((t_object*)x, "can't register because %s is not a relative address", relativeAddress->s_name);
}
TTErr WebSocketAnswerManager::ParseDiscoverAnswer(const TTValue& answer, TTSymbol& returnedType, TTValue& returnedChildren, TTValue& returnedAttributes)
{
TTSymbol toParse, parsed;
TTBoolean endFlagFound;
// pars the type
returnedType = answer[0];
// parse something like : nodes={ all nodes below } attributes={ all current node's attributes }
for (TTUInt32 i = 1; i < answer.size(); i++) {
toParse = answer[i];
// parse nodes
if (toParse == TTSymbol(WEBSOCKET_START_NODES)) {
endFlagFound = NO;
do {
i++;
parsed = kTTSymEmpty;
if (answer[i].type() == kTypeSymbol)
parsed = answer[i];
// don't store the end flag
if (parsed != TTSymbol(WEBSOCKET_END_NODES)) {
returnedChildren.append(parsed);
#ifdef TT_PROTOCOL_DEBUG
cout << "Parsed node " << parsed.c_str() << endl;
#endif
}
else
endFlagFound = YES;
}
while (!endFlagFound);
}
else if (toParse == TTSymbol(WEBSOCKET_START_ATTRIBUTES)) {
endFlagFound = NO;
do {
i++;
parsed = kTTSymEmpty;
if (answer[i].type() == kTypeSymbol)
parsed = answer[i];
// don't store the end flag
if (parsed != TTSymbol(WEBSOCKET_END_ATTRIBUTES)) {
returnedAttributes.append(parsed);
#ifdef TT_PROTOCOL_DEBUG
cout << "Parsed attribute " << parsed.c_str() << endl;
#endif
}
else
endFlagFound = YES;
}
while (!endFlagFound);
}
else
i++;
} // end for to parse answer
return kTTErrNone;
}
