def stream_file(info, filename): def progress_stream_wrapper(stream) -> miniaudio.PlaybackCallbackGeneratorType: framecount = yield(b"") try: while True: framecount = yield stream.send(framecount) print(".", end="", flush=True) except StopIteration: return output_format = info.sample_format try: filestream = miniaudio.stream_file(filename, output_format=output_format, sample_rate=info.sample_rate) except miniaudio.MiniaudioError as x: print("Cannot create optimal stream:", x) print("Creating stream with different sample format!") output_format = miniaudio.SampleFormat.SIGNED16 filestream = miniaudio.stream_file(filename, output_format=output_format, sample_rate=info.sample_rate, dither=miniaudio.DitherMode.TRIANGLE) stream = progress_stream_wrapper(filestream) next(stream) # start the generator with miniaudio.PlaybackDevice(output_format=output_format, sample_rate=info.sample_rate) as device: print("playback device backend:", device.backend, device.format.name, device.sample_rate, "hz") print("Audio file playing in the background. Enter to stop playback: ") device.start(stream) input()
def play(self): stream = miniaudio.stream_file(self.file_path) with miniaudio.PlaybackDevice() as device: device.start(stream) input( "Audio file playing in the background. Enter to stop playback: " )
def __init__(self): super().__init__() default_font = nametofont("TkDefaultFont") default_font.configure(size=12) self.wm_title("Python ModPlayer -- libxmplite v{} -- xmp v{}".format(libxmplite.__version__, libxmplite.xmp_version)) self.load_button = tkinter.Button(self, text="Load module", command=self.load_module, bg="teal") self.load_button.pack(anchor=tkinter.W) # self.load_button = tkinter.Button(self, text="Pause/Unpause", command=self.pause) # self.load_button.pack() info_frame = tkinter.Frame(self, width=10) info_frame.title_label = tkinter.Label(info_frame, text="title") info_frame.title_label.grid(row=0, column=0, padx=10, sticky=tkinter.E) info_frame.type_label = tkinter.Label(info_frame, text="type") info_frame.type_label.grid(row=1, column=0, padx=10, sticky=tkinter.E) info_frame.channels_label = tkinter.Label(info_frame, text="channels") info_frame.channels_label.grid(row=2, column=0, padx=10, sticky=tkinter.E) info_frame.bpm_label = tkinter.Label(info_frame, text="bpm") info_frame.bpm_label.grid(row=3, column=0, padx=10, sticky=tkinter.E) info_frame.time_label = tkinter.Label(info_frame, text="time") info_frame.time_label.grid(row=5, column=0, padx=10, sticky=tkinter.E) info_frame.pos_label = tkinter.Label(info_frame, text="pos") info_frame.pos_label.grid(row=6, column=0, padx=10, sticky=tkinter.E) info_frame.pat_label = tkinter.Label(info_frame, text="pat") info_frame.pat_label.grid(row=7, column=0, padx=10, sticky=tkinter.E) info_frame.row_label = tkinter.Label(info_frame, text="row") info_frame.row_label.grid(row=8, column=0, padx=10, sticky=tkinter.E) info_frame.title_e = tkinter.Label(info_frame, relief=tkinter.SUNKEN) info_frame.title_e.grid(row=0, column=1, sticky=tkinter.W) info_frame.type_e = tkinter.Label(info_frame, relief=tkinter.SUNKEN) info_frame.type_e.grid(row=1, column=1, sticky=tkinter.W) info_frame.channels_e = tkinter.Label(info_frame, relief=tkinter.SUNKEN) info_frame.channels_e.grid(row=2, column=1, sticky=tkinter.W) info_frame.bpm_e = tkinter.Label(info_frame, relief=tkinter.SUNKEN) info_frame.bpm_e.grid(row=3, column=1, sticky=tkinter.W) info_frame.time_e = tkinter.Label(info_frame, relief=tkinter.SUNKEN) info_frame.time_e.grid(row=5, column=1, sticky=tkinter.W) info_frame.pos_e = tkinter.Label(info_frame, relief=tkinter.SUNKEN) info_frame.pos_e.grid(row=6, column=1, sticky=tkinter.W) info_frame.pat_e = tkinter.Label(info_frame, relief=tkinter.SUNKEN) info_frame.pat_e.grid(row=7, column=1, sticky=tkinter.W) info_frame.row_e = tkinter.Label(info_frame, relief=tkinter.SUNKEN) info_frame.row_e.grid(row=8, column=1, sticky=tkinter.W) self.info_frame = info_frame self.info_frame.columnconfigure(1, minsize=200) self.info_frame.rowconfigure(4, minsize=20) self.info_frame.pack(side=tkinter.LEFT, padx=10, fill=tkinter.X, expand=tkinter.YES) tracks_holder = tkinter.Frame(relief=tkinter.RIDGE, height=256, width=200) self.tracks_holder = tracks_holder self.tracks_holder.pack(fill=tkinter.X, expand=tkinter.YES, padx=16, pady=16) # pbstyle = tkinter.ttk.Style() # pbstyle.theme_use("classic") self.audiodevice = miniaudio.PlaybackDevice(output_format=miniaudio.SampleFormat.SIGNED16, nchannels=2, sample_rate=44100) self.xmp = libxmplite.Xmp() self.tracks = [] self.playing = False self.previous_update_time = 0
def play(song_name): """Function used for playing audio from Storage folder""" import miniaudio stream = miniaudio.stream_file('Storage/' + song_name) with miniaudio.PlaybackDevice() as device: device.start(stream) input("Audio file playing in the background. Enter to stop playback: ") pass
def _start_device(self): with miniaudio.PlaybackDevice( output_format=miniaudio.SampleFormat.SIGNED16, backends=[miniaudio.Backend.PULSEAUDIO], nchannels=CHANNELS, sample_rate=SAMPLE_RATE) as device: generator = self._read_frames() next(generator) device.start(generator) self.running.acquire() # keep the thread running or else audio stops
def __init__(self, samplerate: int = 0, samplewidth: int = 0, nchannels: int = 0, queue_size: int = 100) -> None: super().__init__(samplerate, samplewidth, nchannels, queue_size=queue_size) self.command_queue = queue.Queue(maxsize=queue_size) # type: queue.Queue[Dict[str, Any]] output_format = { 1: miniaudio.SampleFormat.UNSIGNED8, 2: miniaudio.SampleFormat.SIGNED16, 3: miniaudio.SampleFormat.SIGNED24, 4: miniaudio.SampleFormat.SIGNED32 }[self.samplewidth] self.device = miniaudio.PlaybackDevice(output_format, self.nchannels, self.samplerate) stream = self.generator() next(stream) # start generator self.device.start(stream)
def test_stop_callback_playback(backends, jackd_server): stop_callback = mock.Mock() playback = miniaudio.PlaybackDevice(backends=backends) gen = dummy_generator() next(gen) playback.start(gen, stop_callback) assert playback.running is True # Simulate an unexpected stop. miniaudio.lib.ma_device_stop(playback._device) stop_callback.assert_called_once() assert playback.running is False
def __init__(self, samplerate: int = 0, samplewidth: int = 0, nchannels: int = 0, frames_per_chunk: int = 0) -> None: super().__init__(samplerate, samplewidth, nchannels, frames_per_chunk, 0) self.mixed_chunks = self.mixer.chunks() output_format = { 1: miniaudio.SampleFormat.UNSIGNED8, 2: miniaudio.SampleFormat.SIGNED16, 3: miniaudio.SampleFormat.SIGNED24, 4: miniaudio.SampleFormat.SIGNED32 }[self.samplewidth] buffersize_msec = self.nchannels * 1000 * self.frames_per_chunk // self.samplerate self.mixed_chunks = self.mixer.chunks() self.device = miniaudio.PlaybackDevice(output_format, self.nchannels, self.samplerate, buffersize_msec) stream = self.generator() next(stream) # start generator self.device.start(stream)
def unpause(self): if self._played: return if not self._paused or self._device is None: raise RuntimeError("Cannot unpause invalid playback") self._device = miniaudio.PlaybackDevice( output_format=miniaudio.SampleFormat.SIGNED16, nchannels=self._channels, sample_rate=self._sample_rate) self._device.start(self._stream) self._played = True self._paused = False
def play(self): if self._played: raise RuntimeError("Cannot be played again") if not self._paused: self._device = miniaudio.PlaybackDevice( output_format=miniaudio.SampleFormat.SIGNED16, nchannels=self._channels, sample_rate=self._sample_rate) self._stream = self.__sound_callback() next(self._stream) self._device.start(self._stream) self._played = True self._paused = False
def run_radio(q): def title_printer(client: miniaudio.IceCastClient, new_title: str) -> None: print("Stream title: ", new_title) with miniaudio.IceCastClient("http://23.237.150.178:9002", update_stream_title=title_printer) as source: #print("Connected to internet stream, audio format:", source.audio_format.name) #print("Station name: ", source.station_name) #print("Station genre: ", source.station_genre) #print("Press <enter> to quit playing.\n") stream = miniaudio.stream_any(source, source.audio_format) with miniaudio.PlaybackDevice() as device: device.start(stream) something = q.get() print(something)
def stream_file(info, filename): if info.file_format == miniaudio.FileFormat.FLAC: fstream = miniaudio.flac_stream_file(filename) elif info.file_format == miniaudio.FileFormat.MP3: fstream = miniaudio.mp3_stream_file(filename) elif info.file_format == miniaudio.FileFormat.VORBIS: fstream = miniaudio.vorbis_stream_file(filename) elif info.file_format == miniaudio.FileFormat.WAV: fstream = miniaudio.wav_stream_file(filename) else: raise IOError("unsupported audio file format") stream = playback_stream(fstream, info.nchannels) next(stream) # start the generator with miniaudio.PlaybackDevice(output_format=info.sample_format, sample_rate=info.sample_rate, nchannels=info.nchannels) as play: play.start(stream) input("Audio file playing in the background. Enter to stop playback: ")
def stream_file(filename): def progress_stream_wrapper(stream) -> miniaudio.AudioProducerType: framecount = yield(b"") try: while True: framecount = yield stream.send(framecount) print(".", end="", flush=True) except StopIteration: return stream = progress_stream_wrapper(miniaudio.stream_file(filename)) next(stream) # start the generator device = miniaudio.PlaybackDevice() print("playback device backend:", device.backend) device.start(stream) input("Audio file playing in the background. Enter to stop playback: ") device.close()
def play(self) -> bool: try: media = requests.get(self.stream, stream=True).raw except requests.exceptions.MissingSchema: return False channels: int = 2 sample_rate: int = 44100 device = miniaudio.PlaybackDevice() stream = miniaudio.stream_any( source=media, source_format=miniaudio.FileFormat.MP3, nchannels=channels, sample_rate=sample_rate, ) device.start(stream) time.sleep(self.duration) device.close() return True
def __init__(self, awsHelper, cache): self._awsHelper = awsHelper self._device = miniaudio.PlaybackDevice()
""" Listing and Choosing the audio device to play on. """ import os import miniaudio def samples_path(filename): return os.path.join(os.path.abspath(os.path.dirname(__file__)), 'samples', filename) def choose_device(): devices = miniaudio.Devices() print("Available playback devices:") playbacks = devices.get_playbacks() for d in enumerate(playbacks, 1): print("{num} = {name}".format(num=d[0], name=d[1]['name'])) choice = int(input("play on which device? ")) return playbacks[choice-1] if __name__ == "__main__": selected_device = choose_device() stream = miniaudio.stream_file(samples_path("music.mp3")) device = miniaudio.PlaybackDevice(device_id=selected_device["id"]) device.start(stream) input("Audio file playing in the background. Enter to stop playback: ")
def notificacion(self): stream = miniaudio.stream_file("notify.mp3") device = miniaudio.PlaybackDevice() device.start(stream) sleep(2) device.close()
def playAudioInBackground(self): stream = miniaudio.stream_file("output.wav") with miniaudio.PlaybackDevice() as device: device.start(stream) input("Audio file playing in the background. Enter to stop playback: ")
def play_pcm(source, channels, sample_rate, format_type, field_size, signedness, endian, start=None, end=None, length=None, interpolation=AudioInterpolation.LINEAR): """Play back a byte string as PCM audio. source The byte string to play. channels Number of audio channels. sample_rate Audio sample rate in Hz. format_type Type of sample encoding; either int or float. field_size Size of each sample, in bytes. signedness Signedness of each sample; either 'signed' or 'unsigned'. endian Endianness of each sample; either 'big', 'little' or None. start Start offset to read from (default: start). end End offset to stop reading at (default: end). length Length to read in (optional replacement for end). interpolation Interpolation algorithm to use for upsampling. Defaults to AudioInterpolation.LINEAR. """ assert is_bytes(source) start, end = bounds(start, end, length, len(source)) if not miniaudio: raise ImportError( 'miniaudio must be installed for audio playback support (see https://github.com/irmen/pyminiaudio)' ) format = getattr(miniaudio.SampleFormat, MINIAUDIO_NORMALISE_TYPE) playback_rate = None INTERP_MAP = { AudioInterpolation.NONE: miniaudio.DitherMode.NONE, AudioInterpolation.LINEAR: miniaudio.DitherMode.TRIANGLE, AudioInterpolation.STEP: miniaudio.DitherMode.RECTANGLE, } interpolation = INTERP_MAP.get(interpolation, miniaudio.DitherMode.NONE) FORMAT_MAP = { (int, 1, 'unsigned', None): miniaudio.SampleFormat.UNSIGNED8, (int, 2, 'signed', 'little'): miniaudio.SampleFormat.SIGNED16, (int, 3, 'signed', 'little'): miniaudio.SampleFormat.SIGNED24, (int, 4, 'signed', 'little'): miniaudio.SampleFormat.SIGNED32, (float, 4, 'signed', 'little'): miniaudio.SampleFormat.FLOAT32, } format = FORMAT_MAP.get((format_type, field_size, signedness, endian)) if not format: raise ValueError('Format not supported yet!') with miniaudio.PlaybackDevice(output_format=format, nchannels=channels, sample_rate=PLAYBACK_RATE) as device: def audio_iter(): conv = miniaudio.convert_frames(format, channels, sample_rate, source[start:end], device.format, device.nchannels, device.sample_rate) samp_iter = iter(conv) required_frames = yield b'' old_time = time.time() while True: sample_data = bytes( itertools.islice(samp_iter, required_frames * channels * field_size)) if not sample_data: break new_time = time.time() old_time = new_time required_frames = yield sample_data ai = audio_iter() next(ai) device.start(ai) while device.callback_generator: time.sleep(0.1)
required_frames = yield b"" # generator initialization try: while True: buffer = xmp.play_buffer(required_frames * 2 * 2) display.update(xmp.frame_info()) required_frames = yield buffer except libxmplite.XmpError as x: print("XMP Playback error!!", x) if __name__ == "__main__": if len(sys.argv) != 2: raise SystemExit("must give mod filename to play as argument") device = miniaudio.PlaybackDevice( output_format=miniaudio.SampleFormat.SIGNED16, nchannels=2, sample_rate=44100) xmp = libxmplite.Xmp() xmp.load(sys.argv[1]) xmp.start(device.sample_rate) mod_info = xmp.module_info() display = Display(mod_info) stream = stream_module(xmp, display) next(stream) # start the generator device.start(stream) print("\nFile playing in the background. Press enter to stop playback!\n") input()
""" Simplest example of decoding and playing an audio file """ import os import miniaudio def samples_path(filename): return os.path.join(os.path.abspath(os.path.dirname(__file__)), 'samples', filename) stream = miniaudio.stream_file(samples_path("music.mp3"), dither=miniaudio.DitherMode.TRIANGLE) device = miniaudio.PlaybackDevice() device.start(stream) input("Audio file playing in the background. Enter to stop playback: ") device.close()
channels = 2 sample_rate = 48000 sample_width = 4 # 32bit float def stream_pcm(source): required_frames = yield b"" # generator initialization while True: required_bytes = required_frames * channels * sample_width sample_data = source.read(required_bytes) if not sample_data: break # print(".", end="", flush=True) required_frames = yield sample_data with miniaudio.PlaybackDevice(output_format=miniaudio.SampleFormat.FLOAT32, nchannels=channels, sample_rate=sample_rate) as device: fmradion = subprocess.Popen([ "airspy-fmradion", "-E100", "-b0.001", "-t", "airspyhf", "-c", "freq=" + str(freq), "-F", "-" ], stdin=None, stdout=subprocess.PIPE) stream = stream_pcm(fmradion.stdout) next(stream) device.start(stream) input("Enter to stop playback\n") fmradion.terminate()
def son_chrono(): stream = miniaudio.stream_file("buzzer1.mp3") device = miniaudio.PlaybackDevice() device.start(stream) input("\n Appuyer sur Enter pour passer à la suite du programme :") device.close()
""" Simplest example of decoding and playing an audio file """ import os import miniaudio def samples_path(filename): return os.path.join(os.path.abspath(os.path.dirname(__file__)), 'samples', filename) stream = miniaudio.stream_file(samples_path("music.mp3"), dither=miniaudio.DitherMode.TRIANGLE) with miniaudio.PlaybackDevice() as device: device.start(stream) input("Audio file playing in the background. Enter to stop playback: ")
def fbi_ACDC(): stream = miniaudio.stream_file("Thunderstruck.mp3") device = miniaudio.PlaybackDevice() device.start(stream) input("\n Appuyer sur Enter pour terminer l'exercice :") device.close()
def main(config: str, make_config: bool) -> None: """ This is a module which implements realtime polyphonic FM synthesis in Python controllable by MIDI. Note that this is very CPU-intensive. It's got the following features: - configurable polyphony; - AD envelope (no sustain yet); - dispatches MIDI IN events like NOTE_ON and NOTE_OFF events to the synthesizer. To use this yourself, you will need: - a MIDI IN port, can be virtual (I'm using IAC in Audio MIDI Setup on macOS); - an AUDIO OUT, can be virtual (I'm using BlackHole on macOS); - a DAW project which will be configured as follows (Renoise as an example): - a MIDI Instrument in the DAW configured to output notes to the MIDI port that fmsynth listens on (I call my virtual MIDI port "IAC fmsynth"); - a #Line Input routing in the DAW configured to catch audio from the out that fmsynth (like "BlackHole 16ch 1+2"); - turn on "MIDI Return Mode" to compensate latency; - in Ableton Live use "External Instrument" to do this in one place and automatically compensate latency. You can customize the ports by creating a config file. Use `--make-config` to output a new config to stdout. Then run `python -m aiotone.fmsynth --config=PATH_TO_YOUR_CONFIG_FILE`. """ if make_config: with open(CURRENT_DIR / "aiotone-fmsynth.ini") as f: print(f.read()) return cfg = configparser.ConfigParser() cfg.read(config) devices = miniaudio.Devices() playbacks = devices.get_playbacks() audio_out = cfg["audio-out"]["out-name"] sample_rate = cfg["audio-out"].getint("sample-rate") buffer_msec = cfg["audio-out"].getint("buffer-msec") polyphony = cfg["audio-out"].getint("polyphony") for playback in playbacks: if playback["name"] == audio_out: play_id = playback["id"] break else: raise click.UsageError(f"No audio out available called {audio_out}") with miniaudio.PlaybackDevice( device_id=play_id, nchannels=2, sample_rate=sample_rate, output_format=miniaudio.SampleFormat.SIGNED16, buffersize_msec=buffer_msec, ) as dev: synth = Synthesizer(sample_rate=sample_rate, polyphony=polyphony) stream = synth.stereo_out() init(stream) dev.start(stream) try: asyncio.run(async_main(synth, cfg["midi-in"])) except KeyboardInterrupt: pass
filename = "samples/music.m4a" # AAC encoded audio file def stream_pcm(source): required_frames = yield b"" # generator initialization while True: required_bytes = required_frames * channels * sample_width sample_data = source.read(required_bytes) if not sample_data: break print(".", end="", flush=True) required_frames = yield sample_data device = miniaudio.PlaybackDevice(ma_output_format=miniaudio.ma_format_s16, nchannels=channels, sample_rate=sample_rate) ffmpeg = subprocess.Popen([ "ffmpeg", "-v", "fatal", "-hide_banner", "-nostdin", "-i", filename, "-f", "s16le", "-acodec", "pcm_s16le", "-ac", str(channels), "-ar", str(sample_rate), "-" ], stdin=None, stdout=subprocess.PIPE) stream = stream_pcm(ffmpeg.stdout) next(stream) # start the generator device.start(stream) input("Audio file playing in the background. Enter to stop playback: ") device.close() ffmpeg.terminate()