source: cmedia/trunk/Drv16/midistrm.cpp

/* $Id: midistrm.cpp,v 1.2 2000/04/24 19:45:17 sandervl Exp $ */

/* SCCSID = %W% %E% */
/****************************************************************************
 *                                                                          *
 * Copyright (c) IBM Corporation 1994 - 1997.                               *
 *                                                                          *
 * The following IBM OS/2 source code is provided to you solely for the     *
 * the purpose of assisting you in your development of OS/2 device drivers. *
 * You may use this code in accordance with the IBM License Agreement       *
 * provided in the IBM Device Driver Source Kit for OS/2.                   *
 *                                                                          *
 ****************************************************************************/
/**@internal %W%
 * @notes
 *  MIDISTREAM class implementation.  The Midi Stream class is derived
 *  from the Stream class.
 * @version %I%
 * @context Unless otherwise noted, all interfaces are Ring-0, 16-bit,
 *  kernel stack.
 * @history
 *
 */
#define INCL_NOPMAPI
#define INCL_DOSERRORS            // for ERROR_INVALID_FUNCTION
#include <os2.h>
#include <os2me.h>
#include <audio.h>                // for #define MIDI

#include <include.h>
#include <devhelp.h>

#include "midistrm.hpp"
#include "event.hpp"
#include "maudio.hpp"

#include <ossidc.h>
#include <dbgos2.h>


/**@internal CalcDelay
 * @param    None
 * @return   None
 * @notes
 *           600,000,000 microseconds/10 minutes
 *----------------------------------------------------------   ==   X microseconds/clock
 *                                    usCPQNnum
 *  (ulTempo beats/10 min) * ( 24 * ------------- clocks/beat )
 *                                    usCPQNden
 *
 *
 *      25,000,000 * usCPQNden
 *==  --------------------------
 *       ulTempo * usCPQNnum
 *
 * where
 * usCPQNden = ((usCPQN & 0x3F) + 1) * 3
 * usCPQNnum = 1                                    if bit 6 of usCPQN is set
 *
 *    or
 *
 * usCPQNden = 1
 * usCPQNnum = usCPQN + 1                           if bit 6 is not set
 */
void MIDISTREAM::CalcDelay(void)
{
   ULONG ul;

   if (usCPQN & 0x40) {          // bit 6 is set if it's a denominator
      ul = 25000000 * ((usCPQN & 0x3F) + 1);
      ulPerClock = ul / ulTempo;
//      ulPerClock *= 3;
      ulPerClock += ulPerClock << 1;
   } else {
      ul = ulTempo * (usCPQN+1);
      ulPerClock = 25000000 / ul;
   }
}


/**@internal MIDISTREAM::_allNotesOff
 *  Shut off all notes that are currently playing.
 * @param None.
 * @return void
 * @notes This function walks the _notesOn array and shuts off any note
 *  that is flagged as being actively played.
 */
void MIDISTREAM::_allNotesOff( void )
{
   USHORT       noteNum, mchan, chanmask;

   for (noteNum = 0; noteNum < NUM_MidiNotes; ++noteNum)
      if (_notesOn[noteNum])
         // This note number is playing on one or more channels.
         // Shut the note off on all channels on which it is playing.
         for (mchan = 0; mchan < NUM_MidiChannels; ++mchan)  {
            chanmask = 1 << mchan;
            if (_notesOn[noteNum] & chanmask) {
               ((MIDIAUDIO*) pahw)->noteOff((BYTE)mchan, (BYTE)noteNum, 0 );
               _notesOn[noteNum] &= ~chanmask;
            }
         }
}


/**@external MIDISTRM::Process
 *  Consume MIDI bytes from the MMPM/2 stream buffers and send
 *  them off to the MIDI parser to be interpreted.
 * @param void
 * @return void
 * @notes Runs at Task time on a global context hook;  does not run
 *  on an interrupt level.  Interacts with the Timer object defined
 *  for this stream to obtain current time and to request next Stream
 *  time to be scheduled.
 */
void MIDISTREAM::Process( void )
{
   ULONG                ulNewTime;      // Time, in mSec, on entry.
   ULONG                ulElapsedTime;  // Elapsed time, last tick to this one.
   ULONG                ulTimeNextRun;
   PSTREAMBUFFER        pStrmBuf;
   PSTREAMBUF           pData;

   // Update time variables.
   ulNewTime = GetCurrentTime();

   ulElapsedTime =
        ( ulNewTime > _ulLastProcess ) ?  (ulNewTime - _ulLastProcess) : 0;

   _ulLastProcess = ulCurrentTime = ulNewTime;

// Rudi: check for !STREAM_STREAMING instead of STREAM_PAUSED
   if (!qhInProcess.IsElements() ||             // no buffers to process?
        usStreamState != STREAM_STREAMING)      // is the stream paused?
      return;

   ProcessEvents();

   lWait -= ulElapsedTime * 1000;

   while (lWait <= 0 && (pStrmBuf = (PSTREAMBUFFER)qhInProcess.Head()) != NULL) {

     pData = pStrmBuf->pBuffptr;

     while (lWait <= 0) {
       parse(pData[pStrmBuf->ulBuffpos++]);

       if (pStrmBuf->ulBuffpos >= pStrmBuf->ulBuffsz) {
         qhDone.PushOnTail(qhInProcess.PopHead());
         break;
       }
     }
   }

   // Return finished buffer(s)
   while (qhDone.IsElements())
      ReturnBuffer();

   // Determine next time to run.  If we submit a time that has already
   // passed, we'll get scheduled for the next tick.
   ulTimeNextRun = ulCurrentTime + (lWait / 1000);
   ((MIDIAUDIO*) pahw)->getTimer()->vSchedule( ulTimeNextRun );
}


