void
ReceiveOSCThread::ProcessMessage(const osc::ReceivedMessage&m, const IpEndpointName& remoteEndPoint)
{
	std::ostringstream oss;

	if ((m.AddressPattern())[0] == '/') {
		m_minuitMethods->receiveNetworkMessage(m.AddressPattern());
	} else {
		std::string currentString(m.AddressPattern());

		if (currentString.find(":namespace") != currentString.npos) {
			osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();

			if (arg->IsChar()) {
				oss << arg->AsChar();
			} else if (arg->IsInt32()) {
				oss << arg->AsInt32();
			} else if (arg->IsString()) {
				oss << arg->AsString();
			} 
			
			m_minuitMethods->minuitParseNamespaceRequest(oss.str(), m);
		} else if (currentString.find(":get") != currentString.npos) {
			osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();

			if (arg->IsChar()) {
				oss << arg->AsChar();
			} else if (arg->IsInt32()) {
				oss << arg->AsInt32();
			} else if (arg->IsString()) {
				oss << arg->AsString();
			}

			m_minuitMethods->minuitParseGetRequest(oss.str(), m);
		} else if (currentString.find("?namespace") != currentString.npos ||
				   currentString.find("?get") != currentString.npos) {
			osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();
	
			if (arg->IsChar()) {
				oss << arg->AsChar();
			} else if (arg->IsInt32()) {
				oss << arg->AsInt32();
			} else if (arg->IsString()) {
				oss << arg->AsString();
			}
			
			m_minuitMethods->receiveNetworkRequest(oss.str(), currentString);
		} 
	}
};
Exemple #2
0
void oscReceiver::ProcessMessage(const osc::ReceivedMessage &_m, const IpEndpointName &remoteEndpoint)
{
	boost::mutex::scoped_lock lock(listenerMutex);
	
	if (retrievalMode == SIGNAL_PARSER_ONLY_AFTER_RELEASE)
	{
		if (currentMessage != 0) return;
	}
	
	osc::ReceivedMessage::const_iterator arg = _m.ArgumentsBegin();
	
	currentMessage = new oscMessage(_m.AddressPattern(), oscMessage::NO_BUFFER);
	
	// set source IP
	char sourceString[ IpEndpointName::ADDRESS_STRING_LENGTH ];
    remoteEndpoint.AddressAsString( sourceString  );
	currentMessage->sourceIP = sourceString;
	
	while ( arg != _m.ArgumentsEnd() )
	{
		if 		( arg->IsBool() 	) { currentMessage->AppendBoolean	(arg->AsBool());}
		else if ( arg->IsInt32() 	) { currentMessage->AppendInteger	(arg->AsInt32());}
		else if ( arg->IsFloat() 	) { currentMessage->AppendFloat		(arg->AsFloat());}
		else if ( arg->IsString() 	) { currentMessage->AppendString	(arg->AsString());}
		else { std::cout << "Unrecognized osc argument type\n"; }
		arg++;
	}
	
	signalNewOscMessageReceived(currentMessage);
}
Exemple #3
0
void OscListener::ProcessMessage( const ::osc::ReceivedMessage &m, const IpEndpointName& remoteEndpoint ) {
	Message* message = new Message();
	
	message->setAddress(m.AddressPattern());
	
	char endpoint_host[IpEndpointName::ADDRESS_STRING_LENGTH];
	remoteEndpoint.AddressAsString(endpoint_host);
	message->setRemoteEndpoint(endpoint_host, remoteEndpoint.port);
	
	for (::osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin(); arg != m.ArgumentsEnd(); ++arg){
		if (arg->IsInt32())
			message->addIntArg( arg->AsInt32Unchecked());
		else if (arg->IsFloat())
			message->addFloatArg(arg->AsFloatUnchecked());
		else if (arg->IsString())
			message->addStringArg(arg->AsStringUnchecked());
		else {
			assert(false && "message argument type unknown");
		}
	}
	
	lock_guard<mutex> lock(mMutex);
	
	if( mMessageReceivedCbs.empty() ){
		mMessages.push_back( message );
	}else{
		mMessageReceivedCbs.call( message );
		delete message;
	}
}
void Receiver::ProcessMessage( const osc::ReceivedMessage &m, const osc::IpEndpointName& remoteEndpoint ) {
	// convert the m to a Message, return at the end to other main thread
	Message message;

	// set the address
	message.setAddress( m.AddressPattern() );

	// set the sender ip/host
	char endpoint_host[ osc::IpEndpointName::ADDRESS_STRING_LENGTH ];
	remoteEndpoint.AddressAsString( endpoint_host );
    message.setRemoteEndpoint( endpoint_host, remoteEndpoint.port );

	// transfer the arguments
	for ( osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin(); 
          arg != m.ArgumentsEnd(); 
          ++arg )
    {
		if ( arg->IsInt32() ) {
			message.addIntArg( arg->AsInt32Unchecked() );
		} else if ( arg->IsFloat() ) {
			message.addFloatArg( arg->AsFloatUnchecked() );
		} else if ( arg->IsString() ) {
			message.addStringArg( arg->AsStringUnchecked() );
		} else {
			assert( false && "message argument is not int, float, or string" );
		}
	}

	// at this point we are running inside the thread created by start()
	// since we are returning a copy no shared memory management
    
    for(unsigned int i=0; i<_oscHandlers.size(); ++i) {
        _oscHandlers[i]->oscReceive( message );
    }    
}
void BitalinoPacketListener::ProcessMessage( const osc::ReceivedMessage& m )  {
    
    try{        
        if( std::strcmp( m.AddressPattern(), "/wek/inputs" ) == 0 ){
            
            osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();
            float emg = (arg++)->AsFloat();
            float emgFilt = (arg++)->AsFloat();
            float eda = (arg++)->AsFloat();
            
            this->emgBuffer[this->curEmgBuffIdx++] = emgFilt;
            if (this->curEmgBuffIdx >= BUFFER_SIZE) {
                this->curEmgBuffIdx = 0;
            }
            
            this->emgStd = minMax(this->emgBuffer, BUFFER_SIZE);
            
            float ecg = (arg++)->AsFloat();
            this->accelMean =(arg++)->AsFloat();
            this->lux = (arg++)->AsFloat();
            
            //std::cout << "emg: " << emg << " emgfilt: " << emgFilt << "  eda: " << eda << "  ecg: " << ecg << "  accel: " << accel << "  lux: " << lux << '\n';
            
        }
    }catch( osc::Exception& e ){
        // any parsing errors such as unexpected argument types, or
        // missing arguments get thrown as exceptions.
        std::cout << "error while parsing message: "
        << m.AddressPattern() << ": " << e.what() << "\n";
    }
}
Exemple #6
0
//------------------------------------------------------------------------
void OSCListener::ProcessMessage( const osc::ReceivedMessage& m, const IpEndpointName& src )
{
    string address(m.AddressPattern());

    if (address == kGreensoundsAddr) {
        ReceivedMessageArgumentIterator i = m.ArgumentsBegin();
        while (i != m.ArgumentsEnd()) {
            if (i->IsString()) {
                string msg(i->AsStringUnchecked());
                if (msg == "hello") {
                    char buff[120];
                    src.AddressAsString(buff);
                    fSensors->connect(buff);
                }
                else if (msg == "version") {
                    fSensors->send (kGreensoundsAddr, "version", kVersion);
                }

            }
            else if (i->IsInt32()) {
            }
            else if (i->IsFloat()) {
            }
            i++;
        }
    }
}
Exemple #7
0
void OscListener::ProcessMessage(const osc::ReceivedMessage& message, const IpEndpointName& endpoint)
{
    char addressBuffer[256];

    endpoint.AddressAsString(addressBuffer);

    QList<QVariant> arguments;
    for (osc::ReceivedMessage::const_iterator iterator = message.ArgumentsBegin(); iterator != message.ArgumentsEnd(); ++iterator)
    {
        const osc::ReceivedMessageArgument& argument = *iterator;

        if (argument.IsBool())
            arguments.push_back(argument.AsBool());
        else if (argument.IsInt32())
            arguments.push_back(QVariant::fromValue<qint32>(argument.AsInt32()));
        else if (argument.IsInt64())
            arguments.push_back(QVariant::fromValue<qint64>(argument.AsInt64()));
        else if (argument.IsFloat())
            arguments.push_back(argument.AsFloat());
        else if (argument.IsDouble())
            arguments.push_back(argument.AsDouble());
        else if (argument.IsString())
            arguments.push_back(argument.AsString());
    }

    QString eventPath = QString("%1%2").arg(addressBuffer).arg(message.AddressPattern());

    QMutexLocker locker(&eventsMutex);
    this->events[eventPath] = arguments;
}
Exemple #8
0
//get OSC message
void OscInput::ProcessMessage( const osc::ReceivedMessage& m, const IpEndpointName& remoteEndpoint )
{
    try
    {
        if( strcmp( m.AddressPattern(), "/alpha" ) == 0 )
        {
            osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();
            int recievedPad = (arg++)->AsInt32();
            int recievedValue = (arg++)->AsInt32();
            if( arg != m.ArgumentsEnd() )
                throw osc::ExcessArgumentException();
            
            recievedPad = Layouts::padArrangementLayout[recievedPad];
            
            //call callback function
            oscCallBack(recievedPad, recievedValue);
        }
    }
    catch( osc::Exception& e )
    {
        // any parsing errors such as unexpected argument types, or 
        // missing arguments get thrown as exceptions.
        std::cout << "error while parsing message: "
        << m.AddressPattern() << ": " << e.what() << "\n";
    }
}
void ofxOscReceiver::ProcessMessage( const osc::ReceivedMessage &m, const osc::IpEndpointName& remoteEndpoint )
{
	// convert the message to an ofxOscMessage
	ofxOscMessage msg;

	// set the address
	msg.setAddress( m.AddressPattern() );
    
	// set the sender ip/host
	char endpoint_host[ osc::IpEndpointName::ADDRESS_STRING_LENGTH ];
	remoteEndpoint.AddressAsString( endpoint_host );
    msg.setRemoteEndpoint( endpoint_host, remoteEndpoint.port );

	// transfer the arguments
	for ( osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();
		  arg != m.ArgumentsEnd();
		  ++arg )
	{
		if ( arg->IsInt32() )
			msg.addIntArg( arg->AsInt32Unchecked() );
		else if ( arg->IsInt64() )
			msg.addInt64Arg( arg->AsInt64Unchecked() );
		else if ( arg->IsFloat() )
			msg.addFloatArg( arg->AsFloatUnchecked() );
		else if ( arg->IsDouble() )
			msg.addDoubleArg( arg->AsDoubleUnchecked() );
		else if ( arg->IsString() )
			msg.addStringArg( arg->AsStringUnchecked() );
		else if ( arg->IsSymbol() )
			msg.addSymbolArg( arg->AsSymbolUnchecked() );
		else if ( arg->IsChar() )
			msg.addCharArg( arg->AsCharUnchecked() );
		else if ( arg->IsMidiMessage() )
			msg.addMidiMessageArg( arg->AsMidiMessageUnchecked() );
		else if ( arg->IsBool())
			msg.addBoolArg( arg->AsBoolUnchecked() );
		else if ( arg->IsInfinitum() )
			msg.addTriggerArg();
		else if ( arg->IsTimeTag() )
			msg.addTimetagArg( arg->AsTimeTagUnchecked() );
		else if ( arg->IsRgbaColor() )
			msg.addRgbaColorArg( arg->AsRgbaColorUnchecked() );
		else if ( arg->IsBlob() ){
            const char * dataPtr;
            osc::osc_bundle_element_size_t len = 0;
            arg->AsBlobUnchecked((const void*&)dataPtr, len);
            ofBuffer buffer(dataPtr, len);
			msg.addBlobArg( buffer );
		}
		else
		{
			ofLogError("ofxOscReceiver") << "ProcessMessage: argument in message " << m.AddressPattern() << " is not an int, float, or string";
		}
	}

	// send msg to main thread
	messagesChannel.send( std::move(msg) );
}
Exemple #10
0
void ExamplePacketListener::ProcessMessage( const osc::ReceivedMessage& m, const IpEndpointName& remoteEndpoint )
{
    try{
        // example of parsing single messages. osc::OsckPacketListener
        // handles the bundle traversal.
        
		OSCData *d = new OSCData; //new OSCData;
		d->header = oscNothing;

		osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();
		if( strcmp( m.AddressPattern(), "/obs") == 0 )	// this is a packet of feature data: /obs len x x x x
		{
            d = new OSCData;
            int len = (arg++)->AsInt32();
            for (int i = 0; i < len; i++)
                d->data.push_back((arg++)->AsFloat());	// the observed state
			d->header = oscUpdate;
        } else if( strcmp( m.AddressPattern(), "/spo") == 0 )	// set the RL's willingness to jump to new categories
		{
            d = new OSCData;
            d->data.push_back((arg++)->AsFloat());	// the observed state
			d->header = oscSponteneity;
        } else if( strcmp( m.AddressPattern(), "/reset") == 0 )	// start over!
		{
            d = new OSCData;
			d->header = oscReset;
        } else if( strcmp( m.AddressPattern(), "/analyze") == 0 )	// toggle between purely analyzing and predicting states
		{
            d = new OSCData;
			d->header = oscAnalyze;
        } else if( strcmp( m.AddressPattern(), "/learnRate") == 0 )	// toggle between purely analyzing and predicting states
		{
            d = new OSCData;
			d->header = oscLearnRates;
            for (int i = 0; i < 4; i++)
                d->data.push_back((arg++)->AsFloat());	// the observed state
        } else if( strcmp( m.AddressPattern(), "/rewardWeight") == 0 )	// toggle between purely analyzing and predicting states
		{
            d = new OSCData;
			d->header = oscRewardWeights;
            for (int i = 0; i < 4; i++)
                d->data.push_back((arg++)->AsFloat());	// the observed state
        }
		if (d->header != oscNothing)
		{
			pthread_mutex_lock(MusiVerse::oscmutex);	//wait for the lock
			MusiVerse::rxCommands.push_back(d);
			pthread_mutex_unlock(MusiVerse::oscmutex);
		} else
            delete d;
    }catch( osc::Exception& e )
	{
        // any parsing errors such as unexpected argument types, or 
        // missing arguments get thrown as exceptions.
        std::cout << "error while parsing message: "
            << m.AddressPattern() << ": " << e.what() << "\n";
    }
}
Exemple #11
0
void ofxOscReceiver::ProcessMessage( const osc::ReceivedMessage &m, const IpEndpointName& remoteEndpoint )
{
	// convert the message to an ofxOscMessage
	ofxOscMessage* ofMessage = new ofxOscMessage();

	// set the address
	ofMessage->setAddress( m.AddressPattern() );

	// set the sender ip/host
	char endpoint_host[ IpEndpointName::ADDRESS_STRING_LENGTH ];
	remoteEndpoint.AddressAsString( endpoint_host );
    ofMessage->setRemoteEndpoint( endpoint_host, remoteEndpoint.port );

	// transfer the arguments
	for ( osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();
		  arg != m.ArgumentsEnd();
		  ++arg )
	{
		if ( arg->IsInt32() )
			ofMessage->addIntArg( arg->AsInt32Unchecked() );
		else if ( arg->IsFloat() )
			ofMessage->addFloatArg( arg->AsFloatUnchecked() );
		else if ( arg->IsString() )
			ofMessage->addStringArg( arg->AsStringUnchecked() );
		else if ( arg->IsBlob() )
		{
			osc::Blob blob;
			arg->AsBlobUnchecked( blob.data, blob.size );
			ofMessage->addBlobArg( blob );
		}
		else
		{
			assert( false && "message argument is not int, float, string, or blob" );
		}
	}

	// now add to the queue

	// at this point we are running inside the thread created by startThread,
	// so anyone who calls hasWaitingMessages() or getNextMessage() is coming
	// from a different thread

	// so we have to practise shared memory management

	// grab a lock on the queue
	grabMutex();

	// add incoming message on to the queue
	messages.push_back( ofMessage );

	// release the lock
	releaseMutex();
}
void GesturePacketListener::ProcessMessage( const osc::ReceivedMessage& m) {
    try{
        if( std::strcmp( m.AddressPattern(), "/0/raw" ) == 0 ){
            osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();
            int battery = (arg++)->AsInt32();
            
            this->switchState = (arg++)->AsInt32();
            int accX = (arg++)->AsInt32();
            this->accX = (arg++)->AsInt32();
            int accZ =(arg++)->AsInt32();
            
            accelMag = sqrt(pow(accX,2) + pow(this->accX, 2) + pow(accZ, 2));
            
            int gyroY = (arg++)->AsInt32();
            int gyroP = (arg++)->AsInt32();
            int gyroR =(arg++)->AsInt32();
            
            int magnetX = (arg++)->AsInt32();
            int magnetY = (arg++)->AsInt32();
            int magnetZ =(arg++)->AsInt32();
        }
        if( std::strcmp( m.AddressPattern(), "/0/euler" ) == 0 ){
            osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();
            this->yaw = (arg++)->AsFloat();
            this->pitch = (arg++)->AsFloat();
            this->roll = (arg++)->AsFloat();
        }
        if( std::strcmp( m.AddressPattern(), "/0/quat" ) == 0 ){
            osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();
            this->q1 = (arg++)->AsFloat();
            this->q2 = (arg++)->AsFloat();
            this->q3 = (arg++)->AsFloat();
            this->q3 = (arg++)->AsFloat();
        }
    }catch( osc::Exception& e ){
        std::cout << "error while parsing message: "
        << m.AddressPattern() << ": " << e.what() << "\n";
    }
}
void MinuitGetAnswer::parseMinuitGetAnswer(const osc::ReceivedMessage&m)
{
	osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();
	std::ostringstream ossWithAddress;
	std::ostringstream ossWithoutAddress;
	std::ostringstream floatCorrection;

	// get the address
	ossWithAddress << arg->AsString();
	++arg;
	
	while(arg != m.ArgumentsEnd()) {

		if (arg->IsChar()) {
			ossWithAddress  << arg->AsChar();
			ossWithoutAddress  << arg->AsChar();
		} else if (arg->IsInt32()) {
			ossWithAddress  << arg->AsInt32();
			ossWithoutAddress  << arg->AsInt32();
		} else if (arg->IsString()) {
			ossWithAddress  << arg->AsString();
			ossWithoutAddress  << arg->AsString();
		}else if (arg->IsFloat()) {
			floatCorrection.str("");

			floatCorrection << arg->AsFloat();

			std::string floatWithPoint = floatCorrection.str();

			if(floatWithPoint.find(".") == floatWithPoint.npos) {
				floatWithPoint = floatWithPoint + ".";
			}

			ossWithAddress  << floatWithPoint;
			ossWithoutAddress  << floatWithPoint;
		}

		++arg;
		if(arg != m.ArgumentsEnd()){
			ossWithAddress << " ";
			ossWithoutAddress << " ";
		}
	}

	m_getStringWithAddress = ossWithAddress.str();
	m_getStringWithoutAddress = ossWithoutAddress.str();
	
	m_state = ANSWER_RECEIVED;
}
Exemple #14
0
void process_message( MarSystem * root_system, const osc::ReceivedMessage& message )
{
  const char * path = message.AddressPattern();
  if (path[0] == '/') ++path;

  // FIXME: Constructing std::string is not real-time-safe.
  MarControlPtr control = find_control(root_system, path);
  if (control.isInvalid())
  {
    MRSWARN("OSC receiver: no control for path: " << path);
    return;
  }

  try
  {
    osc::ReceivedMessage::const_iterator it = message.ArgumentsBegin();
    if (it == message.ArgumentsEnd())
      throw std::runtime_error("OSC receiver: Message has no arguments.");

    char tag = it->TypeTag();
    switch(tag)
    {
    case osc::TRUE_TYPE_TAG:
    case osc::FALSE_TYPE_TAG:
      control->setValue(it->AsBoolUnchecked());
      break;
    case osc::INT32_TYPE_TAG:
      control->setValue(it->AsInt32Unchecked());
      break;
    case osc::FLOAT_TYPE_TAG:
      control->setValue((mrs_real) it->AsFloatUnchecked());
      break;
    case osc::DOUBLE_TYPE_TAG:
      control->setValue((mrs_real) it->AsDoubleUnchecked());
      break;
    case osc::STRING_TYPE_TAG:
      control->setValue(it->AsStringUnchecked());
      break;
    default:
      throw std::runtime_error("OSC receiver: Unsupported message argument type.");
    }
  }
  catch ( std::exception & e )
  {
    MRSWARN("OSC receiver: error while parsing message: " << e.what());
  }
}
Exemple #15
0
void OscReceiver::processXFadeMessage(const std::string addr, const osc::ReceivedMessage& m){
	boost::regex position_re("^(/relative){0,1}/{0,1}$");
	//boost::regex leftmixer_re("^/mixer/left/{0,1}$");
	//boost::regex rightmixer_re("^/mixer/right/{0,1}$");
	boost::regex mixers_re("^/mixers/{0,1}$");
	boost::regex enable_re("^/enable/{0,1}$");
	boost::cmatch matches;
	osc::ReceivedMessage::const_iterator arg_it = m.ArgumentsBegin();

	if(boost::regex_match(addr.c_str(), matches, position_re)){
		if(arg_it == m.ArgumentsEnd())
			throw osc::MissingArgumentException();
		float arg = floatFromOscNumber(*arg_it);
		if(strcmp("", matches[1].str().c_str()) == 0)
			mModel->crossFade()->setPosition(arg);
		else
			mModel->crossFade()->setPosition(mModel->crossFade()->position() + arg);
	} else if(boost::regex_match(addr.c_str(), mixers_re)){
		if(arg_it == m.ArgumentsEnd())
			throw osc::MissingArgumentException();
		int left = intFromOsc(*arg_it);
		arg_it++;
		if(arg_it == m.ArgumentsEnd())
			throw osc::MissingArgumentException();
		int right = intFromOsc(*arg_it);
		mModel->crossFade()->setMixers(left, right);
		/*
	} else if(boost::regex_match(addr.c_str(), leftmixer_re)){
		if(arg_it == m.ArgumentsEnd())
			throw osc::MissingArgumentException();
		int arg = intFromOsc(*arg_it);
		mModel->crossFade()->setLeftMixer(arg);
	} else if(boost::regex_match(addr.c_str(), rightmixer_re)){
		if(arg_it == m.ArgumentsEnd())
			throw osc::MissingArgumentException();
		int arg = intFromOsc(*arg_it);
		mModel->crossFade()->setRightMixer(arg);
		*/
	} else if(boost::regex_match(addr.c_str(), enable_re)){
		if(arg_it == m.ArgumentsEnd())
			mModel->crossFade()->enable();
		else
			mModel->crossFade()->enable(boolFromBoolOrInt(*arg_it));
	}
}
Exemple #16
0
static void SendMessage(TCircularQueue<std::pair<FName, TArray<FOscDataElemStruct>>> & _pendingMessages, const osc::ReceivedMessage & message)
{
    const FName address(message.AddressPattern());

    TArray<FOscDataElemStruct> data;
    
    const auto argBegin = message.ArgumentsBegin();
    const auto argEnd = message.ArgumentsEnd();
    for(auto it = argBegin; it != argEnd; ++it)
    {
        FOscDataElemStruct elem;
        if(it->IsFloat())
        {
            elem.SetFloat(it->AsFloatUnchecked());
        }
        else if(it->IsDouble())
        {
            elem.SetFloat(it->AsDoubleUnchecked());
        }
        else if(it->IsInt32())
        {
            elem.SetInt(it->AsInt32Unchecked());
        }
        else if(it->IsInt64())
        {
            elem.SetInt(it->AsInt64Unchecked());
        }
        else if(it->IsBool())
        {
            elem.SetBool(it->AsBoolUnchecked());
        }
        else if(it->IsString())
        {
            elem.SetString(FName(it->AsStringUnchecked()));
        }
        data.Add(elem);
    }

    // save it in pending messages
    _pendingMessages.Enqueue(std::make_pair(address, data));
}
Exemple #17
0
void OscReceiver::processMasterMessage(const std::string addr, const osc::ReceivedMessage& m){
	boost::regex volume_re("^/volume(/relative){0,1}/{0,1}$");
	boost::regex tempo_re("^/tempo(/relative){0,1}/{0,1}$");
	boost::regex sync_re("^/syncsource/{0,1}$");
	boost::cmatch matches;
	osc::ReceivedMessage::const_iterator arg_it = m.ArgumentsBegin();
	if(boost::regex_match(addr.c_str(), matches, volume_re)){
		//make sure our matches list is long enough and that we have an argument
		if(matches.size() == 2 && arg_it != m.ArgumentsEnd()){
			float num = floatFromOscNumber(*arg_it);
			//"" == absolute, otherwise, relative
			if(strcmp("", matches[1].str().c_str()) == 0)
				mModel->master()->setVolume(num);
			else 
				mModel->master()->setVolume(mModel->master()->volume() + num);
		} else
			throw osc::MissingArgumentException();
	} else if(boost::regex_match(addr.c_str(), matches, tempo_re)){
		//make sure our matches list is long enough and that we have an argument
		if(matches.size() == 2 && arg_it != m.ArgumentsEnd()){
			float num = floatFromOscNumber(*arg_it);
			//"" == absolute, otherwise, relative
			if(strcmp("", matches[1].str().c_str()) == 0)
				mModel->master()->setTempo(num);
			else 
				mModel->master()->setTempo(mModel->master()->tempo() + num);
		} else
			throw osc::MissingArgumentException();
	} else if(boost::regex_match(addr.c_str(), sync_re)){
		//make sure our matches list is long enough and that we have an argument
		if(matches.size() == 2 && arg_it != m.ArgumentsEnd()){
			int src = intFromOsc(*arg_it);
			mModel->master()->setSyncSource(src);
		} else
			throw osc::MissingArgumentException();
	} else {
		//XXX throw an error?
	}
}
	void ExternalVisualScrollMenu::ProcessMessage(const osc::ReceivedMessage& m, const IpEndpointName& remoteEndpoint)
	{

		printf("\nTesting process listening "); //Works

		//Take in package and break down into arguments


		std::vector<std::string> vals;
		/*Go through arguements. 
		0 = /Reply
		1 = Name
		2 = All arguments

		*/

		string name = "";
		bool aBreak = true;
		int i = 0;
		m;
		//EDITED
		vals.clear();
		for(osc::ReceivedMessageArgumentIterator it = m.ArgumentsBegin(); it != m.ArgumentsEnd(); it++, i++)
		{
			if (it->IsString())
			{
				//Convert the message into a usable string format
				std::string wub = ""; 
				wub = std::string (it->AsString());
				//If it is the first element
				if (i == 0)
				{
					//Check Break
					if (wub == "break")
					{
							printf("\nAccessed");
							s->AsynchronousBreak();
							aBreak = false;
					//Otherwise set the name
					}else
					{
						//Assign the string as the EV name
						name = wub;
					}
				//If not frst element
				}else
				{
					//Push into the parameters array
					vals.push_back(wub);
				}

				printf("THIS IS ONE STATEMENT");


			}else
			{
				printf("THIS IS ANOTHER STATMENT");

			}
			i++;

		}

		//Call External Visual Constructor
		//if( i >= 0)
		if( aBreak)
		{
			ExternalVisual* newVisual = new ExternalVisual (name,vals);
			//Add to the visuals list
			visuals.push_back(newVisual);
		}
	}
