helpers/music_file.py

   1 import threading
   2 import pydub
   3 import time
   4 from transitions.extensions import HierarchicalMachine as Machine
   5
   6 import pyaudio as pa
   7 import sounddevice as sd
   8 import os.path
   9
  10 from .lock import Lock
  11 from . import gain
  12
  13 file_lock = Lock("file")
  14
  15 pyaudio = pa.PyAudio()
  16
  17 class MusicFile(Machine):
  18     def __init__(self, filename, mapping, name = None, gain = 1):
  19         states = [
  20             'initial',
  21             'loading',
  22             'failed',
  23             { 'name': 'loaded', 'children': ['stopped', 'playing', 'paused', 'stopping'] }
  24         ]
  25         transitions = [
  26             { 'trigger': 'load', 'source':  'initial', 'dest': 'loading'},
  27             { 'trigger': 'fail', 'source':  'loading', 'dest': 'failed'},
  28             { 'trigger': 'success', 'source':  'loading', 'dest': 'loaded_stopped'},
  29             { 'trigger': 'start_playing', 'source':  'loaded_stopped', 'dest': 'loaded_playing'},
  30             { 'trigger': 'pause', 'source':  'loaded_playing', 'dest': 'loaded_paused'},
  31             { 'trigger': 'unpause', 'source':  'loaded_paused', 'dest': 'loaded_playing'},
  32             { 'trigger': 'stop_playing', 'source': ['loaded_playing','loaded_paused'], 'dest': 'loaded_stopping'},
  33             { 'trigger': 'stopped', 'source':  'loaded_stopping', 'dest': 'loaded_stopped'}
  34         ]
  35
  36         Machine.__init__(self, states=states, transitions=transitions, initial='initial')
  37
  38         self.volume = 100
  39         self.mapping = mapping
  40         self.filename = filename
  41         self.stream = None
  42         self.name = name or filename
  43         self.audio_segment = None
  44         self.volume_factor = gain
  45         self.music_lock = Lock("music__" + filename)
  46         self.wait_event = threading.Event()
  47
  48         threading.Thread(name = "MSMusicLoad", target = self.load).start()
  49
  50     def on_enter_loading(self):
  51         with file_lock:
  52             try:
  53                 print("Loading « {} »".format(self.name))
  54                 db_gain = gain(self.volume_factor * 100)
  55                 self.audio_segment = pydub.AudioSegment.from_file(self.filename).set_frame_rate(44100).apply_gain(db_gain)
  56                 self.sound_duration = self.audio_segment.duration_seconds
  57             except Exception as e:
  58                 print("failed to load « {} »: {}".format(self.name, e))
  59                 self.loading_error = e
  60                 self.fail()
  61             else:
  62                 self.success()
  63                 print("Loaded « {} »".format(self.name))
  64
  65     def check_is_loaded(self):
  66         return self.state.startswith('loaded_')
  67
  68     def is_not_stopped(self):
  69         return self.check_is_loaded() and not self.is_loaded_stopped()
  70
  71     def is_paused(self):
  72         return self.is_loaded_paused()
  73
  74     @property
  75     def sound_position(self):
  76         if self.is_not_stopped():
  77             return self.current_frame / self.current_audio_segment.frame_rate
  78         else:
  79             return 0
  80
  81     def play(self, fade_in = 0, volume = 100, start_at = 0):
  82         db_gain = gain(volume) + self.mapping.master_gain
  83         self.volume = volume
  84
  85         ms = int(start_at * 1000)
  86         ms_fi = max(1, int(fade_in * 1000))
  87         with self.music_lock:
  88             self.current_audio_segment = (self.audio_segment + db_gain).fade(from_gain=-120, duration=ms_fi, start=ms)
  89         self.before_loaded_playing(initial_frame = int(start_at * self.audio_segment.frame_rate))
  90         self.start_playing()
  91
  92     def before_loaded_playing(self, initial_frame = 0):
  93         self.current_frame = initial_frame
  94         with self.music_lock:
  95             segment = self.current_audio_segment
  96
  97             self.stream = sd.RawOutputStream(samplerate=segment.frame_rate,
  98                             channels=segment.channels,
  99                             dtype='int' + str(8*segment.sample_width), # FIXME: ?
 100                             latency=1.,
 101                             callback=self.play_callback,
 102                             finished_callback=self.finished_callback
 103                             )
 104
 105     def on_enter_loaded_playing(self):
 106         self.stream.start()
 107
 108     def on_enter_loaded_paused(self):
 109         self.stream.stop()
 110
 111     def finished_callback(self):
 112         if self.is_loaded_playing():
 113             self.stop_playing()
 114         if self.is_loaded_stopping():
 115             self.stopped()
 116
 117     def on_enter_loaded_stopped(self):
 118         self.wait_event.set()
 119
 120     def play_callback(self, out_data, frame_count, time_info, status_flags):
 121         with self.music_lock:
 122             audio_segment = self.current_audio_segment.get_sample_slice_data(
 123                                 start_sample=self.current_frame,
 124                                 end_sample=self.current_frame + frame_count
 125                                 )
 126             self.current_frame += frame_count
 127             if len(audio_segment) == 0:
 128                 raise sd.CallbackStop
 129
 130             out_data[:] = audio_segment.ljust(len(out_data), b'\0')
 131
 132     def stop(self, fade_out = 0, wait = False):
 133         if self.is_loaded_playing():
 134             ms = int(self.sound_position * 1000)
 135             ms_fo = max(1, int(fade_out * 1000))
 136
 137             with self.music_lock:
 138                 self.current_audio_segment = self.current_audio_segment[:ms + ms_fo].fade_out(ms_fo)
 139                 self.stop_playing()
 140             if wait:
 141                 self.wait_end()
 142         else:
 143             self.stop_playing()
 144             self.stopped()
 145
 146     def set_gain(self, db_gain):
 147         if not self.is_not_stopped():
 148             return
 149
 150         new_audio_segment = self.current_audio_segment + db_gain
 151
 152         with self.music_lock:
 153             self.current_audio_segment = new_audio_segment
 154
 155     def set_volume(self, value, add = False):
 156         [db_gain, self.volume] = gain(value + int(add) * self.volume, self.volume)
 157
 158         self.set_gain(db_gain)
 159
 160     def wait_end(self):
 161         self.wait_event.clear()
 162         self.wait_event.wait()
 163
 164 # Add some more functions to AudioSegments
 165 def get_sample_slice_data(self, start_sample=0, end_sample=float('inf')):
 166     max_val = int(self.frame_count())
 167
 168     start_i = max(start_sample, 0) * self.frame_width
 169     end_i =   min(end_sample, max_val) * self.frame_width
 170
 171     return self._data[start_i:end_i]
 172
 173 pydub.AudioSegment.get_sample_slice_data = get_sample_slice_data