Return to callback.c CVS log

Up to [WindowsNT SDKs] / mstools / samples / midimon

Annotation of mstools/samples/midimon/callback.c, revision 1.1.1.1

1.1       root        1: /* callback.c - Contains the low-level MIDI input callback function for
                      2:  *      MIDIMon.  This module also contains the LibMain() and WEP() 
                      3:  *      DLL routines, and other functions accessed by the callback.
                      4:  *
                      5:  *      Because this module contains a low-level callback function,
                      6:  *      this entire module must reside in a FIXED code segment in a DLL.
                      7:  *      The data segment must be FIXED as well, since it accessed by
                      8:  *      the callback.
                      9:  */
                     10: 
                     11: #include <windows.h>
                     12: #include <mmsystem.h>
                     13: #include "midimon.h"
                     14: #include "circbuf.h"
                     15: #include "instdata.h"
                     16: #include "callback.h"
                     17: 
                     18: static EVENT event;
                     19:     
                     20: /* midiInputHandler - Low-level callback function to handle MIDI input.
                     21:  *      Installed by midiInOpen().  The input handler takes incoming
                     22:  *      MIDI events and places them in the circular input buffer.  It then
                     23:  *      notifies the application by posting a MM_MIDIINPUT message.
                     24:  *
                     25:  *      This function is accessed at interrupt time, so it should be as 
                     26:  *      fast and efficient as possible.  You can't make any
                     27:  *      Windows calls here, except PostMessage().  The only Multimedia
                     28:  *      Windows call you can make are timeGetSystemTime(), midiOutShortMsg().
                     29:  *      
                     30:  *
                     31:  * Param:   hMidiIn - Handle for the associated input device.
                     32:  *          wMsg - One of the MIM_***** messages.
                     33:  *          dwInstance - Points to CALLBACKINSTANCEDATA structure.
                     34:  *          dwParam1 - MIDI data.
                     35:  *          dwParam2 - Timestamp (in milliseconds)
                     36:  *
                     37:  * Return:  void
                     38:  */     
                     39: void FAR PASCAL midiInputHandler(
                     40: HMIDIIN hMidiIn, 
                     41: WORD wMsg, 
                     42: DWORD dwInstance, 
                     43: DWORD dwParam1, 
                     44: DWORD dwParam2)
                     45: {
                     46:     UNREFERENCED_PARAMETER(hMidiIn);
                     47: 
                     48:     switch(wMsg)
                     49:     {
                     50:         case MIM_OPEN:
                     51:             break;
                     52: 
                     53:         /* The only error possible is invalid MIDI data, so just pass
                     54:          * the invalid data on so we'll see it.
                     55:          */
                     56:         case MIM_ERROR:
                     57:         case MIM_DATA:
                     58:             event.dwDevice = ((LPCALLBACKINSTANCEDATA)dwInstance)->dwDevice;
                     59:             event.data = dwParam1;
                     60:             event.timestamp = dwParam2;
                     61:             
                     62:             /* Send the MIDI event to the MIDI Mapper, put it in the
                     63:              * circular input buffer, and notify the application that
                     64:              * data was received.
                     65:              */
                     66:             if(((LPCALLBACKINSTANCEDATA)dwInstance)->hMapper)
                     67:                 midiOutShortMsg( 
                     68:                             ((LPCALLBACKINSTANCEDATA)dwInstance)->hMapper, 
                     69:                               dwParam1);
                     70: 
                     71:             PutEvent(((LPCALLBACKINSTANCEDATA)dwInstance)->lpBuf,
                     72:                        (LPEVENT) &event); 
                     73: 
                     74:             PostMessage(((LPCALLBACKINSTANCEDATA)dwInstance)->hWnd,
                     75:                           MM_MIDIINPUT, 0, 0L);
                     76: 
                     77:             break;
                     78: 
                     79:         default:
                     80:             break;
                     81:     }
                     82: }
                     83: 
                     84: /* PutEvent - Puts an EVENT in a CIRCULARBUFFER.  If the buffer is full, 
                     85:  *      it sets the wError element of the CIRCULARBUFFER structure 
                     86:  *      to be non-zero.
                     87:  *
                     88:  * Params:  lpBuf - Points to the CIRCULARBUFFER.
                     89:  *          lpEvent - Points to the EVENT.
                     90:  *
                     91:  * Return:  void
                     92: */
                     93: void FAR PASCAL PutEvent(LPCIRCULARBUFFER lpBuf, LPEVENT lpEvent)
                     94: {
                     95:     /* If the buffer is full, set an error and return. 
                     96:      */
                     97:     if(lpBuf->dwCount >= lpBuf->dwSize){
                     98:         lpBuf->wError = 1;
                     99:         return;
                    100:     }
                    101:     
                    102:     /* Put the event in the buffer, bump the head pointer and the byte count.
                    103:      */
                    104:     *lpBuf->lpHead = *lpEvent;
                    105:     
                    106:     ++lpBuf->lpHead;
                    107:     ++lpBuf->dwCount;
                    108: 
                    109:     /* Wrap the head pointer, if necessary.
                    110:      */
                    111:     if(lpBuf->lpHead >= lpBuf->lpEnd)
                    112:         lpBuf->lpHead = lpBuf->lpStart;
                    113: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.