![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to display.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / midimon|
Return to display.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / midimon |
1.1 root 1: /*
2: * display.c - Functions to manage the display buffer and convert a
3: * MIDI event to a text string for display.
4: *
5: * The display buffer is filled by the application's WndProc()
6: * function when it receives an MM_MIDIINPUT message. This message
7: * is sent by the low-level callback function upon reception of a
8: * MIDI event. When the display buffer becomes full, newly added
9: * events overwrite the oldest events in the buffer.
10: */
11:
12: #include <windows.h>
13: #include <stdio.h>
14: #include "midimon.h"
15: #include "circbuf.h"
16: #include "display.h"
17:
18: /* MIDI event-name strings
19: */
20: char szEventNames[8][24] =
21: {
22: "Note Off",
23: "Note On",
24: "Key Aftertouch",
25: "Control Change",
26: "Program Change",
27: "Channel Aftertouch",
28: "Pitch Bend",
29: "System Message"
30: };
31:
32: char szSysMsgNames[16][24] =
33: {
34: "System Exclusive",
35: "MTC Quarter Frame",
36: "Song Position Pointer",
37: "Song Select",
38: "Undefined",
39: "Undefined",
40: "Tune Request",
41: "System Exclusive End",
42: "Timing Clock",
43: "Undefined",
44: "Start",
45: "Continue",
46: "Stop",
47: "Undefined",
48: "Active Sensing",
49: "System Reset"
50: };
51:
52: /* GetDisplayText - Takes a MIDI event and creates a text string for display.
53: *
54: * Params: npText - Points to a string that the function fills.
55: * lpEvent - Points to a MIDI event.
56: *
57: * Return: The number of characters in the text string pointed to by npText.
58: */
59: int GetDisplayText(NPSTR npText, LPEVENT lpEvent)
60: {
61: BYTE bStatus, bStatusRaw, bChannel, bData1, bData2;
62: DWORD dwTimestamp;
63:
64: bStatusRaw = LOBYTE(LOWORD(lpEvent->data));
65: bStatus = bStatusRaw & (BYTE) 0xf0;
66: bChannel = bStatusRaw & (BYTE) 0x0f;
67: bData1 = HIBYTE(LOWORD(lpEvent->data));
68: bData2 = LOBYTE(HIWORD(lpEvent->data));
69: dwTimestamp = lpEvent->timestamp;
70:
71: switch(bStatus)
72: {
73: /* Three byte events
74: */
75: case NOTEOFF:
76: case NOTEON:
77: case KEYAFTERTOUCH:
78: case CONTROLCHANGE:
79: case PITCHBEND:
80: /* A note on with a velocity of 0 is a note off
81: */
82: if((bStatus == NOTEON) && (bData2 == 0))
83: bStatus = NOTEOFF;
84:
85: return(sprintf(npText, FORMAT3, dwTimestamp, bStatusRaw, bData1,
86: bData2, bChannel, &szEventNames[(bStatus-0x80) >> 4][0]));
87: break;
88:
89: /* Two byte events
90: */
91: case PROGRAMCHANGE:
92: case CHANAFTERTOUCH:
93: return(sprintf(npText, FORMAT2, dwTimestamp, bStatusRaw, bData1,
94: bChannel, &szEventNames[(bStatus-0x80) >> 4][0]));
95: break;
96:
97: /* MIDI system events (0xf0 - 0xff)
98: */
99: case SYSTEMMESSAGE:
100: switch(bStatusRaw)
101: {
102: /* Two byte system events
103: */
104: case MTCQUARTERFRAME:
105: case SONGSELECT:
106: return(sprintf(npText, FORMAT2X, dwTimestamp, bStatusRaw,
107: bData1,
108: &szSysMsgNames[(bStatusRaw & 0x0f)][0]));
109: break;
110:
111: /* Three byte system events
112: */
113: case SONGPOSPTR:
114: return(sprintf(npText, FORMAT3X, dwTimestamp, bStatusRaw,
115: bData1, bData2,
116: &szSysMsgNames[(bStatusRaw & 0x0f)][0]));
117: break;
118:
119: /* One byte system events
120: */
121: default:
122: return(sprintf(npText, FORMAT1X, dwTimestamp, bStatusRaw,
123: &szSysMsgNames[(bStatusRaw & 0x0f)][0]));
124: break;
125: }
126: break;
127:
128: default:
129: return(sprintf(npText, FORMAT3X, dwTimestamp, bStatusRaw, bData1,
130: bData2, "Unknown Event"));
131: break;
132: }
133: }
134:
135: /* AddDisplayEvent - Puts a MIDI event in the display buffer. The display
136: * buffer is a circular buffer. Once it is full, newly added events
137: * overwrite the oldest events in the buffer.
138: *
139: * Params: lpBuf - Points to the display buffer.
140: * lpEvent - Points to a MIDI event.
141: *
142: * Return: void
143: */
144: void AddDisplayEvent(LPDISPLAYBUFFER lpBuf, LPEVENT lpEvent)
145: {
146: /* Put the event in the buffer, bump the head pointer and byte count.
147: */
148: *lpBuf->lpHead = *lpEvent;
149: ++lpBuf->lpHead;
150: ++lpBuf->dwCount;
151:
152: /* Wrap pointer, if necessary.
153: */
154: if(lpBuf->lpHead == lpBuf->lpEnd)
155: lpBuf->lpHead = lpBuf->lpStart;
156:
157: /* A full buffer is a full buffer, no more.
158: */
159: lpBuf->dwCount = min(lpBuf->dwCount, lpBuf->dwSize);
160: }
161:
162:
163: /* GetDisplayEvent - Retrieves a MIDI event from the display buffer.
164: * Unlike the input buffer, the event is not removed from the buffer.
165: *
166: * Params: lpBuf - Points to the display buffer.
167: * lpEvent - Points to an EVENT structure that is filled with
168: * the retrieved MIDI event.
169: * wNum - Specifies which event to retrieve.
170: *
171: * Return: void
172: */
173: void GetDisplayEvent(LPDISPLAYBUFFER lpBuf, LPEVENT lpEvent, DWORD wNum)
174: {
175: LPEVENT lpFirstEvent, lpThisEvent;
176:
177: /* Get pointer to the first (oldest) event in buffer.
178: */
179: if(lpBuf->dwCount < lpBuf->dwSize) // buffer is not yet full
180: lpFirstEvent = lpBuf->lpStart;
181:
182: else // buffer is full
183: lpFirstEvent = lpBuf->lpHead;
184:
185: /* Offset pointer to point to requested event; wrap pointer.
186: */
187: lpThisEvent = lpFirstEvent + wNum;
188: if(lpThisEvent >= lpBuf->lpEnd)
189: lpThisEvent = lpBuf->lpStart + (lpThisEvent - lpBuf->lpEnd);
190:
191: /* Get the requested event.
192: */
193: *(lpEvent) = *lpThisEvent;
194: }
195:
196: /* AllocDisplayBuffer - Allocates memory for a DISPLAYBUFFER structure
197: * and a buffer of the specified size. Each memory block is allocated
198: * with GlobalAlloc() using GMEM_SHARE and GMEM_MOVEABLE flags and
199: * locked with GlobalLock(). Since this buffer is only accessed by the
200: * application, and not the low-level callback function, it does not
201: * have to be page locked.
202: *
203: * Params: dwSize - The size of the buffer, in events.
204: *
205: * Return: A pointer to a DISPLAYBUFFER structure identifying the
206: * allocated display buffer. NULL if the buffer could not be allocated.
207: */
208: LPDISPLAYBUFFER AllocDisplayBuffer(DWORD dwSize)
209: {
210: HANDLE hMem;
211: LPDISPLAYBUFFER lpBuf;
212: LPEVENT lpMem;
213:
214: /* Allocate and lock a DISPLAYBUFFER structure.
215: */
216: hMem = GlobalAlloc(GMEM_SHARE | GMEM_MOVEABLE,
217: (DWORD)sizeof(DISPLAYBUFFER));
218: if(hMem == NULL)
219: return NULL;
220:
221: lpBuf = (LPDISPLAYBUFFER)GlobalLock(hMem);
222: if(lpBuf == NULL)
223: {
224: GlobalFree(hMem);
225: return NULL;
226: }
227:
228: /* Save the handle.
229: */
230: lpBuf->hSelf = hMem;
231:
232: /* Allocate and lock memory for the actual buffer.
233: */
234: hMem = GlobalAlloc(GMEM_SHARE | GMEM_MOVEABLE, dwSize * sizeof(EVENT));
235: if(hMem == NULL)
236: {
237: GlobalUnlock(lpBuf->hSelf);
238: GlobalFree(lpBuf->hSelf);
239: return NULL;
240: }
241: lpMem = (LPEVENT)GlobalLock(hMem);
242: if(lpMem == NULL)
243: {
244: GlobalFree(hMem);
245: GlobalUnlock(lpBuf->hSelf);
246: GlobalFree(lpBuf->hSelf);
247: return NULL;
248: }
249:
250: /* Set up the DISPLAYBUFFER structure.
251: */
252: lpBuf->hBuffer = hMem;
253: lpBuf->wError = 0;
254: lpBuf->dwSize = dwSize;
255: lpBuf->dwCount = 0L;
256: lpBuf->lpStart = lpMem;
257: lpBuf->lpEnd = lpMem + dwSize;
258: lpBuf->lpTail = lpMem;
259: lpBuf->lpHead = lpMem;
260:
261: return lpBuf;
262: }
263:
264: /* FreeDisplayBuffer - Frees the memory for a display buffer.
265: *
266: * Params: lpBuf - Points to the DISPLAYBUFFER to be freed.
267: *
268: * Return: void
269: */
270: void FreeDisplayBuffer(LPDISPLAYBUFFER lpBuf)
271: {
272: HANDLE hMem;
273:
274: /* Unlock and free the buffer itself.
275: */
276: GlobalUnlock(lpBuf->hBuffer);
277: GlobalFree(lpBuf->hBuffer);
278:
279: /* Unlock and free the DISPLAYBUFFER structure.
280: */
281: hMem = lpBuf->hSelf;
282: GlobalUnlock(hMem);
283: GlobalFree(hMem);
284: }
285:
286: /* ResetDisplayBuffer - Empties a display buffer.
287: *
288: * Params: lpBuf - Points to a display buffer.
289: *
290: * Return: void
291: */
292: void ResetDisplayBuffer(LPDISPLAYBUFFER lpBuf)
293: {
294: /* Reset the pointers and event count.
295: */
296: lpBuf->lpHead = lpBuf->lpStart;
297: lpBuf->lpTail = lpBuf->lpStart;
298: lpBuf->dwCount = 0L;
299: lpBuf->wError = 0;
300: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.