From fc1a0d8a61252b390e585480cbd44f648d19a42d Mon Sep 17 00:00:00 2001
From: kpl <kpl@larke.org>
Date: Sun, 24 Nov 2019 20:07:47 -0500
Subject: [PATCH] Added calibrate.py, plot_calibrate.py and made associated
 changes. Added plot_calibrate.ipynb jupyter notebook.

---
 MidiDevice.py         | 222 ++++++++++++++++++++++
 calibrate.py          | 427 ++++++++++++++++++++++++++++++++++++++++++
 p_ac.py               |  73 ++++++--
 p_ac.yml              | 127 ++++++++++++-
 plot_calibrate.ipynb  |  72 +++++++
 plot_calibrate.py     | 150 +++++++++++++++
 plot_note_analysis.py |  36 +++-
 rms_analysis.py       | 110 ++++++++++-
 8 files changed, 1190 insertions(+), 27 deletions(-)
 create mode 100644 MidiDevice.py
 create mode 100644 calibrate.py
 create mode 100644 plot_calibrate.ipynb
 create mode 100644 plot_calibrate.py

diff --git a/MidiDevice.py b/MidiDevice.py
new file mode 100644
index 0000000..9192fee
--- /dev/null
+++ b/MidiDevice.py
@@ -0,0 +1,222 @@
+import rtmidi
+import rtmidi.midiutil
+
+from result import Result
+
+class MidiDevice(object):
+    def __init__(self, **kwargs ):
+        self.mip          = None
+        self.mop          = None
+        self.inMonitorFl  = False
+        self.outMonitorFl = False
+        self.throughFl    = False
+        self.inPortLabel  = None
+        self.outPortLabel = None
+        self.setup(**kwargs)
+
+    def setup( self, **kwargs  ):
+
+        res = Result()
+
+        if kwargs is None:
+            return res
+
+        if 'inPortLabel' in kwargs:
+            res += self.select_port( True, kwargs['inPortLabel'] )
+            
+        if 'outPortLabel' in kwargs:
+            res += self.select_port( False, kwargs['outPortLabel'] )
+
+        if 'inMonitorFl' in kwargs:
+            self.enable_monitor( True, kwargs['inMonitorFl'] )
+
+        if 'outMonitorFl' in kwargs:
+            self.enable_monitor( True, kwargs['outMonitorFl'] )
+
+        if 'throughFl' in kwargs:
+            self.enable_through( kwargs['throughFl'] )
+
+        return res
+
+    def _clean_port_label( self, portLabel ):
+        return ' '.join(portLabel.split(' ')[:-1])
+        
+    def _get_port_list( self, inDirFl ):
+        dev   =  rtmidi.MidiIn() if inDirFl else rtmidi.MidiOut()
+
+        # get port list and drop the numeric id at the end of the port label
+        return [ self._clean_port_label(p)  for p in dev.get_ports() ]
+
+        
+        
+    def get_port_list( self, inDirFl ):
+        return { 'type':'midi',
+                 'dir': 'in' if inDirFl else 'out',
+                 'op':  'list',
+                 'listL': self._get_port_list( inDirFl )              
+        }
+
+    def get_in_port_list( self ):
+        return self.get_port_list( True )
+
+    def get_out_port_list( self ):
+        return self.get_port_list( False )
+    
+    def select_port( self, inDirFl, portLabel ):
+        res = Result()
+        
+        if portLabel:
+
+            dirLabel = "input" if inDirFl else "output"
+
+            portL = self._get_port_list( inDirFl )
+
+            if portLabel not in portL:
+                res.set_error("The port '%s' is not an available %s port." % (portLabel,dirLabel))
+            else:
+                port_idx = portL.index(portLabel)  # TODO error check
+
+                if inDirFl:
+                    self.mip,self.inPortLabel = rtmidi.midiutil.open_midiinput(port=port_idx)
+                    self.inPortLabel = self._clean_port_label(self.inPortLabel)
+                else:
+                    self.mop,self.outPortLabel = rtmidi.midiutil.open_midioutput(port=port_idx)
+                    self.outPortLabel = self._clean_port_label(self.outPortLabel)
+
+        return res
+
+    def select_in_port( self, portLabel ):
+        return self.select_port( True, portLabel )
+
+    def select_out_port( self, portLabel ):
+        return self.select_port( False, portLabel )
+    
+    def enable_through( self, throughFl ):
+        self.throughFl = throughFl
+
+    def enable_monitor( self, inDirFl, monitorFl ):
+        if inDirFl:
+            self.inMonitorFl = monitorFl
+        else:
+            self.outMonitorFl = monitorFl
+
+    def enable_in_monitor( self, monitorFl):
+        self.enable_monitor( True, monitorFl )
+        
+    def enable_out_monitor( self, monitorFl):
+        self.enable_monitor( False, monitorFl )
+
+    def port_name( self, inDirFl ):
+        return inPortLabel if inDirFl else outPortLabel
+
+    def in_port_name( self ):
+        return self.port_name(True)
+
+    def out_port_name( self ):
+        return self.port_name(False)
+
+    def _midi_data_to_text_msg( self, inFl, midi_data ):
+
+        text = ""
+        if len(midi_data) > 0:
+            text += "{:02x}".format(midi_data[0])
+            
+        if len(midi_data) > 1:
+            text += " {:3d}".format(midi_data[1])
+
+        if len(midi_data) > 2:
+            text += " {:3d}".format(midi_data[2])
+
+        text = ("in:  " if inFl else "out: ") + text
+        return { 'type':'midi', 'dir':inFl, 'op':'monitor', 'value':text }
+    
+    def get_input( self ):
+        o_msgL = []
+        
+        if self.mip is not None:
+            midi_msg = self.mip.get_message()
+            if midi_msg and midi_msg[0]:
+                
+                if self.monitorInFl:
+                    o_msgL.append( self._midi_data_to_text_msg(True,midi_msg[0]) )
+                    
+                if self.throughFl and self.mop is not None:
+                    self.mop.send_message(midi_msg[0])
+                                   
+                    
+                o_msgL.append( { 'type':'midi', 'op':'data', 'dir':'in', 'value':midi_msg[0] } )
+                    
+        return o_msgL
+        
+
+    def send_output( self, m ):
+        o_msgL = []
+        
+        if self.mop is not None:
+            self.mop.send_message(m)
+                                   
+        if self.outMonitorFl:
+            o_msgL += [self._midi_data_to_text_msg( False, m )]
+                                   
+        return o_msgL                           
+
+    def send_note_on( self, pitch, vel, ch=0 ):
+        return self.send_output( [ 0x90+ch, pitch, vel ] )
+
+    def send_note_off( self, pitch, ch=0 ):
+        return self.send_note_on( 0, ch )
+
+    def send_pgm_change( self, pgm, ch=0 ):
+        return self.send_output( [ 0xc0+ch, pgm ] )
+
+    def send_pbend( self, val, ch=0 ):
+        assert( val < 8192 )
+
+        ival = int(val)
+
+        lsb = ival & 0x7f
+        msb = (ival >> 7) & 0x7f
+
+        return self.send_output( [ 0xe0+ch, lsb, msb ] )
+        
+
+    def send_controller( self, num, value, ch=0 ):
+        return self.send_output( [0xb0+ch, num, value ] )
+
+    def send_all_notes_off(self, ch=0 ):
+        return self.send_controller( 123, 1, ch=ch )
+
+    def get_state( self ):
+        return  {
+            "inMonitorFl":self.inMonitorFl,
+            "outMonitorFl":self.outMonitorFl,
+            "throughFl":self.throughFl,
+            "inPortLabel":self.inPortLabel,
+            "outPortLabel":self.outPortLabel,
+            "inPortL":self.get_in_port_list(),
+            "outPortL":self.get_out_port_list()
+        }
+        
+        
+    def on_command( self, m, ms ):
+        errL = []
+        
+        if m.type == 'midi':
+            if m.op == 'sel':
+                errL.append(self.select_port( m.dir=='in', m.value ))
+                
+            elif m.op == 'through':
+                self.enable_through( m.value )
+                
+            elif m.op == 'monitor':
+                self.enable_monitor( m.dir=='in', m.value )
+
+        return errL
+
+if __name__ == "__main__":
+
+    md = MidiDevice()
+
+    print(md.get_port_list( True ))
+    print(md.get_port_list( False ))
+    
diff --git a/calibrate.py b/calibrate.py
new file mode 100644
index 0000000..e0193ef
--- /dev/null
+++ b/calibrate.py
@@ -0,0 +1,427 @@
+import os,types,wave,json,array
+import numpy as np
+from rms_analysis import rms_analyze_one_note
+
+class Calibrate:
+    def __init__( self, cfg, audio, midi, api ):
+        self.cfg   = types.SimpleNamespace(**cfg)
+        self.audio = audio
+        self.midi  = midi
+        self.api   = api
+        self.state = "stopped"  # stopped | started | note_on | note_off | analyzing
+        self.playOnlyFl = False
+        self.startMs = None
+        self.nextStateChangeMs = None
+        self.curHoldDutyCyclePctD = None  # { pitch:dutyPct}
+        self.noteAnnotationL = []  # (noteOnMs,noteOffMs,pitch,pulseUs)
+
+        self.measD = None   # { midi_pitch: [ {pulseUs, db, durMs, targetDb } ] }
+
+        self.curNoteStartMs = None
+        self.curPitchIdx = None
+        self.curTargetDbIdx = None
+        self.successN = None
+        self.failN    = None
+
+        self.curTargetDb = None
+        self.curPulseUs = None
+        self.curMatchN = None
+        self.curAttemptN = None
+        self.lastAudiblePulseUs = None
+        self.maxTooShortPulseUs = None
+        self.pulseDbL = None
+        self.deltaUpMult = None
+        self.deltaDnMult = None
+        self.skipMeasFl  = None
+        
+    def start(self,ms):
+        self.stop(ms)
+        self.state             = 'started'
+        self.playOnlyFl        = False
+        self.nextStateChangeMs = ms + 500
+        
+        self.startMs           = ms
+
+        self.curPitchIdx    = 0
+        self.curPulseUs     = self.cfg.initPulseUs
+        self.lastAudiblePulseUs = None
+        self.maxTooShortPulseUs = None
+        self.pulseDbL = []
+        self.deltaUpMult = 1
+        self.deltaDnMult = 1
+        self.curTargetDbIdx = -1       
+        self._start_new_db_target()
+        
+        self.curDutyPctD = {}
+        self.skipMeasFl = False
+        self.measD = {}
+        
+        self.successN = 0
+        self.failN = 0
+        self.audio.record_enable(True)
+
+    def stop(self,ms):
+
+        if self.midi is not None:
+            self.midi.send_all_notes_off()
+
+        if not self.playOnlyFl:
+            self.audio.record_enable(False)
+
+            self._save_results()
+
+    def play(self,ms):
+
+        if self.measD is None or len(self.measD) == 0:
+            print("Nothing to play.")
+        else:
+            self.state             = 'started'
+            self.playOnlyFl        = True
+            self.nextStateChangeMs = ms + 500
+            self.curPitchIdx       = -1
+            self.curTargetDbIdx    = 0
+            self._do_play_update()
+        
+    def tick(self,ms):
+
+        if self.nextStateChangeMs is not None and ms > self.nextStateChangeMs:
+                    
+            if self.state == 'stopped':
+                pass
+
+            elif self.state == 'started':
+                self._do_note_on(ms)
+                self.nextStateChangeMs += self.cfg.noteOnDurMs
+                self.state = 'note_on'
+
+            elif self.state == 'note_on':
+                self._do_note_off(ms)
+                self.nextStateChangeMs += self.cfg.noteOffDurMs
+                self.state = 'note_off'
+
+            elif self.state == 'note_off':
+                if self.playOnlyFl:
+                    if not self._do_play_update():
+                        self.state = 'stopped'
+                else:
+                    if self._do_analysis(ms):
+                        if not self._start_new_db_target():
+                            self.stop(ms)
+                            self.state = 'stopped'
+                            print("DONE!")
+
+                # if the state was not changed to 'stopped'
+                if self.state == 'note_off':
+                    self.state = 'started'
+                    
+                
+    def _do_play_update( self ):
+
+        self.curPitchIdx +=1
+        if self.curPitchIdx >= len(self.cfg.pitchL):
+            self.curPitchIdx = 0
+            self.curTargetDbIdx += 1
+            if self.curTargetDbIdx >= len(self.cfg.targetDbL):
+                return False
+
+        pitch = self.cfg.pitchL[ self.curPitchIdx ]
+        targetDb = self.cfg.targetDbL[ self.curTargetDbIdx ]
+        self.curPulseUs = -1
+        for d in self.measD[ pitch ]:
+            if d['targetDb'] == targetDb and d['matchFl']==True:
+                self.curPulseUs = d['pulse_us']
+                break
+
+        if self.curPulseUs == -1:
+            print("Pitch:%i TargetDb:%f not found." % (pitch,targetDb))
+            return False
+
+        print("Target db: %4.1f" % (targetDb))
+        
+        return True
+            
+    
+        
+    def _get_duty_cycle( self, pitch, pulseUsec ):
+        
+        dutyPct = 50
+
+        if pitch in self.cfg.holdDutyPctD:
+            
+            dutyPct = self.cfg.holdDutyPctD[pitch][0][1]
+            for refUsec,refDuty in self.cfg.holdDutyPctD[pitch]:
+                if pulseUsec < refUsec:
+                    break
+                dutyPct = refDuty
+
+        return dutyPct
+            
+    def _set_duty_cycle( self, pitch, pulseUsec ):
+
+        dutyPct = self._get_duty_cycle( pitch, pulseUsec )
+
+        if pitch not in self.curDutyPctD or self.curDutyPctD[pitch] != dutyPct:
+            self.curDutyPctD[pitch] = dutyPct
+            self.api.set_pwm_duty( pitch, dutyPct )
+            print("Hold Duty Set:",dutyPct)
+            self.skipMeasFl = True
+
+        return dutyPct
+    
+    def _do_note_on(self,ms):
+        self.curNoteStartMs = ms
+
+        pitch = self.cfg.pitchL[ self.curPitchIdx]
+        
+        if self.midi is not None:
+            self.midi.send_note_on( pitch, 60 )
+        else:
+            self._set_duty_cycle( pitch, self.curPulseUs )
+            self.api.note_on_us( pitch, self.curPulseUs )
+
+
+        print("note-on:  ",pitch," ",self.curPulseUs," us")
+        
+    def _do_note_off(self,ms):
+        self.noteAnnotationL.append( { 'beg_ms':self.curNoteStartMs-self.startMs, 'end_ms':ms-self.startMs, 'midi_pitch':self.cfg.pitchL[ self.curPitchIdx], 'pulse_us':self.curPulseUs } )
+
+        if self.midi is not None:
+            self.midi.send_note_off( self.cfg.pitchL[ self.curPitchIdx] )
+        else:
+            for pitch in self.cfg.pitchL:
+                self.api.note_off( pitch )
+
+            
+        #print("note-off: ",self.cfg.pitchL[ self.curPitchIdx])
+
+
+    def _calc_next_pulse_us( self, targetDb ):
+
+        # sort pulseDb ascending on db
+        self.pulseDbL = sorted( self.pulseDbL, key=lambda x: x[1] )
+
+        
+        pulseL,dbL = zip(*self.pulseDbL)
+
+        max_i = np.argmax(dbL)
+        min_i = np.argmin(dbL)        
+
+        if targetDb > dbL[max_i]:
+            pu =  pulseL[max_i] + self.deltaUpMult * 500
+            self.deltaUpMult += 1
+
+        elif targetDb < dbL[min_i]:
+            pu = pulseL[min_i] - self.deltaDnMult * 500
+            self.deltaDnMult += 1
+            if self.maxTooShortPulseUs is not None and pu < self.maxTooShortPulseUs:
+                # BUG: this is a problem is self.pulseL[min_i] is <= than self.maxTooShortPulseUs
+                # the abs() covers the problem to prevent decreasing from maxTooShortPulseus
+                pu = self.maxTooShortPulseUs + (abs(pulseL[min_i] - self.maxTooShortPulseUs))/2
+                self.deltaDnMult = 1                
+        else:
+            self.deltaUpMult = 1
+            self.deltaDnMult = 1
+            pu =  np.interp([targetDb],dbL,pulseL)
+
+        return max(min(pu,self.cfg.maxPulseUs),self.cfg.minPulseUs)
+    
+    def _do_analysis(self,ms):
+
+        analysisDoneFl = False
+        midi_pitch     = self.cfg.pitchL[self.curPitchIdx]
+        pulse_us       = self.curPulseUs
+        
+        measD = self._meas_note(midi_pitch,pulse_us)
+
+        # if the the 'skip' flag is set then don't analyze this note
+        if self.skipMeasFl:
+            self.skipMeasFl = False
+            print("SKIP")
+        else:
+
+            db    = measD[self.cfg.dbSrcLabel]['db']
+            durMs = measD['hm']['durMs']
+
+            # if this note is shorter than the minimum allowable duration
+            if durMs < self.cfg.minMeasDurMs:
+
+                print("SHORT!")
+                
+                if self.maxTooShortPulseUs is None or self.curPulseUs > self.maxTooShortPulseUs:
+                    self.maxTooShortPulseUs = self.curPulseUs
+
+                if self.lastAudiblePulseUs is not None and self.curPulseUs < self.lastAudiblePulseUs:
+                    self.curPulseUs = self.lastAudiblePulseUs
+                else:
+                    self.curPulseUs = self.cfg.initPulseUs
+                
+            else:
+
+                # this is a valid measurement store it to the pulse-db table 
+                self.pulseDbL.append( (self.curPulseUs,db) )
+
+                # track the most recent audible note - to return to if a successive note is too short
+                self.lastAudiblePulseUs = self.curPulseUs
+                
+                # calc the upper and lower bounds db range
+                lwr_db = self.curTargetDb * ((100.0 - self.cfg.tolDbPct)/100.0)
+                upr_db = self.curTargetDb * ((100.0 + self.cfg.tolDbPct)/100.0)
+
+                # was this note is inside the db range then set the 'match' flag
+                if lwr_db <= db and db <= upr_db:
+                    self.curMatchN += 1
+                    measD['matchFl'] = True
+                    print("MATCH!")
+
+                # 
+                self.curPulseUs = int(self._calc_next_pulse_us(self.curTargetDb))
+
+            # if at least minMatchN matches have been made on this pitch/targetDb 
+            if self.curMatchN >= self.cfg.minMatchN:
+                analysisDoneFl = True
+                self.successN += 1
+                print("Anysis Done: Success")
+
+            # if at least maxAttemptN match attempts have been made without success
+            self.curAttemptN += 1
+            if self.curAttemptN >= self.cfg.maxAttemptN:
+                analysisDoneFl = True
+                self.failN += 1
+                print("Analysis Done: Fail")
+
+                
+        if midi_pitch not in self.measD:
+            self.measD[ midi_pitch ] = []
+
+        self.measD[ midi_pitch ].append( measD )
+
+        return analysisDoneFl
+    
+
+    def _meas_note(self,midi_pitch,pulse_us):
+        
+        # get the annotation information for the last note
+        annD = self.noteAnnotationL[-1]
+
+        buf_result = self.audio.linear_buffer()
+
+        if buf_result:
+
+            sigV = buf_result.value
+
+            # get the annotated begin and end of the note as sample indexes into sigV
+            bi = int(round(annD['beg_ms'] * self.audio.srate / 1000))
+            ei = int(round(annD['end_ms'] * self.audio.srate / 1000))
+
+            # calculate half the length of the note-off duration in samples
+            noteOffSmp_o_2 = int(round(self.cfg.noteOffDurMs/2  * self.audio.srate / 1000))
+
+            # widen the note analysis space noteOffSmp_o_2 samples pre/post the annotated begin/end of the note
+            bi = max(0,bi - noteOffSmp_o_2)
+            ei = min(noteOffSmp_o_2,sigV.shape[0]-1)
+
+            
+            ar = types.SimpleNamespace(**self.cfg.analysisD)
+
+            # shift the annotatd begin/end of the note to be relative to  index bi
+            begMs = noteOffSmp_o_2 * 1000 / self.audio.srate
+            endMs = begMs + (annD['end_ms'] - annD['beg_ms'])
+
+            # analyze the note
+            resD  = rms_analyze_rt_one_note( sigV[bi:ei], self.audio.srate, begMs, endMs, midi_pitch, rmsWndMs=ar.rmsWndMs, rmsHopMs=ar.rmsHopMs, dbRefWndMs=ar.dbRefWndMs, harmCandN=ar.harmCandN, harmN=ar.harmN, durDecayPct=ar.durDecayPct )
+
+            resD["pulse_us"]   = pulse_us 
+            resD["midi_pitch"] = midi_pitch
+            resD["beg_ms"]     = annD['beg_ms']
+            resD['end_ms']     = annD['end_ms']
+            resD['skipMeasFl'] = self.skipMeasFl
+            resD['matchFl']    = False
+            resD['targetDb']   = self.curTargetDb
+            resD['annIdx']     = len(self.noteAnnotationL)-1
+            
+            print( "%4.1f hm:%4.1f (%4.1f) %4i  td:%4.1f (%4.1f) %4i" %  (self.curTargetDb,resD['hm']['db'], resD['hm']['db']-self.curTargetDb, resD['hm']['durMs'], resD['td']['db'], resD['td']['db']-self.curTargetDb, resD['td']['durMs']))
+
+        
+        return resD
+
+    
+
+    def _start_new_db_target(self):
+        
+        self.curTargetDbIdx += 1
+        
+        # if all db targets have been queried then advance to the next pitch
+        if self.curTargetDbIdx >= len(self.cfg.targetDbL):
+            
+            self.curTargetDbIdx = 0
+            self.curPitchIdx += 1
+
+            # if all pitches have been queried then we are done
+            if self.curPitchIdx >= len(self.cfg.pitchL):
+                return False
+
+            
+        self.curTargetDb        = self.cfg.targetDbL[ self.curTargetDbIdx ]
+        self.curMatchN          = 0
+        self.curAttemptN        = 0
+        self.lastAudiblePulseUs = None
+        self.maxTooShortPulseUs = None
+        self.pulseDbL           = []
+        self.deltaUpMult        = 1
+        self.deltaDnMult        = 1
+        return True
+
+
+    def _write_16_bit_wav_file( self, fn ):
+
+        srate = int(self.audio.srate)
+
+        buf_result = self.audio.linear_buffer()
+
+        sigV = buf_result.value
+
+        smpN = sigV.shape[0]
+        chN  = 1
+        sigV = np.squeeze(sigV.reshape( smpN * chN, )) * 0x7fff
+        sigL = [ int(round(sigV[i])) for i in range(smpN) ]
+
+        sigA = array.array('h',sigL)
+
+        with wave.open( fn, "wb") as f:
+
+            bits = 16
+            bits_per_byte = 8
+            f.setparams((chN, bits//bits_per_byte, srate, 0, 'NONE', 'not compressed'))
+
+            f.writeframes(sigA)
+
+    def _save_results( self ):
+
+        if self.measD is None or len(self.measD) == 0:
+            return
+        
+        outDir = os.path.expanduser( self.cfg.outDir )
+        
+        if not os.path.isdir(outDir):
+            os.mkdir(outDir)
+
+        outDir = os.path.join( outDir, self.cfg.outLabel )
+
+        if not os.path.isdir(outDir):
+            os.mkdir(outDir)
+
+        i = 0
+        while( os.path.isdir( os.path.join(outDir,"%i" % i )) ):
+            i += 1
+
+        outDir = os.path.join( outDir, "%i" % i )
+        os.mkdir(outDir)
+
+        self._write_16_bit_wav_file( os.path.join(outDir,"audio.wav"))
+
+        d = {'cfg':self.cfg.__dict__, 'measD': self.measD, 'annoteL':self.noteAnnotationL }
+
+        with open( os.path.join(outDir,"meas.json"), "w") as f:
+            json.dump(d,f)
+
+            
diff --git a/p_ac.py b/p_ac.py
index 65f956c..23b6aae 100644
--- a/p_ac.py
+++ b/p_ac.py
@@ -6,12 +6,14 @@ from multiprocessing import Process, Pipe
 
 from picadae_api  import Picadae
 from AudioDevice  import AudioDevice
+from MidiDevice   import MidiDevice
 from result       import Result
 from common       import parse_yaml_cfg
 from plot_seq     import form_resample_pulse_time_list
 from plot_seq     import form_final_pulse_list
 from rt_note_analysis import RT_Analyzer
 from keyboard         import Keyboard
+from calibrate        import Calibrate
 
 class AttackPulseSeq:
     """ Sequence a fixed chord over a list of attack pulse lengths."""
@@ -274,13 +276,15 @@ class App:
         self.cfg       = None
         self.audioDev  = None
         self.api       = None
-        self.calibrate = None
+        self.cal_keys  = None
         self.keyboard  = None
+        self.calibrate = None
         
     def setup( self, cfg ):
         self.cfg = cfg
 
         self.audioDev = AudioDevice()
+        self.midiDev = MidiDevice()
 
         #
         # TODO: unify the result error handling
@@ -292,20 +296,31 @@ class App:
         if not res:
             self.audio_dev_list(0)
         else:
-            self.api = Picadae( key_mapL=cfg.key_mapL)
 
-            # wait for the letter 'a' to come back from the serial port
-            api_res = self.api.wait_for_serial_sync(timeoutMs=cfg.serial_sync_timeout_ms)
+            if hasattr(cfg,'midi'):
+                res = self.midiDev.setup(**cfg.midi)
 
-            # did the serial port sync fail?
-            if not api_res:
-                res.set_error("Serial port sync failed.")
+                if not res:
+                    self.midi_dev_list(0)
             else:
-                print("Serial port sync'ed")
+                self.midiDev = None
 
-                self.calibrate = CalibrateKeys( cfg, self.audioDev, self.api )
+                self.api = Picadae( key_mapL=cfg.key_mapL)
 
-                self.keyboard  = Keyboard( cfg, self.audioDev, self.api )
+                # wait for the letter 'a' to come back from the serial port
+                api_res = self.api.wait_for_serial_sync(timeoutMs=cfg.serial_sync_timeout_ms)
+
+                # did the serial port sync fail?
+                if not api_res:
+                    res.set_error("Serial port sync failed.")
+                else:
+                    print("Serial port sync'ed")
+
+                    self.cal_keys = CalibrateKeys( cfg, self.audioDev, self.api )
+
+                    self.keyboard  = Keyboard( cfg, self.audioDev, self.api )
+
+                    self.calibrate = Calibrate( cfg.calibrateArgs, self.audioDev, self.midiDev, self.api )
     
         return res
 
@@ -313,10 +328,14 @@ class App:
         
         self.audioDev.tick(ms)
         
-        if self.calibrate:
-            self.calibrate.tick(ms)
+        if self.cal_keys:
+            self.cal_keys.tick(ms)
+            
         if self.keyboard:
             self.keyboard.tick(ms)
+            
+        if self.calibrate:
+            self.calibrate.tick(ms)
 
     def audio_dev_list( self, ms ):
         portL = self.audioDev.get_port_list( True )
@@ -324,13 +343,25 @@ class App:
         for port in portL:
             print("chs:%4i label:%s" % (port['chN'],port['label']))
 
+    def midi_dev_list( self, ms ):
+        d = self.midiDev.get_port_list( True )
+
+        for port in d['listL']:
+            print("IN:",port)
+        
+        d = self.midiDev.get_port_list( False )
+          
+        for port in d['listL']:
+            print("OUT:",port)
+        
+
     def calibrate_keys_start( self, ms, pitchRangeL ):
         chordL = [ [pitch]  for pitch in range(pitchRangeL[0], pitchRangeL[1]+1)]
-        self.calibrate.start(  ms, chordL, cfg.full_pulseL )
+        self.cal_keys.start(  ms, chordL, cfg.full_pulseL )
 
     def play_keys_start( self, ms, pitchRangeL ):
         chordL = [ [pitch]  for pitch in range(pitchRangeL[0], pitchRangeL[1]+1)]
-        self.calibrate.start(  ms, chordL, cfg.full_pulseL, playOnlyFl=True )
+        self.cal_keys.start(  ms, chordL, cfg.full_pulseL, playOnlyFl=True )
 
     def keyboard_start_pulse_idx( self, ms, argL ):
         pitchL = [ pitch  for pitch in range(argL[0], argL[1]+1)]        
@@ -346,9 +377,16 @@ class App:
     def keyboard_repeat_target_db( self, ms, argL ):
         self.keyboard.repeat(  ms, None, argL[0] )
 
+    def calibrate_start( self, ms, argL ):
+        self.calibrate.start(ms)
+        
+    def calibrate_play( self, ms, argL ):
+        self.calibrate.play(ms)
+        
     def calibrate_keys_stop( self, ms ):
-        self.calibrate.stop(ms)
+        self.cal_keys.stop(ms)
         self.keyboard.stop(ms)
+        self.calibrate.stop(ms)
         
     def quit( self, ms ):
         if self.api:
@@ -424,7 +462,7 @@ def app_event_loop_func( pipe, cfg ):
 
 
         # give some time to the system
-        time.sleep(0.1)
+        time.sleep(0.05)
         
         # calc the tick() time stamp
         ms  = int(round( (datetime.now() - dt0).total_seconds() * 1000.0) )
@@ -470,7 +508,10 @@ class Shell:
             'q':{ "func":'quit',                      "minN":0,  "maxN":0, "help":"quit"},
             '?':{ "func":"_help",                     "minN":0,  "maxN":0, "help":"Print usage text."},
             'a':{ "func":"audio_dev_list",            "minN":0,  "maxN":0, "help":"List the audio devices."},
+            'm':{ "func":"midi_dev_list",             "minN":0,  "maxN":0, "help":"List the MIDI devices."},
             'c':{ "func":"calibrate_keys_start",      "minN":1,  "maxN":2, "help":"Calibrate a range of keys. "},
+            'd':{ "func":"calibrate_start",           "minN":1,  "maxN":1, "help":"Calibrate based on fixed db levels. "},
+            'D':{ "func":"calibrate_play",            "minN":1,  "maxN":1, "help":"Play back last calibration."},
             's':{ "func":"calibrate_keys_stop",       "minN":0,  "maxN":0, "help":"Stop key calibration"},
             'p':{ "func":"play_keys_start",           "minN":1,  "maxN":2, "help":"Play current calibration"},
             'k':{ "func":"keyboard_start_pulse_idx",  "minN":3,  "maxN":3, "help":"Play pulse index across keyboard"},
diff --git a/p_ac.yml b/p_ac.yml
index c87ab9e..322ef02 100644
--- a/p_ac.yml
+++ b/p_ac.yml
@@ -6,8 +6,17 @@
     audio: {
       inPortLabel: "5 USB Audio CODEC:", #"HDA Intel PCH: CS4208", # "5 USB Audio CODEC:", #"5 USB Sound Device",
       outPortLabel: ,
-      },
+    },
 
+    midi_off: {
+        inMonitorFl: False,
+        outMonitorFl: False,
+        throughFl: False,
+        inPortLabel: "Fastlane:Fastlane MIDI A",
+        outPortLabel: "Fastlane:Fastlane MIDI A"
+        #inPortLabel: "picadae:picadae MIDI 1",
+        #outPortLabel: "picadae:picadae MIDI 1"
+    },
     
     # Picadae API args
     serial_dev: "/dev/ttyACM0",
@@ -61,6 +70,121 @@
       finalPulseListCacheFn: "/home/kevin/temp/final_pulse_list_cache.pickle",
       rmsAnalysisCacheFn: "/home/kevin/temp/rms_analysis_cache.pickle"
       },
