Navigation

← Previous Changeset
Next Changeset →

Changeset dcfd2c71c6e196ca7228a1efaa311ebb464c4ec6

Timestamp:

09/10/07 22:28:47 (10 months ago)

Author:

Rafaël Carré <funman@videolan.org>

git-committer:

Rafaël Carré <funman@videolan.org> 1189456127 +0000

git-parent:

[6ee1e193fd896ab9a4729fde14f009d9ce629815]

git-author:

Rafaël Carré <funman@videolan.org> 1189456127 +0000

Message:

Revert previous commit for loader as it is external to vlc

Files:

libs/loader/afl.c (modified) (29 diffs)
libs/loader/com.h (modified) (1 diff)
libs/loader/driver.c (modified) (5 diffs)
libs/loader/driver.h (modified) (1 diff)
libs/loader/ext.c (modified) (24 diffs)
libs/loader/ext.h (modified) (1 diff)
libs/loader/kludge.c (modified) (1 diff)
libs/loader/ldt_keeper.c (modified) (8 diffs)
libs/loader/loader.h (modified) (1 diff)
libs/loader/module.c (modified) (34 diffs)
libs/loader/pe_image.c (modified) (43 diffs)
libs/loader/pe_resource.c (modified) (7 diffs)
libs/loader/qtx/qtxsdk/components.h (modified) (9 diffs)
libs/loader/registry.c (modified) (14 diffs)
libs/loader/registry.h (modified) (1 diff)
libs/loader/resource.c (modified) (23 diffs)
libs/loader/vfl.c (modified) (5 diffs)
libs/loader/win32.c (modified) (191 diffs)
libs/loader/wine/avifmt.h (modified) (12 diffs)
libs/loader/wine/driver.h (modified) (4 diffs)
libs/loader/wine/heap.h (modified) (1 diff)
libs/loader/wine/mmreg.h (modified) (1 diff)
libs/loader/wine/module.h (modified) (4 diffs)
libs/loader/wine/msacm.h (modified) (16 diffs)
libs/loader/wine/msacmdrv.h (modified) (1 diff)
libs/loader/wine/pe_image.h (modified) (3 diffs)
libs/loader/wine/vfw.h (modified) (18 diffs)
libs/loader/wine/winbase.h (modified) (22 diffs)
libs/loader/wine/windef.h (modified) (7 diffs)
libs/loader/wine/winerror.h (modified) (8 diffs)
libs/loader/wine/winnt.h (modified) (52 diffs)
libs/loader/wine/winreg.h (modified) (2 diffs)
libs/loader/wine/winuser.h (modified) (50 diffs)
libs/loader/wineacm.h (modified) (4 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

libs/loader/afl.c

r6ee1e19	rdcfd2c7
34	34	actually, for audio decompression only the following functions
35	35	are needed:
36
	36
37	37	acmStreamOpen ( takes formats of src and dest, returns stream handle )
38	38	acmStreamPrepareHeader ( takes stream handler and info on data )
…	…
42	42	acmStreamSize
43	43	maybe acmStreamReset
44
45		In future I'll also add functions for format enumeration,
	44
	45	In future I'll also add functions for format enumeration,
46	46	but not right now.
47	47
48	48	Modified for use with MPlayer, detailed CVS changelog at
49	49	http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
50
	50
51	51	***************************************************************************/
52	52	#include "config.h"
…	…
83	83	*/
84	84	MMRESULT WINAPI acmDriverAddA(PHACMDRIVERID phadid, HINSTANCE hinstModule,
85		LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
	85	LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
86	86	{
87	87	if (!phadid)
88		return MMSYSERR_INVALPARAM;
89
	88	return MMSYSERR_INVALPARAM;
	89
90	90	/* Check if any unknown flags */
91		if (fdwAdd &
92		~(ACM_DRIVERADDF_FUNCTION\|ACM_DRIVERADDF_NOTIFYHWND\|
93		ACM_DRIVERADDF_GLOBAL))
94		return MMSYSERR_INVALFLAG;
95
	91	if (fdwAdd &
	92	~(ACM_DRIVERADDF_FUNCTION\|ACM_DRIVERADDF_NOTIFYHWND\|
	93	ACM_DRIVERADDF_GLOBAL))
	94	return MMSYSERR_INVALFLAG;
	95
96	96	/* Check if any incompatible flags */
97		if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
98		(fdwAdd & ACM_DRIVERADDF_NOTIFYHWND))
99		return MMSYSERR_INVALFLAG;
100
101		/* FIXME: in fact, should GetModuleFileName(hinstModule) and do a
	97	if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
	98	(fdwAdd & ACM_DRIVERADDF_NOTIFYHWND))
	99	return MMSYSERR_INVALFLAG;
	100
	101	/* FIXME: in fact, should GetModuleFileName(hinstModule) and do a
102	102	* LoadDriver on it, to be sure we can call SendDriverMessage on the
103	103	* hDrvr handle.
104	104	*/
105	105	*phadid = (HACMDRIVERID) MSACM_RegisterDriver(NULL, 0, hinstModule);
106
	106
107	107	/* FIXME: lParam, dwPriority and fdwAdd ignored */
108
	108
109	109	return MMSYSERR_NOERROR;
110	110	}
…	…
117	117	PWINE_ACMDRIVER p;
118	118	PWINE_ACMDRIVER* tp;
119
	119
120	120	if (fdwClose)
121		return MMSYSERR_INVALFLAG;
122
	121	return MMSYSERR_INVALFLAG;
	122
123	123	p = MSACM_GetDriver(had);
124	124	if (!p)
125		return MMSYSERR_INVALHANDLE;
	125	return MMSYSERR_INVALHANDLE;
126	126
127	127	for (tp = &(p->obj.pACMDriverID->pACMDriverList); tp; tp = (*tp)->pNextACMDriver) {
128		if (*tp == p) {
129		tp = (tp)->pNextACMDriver;
130		break;
131		}
132		}
133
	128	if (*tp == p) {
	129	tp = (tp)->pNextACMDriver;
	130	break;
	131	}
	132	}
	133
