// Quick test of functions
int main()
{
Blip_Buffer buf;
Blip_Synth<blip_low_quality,20> synth;
// Setup buffer
buf.clock_rate( 44100 );
if ( buf.set_sample_rate( 44100 ) )
return 1;
synth.output( &buf );
synth.volume( 0.5 );
// Add wave that goes from 0 to 50% to -50%
synth.update( 4, 10 );
synth.update( 8, -10 );
buf.end_frame( 30 );
// Read samples as this type
typedef float sample_t; // floating-point
//typedef unsigned short sample_t; // unsigned 16-bit
//typedef unsigned char sample_t; // unsigned 8-bit
// Read and display samples
const int max_samples = 30;
sample_t samples [max_samples];
int count = read_samples( buf, samples, max_samples );
for ( int i = buf.output_latency() + 1; i < count; i++ )
printf( "%.2f,", (double) samples [i] );
printf( "\n" );
return 0;
}
int main()
{
long sample_rate = 44100;
// Sample rate sets how many samples are generated per second
if ( buf.set_sample_rate( sample_rate ) )
return 1; // out of memory
buf.bass_freq( 0 ); // keep waveforms perfectly flat
// Setup synth
synth.output( &buf );
synth.volume( 0.50 );
while ( !button_pressed() )
{
// Mouse sets clock rate, higher to the right. The higher the clock
// rate, the more packed the waveform becomes.
long rate = sample_rate * (mouse_x() * 10 + 1);
// Clock rate sets how many time units there are per second
buf.clock_rate( rate );
// Generate random waveform, with each transition spaced 50 clocks apart.
srand( 1 );
buf.clear();
for ( int time = 0; time < 500; time += 50 )
synth.update( time, rand() % 20 - 10 );
buf.end_frame( 600 );
show_buffer_unscaled( buf );
}
return 0;
}
int main()
{
// Setup left buffer and wave
int left_time = 0;
int left_amp = 0;
setup_demo( left, left_synth );
left.clock_rate( left.sample_rate() * 100 );
// Setup right buffer and wave
int right_time = 0;
int right_amp = 0;
setup_demo( right, right_synth );
right.clock_rate( right.sample_rate() * 100 );
while ( !button_pressed() )
{
blip_time_t length = 100000;
// mouse sets frequency of left wave
int period = 1000 + 6 * mouse_x();
// Add saw wave to left buffer
do {
left_synth.update( left_time, left_amp = (left_amp + 1) % 10 );
} while ( (left_time += period) < length );
left.end_frame( length );
left_time -= length;
// Add saw wave of slightly lower pitch to right buffer
do {
right_synth.update( right_time, right_amp = (right_amp + 1) % 10 );
} while ( (right_time += 1000) < length );
right.end_frame( length );
right_time -= length;
// buffer to read samples into
int const buf_size = 2048;
static blip_sample_t samples [buf_size];
// Read left channel into even samples, right channel into odd samples:
// LRLRLRLRLR...
long count = left.read_samples( samples, buf_size / 2, 1 );
right.read_samples( samples + 1, count, 1 );
play_stereo_samples( samples, count * 2 );
}
return 0;
}
int main()
{
setup_demo( buf, synth );
// generate 1000 clocks of square wave
int length = 1000;
int amplitude = 1;
for ( int time = 0; time < length; time += 10 )
{
synth.update( time, amplitude );
amplitude = -amplitude;
}
// find out how many samples of sine wave to generate
int count = buf.count_samples( length );
blip_sample_t temp [4096];
for ( int i = 0; i < count; i++ )
{
double y = sin( i * (3.14159 / 100) );
temp [i] = y * 0.30 * blip_sample_max; // convert to blip_sample_t's range
}
// mix sine wave's samples into Blip_Buffer
buf.mix_samples( temp, count );
// end frame and show samples
buf.end_frame( length );
show_buffer( buf );
wait_button();
return 0;
}
int main()
{
while ( !button_pressed() )
{
setup_demo( buf, synth );
// base frequency and amplitude on mouse position
int period = mouse_x() * 100 + 10;
int amplitude = mouse_y() * 9 + 1;
// generate alternating signs of square wave, spaced by period
int time = 0;
while ( time < 1000 )
{
amplitude = -amplitude;
synth.update( time, amplitude );
time += period;
}
buf.end_frame( 1000 );
show_buffer( buf );
}
return 0;
}
static void RedoVolume(void)
{
apu.output(zebuf.center(), zebuf.left(), zebuf.right());
//apu.volume(0.15);
apu.volume(0.25);
FMSynth.volume(1.00);
}
static void gba_pcm_apply_control( int pcm_idx, int idx )
{
int ch = 0;
pcm[pcm_idx].pcm.shift = ~ioMem [SGCNT0_H] >> (2 + idx) & 1;
if ( (ioMem [NR52] & 0x80) )
ch = ioMem [SGCNT0_H+1] >> (idx << 2) & 3;
Blip_Buffer* out = 0;
switch ( ch )
{
case 1:
out = &stereo_buffer->bufs_buffer[1];
break;
case 2:
out = &stereo_buffer->bufs_buffer[0];
break;
case 3:
out = &stereo_buffer->bufs_buffer[2];
break;
}
if ( pcm[pcm_idx].pcm.output != out )
{
if ( pcm[pcm_idx].pcm.output )
pcm_synth.offset( SOUND_CLOCK_TICKS - soundTicks, -pcm[pcm_idx].pcm.last_amp, pcm[pcm_idx].pcm.output );
pcm[pcm_idx].pcm.last_amp = 0;
pcm[pcm_idx].pcm.output = out;
}
}
// Callback called when Alure needs more data to ffed a buffer
ALuint StreamCB (void* userdata, ALubyte *data, ALuint bytes) {
double period = SR / (2* freq); // How many samples need to do a half cycle.
size_t lenght = bytes / 2; // Lenght in "samples"
unsigned const amplitude = 9;
while (offset < lenght) {
sign = -sign;
synth.update(offset, amplitude * sign);
offset += period;
}
blipbuf.end_frame(lenght);
offset -= lenght; // adjust time to new frame
return 2* blipbuf.read_samples ((blip_sample_t*) data, lenght ); // return bytes!
}
int main () {
if (!alureInitDevice(NULL, NULL)) {
std::fprintf(stderr, "Failed to open OpenAL device: %s\n", alureGetErrorString());
return 1;
}
alGenSources(1, &src);
if (alGetError() != AL_NO_ERROR) {
std::fprintf(stderr, "Failed to create OpenAL source!\n");
alureShutdownDevice();
return 1;
}
// Seeting Blip Buffer
synth.treble_eq( -18.0f );
synth.volume (0.80);
synth.output (&blipbuf);
// Init Blip Buffer with a buffer of 250ms (second paramter is time in ms)
if ( blipbuf.set_sample_rate( SR, 1000 / 4 ) ) {
std::fprintf(stderr, "Failed to create Blip Buffer! Our of Memory\n");
alureShutdownDevice();
return 1;
}
blipbuf.clock_rate( blipbuf.sample_rate() );
blipbuf.bass_freq(300); // Equalization like a TV speaker
stream = alureCreateStreamFromCallback (StreamCB, nullptr, AL_FORMAT_MONO16, SR, SR/2, 0, nullptr);
if(!stream) {
std::fprintf(stderr, "Error creating stream! %s\n", alureGetErrorString());
alDeleteSources(1, &src);
alureShutdownDevice();
return 1;
}
if (!alurePlaySourceStream(src, stream, 4, 0, eos_callback, NULL)) {
std::fprintf(stderr, "Failed to play stream: %s\n", alureGetErrorString());
isdone = 1;
}
alureUpdateInterval(0.005f); // Should be a independint thread playing the stream
while(!isdone) {
freq -= 1;
if (freq < 1) {
freq = 600;
}
alureSleep(0.02f);
}
alureStopSource(src, AL_FALSE);
alDeleteSources(1, &src);
alureDestroyStream(stream, 0, NULL);
alureShutdownDevice();
return 0;
}