+
+
+      calibrateArgs: {
+
+        outDir: "~/temp/calib0",
+        outLabel: "test",
+        
+        analysisD: {
+          rmsWndMs: 300,    # length of the RMS measurment window
+          rmsHopMs: 30,     # RMS measurement inter window distance
+          dbRefWndMs: 500,  # length of initial portion of signal to use to calculate the dB reference level
+          harmCandN: 5,     # count of harmonic candidates to locate during harmonic based RMS analysis
+          harmN: 3,         # count of harmonics to use to calculate harmonic based RMS analysis
+          durDecayPct: 40   # percent drop in RMS to indicate the end of a note
+          },
+    
+          noteOnDurMs: 1000,
+          noteOffDurMs: 1000,
+    
+          
+          pitchL: [ 50, 51, 52 ],                    # list of pitches
+          targetDbL: [ 16, 20, 23 ],                  # list of target db
+
+          minMeasDurMs: 800,             # minimum candidate note duration
+          tolDbPct: 5.0,                 # tolerance as a percent of targetDb above/below used to form match db window
+          maxPulseUs: 45000,             # max. allowable pulse us
+          minPulseUs:  8000,             # min. allowable pulse us
+          initPulseUs: 15000,            # pulseUs for first note
+          minMatchN: 3,                  # at least 3 candidate notes must be within tolDbPct to move on to a new targetDb
+          maxAttemptN: 30,               # give up if more than 20 candidate notes fail for a given targetDb
+          dbSrcLabel: 'td',              # source of the db measurement 'td' (time-domain) or 'hm' (harmonic)
+
+          holdDutyPctD:  {
+          23: [[0, 70]],
+          24: [[0, 75]],
+          25: [[0, 70]],
+          26: [[0, 65]],
+          27: [[0, 70]],
+          28: [[0, 70]],
+          29: [[0, 65]],
+          30: [[0, 65]],
+          31: [[0, 65]],
+          32: [[0, 60]],
+          33: [[0, 65]],
+          34: [[0, 65]],
+          35: [[0, 65]],
+          36: [[0, 65]],
+          37: [[0, 65]],
+          38: [[0, 60]],
+          39: [[0, 60]],
+          40: [[0, 55]],
+          41: [[0, 60]],
+          42: [[0, 60]],
+          43: [[0, 65]],
+          44: [[0, 60]],
+          45: [[0, 60]],
+          46: [[0, 60]],
+          47: [[0, 60]],
+          48: [[0, 70]],
+          49: [[0, 60]],
+          50: [[0, 50]],
+          51: [[0, 50]],
+          52: [[0, 55]],
+          53: [[0, 50]],
+          54: [[0, 50]],
+          55: [[0, 50], [22000, 55]],
+          56: [[0, 50]],
+          57: [[0, 50]],
+          58: [[0, 50]],
+          59: [[0, 60]],
+          60: [[0, 50]],
+          61: [[0, 50]],
+          62: [[0, 55]],
+          63: [[0, 50]],
+          64: [[0, 50]],
+          65: [[0, 50], [17000, 65]],
+          66: [[0, 53]],
+          67: [[0, 55]],
+          68: [[0, 53]],
+          69: [[0, 55]],
+          70: [[0, 50]],
+          71: [[0, 50]],
+          72: [[0, 60]],
+          73: [[0, 50]],
+          74: [[0, 60]],
+          75: [[0, 55]],
+          76: [[0, 70]],
+          77: [[0, 50], [15000, 60], [19000, 70]],
+          78: [[0, 60]],
+          79: [[0, 50], [15000, 60], [19000, 70]],
+          80: [[0, 45]],
+          81: [[0, 50], [15000, 70]],
+          82: [[0, 50], [12500, 60], [14000, 65], [17000, 70]],
+          83: [[0, 50], [15000, 65]],
+          84: [[0, 50], [12500, 60], [14000, 65], [17000, 70]],
+          85: [[0, 50], [12500, 60], [14000, 65], [17000, 70]],
+          86: [[0, 50], [12500, 60], [14000, 65], [17000, 70]],
+          87: [[0, 50], [14000, 60]],
+          88: [[0, 50], [12500, 60], [14000, 65], [17000, 70]],
+          89: [[0, 50], [12500, 60], [14000, 65], [17000, 70]],
+          91: [[0, 40], [12500, 50], [14000, 60], [17000, 65]],
+          92: [[0, 40], [14000, 50]],
+          93: [[0, 40], [12500, 50], [14000, 60], [17000, 65]],
+          94: [[0, 40], [14000, 50]],
+          95: [[0, 40], [12500, 50], [14000, 60], [17000, 65]],
+          96: [[0, 40], [12500, 50], [14000, 60], [17000, 65]],
+          97: [[0, 40], [14000, 50]],
+          98: [[0, 50]],
+          99: [[0, 50]],
+          100: [[0, 50]],
+          101: [[0, 50]],
+          106: [[0, 50]]
+          },
+          
+        },
     
      key_mapL: [
 
@@ -163,6 +287,5 @@
        ]
       
     