134	134	if (p->hDrvr && !p->obj.pACMDriverID->pACMDriverList)
135		CloseDriver(p->hDrvr);
136
	135	CloseDriver(p->hDrvr);
	136
137	137	HeapFree(MSACM_hHeap, 0, p);
138
	138
139	139	return MMSYSERR_NOERROR;
140	140	}
…	…
145	145	MMRESULT WINAPI acmDriverEnum(ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
146	146	{
147		PWINE_ACMDRIVERID p;
148		DWORD fdwSupport;
	147	PWINE_ACMDRIVERID p;
	148	DWORD fdwSupport;
149	149
150	150	if (!fnCallback) {
151		return MMSYSERR_INVALPARAM;
152		}
153
	151	return MMSYSERR_INVALPARAM;
	152	}
	153
154	154	if (fdwEnum && ~(ACM_DRIVERENUMF_NOLOCAL\|ACM_DRIVERENUMF_DISABLED)) {
155		return MMSYSERR_INVALFLAG;
156		}
157
	155	return MMSYSERR_INVALFLAG;
	156	}
	157
158	158	for (p = MSACM_pFirstACMDriverID; p; p = p->pNextACMDriverID) {
159		fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
160		if (!p->bEnabled) {
161		if (fdwEnum & ACM_DRIVERENUMF_DISABLED)
162		fdwSupport \|= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
163		else
164		continue;
165		}
166		(*fnCallback)((HACMDRIVERID) p, dwInstance, fdwSupport);
167		}
168
	159	fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
	160	if (!p->bEnabled) {
	161	if (fdwEnum & ACM_DRIVERENUMF_DISABLED)
	162	fdwSupport \|= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
	163	else
	164	continue;
	165	}
	166	(*fnCallback)((HACMDRIVERID) p, dwInstance, fdwSupport);
	167	}
	168
169	169	return MMSYSERR_NOERROR;
170	170	}
…	…
176	176	{
177	177	PWINE_ACMOBJ pao;
178
	178
179	179	pao = MSACM_GetObj(hao);
180	180	if (!pao)
181		return MMSYSERR_INVALHANDLE;
182
	181	return MMSYSERR_INVALHANDLE;
	182
183	183	if (!phadid)
184		return MMSYSERR_INVALPARAM;
185
	184	return MMSYSERR_INVALPARAM;
	185
186	186	if (fdwDriverID)
187		return MMSYSERR_INVALFLAG;
188
	187	return MMSYSERR_INVALFLAG;
	188
189	189	*phadid = (HACMDRIVERID) pao->pACMDriverID;
190
	190
191	191	return MMSYSERR_NOERROR;
192	192	}
…	…
201	201	PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
202	202	if (!pad)
203		return MMSYSERR_INVALPARAM;
204
	203	return MMSYSERR_INVALPARAM;
	204
205	205	/* FIXME: Check if uMsg legal */
206
	206
207	207	if (!SendDriverMessage(pad->hDrvr, uMsg, lParam1, lParam2))
208		return MMSYSERR_NOTSUPPORTED;
209
	208	return MMSYSERR_NOTSUPPORTED;
	209
210	210	return MMSYSERR_NOERROR;
211	211	}
…	…
217	217	MMRESULT WINAPI acmDriverOpen(PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
218	218	{
219		PWINE_ACMDRIVERID padid;
220		PWINE_ACMDRIVER pad;
221		ICOPEN icopen;
222		HDRVR hdrv;
	219	PWINE_ACMDRIVERID padid;
	220	PWINE_ACMDRIVER pad;
	221	ICOPEN icopen;
	222	HDRVR hdrv;
223	223
224	224
…	…
226	226
227	227	if (!phad)
228		return MMSYSERR_INVALPARAM;
229
230		padid = MSACM_GetDriverID(hadid);
	228	return MMSYSERR_INVALPARAM;
	229
	230	padid = MSACM_GetDriverID(hadid);
231	231	if (!padid)
232		return MMSYSERR_INVALHANDLE;
233
	232	return MMSYSERR_INVALHANDLE;
	233
234	234	if (fdwOpen)
235		return MMSYSERR_INVALFLAG;
236
	235	return MMSYSERR_INVALFLAG;
	236
237	237	pad = (PWINE_ACMDRIVER) HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER));
238	238	if (!pad)
239		return MMSYSERR_NOMEM;
	239	return MMSYSERR_NOMEM;
