static void
scan_freqs() {
int note, j;
real_t power;
for ( note = lo_note; note<hi_note; note++ ) {
power = get_power(note);
// harmonic compensation
if ( use_harm_comp ) {
j = note-12;
while ( j > lo_note ) {
if (act_freq[j]) {
power = -10000.0;
break;
}
j -= 12;
}
}
if ( act_freq[note] ) act_freq[note] =max(act_freq[note], power);
if ( power > threshold && !act_freq[note] )
note_on(note, power);
if (power < (threshold / hysteresis) && act_freq[note] )
note_off(note, power);
}
}
void strum_chord(struct chord_t chord, void* port_buf, int i) {
int q,r = 0;
for (q = 0; q < chord.size; q++) {
if (chord.note[q].delay == 0) {
note_on(chord.note[q], port_buf, i);
}
else {
if (chord.note[q].velocity > 0) {
while (delayed_notes[r].note.velocity != 0) {
r++;
}
delayed_notes[r].note = chord.note[q];
delayed_notes[r].sevent.sigev_signo = SIGUSR1;
delayed_notes[r].sevent.sigev_notify = SIGEV_SIGNAL;
delayed_notes[r].sevent.sigev_value.sival_ptr = &(delayed_notes[r]);
timer_create(CLOCK_MONOTONIC, &(delayed_notes[r].sevent), &(delayed_notes[r].timer));
delayed_notes[r].note.velocity = chord.note[q].velocity;
delayed_notes[r].note.note_number = chord.note[q].note_number;
delayed_notes[r].time.it_value.tv_sec = chord.note[q].delay / 1000;
delayed_notes[r].time.it_value.tv_nsec = (chord.note[q].delay * 1000000) % 1000000000;
delayed_notes[r].time.it_interval.tv_sec = 0;
delayed_notes[r].time.it_interval.tv_nsec = 0;
timer_settime(delayed_notes[r].timer, 0, &(delayed_notes[r].time), NULL);
}
}
}
}
void sn76_noise_voicer::midi_message(unsigned char message,unsigned char data1, unsigned char data2)
{
switch(message)
{
case 0x90: //note on
if(data2 == 0)
{
note_off(data1,data2);
}
else
{
note_on(data1,data2);
}
break;
case 0x80: //note off
note_off(data1,data2);
break;
case 0xC0: //prog change
patch_change(data1);
break;
case 0xF8: //TICK
tick();
default:
//std::cout<<"unknown msg, status: 0x" << std::hex <<(unsigned int)status<<std::endl;
break;
}
}
int main() {
note_on(100, 0);
for (int i = 0; i < MUSICDURATION; i++) {
sample s = render();
printf("%d %d %d\n", i, s, s / 0x7fffffff);
}
}
jack_read_midi(jack_nframes_t nframes) {
jack_nframes_t i;
midi_buf=jack_port_get_buffer(midi_port, nframes);
jack_nframes_t num_events=jack_midi_get_event_count(midi_buf);
for(i=0; i<num_events; i++) {
if(jack_midi_event_get(&midi_event, midi_buf, i)) return;
int status=midi_event.buffer[0];
jack_midi_data_t param=midi_event.buffer[1];
jack_midi_data_t value=midi_event.buffer[2];
//printf("JACK MIDI event: %x %x %x\n", status, param, value);
int ev_type=status&0xf0;
int channel=status&0x0f;
switch(ev_type) {
case SND_SEQ_EVENT_CONTROLLER:
if(!midi_channels[channel].in_use) break;
if(param==64) {
if(value>64) midi_channels[channel].sustain=1;
else midi_channels[channel].sustain=0;
} else if(param==1) {
// modulation controlling vibrato: value=0-127
midi_channels[channel].vibrato=value;
//printf("%d\n", value);
midi_channels[channel].vibrato_changed=1;
}
break;
// case SND_SEQ_EVENT_KEYPRESS:
case SND_SEQ_EVENT_CHANPRESS:
if(!midi_channels[channel].in_use) break;
midi_channels[channel].chanpress=value;
midi_channels[channel].chanpress_changed=1;
break;
case SND_SEQ_EVENT_NOTEON:
if(!midi_channels[channel].in_use) break;
note_on(channel, param, value);
break;
case SND_SEQ_EVENT_NOTEOFF:
if(!midi_channels[channel].in_use) break;
note_off(channel, param);
break;
case SND_SEQ_EVENT_PITCHBEND:
// value=-8192 to +8191
if(!midi_channels[channel].in_use) break;
//int pitchbend=(value*128)|(param&0x7f);
int pitchbend=(((value&0x7f)<<7)|(param&0x7f))-8192;
//printf("got pitchbend %x %x: %x %d\n", param, value, pitchbend, pitchbend);
midi_channels[channel].pitchbend=pitchbend;
break;
case SND_SEQ_EVENT_PGMCHANGE:
if(midi_channels[channel].program==-1) break;
//printf("prg change %d\n", value);
midi_channels[channel].program=param;
break;
}
}
}
void Channel::event(uint8_t a, uint8_t b, uint8_t c)
{
switch(a & 0xF0)
{
case 0x80: note_off(b); break;
case 0x90: note_on(b,c); break;
case 0xA0: break; //IMPLEMENTME: polyphonic aftertouch (note, dynamic)
case 0xB0: set_controller(b,c); break;
case 0xC0: set_program(b); break;
case 0xD0: break; //IMPLEMENTME: monotonic aftertouch (dynamic)
case 0xE0: set_pitch_bend( ( (((b&0x7F) + ((c&0x7F)<<7)) - 8192) / 8192.0 ) * max_pitchbend ); break;
case 0xF0: break; //own controls/sysex (to be implemented) IMPLEMENTME
default: output_verbose("NOTE: got unknown command "+ IntToStrHex(a&0xF0) +", ignoring it\n");
;
}
}
void Sampler::preview_instrument( Instrument* instr )
{
Instrument * old_preview;
AudioEngine::get_instance()->lock( RIGHT_HERE );
stop_playing_notes( __preview_instrument );
old_preview = __preview_instrument;
__preview_instrument = instr;
Note *previewNote = new Note( __preview_instrument, 0, 1.0, 0.5, 0.5, MAX_NOTES, 0 );
note_on( previewNote ); // exclusive note
AudioEngine::get_instance()->unlock();
delete old_preview;
}
/// Preview, uses only the first layer
void Sampler::preview_sample( Sample* sample, int length )
{
AudioEngine::get_instance()->lock( RIGHT_HERE );
InstrumentLayer *pLayer = __preview_instrument->get_layer( 0 );
Sample *pOldSample = pLayer->get_sample();
pLayer->set_sample( sample );
Note *previewNote = new Note( __preview_instrument, 0, 1.0, 0.5, 0.5, length, 0 );
stop_playing_notes( __preview_instrument );
note_on( previewNote );
delete pOldSample;
AudioEngine::get_instance()->unlock();
}
/*Reads the UART buffer and completes operation set by the
*Control Byte*/
void read_uart(void)
{
//Reset Count back to 0;
uartCount = 0;
//Byte1 is config
if (uartBuffer[0] == 0xF0) {
UDR0 = uartBuffer[1];
note_on(uartBuffer[1]);
} else if (uartBuffer [0] == 0x80) {
note_off(uartBuffer[1]);
} else if ((uartBuffer[0] & 0xF0) == 0b10100000) {
//Button Setting message
set_save_button((uartBuffer[0] & 0x0F), uartBuffer[1]);
}
//Update the playing notes linked list
tword1 = tune[head->name];
tword2 = tune[head->next->name];
tword3 = tune[head->next->next->name];
}
/// Preview, uses only the first layer
void Sampler::preview_sample( Sample* sample, int length )
{
AudioEngine::get_instance()->lock( RIGHT_HERE );
for (std::vector<InstrumentComponent*>::iterator it = __preview_instrument->get_components()->begin() ; it != __preview_instrument->get_components()->end(); ++it) {
InstrumentComponent* pComponent = *it;
InstrumentLayer *pLayer = pComponent->get_layer( 0 );
pLayer->set_sample( sample );
Note *pPreviewNote = new Note( __preview_instrument, 0, 1.0, 0.5, 0.5, length, 0 );
stop_playing_notes( __preview_instrument );
note_on( pPreviewNote );
}
AudioEngine::get_instance()->unlock();
}
int midi_action(snd_seq_t *seq_handle) {
snd_seq_event_t *ev;
int cnt = 0;
do {
snd_seq_event_input(seq_handle, &ev);
switch (ev->type) {
case SND_SEQ_EVENT_NOTEON:
if (channels && !(channels & (1<<ev->data.note.channel)))
break;
if (ev->data.note.velocity != 0) {
note_on(ev->data.note.note, ev->data.note.velocity);
cnt++;
}
}
snd_seq_free_event(ev);
} while (snd_seq_event_input_pending(seq_handle, 0) > 0);
return cnt;
}
/*Checks buttons 4 to 7 on the lower nibble of PINB*/
void check_high_buttons(void)
{
//Check buttons 5 - 8 on lower Nibble of PINB
buttonState2 = (PINB & 0x0F);
for (uint8_t pin2 = 0; pin2 <= 3; ++pin2) {
if ((buttonState2 & (1 << pin2)) && !(prevButtonState2 & (1 << pin2))) {
//Button Now On
note_on(get_upper_button_tword((1<<pin2)));
tword1 = tune[head->name];
tword2 = tune[head->next->name];
tword3 = tune[head->next->next->name];
break;
}
if (!(buttonState2 & (1 << pin2)) && (prevButtonState2 & (1 << pin2))) {
//Button Now Off
note_off(get_upper_button_tword((1<<pin2)));
tword1 = tune[head->name];
tword2 = tune[head->next->name];
tword3 = tune[head->next->next->name];
break;
}
}
prevButtonState2 = buttonState2;
}
/*Checks buttons 0 to 3 on the lower nibble of PINA*/
void check_low_buttons(void)
{
//Check buttons 1 - 4 lower Nibble of PINA
buttonState1 = (PINA & 0x0F);
for (uint8_t pin = 0; pin <= 3; ++pin) {
if ((buttonState1 & (1 << pin)) && !(prevButtonState1 & (1 << pin))) {
//Button Now On
note_on(get_lower_button_tword((1 << pin)));
tword1 = tune[head->name];
tword2 = tune[head->next->name];
tword3 = tune[head->next->next->name];
break;
}
if (!(buttonState1 & (1 << pin)) && (prevButtonState1 & (1 << pin))) {
//Button Now Off
note_off(get_lower_button_tword((1 << pin)));
tword1 = tune[head->name];
tword2 = tune[head->next->name];
tword3 = tune[head->next->next->name];
break;
}
}
prevButtonState1 = buttonState1;
}
void do_keyboard_mode(void) {
signed int shift = 0;
uint8_t accent=0, slide=0;
uint8_t i, last_bank;
// turn tempo off!
turn_off_tempo();
clear_bank_leds();
read_switches();
last_bank = bank;
has_bank_knob_changed(); // ignore startup change
while (1) {
read_switches();
if (function_changed) {
midi_notesoff(); // turn all notes off
return;
}
// show the current MIDI address
if (!is_bank_led_set(midi_out_addr)) {
clear_bank_leds();
set_bank_led(midi_out_addr);
}
if (has_bank_knob_changed()) {
// bank knob was changed, which means they want a different
// midi addr... OK then!
midi_out_addr = bank;
// set the new midi address (burn to EEPROM)
internal_eeprom_write8(MIDIOUT_ADDR_EEADDR, midi_out_addr);
last_bank = bank;
}
// show the octave
display_octave_shift(shift);
for (i=0; i<13; i++) {
// check if any notes were just pressed
if (just_pressed(notekey_tab[i])) {
note_on((C2+i) + shift*OCTAVE, slide, accent);
midi_send_note_on( ((C2+i) + shift*OCTAVE) | (accent << 6));
slide = TRUE;
// turn on that LED
set_notekey_led(i);
}
// check if any notes were released
if (just_released(notekey_tab[i])) {
midi_send_note_off( ((C2+i) + shift*OCTAVE) | (accent << 6));
// turn off that LED
clear_notekey_led(i);
}
}
if (just_pressed(KEY_UP)) {
if (shift < 2)
shift++;
} else if (just_pressed(KEY_DOWN)) {
if (shift > -1)
shift--;
}
// check if they turned accent on
if (just_pressed(KEY_ACCENT)) {
accent = !accent;
if (accent)
set_led(LED_ACCENT);
else
clear_led(LED_ACCENT);
}
// if no keys are held down and there was a note just playing
// turn off the note.
if ((NOTE_PIN & 0x3F) && no_keys_pressed()) {
note_off(0);
slide = FALSE;
clear_notekey_leds();
}
}
}
int process(jack_nframes_t nframes, void *arg) {
int i,j;
void* port_buf = jack_port_get_buffer(output_port, nframes);
unsigned char* buffer;
jack_midi_clear_buffer(port_buf);
for(i = 0; i < nframes; i++) {
while(queued_notes.size > 0) {
note_on(queued_notes.note[queued_notes.size - 1], port_buf, i);
queued_notes.size--;
}
if (strummer_action != STRUMMER_ACTION_NONE) {
if (strummer_action == STRUMMER_ACTION_MID_DOWN || strummer_action == STRUMMER_ACTION_MID_UP) {
strum_chord(chord[chord_state], port_buf, i);
strummer_action = STRUMMER_ACTION_NONE;
}
else {
if (strummer_state != STRUMMER_STATE_SUSTAINED) {
mute(port_buf, i);
strummer_action = STRUMMER_ACTION_NONE;
}
}
}
if (whammy_action != WHAMMY_ACTION_NONE) {
buffer = jack_midi_event_reserve(port_buf, i, 3);
unsigned int pitch_shift = (MIDI_PITCH_CENTER * whammy_state) / CWIID_GUITAR_WHAMMY_MAX ;
unsigned int pitch_value = MIDI_PITCH_CENTER - pitch_shift;
buffer[2] = (pitch_value & 0x3F80) >> 7; // most significant bits
buffer[1] = pitch_value & 0x007f; // least significant bits
buffer[0] = MIDI_PITCH_WHEEL + midi_channel; // pitch wheel change
printf("whammy! %x, %x, %x, desimalt: %d\n", buffer[0], buffer[2], buffer[1], pitch_value);
whammy_action = WHAMMY_ACTION_NONE;
}
if (touchbar_action != TOUCHBAR_ACTION_NONE) {
buffer = jack_midi_event_reserve(port_buf, i, 3);
// scale input to output values (5th represents maximum possible input value)
unsigned int modulation = (MIDI_MODULATION_MAX * touchbar_state) / CWIID_GUITAR_TOUCHBAR_5TH ;
printf("touchbar action! %d, %x, sent %x\n", touchbar_action, touchbar_state, modulation);
buffer[2] = modulation;
buffer[1] = 0x1; // modulation
buffer[0] = MIDI_CONTROL_CHANGE + midi_channel; // control change
touchbar_action = TOUCHBAR_ACTION_NONE;
}
if (stick_action != STICK_ACTION_NONE) {
printf("stick_action!\n");
unsigned int volume = last_sent_volume_value;
if (stick_action == STICK_ACTION_ROTATE_COUNTER_CLOCKWISE) {
volume += stick_zone_average_value / 2 ;
if (volume > 127) {
volume = 127;
}
}
else if (stick_action == STICK_ACTION_ROTATE_CLOCKWISE) {
if (volume >= stick_zone_average_value / 2) {
volume -= stick_zone_average_value / 2;
} else {
volume = 0;
}
}
if (volume != last_sent_volume_value) {
printf("volume: %d\n", volume);
buffer = jack_midi_event_reserve(port_buf, i, 3);
buffer[2] = volume;
buffer[1] = 0x7; // volume
buffer[0] = MIDI_CONTROL_CHANGE + midi_channel; // control change
last_sent_volume_value = volume;
}
stick_action = STICK_ACTION_NONE;
}
while (drums_action != 0) {
uint8_t send_note_off = 0;
buffer = jack_midi_event_reserve(port_buf, i, 3);
buffer[2] = 0x7F; /* velocity */
if ((drums_action & RED) == RED) {
/* if ((drums_state & RED) == RED) {
send_note_off = 1;
}
drums_state ^= RED;
*/
buffer[1] = 38; /* note number */
drums_action &= ~RED;
} else if ((drums_action & YELLOW) == YELLOW) {
/* if ((drums_state & YELLOW) == YELLOW) {
send_note_off = 1;
}
drums_state ^= YELLOW;
*/
buffer[1] = 42; /* note number */
drums_action &= ~YELLOW;
} else if ((drums_action & BLUE) == BLUE) {
/* if ((drums_state & BLUE) == BLUE) {
send_note_off = 1;
}
drums_state ^= BLUE;
*/
buffer[1] = 48; /* note number */
drums_action &= ~BLUE;
} else if ((drums_action & ORANGE) == ORANGE) {
/* if ((drums_state & ORANGE) == ORANGE) {
send_note_off = 1;
}
drums_state ^= ORANGE;
*/
buffer[1] = 51; /* note number */
drums_action &= ~ORANGE;
} else if ((drums_action & GREEN) == GREEN) {
/* if ((drums_state & GREEN) == GREEN) {
send_note_off = 1;
}
drums_state ^= GREEN;
*/
buffer[1] = 45; /* note number */
drums_action &= ~GREEN;
} else if ((drums_action & PEDAL) == PEDAL) {
/* if ((drums_state & PEDAL) == PEDAL) {
send_note_off = 1;
}
drums_state ^= PEDAL;
*/
buffer[1] = 36; /* note number */
drums_action &= ~PEDAL;
}
if (send_note_off) {
buffer[0] = MIDI_NOTE_OFF + 9; // note off
} else {
buffer[0] = MIDI_NOTE_ON + 9; // note on
}
}
if (crossfader_action != CROSSFADER_ACTION_NONE) {
buffer = jack_midi_event_reserve(port_buf, i, 3);
uint8_t crossfader_midi_value = current_turntables_state.crossfader * 127 / CWIID_TURNTABLES_CROSSFADER_MAX;
buffer[2] = crossfader_midi_value;
buffer[1] = MIDI_BALANCE_MSB;
buffer[0] = MIDI_CONTROL_CHANGE + midi_channel; // control change
crossfader_action = CROSSFADER_ACTION_NONE;
}
if (effect_dial_action != EFFECT_DIAL_ACTION_NONE) {
buffer = jack_midi_event_reserve(port_buf, i, 3);
buffer[0] = MIDI_CONTROL_CHANGE + midi_channel; // control change
buffer[1] = MIDI_EFFECT_CTL_1_MSB;
int16_t signed_value;
switch (effect_dial_action) {
case EFFECT_DIAL_ACTION_ROTATE_CLOCKWISE:
effect_dial_state.value += effect_dial_state.change;
if (effect_dial_state.value > effect_dial_state.max_value) {
effect_dial_state.value = effect_dial_state.max_value;
}
break;
case EFFECT_DIAL_ACTION_ROTATE_COUNTER_CLOCKWISE:
signed_value = effect_dial_state.value + effect_dial_state.change;
effect_dial_state.value += effect_dial_state.change;
if (signed_value < effect_dial_state.min_value) {
effect_dial_state.value = effect_dial_state.min_value;
}
break;
case EFFECT_DIAL_ACTION_INITIALIZE:
printf("initialize\n");
current_turntables_state.effect_dial = effect_dial_state.initial_value;
break;
}
buffer[2] = effect_dial_state.value;
effect_dial_action = EFFECT_DIAL_ACTION_NONE;
}
}
int main(int argc, char ** argv)
{
static msg_block_t msg;
memset((void *)&msg, 0, sizeof(msg));
struct timespec time;
double time0, time1;
uint32_t notes[SCALE_PATTERN][NOTES_SIZE];
uint32_t scales[SCALE_PATTERN][SCALE_SIZE] = {
{0,4,7,9,},
{0,5,7,9,},
{2,4,7,11,},
{2,5,7,9,},
{2,5,7,11,},
{0,2,4,7,},
{0,2,5,7,},
{0,2,5,9,},
};
uint32_t instruments[] = {
0, 4, 5, 6, 8, 9, 11, 14, 15, 16, 17, 19, 24,
25, 26, 30, 40, 42, 46, 48, 51, 52, 56, 57, 60,
61, 63, 64, 65, 68, 69, 70, 73, 88, 89, 91, 93,
94, 95, 98, 99, 103, 104, 110,
};
uint32_t insts = sizeof(instruments) / sizeof(uint32_t);
int fb = open(FBDEV, O_RDWR);
if (fb > 0)
{
struct fb_fix_screeninfo fbfsi;
struct fb_var_screeninfo fbvsi;
if (ioctl(fb, FBIOGET_FSCREENINFO, &fbfsi) == 0)
{
msg.fbinfo.smem_start = fbfsi.smem_start;
msg.fbinfo.smem_len = fbfsi.smem_len;
msg.fbinfo.line_length = fbfsi.line_length;
}
if (ioctl(fb, FBIOGET_VSCREENINFO, &fbvsi) == 0)
{
msg.fbinfo.xres = fbvsi.xres;
msg.fbinfo.yres = fbvsi.yres;
msg.fbinfo.xres_virtual = fbvsi.xres_virtual;
msg.fbinfo.yres_virtual = fbvsi.yres_virtual;
msg.fbinfo.xoffset = fbvsi.xoffset;
msg.fbinfo.yoffset = fbvsi.yoffset;
msg.fbinfo.bits_per_pixel = fbvsi.bits_per_pixel;
}
close(fb);
}
long pagesize = (sysconf(_SC_PAGESIZE));
int fdmem = open(MEMDEV, O_RDWR | O_SYNC);
uint32_t *frame_buffer = NULL;
size_t mapsize = 0;
if ((fdmem > 0) && (msg.fbinfo.smem_start != 0))
{
off_t physical_page = msg.fbinfo.smem_start & (~(pagesize - 1));
unsigned long offset = msg.fbinfo.smem_start - (unsigned long)physical_page;
mapsize = msg.fbinfo.smem_len + offset;
frame_buffer = mmap(NULL, mapsize, PROT_READ | PROT_WRITE, MAP_SHARED, fdmem, physical_page);
if (frame_buffer == MAP_FAILED)
{
perror("Framebuffer Map Failed");
}
}
struct timespec time_start;
clock_gettime(CLOCK_MONOTONIC_RAW, &time_start);
srand((uint32_t)time_start.tv_nsec);
seq_context_t seq;
if (open_sequencer(&seq) == FALSE)
{
exit(EXIT_FAILURE);
}
program_change(&seq, 0, 48);
control_change(&seq, 0, 91, 127);
static rt_context_t rtx;
memset((void *)&rtx, 0, sizeof(rtx));
int width = msg.fbinfo.xres_virtual;
int height = msg.fbinfo.yres_virtual;
rtx.objnum = OBJNUM;
rtx.light.pos = vec3_set(-4.0f, 8.0f, 2.0f);
rtx.light.col = vec3_set(1.0f, 1.0f, 1.0f);
rtx.eye = vec3_set(0.0f, 0.0f, -7.0f);
rtx.swidth = 10.0f * (float)width / (float)height;
rtx.sheight = 10.0f;
rtx.width = width / SCALE;
rtx.height = height / SCALE;
rtx.xoff = 0;
rtx.yoff = 0;
rtx.ax = rtx.swidth / (float)rtx.width;
rtx.ayc = rtx.sheight / (float)rtx.height;
rtx.ay = rtx.sheight / (float)rtx.height;
uint32_t i, j;
for (i = 0; i < SCALE_PATTERN; i++)
{
for (j = 0; j < NOTES_SIZE; j++)
{
notes[i][j] = scales[i][j % SCALE_SIZE] + (j / SCALE_SIZE) * 12;
}
}
for (i = 0; i < rtx.objnum; i++)
{
rtx.obj[i].type = SPHERE;
rtx.obj[i].pos = vec3_set(0.0f, -100.0f, 0.0f);
rtx.obj[i].rad = 1.0f;
rtx.obj[i].col = vec3_set(randf(), randf(), randf());
rtx.obj[i].flag_shadow = TRUE;
rtx.obj[i].flag_refrect = TRUE;
rtx.obj[i].spd = vec3_set(0.0f, 0.0f, 0.0f);
rtx.obj[i].note = 0;
}
rtx.obj[0].type = PLANE;
rtx.obj[0].norm = normalize(vec3_set(0.0f, 1.0f, 0.0f));
rtx.obj[0].dist = 2.0f;
rtx.obj[0].col = vec3_set(0.1f, 0.3f, 0.6f);
rtx.obj[0].flag_shadow = TRUE;
rtx.obj[0].flag_refrect = TRUE;
rtx.obj[0].spd = vec3_set(0.0f, 0.0f, 0.0f);
uint32_t scale = 0;
uint32_t curobj = 0;
float next_note_time = get_elapsed(time_start) + 3.0f;
float next_scale_time = get_elapsed(time_start) + 15.0f + randf() * 15.0f;
float time_now = get_elapsed(time_start);
float time_quit = time_now + 3600.0f;
uint32_t retry_count = 0;
uint32_t counter = 0;
float time_prev = 0.0f;
while(time_now < time_quit)
{
uint32_t e;
for (e = 1; e < rtx.objnum; e++)
{
rtx.obj[e].pos = vec3_add(rtx.obj[e].pos, rtx.obj[e].spd);
}
time_now = get_elapsed(time_start);
if (time_now > next_note_time)
{
e = (curobj % (rtx.objnum - 1)) + 1;
rtx.obj[e].pos = vec3_set(randf()*8.0f-4.0f, randf()*6.0f-1.0f, randf()*8.0+0.0f);
rtx.obj[e].col = vec3_set(randf(), randf(), randf());
rtx.obj[e].spd = vec3_set(randf()*0.1f-0.05f,randf()*0.1f-0.05f,randf()*0.1f-0.05f);
note_off(&seq, 0, rtx.obj[e].note);
rtx.obj[e].note = notes[scale][(uint32_t)(randf() * 17.0f) + 12];
note_on(&seq, 0, rtx.obj[e].note, 127 - rtx.obj[e].note);
curobj++;
float len = (randf() + 0.5f);
next_note_time = time_now + len * len * len;
}
if (time_now > next_scale_time)
{
scale = (uint32_t)(randf() * (float)SCALE_PATTERN);
program_change(&seq, 0, instruments[(uint32_t)(randf() * ((float)insts + 0.99f))]);
rtx.obj[0].col = vec3_set(randf(), randf(), randf());
rtx.light.pos = vec3_set(randf() * 8.0f - 4.0f, 8.0f, randf() * 4.0f);
next_scale_time = time_now + (randf() + 0.1f) * 40.0f;
}
render(&msg, &rtx, frame_buffer);
counter++;
if (counter > 100)
{
//printf("FPS: %.2f\n", 100.0f / (time_now - time_prev));
time_prev = time_now;
counter = 0;
}
}
close_sequencer(&seq);
munmap(frame_buffer, mapsize);
close(fdmem);
return 0;
}
int main(void)
{
unsigned char cf,key_data;
int vol = 127;
ROMEMU();
da_init();
timer_init();
P6DDR &= ~0x07; /* P60,1,2 入力 */
PADDR |= 0x0f; /* PA0,1,2,3 出力 */
tone_init();
while (1)
{
key_data = 0;
//key 1,2,3
PADR = 0x07; // PA3 = L
cf = P6DR; // データ入力
cf = ~cf; // cfの反転
cf &= 0x07; // P60,1,2のみ見る
switch(cf) {
case 1 : key_data = '1'; break;
case 2 : key_data = '2'; break;
case 4 : key_data = '3'; break;
}
//key 4,5,6
PADR = 0x0b;
cf = P6DR;
cf = ~cf;
cf &= 0x07;
switch(cf) {
case 1 : key_data = '4'; break;
case 2 : key_data = '5'; break;
case 4 : key_data = '6'; break;
}
//key 7,8,9
PADR = 0x0d; /* This is a mistake code. */
cf = P6DR;
cf = ~cf;
cf &= 0x07;
switch(cf) {
case 1 : key_data = '7'; break;
case 2 : key_data = '8'; break;
case 4 : key_data = '9'; break;
}
//key *,0,#
PADR = 0x0e;
cf = P6DR;
cf = ~cf;
cf &= 0x07;
switch(cf) {
case 1 : key_data = '*'; break;
case 2 : key_data = '0'; break;
case 4 : key_data = '#'; break;
}
switch(key_data)
{
case '1':
note_on(DO_L,vol);
break;
case '2':
note_on(RE,vol);
break;
case '3':
note_on(MI,vol);
break;
case '4':
note_on(FA,vol);
break;
case '5':
note_on(SO,vol);
break;
case '6':
note_on(RA,vol);
break;
case '7':
note_on(SI,vol);
break;
case '8':
note_on(DO_H,vol);
break;
default:
note_off();
break;
}
}
return 1;
}
static int
set_new_event( int t )
{
int ptr;
unsigned char *data;
int count;
int follower;
__GETMDX;
data = mdx->data;
ptr = mdx->track[t].current_mml_ptr;
count = 0;
follower = 0;
#if 0
if ( ptr+1 <= mdx->length && t>7 ) {
fprintf(stderr,"%2d %2x %2x\n",t,data[ptr],data[ptr+1]);
fflush(stderr);
}
#endif
if ( data[ptr] <= MDX_MAX_REST ) { /* rest */
note_off(t);
count = data[ptr]+1;
mdx->track[t].gate = count+1;
follower=0;
} else if ( data[ptr] <= MDX_MAX_NOTE ) { /* note */
note_on( t, data[ptr]);
count = data[ptr+1]+1;
do_quantize( t, count );
follower = 1;
} else {
switch ( data[ptr] ) {
case MDX_SET_TEMPO:
set_tempo( data[ptr+1] );
follower = 1;
break;
case MDX_SET_OPM_REG:
set_opm_reg( t, data[ptr+1], data[ptr+2] );
follower = 2;
break;
case MDX_SET_VOICE:
set_voice( t, data[ptr+1] );
follower = 1;
break;
case MDX_SET_PHASE:
set_phase( t, data[ptr+1] );
follower = 1;
break;
case MDX_SET_VOLUME:
set_volume( t, data[ptr+1] );
follower = 1;
break;
case MDX_VOLUME_DEC:
dec_volume( t );
follower = 0;
break;
case MDX_VOLUME_INC:
inc_volume( t );
follower = 0;
break;
case MDX_SET_QUANTIZE:
set_quantize( t, data[ptr+1] );
follower = 1;
break;
case MDX_SET_KEYOFF:
set_keyoff( t );
follower = 0;
break;
case MDX_REPEAT_START:
mdx->track[t].loop_counter[mdx->track[t].loop_depth] = data[ptr+1];
if ( mdx->track[t].loop_depth < MDX_MAX_LOOP_DEPTH )
mdx->track[t].loop_depth++;
follower = 2;
break;
case MDX_REPEAT_END:
if (--mdx->track[t].loop_counter[mdx->track[t].loop_depth-1] == 0 ) {
if ( --mdx->track[t].loop_depth < 0 ) mdx->track[t].loop_depth=0;
} else {
if ( data[ptr+1] >= 0x80 ) {
ptr = ptr+2 - (0x10000-(data[ptr+1]*256 + data[ptr+2])) - 2;
} else {
ptr = ptr+2 + data[ptr+1]*256 + data[ptr+2] - 2;
}
}
follower = 2;
break;
case MDX_REPEAT_BREAK:
if ( mdx->track[t].loop_counter[mdx->track[t].loop_depth-1] == 1 ) {
if ( --mdx->track[t].loop_depth < 0 ) mdx->track[t].loop_depth=0;
ptr = ptr+2 + data[ptr+1]*256 + data[ptr+2] -2 +2;
}
follower = 2;
break;
case MDX_SET_DETUNE:
set_detune( t, data[ptr+1], data[ptr+2] );
follower = 2;
break;
case MDX_SET_PORTAMENT:
set_portament( t, data[ptr+1], data[ptr+2] );
follower = 2;
break;
case MDX_DATA_END:
if ( data[ptr+1] == 0x00 ) {
count = -1;
note_off(t);
follower = 1;
} else {
ptr = ptr+2 - (0x10000-(data[ptr+1]*256 + data[ptr+2])) - 2;
mdx->track[t].infinite_loop_times++;
follower = 2;
}
break;
case MDX_KEY_ON_DELAY:
follower = 1;
break;
case MDX_SEND_SYNC:
send_sync( data[ptr+1] );
follower = 1;
break;
case MDX_RECV_SYNC:
recv_sync( t );
follower = 0;
count = 1;
break;
case MDX_SET_FREQ:
set_freq( t, data[ptr+1] );
follower = 1;
break;
case MDX_SET_PLFO:
if ( data[ptr+1] == 0x80 || data[ptr+1] == 0x81 ) {
set_plfo_onoff( t, data[ptr+1]-0x80 );
follower = 1;
} else {
set_plfo( t,
data[ptr+1], data[ptr+2], data[ptr+3],
data[ptr+4], data[ptr+5] );
follower = 5;
}
break;
case MDX_SET_ALFO:
if ( data[ptr+1] == 0x80 || data[ptr+1] == 0x81 ) {
set_alfo_onoff( t, data[ptr+1]-0x80 );
follower = 1;
} else {
set_alfo( t,
data[ptr+1], data[ptr+2], data[ptr+3],
data[ptr+4], data[ptr+5] );
follower = 5;
}
break;
case MDX_SET_OPMLFO:
if ( data[ptr+1] == 0x80 || data[ptr+1] == 0x81 ) {
set_hlfo_onoff( t, data[ptr+1]-0x80 );
follower = 1;
} else {
set_hlfo( t,
data[ptr+1], data[ptr+2], data[ptr+3],
data[ptr+4], data[ptr+5] );
follower = 5;
}
break;
case MDX_SET_LFO_DELAY:
set_lfo_delay( t, data[ptr+1] );
follower = 1;
break;
case MDX_SET_PCM8_MODE:
follower = 0;
break;
case MDX_FADE_OUT:
if ( data[ptr+1]==0x00 ) {
follower = 1;
set_fade_out( 5 );
} else {
follower = 2;
set_fade_out( data[ptr+2] );
}
break;
default:
count = -1;
break;
}
}
ptr += 1+follower;
mdx->track[t].current_mml_ptr = ptr;
return count;
}
void play_note(int pitch, float length) {
note_on (pitch, 100);
usleep((int) (length * 1000000));
note_off(pitch, 100);
}