-    
     }
 }
diff --git a/plot_calibrate.ipynb b/plot_calibrate.ipynb
new file mode 100644
index 0000000..97f8836
--- /dev/null
+++ b/plot_calibrate.ipynb
@@ -0,0 +1,72 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "from plot_calibrate import plot_all_notes\n",
+    "from plot_calibrate import plot_by_pitch\n",
+    "\n",
+    "inDir = \"/home/kevin/temp/calib0/test/34\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1332x2268 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#plot_all_notes(inDir)\n",
+    "plot_by_pitch(inDir)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/plot_calibrate.py b/plot_calibrate.py
new file mode 100644
index 0000000..a0a3058
--- /dev/null
+++ b/plot_calibrate.py
@@ -0,0 +1,150 @@
+import sys,os,json,types
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib._color_data as mcd
+from matplotlib.pyplot import figure
+
+from rms_analysis import calibrate_recording_analysis
+
+def plot_by_pitch( inDir, pitch=None ):
+
+    anlD = calibrate_recording_analysis( inDir )
+    jsonFn  = os.path.join(inDir, "meas.json" )
+    audioFn = os.path.join(inDir, "audio.wav" )
+
+    with open(jsonFn,"r") as f:
+        r = json.load(f)
+
+    measD = r['measD']
+    cfg  = types.SimpleNamespace(**r['cfg'])
+    
+    axN = len(measD) if pitch is None else 1
+    fig,axL = plt.subplots(axN,1)
+    fig.set_size_inches(18.5, 10.5*axN)
+
+
+    # for each pitch
+    for axi,(midi_pitch,measL)in enumerate(measD.items()):
+
+        midi_pitch = int(midi_pitch)
+        
+        if pitch is not None and pitch != midi_pitch:
+            continue
+
+        if pitch is not None:
+            axi = 0
+            axL = [ axL ]
+        
+        targetDbS  = set()
+        hmPulseDbL = []
+        tdPulseDbL = []
+        anPulseDbL = []
+
+        # for each measurement on this pitch
+        for mi,d in enumerate(measL):
+            m = types.SimpleNamespace(**d)
+
+            # form a list of pulse/db measurements associated with this pitch
+            hmPulseDbL.append( (m.pulse_us,m.hm['db'],m.matchFl,m.hm['durMs'],m.skipMeasFl) )
+            tdPulseDbL.append( (m.pulse_us,m.td['db'],m.matchFl,m.td['durMs'],m.skipMeasFl) )
+
+            ar = next(ad for ad in anlD[midi_pitch] if ad['meas_idx']==mi )
+            anPulseDbL.append( (m.pulse_us,ar['db'],m.matchFl,m.hm['durMs'],m.skipMeasFl))
+
+            # get the unique set of targets
+            targetDbS.add(m.targetDb)
+
+
+        # sort measurements on pulse length
+        hmPulseDbL = sorted(hmPulseDbL,key=lambda x: x[0])
+        tdPulseDbL = sorted(tdPulseDbL,key=lambda x: x[0])
+        anPulseDbL = sorted(anPulseDbL,key=lambda x: x[0])
+
+        # plot the re-analysis 
+        pulseL,dbL,matchFlL,_,_ = zip(*anPulseDbL)
+        axL[axi].plot( pulseL, dbL, label="post", marker='.' )
+        
+        # plot harmonic measurements
+        pulseL,dbL,matchFlL,durMsL,skipFlL = zip(*hmPulseDbL)
+        axL[axi].plot( pulseL, dbL, label="harm", marker='.' )
+
+        # plot time-domain based measuremented
+        pulseL,dbL,matchFlL,_,_ = zip(*tdPulseDbL)
+        axL[axi].plot( pulseL, dbL, label="td", marker='.' )
+
+        
+        # plot target boundaries
+        for targetDb in targetDbS:
+            lwr = targetDb * ((100.0 - cfg.tolDbPct)/100.0)
+            upr = targetDb * ((100.0 + cfg.tolDbPct)/100.0 )       
+
+            axL[axi].axhline(targetDb)
+            axL[axi].axhline(lwr,color='lightgray')
+            axL[axi].axhline(upr,color='gray')
+
+        # plot match and 'too-short' markers
+        for i,matchFl in enumerate(matchFlL):
+
+            if durMsL[i] < cfg.minMeasDurMs:
+                axL[axi].plot( pulseL[i], dbL[i], marker='x', color='black', linestyle='None')
+
+            if skipFlL[i]:
+                axL[axi].plot( pulseL[i], dbL[i], marker='+', color='blue', linestyle='None')
+                
+            if matchFl:
+                axL[axi].plot( pulseL[i], dbL[i], marker='.', color='red', linestyle='None')
+
+                
+                
+
+        axL[axi].set_title("pitch:%i " % (midi_pitch))
+        
+    plt.legend()
+    plt.show()
+
+def plot_all_notes( inDir ):
+
+    jsonFn  = os.path.join(inDir, "meas.json" )
+    audioFn = os.path.join(inDir, "audio.wav" )
+
+    with open(jsonFn,"r") as f:
+        r = json.load(f)
+
+    measD = r['measD']
+
+    axN = 0
+    for midi_pitch,measL in measD.items():
+        axN += len(measL)
+
+    print(axN)
+    fig,axL = plt.subplots(axN,1)
+    fig.set_size_inches(18.5, 10.5*axN)
+    
+
+    i = 0
+    for midi_pitch,measL in measD.items():
+        for d in measL:
+            axL[i].plot(d['td']['rmsDbV'])
+            axL[i].plot(d['hm']['rmsDbV'])
+
+            axL[i].axvline(d['td']['pk_idx'],color='red')
+            axL[i].axvline(d['hm']['pk_idx'],color='green')
+
+            i += 1
+
+    plt.show()
+
+
+
+if __name__ == "__main__":
+
+    pitch = None
+    inDir = sys.argv[1]
+    if len(sys.argv) > 2:
+        pitch = int(sys.argv[2])
+
+    #plot_all_notes( inDir )
+    plot_by_pitch(inDir,pitch)
+    #calibrate_recording_analysis( inDir )
+    
+    
diff --git a/plot_note_analysis.py b/plot_note_analysis.py
index fc80cd4..8e75cee 100644
--- a/plot_note_analysis.py
+++ b/plot_note_analysis.py
@@ -1,4 +1,4 @@
-import os,sys,pickle
+import os,sys,pickle,json
 import numpy as np
 
 import matplotlib.pyplot as plt