240	240
241	241	pad->obj.pACMDriverID = padid;
242		icopen.fccType = mmioFOURCC('a', 'u', 'd', 'c');
243		icopen.fccHandler = (long)padid->pszFileName;
244		icopen.dwSize = sizeof(ICOPEN);
245		icopen.dwFlags = 0;
	242	icopen.fccType = mmioFOURCC('a', 'u', 'd', 'c');
	243	icopen.fccHandler = (long)padid->pszFileName;
	244	icopen.dwSize = sizeof(ICOPEN);
	245	icopen.dwFlags = 0;
246	246
247	247	icopen.pV1Reserved = padid->pszFileName;
248	248	if (!padid->hInstModule)
249		pad->hDrvr = OpenDriverA((long)&icopen);
	249	pad->hDrvr = OpenDriverA((long)&icopen);
250	250	else
251		pad->hDrvr = padid->hInstModule;
252
	251	pad->hDrvr = padid->hInstModule;
	252
253	253	if (!pad->hDrvr) {
254		HeapFree(MSACM_hHeap, 0, pad);
255		return MMSYSERR_ERROR;
	254	HeapFree(MSACM_hHeap, 0, pad);
	255	return MMSYSERR_ERROR;
256	256	}
257	257
…	…
274	274	{
275	275	PWINE_ACMDRIVERID padid;
276
	276
277	277	padid = MSACM_GetDriverID(hadid);
278	278	if (!padid)
279		return MMSYSERR_INVALHANDLE;
280
	279	return MMSYSERR_INVALHANDLE;
	280
281	281	if (fdwRemove)
282		return MMSYSERR_INVALFLAG;
283
	282	return MMSYSERR_INVALFLAG;
	283
284	284	MSACM_UnregisterDriver(padid);
285
	285
286	286	return MMSYSERR_NOERROR;
287	287	}
…	…
296	296
297	297	/***********************************************************************
298		* MSACM_RegisterDriver32()
	298	* MSACM_RegisterDriver32()
299	299	*/
300	300	PWINE_ACMDRIVERID MSACM_RegisterDriver(const char* pszFileName,
301		WORD wFormatTag,
302		HINSTANCE hinstModule)
	301	WORD wFormatTag,
	302	HINSTANCE hinstModule)
303	303	{
304	304	PWINE_ACMDRIVERID padid;
…	…
307	307
308	308	#ifndef WIN32_LOADER
309		MSACM_hHeap = GetProcessHeap();
	309	MSACM_hHeap = GetProcessHeap();
310	310	#endif
311	311	padid = (PWINE_ACMDRIVERID) HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVERID));
…	…
320	320	padid->pPrevACMDriverID = MSACM_pLastACMDriverID;
321	321	if (MSACM_pLastACMDriverID)
322		MSACM_pLastACMDriverID->pNextACMDriverID = padid;
	322	MSACM_pLastACMDriverID->pNextACMDriverID = padid;
323	323	MSACM_pLastACMDriverID = padid;
324	324	if (!MSACM_pFirstACMDriverID)
325		MSACM_pFirstACMDriverID = padid;
326
	325	MSACM_pFirstACMDriverID = padid;
	326
