first performance version

1 files changed, 1039 insertions, 0 deletions

diff --git a/07_performance/src/testApp.cpp b/07_performance/src/testApp.cpp
new file mode 100644
index 0000000..a5cbf55
--- /dev/null
+++ b/07_performance/src/testApp.cpp
@@ -0,0 +1,1039 @@
+#include "testApp.h"
+
+	/*
+	maybe draw pixel lines to a range of buffers and then play them in various 3D directions
+	pixel lines can have nice, missing corners and be nicely smoothed
+
+	is it insane not to do this in vvvv
+
+	can there be an editing interface
+
+	have a play with vvvv/ max and try to replicate this idea QUICKLY?
+	*/
+
+
+//--------------------------------------------------------------
+void testApp::setup(){
+
+	midiIn.listPorts();
+
+	midiIn.openPort(0); //this was 1 on linux, 0 on OSX
+	midiIn.addListener(this);
+
+	midiOut.listPorts();
+	midiOut.openPort(0); //this was 1 on linux, 0 on OSX
+
+	// 0 output channeLs,
+	// 2 input channels
+	// 44100 samples per second
+	// BUFFER_SIZE samples per buffer
+	// 4 num buffers (latency)
+
+	soundStream.listDevices();
+
+	left = new float[BUFFER_SIZE];
+	right = new float[BUFFER_SIZE];
+
+	//soundStream.setDeviceID(7); //ignore to use  default?
+	soundStream.setup(this, 0, 2, 44100, BUFFER_SIZE, 4);
+	//soundStream.setup(this, 0, 4, 44100, BUFFER_SIZE, 4);
+
+	ofSetHexColor(0x666666);
+
+	lFFTanalyzer.setup(44100, BUFFER_SIZE/2,32);
+
+	lFFTanalyzer.peakHoldTime = 15; // hold longer
+	lFFTanalyzer.peakDecayRate = 0.95f; // decay slower
+	lFFTanalyzer.linearEQIntercept = 0.9f; // reduced gain at lowest frequency
+	lFFTanalyzer.linearEQSlope = 0.01f; // increasing gain at higher frequencies
+
+	rFFTanalyzer.setup(44100, BUFFER_SIZE/2,32);
+
+	rFFTanalyzer.peakHoldTime = 15; // hold longer
+	rFFTanalyzer.peakDecayRate = 0.95f; // decay slower
+	rFFTanalyzer.linearEQIntercept = 0.9f; // reduced gain at lowest frequency
+	rFFTanalyzer.linearEQSlope = 0.01f; // increasing gain at higher frequencies
+
+/*
+	if (4chan)
+	{
+		lFFTanalyzer2.setup(44100, BUFFER_SIZE/2,32);
+
+		lFFTanalyzer2.peakHoldTime = 15; // hold longer
+		lFFTanalyzer2.peakDecayRate = 0.95f; // decay slower
+		lFFTanalyzer2.linearEQIntercept = 0.9f; // reduced gain at lowest frequency
+		lFFTanalyzer2.linearEQSlope = 0.01f; // increasing gain at higher frequencies
+
+		rFFTanalyzer2.setup(44100, BUFFER_SIZE/2,32);
+
+		rFFTanalyzer2.peakHoldTime = 15; // hold longer
+		rFFTanalyzer2.peakDecayRate = 0.95f; // decay slower
+		rFFTanalyzer2.linearEQIntercept = 0.9f; // reduced gain at lowest frequency
+		rFFTanalyzer2.linearEQSlope = 0.01f; // increasing gain at higher frequencies
+	}
+	*/
+
+	ofSetFrameRate(60);
+
+	ofBackground(0,0,0);
+
+    F_movieSpeed=0.0;
+
+	//blendImage.loadImage("blend01.png");
+	blendImage.loadMovie("blend.mp4");
+	blendImage.play();
+    blendImage.setLoopState(OF_LOOP_NORMAL);
+    blendImage.setSpeed(F_movieSpeed);
+
+    I_movieSource=0;
+    I_moviePlaying=0;
+
+	//renderImage.allocate(ofGetWidth(),ofGetHeight(),GL_RGB);
+	renderImage.allocate(4080,768,GL_RGB);
+	maskShader.load("composite");
+
+	//testImage.loadImage("mask.png");
+
+
+	maskShader.begin();
+	maskShader.setUniformTexture("Tex0", blendImage.getTextureReference(), 0);
+	maskShader.setUniformTexture("Tex1", renderImage.getTextureReference(), 1);
+	maskShader.end();
+
+	showFPS=false;
+
+	//defaults
+
+	F_scale=0;
+	F_drawFrames=10;
+	F_drawStep=0;
+	F_drawDecay=0.95;
+	F_lineWidth=1.0; //1.0;
+	F_drawAxis=90; //Y
+
+
+	F_xRotate=0;
+	F_yRotate=0;
+	F_zRotate=0;
+
+	F_xRotation=180;
+	F_yRotation=180; //was 180
+	F_zRotation=0;
+
+	F_particleAmount=2000; //100
+	F_particleLife=0.75; //0.5
+	F_particleSize=16.0; //1.0;
+
+	I_fade1=0;
+	I_fade2=0;
+
+	thisFFTbuffer=0;
+
+	lastFrameTime=ofGetElapsedTimef();
+
+	draworder=true; //forwards;
+
+	visMode=WAVEFORM;
+
+	B_vSync=true;
+	B_fill=true;
+
+	inputMode=PICTURE;
+
+
+	gammamap=new unsigned char[256];
+
+
+	whitePt=0.9;
+	blackPt=0.3;
+	gamma=1.0;
+
+	//calc gamma map
+	for (int i=0;i<256;i++){
+       float ewp=max(whitePt,blackPt+0.1f); //limit range to 0.1
+       gammamap[i]=(unsigned char)(pow(min(1.0f,max(0.0f,(((float(i)/255.0f)-blackPt)/(ewp-blackPt)))),gamma)*255.0);
+	}
+
+    B_glitch=false;
+
+    blanker.allocate(64,64,OF_IMAGE_COLOR);
+    // blanker.loadImage("black.png");
+
+
+    fullScreen=false;
+
+	setMidiState();
+
+	receiver.setup(OSCPORT);
+
+	target.setPosition(0,0,0);
+    camera.setPosition(0,0,-700);
+    camera.lookAt(target,ofVec3f(0,1,0));
+	narrator.init("TRSS_nesbitt_recordings.xml");
+
+    if( !XML.loadFile("videos.xml") ){
+        printf("unable to load videos, check data/ folder\n");
+    }else{
+        if(XML.pushTag("TRSS")) {
+            int num=XML.getNumTags("video");
+            if(num) {
+            	int i;
+                for (i=0;i<num;i++) {
+                    videoclips.push_back(ofVideoPlayer());
+                    videoclips[i].loadMovie(XML.getAttribute("video","file","",i));
+                    videoclips[i].setLoopState(OF_LOOP_NONE);
+                    videoclips[i].stop();
+                }
+                cerr<<"loaded "<<i<<" video clips"<<endl;
+            }
+            else printf("no video clips found!\n");
+        }
+    }
+
+    xOffs=startX=yOffs=startY=0;
+    xModel=0;
+    yModel=0;
+    zModel=-1050;
+    sModel=4.0f;
+};
+
+
+
+
+//--------------------------------------------------------------
+void testApp::update(){
+
+	// check for waiting messages
+    while(receiver.hasWaitingMessages()){
+        // get the next message
+        ofxOscMessage m;
+        receiver.getNextMessage(&m);
+
+
+        ///mrmr/pushbutton/6/Pauls-iPad 1000
+        
+
+        vector<string> path;
+  		explode(m.getAddress(),'/', back_inserter(path));
+
+  		cerr<<"OSC: "<<m.getAddress()<<endl;
+
+  		if (path.size()>1) {
+  			if (path[1]=="mrmr"){
+  				if (path.size()>3){
+  					if (path[2]=="pushbutton"){
+  						int channel=ofToInt(path[3]);
+  						if (channel>12) channel--; //12 is missing
+  						if (m.getArgAsInt32(0)==1000) {
+  							for (int i=0;i<videoclips.size();i++) {
+  								videoclips[i].stop();
+  								videoclips[i].setPosition(0.01f);
+  							}
+  							videoclips[channel].play();
+  						}
+  					}
+  				}
+  			}
+  			else {
+	  			string type=path[1];
+	  			if (type=="narrator"||type=="video") {
+		  			int channel=ofToInt(path[2])-1;
+		  			int data=m.getArgAsInt32(0);
+
+		  			cerr<<"type: "<<type<<" channel: "<<channel<<" data: "<<data<<endl;
+
+		  			if (type=="video"){
+		  				if ((channel > -1)&&videoclips.size()>channel) {
+		  					if (data>0) {
+		  						cerr<<"playing video "<<channel<<endl;
+		  						videoclips[channel].play();
+		  					}
+		  				}
+		  			}
+		  			if (type=="narrator"){
+		  				if ((channel > -1)&&narrator.getNumClips()>channel) {
+		  					if (data>0) { //???doesn't seem to work
+		  						cerr<<"playing narrator "<<channel<<endl;
+		  						narrator.startPlayer(channel);
+		  					}
+		  				}
+		  			}
+		  		}
+	  		}
+  		}
+    }
+
+
+	if (I_movieSource!=I_moviePlaying) {
+	    blendImage.stop();
+        switch(I_movieSource){
+            case 0:
+                blendImage.loadMovie("gradblend.mov");
+                break;
+            case 1:
+                blendImage.loadMovie("gradblend01.mov");
+                break;
+            case 2:
+                blendImage.loadMovie("ll_waltz1.mov");
+                break;
+            case 3:
+                blendImage.loadMovie("ll_longtrains.avi");
+                break;
+
+        }
+        blendImage.play();
+        blendImage.setLoopState(OF_LOOP_NORMAL);
+        I_moviePlaying=I_movieSource;
+	}
+	blendImage.setSpeed(F_movieSpeed);
+    //blendImage.idleMovie();
+
+    for (int i=0;i<videoclips.size();i++) {
+    	videoclips[i].update();
+    	if (videoclips[i].getPosition()>0.99f) videoclips[i].stop();
+    }
+
+    narrator.update();
+
+	xOffs*=.95;
+	yOffs*=.95;
+
+}
+
+//--------------------------------------------------------------
+void testApp::draw(){
+	ofSetVerticalSync(B_vSync);
+
+
+	
+	static int index=0;
+	float lavg_power = 0.0f;
+	float ravg_power = 0.0f;
+
+	if (visMode==FFT_RAW||visMode==FFT_AVG) {
+		myfft.powerSpectrum(0,(int)BUFFER_SIZE/2, left,BUFFER_SIZE,&lmagnitude[0],&lphase[0],&lpower[0],&lavg_power);
+		myfft.powerSpectrum(0,(int)BUFFER_SIZE/2, right,BUFFER_SIZE,&rmagnitude[0],&rphase[0],&rpower[0],&ravg_power);
+	}
+	if (visMode==FFT_AVG) {
+		lFFTanalyzer.calculate(lmagnitude);
+		rFFTanalyzer.calculate(rmagnitude);
+	}
+
+	thisFFTbuffer=(thisFFTbuffer-1);
+	thisFFTbuffer=thisFFTbuffer<0?BUFFER_FRAMES-1:thisFFTbuffer;
+
+	switch(visMode) {
+		case FFT_AVG:
+			for (int i=0;i<rFFTanalyzer.nAverages;i++) {
+				FFTbuffer[0][i][thisFFTbuffer]=lFFTanalyzer.averages[i];
+				FFTbuffer[1][i][thisFFTbuffer]=rFFTanalyzer.averages[i];
+			}
+			break;
+		case FFT_RAW:
+			for (int i=0;i<BUFFER_SIZE;i++) {
+				FFTbuffer[0][i][thisFFTbuffer]=lmagnitude[i]*3;
+				FFTbuffer[1][i][thisFFTbuffer]=rmagnitude[i]*3;
+			}
+			break;
+		case WAVEFORM:
+			for (int i=0;i<BUFFER_SIZE/2;i++) {
+				FFTbuffer[0][i][thisFFTbuffer]=left[i]*100;
+				FFTbuffer[1][i][thisFFTbuffer]=right[i]*100;
+			}
+			break;
+	}
+
+	//ofDisableAlphaBlending();
+
+	renderImage.begin(); //render to FOB
+	glDisable(GL_BLEND);
+
+	float hw=ofGetWidth()/2;
+	float hh=ofGetHeight()/2;
+	float xStep = ((float)ofGetWidth())/(lFFTanalyzer.nAverages*2);
+	float zStep = ((float)ofGetWidth())/F_drawFrames;
+
+	float newTime=ofGetElapsedTimef();
+	float interval=newTime-lastFrameTime;
+	lastFrameTime=newTime;
+
+
+	if (B_glitch) {
+	    //glEnable(GL_BLEND);
+        //glBlendFunc(GL_CONSTANT_COLOR,GL_ONE);
+        //glBlendColor(1.0f,1.0f,1.0f,0.9f);
+        //blanker.draw(0,0,ofGetWidth(),ofGetHeight());
+	}
+	else {
+	    glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
+	}
+
+
+	
+
+	F_xRotation+=(F_xRotate*interval);
+	F_yRotation+=((F_yRotate+xOffs)*interval);
+	F_zRotation+=((F_zRotate+yOffs)*interval);
+	F_drawFrames=max(1.99f,min(F_drawFrames+(F_drawStep*interval),(float)BUFFER_FRAMES));
+
+	ofPushMatrix();
+		//ofTranslate(hw,hh);
+		camera.begin();
+		ofRotateY(F_yRotation);
+		ofRotateX(F_xRotation);
+		ofRotateZ(F_zRotation);
+
+	/*
+		if (inputMode==GRABBER) {
+			ofSetColor(I_fade2,I_fade2,I_fade2);
+			ofPushMatrix();
+				ofRotateX(90);
+				ofRotateZ(-90);
+				outTexture.draw(hw,-hh,-ofGetWidth(),ofGetHeight());
+			ofPopMatrix();
+		}
+	*/
+		GLfloat fogColor[4] = {0,0,0, 1.0};
+		glFogi(GL_FOG_MODE, GL_LINEAR);
+		glFogfv(GL_FOG_COLOR, fogColor);
+		glFogf(GL_FOG_DENSITY,1.0 );
+		glHint(GL_FOG_HINT, GL_DONT_CARE);
+		glFogf(GL_FOG_START, ofGetHeight()*(0.25+F_drawDecay));
+		glFogf(GL_FOG_END, ofGetHeight()*(0.75+F_drawDecay));
+		glEnable(GL_FOG);
+
+		//reverse draw order when looking from back
+		int jStart=0;
+		int jEnd=F_drawFrames-1;
+		int jStep=1;
+		float F_yseg=F_yRotation;
+		while (F_yseg<-90) F_yseg+=360;
+		while (F_yseg>270) F_yseg-=360;
+		if (F_yseg>90) {
+			jStart=jEnd;
+			jEnd=0;
+			jStep=-1;
+			if (draworder) {
+				draworder=false;
+				//printf("switched to reverse order\n");
+			}
+		}
+		else if (!draworder) {
+			draworder=true;
+			//printf("switched to normal order\n");
+		}
+
+		for (int j=jStart;j!=jEnd;j+=jStep) {
+			int fB=(thisFFTbuffer+j)%BUFFER_FRAMES;
+
+			ofPushMatrix(); //coordinate transform for FFT draw direction
+				ofTranslate(0,0,(j*zStep)-hw);
+				ofRotateX(F_drawAxis);
+
+				ofFill();
+				ofSetColor(0,0,0);
+				if (B_fill) {
+		            glBegin(GL_QUAD_STRIP);
+		                for (int i = 0; i < lFFTanalyzer.nAverages-1; i++){
+		                    glVertex3f((i*xStep)-hw,(FFTbuffer[0][i][fB]  * F_scale),0);
+		                    glVertex3f((i*xStep)-hw,0,0);
+		                }
+		                for (int i =lFFTanalyzer.nAverages, k=lFFTanalyzer.nAverages-1; i < lFFTanalyzer.nAverages+rFFTanalyzer.nAverages; i++, k--){
+		                    glVertex3f((i*xStep)-hw,(FFTbuffer[1][(lFFTanalyzer.nAverages+rFFTanalyzer.nAverages)-(i+1)][fB] * F_scale),0);
+		                    glVertex3f((i*xStep)-hw,0,0);
+		                }
+		            glEnd();
+		        }
+
+				ofNoFill();
+				ofSetLineWidth(F_lineWidth);
+				ofSetColor(I_fade1,I_fade1,I_fade1);
+				glBegin(GL_LINE_STRIP);
+				for (int i = 0; i < lFFTanalyzer.nAverages; i++){
+					glVertex3f((i*xStep)-hw,(FFTbuffer[0][i][fB]  * F_scale),0);
+				}
+				for (int i =lFFTanalyzer.nAverages, k=lFFTanalyzer.nAverages-1; i < lFFTanalyzer.nAverages+rFFTanalyzer.nAverages; i++, k--){
+					glVertex3f((i*xStep)-hw,(FFTbuffer[1][(lFFTanalyzer.nAverages+rFFTanalyzer.nAverages)-(i+1)][fB] * F_scale),0);
+				}
+				glEnd();
+			ofPopMatrix();
+		}
+		camera.end();
+
+	ofPopMatrix();
+
+		for (int i=0;i<videoclips.size();i++) {
+			if (videoclips[i].isPlaying()) {
+				if (videoclips[i].getPosition()<0.1f) {
+					glEnable(GL_BLEND);
+					uint8_t b=uint8_t((videoclips[i].getPosition()/0.1f)*255);
+					ofSetColor(255,255,255,b);
+				}
+				else if (videoclips[i].getPosition()>0.8f) {
+					glEnable(GL_BLEND);
+					uint8_t b=uint8_t((1.0f-((videoclips[i].getPosition()-0.8f)/0.2f))*255);
+					ofSetColor(255,255,255,b);
+				}
+				else ofSetColor(255,255,255);
+				videoclips[i].draw(0,0,renderImage.getWidth()/3,renderImage.getHeight());
+				videoclips[i].draw(renderImage.getWidth()*0.666666667,0,renderImage.getWidth()/3,renderImage.getHeight());
+				glDisable(GL_BLEND);
+			} 
+		}
+
+		ofPushMatrix();
+		//ofTranslate(hw,hh);
+		camera.begin();
+		ofRotateY(F_yRotation);
+		ofRotateX(F_xRotation);
+		ofRotateZ(F_zRotation);
+
+		ofPushMatrix();
+	        //ofTranslate(0,-100,-1050);
+			ofScale(sModel,sModel,sModel);
+	        //ofTranslate(xModel*sModel,yModel*sModel,zModel*sModel);
+	        ofTranslate(xModel,yModel,zModel);
+	        
+	        //narrator.drawCloud(2);
+	        narrator.drawPoints(F_particleSize,F_particleAmount,F_particleLife,F_particleX,F_particleY,F_particleZ);
+        ofPopMatrix();
+
+        ofSetColor(255,255,255);
+
+
+        camera.end();
+
+	ofPopMatrix();
+    renderImage.end();
+
+
+
+
+    //ofEndShape(false);
+
+
+    //fbImage.grabScreen(0,0,ofGetWidth(),ofGetHeight());
+/*
+
+
+
+
+	ofSetHexColor(0xaaaaaa);
+    int width=2048/FFTanalyzer.nAverages;
+	for (int i = 0; i < FFTanalyzer.nAverages; i++){
+		ofRect(i*width,768,width,-FFTanalyzer.averages[i] * 20);
+	}
+	ofSetHexColor(0xffffff);
+	for (int i = 0; i < (int)(BUFFER_SIZE/2 - 1); i++){
+		ofRect(i,768-freq[i]*10.0f,1,1);
+	}
+
+	ofSetHexColor(0xff0000);
+	for (int i = 0; i < FFTanalyzer.nAverages; i++){
+		ofRect(i*width,768-FFTanalyzer.peaks[i] * 20,width,-1);
+	}
+
+	float avgStep = 1024/FFTanalyzer.nAverages;
+
+
+	ofNoFill();
+    ofSetLineWidth(1);
+
+	ofSetColor(223, 218, 218);
+	ofDrawBitmapString("FFT average", 4, 18);
+    ofBeginShape();
+    for (int i = 0; i < FFTanalyzer.nAverages; i++){
+        ofVertex(i*avgStep, 284 -FFTanalyzer.averages[i] * 20);
+    }
+    ofEndShape(false);
+
+
+    ofSetColor(97,181,243);
+    ofDrawBitmapString("FFT magnitude", 4, 38);
+    ofBeginShape();
+    for (int i = 0; i < BUFFER_SIZE; i++){
+        ofVertex(i*avgStep, 384 -magnitude[i] * 20);
+    }
+    ofEndShape(false);
+
+
+    ofSetColor(97,243,174);
+    ofDrawBitmapString("FFT phase", 4, 58);
+    ofBeginShape();
+    for (int i = 0; i < BUFFER_SIZE; i++){
+        ofVertex(i*avgStep, 484 -phase[i] * 20);
+    }
+    ofEndShape(false);
+
+    ofSetColor(243,174,94);
+    ofDrawBitmapString("FFT power", 4, 78);
+    ofBeginShape();
+    for (int i = 0; i < BUFFER_SIZE; i++){
+        ofVertex(i*avgStep, 584 -power[i] * 20);
+    }
+    ofEndShape(false);
+
+
+		 //float * averages; // the actual averages
+		 //float * peaks; // peaks of the averages, aka "maxAverages" in other implementations
+
+*/
+
+
+
+	ofEnableAlphaBlending();
+
+    maskShader.begin();
+
+    glActiveTexture(GL_TEXTURE0_ARB);
+	blendImage.getTextureReference().bind();
+	glActiveTexture(GL_TEXTURE1_ARB);
+	renderImage.getTextureReference().bind();
+
+	glBegin(GL_QUADS);
+
+	glMultiTexCoord2d(GL_TEXTURE0_ARB, 0, 0);
+	glMultiTexCoord2d(GL_TEXTURE1_ARB, 0, 0);
+	glVertex2f( 0, 0);
+
+	glMultiTexCoord2d(GL_TEXTURE0_ARB, blendImage.getWidth(), 0);
+	glMultiTexCoord2d(GL_TEXTURE1_ARB, renderImage.getWidth(), 0);
+	glVertex2f( ofGetWidth(), 0);
+
+	glMultiTexCoord2d(GL_TEXTURE0_ARB, blendImage.getWidth(), blendImage.getHeight());
+	glMultiTexCoord2d(GL_TEXTURE1_ARB, renderImage.getWidth(), renderImage.getHeight() );
+	glVertex2f( ofGetWidth(), ofGetHeight());
+
+	glMultiTexCoord2d(GL_TEXTURE0_ARB, 0, blendImage.getHeight());
+	glMultiTexCoord2d(GL_TEXTURE1_ARB, 0, renderImage.getHeight() );
+	glVertex2f( 0, ofGetHeight() );
+
+	glEnd();
+
+	glActiveTexture(GL_TEXTURE1_ARB);
+	renderImage.getTextureReference().unbind();
+
+	glActiveTexture(GL_TEXTURE0_ARB);
+	blendImage.getTextureReference().unbind();
+
+	maskShader.end();
+/*
+    glPushMatrix();
+    glTranslatef(ofGetWidth()*0.5,ofGetHeight()*0.5,0);
+    glRotatef((float)ofGetFrameNum(),0,1.0,0);
+    renderImage.draw(ofGetWidth()*-0.5,ofGetHeight()*-0.5);
+    glPopMatrix();
+    */
+
+
+
+    if (showFPS) {
+    	string msg=ofToString(ofGetFrameRate(), 2);
+    	msg+="\n"+ofToString(F_xRotation, 4)+" "+ofToString(F_yRotation, 4)+" "+ofToString(F_zRotation, 4);
+    	msg+="\n"+ofToString(F_yseg, 4);
+    	msg+="\n"+ofToString(narrator.getNumParticles())+" size "+ofToString(F_lineWidth);
+    	msg+="\n"+ofToString(xModel)+","+ofToString(yModel)+","+ofToString(zModel)+" * "+ofToString(sModel);
+    	syncOniPlayer *player=narrator.getCurrentPlayer();
+    	if (player) {
+    		msg+="\n"+ofToString(player->getCurrentFrame())+","+ofToString(player->getPosition(),2);
+    		msg+=player->getCurrentFile();
+    	}
+	    ofDrawBitmapString(msg,20,20);
+    }
+}
+
+
+//--------------------------------------------------------------
+void testApp::keyPressed  (int key){
+    if(key == 'f'){
+        showFPS=!showFPS;
+    }
+    if(key == ' '){
+    	fullScreen=!fullScreen;
+        ofSetFullscreen(fullScreen);
+    }
+    if(key == '/'){
+        narrator.startPlayer(23);
+    }
+    if(key == ','){
+        narrator.previous();
+    }
+    if(key == '.'){
+        narrator.next();
+    }
+    if(key>='1'&key<='9'){
+    	int clip=key-'1';
+    	cerr<<"playing video clip "<<clip<<endl;
+    	if (videoclips.size()>clip) videoclips[clip].play();
+    }
+    if(key == 't'){
+        for (int i=0;i<videoclips.size();i++) {
+			if (videoclips[i].isPlaying()) {
+				cerr<<"videoclip "<<i<<" is playing"<<endl;
+			}
+		}
+    }
+    if(key == 'r'){
+        yModel+=25;
+    }
+    if(key == 'v'){
+        yModel-=25;
+    }
+    if(key == 'd'){
+        xModel+=25;
+    }
+    if(key == 'g'){
+        xModel-=25;
+    }
+    if(key == 't'){
+        zModel+=25;
+    }
+    if(key == 'c'){
+        zModel-=25;
+    }
+    if(key == 'w'){
+        sModel*=1.02;
+    }
+    if(key == 's'){
+        sModel/=1.02;
+    }
+    if(key == 'q'){
+        I_fade1=min(I_fade1+1,255);
+    }
+    if(key == 'a'){
+        I_fade1=max(I_fade1-1,0);
+    }
+    if(key == 'h'){
+        F_particleX-=1;
+    }
+    if(key == 'k'){
+        
+        F_particleX+=1;
+    }
+    if(key == 'm'){
+        F_particleY-=1;
+    }
+    if(key == 'u'){
+        
+        F_particleY+=1;
+    }
+    if(key == 'i'){
+        F_particleZ+=1;
+    }
+    if(key == 'n'){
+        
+        F_particleZ-=1;
+    }
+
+}
+
+//--------------------------------------------------------------
+void testApp::mouseMoved(int x, int y ){
+
+}
+
+//--------------------------------------------------------------
+void testApp::mouseDragged(int x, int y, int button){
+	xOffs=x-startX;
+	yOffs=y-startY;
+}
+
+//--------------------------------------------------------------
+void testApp::mousePressed(int x, int y, int button){
+	startX=x;
+	startY=y;
+}
+
+//--------------------------------------------------------------
+void testApp::mouseReleased(){
+}
+
+
+//--------------------------------------------------------------
+void testApp::audioIn(float * input, int bufferSize, int nChannels){
+    /*if (sampnum<10) {
+        printf("size %i, channels %i\n",bufferSize,nChannels);
+        sampnum++;
+    }
+    */
+	// samples are "interleaved"
+	//if (nChannels==2) {
+        for (int i = 0; i < bufferSize; i++){
+            left[i] = input[i*2];
+            right[i] = input[i*2+1];
+        }
+	//}
+
+}
+
+void testApp::newMidiMessage(ofxMidiEventArgs& eventArgs){
+
+    //newMessage(eventArgs.port, eventArgs.channel, eventArgs.byteTwo, eventArgs.timestamp);
+
+//byteOne : message type
+
+    /*
+    int 	port;
+	int		channel;
+	int 	status;
+	int 	byteOne;
+	int 	byteTwo;
+	double 	timestamp;
+	*/
+
+    //printf("%d %d %d %d %d\n",eventArgs.port,eventArgs.channel,eventArgs.status,eventArgs.byteOne,eventArgs.byteTwo);
+
+    bool noteOn; //this old thing!
+
+        switch(eventArgs.status) {
+            case 144: //noteon-off
+
+                break;
+            case 176: //control change 1-8 x 4 banks
+                switch(eventArgs.byteOne) {
+                    case 1:
+                        F_scale = ((float)eventArgs.byteTwo)*.25;
+                        break;
+                    case 2:
+			F_particleSize=(float)eventArgs.byteTwo*0.25;
+                        break;
+                    case 3:
+			F_drawAxis=((float) eventArgs.byteTwo-64)*(360.0/127);
+                        break;
+                    case 4:
+            F_particleAmount=((float) eventArgs.byteTwo)*(10000.0f/127.0f);
+                        break;
+                    case 5:
+            F_particleLife=((float) eventArgs.byteTwo)*(3.0f/127.0f);
+                        break;
+                    case 6:
+            F_particleX=(((float) eventArgs.byteTwo)-64)*10.0f;
+                        break;
+                    case 7:
+            F_particleY=(((float) eventArgs.byteTwo)-64)*10.0f;
+                        break;
+                    case 8:
+            F_particleZ=(((float) eventArgs.byteTwo)-64)*10.0f;
+                        break;
+
+                        //65-80 buttons
+
+			//radio button set
+                    case 65:
+                        if (eventArgs.byteTwo==127) {
+                            visMode=FFT_AVG;
+                            midiOut.sendControlChange(1, 66, 0);
+                            midiOut.sendControlChange(1, 67, 0);
+                        }
+                        else midiOut.sendControlChange(1, 65, 127);
+                        break;
+                    case 66:
+                        if (eventArgs.byteTwo==127) {
+                            visMode=FFT_RAW;
+                            midiOut.sendControlChange(1, 65, 0);
+                            midiOut.sendControlChange(1, 67, 0);
+                        }
+                        else midiOut.sendControlChange(1, 66, 127);
+                        break;
+                    case 67:
+                        if (eventArgs.byteTwo==127) {
+                            visMode=WAVEFORM;
+                            midiOut.sendControlChange(1, 65, 0);
+                            midiOut.sendControlChange(1, 66, 0);
+                        }
+                        else midiOut.sendControlChange(1, 67, 127);
+                        break;
+
+			//radio button set
+		     case 68:
+                        if (eventArgs.byteTwo==127) {
+                            inputMode=PICTURE;
+                            midiOut.sendControlChange(1, 69, 0);
+
+                        }
+                        else midiOut.sendControlChange(1, 68, 127);
+                        break;
+		     case 69:
+                        if (eventArgs.byteTwo==127) {
+                            inputMode=GRABBER;
+                            midiOut.sendControlChange(1, 68, 0);
+
+                        }
+                        else midiOut.sendControlChange(1, 69, 127);
+                        break;
+            case 70:
+                        B_glitch=(eventArgs.byteTwo==127);
+                        break;
+            case 71:
+                        B_fill=(eventArgs.byteTwo==127);
+                        break;
+		    case 72:
+                        B_vSync=(eventArgs.byteTwo==127);
+                        break;
+
+			//buttons to zero rotations
+		    case 73:
+			    	F_xRotate=0;
+				midiOut.sendControlChange(1, 73, 0);
+				midiOut.sendControlChange(1, 81, 64);
+			    break;
+		     case 74:
+			    	F_yRotate=0;
+				midiOut.sendControlChange(1, 74, 0);
+				midiOut.sendControlChange(1, 82, 64);
+			    break;
+		      case 75:
+			    	F_zRotate=0;
+				midiOut.sendControlChange(1, 75, 0);
+				midiOut.sendControlChange(1, 83, 64);
+			    break;
+		       case 76:
+			    	F_drawStep=0;
+				midiOut.sendControlChange(1, 76, 0);
+				midiOut.sendControlChange(1, 84, 64);
+			    break;
+                case 77:
+                    if (eventArgs.byteTwo==127) {
+                            I_movieSource=0;
+                            midiOut.sendControlChange(1, 78, 0);
+                            midiOut.sendControlChange(1, 79, 0);
+                            midiOut.sendControlChange(1, 80, 0);
+
+                        }
+                        else midiOut.sendControlChange(1, 77, 127);
+                    break;
+              case 78:
+                    if (eventArgs.byteTwo==127) {
+                            I_movieSource=1;
+                            midiOut.sendControlChange(1, 77, 0);
+                            midiOut.sendControlChange(1, 79, 0);
+                            midiOut.sendControlChange(1, 80, 0);
+                        }
+                        else midiOut.sendControlChange(1, 78, 127);
+                    break;
+              case 79:
+                    if (eventArgs.byteTwo==127) {
+                            I_movieSource=2;
+                            midiOut.sendControlChange(1, 77, 0);
+                            midiOut.sendControlChange(1, 78, 0);
+                            midiOut.sendControlChange(1, 80, 0);
+                        }
+                        else midiOut.sendControlChange(1, 79, 127);
+                    break;
+              case 80:
+                    if (eventArgs.byteTwo==127) {
+                            I_movieSource=3;
+                            midiOut.sendControlChange(1, 77, 0);
+                            midiOut.sendControlChange(1, 78, 0);
+                            midiOut.sendControlChange(1, 79, 0);
+                        }
+                        else midiOut.sendControlChange(1, 80, 127);
+                    break;
+
+		    // probably make controls logarithmic
+                     case 81:
+                        F_xRotate=(((float) eventArgs.byteTwo)-64)*.1;
+                        break;
+                     case 82:
+                        F_yRotate=(((float) eventArgs.byteTwo)-64)*.1;
+                        break;
+                     case 83:
+                        F_zRotate=(((float) eventArgs.byteTwo)-64)*.1;
+                        break;
+                     case 84:
+			F_drawStep=(((float) eventArgs.byteTwo)-64)*.1;
+                        break;
+                     case 85:
+            //F_movieSpeed=((float)eventArgs.byteTwo)/64.0;
+                     F_lineWidth=((float)eventArgs.byteTwo)/8.0;
+                        break;
+                     case 86:
+			F_drawDecay=((float)eventArgs.byteTwo)/127.0;
+                        break;
+                    case 87:
+			I_fade2=((float)eventArgs.byteTwo)*2;
+                        break;
+                    case 88:
+			I_fade1=((float)eventArgs.byteTwo)*2;
+			//printf("fog- %f\n", F_drawDecay);
+                        break;
+
+                    case 91: //top
+                        F_xRotation=90;
+                        F_yRotation=90;
+                        F_zRotation=0;
+                        midiOut.sendControlChange(1, 91, 0);
+                        break;
+                    case 92: //front
+                        F_xRotation=0;
+                        F_yRotation=180;
+                        F_zRotation=0;
+                        midiOut.sendControlChange(1, 92, 0);
+                        break;
+
+                        //89-92 bottom 4
+
+                }
+		//printf("rotation- %f %f %f\n",F_xRotate,F_yRotate,F_zRotate);
+		//printf(inputMode==PICTURE?"PICTURE mode\n":"GRABBER mode\n");
+        }
+}
+void testApp::setMidiState(){
+	int knobs[32];
+	int buttons[16];
+	int faders[8];
+	for (int i=0;i<32;i++) knobs[i]=0;
+	for (int i=0;i<16;i++) buttons[i]=0;
+	for (int i=0;i<8;i++) faders[i]=0;
+
+	knobs[0] = (F_scale * 5);
+	knobs[1]=(F_particleSize*4);
+	knobs[2]=(F_drawAxis/(360.0/127))+64;
+
+	knobs[3]=F_particleAmount/(10000.0f/127);
+    knobs[4]=F_particleLife/(3.0f/127);
+    knobs[5]=(F_particleX*.1)+64;
+    knobs[6]=(F_particleY*.1)+64;
+    knobs[7]=(F_particleZ*.1)+64;
+
+
+	//radio button set
+	buttons[0]=(visMode==FFT_AVG?127:0);
+	buttons[1]=(visMode==FFT_RAW?127:0);
+	buttons[2]=(visMode==WAVEFORM?127:0);
+
+	//radio button set
+	buttons[3]=(inputMode==PICTURE?127:0);
+	buttons[4]=(inputMode==GRABBER?127:0);
+    buttons[5]=B_glitch?127:0;
+    buttons[6]=B_fill?127:0;
+	buttons[7]=B_vSync?127:0;
+
+	buttons[12]=I_movieSource==0?127:0;
+	buttons[13]=I_movieSource==1?127:0;
+	buttons[14]=I_movieSource==2?127:0;
+	buttons[15]=I_movieSource==3?127:0;
+
+	faders[0]=(F_xRotate*10)+64;
+	faders[1]=(F_yRotate*10)+64;
+	faders[2]=(F_zRotate*10)+64;
+	faders[3]=(F_drawStep*10)+64;
+    faders[4]=F_lineWidth*8;
+
+	faders[5]=(F_drawDecay*127);
+
+	faders[6]=I_fade1/2;
+	faders[7]=I_fade1/2;
+
+	for (int i=0;i<32;i++) midiOut.sendControlChange(1, i+1, knobs[i]);
+	for (int i=0;i<16;i++) midiOut.sendControlChange(1, i+65, buttons[i]);
+	for (int i=0;i<8;i++) midiOut.sendControlChange(1, i+81, faders[i]);
+}
+
+/*
+void            sendNoteOn(int channel, int id, int value);
+void            sendNoteOff(int channel, int id, int value);
+void            sendControlChange(int channel, int id, int value);
+*/
+
+