Return to circbuf.c CVS log

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

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

1.1       root        1: /*
                      2:  * circbuf.c - Routines to manage the circular MIDI input buffer.
                      3:  *      This buffer is filled by the low-level callback function and
                      4:  *      emptied by the application.  Since this buffer is accessed
                      5:  *      by a low-level callback, memory for it must be allocated
                      6:  *      exactly as shown in AllocCircularBuffer().
                      7:  */
                      8: 
                      9: #include <windows.h>
                     10: #include "midimon.h"
                     11: #include "circbuf.h"
                     12: 
                     13: /*
                     14:  * AllocCircularBuffer -    Allocates memory for a CIRCULARBUFFER structure 
                     15:  * and a buffer of the specified size.  Each memory block is allocated 
                     16:  * with GlobalAlloc() using GMEM_SHARE and GMEM_MOVEABLE flags, locked 
                     17:  * with GlobalLock(), and page-locked with GlobalPageLock().
                     18:  *
                     19:  * Params:  dwSize - The size of the buffer, in events.
                     20:  *
                     21:  * Return:  A pointer to a CIRCULARBUFFER structure identifying the 
                     22:  *      allocated display buffer.  NULL if the buffer could not be allocated.
                     23:  */
                     24: LPCIRCULARBUFFER AllocCircularBuffer(DWORD dwSize)
                     25: {
                     26:     HANDLE hMem;
                     27:     LPCIRCULARBUFFER lpBuf;
                     28:     LPEVENT lpMem;
                     29:     
                     30:     /* Allocate and lock a CIRCULARBUFFER structure.
                     31:      */
                     32:     hMem = GlobalAlloc(GMEM_SHARE | GMEM_MOVEABLE,
                     33:                        (DWORD)sizeof(CIRCULARBUFFER));
                     34:     if(hMem == NULL)
                     35:         return NULL;
                     36: 
                     37:     lpBuf = (LPCIRCULARBUFFER)GlobalLock(hMem);
                     38:     if(lpBuf == NULL)
                     39:     {
                     40:         GlobalFree(hMem);
                     41:         return NULL;
                     42:     }
                     43:     
                     44:     /* Page lock the memory.  Global memory blocks accessed by
                     45:      * low-level callback functions must be page locked.
                     46:      */
                     47:     //GlobalPageLock((HGLOBAL)HIWORD(lpBuf));
                     48: 
                     49:     /* Save the memory handle.
                     50:      */
                     51:     lpBuf->hSelf = hMem;
                     52:     
                     53:     /* Allocate and lock memory for the actual buffer.
                     54:      */
                     55:     hMem = GlobalAlloc(GMEM_SHARE | GMEM_MOVEABLE, dwSize * sizeof(EVENT));
                     56:     if(hMem == NULL)
                     57:     {
                     58:        //GlobalPageUnlock((HGLOBAL)HIWORD(lpBuf));
                     59:         GlobalUnlock(lpBuf->hSelf);
                     60:         GlobalFree(lpBuf->hSelf);
                     61:         return NULL;
                     62:     }
                     63:     
                     64:     lpMem = (LPEVENT)GlobalLock(hMem);
                     65:     if(lpMem == NULL)
                     66:     {
                     67:         GlobalFree(hMem);
                     68:        //GlobalPageUnlock((HGLOBAL)HIWORD(lpBuf));
                     69:         GlobalUnlock(lpBuf->hSelf);
                     70:         GlobalFree(lpBuf->hSelf);
                     71:         return NULL;
                     72:     }
                     73:     
                     74:     /* Page lock the memory.  Global memory blocks accessed by
                     75:      * low-level callback functions must be page locked.
                     76:      */
                     77:     //GlobalPageLock((HGLOBAL)HIWORD(lpMem));
                     78:     
                     79:     /* Set up the CIRCULARBUFFER structure.
                     80:      */
                     81:     lpBuf->hBuffer = hMem;
                     82:     lpBuf->wError = 0;
                     83:     lpBuf->dwSize = dwSize;
                     84:     lpBuf->dwCount = 0L;
                     85:     lpBuf->lpStart = lpMem;
                     86:     lpBuf->lpEnd = lpMem + dwSize;
                     87:     lpBuf->lpTail = lpMem;
                     88:     lpBuf->lpHead = lpMem;
                     89:         
                     90:     return lpBuf;
                     91: }
                     92: 
                     93: /* FreeCircularBuffer - Frees the memory for the given CIRCULARBUFFER 
                     94:  * structure and the memory for the buffer it references.
                     95:  *
                     96:  * Params:  lpBuf - Points to the CIRCULARBUFFER to be freed.
                     97:  *
                     98:  * Return:  void
                     99:  */
                    100: void FreeCircularBuffer(LPCIRCULARBUFFER lpBuf)
                    101: {
                    102:     HANDLE hMem;
                    103:     
                    104:     /* Free the buffer itself.
                    105:      */
                    106:     //GlobalPageUnlock((HGLOBAL)HIWORD(lpBuf->lpStart));
                    107:     GlobalUnlock(lpBuf->hBuffer);
                    108:     GlobalFree(lpBuf->hBuffer);
                    109:     
                    110:     /* Free the CIRCULARBUFFER structure.
                    111:      */
                    112:     hMem = lpBuf->hSelf;
                    113:     //GlobalPageUnlock((HGLOBAL)HIWORD(lpBuf));
                    114:     GlobalUnlock(hMem);
                    115:     GlobalFree(hMem);
                    116: }
                    117: 
                    118: /* GetEvent - Gets a MIDI event from the circular input buffer.  Events
                    119:  *  are removed from the buffer.  The corresponding PutEvent() function
                    120:  *  is called by the low-level callback function, so it must reside in
                    121:  *  the callback DLL.  PutEvent() is defined in the CALLBACK.C module.
                    122:  *
                    123:  * Params:  lpBuf - Points to the circular buffer.
                    124:  *          lpEvent - Points to an EVENT structure that is filled with the
                    125:  *              retrieved event.
                    126:  *
                    127:  * Return:  Returns non-zero if successful, zero if there are no 
                    128:  *   events to get.
                    129:  */
                    130: WORD FAR PASCAL GetEvent(LPCIRCULARBUFFER lpBuf, LPEVENT lpEvent)
                    131: {
                    132:     /* If no event available, return.
                    133:      */
                    134:     if(lpBuf->dwCount <= 0)
                    135:         return 0;
                    136:     
                    137:     /* Get the event.
                    138:      */
                    139:     *lpEvent = *lpBuf->lpTail;
                    140:     
                    141:     /* Decrement the byte count, bump the tail pointer.
                    142:      */
                    143:     --lpBuf->dwCount;
                    144:     ++lpBuf->lpTail;
                    145:     
                    146:     /* Wrap the tail pointer, if necessary.
                    147:      */
                    148:     if(lpBuf->lpTail >= lpBuf->lpEnd)
                    149:         lpBuf->lpTail = lpBuf->lpStart;
                    150: 
                    151:     return 1;
                    152: }

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