327	327	return padid;
328	328	}
…	…
335	335	{
336	336	PWINE_ACMDRIVERID pNextACMDriverID;
337
	337
338	338	while (p->pACMDriverList)
339		acmDriverClose((HACMDRIVER) p->pACMDriverList, 0);
340
	339	acmDriverClose((HACMDRIVER) p->pACMDriverList, 0);
	340
341	341	if (p->pszFileName)
342		free(p->pszFileName);
343
	342	free(p->pszFileName);
	343
344	344	if (p == MSACM_pFirstACMDriverID)
345		MSACM_pFirstACMDriverID = p->pNextACMDriverID;
	345	MSACM_pFirstACMDriverID = p->pNextACMDriverID;
346	346	if (p == MSACM_pLastACMDriverID)
347		MSACM_pLastACMDriverID = p->pPrevACMDriverID;
	347	MSACM_pLastACMDriverID = p->pPrevACMDriverID;
348	348
349	349	if (p->pPrevACMDriverID)
350		p->pPrevACMDriverID->pNextACMDriverID = p->pNextACMDriverID;
	350	p->pPrevACMDriverID->pNextACMDriverID = p->pNextACMDriverID;
351	351	if (p->pNextACMDriverID)
352		p->pNextACMDriverID->pPrevACMDriverID = p->pPrevACMDriverID;
353
	352	p->pNextACMDriverID->pPrevACMDriverID = p->pPrevACMDriverID;
	353
354	354	pNextACMDriverID = p->pNextACMDriverID;
355
	355
356	356	HeapFree(MSACM_hHeap, 0, p);
357
	357
358	358	return pNextACMDriverID;
359	359	}
…	…
372	372
373	373	/***********************************************************************
374		* MSACM_GetDriverID32()
	374	* MSACM_GetDriverID32()
375	375	*/
376	376	PWINE_ACMDRIVERID MSACM_GetDriverID(HACMDRIVERID hDriverID)
…	…
401	401	*/
402	402	MMRESULT WINAPI acmStreamOpen(PHACMSTREAM phas, HACMDRIVER had, PWAVEFORMATEX pwfxSrc,
403		PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD dwCallback,
404		DWORD dwInstance, DWORD fdwOpen)
405		{
406		PWINE_ACMSTREAM was;
407		PWINE_ACMDRIVER wad;
408		MMRESULT ret;
409		int wfxSrcSize;
410		int wfxDstSize;
411
	403	PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD dwCallback,
	404	DWORD dwInstance, DWORD fdwOpen)
	405	{
	406	PWINE_ACMSTREAM was;
	407	PWINE_ACMDRIVER wad;
	408	MMRESULT ret;
	409	int wfxSrcSize;
	410	int wfxDstSize;
	411
412	412	TRACE("(%p, 0x%08x, %p, %p, %p, %ld, %ld, %ld)\n",
413		phas, had, pwfxSrc, pwfxDst, pwfltr, dwCallback, dwInstance, fdwOpen);
414
415		TRACE("src [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
416		pwfxSrc->wFormatTag, pwfxSrc->nChannels, pwfxSrc->nSamplesPerSec, pwfxSrc->nAvgBytesPerSec,
417		pwfxSrc->nBlockAlign, pwfxSrc->wBitsPerSample, pwfxSrc->cbSize);
418
419		TRACE("dst [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
420		pwfxDst->wFormatTag, pwfxDst->nChannels, pwfxDst->nSamplesPerSec, pwfxDst->nAvgBytesPerSec,
421		pwfxDst->nBlockAlign, pwfxDst->wBitsPerSample, pwfxDst->cbSize);
	413	phas, had, pwfxSrc, pwfxDst, pwfltr, dwCallback, dwInstance, fdwOpen);
	414
	415	TRACE("src [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
	416	pwfxSrc->wFormatTag, pwfxSrc->nChannels, pwfxSrc->nSamplesPerSec, pwfxSrc->nAvgBytesPerSec,
	417	pwfxSrc->nBlockAlign, pwfxSrc->wBitsPerSample, pwfxSrc->cbSize);
	418
	419	TRACE("dst [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
	420	pwfxDst->wFormatTag, pwfxDst->nChannels, pwfxDst->nSamplesPerSec, pwfxDst->nAvgBytesPerSec,
	421	pwfxDst->nBlockAlign, pwfxDst->wBitsPerSample, pwfxDst->cbSize);
422	422
423	423	#define SIZEOF_WFX(wfx) (sizeof(WAVEFORMATEX) + ((wfx->wFormatTag == WAVE_FORMAT_PCM) ? 0 : wfx->cbSize))
…	…
428	428	was = (PWINE_ACMSTREAM) HeapAlloc(MSACM_hHeap, 0, sizeof(*was) + wfxSrcSize + wfxDstSize + ((pwfltr) ? sizeof(WAVEFILTER) : 0));
429	429	if (was == NULL)
430		return MMSYSERR_NOMEM;
	430	return MMSYSERR_NOMEM;
431	431	was->drvInst.cbStruct = sizeof(was->drvInst);
432	432	was->drvInst.pwfxSrc = (PWAVEFORMATEX)((LPSTR)was + sizeof(*was));
…	…
438	438	memcpy(was->drvInst.pwfxDst, pwfxDst, wfxDstSize);
439	439	if (pwfltr) {
440		was->drvInst.pwfltr = (PWAVEFILTER)((LPSTR)was + sizeof(*was) + wfxSrcSize + wfxDstSize);
441		memcpy(was->drvInst.pwfltr, pwfltr, sizeof(WAVEFILTER));
	440	was->drvInst.pwfltr = (PWAVEFILTER)((LPSTR)was + sizeof(*was) + wfxSrcSize + wfxDstSize);
	441	memcpy(was->drvInst.pwfltr, pwfltr, sizeof(WAVEFILTER));
442	442	} else {
443		was->drvInst.pwfltr = NULL;
444		}
445		was->drvInst.dwCallback = dwCallback;
	443	was->drvInst.pwfltr = NULL;
	444	}
	445	was->drvInst.dwCallback = dwCallback;
446	446	was->drvInst.dwInstance = dwInstance;
447	447	was->drvInst.fdwOpen = fdwOpen;
448		was->drvInst.fdwDriver = 0L;
449		was->drvInst.dwDriver = 0L;
	448	was->drvInst.fdwDriver = 0L;
	449	was->drvInst.dwDriver = 0L;
450	450	was->drvInst.has = (HACMSTREAM)was;
451
	451
452	452	if (had) {
453		if (!(wad = MSACM_GetDriver(had))) {
454		ret = MMSYSERR_INVALPARAM;
455		goto errCleanUp;
456		}
457
458		was->obj.pACMDriverID = wad->obj.pACMDriverID;
459		was->pDrv = wad;
460		was->hAcmDriver = 0; /* not to close it in acmStreamClose */
461
462		ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
463		if (ret != MMSYSERR_NOERROR)
464		goto errCleanUp;
	453	if (!(wad = MSACM_GetDriver(had))) {
	454	ret = MMSYSERR_INVALPARAM;
	455	goto errCleanUp;
	456	}
	457
	458	was->obj.pACMDriverID = wad->obj.pACMDriverID;
	459	was->pDrv = wad;
	460	was->hAcmDriver = 0; /* not to close it in acmStreamClose */
	461
	462	ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
	463	if (ret != MMSYSERR_NOERROR)
	464	goto errCleanUp;
465	465	} else {
466		PWINE_ACMDRIVERID wadi;
467		short drv_tag;
468		ret = ACMERR_NOTPOSSIBLE;
469		/* if(pwfxSrc->wFormatTag==1)//compression
470		drv_tag=pwfxDst->wFormatTag;
471		else
472		if(pwfxDst->wFormatTag==1)//decompression
473		drv_tag=pwfxSrc->wFormatTag;
474		else
475		goto errCleanUp;
476
477		ret=acmDriverOpen2(drv_tag);
478		if (ret == MMSYSERR_NOERROR) {
479		if ((wad = MSACM_GetDriver(had)) != 0) {
480		was->obj.pACMDriverID = wad->obj.pACMDriverID;
481		was->pDrv = wad;
482		was->hAcmDriver = had;
483
484		ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
485		if (ret == MMSYSERR_NOERROR) {
486		if (fdwOpen & ACM_STREAMOPENF_QUERY) {
487		acmDriverClose(had, 0L);
488		}
489		break;
490		}
491		}
492		acmDriverClose(had, 0L);*/
493		//if(MSACM_pFirstACMDriverID==NULL)
494		// MSACM_RegisterAllDrivers();
495
496		for (wadi = MSACM_pFirstACMDriverID; wadi; wadi = wadi->pNextACMDriverID)
497		{
498		/* Check Format */
499		if ((int)wadi->wFormatTag != (int)pwfxSrc->wFormatTag) continue;
500
501		ret = acmDriverOpen(&had, (HACMDRIVERID)wadi, 0L);
502		if (ret == MMSYSERR_NOERROR) {
503		if ((wad = MSACM_GetDriver(had)) != 0) {
504		was->obj.pACMDriverID = wad->obj.pACMDriverID;
505		was->pDrv = wad;
506		was->hAcmDriver = had;
507
508		ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
509		//lhacm - crash printf("RETOPEN %d\n", ret);
	466	PWINE_ACMDRIVERID wadi;
	467	short drv_tag;
	468	ret = ACMERR_NOTPOSSIBLE;
	469	/* if(pwfxSrc->wFormatTag==1)//compression
	470	drv_tag=pwfxDst->wFormatTag;
	471	else
	472	if(pwfxDst->wFormatTag==1)//decompression
	473	drv_tag=pwfxSrc->wFormatTag;
	474	else
	475	goto errCleanUp;
	476
	477	ret=acmDriverOpen2(drv_tag);
	478	if (ret == MMSYSERR_NOERROR) {
	479	if ((wad = MSACM_GetDriver(had)) != 0) {
	480	was->obj.pACMDriverID = wad->obj.pACMDriverID;
	481	was->pDrv = wad;
	482	was->hAcmDriver = had;
	483
	484	ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
	485	if (ret == MMSYSERR_NOERROR) {
	486	if (fdwOpen & ACM_STREAMOPENF_QUERY) {
	487	acmDriverClose(had, 0L);
	488	}
	489	break;
	490	}
	491	}
	492	acmDriverClose(had, 0L);*/
	493	//if(MSACM_pFirstACMDriverID==NULL)
	494	// MSACM_RegisterAllDrivers();
	495
	496	for (wadi = MSACM_pFirstACMDriverID; wadi; wadi = wadi->pNextACMDriverID)
	497	{
	498	/* Check Format */
	499	if ((int)wadi->wFormatTag != (int)pwfxSrc->wFormatTag) continue;
	500
	501	ret = acmDriverOpen(&had, (HACMDRIVERID)wadi, 0L);
	502	if (ret == MMSYSERR_NOERROR) {
	503	if ((wad = MSACM_GetDriver(had)) != 0) {
	504	was->obj.pACMDriverID = wad->obj.pACMDriverID;
	505	was->pDrv = wad;
	506	was->hAcmDriver = had;
	507
	508	ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
	509	//lhacm - crash printf("RETOPEN %d\n", ret);
510	510	//ret = 0;
511		if (ret == MMSYSERR_NOERROR) {
512		if (fdwOpen & ACM_STREAMOPENF_QUERY) {
513		acmDriverClose(had, 0L);
514		}
515		break;
516		}
517		}
518		// no match, close this acm driver and try next one
519		acmDriverClose(had, 0L);
520		}
521		}
522		if (ret != MMSYSERR_NOERROR) {
523		ret = ACMERR_NOTPOSSIBLE;
524		goto errCleanUp;
525		}
	511	if (ret == MMSYSERR_NOERROR) {
	512	if (fdwOpen & ACM_STREAMOPENF_QUERY) {
	513	acmDriverClose(had, 0L);
	514	}
	515	break;
	516	}
	517	}
	518	// no match, close this acm driver and try next one
	519	acmDriverClose(had, 0L);
	520	}
	521	}
	522	if (ret != MMSYSERR_NOERROR) {
	523	ret = ACMERR_NOTPOSSIBLE;
	524	goto errCleanUp;
	525	}
526	526	}
527	527	ret = MMSYSERR_NOERROR;
528	528	if (!(fdwOpen & ACM_STREAMOPENF_QUERY)) {
529		if (phas)
530		*phas = (HACMSTREAM)was;
531		TRACE("=> (%d)\n", ret);
	529	if (phas)
	530	*phas = (HACMSTREAM)was;
	531	TRACE("=> (%d)\n", ret);
532	532	#ifdef WIN32_LOADER
533	533	CodecAlloc();
534	534	#endif
535		return ret;
536		}
537		errCleanUp:
	535	return ret;
	536	}
	537	errCleanUp:
