eas_vm_protos.h revision e442bb7cd6a085b33a4dd52c0e20a157ada7feb1
1/*---------------------------------------------------------------------------- 2 * 3 * File: 4 * eas_vm_protos.h 5 * 6 * Contents and purpose: 7 * Declarations, interfaces, and prototypes for voice manager. 8 * 9 * Copyright Sonic Network Inc. 2004 10 11 * Licensed under the Apache License, Version 2.0 (the "License"); 12 * you may not use this file except in compliance with the License. 13 * You may obtain a copy of the License at 14 * 15 * http://www.apache.org/licenses/LICENSE-2.0 16 * 17 * Unless required by applicable law or agreed to in writing, software 18 * distributed under the License is distributed on an "AS IS" BASIS, 19 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 20 * See the License for the specific language governing permissions and 21 * limitations under the License. 22 * 23 *---------------------------------------------------------------------------- 24 * Revision Control: 25 * $Revision: 736 $ 26 * $Date: 2007-06-22 13:51:24 -0700 (Fri, 22 Jun 2007) $ 27 *---------------------------------------------------------------------------- 28*/ 29 30#ifndef _EAS_VM_PROTOS_H 31#define _EAS_VM_PROTOS_H 32 33// includes 34#include "eas_data.h" 35#include "eas_sndlib.h" 36 37/*---------------------------------------------------------------------------- 38 * VMInitialize() 39 *---------------------------------------------------------------------------- 40 * Purpose: 41 * 42 * Inputs: 43 * psEASData - pointer to overall EAS data structure 44 * 45 * Outputs: 46 * 47 *---------------------------------------------------------------------------- 48*/ 49EAS_RESULT VMInitialize (S_EAS_DATA *pEASData); 50 51/*---------------------------------------------------------------------------- 52 * VMInitMIDI() 53 *---------------------------------------------------------------------------- 54 * Purpose: 55 * 56 * Inputs: 57 * psEASData - pointer to overall EAS data structure 58 * 59 * Outputs: 60 * 61 *---------------------------------------------------------------------------- 62*/ 63EAS_RESULT VMInitMIDI (S_EAS_DATA *pEASData, S_SYNTH **ppSynth); 64 65/*---------------------------------------------------------------------------- 66 * VMInitializeAllChannels() 67 *---------------------------------------------------------------------------- 68 * Purpose: 69 * 70 * Inputs: 71 * psEASData - pointer to overall EAS data structure 72 * 73 * Outputs: 74 * 75 *---------------------------------------------------------------------------- 76*/ 77void VMInitializeAllChannels (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth); 78 79/*---------------------------------------------------------------------------- 80 * VMResetControllers() 81 *---------------------------------------------------------------------------- 82 * Purpose: 83 * 84 * Inputs: 85 * psEASData - pointer to overall EAS data structure 86 * 87 * Outputs: 88 * 89 *---------------------------------------------------------------------------- 90*/ 91void VMResetControllers (S_SYNTH *pSynth); 92 93/*---------------------------------------------------------------------------- 94 * VMInitMIPTable() 95 *---------------------------------------------------------------------------- 96 * Purpose: 97 * Initialize the SP-MIDI MIP table 98 * 99 * Inputs: 100 * pEASData - pointer to synthesizer instance data 101 * mute - EAS_FALSE to unmute channels, EAS_TRUE to mute 102 * 103 * Outputs: 104 * 105 * 106 * Side Effects: 107 * 108 *---------------------------------------------------------------------------- 109*/ 110void VMInitMIPTable (S_SYNTH *pSynth); 111 112/*---------------------------------------------------------------------------- 113 * VMSetMIPEntry() 114 *---------------------------------------------------------------------------- 115 * Purpose: 116 * Sets the priority and MIP level for a MIDI channel 117 * 118 * Inputs: 119 * pEASData - pointer to synthesizer instance data 120 * channel - MIDI channel number 121 * priority - priority (0-15 with 0 = highest priority) 122 * mip - maximum instantaneous polyphony 123 * 124 * Outputs: 125 * 126 * 127 * Side Effects: 128 * 129 *---------------------------------------------------------------------------- 130*/ 131void VMSetMIPEntry (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_U8 channel, EAS_U8 priority, EAS_U8 mip); 132 133/*---------------------------------------------------------------------------- 134 * VMUpdateMIPTable() 135 *---------------------------------------------------------------------------- 136 * Purpose: 137 * This routine is called when the polyphony count in the synthesizer changes 138 * 139 * Inputs: 140 * pEASData - pointer to synthesizer instance data 141 * 142 * Outputs: 143 * 144 * 145 * Side Effects: 146 * 147 *---------------------------------------------------------------------------- 148*/ 149void VMUpdateMIPTable (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth); 150 151/*---------------------------------------------------------------------------- 152 * VMInitializeAllVoices() 153 *---------------------------------------------------------------------------- 154 * Purpose: 155 * 156 * Inputs: 157 * psEASData - pointer to overall EAS data structure 158 * 159 * Outputs: 160 * 161 *---------------------------------------------------------------------------- 162*/ 163void VMInitializeAllVoices (S_VOICE_MGR *pVoiceMgr, EAS_INT vSynthNum); 164 165/*---------------------------------------------------------------------------- 166 * VMStartNote() 167 *---------------------------------------------------------------------------- 168 * Purpose: 169 * Update the synth's state to play the requested note on the requested 170 * channel if possible. 171 * 172 * Inputs: 173 * nChannel - the MIDI channel 174 * nKeyNumber - the MIDI key number for this note 175 * nNoteVelocity - the key velocity for this note 176 * psEASData - pointer to overall EAS data structure 177 * 178 * Outputs: 179 * 180 *---------------------------------------------------------------------------- 181*/ 182void VMStartNote (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_U8 channel, EAS_U8 note, EAS_U8 velocity); 183 184/*---------------------------------------------------------------------------- 185 * VMCheckKeyGroup() 186 *---------------------------------------------------------------------------- 187 * Purpose: 188 * If the note that we've been asked to start is in the same key group as 189 * any currently playing notes, then we must shut down the currently playing 190 * note in the same key group and then start the newly requested note. 191 * 192 * Inputs: 193 * nChannel - synth channel that wants to start a new note 194 * nKeyNumber - new note's midi note number 195 * nRegionIndex - calling routine finds this index and gives to us 196 * nNoteVelocity - new note's velocity 197 * psEASData - pointer to overall EAS data structure 198 * 199 * Outputs: 200 * pbVoiceStealingRequired - flag: this routine sets true if we needed to 201 * steal a voice 202 * 203 * Side Effects: 204 * gsSynthObject.m_sVoice[free voice num].m_nKeyNumber may be assigned 205 * gsSynthObject.m_sVoice[free voice num].m_nVelocity may be assigned 206 *---------------------------------------------------------------------------- 207*/ 208void VMCheckKeyGroup (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_U16 keyGroup, EAS_U8 channel); 209 210/*---------------------------------------------------------------------------- 211 * VMCheckPolyphonyLimiting() 212 *---------------------------------------------------------------------------- 213 * Purpose: 214 * We only play at most 2 of the same note on a MIDI channel. 215 * E.g., if we are asked to start note 36, and there are already two voices 216 * that are playing note 36, then we must steal the voice playing 217 * the oldest note 36 and use that stolen voice to play the new note 36. 218 * 219 * Inputs: 220 * nChannel - synth channel that wants to start a new note 221 * nKeyNumber - new note's midi note number 222 * nNoteVelocity - new note's velocity 223 * psEASData - pointer to overall EAS data structure 224 * 225 * Outputs: 226 * pbVoiceStealingRequired - flag: this routine sets true if we needed to 227 * steal a voice 228 * * 229 * Side Effects: 230 * psSynthObject->m_sVoice[free voice num].m_nKeyNumber may be assigned 231 * psSynthObject->m_sVoice[free voice num].m_nVelocity may be assigned 232 *---------------------------------------------------------------------------- 233*/ 234EAS_BOOL VMCheckPolyphonyLimiting (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_U8 channel, EAS_U8 note, EAS_U8 velocity, EAS_U16 regionIndex, EAS_I32 lowVoice, EAS_I32 highVoice); 235 236/*---------------------------------------------------------------------------- 237 * VMStopNote() 238 *---------------------------------------------------------------------------- 239 * Purpose: 240 * Update the synth's state to end the requested note on the requested 241 * channel. 242 * 243 * Inputs: 244 * nChannel - the MIDI channel 245 * nKeyNumber - the key number of the note to stop 246 * nNoteVelocity - the note-off velocity 247 * psEASData - pointer to overall EAS data structure 248 * 249 * Outputs: 250 * Side Effects: 251 * gsSynthObject.m_sVoice[free voice num].m_nSynthChannel may be assigned 252 * gsSynthObject.m_sVoice[free voice num].m_nKeyNumber is assigned 253 * gsSynthObject.m_sVoice[free voice num].m_nVelocity is assigned 254 *---------------------------------------------------------------------------- 255*/ 256void VMStopNote (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_U8 channel, EAS_U8 key, EAS_U8 velocity); 257 258/*---------------------------------------------------------------------------- 259 * VMFindAvailableVoice() 260 *---------------------------------------------------------------------------- 261 * Purpose: 262 * Find an available voice and return the voice number if available. 263 * 264 * Inputs: 265 * pnVoiceNumber - really an output, see below 266 * psEASData - pointer to overall EAS data structure 267 * 268 * Outputs: 269 * pnVoiceNumber - returns the voice number of available voice if found 270 * success - if there is an available voice 271 * failure - otherwise 272 *---------------------------------------------------------------------------- 273*/ 274EAS_RESULT VMFindAvailableVoice (S_VOICE_MGR *pVoiceMgr, EAS_INT *pVoiceNumber, EAS_I32 lowVoice, EAS_I32 highVoice); 275 276/*---------------------------------------------------------------------------- 277 * VMStealVoice() 278 *---------------------------------------------------------------------------- 279 * Purpose: 280 * Steal a voice and return the voice number 281 * 282 * Stealing algorithm: steal the best choice with minimal work, taking into 283 * account SP-Midi channel priorities and polyphony allocation. 284 * 285 * In one pass through all the voices, figure out which voice to steal 286 * taking into account a number of different factors: 287 * Priority of the voice's MIDI channel 288 * Number of voices over the polyphony allocation for voice's MIDI channel 289 * Amplitude of the voice 290 * Note age 291 * Key velocity (for voices that haven't been started yet) 292 * If any matching notes are found 293 * 294 * Inputs: 295 * nChannel - the channel that this voice wants to be started on 296 * nKeyNumber - the key number for this new voice 297 * psEASData - pointer to overall EAS data structure 298 * 299 * Outputs: 300 * pnVoiceNumber - voice stolen 301 * EAS_RESULT EAS_SUCCESS - always successful 302 *---------------------------------------------------------------------------- 303*/ 304EAS_RESULT VMStealVoice (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_INT *pVoiceNumber, EAS_U8 channel, EAS_U8 note, EAS_I32 lowVoice, EAS_I32 highVoice); 305 306/*---------------------------------------------------------------------------- 307 * VMAddSamples() 308 *---------------------------------------------------------------------------- 309 * Purpose: 310 * Synthesize the requested number of samples. 311 * 312 * Inputs: 313 * nNumSamplesToAdd - number of samples to write to buffer 314 * psEASData - pointer to overall EAS data structure 315 * 316 * Outputs: 317 * number of samples actually written to buffer 318 * 319 * Side Effects: 320 * - samples are added to the presently free buffer 321 * 322 *---------------------------------------------------------------------------- 323*/ 324EAS_I32 VMAddSamples (S_VOICE_MGR *pVoiceMgr, EAS_I32 *pMixBuffer, EAS_I32 numSamplesToAdd); 325 326/*---------------------------------------------------------------------------- 327 * VMProgramChange() 328 *---------------------------------------------------------------------------- 329 * Purpose: 330 * Change the instrument (program) for the given channel. 331 * 332 * Depending on the program number, and the bank selected for this channel, the 333 * program may be in ROM, RAM (from SMAF or CMX related RAM wavetable), or 334 * Alternate wavetable (from mobile DLS or other DLS file) 335 * 336 * This function figures out what wavetable should be used, and sets it up as the 337 * wavetable to use for this channel. Also the channel may switch from a melodic 338 * channel to a rhythm channel, or vice versa. 339 * 340 * Inputs: 341 * 342 * Outputs: 343 * Side Effects: 344 * gsSynthObject.m_sChannel[nChannel].m_nProgramNumber is likely changed 345 * gsSynthObject.m_sChannel[nChannel].m_psEAS may be changed 346 * gsSynthObject.m_sChannel[nChannel].m_bRhythmChannel may be changed 347 * 348 *---------------------------------------------------------------------------- 349*/ 350void VMProgramChange (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_U8 channel, EAS_U8 program); 351 352/*---------------------------------------------------------------------------- 353 * VMChannelPressure() 354 *---------------------------------------------------------------------------- 355 * Purpose: 356 * Change the channel pressure for the given channel 357 * 358 * Inputs: 359 * nChannel - the MIDI channel 360 * nVelocity - the channel pressure value 361 * psEASData - pointer to overall EAS data structure 362 * 363 * Outputs: 364 * Side Effects: 365 * gsSynthObject.m_sChannel[nChannel].m_nChannelPressure is updated 366 *---------------------------------------------------------------------------- 367*/ 368void VMChannelPressure (S_SYNTH *pSynth, EAS_U8 channel, EAS_U8 value); 369 370/*---------------------------------------------------------------------------- 371 * VMPitchBend() 372 *---------------------------------------------------------------------------- 373 * Purpose: 374 * Change the pitch wheel value for the given channel. 375 * This routine constructs the proper 14-bit argument when the calling routine 376 * passes the pitch LSB and MSB. 377 * 378 * Note: some midi disassemblers display a bipolar pitch bend value. 379 * We can display the bipolar value using 380 * if m_nPitchBend >= 0x2000 381 * bipolar pitch bend = postive (m_nPitchBend - 0x2000) 382 * else 383 * bipolar pitch bend = negative (0x2000 - m_nPitchBend) 384 * 385 * Inputs: 386 * nChannel - the MIDI channel 387 * nPitchLSB - the LSB byte from the pitch bend message 388 * nPitchMSB - the MSB byte from the message 389 * psEASData - pointer to overall EAS data structure 390 * 391 * Outputs: 392 * 393 * Side Effects: 394 * gsSynthObject.m_sChannel[nChannel].m_nPitchBend is changed 395 * 396 *---------------------------------------------------------------------------- 397*/ 398void VMPitchBend (S_SYNTH *pSynth, EAS_U8 channel, EAS_U8 pitchLSB, EAS_U8 pitchMSB); 399 400/*---------------------------------------------------------------------------- 401 * VMControlChange() 402 *---------------------------------------------------------------------------- 403 * Purpose: 404 * Change the controller (or mode) for the given channel. 405 * 406 * Inputs: 407 * nChannel - the MIDI channel 408 * nControllerNumber - the controller number 409 * nControlValue - the controller number for this control change 410 * nControlValue - the value for this control change 411 * psEASData - pointer to overall EAS data structure 412 * 413 * Outputs: 414 * Side Effects: 415 * gsSynthObject.m_sChannel[nChannel] controller is changed 416 * 417 *---------------------------------------------------------------------------- 418*/ 419void VMControlChange (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_U8 channel, EAS_U8 controller, EAS_U8 value); 420 421/*---------------------------------------------------------------------------- 422 * VMUpdateRPNStateMachine() 423 *---------------------------------------------------------------------------- 424 * Purpose: 425 * Call this function when we want to parse a stream of RPN messages. 426 * NOTE: The synth has only one set of global RPN data instead of RPN data 427 * per channel. 428 * So actually, we don't really need to look at the nChannel parameter, 429 * but we pass it to facilitate future upgrades. Furthermore, we only 430 * support RPN0 (pitch bend sensitivity), RPN1 (fine tuning) and 431 * RPN2 (coarse tuning). Any other RPNs are rejected. 432 * 433 * Inputs: 434 * nChannel - the MIDI channel 435 * nControllerNumber - the RPN controller number 436 * nControlValue - the value for this control change 437 * psEASData - pointer to overall EAS data structure 438 * 439 * Outputs: 440 * 441 * Side Effects: 442 * gsSynthObject.m_RPN0 (or m_RPN1 or m_RPN2) may be updated if the 443 * proper RPN message sequence is parsed. 444 *---------------------------------------------------------------------------- 445*/ 446EAS_RESULT VMUpdateRPNStateMachine (S_SYNTH *pSynth, EAS_U8 channel, EAS_U8 controller, EAS_U8 value); 447 448/*---------------------------------------------------------------------------- 449 * VMUpdateStaticChannelParameters() 450 *---------------------------------------------------------------------------- 451 * Purpose: 452 * Update all of the static channel parameters for channels that have had 453 * a controller change values 454 * Or if the synth has signalled that all channels must forcibly 455 * be updated 456 * 457 * Inputs: 458 * psEASData - pointer to overall EAS data structure 459 * 460 * Outputs: 461 * none 462 * 463 * Side Effects: 464 * - psSynthObject->m_sChannel[].m_nStaticGain and m_nStaticPitch 465 * are updated for channels whose controller values have changed 466 * or if the synth has signalled that all channels must forcibly 467 * be updated 468 *---------------------------------------------------------------------------- 469*/ 470void VMUpdateStaticChannelParameters (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth); 471 472/*---------------------------------------------------------------------------- 473 * VMReleaseAllDeferredNoteOffs() 474 *---------------------------------------------------------------------------- 475 * Purpose: 476 * Call this functin when the sustain flag is presently set but 477 * we are now transitioning from damper pedal on to 478 * damper pedal off. This means all notes in this channel 479 * that received a note off while the damper pedal was on, and 480 * had their note-off requests deferred, should now proceed to 481 * the release state. 482 * 483 * Inputs: 484 * nChannel - this channel has its sustain pedal transitioning from on to off 485 * psEASData - pointer to overall EAS data structure 486 * 487 * Outputs: 488 * Side Effects: 489 * any voice with deferred note offs on this channel are updated such that 490 * 491 * 492 *---------------------------------------------------------------------------- 493*/ 494void VMReleaseAllDeferredNoteOffs (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_U8 channel); 495 496/*---------------------------------------------------------------------------- 497 * VMCatchNotesForSustainPedal() 498 *---------------------------------------------------------------------------- 499 * Purpose: 500 * Call this function when the sustain flag is presently clear and 501 * the damper pedal is off and we are transitioning from damper pedal OFF to 502 * damper pedal ON. Currently sounding notes should be left 503 * unchanged. However, we should try to "catch" notes if possible. 504 * If any notes have levels >= sustain level, catch them, 505 * otherwise, let them continue to release. 506 * 507 * Inputs: 508 * nChannel - this channel has its sustain pedal transitioning from on to off 509 * psEASData - pointer to overall EAS data structure 510 * 511 * Outputs: 512 * Side Effects: 513 * any voice with deferred note offs on this channel are updated such that 514 * psVoice->m_sEG1.m_eState = eEnvelopeStateSustainPedal 515 *---------------------------------------------------------------------------- 516*/ 517void VMCatchNotesForSustainPedal (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_U8 channel); 518 519/*---------------------------------------------------------------------------- 520 * VMUpdateAllNotesAge() 521 *---------------------------------------------------------------------------- 522 * Purpose: 523 * Increment the note age for all voices older than the age of the voice 524 * that is stopping, effectively making the voices "younger". 525 * 526 * Inputs: 527 * nAge - age of voice that is going away 528 * psEASData - pointer to overall EAS data structure 529 * 530 * Outputs: 531 * 532 * Side Effects: 533 * m_nAge for some voices is incremented 534 *---------------------------------------------------------------------------- 535*/ 536void VMUpdateAllNotesAge (S_VOICE_MGR *pVoiceMgr, EAS_U16 nAge); 537 538/*---------------------------------------------------------------------------- 539 * VMFindRegionIndex() 540 *---------------------------------------------------------------------------- 541 * Purpose: 542 * Find the region index for the given instrument using the midi key number 543 * and the RPN2 (coarse tuning) value. By using RPN2 as part of the 544 * region selection process, we reduce the amount a given sample has 545 * to be transposed by selecting the closest recorded root instead. 546 * 547 * Inputs: 548 * nChannel - current channel for this note 549 * nKeyNumber - current midi note number 550 * psEASData - pointer to overall EAS data structure 551 * 552 * Outputs: 553 * pnRegionIndex - valid only if we returned success 554 * success if we found the region index number, otherwise 555 * failure 556 * 557 * Side Effects: 558 *---------------------------------------------------------------------------- 559*/ 560EAS_RESULT VMFindRegionIndex (S_VOICE_MGR *pVoiceMgr, EAS_U8 channel, EAS_U8 note, EAS_U16 *pRegionIndex); 561 562/*---------------------------------------------------------------------------- 563 * VMIncRefCount() 564 *---------------------------------------------------------------------------- 565 * Increment reference count for virtual synth 566 *---------------------------------------------------------------------------- 567*/ 568void VMIncRefCount (S_SYNTH *pSynth); 569 570/*---------------------------------------------------------------------------- 571 * VMReset() 572 *---------------------------------------------------------------------------- 573 * Purpose: 574 * We call this routine to start the process of reseting the synth. 575 * This routine sets a flag for the entire synth indicating that we want 576 * to reset. 577 * We also force all voices to mute quickly. 578 * However, we do not actually perform any synthesis in this routine. That 579 * is, we do not ramp the voices down from this routine, but instead, we 580 * let the "regular" synth processing steps take care of adding the ramp 581 * down samples to the output buffer. After we are sure that all voices 582 * have completed ramping down, we continue the process of resetting the 583 * synth (from another routine). 584 * 585 * Inputs: 586 * psEASData - pointer to overall EAS data structure 587 * 588 * Outputs: 589 * 590 * Side Effects: 591 * - set a flag (in gsSynthObject.m_nFlags) indicating synth reset requested. 592 * - force all voices to update their envelope states to mute 593 * 594 *---------------------------------------------------------------------------- 595*/ 596void VMReset (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_BOOL force); 597 598/*---------------------------------------------------------------------------- 599 * VMMuteAllVoices() 600 *---------------------------------------------------------------------------- 601 * Purpose: 602 * We call this in an emergency reset situation. 603 * This forces all voices to mute quickly. 604 * 605 * Inputs: 606 * psEASData - pointer to overall EAS data structure 607 * 608 * Outputs: 609 * 610 * Side Effects: 611 * - forces all voices to update their envelope states to mute 612 * 613 *---------------------------------------------------------------------------- 614*/ 615void VMMuteVoice (S_VOICE_MGR *pVoiceMgr, EAS_I32 voiceNum); 616void VMMuteAllVoices (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth); 617 618/*---------------------------------------------------------------------------- 619 * VMReleaseAllVoices() 620 *---------------------------------------------------------------------------- 621 * Purpose: 622 * We call this after we've encountered the end of the Midi file. 623 * This ensures all voice are either in release (because we received their 624 * note off already) or forces them to mute quickly. 625 * We use this as a safety to prevent bad midi files from playing forever. 626 * 627 * Inputs: 628 * psEASData - pointer to overall EAS data structure 629 * 630 * Outputs: 631 * 632 * Side Effects: 633 * - forces all voices to update their envelope states to release or mute 634 * 635 *---------------------------------------------------------------------------- 636*/ 637void VMReleaseAllVoices (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth); 638 639/*---------------------------------------------------------------------------- 640 * VMAllNotesOff() 641 *---------------------------------------------------------------------------- 642 * Purpose: 643 * Quickly mute all notes on the given channel. 644 * 645 * Inputs: 646 * nChannel - quickly turn off all notes on this channel 647 * psEASData - pointer to overall EAS data structure 648 * 649 * Outputs: 650 * 651 * Side Effects: 652 * - forces all voices on this channel to update their envelope states to mute 653 * 654 *---------------------------------------------------------------------------- 655*/ 656void VMAllNotesOff (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_U8 channel); 657 658/*---------------------------------------------------------------------------- 659 * VMDeferredStopNote() 660 *---------------------------------------------------------------------------- 661 * Purpose: 662 * Stop the notes that had deferred note-off requests. 663 * 664 * Inputs: 665 * psEASData - pointer to overall EAS data structure 666 * 667 * Outputs: 668 * None. 669 * 670 * Side Effects: 671 * voices that have had deferred note-off requests are now put into release 672 * gsSynthObject.m_sVoice[i].m_nFlags has the VOICE_FLAG_DEFER_MIDI_NOTE_OFF 673 * cleared 674 *---------------------------------------------------------------------------- 675*/ 676void VMDeferredStopNote (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth); 677 678/*---------------------------------------------------------------------------- 679 * VMSetSynthPolyphony() 680 *---------------------------------------------------------------------------- 681 * Purpose: 682 * Set the synth to a new polyphony value. Value must be >= 1 and 683 * <= MAX_SYNTH_VOICES. This function will pin the polyphony at those limits 684 * 685 * Inputs: 686 * pVoiceMgr pointer to synthesizer data 687 * synth synthesizer number (0 = onboard, 1 = DSP) 688 * polyphonyCount desired polyphony count 689 * 690 * Outputs: 691 * 692 * Side Effects: 693 * 694 *---------------------------------------------------------------------------- 695*/ 696EAS_RESULT VMSetSynthPolyphony (S_VOICE_MGR *pVoiceMgr, EAS_I32 synth, EAS_I32 polyphonyCount); 697 698/*---------------------------------------------------------------------------- 699 * VMGetSynthPolyphony() 700 *---------------------------------------------------------------------------- 701 * Purpose: 702 * Set the synth to a new polyphony value. Value must be >= 1 and 703 * <= MAX_SYNTH_VOICES. This function will pin the polyphony at those limits 704 * 705 * Inputs: 706 * pVoiceMgr pointer to synthesizer data 707 * synth synthesizer number (0 = onboard, 1 = DSP) 708 * polyphonyCount desired polyphony count 709 * 710 * Outputs: 711 * 712 * Side Effects: 713 * 714 *---------------------------------------------------------------------------- 715*/ 716EAS_RESULT VMGetSynthPolyphony (S_VOICE_MGR *pVoiceMgr, EAS_I32 synth, EAS_I32 *pPolyphonyCount); 717 718/*---------------------------------------------------------------------------- 719 * VMSetPolyphony() 720 *---------------------------------------------------------------------------- 721 * Purpose: 722 * Set the virtual synth polyphony. 0 = no limit (i.e. can use 723 * all available voices). 724 * 725 * Inputs: 726 * pVoiceMgr pointer to synthesizer data 727 * polyphonyCount desired polyphony count 728 * pSynth pointer to virtual synth 729 * 730 * Outputs: 731 * Returns error code 732 * 733 * Side Effects: 734 * 735 *---------------------------------------------------------------------------- 736*/ 737EAS_RESULT VMSetPolyphony (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_I32 polyphonyCount); 738 739/*---------------------------------------------------------------------------- 740 * VMGetPolyphony() 741 *---------------------------------------------------------------------------- 742 * Purpose: 743 * Returns the current polyphony setting 744 * 745 * Inputs: 746 * pVoiceMgr pointer to synthesizer data 747 * pSynth pointer to virtual synth 748 * pPolyphonyCount pointer to variable to receive data 749 * 750 * Outputs: 751 * 752 * Side Effects: 753 * 754 *---------------------------------------------------------------------------- 755*/ 756EAS_RESULT VMGetPolyphony (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_I32 *pPolyphonyCount); 757 758/*---------------------------------------------------------------------------- 759 * VMSetPriority() 760 *---------------------------------------------------------------------------- 761 * Purpose: 762 * Set the virtual synth priority 763 * 764 * Inputs: 765 * pVoiceMgr pointer to synthesizer data 766 * priority new priority 767 * pSynth pointer to virtual synth 768 * 769 * Outputs: 770 * Returns error code 771 * 772 * Side Effects: 773 * 774 *---------------------------------------------------------------------------- 775*/ 776EAS_RESULT VMSetPriority (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_I32 priority); 777 778/*---------------------------------------------------------------------------- 779 * VMGetPriority() 780 *---------------------------------------------------------------------------- 781 * Purpose: 782 * Get the virtual synth priority 783 * 784 * Inputs: 785 * pVoiceMgr pointer to synthesizer data 786 * pPriority pointer to variable to hold priority 787 * pSynth pointer to virtual synth 788 * 789 * Outputs: 790 * Returns error code 791 * 792 * Side Effects: 793 * 794 *---------------------------------------------------------------------------- 795*/ 796EAS_RESULT VMGetPriority (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_I32 *pPriority); 797 798/*---------------------------------------------------------------------------- 799 * VMSetVolume() 800 *---------------------------------------------------------------------------- 801 * Purpose: 802 * Set the master volume for this sequence 803 * 804 * Inputs: 805 * nSynthVolume - the desired master volume 806 * psEASData - pointer to overall EAS data structure 807 * 808 * Outputs: 809 * 810 * 811 * Side Effects: 812 * overrides any previously set master volume from sysex 813 * 814 *---------------------------------------------------------------------------- 815*/ 816void VMSetVolume (S_SYNTH *pSynth, EAS_U16 masterVolume); 817 818/*---------------------------------------------------------------------------- 819 * VMSetPitchBendRange() 820 *---------------------------------------------------------------------------- 821 * Set the pitch bend range for the given channel. 822 *---------------------------------------------------------------------------- 823*/ 824void VMSetPitchBendRange (S_SYNTH *pSynth, EAS_INT channel, EAS_I16 pitchBendRange); 825 826/*---------------------------------------------------------------------------- 827 * VMSetEASLib() 828 *---------------------------------------------------------------------------- 829 * Purpose: 830 * Sets the pointer to the sound library 831 * 832 * Inputs: 833 * psEASData - pointer to overall EAS data structure 834 * 835 * Outputs: 836 * 837 *---------------------------------------------------------------------------- 838*/ 839EAS_RESULT VMSetGlobalEASLib (S_VOICE_MGR *pVoiceMgr, EAS_SNDLIB_HANDLE pEAS); 840EAS_RESULT VMSetEASLib (S_SYNTH *pSynth, EAS_SNDLIB_HANDLE pEAS); 841 842#ifdef DLS_SYNTHESIZER 843/*---------------------------------------------------------------------------- 844 * VMSetDLSLib() 845 *---------------------------------------------------------------------------- 846 * Purpose: 847 * Sets the pointer to the sound library 848 * 849 * Inputs: 850 * psEASData - pointer to overall EAS data structure 851 * 852 * Outputs: 853 * 854 *---------------------------------------------------------------------------- 855*/ 856EAS_RESULT VMSetGlobalDLSLib (EAS_DATA_HANDLE pEASData, EAS_DLSLIB_HANDLE pDLS); 857EAS_RESULT VMSetDLSLib (S_SYNTH *pSynth, EAS_DLSLIB_HANDLE pDLS); 858#endif 859 860/*---------------------------------------------------------------------------- 861 * VMSetTranposition() 862 *---------------------------------------------------------------------------- 863 * Purpose: 864 * Sets the global key transposition used by the synthesizer. 865 * Transposes all melodic instruments up or down by the specified 866 * amount. Range is limited to +/-12 semitones. 867 * 868 * Inputs: 869 * psEASData - pointer to overall EAS data structure 870 * transposition - transpose amount (+/-12) 871 * 872 * Outputs: 873 * 874 * 875 * Side Effects: 876 * 877 *---------------------------------------------------------------------------- 878*/ 879void VMSetTranposition (S_SYNTH *pSynth, EAS_I32 transposition); 880 881/*---------------------------------------------------------------------------- 882 * VMGetTranposition() 883 *---------------------------------------------------------------------------- 884 * Purpose: 885 * Gets the global key transposition used by the synthesizer. 886 * Transposes all melodic instruments up or down by the specified 887 * amount. Range is limited to +/-12 semitones. 888 * 889 * Inputs: 890 * psEASData - pointer to overall EAS data structure 891 * 892 * Outputs: 893 * 894 * 895 * Side Effects: 896 * 897 *---------------------------------------------------------------------------- 898*/ 899void VMGetTranposition (S_SYNTH *pSynth, EAS_I32 *pTransposition); 900 901/*---------------------------------------------------------------------------- 902 * VMGetNoteCount() 903 *---------------------------------------------------------------------------- 904* Returns the total note count 905*---------------------------------------------------------------------------- 906*/ 907EAS_I32 VMGetNoteCount (S_SYNTH *pSynth); 908 909/*---------------------------------------------------------------------------- 910 * VMRender() 911 *---------------------------------------------------------------------------- 912 * Purpose: 913 * This routine renders a frame of audio 914 * 915 * Inputs: 916 * psEASData - pointer to overall EAS data structure 917 * 918 * Outputs: 919 * pVoicesRendered - number of voices rendered this frame 920 * 921 * Side Effects: 922 * sets psMidiObject->m_nMaxWorkloadPerFrame 923 * 924 *---------------------------------------------------------------------------- 925*/ 926EAS_RESULT VMRender (S_VOICE_MGR *pVoiceMgr, EAS_I32 numSamples, EAS_I32 *pMixBuffer, EAS_I32 *pVoicesRendered); 927 928/*---------------------------------------------------------------------------- 929 * VMInitWorkload() 930 *---------------------------------------------------------------------------- 931 * Purpose: 932 * Clears the workload counter 933 * 934 * Inputs: 935 * pVoiceMgr - pointer to instance data 936 * 937 * Outputs: 938 * 939 * Side Effects: 940 * 941 *---------------------------------------------------------------------------- 942*/ 943void VMInitWorkload (S_VOICE_MGR *pVoiceMgr); 944 945/*---------------------------------------------------------------------------- 946 * VMSetWorkload() 947 *---------------------------------------------------------------------------- 948 * Purpose: 949 * Sets the max workload for a single frame. 950 * 951 * Inputs: 952 * pVoiceMgr - pointer to instance data 953 * 954 * Outputs: 955 * 956 * Side Effects: 957 * 958 *---------------------------------------------------------------------------- 959*/ 960void VMSetWorkload (S_VOICE_MGR *pVoiceMgr, EAS_I32 maxWorkLoad); 961 962/*---------------------------------------------------------------------------- 963 * VMCheckWorkload() 964 *---------------------------------------------------------------------------- 965 * Purpose: 966 * Checks to see if work load has been exceeded on this frame. 967 * 968 * Inputs: 969 * pVoiceMgr - pointer to instance data 970 * 971 * Outputs: 972 * 973 * Side Effects: 974 * 975 *---------------------------------------------------------------------------- 976*/ 977EAS_BOOL VMCheckWorkload (S_VOICE_MGR *pVoiceMgr); 978 979/*---------------------------------------------------------------------------- 980 * VMActiveVoices() 981 *---------------------------------------------------------------------------- 982 * Purpose: 983 * Returns the number of active voices in the synthesizer. 984 * 985 * Inputs: 986 * pEASData - pointer to instance data 987 * 988 * Outputs: 989 * Returns the number of active voices 990 * 991 * Side Effects: 992 * 993 *---------------------------------------------------------------------------- 994*/ 995EAS_I32 VMActiveVoices (S_SYNTH *pSynth); 996 997/*---------------------------------------------------------------------------- 998 * VMMIDIShutdown() 999 *---------------------------------------------------------------------------- 1000 * Purpose: 1001 * Clean up any Synth related system issues. 1002 * 1003 * Inputs: 1004 * psEASData - pointer to overall EAS data structure 1005 * 1006 * Outputs: 1007 * None 1008 * 1009 * Side Effects: 1010 * 1011 *---------------------------------------------------------------------------- 1012*/ 1013void VMMIDIShutdown (S_EAS_DATA *pEASData, S_SYNTH *pSynth); 1014 1015/*---------------------------------------------------------------------------- 1016 * VMShutdown() 1017 *---------------------------------------------------------------------------- 1018 * Purpose: 1019 * Clean up any Synth related system issues. 1020 * 1021 * Inputs: 1022 * psEASData - pointer to overall EAS data structure 1023 * 1024 * Outputs: 1025 * None 1026 * 1027 * Side Effects: 1028 * 1029 *---------------------------------------------------------------------------- 1030*/ 1031void VMShutdown (S_EAS_DATA *pEASData); 1032 1033#ifdef EXTERNAL_AUDIO 1034/*---------------------------------------------------------------------------- 1035 * EAS_RegExtAudioCallback() 1036 *---------------------------------------------------------------------------- 1037 * Register a callback for external audio processing 1038 *---------------------------------------------------------------------------- 1039*/ 1040void VMRegExtAudioCallback (S_SYNTH *pSynth, EAS_VOID_PTR pInstData, EAS_EXT_PRG_CHG_FUNC cbProgChgFunc, EAS_EXT_EVENT_FUNC cbEventFunc); 1041 1042/*---------------------------------------------------------------------------- 1043 * VMGetMIDIControllers() 1044 *---------------------------------------------------------------------------- 1045 * Returns the MIDI controller values on the specified channel 1046 *---------------------------------------------------------------------------- 1047*/ 1048void VMGetMIDIControllers (S_SYNTH *pSynth, EAS_U8 channel, S_MIDI_CONTROLLERS *pControl); 1049#endif 1050 1051#ifdef _SPLIT_ARCHITECTURE 1052/*---------------------------------------------------------------------------- 1053 * VMStartFrame() 1054 *---------------------------------------------------------------------------- 1055 * Purpose: 1056 * Starts an audio frame 1057 * 1058 * Inputs: 1059 * 1060 * Outputs: 1061 * 1062 * Side Effects: 1063 * 1064 *---------------------------------------------------------------------------- 1065*/ 1066EAS_BOOL VMStartFrame (S_EAS_DATA *pEASData); 1067 1068/*---------------------------------------------------------------------------- 1069 * VMEndFrame() 1070 *---------------------------------------------------------------------------- 1071 * Purpose: 1072 * Stops an audio frame 1073 * 1074 * Inputs: 1075 * 1076 * Outputs: 1077 * 1078 * Side Effects: 1079 * 1080 *---------------------------------------------------------------------------- 1081*/ 1082EAS_BOOL VMEndFrame (S_EAS_DATA *pEASData); 1083#endif 1084 1085#endif /* #ifdef _EAS_VM_PROTOS_H */ 1086 1087