@@ -279,9 +279,37 @@ def plot_quiet_note_db( cacheFn, yamlCfgFn, minDurMs=700 ):
     plt.show()
     
     
-        
+def dump_hold_duty_pct( inDir ):
 
+    pitchL = []
+    folderL = os.listdir(inDir)
+
+    for folder in folderL:
+
+        midi_pitch = int(folder)
         
+        fn = os.path.join( inDir,folder,"0","seq.json")
+        
+        if not os.path.isfile(fn):
+            print("No sequence file:%s" % (fn))
+        else:
+            with open(fn,"r") as f:
+                d = json.load(f)
+
+                if 'holdDutyPct' in d:
+                    holdDutyPctL = [ [0,d['holdDutyPct']] ]
+                else:
+                    holdDutyPctL = d['holdDutyPctL']
+
+                pitchL.append( {'pitch':midi_pitch, 'holdDutyPctL':holdDutyPctL} )
+                #print(midi_pitch, holdDutyPctL)
+        
+    pitchL = sorted(pitchL, key=lambda x:  x['pitch'])
+
+    for d in pitchL:
+        print("{",d['pitch'],":",d['holdDutyPctL'],"},")
+                    
+                
 if __name__ == "__main__":
 
     #inDir = sys.argv[1]
@@ -297,4 +325,6 @@ if __name__ == "__main__":
     #get_all_note_durations("/home/kevin/temp/p_ac_3c",durFn)
     #plot_all_note_durations(durFn, np.arange(45,55),2,"p_ac.yml",800,20000)
 
