annotate nodescore.js @ 31:e4d2a8eb1450

widescreen style aspect ratio
 for music
still sttuggling with memory leak releated to stop  in transport controls

/*
////////////////////////////////////////////

nodescore server
nodescore.kiben.net
[e-mail]

////////////////////////////////////////////
*/

var sio = require('socket.io')
, http = require('http')
, fs = require('fs')
,  $ = require('jQuery')
, static = require('node-static');

var bla
var pinging=0
    console.log("ping set to 0")

// run webserver serving static html
////////////////////////////////////////////

var clientFiles = new static.Server('./www');
var httpServer = http.createServer(function(request, response) {
    request.addListener('end', function () {
	clientFiles.serve(request, response);	    
	process.setMaxListeners(0);
    });    
});
httpServer.listen(8889);

////////////////////////////////////////////
// connect to websockets 
////////////////////////////////////////////

var io = sio.listen(httpServer)
, nicknames = {};

io.set('log level', 1); // reduce loggingi
io.sockets.on('connection', function (socket) {

    ////////////////////////////////////////////
    // metronome
    ////////////////////////////////////////////
    socket.on('metroStop', stopMetro)
    function stopMetro () {
	metroState=0;
    };
    

    ////////////////////////////////////////////
    // Chronometer
    ////////////////////////////////////////////

    // number padding: 0 to 00

    function pad(number) { return (number < 10 ? '0' : '') + number }
    
    // the chronometer initial states
    var chronstate = 0; var zecsec = 0; var seconds = -20; 
    var mins = 0; var hours = 0;
 
    function startChr() { if (chronstate !== 1) {
	chronstate = 1; chronometer();} 
			}      // if not already started start the chronometer    
    function stopChr() {  chronstate = 0; }  // stop the chronometer
    function resetChr() {  console.log("reset");
			   clearInterval();
			   chronstate = 0;
			   zecsec = 0; seconds = 0; 
			    mins = 0; hours = 0; 
			    chronstate = 0; 
			   var chron = pad(hours) +":"+pad(mins)+ ':'+ pad(seconds)+ ":"+ zecsec
			   socket.broadcast.emit('chronFromServer', chron)
			   socket.emit('chronFromServer', chron)
			}
    
    var ding
    function dateTime() { 

	ding = setInterval( function () {
	    var datetime= new Date(); 
	    var now=datetime.toString()
//	    console.log(now);
	    socket.broadcast.emit("dateTime", now);
// 	    socket.emit("dateTime", now);
	}, 1000)}
   
    clearInterval(ding);
    dateTime()

    
    function chronometer() {
	
	if (chronstate==1){
	zecsec += 1;       // set tenths of a second
	if(zecsec > 9) { zecsec = 0; seconds += 1;}
	if(seconds > 59) { seconds = 0;mins += 1;}
	if(mins > 59) { mins = 0; hours += 1; }
	var chron = pad(hours) +":"+pad(mins)+ ':'+ pad(seconds)+ ":"+ zecsec
	setTimeout(function(){chronometer()}, 100);
	socket.broadcast.emit('chronFromServer', chron)
	socket.emit('chronFromServer', chron)
	}
    }
    
    socket.on('startChr', function () { startChr();});
    socket.on('stopChr', function () { stopChr();} );
    socket.on('resetChr', function () { resetChr();});




    ////////////////////////////////////////////
    // magic square sequencer
    ////////////////////////////////////////////

    var sequencerState = 0;
    var timemultiplier=1000
    var srcsqr = []

    srcsqr[0] = [22,21,24,25,06,07];
    srcsqr[1] = [20,23,27,26,05,04];
    srcsqr[2] = [03,00,17,16,35,34];
    srcsqr[3] = [01,02,19,18,33,32];

    var seqA = { metrobeat:0, voice:1, name: "A", counter: 0, mm: 60, beatsinbar: 4, durations: srcsqr[0], units: [1,2,3,1,2,4]};
    var seqB = { metrobeat:0, voice:2, name: "B", counter: 0, mm: 60, beatsinbar: 4, durations: srcsqr[1], units: [3,2,1,1,2,3]};
    var seqC = { metrobeat:0, voice:3, name: "C", counter: 0, mm: 60, beatsinbar: 4, durations: srcsqr[2], units: [4,5,6,5,4,2]};
    var seqD = { metrobeat:0, voice:4, name: "D", counter: 0, mm: 60, beatsinbar: 4, durations: srcsqr[3], units: [2,3,4,2,3,1]};
    

    var countdowntick = function(seq){

	var outcount = 12; var incount=12;
	var time = ((seq.durations[seq.counter]+1) *timemultiplier) + 30000 + (outcount*1000);
	var ztime = time; var totaltime = time/1000
	var unit = seq.units[seq.counter];
	var tempoms = 60000/seq.mm
	
	// initiate first page here
	socket.broadcast.emit("pageFlipfromserver", seq.voice, unit, time, seq.mm,seq.counter);
	
	var tock = setInterval(function(){



	    if (ztime >= 0 ){
		
		// basic unit is still the second/1000ms - change this to tempoms? no i dont think so
		// count in and count out
		////////////////////////////////////////////
		
		var counter = ztime/1000
		socket.emit('counterText', seq.voice, seq.counter, counter);

		if (counter > 0 && counter <= outcount ) {              
		    socket.broadcast.emit('countinFromServer', seq.voice, counter, "","", "white", "transparent");
		}
		
		// remove displayed number with " " at end of both countin/out
		
		if (counter == 0 ) {

		    socket.broadcast.emit('countinFromServer', seq.voice, " ", "","", "white","transparent");
		}
		
		if (counter > (totaltime)-incount  && counter <= totaltime ) {              
		    socket.broadcast.emit('countinFromServer', seq.voice, counter-(totaltime-incount), "","", "red","gray");	    
		}
		
		if (counter == (totaltime)-incount ) {
		    socket.broadcast.emit('countinFromServer', seq.voice, " ", "","", "red","gray");
		}
	    	
		// push out the pulse to metronome	

		seq.metrobeat = (seq.metrobeat+1)%seq.beatsinbar ;
     		socket.broadcast.emit('metroPulse', tempoms, seq.voice,seq.metrobeat); 
		socket.emit('metroPulse', tempoms, seq.voice,seq.metrobeat);	
//	    	socket.broadcast.emit("pageFlipfromserver", seq.voice, unit, time, seq.mm,seq.counter);
	    }
	    
	    // flip the page

	    if (ztime == 0){
		socket.emit('counterText', seq.voice, seq.counter, " ");
		seq.counter = (seq.counter + 1) % seq.durations.length	    		
		socket.broadcast.emit("pageFlipfromserver", seq.voice, unit, time, seq.mm,seq.counter);
// 		socket.emit("pageFlipfromserver", seq.voice, unit, time, seq.mm,seq.counter);		
		delete tock;	
		step(seq);     
	    }

	    if (ztime < 0){}	    	    	    
	    // decrement the time 
	    ztime -= 1000
				
	}, tempoms)
		
	  };

//	    socket.on('stopSeq', function () {
//		console.log("sequencer stopping...")	    
//		clearInterval(tock)
//		sequencerState=0;  
//		stopChr();    
		//		var tock = function(){null}
	    
//	    });

    socket.on('startSeq', function () { 
	if (sequencerState == 0) { 
	    console.log("sequencer starting...")	    
	    sequencerState=1;
	    startChr();
	    step(seqA); step(seqB); step(seqC); step(seqD);	    
	    ztime =-1;
	}
	else console.log("sequencer already started...")
    });




    
    socket.on('resetSeq', function () { 
	console.log("reset")
	resetChr();		
    });


    
    step = function (seq) {
	clearInterval(countdowntick);
	countdowntick(seq)
    };    


    ////////////////////////////////////////////  
    // some latency calculations
    ///////////////////////////////////////////

    /*
      a ping is periodically broadcast to all connected clients each
      connected returns a pong to the server via an "emit" and in turn
      the server returns each unique client a report of the latency
      via another emit - the emit only sends to the source of the
      request, whereas the broadcast.emit..  broadcasts.. ie to all
      connected clients

      TODO: smooth range and average out results to remove erratic ping
      times.

      TODO:
      The result then needs to be used to stagger outgoing messages to
      compensate for latency - how much compensation is more connected
      to the time that any audio/video feed needs to encode/decode as
      the latency of the route from node A to node B is inavoidable?!
      so maybe latency is irrelevant in this context - we just need to
      stagger signals according to encoding decoding times.. hmmm
    */
    


// periodically broadcast  a ping
  
    function serverTime(freq) {

	if (pinging==0){
	st = setInterval(function() {
	    var pinging=1;
	    var d = new Date(); var n = d.getTime(); 
	    socket.emit("timeFromServer", n); 
	    //socket.broadcast.emit("timeFromServer", n); 	    
	}, 1000);   }
	else console.log("already pinging")
    }

    // recieve the pong calculate the latency and
    // return the response to the client

    socket.on("clientTimeResponse", function(x) {
	var d = new Date(); var n = d.getTime();
	var latency = (n-x)/2;
	//console.log("SERVERTIME:"+x + " LATENCY:" + latency);
	socket.emit("latencyFromServer", latency);

    });	      

    // this is the trigger from the control client to start the process
    // maybe remove this and have latency connections constantly running
    /*
    socket.on("getLatencies", function(x){
	serverTime(x);
    });
    */

    serverTime(1000);

    socket.on('disconnect', function(client) {
	console.log(client + " is gone..." )
	clearInterval(st);
    });
    
});