Context Navigation

source: trunk/src/winmm/mmio.cpp@ 7762

Visit:

Last change on this file since 7762 was 6375, checked in by sandervl, 24 years ago
initterm update
File size: 30.8 KB

Line
1	/* $Id: mmio.cpp,v 1.8 2001-07-20 15:35:00 sandervl Exp $ */
2	/*
3	* MMIO functions
4	*
5	* Copyright 1999 Przemyslaw Dobrowolski
6	*
7	* Based on Wine code:
8	* Copyright 1998 Andrew Taylor
9	* Copyright 1998 Ove Kåven
10	*
11	*/
12
13	#include <os2win.h>
14	#include <mmsystem.h>
15	#include <odinwrap.h>
16	#include <misc.h>
17	#include <string.h>
18	#include <heapstring.h>
19
20	#include <stdlib.h>
21	#include <errno.h>
22	#include "windef.h"
23	#include "file.h"
24	#include "mmsystem.h"
25	#include "debugtools.h"
26
27	#define DBG_LOCALLOG DBG_mmio
28	#include "dbglocal.h"
29
30	ODINDEBUGCHANNEL(WINMM-MMIO)
31
32	/**************************************************************************
33	* mmioDosIOProc [internal]
34	*/
35	static LRESULT WIN32API mmioDosIOProc(LPMMIOINFO lpmmioinfo, UINT uMessage, LPARAM lParam1, LPARAM lParam2)
36	{
37	dprintf(("mmioDosIOProc (%p, %X, %ld, %ld);\n", lpmmioinfo, uMessage, lParam1, lParam2));
38
39	switch (uMessage) {
40
41	case MMIOM_OPEN: {
42	/* Parameters:
43	* lParam1 = szFileName parameter from mmioOpen
44	* lParam2 = resrved
45	* NOTE: lDiskOffset automatically set to zero
46	*/
47
48	OFSTRUCT ofs;
49	LPSTR szFileName = (LPSTR) lParam1;
50
51	if (lpmmioinfo->dwFlags & MMIO_GETTEMP) {
52	dprintf(("WINMM: mmioDosIOProc MMIO_GETTEMP not implemented\n"));
53	return MMIOERR_CANNOTOPEN;
54	}
55
56	lpmmioinfo->adwInfo[0] =
57	(DWORD) OpenFile(szFileName, &ofs, lpmmioinfo->dwFlags);
58	if (lpmmioinfo->adwInfo[0] == -1)
59	return MMIOERR_CANNOTOPEN;
60
61	return 0;
62	}
63
64	case MMIOM_CLOSE: {
65	/* Parameters:
66	* lParam1 = wFlags parameter from mmioClose
67	* lParam2 = unused
68	* Returns: zero on success, error code on error
69	*/
70
71	UINT uFlags = (UINT)lParam1;
72
73	if (uFlags & MMIO_FHOPEN)
74	return 0;
75
76	_lclose((HFILE)lpmmioinfo->adwInfo[0]);
77	return 0;
78
79	}
80
81	case MMIOM_READ: {
82	/* Parameters:
83	* lParam1 = huge pointer to read buffer
84	* lParam2 = number of bytes to read
85	* Returns: number of bytes read, 0 for EOF, -1 for error (error code
86	* in wErrorRet)
87	* NOTE: lDiskOffset should be updated
88	*/
89
90	HPSTR pch = (HPSTR) lParam1;
91	LONG cch = (LONG) lParam2;
92	LONG count;
93
94	count = _lread((HFILE)lpmmioinfo->adwInfo[0], pch, cch);
95	if (count != -1)
96	lpmmioinfo->lDiskOffset += count;
97
98	return count;
99	}
100
101	case MMIOM_WRITE:
102	case MMIOM_WRITEFLUSH: {
103	/* no internal buffering, so WRITEFLUSH handled same as WRITE */
104
105	/* Parameters:
106	* lParam1 = huge pointer to write buffer
107	* lParam2 = number of bytes to write
108	* Returns: number of bytes written, -1 for error (error code in
109	* wErrorRet)
110	* NOTE: lDiskOffset should be updated
111	*/
112
113	HPSTR pch = (HPSTR) lParam1;
114	LONG cch = (LONG) lParam2;
115	LONG count;
116
117	#ifdef __WIN32OS2__
118	count = _lwrite((HFILE)lpmmioinfo->adwInfo[0], pch, cch);
119	#else
120	count = _hwrite((HFILE)lpmmioinfo->adwInfo[0], pch, cch);
121	#endif
122	if (count != -1)
123	lpmmioinfo->lDiskOffset += count;
124
125	return count;
126	}
127
128	case MMIOM_SEEK: {
129	/* Parameters:
130	* lParam1 = new position
131	* lParam2 = from whence to seek (SEEK_SET, SEEK_CUR, SEEK_END)
132	* Returns: new file postion, -1 on error
133	* NOTE: lDiskOffset should be updated
134	*/
135
136	LONG Offset = (LONG) lParam1;
137	LONG Whence = (LONG) lParam2;
138	LONG pos;
139
140	pos = _llseek((HFILE)lpmmioinfo->adwInfo[0], Offset, Whence);
141	if (pos != -1)
142	lpmmioinfo->lDiskOffset = pos;
143
144	return pos;
145	}
146
147	case MMIOM_RENAME: {
148	/* Parameters:
149	* lParam1 = old name
150	* lParam2 = new name
151	* Returns: zero on success, non-zero on failure
152	*/
153
154	dprintf(("WINMM: mmioDosIOProc MMIOM_RENAME unimplemented\n"));
155	return MMIOERR_FILENOTFOUND;
156	}
157
158	default:
159	dprintf(("WINMM: mmioDosIOProc unexpected message %u\n", uMessage));
160	return 0;
161	}
162
163	return 0;
164	}
165
166	/**************************************************************************
167	* mmioMemIOProc [internal]
168	*/
169	static LRESULT WIN32API mmioMemIOProc(LPMMIOINFO lpmmioinfo, UINT uMessage, LPARAM lParam1, LPARAM lParam2) {
170	// TRACE("(%p,0x%04x,0x%08lx,0x%08lx)\n",lpmmioinfo,uMessage,lParam1,lParam2);
171	switch (uMessage) {
172
173	case MMIOM_OPEN: {
174	/* Parameters:
175	* lParam1 = filename (must be NULL)
176	* lParam2 = reserved
177	* Returns: zero on success, error code on error
178	* NOTE: lDiskOffset automatically set to zero
179	*/
180
181	if (!(lpmmioinfo->dwFlags & MMIO_CREATE))
182	lpmmioinfo->pchEndRead = lpmmioinfo->pchEndWrite;
183
184	return 0;
185	}
186
187	case MMIOM_CLOSE: {
188	/* Parameters:
189	* lParam1 = wFlags parameter from mmioClose
190	* lParam2 = unused
191	* Returns: zero on success, error code on error
192	*/
193
194	return 0;
195
196	}
197
198	case MMIOM_READ: {
199	/* Parameters:
200	* lParam1 = huge pointer to read buffer
201	* lParam2 = number of bytes to read
202	* Returns: number of bytes read, 0 for EOF, -1 for error (error code
203	* in wErrorRet)
204	* NOTE: lDiskOffset should be updated
205	*/
206
207	/* HPSTR pch = (HPSTR) lParam1; */
208	/* LONG cch = (LONG) lParam2; */
209
210	dprintf(("WINMM (mmioMemIOProc) MMIOM_READ on memory files should not occur, buffer may be lost!\n"));
211	return 0;
212	}
213
214	case MMIOM_WRITE:
215	case MMIOM_WRITEFLUSH: {
216	/* no internal buffering, so WRITEFLUSH handled same as WRITE */
217
218	/* Parameters:
219	* lParam1 = huge pointer to write buffer
220	* lParam2 = number of bytes to write
221	* Returns: number of bytes written, -1 for error (error code in
222	* wErrorRet)
223	* NOTE: lDiskOffset should be updated
224	*/
225
226	/* HPSTR pch = (HPSTR) lParam1; */
227	/* LONG cch = (LONG) lParam2; */
228
229	dprintf(("WINMM (mmioMemIOProc) MMIOM_WRITE on memory files should not occur, buffer may be lost!\n"));
230	return 0;
231	}
232
233	case MMIOM_SEEK: {
234	/* Parameters:
235	* lParam1 = new position
236	* lParam2 = from whence to seek (SEEK_SET, SEEK_CUR, SEEK_END)
237	* Returns: new file postion, -1 on error
238	* NOTE: lDiskOffset should be updated
239	*/
240
241	/* LONG Offset = (LONG) lParam1; */
242	/* LONG Whence = (LONG) lParam2; */
243
244	dprintf(("WINMM (mmioMemIOProc) MMIOM_SEEK on memory files should not occur, buffer may be lost!\n"));
245	return -1;
246	}
247
248	default:
249	dprintf(("WINMM (mmioMemIOProc) unexpected message %u\n", uMessage));
250	return 0;
251	}
252
253	return 0;
254	}
255
256	/**************************************************************************
257	* MMIO_Open [internal]
258	*/
259	static HMMIO MMIO_Open(LPSTR szFileName, LPMMIOINFO refmminfo, DWORD dwOpenFlags)
260	{
261	LPMMIOINFO lpmminfo;
262	HMMIO hmmio;
263
264	// TRACE("('%s', %08lX);\n", szFileName, dwOpenFlags);
265
266	if (dwOpenFlags & MMIO_PARSE) {
267	char buffer[MAX_PATH];
268
269	if (GetFullPathNameA(szFileName, sizeof(buffer), buffer, NULL) >= sizeof(buffer))
270	return (HMMIO)FALSE;
271	strcpy(szFileName, buffer);
272	return (HMMIO)TRUE;
273	}
274
275	hmmio = GlobalAlloc(GHND, sizeof(MMIOINFO));
276	lpmminfo = (LPMMIOINFO)GlobalLock(hmmio);
277	if (lpmminfo == NULL)
278	return 0;
279	memset(lpmminfo, 0, sizeof(MMIOINFO));
280
281	/* assume DOS file if not otherwise specified */
282	if (refmminfo->fccIOProc == 0 && refmminfo->pIOProc == NULL) {
283	lpmminfo->fccIOProc = FOURCC_DOS;
284	lpmminfo->pIOProc = (LPMMIOPROC) mmioDosIOProc;
285	}
286	/* if just the four character code is present, look up IO proc */
287	else if (refmminfo->pIOProc == NULL) {
288
289	lpmminfo->fccIOProc = refmminfo->fccIOProc;
290	lpmminfo->pIOProc = mmioInstallIOProcA(refmminfo->fccIOProc, NULL, MMIO_FINDPROC);
291
292	}
293	/* if IO proc specified, use it and specified four character code */
294	else {
295
296	lpmminfo->fccIOProc = refmminfo->fccIOProc;
297	lpmminfo->pIOProc = (LPMMIOPROC)refmminfo->pIOProc;
298	}
299
300	if (dwOpenFlags & MMIO_ALLOCBUF) {
301	if ((refmminfo->wErrorRet = mmioSetBuffer(hmmio, NULL, MMIO_DEFAULTBUFFER, 0))) {
302	return 0;
303	}
304	} else if (lpmminfo->fccIOProc == FOURCC_MEM) {
305	if ((refmminfo->wErrorRet = mmioSetBuffer(hmmio, refmminfo->pchBuffer, refmminfo->cchBuffer, 0))) {
306	return 0;
307	}
308	}
309
310	/* see mmioDosIOProc for that one */
311	lpmminfo->adwInfo[0] = refmminfo->adwInfo[0];
312	lpmminfo->dwFlags = dwOpenFlags;
313	lpmminfo->hmmio = hmmio;
314
315	/* call IO proc to actually open file */
316	refmminfo->wErrorRet = (UINT) mmioSendMessage(hmmio, MMIOM_OPEN, (LPARAM) szFileName, (LPARAM) 0);
317
318	GlobalUnlock(hmmio);
319
320	if (refmminfo->wErrorRet != 0) {
321	GlobalFree(hmmio);
322	return 0;
323	}
324
325	return hmmio;
326	}
327
328	/**************************************************************************
329	* mmioOpenW [WINMM.123]
330	*/
331	ODINFUNCTION3(HMMIO, mmioOpenW,
332	LPWSTR,szFileName,
333	LPMMIOINFO,lpmmioinfo,
334	DWORD,dwOpenFlags)
335	{
336	LPSTR szFn = HEAP_strdupWtoA(GetProcessHeap(),0,szFileName);
337	HMMIO ret = mmioOpenA(szFn, lpmmioinfo, dwOpenFlags);
338
339	HeapFree(GetProcessHeap(),0,szFn);
340	return ret;
341	}
342
343	/**************************************************************************
344	* mmioOpenA [WINMM.122]
345	*/
346	ODINFUNCTION3(HMMIO, mmioOpenA,
347	LPSTR,szFileName,
348	LPMMIOINFO,lpmmioinfo,
349	DWORD,dwOpenFlags)
350	{
351	HMMIO ret;
352
353	if (lpmmioinfo) {
354	ret = MMIO_Open(szFileName, lpmmioinfo, dwOpenFlags);
355	} else {
356	MMIOINFO mmioinfo;
357
358	mmioinfo.fccIOProc = 0;
359	mmioinfo.pIOProc = NULL;
360	mmioinfo.pchBuffer = NULL;
361	mmioinfo.cchBuffer = 0;
362
363	ret = MMIO_Open(szFileName, &mmioinfo, dwOpenFlags);
364	}
365	return ret;
366	}
367
368
369	/**************************************************************************
370	* mmioClose [WINMM.114]
371	*/
372	ODINFUNCTION2(MMRESULT, mmioClose,
373	HMMIO,hmmio,
374	UINT,uFlags)
375	{
376	LPMMIOINFO lpmminfo;
377	MMRESULT result;
378
379	// TRACE("(%04X, %04X);\n", hmmio, uFlags);
380
381	lpmminfo = (LPMMIOINFO) GlobalLock(hmmio);
382	if (lpmminfo == NULL)
383	return 0;
384
385	/* flush the file - if error reported, ignore */
386	if (mmioFlush(hmmio, MMIO_EMPTYBUF) != 0)
387	lpmminfo->dwFlags &= ~MMIO_DIRTY;
388
389	result = mmioSendMessage(hmmio,MMIOM_CLOSE,(LPARAM)uFlags,(LPARAM)0);
390
391	mmioSetBuffer(hmmio, NULL, 0, 0);
392
393	GlobalUnlock(hmmio);
394	GlobalFree(hmmio);
395
396	return result;
397	}
398
399
400
401	/**************************************************************************
402	* mmioRead [WINMM.124]
403	*/
404	ODINFUNCTION3(LONG, mmioRead,
405	HMMIO,hmmio,
406	HPSTR,pch,
407	LONG,cch)
408	{
409	LONG count;
410	LPMMIOINFO lpmminfo;
411
412	// TRACE("(%04X, %p, %ld);\n", hmmio, pch, cch);
413
414	lpmminfo = (LPMMIOINFO)GlobalLock(hmmio);
415	if (lpmminfo == NULL)
416	return -1;
417
418	if (lpmminfo->pchNext != lpmminfo->pchEndRead) {
419	count = lpmminfo->pchEndRead - lpmminfo->pchNext;
420	if (count > cch \|\| count < 0) count = cch;
421	memcpy(pch, lpmminfo->pchNext, count);
422	lpmminfo->pchNext += count;
423	pch += count;
424	cch -= count;
425	} else
426	count = 0;
427
428	if (cch&&(lpmminfo->fccIOProc!=FOURCC_MEM)) {
429	if (lpmminfo->cchBuffer) {
430	mmioFlush(hmmio, MMIO_EMPTYBUF);
431
432	while (cch) {
433	LONG size;
434	lpmminfo->lBufOffset = lpmminfo->lDiskOffset;
435	lpmminfo->pchNext = lpmminfo->pchBuffer;
436	lpmminfo->pchEndRead = lpmminfo->pchBuffer;
437	size = mmioSendMessage(hmmio, MMIOM_READ,
438	(LPARAM) lpmminfo->pchBuffer,
439	(LPARAM) lpmminfo->cchBuffer);
440	if (size<=0) break;
441	lpmminfo->pchEndRead = lpmminfo->pchBuffer + size;
442	if (size > cch) size = cch;
443	memcpy(pch, lpmminfo->pchNext, size);
444	lpmminfo->pchNext += size;
445	pch += size;
446	cch -= size;
447	count += size;
448	}
449	} else {
450	count += mmioSendMessage(hmmio, MMIOM_READ, (LPARAM) pch, (LPARAM) cch);
451	if (count>0) lpmminfo->lBufOffset += count;
452	}
453	}
454
455	GlobalUnlock(hmmio);
456	TRACE("count=%ld\n", count);
457	return count;
458	}
459
460	/**************************************************************************
461	* mmioWrite [WINMM.133]
462	*/
463	ODINFUNCTION3(LONG, mmioWrite,
464	HMMIO,hmmio,
465	HPCSTR,pch,
466	LONG,cch)
467	{
468	LONG count;
469	LPMMIOINFO lpmminfo;
470
471	// TRACE("(%04X, %p, %ld);\n", hmmio, pch, cch);
472
473	lpmminfo = (LPMMIOINFO)GlobalLock(hmmio);
474	if (lpmminfo == NULL)
475	return -1;
476
477	if (lpmminfo->cchBuffer) {
478	count = 0;
479	while (cch) {
480	if (lpmminfo->pchNext != lpmminfo->pchEndWrite) {
481	count = lpmminfo->pchEndWrite - lpmminfo->pchNext;
482	if (count > cch \|\| count < 0) count = cch;
483	memcpy(lpmminfo->pchNext, pch, count);
484	lpmminfo->pchNext += count;
485	pch += count;
486	cch -= count;
487	lpmminfo->dwFlags \|= MMIO_DIRTY;
488	} else
489	if (lpmminfo->fccIOProc==FOURCC_MEM) {
490	if (lpmminfo->adwInfo[0]) {
491	/* from where would we get the memory handle? */
492	dprintf(("WINMM (mmioWrite) memory file expansion not implemented!\n"));
493	} else break;
494	}
495
496	if (lpmminfo->pchNext == lpmminfo->pchEndWrite
497	&& mmioFlush(hmmio, MMIO_EMPTYBUF)) break;
498	}
499	} else {
500	count = mmioSendMessage(hmmio, MMIOM_WRITE, (LPARAM) pch, (LPARAM) cch);
501	lpmminfo->lBufOffset = lpmminfo->lDiskOffset;
502	}
503
504	GlobalUnlock(hmmio);
505	// TRACE("count=%ld\n", count);
506	return count;
507	}
508
509	/**************************************************************************
510	* mmioSeek [MMSYSTEM.1214]
511	*/
512	ODINFUNCTION3(LONG, mmioSeek,
513	HMMIO, hmmio,
514	LONG,lOffset,
515	INT,iOrigin)
516	{
517	int offset;
518	LPMMIOINFO lpmminfo;
519
520	// TRACE("(%04X, %08lX, %d);\n", hmmio, lOffset, iOrigin);
521
522	lpmminfo = (LPMMIOINFO)GlobalLock(hmmio);
523	if (lpmminfo == NULL)
524	return -1;
525
526	offset = (iOrigin==SEEK_SET)?(lOffset - lpmminfo->lBufOffset):
527	(iOrigin==SEEK_CUR)?(lOffset +
528	(lpmminfo->pchNext - lpmminfo->pchBuffer)):-1;
529
530	if ((lpmminfo->cchBuffer<0)\|\|
531	((offset>=0)&&(offset<=(lpmminfo->pchEndRead-lpmminfo->pchBuffer)))) {
532	lpmminfo->pchNext = lpmminfo->pchBuffer + offset;
533	GlobalUnlock(hmmio);
534	return lpmminfo->lBufOffset + offset;
535	}
536
537	if ((lpmminfo->fccIOProc==FOURCC_MEM)\|\|mmioFlush(hmmio, MMIO_EMPTYBUF)) {
538	GlobalUnlock(hmmio);
539	return -1;
540	}
541
542	offset = mmioSendMessage(hmmio, MMIOM_SEEK, (LPARAM) lOffset, (LPARAM) iOrigin);
543	lpmminfo->lBufOffset = lpmminfo->lDiskOffset;
544
545	GlobalUnlock(hmmio);
546	return offset;
547	}
548
549	/**************************************************************************
550	* mmioGetInfo [MMSYSTEM.1215]
551	*/
552	ODINFUNCTION3(UINT, mmioGetInfo,
553	HMMIO,hmmio,
554	LPMMIOINFO,lpmmioinfo,
555	UINT,uFlags)
556	{
557	LPMMIOINFO lpmminfo;
558	// TRACE("mmioGetInfo\n");
559	lpmminfo = (LPMMIOINFO)GlobalLock(hmmio);
560	if (lpmminfo == NULL) return 0;
561	memcpy(lpmmioinfo, lpmminfo, sizeof(MMIOINFO));
562	GlobalUnlock(hmmio);
563	return 0;
564	}
565
566
567	/**************************************************************************
568	* mmioSetInfo [WINMM.130]
569	*/
570	ODINFUNCTION3(MMRESULT,mmioSetInfo,
571	HMMIO, hmmio,
572	const MMIOINFO*,lpmmioinfo,
573	UINT,uFlags)
574	{
575	LPMMIOINFO lpmminfo;
576	// TRACE("mmioSetInfo\n");
577	lpmminfo = (LPMMIOINFO)GlobalLock(hmmio);
578	if (lpmminfo == NULL) return 0;
579	lpmminfo->pchNext = lpmmioinfo->pchNext;
580	lpmminfo->pchEndRead = lpmmioinfo->pchEndRead;
581	GlobalUnlock(hmmio);
582	return 0;
583	}
584
585	/**************************************************************************
586	* mmioSetBuffer [WINMM.129]
587	*/
588	ODINFUNCTION4(UINT,mmioSetBuffer,
589	HMMIO,hmmio,
590	LPSTR,pchBuffer,
591	LONG,cchBuffer,
592	UINT,uFlags)
593	{
594	LPMMIOINFO lpmminfo;
595
596	if (mmioFlush(hmmio, MMIO_EMPTYBUF) != 0)
597	return MMIOERR_CANNOTWRITE;
598
599	// TRACE("(hmmio=%04x, pchBuf=%p, cchBuf=%ld, uFlags=%#08x)\n",
600	// hmmio, pchBuffer, cchBuffer, uFlags);
601
602	lpmminfo = (LPMMIOINFO)GlobalLock(hmmio);
603	if (lpmminfo == NULL) return 0;
604	if ((!cchBuffer \|\| pchBuffer) && lpmminfo->dwFlags&MMIO_ALLOCBUF) {
605	GlobalUnlock(lpmminfo->dwReserved1);
606	GlobalFree(lpmminfo->dwReserved1);
607	lpmminfo->dwFlags &= ~MMIO_ALLOCBUF;
608	}
609	if (pchBuffer) {
610	lpmminfo->pchBuffer = pchBuffer;
611	} else if (lpmminfo->dwFlags&MMIO_ALLOCBUF) {
612	HGLOBAL hNewBuf;
613	GlobalUnlock(lpmminfo->dwReserved1);
614	hNewBuf = GlobalReAlloc(lpmminfo->dwReserved1, cchBuffer, 0);
615	if (!hNewBuf) {
616	/* FIXME: this assumes the memory block didn't move */
617	GlobalLock(lpmminfo->dwReserved1);
618	GlobalUnlock(hmmio);
619	return MMIOERR_OUTOFMEMORY;
620	}
621	lpmminfo->dwReserved1 = hNewBuf;
622	lpmminfo->pchBuffer = (LPSTR)GlobalLock(hNewBuf);
623	} else if (cchBuffer) {
624	HGLOBAL hNewBuf = GlobalAlloc(GMEM_MOVEABLE, cchBuffer);
625	if (!hNewBuf) {
626	GlobalUnlock(hmmio);
627	return MMIOERR_OUTOFMEMORY;
628	}
629	lpmminfo->dwReserved1 = hNewBuf;
630	lpmminfo->pchBuffer = (LPSTR)GlobalLock(hNewBuf);
631	lpmminfo->dwFlags \|= MMIO_ALLOCBUF;
632	} else
633	lpmminfo->pchBuffer = NULL;
634	lpmminfo->cchBuffer = cchBuffer;
635	lpmminfo->pchNext = lpmminfo->pchBuffer;
636	lpmminfo->pchEndRead = lpmminfo->pchBuffer;
637	lpmminfo->pchEndWrite = lpmminfo->pchBuffer + cchBuffer;
638	lpmminfo->lBufOffset = 0;
639
640	GlobalUnlock(hmmio);
641	return 0;
642	}
643
644	/**************************************************************************
645	* mmioFlush [WINMM.117]
646	*/
647	ODINFUNCTION2(UINT,mmioFlush,
648	HMMIO,hmmio,
649	UINT,uFlags)
650	{
651	LPMMIOINFO lpmminfo;
652	// TRACE("(%04X, %04X)\n", hmmio, uFlags);
653	lpmminfo = (LPMMIOINFO)GlobalLock(hmmio);
654	if (lpmminfo == NULL) return 0;
655
656	if ((!lpmminfo->cchBuffer)\|\|(lpmminfo->fccIOProc==FOURCC_MEM)) {
657	GlobalUnlock(hmmio);
658	return 0;
659	}
660	/* not quite sure what to do here, but I'll guess */
661	if (lpmminfo->dwFlags & MMIO_DIRTY) {
662	mmioSendMessage(hmmio, MMIOM_SEEK,
663	(LPARAM) lpmminfo->lBufOffset,
664	(LPARAM) SEEK_SET);
665	mmioSendMessage(hmmio, MMIOM_WRITE,
666	(LPARAM) lpmminfo->pchBuffer,
667	(LPARAM) (lpmminfo->pchNext - lpmminfo->pchBuffer) );
668	lpmminfo->dwFlags &= ~MMIO_DIRTY;
669	}
670	if (uFlags & MMIO_EMPTYBUF) {
671	/* seems Windows doesn't do any seeking here, hopefully this
672	won't matter, otherwise a slight rewrite is necessary */
673	mmioSendMessage(hmmio, MMIOM_SEEK,
674	(LPARAM) (lpmminfo->lBufOffset +
675	(lpmminfo->pchNext - lpmminfo->pchBuffer)),
676	(LPARAM) SEEK_SET);
677	lpmminfo->pchNext = lpmminfo->pchBuffer;
678	lpmminfo->pchEndRead = lpmminfo->pchBuffer;
679	lpmminfo->lBufOffset = lpmminfo->lDiskOffset;
680	}
681
682	GlobalUnlock(hmmio);
683	return 0;
684	}
685
686
687	/**************************************************************************
688	* mmioAdvance [WINMM.113]
689	*/
690	ODINFUNCTION3(UINT,mmioAdvance,
691	HMMIO, hmmio,
692	LPMMIOINFO,lpmmioinfo,
693	UINT,uFlags)
694	{
695	LPMMIOINFO lpmminfo;
696	// TRACE("mmioAdvance\n");
697	lpmminfo = (LPMMIOINFO)GlobalLock(hmmio);
698	if (lpmminfo == NULL) return 0;
699	if (!lpmminfo->cchBuffer) {
700	GlobalUnlock(hmmio);
701	return MMIOERR_UNBUFFERED;
702	}
703	lpmminfo->pchNext = lpmmioinfo->pchNext;
704	if (mmioFlush(hmmio, MMIO_EMPTYBUF)) {
705	GlobalUnlock(hmmio);
706	return MMIOERR_CANNOTWRITE;
707	}
708	if (uFlags == MMIO_READ)
709	lpmmioinfo->pchEndRead = lpmmioinfo->pchBuffer +
710	mmioSendMessage(hmmio, MMIOM_READ,
711	(LPARAM) lpmmioinfo->pchBuffer,
712	(LPARAM) lpmmioinfo->cchBuffer);
713	lpmmioinfo->pchNext = lpmmioinfo->pchBuffer;
714	GlobalUnlock(hmmio);
715	return 0;
716	}
717
718
719	/**************************************************************************
720	* mmioStringToFOURCCA [WINMM.131]
721	*/
722	ODINFUNCTION2(FOURCC,mmioStringToFOURCCA,
723	LPCSTR, sz, UINT, uFlags)
724	{
725	return mmioFOURCC(sz[0],sz[1],sz[2],sz[3]);
726	}
727
728	/**************************************************************************
729	* mmioStringToFOURCCW [WINMM.132]
730	*/
731	ODINFUNCTION2(FOURCC,mmioStringToFOURCCW,
732	LPCWSTR, sz, UINT, uFlags)
733	{
734	LPSTR szA = HEAP_strdupWtoA(GetProcessHeap(),0,sz);
735	FOURCC ret = mmioStringToFOURCCA(szA,uFlags);
736
737	HeapFree(GetProcessHeap(),0,szA);
738	return ret;
739	}
740
741
742	/* maximum number of I/O procedures which can be installed */
743
744	struct IOProcList
745	{
746	struct IOProcList pNext; / Next item in linked list */
747	FOURCC fourCC; /* four-character code identifying IOProc */
748	LPMMIOPROC pIOProc; /* pointer to IProc */
749	};
750
751	/* This array will be the entire list for most apps */
752
753	static struct IOProcList defaultProcs[] = {
754	{ &defaultProcs[1], (FOURCC) FOURCC_DOS,(LPMMIOPROC) mmioDosIOProc },
755	{ NULL, (FOURCC) FOURCC_MEM,(LPMMIOPROC) mmioMemIOProc },
756	};
757
758	static struct IOProcList *pIOProcListAnchor = &defaultProcs[0];
759
760	ODINFUNCTION3(LPMMIOPROC, mmioInstallIOProcA,
761	FOURCC,fccIOProc,
762	LPMMIOPROC,pIOProc,
763	DWORD,dwFlags)
764	{
765	LPMMIOPROC lpProc = NULL;
766	struct IOProcList *pListNode;
767
768	// TRACE("(%ld, %p, %08lX)\n",
769	// fccIOProc, pIOProc, dwFlags);
770
771	if (dwFlags & MMIO_GLOBALPROC) {
772	dprintf(("WINMM: mmioInstallIOProcA global procedures not implemented\n"));
773	}
774
775	/* just handle the known procedures for now */
776	switch(dwFlags & (MMIO_INSTALLPROC\|MMIO_REMOVEPROC\|MMIO_FINDPROC)) {
777	case MMIO_INSTALLPROC:
778	/* Create new entry for the IOProc list */
779	pListNode = (struct IOProcList )HeapAlloc(GetProcessHeap(),0,sizeof(pListNode));
780	if (pListNode)
781	{
782	/* Find the end of the list, so we can add our new entry to it */
783	struct IOProcList *pListEnd = pIOProcListAnchor;
784	while (pListEnd->pNext)
785	pListEnd = pListEnd->pNext;
786
787	/* Fill in this node */
788	pListNode->fourCC = fccIOProc;
789	pListNode->pIOProc = pIOProc;
790
791	/* Stick it on the end of the list */
792	pListEnd->pNext = pListNode;
793	pListNode->pNext = NULL;
794
795	/* Return this IOProc - that's how the caller knows we succeeded */
796	lpProc = pIOProc;
797	};
798	break;
799
800	case MMIO_REMOVEPROC:
801	/*
802	* Search for the node that we're trying to remove - note
803	* that this method won't find the first item on the list, but
804	* since the first two items on this list are ones we won't
805	* let the user delete anyway, that's okay
806	*/
807
808	pListNode = pIOProcListAnchor;
809	while (pListNode && pListNode->pNext->fourCC != fccIOProc)
810	pListNode = pListNode->pNext;
811
812	/* If we found it, remove it, but only if it isn't builtin */
813	if (pListNode &&
814	((pListNode >= defaultProcs) && (pListNode < defaultProcs + sizeof(defaultProcs))))
815	{
816	/* Okay, nuke it */
817	pListNode->pNext = pListNode->pNext->pNext;
818	HeapFree(GetProcessHeap(),0,pListNode);
819	};
820	break;
821
822	case MMIO_FINDPROC:
823	/* Iterate through the list looking for this proc identified by fourCC */
824	for (pListNode = pIOProcListAnchor; pListNode; pListNode=pListNode->pNext)
825	{
826	if (pListNode->fourCC == fccIOProc)
827	{
828	lpProc = pListNode->pIOProc;
829	break;
830	};
831	};
832	break;
833	}
834
835	return lpProc;
836	}
837
838
839	/**************************************************************************
840	* mmioSendMessage [MMSYSTEM.1222]
841	*/
842	ODINFUNCTION4(LRESULT,mmioSendMessage,
843	HMMIO,hmmio,
844	UINT,uMessage,
845	LPARAM,lParam1,
846	LPARAM,lParam2)
847	{
848	LPMMIOINFO lpmminfo;
849	LRESULT result;
850	const char *msg = NULL;
851
852	#ifdef DEBUG
853	switch (uMessage) {
854	#define msgname(x) case x: msg = #x; break;
855	msgname(MMIOM_OPEN);
856	msgname(MMIOM_CLOSE);
857	msgname(MMIOM_READ);
858	msgname(MMIOM_WRITE);
859	msgname(MMIOM_WRITEFLUSH);
860	msgname(MMIOM_SEEK);
861	msgname(MMIOM_RENAME);
862	#undef msgname
863	}
864	#endif
865
866	if (msg)
867	dprintf(("WINMM: mmioSendMessage (%04X, %s, %ld, %ld)\n",
868	hmmio, msg, lParam1, lParam2));
869	else
870	dprintf(("WINMM: mmioSendMessage (%04X, %u, %ld, %ld)\n",
871	hmmio, uMessage, lParam1, lParam2));
872
873	lpmminfo = (LPMMIOINFO)GlobalLock(hmmio);
874
875	if (lpmminfo && lpmminfo->pIOProc)
876	result = (*lpmminfo->pIOProc)((LPSTR)lpmminfo, (UINT)uMessage, lParam1, lParam2);
877	else
878	result = MMSYSERR_INVALPARAM;
879
880	GlobalUnlock(hmmio);
881
882	return result;
883	}
884
885	/**************************************************************************
886	* mmioDescend [MMSYSTEM.1223]
887	*/
888	ODINFUNCTION4(UINT,mmioDescend,
889	HMMIO,hmmio,
890	LPMMCKINFO,lpck,
891	const MMCKINFO *,lpckParent,
892	UINT,uFlags)
893	{
894	DWORD dwOldPos;
895	FOURCC srchCkId;
896	FOURCC srchType;
897
898
899	// TRACE("(%04X, %p, %p, %04X);\n", hmmio, lpck, lpckParent, uFlags);
900
901	if (lpck == NULL)
902	return MMSYSERR_INVALPARAM;
903
904	dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
905	dprintf(("WINMM: mmioDescend - dwOldPos=%ld\n", dwOldPos));
906
907	if (lpckParent != NULL) {
908	TRACE("seek inside parent at %ld !\n", lpckParent->dwDataOffset);
909	/* EPP: was dwOldPos = mmioSeek(hmmio,lpckParent->dwDataOffset,SEEK_SET); */
910	if (dwOldPos < lpckParent->dwDataOffset \|\| dwOldPos >= lpckParent->dwDataOffset + lpckParent->cksize) {
911	dprintf(("WINMM: mmioDescend - outside parent chunk\n"));
912	return MMIOERR_CHUNKNOTFOUND;
913	}
914	}
915
916	/* The SDK docu says 'ckid' is used for all cases. Real World
917	* examples disagree -Marcus,990216.
918	*/
919
920	srchType = 0;
921	/* find_chunk looks for 'ckid' */
922	if (uFlags & MMIO_FINDCHUNK)
923	srchCkId = lpck->ckid;
924	/* find_riff and find_list look for 'fccType' */
925	if (uFlags & MMIO_FINDLIST) {
926	srchCkId = FOURCC_LIST;
927	srchType = lpck->fccType;
928	}
929	if (uFlags & MMIO_FINDRIFF) {
930	srchCkId = FOURCC_RIFF;
931	srchType = lpck->fccType;
932	}
933	dprintf(("WINMM: mmioDescend - searching for %.4s.%.4s\n",
934	(LPSTR)&srchCkId,
935	srchType?(LPSTR)&srchType:"<any>"));
936
937	if (uFlags & (MMIO_FINDCHUNK\|MMIO_FINDLIST\|MMIO_FINDRIFF)) {
938	while (TRUE) {
939	LONG ix;
940
941	ix = mmioRead(hmmio, (LPSTR)lpck, 3 * sizeof(DWORD));
942	if (ix < 2*sizeof(DWORD)) {
943	mmioSeek(hmmio, dwOldPos, SEEK_SET);
944	WARN("return ChunkNotFound\n");
945	return MMIOERR_CHUNKNOTFOUND;
946	}
947	lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD);
948	if (ix < lpck->dwDataOffset - dwOldPos) {
949	mmioSeek(hmmio, dwOldPos, SEEK_SET);
950	WARN("return ChunkNotFound\n");
951	return MMIOERR_CHUNKNOTFOUND;
952	}
953	dprintf(("WINMM: mmioDescend - ckid=%.4ss fcc=%.4ss cksize=%08lX !\n",
954	(LPSTR)&lpck->ckid,
955	srchType?(LPSTR)&lpck->fccType:"<unused>",
956	lpck->cksize));
957	if ((srchCkId == lpck->ckid) &&
958	(!srchType \|\| (srchType == lpck->fccType))
959	)
960	break;
961
962	dwOldPos = lpck->dwDataOffset + ((lpck->cksize + 1) & ~1);
963	mmioSeek(hmmio, dwOldPos, SEEK_SET);
964	}
965	} else {
966	/* FIXME: unverified, does it do this? */
967	if (mmioRead(hmmio, (LPSTR)lpck, 3 * sizeof(DWORD)) < 3 * sizeof(DWORD)) {
968	mmioSeek(hmmio, dwOldPos, SEEK_SET);
969	dprintf(("WINMM: mmioDescend - return ChunkNotFound 2nd\n"));
970	return MMIOERR_CHUNKNOTFOUND;
971	}
972	lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD);
973	}
974	lpck->dwFlags = 0;
975	/* If we were looking for RIFF/LIST chunks, the final file position
976	* is after the chunkid. If we were just looking for the chunk
977	* it is after the cksize. So add 4 in RIFF/LIST case.
978	*/
979	if (lpck->ckid == FOURCC_RIFF \|\| lpck->ckid == FOURCC_LIST)
980	mmioSeek(hmmio, lpck->dwDataOffset + sizeof(DWORD), SEEK_SET);
981	else
982	mmioSeek(hmmio, lpck->dwDataOffset, SEEK_SET);
983	dprintf(("WINMM: mmioDescend - lpck: ckid=%.4s, cksize=%ld, dwDataOffset=%ld fccType=%08lX (%.4s)!\n",
984	(LPSTR)&lpck->ckid, lpck->cksize, lpck->dwDataOffset,
985	lpck->fccType, srchType?(LPSTR)&lpck->fccType:""));
986	return 0;
987	}
988
989	/**************************************************************************
990	* mmioAscend [WINMM.113]
991	*/
992	ODINFUNCTION3(UINT,mmioAscend,
993	HMMIO,hmmio,
994	LPMMCKINFO,lpck,
995	UINT,uFlags)
996	{
997	// TRACE("(%04X, %p, %04X);\n", hmmio, lpck, uFlags);
998
999	if (lpck->dwFlags & MMIO_DIRTY) {
1000	DWORD dwOldPos, dwNewSize, dwSizePos;
1001
1002	dprintf(("WINMM: mmioAscend - chunk is marked MMIO_DIRTY, correcting chunk size\n"));
1003	dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
1004	dprintf(("WINMM: mmioAscend - dwOldPos=%ld\n", dwOldPos));
1005	dwNewSize = dwOldPos - lpck->dwDataOffset;
1006	if (dwNewSize != lpck->cksize) {
1007	TRACE("dwNewSize=%ld\n", dwNewSize);
1008	lpck->cksize = dwNewSize;
1009
1010	dwSizePos = lpck->dwDataOffset - sizeof(DWORD);
1011	dprintf(("WINMM: mmioAscend - dwSizePos=%ld\n", dwSizePos));
1012
1013	mmioSeek(hmmio, dwSizePos, SEEK_SET);
1014	mmioWrite(hmmio, (LPSTR)&dwNewSize, sizeof(DWORD));
1015	}
1016	}
1017
1018	mmioSeek(hmmio, lpck->dwDataOffset + ((lpck->cksize + 1) & ~1), SEEK_SET);
1019
1020	return 0;
1021	}
1022
1023	/**************************************************************************
1024	* mmioCreateChunk [WINMM.115]
1025	*/
1026	ODINFUNCTION3(UINT,mmioCreateChunk,
1027	HMMIO,hmmio,
1028	LPMMCKINFO,lpck,
1029	UINT,uFlags)
1030	{
1031	DWORD dwOldPos;
1032	LONG size;
1033	LONG ix;
1034
1035	// TRACE("(%04X, %p, %04X);\n", hmmio, lpck, uFlags);
1036
1037	dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
1038	dprintf(("WINMM: mmioCreateChunk - dwOldPos=%ld\n", dwOldPos));
1039
1040	if (uFlags == MMIO_CREATELIST)
1041	lpck->ckid = FOURCC_LIST;
1042	else if (uFlags == MMIO_CREATERIFF)
1043	lpck->ckid = FOURCC_RIFF;
1044
1045	dprintf(("WINMM: mmioCreateChunk - ckid=%08lX\n", lpck->ckid));
1046
1047	size = 2 * sizeof(DWORD);
1048	lpck->dwDataOffset = dwOldPos + size;
1049
1050	if (lpck->ckid == FOURCC_RIFF \|\| lpck->ckid == FOURCC_LIST)
1051	size += sizeof(DWORD);
1052	lpck->dwFlags = MMIO_DIRTY;
1053
1054	ix = mmioWrite(hmmio, (LPSTR)lpck, size);
1055	TRACE("after mmioWrite ix = %ld req = %ld, errno = %d\n",ix, size, errno);
1056	if (ix < size) {
1057	mmioSeek(hmmio, dwOldPos, SEEK_SET);
1058	dprintf(("WINMM: mmioCreateChunk - return CannotWrite\n"));
1059	return MMIOERR_CANNOTWRITE;
1060	}
1061
1062	return 0;
1063	}
1064
1065	/**************************************************************************
1066	* mmioRenameA [WINMM.125]
1067	*/
1068	ODINFUNCTION4(UINT,mmioRenameA,
1069	LPCSTR,szFileName,
1070	LPCSTR,szNewFileName,
1071	LPMMIOINFO,lpmmioinfo,
1072	DWORD,dwRenameFlags)
1073	{
1074	UINT result;
1075	LPMMIOINFO lpmminfo;
1076	HMMIO hmmio;
1077
1078	// TRACE("('%s', '%s', %p, %08lX);\n",
1079	// szFileName, szNewFileName, lpmmioinfo, dwRenameFlags);
1080	dprintf(("WINMM: This may fail - function untested\n"));
1081	hmmio = GlobalAlloc(GHND, sizeof(MMIOINFO));
1082	lpmminfo = (LPMMIOINFO) GlobalLock(hmmio);
1083
1084	if (lpmmioinfo)
1085	memcpy(lpmminfo, lpmmioinfo, sizeof(MMIOINFO));
1086
1087	/* assume DOS file if not otherwise specified */
1088	if (lpmminfo->fccIOProc == 0 && lpmminfo->pIOProc == NULL) {
1089
1090	lpmminfo->fccIOProc = mmioFOURCC('D', 'O', 'S', ' ');
1091	lpmminfo->pIOProc = (LPMMIOPROC) mmioDosIOProc;
1092
1093	}
1094	/* if just the four character code is present, look up IO proc */
1095	else if (lpmminfo->pIOProc == NULL) {
1096
1097	lpmminfo->pIOProc = mmioInstallIOProcA(lpmminfo->fccIOProc, NULL, MMIO_FINDPROC);
1098
1099	}
1100	/* (if IO proc specified, use it and specified four character code) */
1101
1102	result = (UINT) mmioSendMessage(hmmio, MMIOM_RENAME, (LPARAM) szFileName, (LPARAM) szNewFileName);
1103
1104	GlobalUnlock(hmmio);
1105	GlobalFree(hmmio);
1106
1107	return result;
1108	}
1109
1110
1111	/**************************************************************************
1112	* mmioRenameW [WINMM.126]
1113	*/
1114	ODINFUNCTION4(UINT,mmioRenameW,
1115	LPCWSTR,szFileName,
1116	LPCWSTR,szNewFileName,
1117	LPMMIOINFO,lpmmioinfo,
1118	DWORD,dwRenameFlags)
1119	{
1120	LPSTR szFn = HEAP_strdupWtoA(GetProcessHeap(), 0, szFileName);
1121	LPSTR sznFn = HEAP_strdupWtoA(GetProcessHeap(), 0, szNewFileName);
1122	UINT ret = mmioRenameA(szFn, sznFn, lpmmioinfo, dwRenameFlags);
1123
1124	HeapFree(GetProcessHeap(),0,szFn);
1125	HeapFree(GetProcessHeap(),0,sznFn);
1126	return ret;
1127	}
1128
1129	ODINFUNCTION3(LPMMIOPROC, mmioInstallIOProcW,
1130	FOURCC, fccIOProc,
1131	LPMMIOPROC, pIOProc,
1132	DWORD, dwFlags)
1133	{
1134	// TODO: What is difference in mmioInstallIOProcW and mmioInstallIOProcA?
1135	dprintf(("WINMM:mmioInstallIOProcW - stub\n"));
1136	return 0;
1137	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: