Lines Matching refs:ms
132 midisyn *ms = addr;
136 KASSERT(ms->lock != NULL);
137 KASSERT(mutex_owned(ms->lock));
138 DPRINTF(("midisyn_open: ms=%p ms->mets=%p\n", ms, ms->mets));
140 mutex_exit(ms->lock);
141 ms->ctl.lock = ms->lock;
142 error = midictl_open(&ms->ctl);
144 mutex_enter(ms->lock);
147 ms->chnstate = kmem_alloc(MIDI_MAX_CHANS * sizeof(*ms->chnstate),
149 mutex_enter(ms->lock);
152 if (ms->mets->open)
153 rslt = (ms->mets->open(ms, flags));
160 midisyn_notify(ms, MIDICTL_RESET, chan, 0);
168 midisyn *ms = addr;
172 KASSERT(mutex_owned(ms->lock));
173 DPRINTF(("midisyn_close: ms=%p ms->mets=%p\n", ms, ms->mets));
174 fs = ms->mets;
177 midisyn_notify(ms, MIDICTL_SOUND_OFF, chan, 0);
180 fs->close(ms);
182 mutex_exit(ms->lock);
183 midictl_close(&ms->ctl);
184 kmem_free(ms->chnstate, MIDI_MAX_CHANS * sizeof(*ms->chnstate));
185 mutex_enter(ms->lock);
191 midisyn *ms = addr;
193 KASSERT(mutex_owned(ms->lock));
195 mi->name = ms->name;
215 midisyn *ms = addr;
217 *intr = ms->lock;
224 midisyn *ms = maddr;
226 KASSERT(mutex_owned(ms->lock));
228 if (ms->mets->ioctl)
229 return (ms->mets->ioctl(ms, cmd, addr, flag, l));
235 midisyn_findvoice(midisyn *ms, int chan, int note)
240 KASSERT(mutex_owned(ms->lock));
243 for (v = 0; v < ms->nvoice; v++)
244 if (ms->voices[v].chan_note == cn && ms->voices[v].inuse)
250 midisyn_init(midisyn *ms)
253 KASSERT(ms->lock != NULL);
260 if (ms->mets->allocv == 0) {
261 ms->voices = kmem_zalloc(ms->nvoice * sizeof(struct voice),
263 ms->seqno = 1;
264 ms->mets->allocv = midisyn_allocvoice;
267 if (ms->mets->attackv_vel == 0 && ms->mets->attackv != 0)
268 ms->mets->attackv_vel = midisyn_attackv_vel;
270 ms->ctl = (midictl) {
272 .cookie = ms,
276 DPRINTF(("midisyn_init: ms=%p\n", ms));
280 midisyn_freevoice(midisyn *ms, int voice)
283 KASSERT(mutex_owned(ms->lock));
285 if (ms->mets->allocv != midisyn_allocvoice)
287 ms->voices[voice].inuse = 0;
291 midisyn_allocvoice(midisyn *ms, uint_fast8_t chan, uint_fast8_t note)
296 KASSERT(mutex_owned(ms->lock));
300 bestseq = ms->voices[0].seqno + (ms->voices[0].inuse ? 0x40000000 : 0);
301 for (v = 1; v < ms->nvoice; v++) {
302 s = ms->voices[v].seqno;
303 if (ms->voices[v].inuse)
311 bestv, ms->voices[bestv].seqno,
312 ms->voices[bestv].chan_note,
313 ms->voices[bestv].inuse));
315 if (ms->voices[bestv].inuse)
317 ms->voices[bestv].chan_note));
319 ms->voices[bestv].chan_note = MS_CHANNOTE(chan, note);
320 ms->voices[bestv].seqno = ms->seqno++;
321 ms->voices[bestv].inuse = 1;
327 midisyn_attackv_vel(midisyn *ms, uint_fast16_t voice, midipitch_t mp,
331 KASSERT(mutex_owned(ms->lock));
333 ms->voices[voice].velcB = midisyn_vol2cB((uint_fast16_t)vel << 7);
334 ms->mets->attackv(ms, voice, mp, level_cB + ms->voices[voice].velcB);
347 midisyn *ms = addr;
351 KASSERT(mutex_owned(ms->lock));
353 DPRINTF(("midisyn_channelmsg: ms=%p status=%#02x chan=%d\n",
354 ms, status, chan));
355 fs = ms->mets;
367 voice = midisyn_findvoice(ms, chan, buf[1]);
369 fs->releasev(ms, voice, buf[2]);
370 midisyn_freevoice(ms, voice);
382 voice = fs->allocv(ms, chan, buf[1]);
383 ms->voices[voice].velcB = 0; /* assume driver handles vel */
384 fs->attackv_vel(ms, voice,
386 midisyn_adj_pitch(ms, chan)),
387 midisyn_adj_level(ms,chan), buf[2]);
402 midictl_change(&ms->ctl, chan, buf+1);
406 fs->pgmchg(ms, chan, buf[1]);
426 ms->chnstate[chan].bendraw = buf[2]<<7 | buf[1];
427 ms->chnstate[chan].bendraw -= MIDI_BEND_NEUTRAL;
428 midisyn_notify(ms, MIDICTL_RPN, chan,
460 struct midisyn *ms;
463 ms = (struct midisyn *)cookie;
465 KASSERT(mutex_owned(ms->lock));
468 if ( ms->mets->ctlnotice )
469 drvhandled = ms->mets->ctlnotice(ms, evt, chan, key);
477 ms->chnstate[chan].pendingreset |= PEND_ALL;
478 midisyn_notify(ms, MIDICTL_CTLR, chan,
480 midisyn_notify(ms, MIDICTL_CTLR, chan,
482 ms->chnstate[chan].bendraw = 0; /* MIDI_BEND_NEUTRAL - itself */
483 midisyn_notify(ms, MIDICTL_RPN, chan,
485 midisyn_notify(ms, MIDICTL_RPN, chan,
487 midisyn_notify(ms, MIDICTL_RPN, chan,
494 midisyn_chan_releasev(ms, chan, 64);
501 midisyn_chan_releasev(ms, chan, 127);
504 ms->chnstate[chan].pendingreset &= ~PEND_VOL;
506 ms->chnstate[chan].volume = 0;
509 ms->chnstate[chan].volume = midisyn_vol2cB(
510 midictl_read(&ms->ctl, chan, key, 100<<7));
511 midisyn_upd_level(ms, chan);
514 ms->chnstate[chan].pendingreset &= ~PEND_EXP;
516 ms->chnstate[chan].expression = 0;
519 ms->chnstate[chan].expression = midisyn_vol2cB(
520 midictl_read(&ms->ctl, chan, key, 16383));
521 midisyn_upd_level(ms, chan);
529 ms->chnstate[chan].pendingreset &= ~PEND_PBS;
531 ms->chnstate[chan].bend = 0;
535 w = midictl_rpn_read(&ms->ctl, chan, key, 2<<7);
546 ms
547 ( ms->chnstate[chan].bendraw * semis ) << 1;
548 ms->chnstate[chan].bend +=
549 ((ms->chnstate[chan].bendraw * cents)/25 + 1) >> 1;
550 midisyn_upd_pitch(ms, chan);
555 ms->chnstate[chan].tuning_fine = 0;
558 mp = midictl_rpn_read(&ms->ctl, chan, key, 8192);
564 ms->chnstate[chan].tuning_fine = ( mp - 8192 ) << 1;
565 midisyn_upd_pitch(ms, chan);
569 ms->chnstate[chan].pendingreset &= ~PEND_TNC;
571 ms->chnstate[chan].tuning_coarse = 0;
579 mp = midictl_rpn_read(&ms->ctl, chan, key, 64<<7) >> 7;
580 ms->chnstate[chan].tuning_coarse = ( mp - 64 ) << 14;
581 midisyn_upd_pitch(ms, chan);
599 midisyn_adj_level(midisyn *ms, uint_fast8_t chan)
603 KASSERT(mutex_owned(ms->lock));
605 level = ms->chnstate[chan].volume + ms->chnstate[chan].expression;
612 midisyn_adj_pitch(midisyn *ms, uint_fast8_t chan)
614 struct channelstate *s = ms->chnstate + chan;
616 KASSERT(mutex_owned(ms->lock));
621 #define VOICECHAN_FOREACH_BEGIN(ms,vp,ch) \
624 for (vp=(ms)->voices,_end_##vp=vp+(ms)->nvoice; \
635 midisyn_chan_releasev(midisyn *ms, uint_fast8_t chan, uint_fast8_t vel)
638 KASSERT(mutex_owned(ms->lock));
640 VOICECHAN_FOREACH_BEGIN(ms,vp,chan)
641 ms->mets->releasev(ms, vp - ms->voices, vel);
642 midisyn_freevoice(ms, vp - ms->voices);
647 midisyn_upd_level(midisyn *ms, uint_fast8_t chan)
652 KASSERT(mutex_owned(ms->lock));
654 if ( NULL == ms->mets->relevelv )
657 if ( ms->chnstate[chan].pendingreset & PEND_LEVEL )
660 chan_level = midisyn_adj_level(ms, chan);
662 VOICECHAN_FOREACH_BEGIN(ms,vp,chan)
664 ms->mets->relevelv(ms, vp - ms->voices,
670 midisyn_upd_pitch(midisyn *ms, uint_fast8_t chan)
674 KASSERT(mutex_owned(ms->lock));
676 if ( NULL == ms->mets->repitchv )
679 if ( ms->chnstate[chan].pendingreset & PEND_PITCH )
682 chan_adj = midisyn_adj_pitch(ms, chan);
684 VOICECHAN_FOREACH_BEGIN(ms,vp,chan)
685 ms->mets->repitchv(ms, vp - ms->voices,
Indexes created Wed Oct 22 13:09:56 GMT 2025