-    plot_quiet_note_db(durFn,"p_ac.yml")
+    #plot_quiet_note_db(durFn,"p_ac.yml")
+
+    dump_hold_duty_pct( "/home/kevin/temp/p_ac_3c" )
diff --git a/rms_analysis.py b/rms_analysis.py
index 4809b18..0f4ba74 100644
--- a/rms_analysis.py
+++ b/rms_analysis.py
@@ -1,4 +1,4 @@
-import os,types,json,pickle
+import os,types,json,pickle,types
 from scipy.io import wavfile
 from scipy.signal import stft
 import numpy as np
@@ -27,8 +27,9 @@ def calc_harm_bins( srate, binHz, midiPitch, harmN ):
     return fund_l_binL, fund_m_binL, fund_u_binL
     
 def rms_to_db( xV, rms_srate, refWndMs ):
-    dbWndN = int(round(refWndMs * rms_srate / 1000.0))
-    dbRef = ref = np.mean(xV[0:dbWndN])
+    #dbWndN = int(round(refWndMs * rms_srate / 1000.0))
+    #dbRef = ref = np.mean(xV[0:dbWndN])
+    dbRef = refWndMs   ######################################################### HACK HACK HACK HACK HACK
     rmsDbV = 20.0 * np.log10( xV / dbRef )
 
     return rmsDbV
