Звуковые генераторы

FREQ = 11025
CHANNELS = 1
TICK = 2000
 
sound_volume( 64 )
 
per = new_array( 60 )
p = 0
per[ p ] = 1712 p + 1 per[ p ] = 1616 p + 1 per[ p ] = 1524 p + 1 per[ p ] = 1440 p + 1 
per[ p ] = 1356 p + 1 per[ p ] = 1280 p + 1 per[ p ] = 1208 p + 1 per[ p ] = 1140 p + 1 
per[ p ] = 1076 p + 1 per[ p ] = 1016 p + 1 per[ p ] = 960 p + 1 per[ p ] = 906 p + 1
per[ p ] = 856 p + 1 per[ p ] = 808 p + 1 per[ p ] = 762 p + 1 per[ p ] = 720 p + 1 
per[ p ] = 678 p + 1 per[ p ] = 640 p + 1 per[ p ] = 604 p + 1 per[ p ] = 570 p + 1
per[ p ] = 538 p + 1 per[ p ] = 508 p + 1 per[ p ] = 480 p + 1 per[ p ] = 453 p + 1
per[ p ] = 428 p + 1 per[ p ] = 404 p + 1 per[ p ] = 381 p + 1 per[ p ] = 360 p + 1 
per[ p ] = 339 p + 1 per[ p ] = 320 p + 1 per[ p ] = 302 p + 1 per[ p ] = 285 p + 1
per[ p ] = 269 p + 1 per[ p ] = 254 p + 1 per[ p ] = 240 p + 1 per[ p ] = 226 p + 1
per[ p ] = 214 p+1 per[ p ] = 202 p+1 per[ p ] = 190 p+1 per[ p ] = 180 p+1
per[ p ] = 170 p+1 per[ p ] = 160 p+1 per[ p ] = 151 p+1 per[ p ] = 143 p+1
per[ p ] = 135 p+1 per[ p ] = 127 p+1 per[ p ] = 120 p+1 per[ p ] = 113 p+1
per[ p ] = 107 p+1 per[ p ] = 101 p+1 per[ p ] = 95 p+1 per[ p ] = 90 p+1 
per[ p ] = 85 p+1 per[ p ] = 80 p+1 per[ p ] = 75 p+1 per[ p ] = 71 p+1 
per[ p ] = 67 p+1 per[ p ] = 63 p+1 per[ p ] = 60 p+1 per[ p ] = 56 p+1
 
cur_buf = -1
buf_id1 = 0
buf_id2 = 0
tick_buf1 = new_string( TICK * CHANNELS )
tick_buf2 = new_string( TICK * CHANNELS )
 
sp = 0 //Sample pointer 
prev_delta = 0
 
//##########################
//## TUNE SOURCE IS HERE: ##
//##########################
 
tune = tune1
 
tune1 = "
A4 * /
D4   /
A4 * /
F4   /
"
tune2 = "
K1 /
A0/
T0/
I5/
Y2/
A0/
P0/
E4/
T5/
R6/
O5/
V6/
A4
"
tune3 = "
G7 /
O1/
G1/
L2/
U0/
S0/
P7/
I1/
X2/
I3/
"
tune4 = "
T1/
A8/
S1/
H1/
A1/
A9/
R7/
T6/
"
 
tune_ptr = 0
 
//##########################
//##########################
//##########################
 
tune = tune1
 
