On 8/16/21, Roel Schroeven <roel@roelschroeven.net> wrote:
>
> We're not necessarily talking about the PC speaker here: (almost) all
> computers these days have sound cards (mostly integrated on the
> motherboard) that are much more capable than those one-bit PC speakers.

Yes, the PC speaker beep does not get used in Windows 7+. The beep
device object is retained for compatibility, but it redirects the
request to a task in the user's session (which could be a remote
desktop session) that generates a WAV buffer in memory and plays it
via PlaySound(). You can do this yourself if you need a more precise
frequency. For example:

import io
import math
import wave
import winsound

def beep(frequency, duration):
'''Play a beep at frequency (hertz) for duration (milliseconds).'''
fs = 48000
f = 2 * math.pi * frequency / fs
n = round(duration * fs / 1000)
b = io.BytesIO()
w = wave.Wave_write(b)
w.setnchannels(1)
w.setsampwidth(2)
w.setframerate(fs)
w.writeframes(b''.join(round(32767 * math.sin(f*i)).to_bytes(
2, 'little', signed=True) for i in range(n)))
w.close()
winsound.PlaySound(b.getbuffer(), winsound.SND_MEMORY)

Play a beep at 277.1826 Hz for one second:

beep(277.1826, 1000)

I'm tone deaf, I suppose, since I need a difference of about 3 cycles
to perceive it, let alone a fraction of a cycle.

Eryk Sun <eryksun@gmail.com> writes:
>def beep(frequency, duration):
> '''Play a beep at frequency (hertz) for duration (milliseconds).'''
> fs = 48000
> f = 2 * math.pi * frequency / fs
> n = round(duration * fs / 1000)
> b = io.BytesIO()
> w = wave.Wave_write(b)
> w.setnchannels(1)
> w.setsampwidth(2)
> w.setframerate(fs)
> w.writeframes(b''.join(round(32767 * math.sin(f*i)).to_bytes(
> 2, 'little', signed=True) for i in range(n)))
> w.close()
> winsound.PlaySound(b.getbuffer(), winsound.SND_MEMORY)

Thanks for this very instructive example! I wondered whether
it is possible to play a melody this way and extended your
example. (The program allocates large buffers, which might
lead to problems on systems which do not have more than 1 GB
of main memory.)

To hear some variations, one can first hear it as is, then
try "reverb = False" below and then (keeping "reverb = False")
"instrument = 1" instead of "instrument = 0".

# Plays BWV 846 on Windows
# # requires:
# - Python 3.9
# - winsound (i.e., Windows)

# Created 2021-08/2021-09 # Stefan Ram
# Cleaned up 2021-12/2022-01/2022-05 # Stefan Ram

import io
import math
import wave
import winsound
import random
import array
import sys
import time
from math import sin

anti_click = True
sine = False
hull_curve = True
intro = True
reverb = True
noise = True
randomness_intensities = True
instrument = 0

if noise:
strong_noise = lambda x:( random.random() - 0.5 )* x/2 + x
weak_noise = lambda x:( random.random() - 0.5 )* x/5 + x
else:
strong_noise = lambda x: x
weak_noise = lambda x: x

def initialize_frame_buffer():
estimated_duration_in_seconds = 140
frame_buffer_size = estimated_duration_in_seconds * frames_per_second
global frame_values
frame_values =[ 0 ]* frame_buffer_size
del frame_buffer_size
global write_position
write_position = 0

def initialize_reverb_buffers():
global reverb_buffer_size
reverb_buffer_size = 10000
global reverb_buffer
reverb_buffer =[ 0.0 ]* reverb_buffer_size
global primary_reverb_buffer_position
primary_reverb_buffer_position = 0

global size_of_the_second_reverb_buffer
size_of_the_second_reverb_buffer =22768
global second_reverb_buffer
second_reverb_buffer =[ 0.0 ]*size_of_the_second_reverb_buffer
global second_reverb_buffer_position
second_reverb_buffer_position = 0

def initialize():
global frames_per_second
frames_per_second = 48000

print( "Program might need about 1 GB of main memory.\nPlease "+
"be patient." )

initialize_frame_buffer()
initialize_reverb_buffers()
record_signal_for_reverb( 0 )

global number_of_tones_or_pauses_inserted
number_of_tones_or_pauses_inserted = 0

def record_signal_for_reverb( signal ):
global reverb_buffer_is_initialized
global primary_reverb_buffer_position
global second_reverb_buffer_position
reverb_buffer[ primary_reverb_buffer_position ]= signal
primary_reverb_buffer_position += 1
primary_reverb_buffer_position %= reverb_buffer_size
second_reverb_buffer[ second_reverb_buffer_position ]= signal
second_reverb_buffer_position += 1
second_reverb_buffer_position %= size_of_the_second_reverb_buffer
return signal

def some_reverb():
return reverb_buffer[ primary_reverb_buffer_position ]* 0.3 +\
second_reverb_buffer[ second_reverb_buffer_position ]* 0.1