@@ -213,9 +214,6 @@ def note_stats( r, decay_pct=50.0, extraDurSearchMs=500 ):
         bi = pkSmpIdx
         ei = pkSmpIdx + int(round(durMs * srate / 1000.0))
 
-        #bi = begSmpIdx
-        #ei = endSmpIdx
-
         qualityCoeff =  np.sum(r.rmsDbV[bi:ei]) + np.sum(r.tdRmsDbV[bi:ei])
         if qualityCoeff > qmax:
             qmax = qualityCoeff
@@ -259,6 +257,106 @@ def key_info_dictionary( keyMapL=None, yamlCfgFn=None):
 
     return kmD
 
+def rms_analyze_one_rt_note( sigV, srate, begMs, endMs, midi_pitch, rmsWndMs=300, rmsHopMs=30, dbRefWndMs=500, harmCandN=5, harmN=3, durDecayPct=40 ):
+
+    sigV = np.squeeze(sigV)
+
+                        # HACK HACK HACK HACK
+    dbRefWndMs = 0.002  # HACK HACK HACK HACK
+                        # HACK HACK HACK HACK
+    td_rmsDbV, td_srate = audio_rms( srate, sigV, rmsWndMs, rmsHopMs, dbRefWndMs )
+
+    begSmpIdx = int(round(begMs * td_srate/1000))
+    endSmpIdx = int(round(endMs * td_srate/1000))
+    td_pk_idx = begSmpIdx + np.argmax(td_rmsDbV[begSmpIdx:endSmpIdx])
+
+    td_durMs = measure_duration_ms( td_rmsDbV, td_srate, td_pk_idx, len(sigV)-1, durDecayPct )
+
+                       # HACK HACK HACK HACK    
+    dbRefWndMs = 0.01  # HACK HACK HACK HACK
+                       # HACK HACK HACK HACK
+     
+    hm_rmsDbV, hm_srate, binHz = audio_harm_rms( srate, sigV, rmsWndMs, rmsHopMs, dbRefWndMs, midi_pitch, harmCandN, harmN  )
+
+    begSmpIdx = int(round(begMs * hm_srate/1000))
+    endSmpIdx = int(round(endMs * hm_srate/1000))
+    hm_pk_idx = begSmpIdx + np.argmax(hm_rmsDbV[begSmpIdx:endSmpIdx])
+
+    hm_durMs = measure_duration_ms( hm_rmsDbV, hm_srate, hm_pk_idx, len(sigV)-1, durDecayPct )
+
+    tdD = { "rmsDbV":td_rmsDbV.tolist(), "srate":td_srate, "pk_idx":int(td_pk_idx), "db":float(td_rmsDbV[td_pk_idx]), "durMs":td_durMs }
+    hmD = { "rmsDbV":hm_rmsDbV.tolist(), "srate":hm_srate, "pk_idx":int(hm_pk_idx), "db":float(hm_rmsDbV[hm_pk_idx]), "durMs":hm_durMs }
+    
+    return { "td":tdD, "hm":hmD }
+
+def calibrate_rms( sigV, srate, beg_ms, end_ms ):
+
+    bi = int(round(beg_ms * srate / 1000))
+    ei = int(round(end_ms * srate / 1000))
+    rms = np.sqrt( np.mean( sigV[bi:ei] * sigV[bi:ei] ))
+
+    return 20.0*np.log10( rms / 0.002 )
+    
+
+def calibrate_recording_analysis( inDir ):
+
+    jsonFn  = os.path.join(inDir, "meas.json" )
+    audioFn = os.path.join(inDir, "audio.wav" )
+
+    with open(jsonFn,"r") as f:
+        r = json.load(f)
+
+    measD = r['measD']
+    cfg   = types.SimpleNamespace(**r['cfg'])
+    annL  = r['annoteL']
+    anlD  = {}
+    
+    n = 0
+    for midi_pitch,measL in measD.items():
+        n += len(measL)
+        anlD[int(midi_pitch)] = []
+
+    srate, signalM  = wavfile.read(audioFn)
+    sigV  = signalM / float(0x7fff)
+
+    anlr = types.SimpleNamespace(**cfg.analysisD)
+
+                        # HACK HACK HACK HACK
+    dbRefWndMs = 0.002  # HACK HACK HACK HACK
+                        # HACK HACK HACK HACK
+    
+    tdRmsDbV, td_srate = audio_rms( srate, sigV, anlr.rmsWndMs, anlr.rmsHopMs, dbRefWndMs )
+
+    # for each measured pitch 
+    for midi_pitch,measL in measD.items():
+
+        # for each measured note at this pitch
+        for mi,d in enumerate(measL):
+
+            mr = types.SimpleNamespace(**d)
+            
+            # locate the associated annotation reocrd
+            for annD in annL:
+                ar = types.SimpleNamespace(**annD)
+
+                if ar.midi_pitch == mr.midi_pitch and ar.beg_ms==mr.beg_ms and ar.end_ms==mr.end_ms:
+                    assert( ar.pulse_us == mr.pulse_us )
+
+                    bi = int(round(ar.beg_ms * td_srate / 1000))
+                    ei = int(round(ar.end_ms * td_srate / 1000))
+                    db = np.mean(tdRmsDbV[bi:ei])
+
+                    db = calibrate_rms( sigV, srate, ar.beg_ms, ar.end_ms )
+                    
+                    anlD[int(midi_pitch)].append({ 'pulse_us':ar.pulse_us, 'db':db, 'meas_idx':mi })
+
+                    break
+
+
+    return anlD
+                    
+        
+
 
 def rms_analysis_main( inDir, midi_pitch, rmsWndMs=300, rmsHopMs=30, dbRefWndMs=500, harmCandN=5, harmN=3, durDecayPct=40 ):