def do_recording(self, start_time):
     """4. Alice requests recording
     (4 and 5 are called synchronous at ``start_time``)
     
     Function waits until ``start_time`` and then starts recording
     
     :param start_time: Absolute time when recording should start
     :type start_time: int
     """
     log.info('4. Alice requests recording')
     
     if self.recording_use_file:
         # load recording from file
         #left_channel, right_channel, self.recording_samplerate = load_stereo(self.recording_file)
         #self.recording_data = left_channel
         self.recording_data, self.recording_samplerate = load_mono(self.recording_file)
     else:
         # start recording at start_time
         self.recording_data, self.recording_samplerate = record_at_time("client.wav", 7, start_time)
def record_at_time(filename, duration, start_time):
    # init recorder
    recording = AudioRecording(filename, duration)
    
    end_time = start_time+duration
    
    log.debug("Recording Start time: "+str(start_time))
    log.debug("Recording End time: "+str(end_time))
    
    # starting at start_time
    while True:
        if (time.time() >= start_time):
            # now go on!
            break

    log.info('Recording thread started at '+str(time.time()))
    
    # record in thread
    thread.start_new_thread(recording.record_start, (end_time,))
    
    
    # init and start gobject c threads
    loop = gobject.MainLoop()
    gobject.threads_init()
    context = loop.get_context()
    
    # record and do thread loop until end_time
    while True:
        # do gobject iteration
        context.iteration(True)
        
        if (time.time() >= end_time):
            # terminate gobject thread
            loop.quit()
            
            break
    
    # load recorded file
    recording_data, recording_samplerate = load_mono(filename)
    
    return recording_data, recording_samplerate
    def remote_recording(self, start_time):
        """5. remote recording
        (4 and 5 are called synchron at ``start_time``)
        
        Function waits until ``start_time`` and then starts recording
        
        :param start_time: Absolute time when recording should start
        :type start_time: int
        """
        log.info('5. remote recording')
        
        if self.recording_use_file:
            # load recording from file
            self.recording_data, self.recording_samplerate = load_mono(self.recording_file)

            return True
        else:
            # start recording at start_time
            self.recording_data, self.recording_samplerate = record_at_time("server.wav", 7, start_time)

            return True
base = "/home/ds1/Projekte/Bachelorarbeit/Program/recordings/"

# fingerprinting based on energy difference
import fingerprint_energy_diff

import logging
# Logging all above INFO level, output to stderr
logging.basicConfig(#format='%(asctime)s %(levelname)-8s %(message)s')
                    format='%(levelname)-8s %(message)s')
log = logging.getLogger("fuzzy_pairing")
log.setLevel(logging.DEBUG)


# load channels:
left_channel, samplerate = load_mono(base+'1.5_3/high/music5.wav')
right_channel, samplerate = load_mono(base+'1.5_3/high/music1.wav')


# fingerprint energy diff
fingerprint_left = fingerprint_energy_diff.get_fingerprint(left_channel, samplerate)
fingerprint_right = fingerprint_energy_diff.get_fingerprint(right_channel, samplerate)

print repr(fingerprint_left)
print repr(fingerprint_right)

# calculate hamming distance between fingerprints
distance = hamming_distance(fingerprint_left, fingerprint_right)
length = len(fingerprint_left)
print length, distance
print('Correlation %: '+str(1-float(distance)/float(length)))
log.setLevel(logging.DEBUG)


path = "/home/ds1/Projekte/Fuzzy Pairing Paper/Versuche Audiodateien/"


matrix = list()
      
# get all files in all subdirectories etc.
for root, dirs, files in os.walk(path):
    for name in files:
        filename = os.path.join(root, name)
        print filename
       
        print "current file is: " + name
        mono_channel, samplerate = load_mono(filename)
        
        # fingerprint energy diff
        fingerprint = fingerprint_energy_diff.get_fingerprint(mono_channel, samplerate)
        
        # you can add more analysis using helper_analysis here
        # and write the results in the matrix for further analyzing

        matrix.append([filename,fingerprint])

print matrix

# save it with pickle, can later be analyzed
with file('analysis_matrix.txt', 'wr') as f:
    pickle.dump(matrix, f)