def free_reverb_buffer_memory():
global reverb_buffer
reverb_buffer = None
del reverb_buffer

global second_reverb_buffer
second_reverb_buffer = None
del second_reverb_buffer

def show_progress():
global number_of_tones_or_pauses_inserted
text = "Please stand by while I'm filling the buffer!"
if number_of_tones_or_pauses_inserted % 20 == 0:
cd = 545 + 69 - number_of_tones_or_pauses_inserted
cdp = int( cd / 620 * 100 )
print( "About "+ str( cdp )+" % to go. " + text )
number_of_tones_or_pauses_inserted += 1

def integral_duration_of( duration ):
"convert from duration in milliseconds to duration in frames"
return round( duration * frames_per_second / 1000 )

def hull_curve_of( frame_number, integral_duration ):
'''
preconditions:
frame_number <= integral_duration
integral_duration > -1
/`-.
ADSR
attack-decay-sustain-release curve
attack: rise to maximum_intensity until end_of_attack,
decay: then fall to 1 until end_of_decay,
sustain: then, sustain the value of 1 until
integral_duration - initial_duration,
release: finally, fall to 0 until integral_duration
'''
initial_duration = 600
maximum_intensity = 1.2
end_of_attack = maximum_intensity * initial_duration
end_of_decay = end_of_attack +( maximum_intensity - 1 )*\
initial_duration
if frame_number < end_of_attack: # A - attack from 0 to
# maximum_intensity, reaching 1 at initial_duration
hull_curve = frame_number / initial_duration
elif frame_number < end_of_decay:
# D - decay from maximum_intensity to 1
width_of_decay = end_of_decay - end_of_attack
goes_from_0_to_1 =( frame_number - end_of_attack )\
/width_of_decay
goes_from_maximum_intensity_to_0 = maximum_intensity *\
( end_of_decay - frame_number )/ width_of_decay
hull_curve = goes_from_0_to_1 +\
goes_from_maximum_intensity_to_0
elif integral_duration - initial_duration < frame_number:
# R release
hull_curve =( integral_duration - frame_number )\
/ initial_duration
else: # S - sustain at 1
hull_curve = 1
return hull_curve

def accompanying_hull_curve_of\
( frame_number, frequency_multiplier,
attack_duration, attack_duration_ ):
'''
/\
AD
attack-decay curve
attack: rise to maximum_intensity until ...
decay: then fall to 0 until ...
'''
if frame_number - frequency_multiplier < attack_duration_:
if frame_number < attack_duration:
# A - attack
hull_curve_for_accompanying_sound = \
frame_number / attack_duration
else:
# D - decay
hull_curve_for_accompanying_sound = \
1 -( frame_number - attack_duration )/attack_duration_
else:
hull_curve_for_accompanying_sound = 0
return hull_curve_for_accompanying_sound

def record_instrument_value( instrument_value ):
global write_position
frame_value = instrument_value
if reverb:
frame_value += some_reverb()
record_signal_for_reverb( frame_value )
frame_values[ write_position ]= round( 32767/3 * frame_value )
write_position+=1

class instrument0:
halftone_step = 2**( 1/12 )
base_duration = 4
attack_duration = base_duration * 60
release_duration = base_duration * 100
frequency_factor = 5 * halftone_step
base_duration_1 = 5
attack_duration_1 = base_duration_1 * 100
release_duration_1 = base_duration_1 * 240
frequency_factor_1 =( 12 + 5 )* halftone_step
frequency_multiplier = 0
def instrument_of( self, frame_number ):
current_angle = self.frequency_multiplier * frame_number

hull_curve = \
hull_curve_of( frame_number, self.integral_duration )

if sine:
if hull_curve:
frame_value = hull_curve *( sin( current_angle ) )
else:
frame_value = sin( current_angle )
else:
if hull_curve:
frame_value = \
hull_curve *\
( sin( current_angle )+
sin( 2 * current_angle )/3 +
sin( 4 * current_angle )/6 +
sin( 8 * current_angle )/12 )
if intro:
hull_curve_for_accompanying_sound = \
accompanying_hull_curve_of\
( frame_number, self.frequency_multiplier,
self.attack_duration, self.release_duration )
if hull_curve_for_accompanying_sound:
frame_value += \
strong_noise\
( self.intensity_of_first_accompanying_sound *
hull_curve_for_accompanying_sound *
sin( self.frequency_factor * current_angle ))
hull_curve_for_second_accompanying_sound = \
accompanying_hull_curve_of\
( frame_number, self.frequency_multiplier,
self.attack_duration_1, self.release_duration_1 )
if hull_curve_for_second_accompanying_sound:
frame_value += \
strong_noise\
( self.intensity_of_second_accompanying_sound * \
hull_curve_for_second_accompanying_sound * \
sin( self.frequency_factor_1 * current_angle ))
else:
frame_value =\
( sin( current_angle )+
sin( 2 * current_angle )/3 +
sin( 4 * current_angle )/6 +
sin( 8 * current_angle )/12 )
return weak_noise( frame_value )