comparison src/AudioEventMatcher.cpp @ 20:4f6006cac9de

added evaluation of recorded tempo, holding of this data, drawing of recorded and playing tempo estimates

 
 
 	
 	followingLiveInput = true;
 	startedPlaying = false;
-	
-	temporal.setUpEventTimeMatrix();
+	recordedTempoIndex = 0;
+//	temporal.setUpEventTimeMatrix();
+//	recordedTempoData.setUpEventTimeMatrix();
 }
 
 
 
 

 
 void AudioEventMatcher::loadAudioFiles(){
 	recordedTracks.loadTestAudio();
 	synchroniser.fileLengthSamples = recordedTracks.loadedAudioFiles[0].fileLoader.totalNumberOfSamples;
 	printf("synchroniser has %f samples\n", synchroniser.fileLengthSamples);
+	
+	calculateRecordedTempoData();
+	printf("\n\nFIRST PASS: FINAL recorded tempo is %f\n", recordedTempoData.playingTempo);
+	setTempoPrior(recordedTempoData.playingTempo);
+	calculateRecordedTempoData();//now calculate again using better prior
+	
+	printf("\n\nSECOND PASS: FINAL recorded tempo is %f\n", recordedTempoData.playingTempo);
+	printf("GLOBAL TEMPO of RECORDED FILES\n");
+	recordedTempoData.printTempoTimes();
+}
+
+void AudioEventMatcher::setTempoPrior(double tempo){
+	recordedTempoData.zero();
+	recordedTempoData.tempoPosterior.zero();
+	recordedTempoData.tempoPosterior.addGaussianShapeFromRealTime(tempo, 3, 1);
+
+}
+
+void AudioEventMatcher::calculateRecordedTempoData(){
+	int indexForOnsets[3];
+		indexForOnsets[0] = 0;
+		indexForOnsets[1] = 0;
+		indexForOnsets[2] = 0;
+	int kickTime, snareTime;
+	while (indexForOnsets[0] < recordedTracks.loadedAudioFiles[0].fileLoader.onsetDetect.chromaOnsets.size() || 
+		   indexForOnsets[2] < recordedTracks.loadedAudioFiles[2].fileLoader.onsetDetect.chromaOnsets.size()) {
+		
+		setNextOnsetTime(0, kickTime, &indexForOnsets[0]);
+		setNextOnsetTime(2, snareTime, &indexForOnsets[0]);
+		
+		if (kickTime < snareTime){
+			printf("update kick at %i\n", kickTime);
+			recordedTempoData.updateTempo(0, kickTime);
+			printf("recorded tempo is %f\n", recordedTempoData.playingTempo);
+			indexForOnsets[0]++;
+		}else {
+			printf("update snare at %i\n", snareTime);
+			recordedTempoData.updateTempo(2, snareTime);
+			printf("recorded tempo is %f\n", recordedTempoData.playingTempo);
+			indexForOnsets[2]++;
+		}
+	}//end while
+	
+	
+}
+
+void AudioEventMatcher::setNextOnsetTime(const int& channel, int& time, int* indexForOnsets){
+	if (indexForOnsets[channel] < recordedTracks.loadedAudioFiles[channel].fileLoader.onsetDetect.chromaOnsets.size()){
+		time = recordedTracks.loadedAudioFiles[channel].fileLoader.onsetDetect.chromaOnsets[indexForOnsets[channel]].millisTime;
+	}
+	else {
+		time = 2147483647;//infinity
+	}
 }
 
 void AudioEventMatcher::startPlaying(){
 	bayesianStruct.setStartPlaying();
 	currentAlignmentPosition = 0;

 	projectedPrior = bayesianStruct.prior;
 	startedPlaying = true;
 	synchroniser.reset();
 	temporal.reset();
 	
+	recordedTempoIndex = 0;
+	recordedTempo = recordedTempoData.globalTempo[recordedTempoIndex];
+	
+	currentSpeedRatio = 1;
+	
+	//SET TEMPO PRIOR for Speed Ratio
+	//the update this
+	setSpeedRatioDistribution(currentSpeedRatio);
 	//bayesianStruct.posterior.printArray();
 }
 
+
+void AudioEventMatcher::setSpeedRatioDistribution(const double& speedRatio){
+	bayesianStruct.relativeSpeedPosterior.zero();
+	bayesianStruct.relativeSpeedPosterior.addToIndex(bayesianStruct.relativeSpeedPosterior.getRealTermsAsIndex(speedRatio), 1);
+	bayesianStruct.relativeSpeedPosterior.addGaussianShapeFromRealTime(1, 0.06, 0.5);
+}
 
 void AudioEventMatcher::stopPlaying(){
 	startedPlaying = false;
 	temporal.printEventTimes();
 }

 	if (!followingLiveInput)
 		recordedTracks.updatePosition();
 	else
 		recordedTracks.updatePositionToMillis(currentAlignmentPosition);
 		
-	updateBestAlignmentPosition();
-	}
+		updateBestAlignmentPosition();
+	}
+	
+	updateRecordedTempo();
 	
 	temporal.tempoPosterior.addGaussianShape(temporal.tempoPosterior.MAPestimate, temporal.tempoArraySize / 4, 0.5	);
+}
+
+void AudioEventMatcher::updateRecordedTempo(){
+	//tempo of equivalent recorded position is updated 
+	while(currentAlignmentPosition > recordedTempoData.globalTempoTimes[recordedTempoIndex]){
+		recordedTempoIndex++;
+	}
+	recordedTempo = recordedTempoData.globalTempo[recordedTempoIndex];
+	double tmpRatio = currentSpeedRatio;
+	currentSpeedRatio = temporal.playingTempo / recordedTempo;
+	if (currentSpeedRatio != tmpRatio)
+		setSpeedRatioDistribution(currentSpeedRatio);
 }
 
 void AudioEventMatcher::updateBestAlignmentPosition(){
 	//THIS DEALS WITH WHERE WE ARE NOW! ON THE SCREEN
 	//DIFFERENT TO WHEN EVENTS COME IN AS THEY ARE TIMESTAMPED - SO EG A PITCH EVENT MAY ARRIVE 16 CHROMA FRAMES LATER - BIG DIFFERENCE

 	alignString += "  pos "+ofToString(synchroniser.playingPositionMillis,0)+" ms";
 	alignString +=  "  rec pos "+ofToString(synchroniser.recordedPositionMillis,0)+" ms";
 	ofDrawBitmapString(alignString, 20, 50);
 	
 	ofDrawBitmapString("pos "+ofToString(recordedTracks.loadedAudioFiles[0].fileLoader.onsetDetect.playPosition), 200,600);
-}
-	
+
+	temporal.drawTempoArray(bayesLikelihoodWindow);
+	
+	drawRecordedTempo();
+	drawPlayingTempo();
+	
+	
+}
+
+void AudioEventMatcher::drawRecordedTempo(){
+	
+	int xTempoIndex = ofGetWidth() * (recordedTempo - recordedTempoData.minimumTempoInterval)/(recordedTempoData.maximumTempoInterval - recordedTempoData.minimumTempoInterval);
+	ofSetColor(0, 200, 0);
+	ofLine(xTempoIndex, bayesLikelihoodWindow.y, xTempoIndex, bayesLikelihoodWindow.y + bayesLikelihoodWindow.height);
+	ofDrawBitmapString(ofToString(recordedTempo), xTempoIndex, bayesLikelihoodWindow.y + 10);
+}
+
+void AudioEventMatcher::drawPlayingTempo(){
+	
+	int xTempoIndex = ofGetWidth() * (temporal.playingTempo - temporal.minimumTempoInterval)/(temporal.maximumTempoInterval - temporal.minimumTempoInterval);
+	ofSetColor(200, 0, 200);
+	ofLine(xTempoIndex, bayesLikelihoodWindow.y, xTempoIndex, bayesLikelihoodWindow.y + bayesLikelihoodWindow.height);
+	ofDrawBitmapString(ofToString(recordedTempo), xTempoIndex, bayesLikelihoodWindow.y + 10);
+	
+	int xSpeedRatioIndex = (double)(temporal.tempoPosterior.getIndexInRealTerms(currentSpeedRatio)*ofGetWidth())/(double)temporal.tempoPosterior.arraySize;
+	ofSetColor(200,0,0);
+	ofLine(xSpeedRatioIndex, bayesTempoWindow.y, xSpeedRatioIndex, bayesTempoWindow.y + bayesTempoWindow.height);
+	ofDrawBitmapString(ofToString(currentSpeedRatio), 100, bayesTempoWindow.y+50);
+
+}
+
+
 void AudioEventMatcher::setScreenDisplayTimes(){
 		screenWidthMillis = recordedTracks.loadedAudioFiles[0].fileLoader.onsetDetect.framesToMillis(recordedTracks.loadedAudioFiles[0].fileLoader.onsetDetect.amplitudeNumber);
 	//	if (!followingLiveInput){
 		
 		screenStartTimeMillis = recordedTracks.loadedAudioFiles[0].fileLoader.onsetDetect.framesToMillis(recordedTracks.loadedAudioFiles[0].fileLoader.onsetDetect.drawParams.windowStartFrame);

 	bayesianStruct.prior.drawConstrainedVector(bayesianStruct.prior.getRealTermsAsIndex(screenStartTimeMillis), bayesianStruct.prior.getRealTermsAsIndex(screenEndTimeMillis), 0, ofGetWidth(), bayesPositionWindow);
 	
 	ofSetColor(255,0,0);
 	projectedPrior.drawConstrainedVector(bayesianStruct.prior.getRealTermsAsIndex(screenStartTimeMillis), bayesianStruct.prior.getRealTermsAsIndex(screenEndTimeMillis), 0, ofGetWidth(), bayesPositionWindow);
 	
-	temporal.drawTempoArray(bayesLikelihoodWindow);
+	
 	
 }
 
 void AudioEventMatcher::newPitchEvent(const int& channel, const double& pitchIn, const double& timeIn){
 	if (pitchIn > 0){