annotate src/testApp.cpp @ 53:5274e3b5479d

Smoothed output, added tempo distribution variation to match the output

#include "testApp.h"
#include "stdio.h"
//#include "aubio.h"
#include <iostream>
#include <cstring>
#include <string>
#include <cstdlib> 


/*
 L: load marker file
 S: save markers
 
 */

const double samplingFrequency = 44100.0;
	
//--------------------------------------------------------------
void testApp::setup(){

	// 2 output channels,
	// 0 input channels
	// 22050 samples per second
	// 256 samples per buffer
	// 4 num buffers (latency)
	
	//nb THIS CODE WOULD BE USEFUL IF WE EVER WANTED REAL-TIME INPUT - VIA ofSoundSteam
	
	receiver.setup( PORT );
	
	sampleRate 			= 44100;
	ofSoundStreamSetup(2,0,this, sampleRate,256, 4);

	ofSetFrameRate(20);

	eventMatcher.loadAudioFiles();
	
	eventMatcher.setWindowDimensions();
	
	outputWriter.openFile("../../../data/output.txt");
	
	//audioFilePlayer.loadAudioFile(infilename);
}


//--------------------------------------------------------------
void testApp::update(){
	eventMatcher.updatePosition();
	
	checkForOSCmessages();
	
	outputWriter.writeOutput(eventMatcher.synchroniser.recordedPositionTimeSent, eventMatcher.synchroniser.recordedPositionMillis, eventMatcher.synchroniser.playingPositionMillis);
	
}

void testApp::checkForOSCmessages(){
	// check for waiting messages
	while( receiver.hasWaitingMessages() )
	{
		// get the next message
		ofxOscMessage m;
		receiver.getNextMessage( &m );
		
		// check for mouse moved message
		if ( m.getAddress() == "/aubioPitch" ){
			int testChannel = m.getArgAsInt32(0);
			float pitchIn = m.getArgAsFloat(1); 
			int timeIn = m.getArgAsInt32(2); 
			printf("\nAUBIO PITCH RECEIVED %f at time %i\n", pitchIn, timeIn);
			eventMatcher.newPitchEvent(testChannel, pitchIn, timeIn);
		}
		
		if ( m.getAddress() == "/kick" ){
		//	float pitchIn = m.getArgAsFloat(0);
			int testChannel = m.getArgAsInt32(0);
			double timeIn = m.getArgAsInt32(1); 
			printf("\nKICK RECEIVED at time %f\n", timeIn);
		
			eventMatcher.newKickEvent(testChannel, timeIn);
			
		}
		
		if ( m.getAddress() == "/snare" ){
			int testChannel = m.getArgAsInt32(0);
			double timeIn = m.getArgAsInt32(1);
			printf("\nSNARE RECEIVED at time %f\n", timeIn);
			
			eventMatcher.newSnareEvent(testChannel, timeIn);
		}
		
		// check for mouse moved message
		if ( m.getAddress() == "/elec" ){
			int testChannel = m.getArgAsInt32(0);
			double timeIn = m.getArgAsFloat(1);
			float chromaIn[12];
			
			printf("CHROMA received at time %f\n", timeIn);
			for (int i = 0;i < 12;i++){
				chromaIn[i] = m.getArgAsFloat(i+2);
			//	printf("chroma[%i]: %f\n", i, chromaIn[i]);
			}
			eventMatcher.newChromaEvent(testChannel, chromaIn, timeIn);
		}
		
		
		if (m.getAddress() == "/startWindow"){
			eventMatcher.bayesianStruct.startingWindowWidth = m.getArgAsFloat(0);
		}
		
		
		if ( m.getAddress() == "/start" ){
			printf("start!\n");
			printf("STRART TIME IN %i\n", ofGetElapsedTimeMillis());
			outputWriter.openFile();
			eventMatcher.startPlaying();
			printf("TIME OUT %i\n", ofGetElapsedTimeMillis());
		}
		
		if ( m.getAddress() == "/stop" ){
			printf("stop!\n");
			eventMatcher.stopPlaying();
			outputWriter.closeFile();
		}
		
		if (m.getAddress() == "/marker"){
			eventMatcher.goToMarker(m.getArgAsInt32(0));
		}
		
		if ( m.getAddress() == "/accompanimentRatio" ){
			double time = m.getArgAsFloat(0);
			double ratio = m.getArgAsFloat(1);
			eventMatcher.synchroniser.setPlayingRatio(ratio, time);
		}
		
		if ( m.getAddress() == "/rescue" ){
			printf("rescue!\n");
			eventMatcher.rescue();
		}
	
	}
}

//--------------------------------------------------------------
void testApp::draw(){
	
	eventMatcher.draw();
	
//	audioFilePlayer.draw();

}