// ### By getting Timer time, we're assuming that this stream owns the HW.
ULONG MIDISTREAM::GetCurrentTime(void)
{
   return ((MIDIAUDIO*) pahw)->getTimer()->ulGetTime();
}


// ### By setting Timer time, we're assuming that this stream owns the HW.
void MIDISTREAM::SetCurrentTime(ULONG time)
{
   ((MIDIAUDIO*) pahw)->getTimer()->vSetTime( time );
   ulCurrentTime = time;

dprintf(("SetCurrentTime: %ld", ulCurrentTime));
}


ULONG MIDISTREAM::Read(PSTREAMBUF, unsigned)
{
   return ERROR_INVALID_FUNCTION;
}


// Rudi: we need to do this multilpe times
void MIDISTREAM::ResetParser(BOOL fFreshStart)
{
   if( fFreshStart )  {
        usCPQN  = 0;                            // default values
        ulTempo = 1200;
        CalcDelay();                            // initialize ulPerClock
   }

   lWait = 0;                                   // SvL, reset this too
   _ulLastProcess = ulCurrentTime;              // Rudi

   state = S_Init;                              // Reset parser state.

//   message.clear();                           // parse() does this ...
}


ULONG  MIDISTREAM::StartStream(void)
{
   USHORT       usOldState;

dprintf(("MIDISTREAM::StartStream"));

   if (usStreamState == STREAM_STREAMING)       // already started
      return ERROR_INVALID_SEQUENCE;

   ResetParser(TRUE);                           // Rudi

   usOldState = usStreamState;
   usStreamState = STREAM_STREAMING;
   if( !pahw->Start(this) )  {
      usStreamState = usOldState;
      return ERROR_START_STREAM;
   }

   OSS16_SetMidiOutVol(this, volume);
   return NO_ERROR;
}


ULONG  MIDISTREAM::StopStream(PCONTROL_PARM pControl)
{
   if (usStreamState == STREAM_STOPPED)         // is the stream stopped ?
      return ERROR_INVALID_SEQUENCE;

   pahw->Stop(this);
   _allNotesOff();
   ReturnBuffers();

   pControl->ulTime = GetCurrentTime();
   usStreamState = STREAM_STOPPED;

dprintf(("MIDISTREAM::StopStream %ld", pControl->ulTime));
   return NO_ERROR;
}


ULONG  MIDISTREAM::PauseStream(PCONTROL_PARM pControl)
{
// Rudi: allow Resume on suspend
   if (usStreamState == STREAM_PAUSED)          // is the stream paused ?
      return ERROR_INVALID_SEQUENCE;

   pahw->Pause(this);
   _allNotesOff();

   pControl->ulTime = GetCurrentTime();
   usStreamState = STREAM_PAUSED;

dprintf(("MIDISTREAM::PauseStream %ld", pControl->ulTime));
   return NO_ERROR;
}


ULONG  MIDISTREAM::ResumeStream(void)
{
   USHORT       usOldState;

dprintf(("MIDISTREAM::ResumeStream"));

// Rudi: allow Resume on suspend
   if (usStreamState == STREAM_STREAMING)       // is the stream not running ?
      return ERROR_INVALID_SEQUENCE;

   ResetParser(FALSE);                          // Rudi

   usOldState = usStreamState;
   usStreamState = STREAM_STREAMING;
   if( !pahw->Resume(this) )  {
      usStreamState = usOldState;
      return ERROR_START_STREAM;
   }

   OSS16_SetMidiOutVol(this, volume);
   return NO_ERROR;
}


MIDISTREAM::MIDISTREAM(USHORT streamtype, USHORT filesysnum):
   STREAM(streamtype, filesysnum)
{
   // Initialize tempo & scheduling information.
   ulCurrentTime = 0;
   ResetParser(TRUE);

   // Reset our tracking of which notes are currently on.
   memset(_notesOn, 0, sizeof(_notesOn));

// Rudi: set stereo volume
   volume = MAKE_VOLUME_LR(100, 100);
}


BOOL MIDISTREAM::SetProperty(int type, ULONG value, ULONG reserved)
{
   if( type == PROPERTY_VOLUME && volume != value ) {
       volume = value;  mixerchange = TRUE;
       if( usStreamState == STREAM_STREAMING ) {
          OSS16_SetMidiOutVol(this, volume);
       }
       return TRUE;
   }

   return STREAM::SetProperty(type, value, reserved);
}