bool StandardRequestHandler::operator()(const std::string& request_path, const std::string& full_request_path, const osc::ReceivedMessage& m)
{
    try
    {
        std::string path = osgDB::getFilePath(full_request_path);
        std::string last_elem = osgDB::getSimpleFileName(full_request_path);

        osg::ref_ptr<osgGA::GUIEventAdapter> ea = getDevice()->getOrCreateUserDataEvent();
        osg::UserDataContainer* udc = ea->getOrCreateUserDataContainer();


        ea->setName(_treatFirstArgumentAsValueName ? full_request_path : path);
        udc->setName(ea->getName());

        if (m.ArgumentCount() == 0) {
            return true;
        }

        // if we have only one argument, get it and save it to the udc
        else if (m.ArgumentCount() == 1)
        {
            addArgumentToUdc(udc, last_elem, m.ArgumentsBegin());
            return true;
        }
        else
        {
            unsigned int i(0);
            osc::ReceivedMessageArgumentIterator start = m.ArgumentsBegin();
            if ((_treatFirstArgumentAsValueName) && (start->TypeTag() == osc::STRING_TYPE_TAG))
            {
                last_elem = start->AsString();
                ++start;
                // if we hav only 2 arguments, then save the value and return
                if (m.ArgumentCount() == 2)
                {
                    addArgumentToUdc(udc, last_elem, start);
                    return true;
                }
            }
            std::vector<float> float_vec;
            std::vector<double> double_vec;
            bool mixed_arguments(false);
            for(osc::ReceivedMessageArgumentIterator itr = start; itr != m.ArgumentsEnd(); ++itr, ++i)
            {
                if(itr->TypeTag() == osc::FLOAT_TYPE_TAG)
                {
                    float_vec.push_back(itr->AsFloat());
                }
                else if(itr->TypeTag() == osc::DOUBLE_TYPE_TAG)
                {
                    double_vec.push_back(itr->AsDouble());
                }
                else if(itr->TypeTag() == osc::INT32_TYPE_TAG)
                {
                    float_vec.push_back(itr->AsInt32());
                }
                else {
                    mixed_arguments = true;
                    break;
                }
            }
            if (!mixed_arguments)
            {
                unsigned int sum = float_vec.size() + double_vec.size();
                if (sum == float_vec.size())
                {
                    if (addNativeTypeFromVector(udc, last_elem, float_vec))
                        return true;
                }
                else if (sum == double_vec.size())
                {
                    if (addNativeTypeFromVector(udc, last_elem, double_vec))
                        return true;
                }
            }

            for(osc::ReceivedMessageArgumentIterator itr = start; itr != m.ArgumentsEnd(); ++itr, ++i)
            {
                std::ostringstream ss;
                ss << last_elem << "_" << i;
                addArgumentToUdc(udc, ss.str(), itr);
            }
        }
        return true;

    }
    catch(osc::Exception& e)
    {
        handleException(e);
        return false;
    }
    return false;
}
void TUIOMsgListener::ProcessMessage(const osc::ReceivedMessage &m, const IpEndpointName &remoteEndpoint) {
    try {
        const char *addr = m.AddressPattern();
        
        std::cout << "TUIOMsgListener: Received message "
            << addr << std::endl;
            
        const int prefixLen = strlen(tuioAddressPrefix);
        
        if (strncmp(addr, tuioAddressPrefix, prefixLen) == 0 && strlen(addr) > prefixLen + 1) {
            TUIOMsg *msg = new TUIOMsg;
            const char *type = (addr + prefixLen + 1);
            osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();
            const unsigned long numArgs = m.ArgumentCount();

            if (strcmp(type, "2Dobj") == 0) {
                msg->type = kTUIOMsgTypeObj;
            } else if (strcmp(type, "2Dcur") == 0) {
                msg->type = kTUIOMsgTypeCur;
            } else if (strcmp(type, "2Dblb") == 0) {
                msg->type = kTUIOMsgTypeBlb;
            } else {
                std::cerr << "TUIOMsgListener: unknown TUIO message type "
                    << type << std::endl;
                return;
            }
            
            const char *cmd = (arg++)->AsString();

            if (strcmp(cmd, "source") == 0) {
                msg->cmd = kTUIOMsgCmdSrc;
            } else if (strcmp(cmd, "alive") == 0) {
                msg->cmd = kTUIOMsgCmdAlive;
            } else if (strcmp(cmd, "set") == 0) {
                msg->cmd = kTUIOMsgCmdSet;
            } else if (strcmp(cmd, "fseq") == 0) {
                msg->cmd = kTUIOMsgCmdFSeq;
            } else {
                std::cerr << "TUIOMsgListener: unknown TUIO message command "
                    << cmd << std::endl;
                return;
            }
            
            switch (msg->cmd) {
                case kTUIOMsgCmdSrc: {
                    const char *srcAddr = (arg++)->AsString();
                    const int addrLen = strlen(srcAddr + 1);
                    msg->data.source.addr = new char[addrLen];
                    strncpy(msg->data.source.addr, srcAddr, addrLen);
                }
                break;

                case kTUIOMsgCmdAlive: {
                    msg->data.alive.numSessIds = numArgs - 1;
                    if (msg->data.alive.numSessIds > 0) {
                        msg->data.alive.sessIds = new int[msg->data.alive.numSessIds];
                        
                        for (int i = 0; i < msg->data.alive.numSessIds; i++) {
                            msg->data.alive.sessIds[i] = (arg++)->AsInt32();
                        }
                    } else {
                        msg->data.alive.sessIds = NULL;
                    }
                }
                break;
                
                case kTUIOMsgCmdSet: {
                    msg->data.set.sessId = (arg++)->AsInt32();
                
                    switch (msg->type) {
                        case kTUIOMsgTypeObj:
                            msg->data.set.classId = (arg++)->AsInt32();
                            msg->data.set.pos.x = (arg++)->AsFloat();
                            msg->data.set.pos.y = (arg++)->AsFloat();
                            msg->data.set.angle = (arg++)->AsFloat();
                            msg->data.set.size.x = 0.0f;
                            msg->data.set.size.y = 0.0f;
                            msg->data.set.area = 0.0f;
                            msg->data.set.vel.x = (arg++)->AsFloat();
                            msg->data.set.vel.y = (arg++)->AsFloat();
                            msg->data.set.angleVel = (arg++)->AsFloat();
                            msg->data.set.motAccel = (arg++)->AsFloat();
                            msg->data.set.rotAccel = (arg++)->AsFloat();
                        break;
                        
                        case kTUIOMsgTypeCur:
                            msg->data.set.classId = 0;
                            msg->data.set.pos.x = (arg++)->AsFloat();
                            msg->data.set.pos.y = (arg++)->AsFloat();
                            msg->data.set.angle = 0.0f;
                            msg->data.set.size.x = 0.0f;
                            msg->data.set.size.y = 0.0f;
                            msg->data.set.area = 0.0f;
                            msg->data.set.vel.x = (arg++)->AsFloat();
                            msg->data.set.vel.y = (arg++)->AsFloat();
                            msg->data.set.angleVel = 0.0f;
                            msg->data.set.motAccel = (arg++)->AsFloat();
                            msg->data.set.rotAccel = 0.0f;
                        break;
                        
                        case kTUIOMsgTypeBlb:
                            msg->data.set.classId = 0;
                            msg->data.set.pos.x = (arg++)->AsFloat();
                            msg->data.set.pos.y = (arg++)->AsFloat();
                            msg->data.set.angle = (arg++)->AsFloat();
                            msg->data.set.size.x = (arg++)->AsFloat();
                            msg->data.set.size.y = (arg++)->AsFloat();
                            msg->data.set.area = 0.0f;
                            msg->data.set.vel.x = (arg++)->AsFloat();
                            msg->data.set.vel.y = (arg++)->AsFloat();
                            msg->data.set.angleVel = (arg++)->AsFloat();
                            msg->data.set.motAccel = (arg++)->AsFloat();
                            msg->data.set.rotAccel = (arg++)->AsFloat();
                        break;
                    }
                }   
                break;
                
                case kTUIOMsgCmdFSeq: {
                    msg->data.fseq.frameId = (arg++)->AsInt32();
                }
                break;
            }
            
            if (msgCallback) {
                msgCallback(msg);
            }
        } else {
            std::cerr << "TUIOMsgListener: Address prefix " << addr << " did not match to "
                << tuioAddressPrefix << std::endl;
        }
    } catch( osc::Exception& e ){
        // any parsing errors such as unexpected argument types, or
        // missing arguments get thrown as exceptions.
        std::cerr << "TUIOMsgListener: error while parsing message "
            << m.AddressPattern() << ": " << e.what() << "\n";
    }
}
Exemple #21
0
void OscThread::ProcessMessage( const osc::ReceivedMessage& m, 
			const IpEndpointName& remoteEndpoint )
{
    (void) remoteEndpoint; // suppress unused parameter warning

    try{
            string keyword = m.AddressPattern();
        if( keyword == "/object")
		{
		cout<<"Received virtual object from osc"<<endl;
			//if (H2ICUB != NULL)
			
				osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();
				const char *type = (arg++)->AsString();
				const char *name = (arg++)->AsString();
            			string typeword = type;
				if (typeword == "add")
				{
					float x = (arg++)->AsFloat();
					float y = (arg++)->AsFloat();
					float dimx = (arg++)->AsFloat();
					float dimy = (arg++)->AsFloat();
					int r = (arg++)->AsInt32();
					int g = (arg++)->AsInt32();
					int b = (arg++)->AsInt32();
					cout<<"Adding object "<<name<<endl;

					if (!opc->isConnected())	
					{
						cout<<"Not connected to OPC"<<endl;
						return;
					}					
					if (!isCalibrated)	
					{
						cout<<"Not calibrated"<<endl;
						return;
					}

					RTObject* o = opc->addRTObject(name);
					opc->update(o);

					Vector rtPosition(4);
					rtPosition(0) = XaxisFactor * x;
					rtPosition(1) = YaxisFactor * y;
					rtPosition(2) = 0;
					rtPosition(3) = 1;

					o->m_rt_position[0] = rtPosition[0];
					o->m_rt_position[1] = rtPosition[1];
					o->m_rt_position[2] = rtPosition[2];
					cout<<o->toString()<<endl;

					Vector icubPos(4);
					icubPos = H2ICUB * rtPosition;
					o->m_ego_position[0] = icubPos[0];//+ idOffsets[tobj->getSymbolID()][0];
					o->m_ego_position[1] = icubPos[1];//+ idOffsets[tobj->getSymbolID()][1];
					o->m_ego_position[2] = icubPos[2];//+ idOffsets[tobj->getSymbolID()][2];

                    o->m_dimensions[0] = dimx;
                    o->m_dimensions[1] = dimy;
                    o->m_dimensions[2] = 0.01;

					o->m_present = true;
					o->m_ego_orientation[0] = 0.0;
					o->m_ego_orientation[1] = 0.0;
					o->m_ego_orientation[2] = 0.0;//tobj->getAngle();
					
					o->m_color[0] = r;
					o->m_color[1] = g;
					o->m_color[2] = b;//tobj->getAngle();

					//opc->isVerbose = true;
					opc->commit(o);
					//opc->isVerbose = false;
			cout<<"Added"<<endl;
				}				
				if (typeword == "remove")
				{					
					if (!opc->isConnected())	
					{
						cout<<"Not connected to OPC"<<endl;
						return;
					}
			cout<<"Removing object"<<endl;
					RTObject* o = opc->addRTObject(name);
					o->m_present = false;
					//opc->isVerbose = true;
					opc->commit(o);
					//opc->isVerbose = false;
			cout<<"Removed"<<endl;
				}			

        	}
		else if( keyword == "/event")
		{  
              osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();
                const char *subject = (arg++)->AsString();
                const char *verb = (arg++)->AsString();
                const char *cobj = "none";
                const char *cplace = "none";
                const char *ctime = "none";
                const char *cmanner = "none";
		double timeLife = 5.0;
                if (arg != m.ArgumentsEnd())
                    cobj = (arg++)->AsString();
                if (arg != m.ArgumentsEnd())
                    cplace = (arg++)->AsString();
                if (arg != m.ArgumentsEnd())
                    ctime = (arg++)->AsString();
                if (arg != m.ArgumentsEnd())
		    cmanner = (arg++)->AsString();
		if (arg != m.ArgumentsEnd())
		    timeLife = (arg++)->AsFloat();

                Relation r(subject,verb,cobj,cplace,ctime,cmanner);
		cout<<"Received relation (/Event) from OSC "<<r.toString()<< "with a lifetime of "<<timeLife<< "Trying to add : ";
		opc->addRelation(r, timeLife);
		cout<<endl;
          }
		else if( keyword == "/revent")
		{  
              osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();
                const char *subject = (arg++)->AsString();
                const char *verb = (arg++)->AsString();
                const char *cobj = "none";
                const char *cplace = "none";
                const char *ctime = "none";
                const char *cmanner = "none";
		double timeLife = 5.0;
                if (arg != m.ArgumentsEnd())
                    cobj = (arg++)->AsString();
                if (arg != m.ArgumentsEnd())
                    cplace = (arg++)->AsString();
                if (arg != m.ArgumentsEnd())
                    ctime = (arg++)->AsString();
                if (arg != m.ArgumentsEnd())
		    cmanner = (arg++)->AsString();
		if (arg != m.ArgumentsEnd())
		    timeLife = (arg++)->AsFloat();

                Relation r(subject,verb,cobj,cplace,ctime,cmanner);
		cout<<"Received relation remove request (/revent) from OSC "<<r.toString()<< "Trying to remove : ";
		opc->removeRelation(r);
		cout<<endl;
          } 
          else if ( keyword == "/bottle")
          {
            Bottle bFwd;				
			osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();
			const char *fwdMsg = (arg++)->AsString();
            cout<<"OSC input (bottle forwarding) : "<<fwdMsg<<endl;
			bFwd.addString(fwdMsg);
			oscFwding.write(bFwd);
          }          
		  else
          {
            cout<<"OSC input : Unknown format"<<endl;
          }
    }catch( osc::Exception& e ){

        std::cout << "error while parsing message: "
            << m.AddressPattern() << ": " << e.what() << "\n";
    }
}
Exemple #22
0
void OscReceiver::processDJControlMessage(const std::string addr, 
		DJMixerControlModel * control, 
		const osc::ReceivedMessage& m){
	boost::regex play_re("^play(/toggle){0,1}/{0,1}$");
	boost::regex cue_re("^cue(/toggle){0,1}/{0,1}$");
	boost::regex sync_re("^sync(/toggle){0,1}/{0,1}$");
	boost::regex seek_re("^seek(/relative){0,1}/{0,1}$");
	boost::regex reset_re("^reset$");
	boost::regex beatoffset_re("^beatoffset(/relative){0,1}/{0,1}$");
	boost::regex tempomul_re("^tempomul/{0,1}$");
	boost::cmatch matches;
	osc::ReceivedMessage::const_iterator arg_it = m.ArgumentsBegin();

	if(boost::regex_match(addr.c_str(), matches, play_re)){
		//"" == set else toggle
		if(strcmp(matches[1].str().c_str(), "") == 0){
			if(arg_it == m.ArgumentsEnd())
				throw osc::MissingArgumentException();
			else
				control->setPlay(boolFromBoolOrInt(*arg_it));
		} else 
			control->setPlay(!control->playing());
	} else if(boost::regex_match(addr.c_str(), matches, reset_re)){
			control->resetWorkPosition();
	} else if(boost::regex_match(addr.c_str(), matches, cue_re)){
		if(strcmp(matches[1].str().c_str(), "") == 0){
			//set
			if(arg_it == m.ArgumentsEnd())
				throw osc::MissingArgumentException();
			else
				control->setCueing(boolFromBoolOrInt(*arg_it));
		} else 
			control->setCueing(!control->cueing());
	} else if(boost::regex_match(addr.c_str(), matches, sync_re)){
		if(strcmp(matches[1].str().c_str(), "") == 0){
			//set
			if(arg_it == m.ArgumentsEnd())
				throw osc::MissingArgumentException();
			else
				control->setSync(boolFromBoolOrInt(*arg_it));
		} else 
			control->setSync(!control->synced());
	} else if(boost::regex_match(addr.c_str(), matches, seek_re)){
		if(arg_it == m.ArgumentsEnd())
			throw osc::MissingArgumentException();
		int arg = intFromOsc(*arg_it);
		if(strcmp(matches[1].str().c_str(), "") == 0){
			control->setPlaybackPosition(arg);
		} else 
			control->seek(arg);
	} else if(boost::regex_match(addr.c_str(), matches, beatoffset_re)){
		if(arg_it == m.ArgumentsEnd())
			throw osc::MissingArgumentException();
		int arg = intFromOsc(*arg_it);
		if(strcmp(matches[1].str().c_str(), "") == 0){
			control->setBeatOffset(arg);
		} else 
			control->setBeatOffset(control->beatOffset() + arg);
	} else if(boost::regex_match(addr.c_str(), tempomul_re)){
		if(arg_it == m.ArgumentsEnd())
			throw osc::MissingArgumentException();
		float mul = floatFromOscNumber(*arg_it);
		control->setTempoMul(mul);
	} else {
		//XXX throw an error?
	}
}
void MinuitNamespaceAnswer::parseMinuitNamespaceAnswer(const osc::ReceivedMessage&m)
{
	std::ostringstream oss;
	osc::ReceivedMessage::const_iterator arg = m.ArgumentsBegin();

	while (arg != m.ArgumentsEnd()) {
		std::string currentString = arg->AsString();

		if (currentString.find("nodes") != currentString.npos) {

			++arg;
			
			if (arg->IsString()) {
				currentString = arg->AsString();
			} else if (arg->IsInt32()) {
				oss.str("");
				oss << arg->AsInt32();
				currentString = oss.str();
			} else if (arg->IsFloat()) {
				oss.str("");
				oss << arg->AsFloat();
				currentString = oss.str();
			}

			while (currentString.find("}") == currentString.npos) {
				m_nodes.push_back(currentString);
				++arg;
				
				
				if (arg->IsString()) {
					currentString = arg->AsString();
				} else if (arg->IsInt32()) {
					oss.str("");
					oss << arg->AsInt32();
					currentString = oss.str();
				} else if (arg->IsFloat()) {
					oss.str("");
					oss << arg->AsFloat();
					currentString = oss.str();
				}

				//std::cout << "nodes : " << currentString << std::endl;
			}
		} else if  (currentString.find("leaves") != currentString.npos){

			++arg;
		
			if (arg->IsString()) {
				currentString = arg->AsString();
			} else if (arg->IsInt32()) {
				oss.str("");
				oss << arg->AsInt32();
				currentString = oss.str();
			} else if (arg->IsFloat()) {
				oss.str("");
				oss << arg->AsFloat();
				currentString = oss.str();
			}

			while (currentString.find("}") == currentString.npos) {
				m_leaves.push_back(currentString);
				++arg;
				
				if (arg->IsString()) {
					currentString = arg->AsString();
				} else if (arg->IsInt32()) {
					oss.str("");
					oss << arg->AsInt32();
					currentString = oss.str();
				} else if (arg->IsFloat()) {
					oss.str("");
					oss << arg->AsFloat();
					currentString = oss.str();
				}
			}

		} else if  ((currentString.find("attributes") != currentString.npos) || (currentString.find("attributs") != currentString.npos)){

			++arg;
			
			if (arg->IsString()) {
				currentString = arg->AsString();
			} else if (arg->IsInt32()) {
				oss.str("");
				oss << arg->AsInt32();
				currentString = oss.str();
			} else if (arg->IsFloat()) {
				oss.str("");
				oss << arg->AsFloat();
				currentString = oss.str();
			}

			while (currentString.find("}") == currentString.npos) {
				m_attributs.push_back(currentString);
				++arg;
				
				if (arg->IsString()) {
					currentString = arg->AsString();
				} else if (arg->IsInt32()) {
					oss.str("");
					oss << arg->AsInt32();
					currentString = oss.str();
				} else if (arg->IsFloat()) {
					oss.str("");
					oss << arg->AsFloat();
					currentString = oss.str();
				}
			}
		}

		++arg;
	}

//	std::cout << "NODES" << std::endl;
//
//	for (unsigned int i = 0; i < m_nodes.size(); ++i) {
//		std::cout << m_nodes[i] << std::endl;
//	}
//
//	std::cout << "LEAVES" << std::endl;
//
//	for (unsigned int i = 0; i < m_leaves.size(); ++i) {
//		std::cout << m_leaves[i] << std::endl;
//	}
//
//	std::cout << "ATTRIBUTES" << std::endl;
//
//	for (unsigned int i = 0; i < m_attributes.size(); ++i) {
//		std::cout << m_attributes[i] << std::endl;
//	}
	//
	m_state = ANSWER_RECEIVED;
}
void SerialOscController::ProcessMessage(const osc::ReceivedMessage& m, const IpEndpointName& remoteEndpoint)
{
	(void)remoteEndpoint;

	String address = m.AddressPattern();
	auto iter = m.ArgumentsBegin();

	try {
		if (address == "/serialosc/device" || address == "/serialosc/add") {
			String id = (iter++)->AsString();
			String type = (iter++)->AsString();
			int port = (iter++)->AsInt32();
			MonomeDevice *device = nullptr;

			if (devices.contains(id)) {
				device = devices[id];
			}
			else {
				device = new MonomeDevice;
				devices.set(id, device);

				if (address == "/serialosc/add") {
					sendDeviceNotifyMessage();
				}
			}

			device->id = id;
			device->type = type;
			device->port = port;
			device->prefix = devicePrefix;

			if (!device->prefix.startsWith("/")) {
				device->prefix = "/" + device->prefix;
			}

			sendDeviceInfoMessage(device->port);

			sendDevicePrefixMessage(port);
			sendDevicePortMessage(port);
		}
		else if (address == "/serialosc/remove") {
			String id = (iter++)->AsString();

			if (devices.contains(id)) {
				delete devices[id];
				devices.remove(id);
				sendDeviceNotifyMessage();
			}
		}
		else if (address == "/sys/id") {
			currentDeviceID = (iter++)->AsString();
		}
		else if (address == "/sys/size") {
			if (devices.contains(currentDeviceID)) {
				auto device = devices[currentDeviceID];
				device->width = (iter++)->AsInt32();
				device->height = (iter++)->AsInt32();
			}
		}
		else if (address == "/sys/rotation") {
			if (devices.contains(currentDeviceID)) {
				auto device = devices[currentDeviceID];
				device->rotation = (iter++)->AsInt32();
			}
		}
		else if (address == ("/" + devicePrefix + "/grid/key")) {
			int x = (iter++)->AsInt32();
			int y = (iter++)->AsInt32();
			bool state = (iter++)->AsInt32() > 0;

			listener->buttonPressMessageReceived(x, y, state);
		}
	}
	catch(osc::WrongArgumentTypeException &exc) {
		printf("WrongArgumentTypeException: %s", exc.what());
	}
}
Exemple #25
0
void OscReceiver::processMixerMessage(const std::string addr, const osc::ReceivedMessage& m){
	boost::regex mixer_re("^/(\\d+)/(.+)");
	boost::regex volume_re("^volume(/relative){0,1}/{0,1}$");
	boost::regex mute_re("^mute(/toggle){0,1}/{0,1}$");
	boost::regex eq_re("^eq/(high|mid|low)(/relative|/cut|/cut/toggle){0,1}/{0,1}$");
	boost::regex load_re("^load/{0,1}$");
	boost::cmatch matches;
	osc::ReceivedMessage::const_iterator arg_it = m.ArgumentsBegin();

	if(boost::regex_match(addr.c_str(), matches, mixer_re)){
		unsigned int mixer = (unsigned int)atoi(matches[1].str().c_str());
		std::string remain(matches[2].str());
		//make sure we're in range
		if(mixer >= mModel->numMixerChannels())
			return;
		if(boost::regex_match(remain.c_str(), matches, volume_re)){
			//make sure our matches list is long enough and that we have an argument
			if(matches.size() == 2 && arg_it != m.ArgumentsEnd()){
				float num = floatFromOscNumber(*arg_it);
				//"" == absolute, otherwise, relative
				if(strcmp("", matches[1].str().c_str()) == 0)
					mModel->mixerChannels()->at(mixer)->setVolume(num);
				else {
					mModel->mixerChannels()->at(mixer)->setVolume(
							mModel->mixerChannels()->at(mixer)->volume() + num);
				}
			} else
				throw osc::MissingArgumentException();
		} else if(boost::regex_match(remain.c_str(), matches, mute_re)){
			//make sure our matches list is long enough to test
			if(matches.size() == 2){
				//if we have no argument then we're just setting the mute
				//otherwise toggle mute
				if(strcmp("", matches[1].str().c_str()) == 0) {
					if(arg_it != m.ArgumentsEnd())
						mModel->mixerChannels()->at(mixer)->setMuted(boolFromBoolOrInt(*arg_it));
					else 
						throw osc::MissingArgumentException();
				} else {
					mModel->mixerChannels()->at(mixer)->setMuted(
							!mModel->mixerChannels()->at(mixer)->muted());
				}
			}
		} else if(boost::regex_match(remain.c_str(), matches, eq_re)){
			if(matches.size() == 3){
				EQModel * eqModel = mModel->mixerChannels()->at(mixer)->eq();
				//figure out the band
				EQModel::band band;
				if(strcmp(matches[1].str().c_str(), "low") == 0)
					band = EQModel::LOW;
				else if(strcmp(matches[1].str().c_str(), "mid") == 0)
					band = EQModel::MID;
				else
					band = EQModel::HIGH;

				if(strcmp(matches[2].str().c_str(), "") == 0){
					//absolute
					if(arg_it == m.ArgumentsEnd())
						throw osc::MissingArgumentException();
					else
						eqModel->set(band, floatFromOscNumber(*arg_it));
				} else if(strcmp(matches[2].str().c_str(), "/cut") == 0){
					//cut
					if(arg_it == m.ArgumentsEnd())
						throw osc::MissingArgumentException();
					else
						eqModel->cut(band, boolFromBoolOrInt(*arg_it));
				} else if(strcmp(matches[2].str().c_str(), "/cut/toggle") == 0){
					//toggle cut
					eqModel->toggleCut(band);
				} else {
					//otherwise it is relative
					if(arg_it == m.ArgumentsEnd())
						throw osc::MissingArgumentException();
					else {
						eqModel->set(band, 
								eqModel->value(band) + floatFromOscNumber(*arg_it));
					}
				}
			}
		} else if(boost::regex_match(remain.c_str(), load_re)){
			if(arg_it == m.ArgumentsEnd())
				throw osc::MissingArgumentException();
			int work = intFromOsc(*arg_it);
			mModel->mixerChannels()->at(mixer)->loadWork(work);
			//otherwise it is a djmixer control message [or not valid]
		} else {
			processDJControlMessage(remain.c_str(), mModel->mixerChannels()->at(mixer)->control(), m);
		}
	}
}