538	538	if (phas)
539		*phas = (HACMSTREAM)0;
	539	*phas = (HACMSTREAM)0;
540	540	HeapFree(MSACM_hHeap, 0, was);
541	541	TRACE("=> (%d)\n", ret);
…	…
546	546	MMRESULT WINAPI acmStreamClose(HACMSTREAM has, DWORD fdwClose)
547	547	{
548		PWINE_ACMSTREAM was;
549		MMRESULT ret;
550
	548	PWINE_ACMSTREAM was;
	549	MMRESULT ret;
	550
551	551	TRACE("(0x%08x, %ld)\n", has, fdwClose);
552
	552
553	553	if ((was = ACM_GetStream(has)) == NULL) {
554		return MMSYSERR_INVALHANDLE;
	554	return MMSYSERR_INVALHANDLE;
555	555	}
556	556	ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_CLOSE, (DWORD)&was->drvInst, 0);
557	557	if (ret == MMSYSERR_NOERROR) {
558		if (was->hAcmDriver)
559		acmDriverClose(was->hAcmDriver, 0L);
560		HeapFree(MSACM_hHeap, 0, was);
	558	if (was->hAcmDriver)
	559	acmDriverClose(was->hAcmDriver, 0L);
	560	HeapFree(MSACM_hHeap, 0, was);
561	561	#ifdef WIN32_LOADER
562	562	CodecRelease();
…	…
570	570	* acmStreamConvert (MSACM32.38)
571	571	*/
572		MMRESULT WINAPI acmStreamConvert(HACMSTREAM has, PACMSTREAMHEADER pash,
573		DWORD fdwConvert)
574		{
575		PWINE_ACMSTREAM was;
576		MMRESULT ret = MMSYSERR_NOERROR;
577		PACMDRVSTREAMHEADER padsh;
	572	MMRESULT WINAPI acmStreamConvert(HACMSTREAM has, PACMSTREAMHEADER pash,
	573	DWORD fdwConvert)
	574	{
	575	PWINE_ACMSTREAM was;
	576	MMRESULT ret = MMSYSERR_NOERROR;
	577	PACMDRVSTREAMHEADER padsh;
578	578
579	579	TRACE("(0x%08x, %p, %ld)\n", has, pash, fdwConvert);
580	580
581	581	if ((was = ACM_GetStream(has)) == NULL)
582		return MMSYSERR_INVALHANDLE;
	582	return MMSYSERR_INVALHANDLE;
583	583	if (!pash \|\| pash->cbStruct < sizeof(ACMSTREAMHEADER))
584		return MMSYSERR_INVALPARAM;
	584	return MMSYSERR_INVALPARAM;
585	585
586	586	if (!(pash->fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED))
587		return ACMERR_UNPREPARED;
	587	return ACMERR_UNPREPARED;
588	588
589	589	/* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
…	…
595	595	/* check that pointers have not been modified */
596	596	if (padsh->pbPreparedSrc != padsh->pbSrc \|\|
597		padsh->cbPreparedSrcLength < padsh->cbSrcLength \|\|
598		padsh->pbPreparedDst != padsh->pbDst \|\|
599		padsh->cbPreparedDstLength < padsh->cbDstLength) {
600		return MMSYSERR_INVALPARAM;
601		}
	597	padsh->cbPreparedSrcLength < padsh->cbSrcLength \|\|
	598	padsh->pbPreparedDst != padsh->pbDst \|\|
	599	padsh->cbPreparedDstLength < padsh->cbDstLength) {
	600	return MMSYSERR_INVALPARAM;
	601	}
602	602
603	603	padsh->fdwConvert = fdwConvert;
…	…
605	605	ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_CONVERT, (DWORD)&was->drvInst, (DWORD)padsh);
606	606	if (ret == MMSYSERR_NOERROR) {
607		padsh->fdwStatus \|= ACMSTREAMHEADER_STATUSF_DONE;
	607	padsh->fdwStatus \|= ACMSTREAMHEADER_STATUSF_DONE;
608	608	}
609	609	TRACE("=> (%d)\n", ret);
…	…
615	615	* acmStreamPrepareHeader (MSACM32.41)
616	616	*/
617		MMRESULT WINAPI acmStreamPrepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
618		DWORD fdwPrepare)
619		{
620		PWINE_ACMSTREAM was;
621		MMRESULT ret = MMSYSERR_NOERROR;
622		PACMDRVSTREAMHEADER padsh;
	617	MMRESULT WINAPI acmStreamPrepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
	618	DWORD fdwPrepare)
	619	{
	620	PWINE_ACMSTREAM was;
	621	MMRESULT ret = MMSYSERR_NOERROR;
	622	PACMDRVSTREAMHEADER padsh;
623	623
624	624	TRACE("(0x%08x, %p, %ld)\n", has, pash, fdwPrepare);
625
	625
626	626	if ((was = ACM_GetStream(has)) == NULL)
627		return MMSYSERR_INVALHANDLE;
	627	return MMSYSERR_INVALHANDLE;
628	628	if (!pash \|\| pash->cbStruct < sizeof(ACMSTREAMHEADER))
629		return MMSYSERR_INVALPARAM;
	629	return MMSYSERR_INVALPARAM;
630	630	if (fdwPrepare)
631		ret = MMSYSERR_INVALFLAG;
	631	ret = MMSYSERR_INVALFLAG;
632	632
633	633	if (pash->fdwStatus & ACMSTREAMHEADER_STATUSF_DONE)
634		return MMSYSERR_NOERROR;
	634	return MMSYSERR_NOERROR;
635	635
636	636	/* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
…	…
653	653	ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_PREPARE, (DWORD)&was->drvInst, (DWORD)padsh);
654	654	if (ret == MMSYSERR_NOERROR \|\| ret == MMSYSERR_NOTSUPPORTED) {
655		ret = MMSYSERR_NOERROR;
656		padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_DONE\|ACMSTREAMHEADER_STATUSF_INQUEUE);
657		padsh->fdwStatus \|= ACMSTREAMHEADER_STATUSF_PREPARED;
658		padsh->fdwPrepared = padsh->fdwStatus;
659		padsh->dwPrepared = 0;
660		padsh->pbPreparedSrc = padsh->pbSrc;
661		padsh->cbPreparedSrcLength = padsh->cbSrcLength;
662		padsh->pbPreparedDst = padsh->pbDst;
663		padsh->cbPreparedDstLength = padsh->cbDstLength;
	655	ret = MMSYSERR_NOERROR;
	656	padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_DONE\|ACMSTREAMHEADER_STATUSF_INQUEUE);
	657	padsh->fdwStatus \|= ACMSTREAMHEADER_STATUSF_PREPARED;
	658	padsh->fdwPrepared = padsh->fdwStatus;
	659	padsh->dwPrepared = 0;
	660	padsh->pbPreparedSrc = padsh->pbSrc;
	661	padsh->cbPreparedSrcLength = padsh->cbSrcLength;
	662	padsh->pbPreparedDst = padsh->pbDst;
	663	padsh->cbPreparedDstLength = padsh->cbDstLength;
664	664	} else {
665		padsh->fdwPrepared = 0;
666		padsh->dwPrepared = 0;
667		padsh->pbPreparedSrc = 0;
668		padsh->cbPreparedSrcLength = 0;
669		padsh->pbPreparedDst = 0;
670		padsh->cbPreparedDstLength = 0;
	665	padsh->fdwPrepared = 0;
	666	padsh->dwPrepared = 0;
	667	padsh->pbPreparedSrc = 0;
	668	padsh->cbPreparedSrcLength = 0;
	669	padsh->pbPreparedDst = 0;
	670	padsh->cbPreparedDstLength = 0;
671	671	}
672	672	TRACE("=> (%d)\n", ret);
…	…
679	679	MMRESULT WINAPI acmStreamReset(HACMSTREAM has, DWORD fdwReset)
680	680	{
681		PWINE_ACMSTREAM was;
682		MMRESULT ret = MMSYSERR_NOERROR;
	681	PWINE_ACMSTREAM was;
	682	MMRESULT ret = MMSYSERR_NOERROR;
683	683
684	684	TRACE("(0x%08x, %ld)\n", has, fdwReset);
685	685
686	686	if (fdwReset) {
687		ret = MMSYSERR_INVALFLAG;
	687	ret = MMSYSERR_INVALFLAG;
688	688	} else if ((was = ACM_GetStream(has)) == NULL) {
689		return MMSYSERR_INVALHANDLE;
	689	return MMSYSERR_INVALHANDLE;
690	690	} else if (was->drvInst.fdwOpen & ACM_STREAMOPENF_ASYNC) {
691		ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_RESET, (DWORD)&was->drvInst, 0);
	691	ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_RESET, (DWORD)&was->drvInst, 0);
692	692	}
693	693	TRACE("=> (%d)\n", ret);
…	…
698	698	* acmStreamSize (MSACM32.43)
699	699	*/
700		MMRESULT WINAPI acmStreamSize(HACMSTREAM has, DWORD cbInput,
701		LPDWORD pdwOutputBytes, DWORD fdwSize)
702		{
703		PWINE_ACMSTREAM was;
704		ACMDRVSTREAMSIZE adss;
705		MMRESULT ret;
706
	700	MMRESULT WINAPI acmStreamSize(HACMSTREAM has, DWORD cbInput,
	701	LPDWORD pdwOutputBytes, DWORD fdwSize)
	702	{
	703	PWINE_ACMSTREAM was;
	704	ACMDRVSTREAMSIZE adss;
	705	MMRESULT ret;
	706
707	707	TRACE("(0x%08x, %ld, %p, %ld)\n", has, cbInput, pdwOutputBytes, fdwSize);
708
	708
709	709	if ((was = ACM_GetStream(has)) == NULL) {
710		return MMSYSERR_INVALHANDLE;
	710	return MMSYSERR_INVALHANDLE;
711	711	}
712	712	if ((fdwSize & ~ACM_STREAMSIZEF_QUERYMASK) != 0) {
713		return MMSYSERR_INVALFLAG;
	713	return MMSYSERR_INVALFLAG;
714	714	}
715	715
716	716	*pdwOutputBytes = 0L;
717
	717
718	718	switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
719	719	case ACM_STREAMSIZEF_DESTINATION:
720		adss.cbDstLength = cbInput;
721		adss.cbSrcLength = 0;
722		break;
	720	adss.cbDstLength = cbInput;
	721	adss.cbSrcLength = 0;
	722	break;
723	723	case ACM_STREAMSIZEF_SOURCE:
724		adss.cbSrcLength = cbInput;
725		adss.cbDstLength = 0;
726		break;
727		default:
728		return MMSYSERR_INVALFLAG;
729		}
730
	724	adss.cbSrcLength = cbInput;
	725	adss.cbDstLength = 0;
	726	break;
	727	default:
	728	return MMSYSERR_INVALFLAG;
	729	}
	730
731	731	adss.cbStruct = sizeof(adss);
732	732	adss.fdwSize = fdwSize;
733		ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_SIZE,
734		(DWORD)&was->drvInst, (DWORD)&adss);
	733	ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_SIZE,
	734	(DWORD)&was->drvInst, (DWORD)&adss);