start:
clear( BLUE )
print( "8bit waveform
mono 11 kHz", 0, 32, YELLOW )
t = tune - tune1 + 1
print( "Tune #$t", -get_pixi_xsize( 0 ) / 2 + 2, -30, YELLOW )
print( "Simple
Pixilang
Soft Synth", -get_pixi_xsize( 0 ) / 2 + 2, -12, WHITE )
	xx = -get_pixi_xsize( 0 ) / 2 + 90 xxp = 0
	xxsize = get_pixi_xsize( 0 ) / 2
	xxloop:
	if cur_buf = 0 { dot( xx, tick_buf1[ xxp ] / 4, WHITE ) } else { dot( xx, tick_buf2[ xxp ] / 4, WHITE ) }
	xx+2 xxp+1
	if xx < xxsize { go xxloop }
SOUND_HANDLER
handle_pen_keys( { tune + 1 if tune > tune4 { tune = tune1 } }, 0, 0 )
frame
go start
 
SOUND_HANDLER:
if cur_buf = -1 { 
	cur_buf = 0
	RENDER_BUFFER
} else {
	if cur_buf = 0 {
		if get_sound_status( 0 ) != 0 { cur_buf = 1 RENDER_BUFFER }
	} else {
		if get_sound_status( 1 ) != 0 { cur_buf = 0 RENDER_BUFFER }
	}
}
ret
 
RENDER_BUFFER:
buf = tick_buf1 + cur_buf
 
noise = 0
read_notes_loop:
if tune[ tune_ptr ] = '*' { noise = 1 }
if ( tune[ tune_ptr ] >= 'A' ) & ( tune[ tune_ptr ] <= 'Z' ) { note = tune[ tune_ptr ] - 'A' }
if ( tune[ tune_ptr ] >= '0' ) & ( tune[ tune_ptr ] <= '9' ) { oct = tune[ tune_ptr ] - '0' }
tune_ptr + 1
if tune[ tune_ptr ] = '/' { go read_ok }
if tune_ptr > get_string_size( tune ) { tune_ptr = 0 }
go read_notes_loop
read_ok:
 
delta = ( ( 3546894 / FREQ ) * 1024 ) / per[ note + oct * 12 ]
if delta > prev_delta { delta_speed = 1 } else { delta_speed - 1 }
cur_delta = prev_delta
 
bp = 0
buf_loop:
buf[ bp ] = sin( sp / 128 ) / 4
if cur_delta != delta { cur_delta + delta_speed }
sp + cur_delta
bp + 1
if bp < TICK { go buf_loop }
 
if noise {
	bp = 0
	v = 2048
	buf_loop2:
	buf[ bp ] = buf[ bp ] + ( ( ( rand & 63 ) - 31 ) * v ) / 2048
	bp + 1
	v - 1
	if v > 0 { go buf_loop2 }
}
 
prev_delta = cur_delta
 
send_sound_to( cur_buf, buf, FREQ, CHANNELS, 0 )
ret

SAMPLING_FREQ = 11025
CHANNELS = 1
LOOP = 1
 
sound = new_string( 256 )
 
i = 0
sloop:
sound[ i ] = sin( i * 16 ) / 4
i + 1
if i < 256 { go sloop }
 
send_sound( sound, SAMPLING_FREQ, CHANNELS, LOOP )
sound_volume( 64 )
 
//CREATE BACKGROUND:
back = new_pixi( get_pixi_xsize( 0 ), get_pixi_ysize( 0 ), 1 )
set_screen( back )
rand_seed( 0 )
effector( GREEN, 256, 0, -800, -800, 1600, 1600, 3 )
transp( 128 )
pixi( back, 0, 0, 4, 0 )
transp( 256 )
effector( GREEN, 4, 1, -800, -800, 1600, 1600, 1 )
effector( GREEN, 4, 2, -800, -800, 1600, 1600, 1 )
transp( 128 )
//clear( BLACK )
transp( 256 )
set_screen( 0 )
pixi_transp( back, 0 )
 
start:
pixi( back )
 
sound_size = get_string_size( sound )
alpha = ( sound_size * 256 ) / get_pixi_xsize( 0 )
ptr = 0
prev_y = 0
x = -get_pixi_xsize( 0 ) / 2
xloop:
line( x - 1, prev_y, x, sound[ ptr/256 ] / 2, GREEN )
prev_y = sound[ ptr/256 ] / 2
//dot( x, sound[ ptr / 256 ] / 2, GREEN )
ptr + alpha
x + 1
if ptr / 256 < sound_size { go xloop }
 
print( "Click on the screen
for waveform drawing", -get_pixi_xsize( 0 ) / 2 + 2, -get_pixi_ysize( 0 ) / 2 + 2, #909090 )
print( "Waveform
Generator", -get_pixi_xsize( 0 ) / 2 + 2, -get_pixi_ysize( 0 ) / 2 + 2 + 16, GREEN )
 
hkey = {
	pp = ( ( gpx + get_pixi_xsize( 0 ) / 2 ) * alpha ) / 256
	sound[ pp ] = gpy * 2
	sound[ pp-1 ] = gpy * 2
	sound[ pp+1 ] = gpy * 2
	sound[ pp-2 ] = ( sound[ pp-2 ] + gpy * 2 ) / 2
	sound[ pp+2 ] = ( sound[ pp+2 ] + gpy * 2 ) / 2
}
 
handle_keys( hkey, hkey, 0 )
 
frame
go start