//--------------------------------------------------------------
void testApp::keyPressed  (int key){
	if (key == '-'){
		volume -= 0.05;
		volume = MAX(volume, 0);
	} else if (key == '+'){
		volume += 0.05;
		volume = MIN(volume, 1);
	}

	if (key == 'q'){
		eventMatcher.recordedTracks.switchScreens();
	}
	
	if (key == OF_KEY_RIGHT){
//		audioFilePlayer.loadedAudio.setPosition(min(1.0, audioFilePlayer.loadedAudio.getPosition() + (audioFilePlayer.fileLoader.audioHolder.audioScaleSamples/(4.0*audioFilePlayer.fileLoader.audioHolder.audioVector.size()))) );

	}
	
	if (key == OF_KEY_LEFT){
//		audioFilePlayer.loadedAudio.setPosition(max(0.0, audioFilePlayer.loadedAudio.getPosition() - (audioFilePlayer.fileLoader.audioHolder.audioScaleSamples/(4.0*audioFilePlayer.fileLoader.audioHolder.audioVector.size()))));
		
	}
	
	if (key == 'c'){
		eventMatcher.useChromaDotProduct = !eventMatcher.useChromaDotProduct;
		printf("Use dot product is %i\n", eventMatcher.useChromaDotProduct);
	}
	
	if (key == ' '){
		if (!eventMatcher.startedPlaying){
			eventMatcher.recordedTracks.togglePlay();
		}
	}
	//Marker commands
	if (key == 'm'){
		eventMatcher.addMarkerNow();
	}
	
	if (key == 'f'){
		eventMatcher.deleteMarkers();
	}
	if (key == 'd'){
		eventMatcher.deleteNearestMarker();
	}
//	if (key == 's'){
//		eventMatcher.markedPoints.saveMarkers();
//	}

	if (key == 's')
		eventMatcher.markedPoints.saveFile();
	
	if (key == 'l')
		eventMatcher.markedPoints.loadFile();
	
	
	if (key == '.'){
		eventMatcher.moveToNextMarker();
	}
	if (key == ','){
		eventMatcher.moveToPreviousMarker();
	}
	
	if (key == 'j'){
		printf("dynamic vector scalar is %f\n", eventMatcher.bayesianStruct.posterior.scalar);
	}

	if (key == OF_KEY_RETURN){
		eventMatcher.recordedTracks.stop();
	}
	
	
	if (key == 'o'){
		openNewAudioFileWithdialogBox();

	}

	if (key == 'p'){
		eventMatcher.bayesianStruct.posterior.printArray();
	}

	
	if (key == OF_KEY_UP){
		eventMatcher.recordedTracks.zoomOut();
	
	}
	
	if (key == OF_KEY_DOWN){
		eventMatcher.recordedTracks.zoomIn();
	}
	
	if (key == 'k')
		eventMatcher.drawLikelihoods = !eventMatcher.drawLikelihoods;
	
	if (key == 'g'){
		eventMatcher.writeAllDistributions();
	}

}

//--------------------------------------------------------------
void testApp::keyReleased  (int key){

}


//--------------------------------------------------------------
void testApp::mouseMoved(int x, int y ){


}

//--------------------------------------------------------------
void testApp::mouseDragged(int x, int y, int button){

}

//--------------------------------------------------------------
void testApp::mousePressed(int x, int y, int button){
	eventMatcher.mousePressed(x);
}


//--------------------------------------------------------------
void testApp::mouseReleased(int x, int y, int button){

}

//--------------------------------------------------------------
void testApp::windowResized(int w, int h){
	
	eventMatcher.windowResized(w, h);
	
	
}
//--------------------------------------------------------------
void testApp::audioRequested 	(float * output, int bufferSize, int nChannels){
	//pan = 0.5f;
	float leftScale = 1 - pan;
	float rightScale = pan;

}



//--------------------------------------------------------------
void testApp::openNewAudioFileWithdialogBox(){
	std::string filename;
	getFilenameFromDialogBox(&filename);
	loadNewAudio(filename);
	
}


void testApp::loadNewAudio(string soundFileName){
	
	eventMatcher.recordedTracks.loadedAudioFiles[0].loadAudioFile(soundFileName);
	
//	for (int i = 0;i < numberOfAudioTracks;i++)
//		loadedAudioFiles[i].loadAudioFile(soundFileName);
	
//	audioFilePlayer.loadAudioFile(soundFileName);

}


bool testApp::getFilenameFromDialogBox(std::string* fileNameToSave){
	//this uses a pointer structure within the loader and returns true if the dialogue box was used successfully
	// first, create a string that will hold the URL
	string URL;
	
	// openFile(string& URL) returns 1 if a file was picked
	// returns 0 when something went wrong or the user pressed 'cancel'
	int response = ofxFileDialogOSX::openFile(URL);
	if(response){
		// now you can use the URL 
		*fileNameToSave = URL;
		//printf("\n filename is %s \n", soundFileName.c_str());
		return true;
	}
	else {
	//	soundFileName = "OPEN canceled. ";
		printf("\n open file cancelled \n");
		return false;
	}
	
}