735	735	if (ret == MMSYSERR_NOERROR) {
736		switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
737		case ACM_STREAMSIZEF_DESTINATION:
738		*pdwOutputBytes = adss.cbSrcLength;
739		break;
740		case ACM_STREAMSIZEF_SOURCE:
741		*pdwOutputBytes = adss.cbDstLength;
742		break;
743		}
	736	switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
	737	case ACM_STREAMSIZEF_DESTINATION:
	738	*pdwOutputBytes = adss.cbSrcLength;
	739	break;
	740	case ACM_STREAMSIZEF_SOURCE:
	741	*pdwOutputBytes = adss.cbDstLength;
	742	break;
	743	}
744	744	}
745	745	TRACE("=> (%d) [%lu]\n", ret, *pdwOutputBytes);
…	…
750	750	* acmStreamUnprepareHeader (MSACM32.44)
751	751	*/
752		MMRESULT WINAPI acmStreamUnprepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
753		DWORD fdwUnprepare)
754		{
755		PWINE_ACMSTREAM was;
756		MMRESULT ret = MMSYSERR_NOERROR;
757		PACMDRVSTREAMHEADER padsh;
	752	MMRESULT WINAPI acmStreamUnprepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
	753	DWORD fdwUnprepare)
	754	{
	755	PWINE_ACMSTREAM was;
	756	MMRESULT ret = MMSYSERR_NOERROR;
	757	PACMDRVSTREAMHEADER padsh;
758	758
759	759	TRACE("(0x%08x, %p, %ld)\n", has, pash, fdwUnprepare);
760
	760
761	761	if ((was = ACM_GetStream(has)) == NULL)
762		return MMSYSERR_INVALHANDLE;
	762	return MMSYSERR_INVALHANDLE;
763	763	if (!pash \|\| pash->cbStruct < sizeof(ACMSTREAMHEADER))
764		return MMSYSERR_INVALPARAM;
	764	return MMSYSERR_INVALPARAM;
765	765
766	766	if (!(pash->fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED))
767		return ACMERR_UNPREPARED;
	767	return ACMERR_UNPREPARED;
768	768
769	769	/* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
…	…
775	775	/* check that pointers have not been modified */
776	776	if (padsh->pbPreparedSrc != padsh->pbSrc \|\|
777		padsh->cbPreparedSrcLength < padsh->cbSrcLength \|\|
778		padsh->pbPreparedDst != padsh->pbDst \|\|
779		padsh->cbPreparedDstLength < padsh->cbDstLength) {
780		return MMSYSERR_INVALPARAM;
781		}
	777	padsh->cbPreparedSrcLength < padsh->cbSrcLength \|\|
	778	padsh->pbPreparedDst != padsh->pbDst \|\|
	779	padsh->cbPreparedDstLength < padsh->cbDstLength) {
	780	return MMSYSERR_INVALPARAM;
	781	}
782	782
783	783	padsh->fdwConvert = fdwUnprepare;
…	…
785	785	ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_UNPREPARE, (DWORD)&was->drvInst, (DWORD)padsh);
786	786	if (ret == MMSYSERR_NOERROR \|\| ret == MMSYSERR_NOTSUPPORTED) {
787		ret = MMSYSERR_NOERROR;
788