Ignore:
Timestamp:
Jul 22, 2010, 8:20:48 PM (15 years ago)
Author:
David Azarewicz
Message:

debug statement cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified OCO/branches/DAZ/drv16/midistrm.cpp

    r468 r524  
    33/* SCCSID = %W% %E% */
    44/****************************************************************************
    5  *                                                                          *
    6  * Copyright (c) IBM Corporation 1994 - 1997.                               *
    7  *                                                                          *
    8  * The following IBM OS/2 source code is provided to you solely for the     *
     5 *                                                                                                                                                      *
     6 * Copyright (c) IBM Corporation 1994 - 1997.                                                           *
     7 *                                                                                                                                                      *
     8 * The following IBM OS/2 source code is provided to you solely for the         *
    99 * the purpose of assisting you in your development of OS/2 device drivers. *
    10  * You may use this code in accordance with the IBM License Agreement       *
    11  * provided in the IBM Device Driver Source Kit for OS/2.                   *
    12  *                                                                          *
     10 * You may use this code in accordance with the IBM License Agreement           *
     11 * provided in the IBM Device Driver Source Kit for OS/2.                                       *
     12 *                                                                                                                                                      *
    1313 ****************************************************************************/
    1414/**@internal %W%
    1515 * @notes
    16  *  MIDISTREAM class implementation.  The Midi Stream class is derived
    17  *  from the Stream class.
     16 *      MIDISTREAM class implementation.  The Midi Stream class is derived
     17 *      from the Stream class.
    1818 * @version %I%
    1919 * @context Unless otherwise noted, all interfaces are Ring-0, 16-bit,
    20  *  kernel stack.
     20 *      kernel stack.
    2121 * @history
    2222 *
    2323 */
    2424#define INCL_NOPMAPI
    25 #define INCL_DOSERRORS            // for ERROR_INVALID_FUNCTION
     25#define INCL_DOSERRORS                    // for ERROR_INVALID_FUNCTION
    2626#include <os2.h>
    2727#include <os2me.h>
    28 #include <audio.h>                // for #define MIDI
     28#include <audio.h>                                // for #define MIDI
    2929
    3030#include <include.h>
    … …  
    3939USHORT MIDISTREAM::_usBitNumber[ NUM_MidiChannels ] =
    4040  { 0x0001, 0x0002, 0x0004, 0x0008,
    41     0x0010, 0x0020, 0x0040, 0x0080,
    42     0x0100, 0x0200, 0x0400, 0x0800,
    43     0x1000, 0x2000, 0x4000, 0x8000 };
     41        0x0010, 0x0020, 0x0040, 0x0080,
     42        0x0100, 0x0200, 0x0400, 0x0800,
     43        0x1000, 0x2000, 0x4000, 0x8000 };
    4444
    4545
    4646/**@internal CalcDelay
    47  * @param    None
    48  * @return  None
     47 * @param        None
     48 * @return      None
    4949 * @notes
    50  *          600,000,000 microseconds/10 minutes
    51  *----------------------------------------------------------   ==   X microseconds/clock
    52  *                                    usCPQNnum
    53  *  (ulTempo beats/10 min) * ( 24 * ------------- clocks/beat )
    54  *                                    usCPQNden
    55  *
    56  *
    57  *      25,000,000 * usCPQNden
     50 *                      600,000,000 microseconds/10 minutes
     51 *----------------------------------------------------------   ==       X microseconds/clock
     52 *                                                                        usCPQNnum
     53 *      (ulTempo beats/10 min) * ( 24 * ------------- clocks/beat )
     54 *                                                                        usCPQNden
     55 *
     56 *
     57 *              25,000,000 * usCPQNden
    5858 *==  --------------------------
    59  *      ulTempo * usCPQNnum
     59 *              ulTempo * usCPQNnum
    6060 *
    6161 * where
    6262 * usCPQNden = ((usCPQN & 0x3F) + 1) * 3
    63  * usCPQNnum = 1                                    if bit 6 of usCPQN is set
    64  *
    65  *    or
     63 * usCPQNnum = 1                                                                        if bit 6 of usCPQN is set
     64 *
     65 *        or
    6666 *
    6767 * usCPQNden = 1
    68  * usCPQNnum = usCPQN + 1                           if bit 6 is not set
     68 * usCPQNnum = usCPQN + 1                                                       if bit 6 is not set
    6969 */
    7070void MIDISTREAM::CalcDelay(void)
    … …  
    7272   ULONG ul;
    7373
    74    if (usCPQN & 0x40) {         // bit 6 is set if it's a denominator
    75       ul = 25000000 * ((usCPQN & 0x3F) + 1);
    76       ulPerClock = ul / ulTempo;
    77       ulPerClock *= 3;
     74   if (usCPQN & 0x40) {                 // bit 6 is set if it's a denominator
     75          ul = 25000000 * ((usCPQN & 0x3F) + 1);
     76          ulPerClock = ul / ulTempo;
     77          ulPerClock *= 3;
    7878   } else {
    79       ul = ulTempo * (usCPQN+1);
    80       ulPerClock = 25000000 / ul;
     79          ul = ulTempo * (usCPQN+1);
     80          ulPerClock = 25000000 / ul;
    8181   }
    8282}
    … …  
    8484
    8585/**@external MIDISTRM::Process
    86  *  Consume MIDI bytes from the MMPM/2 stream buffers and send
    87  *  them off to the MIDI parser to be interpreted.
     86 *      Consume MIDI bytes from the MMPM/2 stream buffers and send
     87 *      them off to the MIDI parser to be interpreted.
    8888 * @param void
    8989 * @return void
    9090 * @notes Runs at Task time on a global context hook;  does not run
    91  *  on an interrupt level.  Interacts with the Timer object defined
    92  *  for this stream to obtain current time and to request next Stream
    93  *  time to be scheduled.
     91 *      on an interrupt level.  Interacts with the Timer object defined
     92 *      for this stream to obtain current time and to request next Stream
     93 *      time to be scheduled.
    9494 */
    9595void MIDISTREAM::Process( void )
    9696{
    97    ULONG ulNewTime;                    // Time, in mSec, on entry.
    98    ULONG ulElapsedTime;                // Elapsed time, last tick to this one.
     97   ULONG ulNewTime;                                // Time, in mSec, on entry.
     98   ULONG ulElapsedTime;                            // Elapsed time, last tick to this one.
    9999
    100100   // Update time variables.
    101101   ulNewTime = ((MIDIAUDIO*) pahw)->getTimer()->ulGetTime();
    102102   if ( ulNewTime > _ulLastProcess )
    103       ulElapsedTime = ulNewTime - _ulLastProcess;
     103          ulElapsedTime = ulNewTime - _ulLastProcess;
    104104   else
    105       ulElapsedTime = 0;
     105          ulElapsedTime = 0;
    106106
    107107   _ulLastProcess = ulNewTime;
    108108   ulCurrentTime = ulNewTime;
    109109
    110    if (qhInProcess.IsElements() == 0)   // no buffers to process?
    111       return;
    112 
    113    if (ulStreamState == STREAM_PAUSED)    // is the stream paused?
    114       return;
     110   if (qhInProcess.IsElements() == 0)   // no buffers to process?
     111          return;
     112
     113   if (ulStreamState == STREAM_PAUSED)    // is the stream paused?
     114          return;
    115115
    116116   ProcessEvents();
    … …  
    123123
    124124   while (lWait <= 0 && qhInProcess.IsElements()) {
    125       parse(*(pbuff + (pstreambuff->ulBuffpos)++));
    126 
    127       if (pstreambuff->ulBuffpos >= buffsz) {
    128         qhDone.PushOnTail(qhInProcess.PopHead());
    129         pstreambuff = (PSTREAMBUFFER) qhInProcess.Head();
    130         pbuff = pstreambuff->pBuffptr;
    131         buffsz = pstreambuff->ulBuffsz;
    132       }
     125          parse(*(pbuff + (pstreambuff->ulBuffpos)++));
     126
     127          if (pstreambuff->ulBuffpos >= buffsz) {
     128                qhDone.PushOnTail(qhInProcess.PopHead());
     129                pstreambuff = (PSTREAMBUFFER) qhInProcess.Head();
     130                pbuff = pstreambuff->pBuffptr;
     131                buffsz = pstreambuff->ulBuffsz;
     132          }
    133133   }
    134134   while (qhDone.IsElements())
    135       ReturnBuffer();
     135          ReturnBuffer();
    136136
    137137   // Determine next time to run.  If we submit a time that has already
    … …  
    163163}
    164164/**@internal MIDISTREAM::_allNotesOff
    165  *  Shut off all notes that are currently playing.
     165 *      Shut off all notes that are currently playing.
    166166 * @param None.
    167167 * @return void
    168168 * @notes This function walks the _notesOn array and shuts off any note
    169  *  that is flagged as being actively played.
     169 *      that is flagged as being actively played.
    170170 */
    171171void MIDISTREAM::_allNotesOff( void )
    172172{
    173173   for ( USHORT noteNum=0; noteNum < NUM_MidiNotes; ++noteNum)
    174       if (_notesOn[noteNum])
    175         // This note number is playing on one or more channels.
    176         // Shut the note off on all channels on which it is playing.
    177         for ( USHORT mchan=0; mchan < NUM_MidiChannels; ++mchan)
    178             if (_notesOn[noteNum] & _usBitNumber[mchan]) {
    179                pahw->noteOff(StreamId,  (BYTE)mchan, (BYTE)noteNum, 0 );
    180                _notesOn[noteNum] &= ~(_usBitNumber[mchan]);
    181             }
     174          if (_notesOn[noteNum])
     175                // This note number is playing on one or more channels.
     176                // Shut the note off on all channels on which it is playing.
     177                for ( USHORT mchan=0; mchan < NUM_MidiChannels; ++mchan)
     178                        if (_notesOn[noteNum] & _usBitNumber[mchan]) {
     179                           pahw->noteOff(StreamId,      (BYTE)mchan, (BYTE)noteNum, 0 );
     180                           _notesOn[noteNum] &= ~(_usBitNumber[mchan]);
     181                        }
    182182}
    183183//******************************************************************************
    … …  
    185185ULONG  MIDISTREAM::StartStream(void)
    186186{
    187 //    dprintf(("MIDISTREAM::StartStream %lx %lx", (void far *)this, StreamId));
    188    
    189     state = S_Init;                        // Reset parser state.
    190     message.clear();                       // Clear current message.
    191     lWait = 0;  //SvL, reset this too
    192 
    193     pahw->getTimer()->vSetTime(ulCurrentTime);
    194     if (!pahw->Start(StreamId)) {
    195         DebugInt3();
    196         return ERROR_START_STREAM;
    197     }
    198 
    199     ulStreamState = STREAM_STREAMING;
    200     pahw->SetVolume(StreamId, getMixerStreamId(), volume);
    201     return NO_ERROR;
     187        //dprintf(("MIDISTREAM::StartStream %lx %lx", (void far *)this, StreamId));
     188
     189        state = S_Init;                                            // Reset parser state.
     190        message.clear();                                           // Clear current message.
     191        lWait = 0;      //SvL, reset this too
     192
     193        pahw->getTimer()->vSetTime(ulCurrentTime);
     194        if (!pahw->Start(StreamId)) {
     195                DebugInt3();
     196                return ERROR_START_STREAM;
     197        }
     198
     199        ulStreamState = STREAM_STREAMING;
     200        pahw->SetVolume(StreamId, getMixerStreamId(), volume);
     201        return NO_ERROR;
    202202}
    203203//******************************************************************************
    … …  
    205205ULONG  MIDISTREAM::StopStream(PCONTROL_PARM pControl)
    206206{
    207     if(ulStreamState == STREAM_STOPPED) {
    208 //              dprintf(("MIDISTREAM::StopStream %lx (already stopped)", StreamId));
    209             pControl->ulTime = GetCurrentTime();
    210             return NO_ERROR;
    211     }
    212 
    213 //    dprintf(("MIDISTREAM::StopStream %lx %lx", (void far *)this, StreamId));
    214     ulStreamState = STREAM_STOPPED;
    215     pahw->Stop(StreamId);
    216     _allNotesOff();
    217     ReturnBuffers();
    218     pControl->ulTime = GetCurrentTime();
    219     return NO_ERROR;
     207        if(ulStreamState == STREAM_STOPPED) {
     208                //dprintf(("MIDISTREAM::StopStream %lx (already stopped)", StreamId));
     209                pControl->ulTime = GetCurrentTime();
     210                return NO_ERROR;
     211        }
     212
     213        //dprintf(("MIDISTREAM::StopStream %lx %lx", (void far *)this, StreamId));
     214        ulStreamState = STREAM_STOPPED;
     215        pahw->Stop(StreamId);
     216        _allNotesOff();
     217        ReturnBuffers();
     218        pControl->ulTime = GetCurrentTime();
     219        return NO_ERROR;
    220220}
    221221//******************************************************************************
    … …  
    223223ULONG  MIDISTREAM::PauseStream(PCONTROL_PARM pControl)
    224224{
    225 //    dprintf(("MIDISTREAM::PauseStream %lx %lx", (void far *)this, StreamId));
    226     if (ulStreamState == STREAM_PAUSED) {   // is the stream paused?
    227         DebugInt3();
    228         return ERROR_INVALID_SEQUENCE;
    229     }
    230 
    231     pahw->Stop(StreamId);
    232     _allNotesOff();
    233     pControl->ulTime = GetCurrentTime();
    234     ulStreamState = STREAM_PAUSED;
    235     return NO_ERROR;
     225        //dprintf(("MIDISTREAM::PauseStream %lx %lx", (void far *)this, StreamId));
     226        if (ulStreamState == STREAM_PAUSED) {   // is the stream paused?
     227                DebugInt3();
     228                return ERROR_INVALID_SEQUENCE;
     229        }
     230
     231        pahw->Stop(StreamId);
     232        _allNotesOff();
     233        pControl->ulTime = GetCurrentTime();
     234        ulStreamState = STREAM_PAUSED;
     235        return NO_ERROR;
    236236}
    237237//******************************************************************************
    … …  
    239239ULONG  MIDISTREAM::ResumeStream(void)
    240240{
    241 //    dprintf(("MIDISTREAM::ResumeStream %lx %lx", (void far *)this, StreamId));
    242     if (ulStreamState != STREAM_PAUSED) {   // is the stream paused?
    243         DebugInt3();
    244         return ERROR_INVALID_SEQUENCE;
    245     }
    246 
    247     state = S_Init;                        // Reset parser state.
    248     message.clear();                       // Clear current message.
    249     pahw->getTimer()->vSetTime(ulCurrentTime);
    250     pahw->Start(StreamId);
    251     pahw->SetVolume(StreamId, getMixerStreamId(), volume);
    252     ulStreamState = STREAM_STREAMING;
    253     return NO_ERROR;
     241        //dprintf(("MIDISTREAM::ResumeStream %lx %lx", (void far *)this, StreamId));
     242        if (ulStreamState != STREAM_PAUSED) {   // is the stream paused?
     243                DebugInt3();
     244                return ERROR_INVALID_SEQUENCE;
     245        }
     246
     247        state = S_Init;                                            // Reset parser state.
     248        message.clear();                                           // Clear current message.
     249        pahw->getTimer()->vSetTime(ulCurrentTime);
     250        pahw->Start(StreamId);
     251        pahw->SetVolume(StreamId, getMixerStreamId(), volume);
     252        ulStreamState = STREAM_STREAMING;
     253        return NO_ERROR;
    254254}
    255255//******************************************************************************
    … …  
    257257BOOL MIDISTREAM::SetProperty(int type, ULONG value, ULONG reserved)
    258258{
    259     switch(type) {
    260     case PROPERTY_VOLUME:
    261         volume = value;
    262         if(ulStreamState == STREAM_STREAMING) {
    263            pahw->SetVolume(StreamId, getMixerStreamId(), volume);
    264         }
    265         break;
    266 
    267     default:
    268         return STREAM::SetProperty(type, value, reserved);
    269     }
    270     return TRUE;
     259        switch(type) {
     260        case PROPERTY_VOLUME:
     261                volume = value;
     262                if(ulStreamState == STREAM_STREAMING) {
     263                   pahw->SetVolume(StreamId, getMixerStreamId(), volume);
     264                }
     265                break;
     266
     267        default:
     268                return STREAM::SetProperty(type, value, reserved);
     269        }
     270        return TRUE;
    271271}
    272272//******************************************************************************
    … …  
    275275   STREAM(streamtype, filesysnum, mixerStreamId)
    276276{
    277 //    dprintf(("MIDISTREAM::ctor"));
    278 
    279     // get the pointer to the hardware object
    280     pahw = (MIDIAUDIO *)GetHardwareDevice(streamtype);
    281     if(pahw) {
    282         if(pahw->Open(0, streamtype, filesysnum, &StreamId) == FALSE) {
    283 //            dprintf(("MIDISTREAM ctor: open failed!!"));
    284             DebugInt3();
    285         }
    286     }
    287     else DebugInt3();
    288 
    289     // Initialize tempo & scheduling information.
    290     ulTempo = 1200;
    291     usCPQN = 0;
    292     CalcDelay();
    293     lWait = 0;
    294     _ulLastProcess = 0;
    295 
    296     // Reset the parser.
    297     state = S_Init;
    298     message.clear();
    299 
    300     // Reset our tracking of which notes are currently on.
    301     for (int i=0; i<NUM_MidiNotes; ++i)
    302         _notesOn[ i ] = 0;
     277        //dprintf(("MIDISTREAM::ctor"));
     278
     279        // get the pointer to the hardware object
     280        pahw = (MIDIAUDIO *)GetHardwareDevice(streamtype);
     281        if(pahw) {
     282                if(pahw->Open(0, streamtype, filesysnum, &StreamId) == FALSE) {
     283//                        dprintf(("MIDISTREAM ctor: open failed!!"));
     284                        DebugInt3();
     285                }
     286        }
     287        else DebugInt3();
     288
     289        // Initialize tempo & scheduling information.
     290        ulTempo = 1200;
     291        usCPQN = 0;
     292        CalcDelay();
     293        lWait = 0;
     294        _ulLastProcess = 0;
     295
     296        // Reset the parser.
     297        state = S_Init;
     298        message.clear();
     299
     300        // Reset our tracking of which notes are currently on.
     301        for (int i=0; i<NUM_MidiNotes; ++i)
     302                _notesOn[ i ] = 0;
    303303}
    304304//******************************************************************************
    … …  
    306306MIDISTREAM::~MIDISTREAM()
    307307{
    308     if(StreamId && pahw) {
    309         pahw->Close(StreamId);
    310     }
    311 }
    312 //******************************************************************************
    313 //******************************************************************************
    314 
     308        if(StreamId && pahw) {
     309                pahw->Close(StreamId);
     310        }
     311}
     312//******************************************************************************
     313//******************************************************************************
     314
Note: See TracChangeset for help on using the changeset viewer.