Changeset 6712

Timestamp:

Sep 15, 2001, 11:47:44 AM (24 years ago)

Author:

sandervl

Message:

restored old version

Location:

trunk/src

Files:

• NTDLL/initterm.cpp (modified) (3 diffs)
• NTDLL/rtlstr.c (modified) (34 diffs)
• NTDLL/unknown.cpp (modified) (2 diffs)
• NTDLL/wcstring.c (modified) (3 diffs)
• avifil32/api.c (modified) (2 diffs)
• avifil32/comentry.c (modified) (4 diffs)
• avifil32/guid.c (modified) (1 diff)
• avifil32/iafile.c (modified) (8 diffs)
• avifil32/iastream.c (modified) (5 diffs)
• avifil32/igframe.c (modified) (6 diffs)
• avifil32/main.c (modified) (2 diffs)
• avifil32/string.c (modified) (2 diffs)
• crtdll/crtdll.cpp (modified) (58 diffs)
• crtdll/crtdll_main.c (modified) (35 diffs)
• crtdll/dir.c (modified) (18 diffs)
• crtdll/exit.c (modified) (13 diffs)
• crtdll/file.c (modified) (51 diffs)
• crtdll/initterm.cpp (modified) (3 diffs)
• crtdll/memory.c (modified) (8 diffs)
• crtdll/spawn.c (modified) (5 diffs)
• msacm32/driver.c (modified) (14 diffs)
• msacm32/filter.c (modified) (18 diffs)
• msacm32/format.c (modified) (27 diffs)
• msacm32/initterm.cpp (modified) (3 diffs)
• msacm32/internal.c (modified) (7 diffs)
• msacm32/msacm32_main.c (modified) (7 diffs)
• msacm32/pcmconverter.c (modified) (31 diffs)
• msacm32/stream.c (modified) (17 diffs)
• msacm32/wineacm.h (modified) (1 diff)
• msvfw32/drawdib.c (modified) (10 diffs)
• msvfw32/msvideo_main.c (modified) (7 diffs)
• setupapi/devinst.c (modified) (2 diffs)
• setupapi/infparse.c (modified) (8 diffs)
• setupapi/setupx_main.c (modified) (51 diffs)
• setupapi/stubs.c (modified) (4 diffs)
• shdocvw/classinfo.c (modified) (3 diffs)
• shdocvw/events.c (modified) (3 diffs)
• shdocvw/factory.c (modified) (2 diffs)
• shdocvw/misc.c (modified) (2 diffs)
• shdocvw/oleobject.c (modified) (4 diffs)
• shdocvw/persist.c (modified) (3 diffs)
• shdocvw/shdocvw_main.c (modified) (3 diffs)
• shdocvw/webbrowser.c (modified) (2 diffs)
• shlwapi/ordinal.c (modified) (48 diffs)
• shlwapi/path.c (modified) (27 diffs)
• shlwapi/reg.c (modified) (17 diffs)
• shlwapi/regstream.c (modified) (6 diffs)
• shlwapi/shlwapiguid.c (modified) (1 diff)
• shlwapi/string.c (modified) (23 diffs)
• shlwapi/url.c (modified) (16 diffs)
• wininet/http.c (modified) (1 diff)
• wininet/wininet_main.c (modified) (2 diffs)
• winmm/driver.c (modified) (29 diffs)

trunk/src/NTDLL/initterm.cpp

@@ -1 @@
-/* $Id: initterm.cpp,v 1.13 2001-09-05 13:14:08 bird Exp $
- *
+/*
  * DLL entry point
  *
@@ -54 +53 @@
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
-    return NTDLL_LibMain(hinstDLL, fdwReason, fImpLoad);
+        return NTDLL_LibMain(hinstDLL, fdwReason, fImpLoad);
 
    case DLL_PROCESS_DETACH:
-    NTDLL_LibMain(hinstDLL, fdwReason, fImpLoad);
-    ctordtorTerm();
-    return TRUE;
+        NTDLL_LibMain(hinstDLL, fdwReason, fImpLoad);
+        ctordtorTerm();
+        return TRUE;
    }
    return FALSE;
@@ -89 +88 @@
          CheckVersionFromHMOD(PE2LX_VERSION, hModule); /*PLF Wed  98-03-18 05:28:48*/
 
-     dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab);
-         if(dllHandle == 0)
-        return 0UL;
+         dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab);
+         if(dllHandle == 0) 
+                return 0UL;
 
          break;
       case 1 :
          if(dllHandle) {
-        UnregisterLxDll(dllHandle);
+                UnregisterLxDll(dllHandle);
          }
          break;

trunk/src/NTDLL/rtlstr.c

@@ -1 @@
-/* $Id: rtlstr.c,v 1.4 2001-09-05 13:14:08 bird Exp $ */
 /*
  * Rtl string functions
@@ -24 +23 @@
 
 /**************************************************************************
- *  RtlInitAnsiString   (NTDLL.@)
+ *      RtlInitAnsiString   (NTDLL.@)
  */
 void WINAPI RtlInitAnsiString( PSTRING target, LPCSTR source)
@@ -38 +37 @@
 
 /**************************************************************************
- *  RtlInitString   (NTDLL.@)
+ *      RtlInitString   (NTDLL.@)
  */
 void WINAPI RtlInitString( PSTRING target, LPCSTR source )
@@ -47 +46 @@
 
 /**************************************************************************
- *  RtlFreeAnsiString   (NTDLL.@)
+ *      RtlFreeAnsiString   (NTDLL.@)
  */
 void WINAPI RtlFreeAnsiString( PSTRING str )
@@ -56 +55 @@
 
 /**************************************************************************
- *  RtlFreeOemString   (NTDLL.@)
+ *      RtlFreeOemString   (NTDLL.@)
  */
 void WINAPI RtlFreeOemString( PSTRING str )
@@ -65 +64 @@
 
 /**************************************************************************
- *  RtlCopyString   (NTDLL.@)
+ *      RtlCopyString   (NTDLL.@)
  */
 void WINAPI RtlCopyString( STRING *dst, const STRING *src )
@@ -80 +79 @@
 
 /**************************************************************************
- *  RtlInitUnicodeString   (NTDLL.@)
+ *      RtlInitUnicodeString   (NTDLL.@)
  */
 void WINAPI RtlInitUnicodeString( PUNICODE_STRING target, LPCWSTR source )
@@ -94 +93 @@
 
 /**************************************************************************
- *  RtlCreateUnicodeString   (NTDLL.@)
+ *      RtlCreateUnicodeString   (NTDLL.@)
  */
 BOOLEAN WINAPI RtlCreateUnicodeString( PUNICODE_STRING target, LPCWSTR src )
@@ -108 +107 @@
 
 /**************************************************************************
- *  RtlCreateUnicodeStringFromAsciiz   (NTDLL.@)
+ *      RtlCreateUnicodeStringFromAsciiz   (NTDLL.@)
  */
 BOOLEAN WINAPI RtlCreateUnicodeStringFromAsciiz( PUNICODE_STRING target, LPCSTR src )
@@ -119 +118 @@
 
 /**************************************************************************
- *  RtlFreeUnicodeString   (NTDLL.@)
+ *      RtlFreeUnicodeString   (NTDLL.@)
  */
 void WINAPI RtlFreeUnicodeString( PUNICODE_STRING str )
@@ -128 +127 @@
 
 /**************************************************************************
- *  RtlCopyUnicodeString   (NTDLL.@)
+ *      RtlCopyUnicodeString   (NTDLL.@)
  */
 void WINAPI RtlCopyUnicodeString( UNICODE_STRING *dst, const UNICODE_STRING *src )
@@ -145 +144 @@
 
 /**************************************************************************
- *  RtlEraseUnicodeString   (NTDLL.@)
+ *      RtlEraseUnicodeString   (NTDLL.@)
  */
 void WINAPI RtlEraseUnicodeString( UNICODE_STRING *str )
@@ -161 +160 @@
 
 /******************************************************************************
- *  RtlCompareString   (NTDLL.@)
+ *      RtlCompareString   (NTDLL.@)
  */
 LONG WINAPI RtlCompareString( const STRING *s1, const STRING *s2, BOOLEAN CaseInsensitive )
@@ -187 +186 @@
 
 /******************************************************************************
- *  RtlCompareUnicodeString   (NTDLL.@)
+ *      RtlCompareUnicodeString   (NTDLL.@)
  */
 LONG WINAPI RtlCompareUnicodeString( const UNICODE_STRING *s1, const UNICODE_STRING *s2,
@@ -214 +213 @@
 
 /**************************************************************************
- *  RtlEqualString   (NTDLL.@)
+ *      RtlEqualString   (NTDLL.@)
  */
 BOOLEAN WINAPI RtlEqualString( const STRING *s1, const STRING *s2, BOOLEAN CaseInsensitive )
@@ -224 +223 @@
 
 /**************************************************************************
- *  RtlEqualUnicodeString   (NTDLL.@)
+ *      RtlEqualUnicodeString   (NTDLL.@)
  */
 BOOLEAN WINAPI RtlEqualUnicodeString( const UNICODE_STRING *s1, const UNICODE_STRING *s2,
@@ -235 +234 @@
 
 /**************************************************************************
- *  RtlPrefixString   (NTDLL.@)
+ *      RtlPrefixString   (NTDLL.@)
  *
  * Test if s1 is a prefix in s2
@@ -259 +258 @@
 
 /**************************************************************************
- *  RtlPrefixUnicodeString   (NTDLL.@)
+ *      RtlPrefixUnicodeString   (NTDLL.@)
  *
  * Test if s1 is a prefix in s2
@@ -285 +284 @@
 
 /*
-    COPY BETWEEN ANSI_STRING or UNICODE_STRING
-    there is no parameter checking, it just crashes
+        COPY BETWEEN ANSI_STRING or UNICODE_STRING
+        there is no parameter checking, it just crashes
 */
 
 
 /**************************************************************************
- *  RtlAnsiStringToUnicodeString   (NTDLL.@)
+ *      RtlAnsiStringToUnicodeString   (NTDLL.@)
  *
  * NOTES:
@@ -319 +318 @@
 
 /**************************************************************************
- *  RtlOemStringToUnicodeString   (NTDLL.@)
+ *      RtlOemStringToUnicodeString   (NTDLL.@)
  *
  * NOTES
@@ -348 +347 @@
 
 /**************************************************************************
- *  RtlUnicodeStringToAnsiString   (NTDLL.@)
+ *      RtlUnicodeStringToAnsiString   (NTDLL.@)
  *
  * NOTES
@@ -382 +381 @@
 
 /**************************************************************************
- *  RtlUnicodeStringToOemString   (NTDLL.@)
+ *      RtlUnicodeStringToOemString   (NTDLL.@)
  *
  * NOTES
@@ -416 +415 @@
 
 /**************************************************************************
- *  RtlMultiByteToUnicodeN   (NTDLL.@)
+ *      RtlMultiByteToUnicodeN   (NTDLL.@)
  *
  * NOTES
@@ -432 +431 @@
 
 /**************************************************************************
- *  RtlOemToUnicodeN   (NTDLL.@)
+ *      RtlOemToUnicodeN   (NTDLL.@)
  */
 NTSTATUS WINAPI RtlOemToUnicodeN( LPWSTR dst, DWORD dstlen, LPDWORD reslen,
@@ -445 +444 @@
 
 /**************************************************************************
- *  RtlUnicodeToMultiByteN   (NTDLL.@)
+ *      RtlUnicodeToMultiByteN   (NTDLL.@)
  */
 NTSTATUS WINAPI RtlUnicodeToMultiByteN( LPSTR dst, DWORD dstlen, LPDWORD reslen,
@@ -459 +458 @@
 
 /**************************************************************************
- *  RtlUnicodeToOemN   (NTDLL.@)
+ *      RtlUnicodeToOemN   (NTDLL.@)
  */
 NTSTATUS WINAPI RtlUnicodeToOemN( LPSTR dst, DWORD dstlen, LPDWORD reslen,
@@ -477 +476 @@
 
 /**************************************************************************
- *  RtlUpperString   (NTDLL.@)
+ *      RtlUpperString   (NTDLL.@)
  */
 void WINAPI RtlUpperString( STRING *dst, const STRING *src )
@@ -489 +488 @@
 
 /**************************************************************************
- *  RtlUpcaseUnicodeString   (NTDLL.@)
+ *      RtlUpcaseUnicodeString   (NTDLL.@)
  *
  * NOTES:
@@ -516 +515 @@
 
 /**************************************************************************
- *  RtlUpcaseUnicodeStringToAnsiString   (NTDLL.@)
+ *      RtlUpcaseUnicodeStringToAnsiString   (NTDLL.@)
  *
  * NOTES
@@ -538 +537 @@
 
 /**************************************************************************
- *  RtlUpcaseUnicodeStringToOemString   (NTDLL.@)
+ *      RtlUpcaseUnicodeStringToOemString   (NTDLL.@)
  *
  * NOTES
@@ -560 +559 @@
 
 /**************************************************************************
- *  RtlUpcaseUnicodeToMultiByteN   (NTDLL.@)
+ *      RtlUpcaseUnicodeToMultiByteN   (NTDLL.@)
  */
 NTSTATUS WINAPI RtlUpcaseUnicodeToMultiByteN( LPSTR dst, DWORD dstlen, LPDWORD reslen,
@@ -578 +577 @@
 
 /**************************************************************************
- *  RtlUpcaseUnicodeToOemN   (NTDLL.@)
+ *      RtlUpcaseUnicodeToOemN   (NTDLL.@)
  */
 NTSTATUS WINAPI RtlUpcaseUnicodeToOemN( LPSTR dst, DWORD dstlen, LPDWORD reslen,
@@ -596 +595 @@
 
 /*
-    STRING SIZE
+        STRING SIZE
 */
 
@@ -742 +741 @@
 
 /*
-    MISC
+        MISC
 */
 
 /**************************************************************************
- *  RtlIsTextUnicode
- *
- *  Apply various feeble heuristics to guess whether
- *  the text buffer contains Unicode.
- *  FIXME: should implement more tests.
+ *      RtlIsTextUnicode
+ *
+ *      Apply various feeble heuristics to guess whether
+ *      the text buffer contains Unicode.
+ *      FIXME: should implement more tests.
  */
 DWORD WINAPI RtlIsTextUnicode(
-    LPVOID buf,
-    DWORD len,
-    DWORD *pf)
-{
-    LPWSTR s = buf;
-    DWORD flags = -1, out_flags = 0;
-
-    if (!len)
-        goto out;
-    if (pf)
-        flags = *pf;
-    /*
-     * Apply various tests to the text string. According to the
-     * docs, each test "passed" sets the corresponding flag in
-     * the output flags. But some of the tests are mutually
-     * exclusive, so I don't see how you could pass all tests ...
-     */
-
-    /* Check for an odd length ... pass if even. */
-    if (!(len & 1))
-        out_flags |= IS_TEXT_UNICODE_ODD_LENGTH;
-
-    /* Check for the special unicode marker byte. */
-    if (*s == 0xFEFF)
-        out_flags |= IS_TEXT_UNICODE_SIGNATURE;
-
-    /*
-     * Check whether the string passed all of the tests.
-     */
-    flags &= ITU_IMPLEMENTED_TESTS;
-    if ((out_flags & flags) != flags)
-        len = 0;
+        LPVOID buf,
+        DWORD len,
+        DWORD *pf)
+{
+        LPWSTR s = buf;
+        DWORD flags = -1, out_flags = 0;
+
+        if (!len)
+                goto out;
+        if (pf)
+                flags = *pf;
+        /*
+         * Apply various tests to the text string. According to the
+         * docs, each test "passed" sets the corresponding flag in
+         * the output flags. But some of the tests are mutually
+         * exclusive, so I don't see how you could pass all tests ...
+         */
+
+        /* Check for an odd length ... pass if even. */
+        if (!(len & 1))
+                out_flags |= IS_TEXT_UNICODE_ODD_LENGTH;
+
+        /* Check for the special unicode marker byte. */
+        if (*s == 0xFEFF)
+                out_flags |= IS_TEXT_UNICODE_SIGNATURE;
+
+        /*
+         * Check whether the string passed all of the tests.
+         */
+        flags &= ITU_IMPLEMENTED_TESTS;
+        if ((out_flags & flags) != flags)
+                len = 0;
 out:
-    if (pf)
-        *pf = out_flags;
-    return len;
-}
+        if (pf)
+                *pf = out_flags;
+        return len;
+}

trunk/src/NTDLL/unknown.cpp

@@ -1 @@
-/* $Id: unknown.cpp,v 1.9 2001-09-05 13:14:30 bird Exp $ */
+/* $Id: unknown.cpp,v 1.10 2001-09-15 09:36:50 sandervl Exp $ */
 
 /*
@@ -425 +425 @@
  * Opens a thread...
  * @returns Error code?
- * @param   phThreadHandle
+ * @param   pThreadHandle
  * @param   dwFlags
- * @param   pAttribs            Pointer to some attribute structure.
+ * @param   pvAttribs           Pointer to some attribute structure.
  * @param   padwOpenThreadParam Pointer to array of dword it seems. 2 entries?
  * @status  stub

trunk/src/NTDLL/wcstring.c

@@ -1 @@
-/* $Id: wcstring.c,v 1.2 2001-09-05 13:14:08 bird Exp $ */
 /*
  * NTDLL wide-char functions
@@ -287 +286 @@
 {
     LPSTR sA = HEAP_strdupWtoA(GetProcessHeap(),0,s),endA;
-    INT ret = strtol(sA,&endA,base);
+    INT ret = strtol(sA,&endA,base);
 
     HeapFree(GetProcessHeap(),0,sA);
@@ -326 +325 @@
 
     if (radix > 36 || radix <= 1)
-    return 0;
+        return 0;
 
     while (v || tp == tmp)
     {
-    i = v % radix;
-    v = v / radix;
-    if (i < 10)
-        *tp++ = i + '0';
-    else
-        *tp++ = i + 'a' - 10;
+        i = v % radix;
+        v = v / radix;
+        if (i < 10)
+            *tp++ = i + '0';
+        else
+            *tp++ = i + 'a' - 10;
     }
 
     sp = string;
     while (tp > tmp)
-    *sp++ = *--tp;
+        *sp++ = *--tp;
     *sp = 0;
     return string;

trunk/src/avifil32/api.c

@@ -1 @@
-/* $Id: api.c,v 1.2 2001-09-05 12:00:53 bird Exp $
- *
+/*
  * Copyright 1999 Marcus Meissner
  * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
@@ -23 +22 @@
 
 /***********************************************************************
- *      AVIFileInit (AVIFILE.100)
- *      AVIFileInit (AVIFIL32.@)
+ *              AVIFileInit (AVIFILE.100)
+ *              AVIFileInit (AVIFIL32.@)
  */
 void WINAPI AVIFileInit(void)
 {
-    TRACE("()\n");
-    if ( AVIFILE_data.dwAVIFileRef == 0 )
-    {
-        if ( FAILED(CoInitialize(NULL)) )
-            AVIFILE_data.fInitCOM = FALSE;
-        else
-            AVIFILE_data.fInitCOM = TRUE;
-    }
-    AVIFILE_data.dwAVIFileRef ++;
-}
-
-/***********************************************************************
- *      AVIFileExit (AVIFILE.101)
- *      AVIFileExit (AVIFIL32.@)
+        TRACE("()\n");
+        if ( AVIFILE_data.dwAVIFileRef == 0 )
+        {
+                if ( FAILED(CoInitialize(NULL)) )
+                        AVIFILE_data.fInitCOM = FALSE;
+                else
+                        AVIFILE_data.fInitCOM = TRUE;
+        }
+        AVIFILE_data.dwAVIFileRef ++;
+}
+
+/***********************************************************************
+ *              AVIFileExit (AVIFILE.101)
+ *              AVIFileExit (AVIFIL32.@)
  */
 void WINAPI AVIFileExit(void)
 {
-    TRACE("()\n");
-    if ( AVIFILE_data.dwAVIFileRef == 0 )
-    {
-        ERR( "unexpected AVIFileExit()\n" );
-        return;
-    }
-
-    AVIFILE_data.dwAVIFileRef --;
-    if ( AVIFILE_data.dwAVIFileRef == 0 )
-    {
-        if ( AVIFILE_data.fInitCOM )
-        {
-            CoUninitialize();
-            AVIFILE_data.fInitCOM = FALSE;
-        }
-    }
-}
-
-/***********************************************************************
- *      AVIFileAddRef (AVIFIL32.@)
+        TRACE("()\n");
+        if ( AVIFILE_data.dwAVIFileRef == 0 )
+        {
+                ERR( "unexpected AVIFileExit()\n" );
+                return;
+        }
+
+        AVIFILE_data.dwAVIFileRef --;
+        if ( AVIFILE_data.dwAVIFileRef == 0 )
+        {
+                if ( AVIFILE_data.fInitCOM )
+                {
+                        CoUninitialize();
+                        AVIFILE_data.fInitCOM = FALSE;
+                }
+        }
+}
+
+/***********************************************************************
+ *              AVIFileAddRef (AVIFIL32.@)
  */
 ULONG WINAPI AVIFileAddRef(PAVIFILE pfile)
 {
-    return IAVIFile_AddRef( pfile );
-}
-
-/***********************************************************************
- *      AVIFileRelease (AVIFILE.141)
- *      AVIFileRelease (AVIFIL32.@)
+        return IAVIFile_AddRef( pfile );
+}
+
+/***********************************************************************
+ *              AVIFileRelease (AVIFILE.141)
+ *              AVIFileRelease (AVIFIL32.@)
  */
 ULONG WINAPI AVIFileRelease(PAVIFILE pfile)
 {
-    return IAVIFile_Release( pfile );
-}
-
-/***********************************************************************
- *      AVIFileOpen  (AVIFILE.102)
- *      AVIFileOpenA (AVIFIL32.@)
+        return IAVIFile_Release( pfile );
+}
+
+/***********************************************************************
+ *              AVIFileOpen  (AVIFILE.102)
+ *              AVIFileOpenA (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileOpenA(
-    PAVIFILE* ppfile,LPCSTR szFile,UINT uMode,LPCLSID lpHandler )
-{
-    WCHAR*  pwsz;
-    HRESULT hr;
-
-    TRACE("(%p,%p,%u,%p)\n",ppfile,szFile,uMode,lpHandler);
-    pwsz = AVIFILE_strdupAtoW( szFile );
-    if ( pwsz == NULL )
-        return AVIERR_MEMORY;
-    hr = AVIFileOpenW(ppfile,pwsz,uMode,lpHandler);
-    HeapFree( AVIFILE_data.hHeap, 0, pwsz );
-    return hr;
-}
-
-/***********************************************************************
- *      AVIFileOpenW (AVIFIL32.@)
+        PAVIFILE* ppfile,LPCSTR szFile,UINT uMode,LPCLSID lpHandler )
+{
+        WCHAR*  pwsz;
+        HRESULT hr;
+
+        TRACE("(%p,%p,%u,%p)\n",ppfile,szFile,uMode,lpHandler);
+        pwsz = AVIFILE_strdupAtoW( szFile );
+        if ( pwsz == NULL )
+                return AVIERR_MEMORY;
+        hr = AVIFileOpenW(ppfile,pwsz,uMode,lpHandler);
+        HeapFree( AVIFILE_data.hHeap, 0, pwsz );
+        return hr;
+}
+
+/***********************************************************************
+ *              AVIFileOpenW (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileOpenW(
-    PAVIFILE* ppfile,LPCWSTR szFile,UINT uMode,LPCLSID lpHandler )
-{
-    HRESULT hr;
-    IClassFactory*  pcf;
-    CLSID   clsRIFF;
-
-    TRACE("(%p,%p,%u,%p)\n",ppfile,szFile,uMode,lpHandler);
-    *ppfile = (PAVIFILE)NULL;
-
-    if ( lpHandler == NULL )
-    {
-        /* FIXME - check RIFF type and get a handler from registry
-         *         if IAVIFile::Open is worked...
-         */
-        memcpy( &clsRIFF, &CLSID_AVIFile, sizeof(CLSID) );
-        lpHandler = &clsRIFF;
-    }
-
-    /*
-     * FIXME - MS says IAVIFile::Open will be called,
-     *         but no such method in vfw.h... why????
-     */
-    if ( !IsEqualGUID( lpHandler, &CLSID_AVIFile ) )
-        return REGDB_E_CLASSNOTREG;
-
-    hr = AVIFILE_DllGetClassObject(&CLSID_AVIFile,
-                       &IID_IClassFactory,(void**)&pcf);
-    if ( hr != S_OK )
-        return hr;
-
-    hr = IClassFactory_CreateInstance( pcf, NULL, &IID_IAVIFile,
-                       (void**)ppfile );
-    IClassFactory_Release( pcf );
-
-    if ( hr == S_OK )
-    {
-        /* FIXME??? */
-        hr = AVIFILE_IAVIFile_Open( *ppfile, szFile, uMode );
-        if ( hr != S_OK )
-        {
-            IAVIFile_Release( (*ppfile) );
-            *ppfile = NULL;
-        }
-    }
-
-    return hr;
-}
-
-/***********************************************************************
- *      AVIFileInfoW (AVIFIL32.@)
+        PAVIFILE* ppfile,LPCWSTR szFile,UINT uMode,LPCLSID lpHandler )
+{
+        HRESULT hr;
+        IClassFactory*  pcf;
+        CLSID   clsRIFF;
+
+        TRACE("(%p,%p,%u,%p)\n",ppfile,szFile,uMode,lpHandler);
+        *ppfile = (PAVIFILE)NULL;
+
+        if ( lpHandler == NULL )
+        {
+                /* FIXME - check RIFF type and get a handler from registry
+                 *         if IAVIFile::Open is worked...
+                 */
+                memcpy( &clsRIFF, &CLSID_AVIFile, sizeof(CLSID) );
+                lpHandler = &clsRIFF;
+        }
+
+        /*
+         * FIXME - MS says IAVIFile::Open will be called,
+         *         but no such method in vfw.h... why????
+         */
+        if ( !IsEqualGUID( lpHandler, &CLSID_AVIFile ) )
+                return REGDB_E_CLASSNOTREG;
+
+        hr = AVIFILE_DllGetClassObject(&CLSID_AVIFile,
+                                       &IID_IClassFactory,(void**)&pcf);
+        if ( hr != S_OK )
+                return hr;
+
+        hr = IClassFactory_CreateInstance( pcf, NULL, &IID_IAVIFile,
+                                           (void**)ppfile );
+        IClassFactory_Release( pcf );
+
+        if ( hr == S_OK )
+        {
+                /* FIXME??? */
+                hr = AVIFILE_IAVIFile_Open( *ppfile, szFile, uMode );
+                if ( hr != S_OK )
+                {
+                        IAVIFile_Release( (*ppfile) );
+                        *ppfile = NULL;
+                }
+        }
+
+        return hr;
+}
+
+/***********************************************************************
+ *              AVIFileInfoW (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileInfoW(PAVIFILE pfile,AVIFILEINFOW* pfi,LONG lSize)
 {
-    return IAVIFile_Info( pfile, pfi, lSize );
-}
-
-/***********************************************************************
- *      AVIFileInfo  (AVIFIL32.@)
- *      AVIFileInfoA (AVIFIL32.@)
+        return IAVIFile_Info( pfile, pfi, lSize );
+}
+
+/***********************************************************************
+ *              AVIFileInfo  (AVIFIL32.@)
+ *              AVIFileInfoA (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileInfoA(PAVIFILE pfile,AVIFILEINFOA* pfi,LONG lSize)
 {
-    AVIFILEINFOW    fiw;
-    HRESULT     hr;
-
-    if ( lSize < sizeof(AVIFILEINFOA) )
-        return AVIERR_BADSIZE;
-    hr = AVIFileInfoW( pfile, &fiw, sizeof(AVIFILEINFOW) );
-    if ( hr != S_OK )
-        return hr;
-    memcpy( pfi,&fiw,sizeof(AVIFILEINFOA) );
-    AVIFILE_strncpyWtoA( pfi->szFileType, fiw.szFileType,
-                 sizeof(pfi->szFileType) );
-    pfi->szFileType[sizeof(pfi->szFileType)-1] = 0;
-
-    return S_OK;
-}
-
-/***********************************************************************
- *      AVIFileGetStream (AVIFILE.143)
- *      AVIFileGetStream (AVIFIL32.@)
+        AVIFILEINFOW    fiw;
+        HRESULT         hr;
+
+        if ( lSize < sizeof(AVIFILEINFOA) )
+                return AVIERR_BADSIZE;
+        hr = AVIFileInfoW( pfile, &fiw, sizeof(AVIFILEINFOW) );
+        if ( hr != S_OK )
+                return hr;
+        memcpy( pfi,&fiw,sizeof(AVIFILEINFOA) );
+        AVIFILE_strncpyWtoA( pfi->szFileType, fiw.szFileType,
+                             sizeof(pfi->szFileType) );
+        pfi->szFileType[sizeof(pfi->szFileType)-1] = 0;
+
+        return S_OK;
+}
+
+/***********************************************************************
+ *              AVIFileGetStream (AVIFILE.143)
+ *              AVIFileGetStream (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileGetStream(PAVIFILE pfile,PAVISTREAM* pas,DWORD fccType,LONG lParam)
 {
-    return IAVIFile_GetStream(pfile,pas,fccType,lParam);
-}
-
-/***********************************************************************
- *      AVIFileCreateStreamW (AVIFIL32.@)
+        return IAVIFile_GetStream(pfile,pas,fccType,lParam);
+}
+
+/***********************************************************************
+ *              AVIFileCreateStreamW (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileCreateStreamW(PAVIFILE pfile,PAVISTREAM* ppas,AVISTREAMINFOW* pasi)
 {
-    return IAVIFile_CreateStream(pfile,ppas,pasi);
-}
-
-/***********************************************************************
- *      AVIFileCreateStreamA (AVIFIL32.@)
+        return IAVIFile_CreateStream(pfile,ppas,pasi);
+}
+
+/***********************************************************************
+ *              AVIFileCreateStreamA (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileCreateStreamA(PAVIFILE pfile,PAVISTREAM* ppas,AVISTREAMINFOA* pasi)
 {
-    AVISTREAMINFOW  siw;
-    HRESULT     hr;
-
-    memcpy( &siw,pasi,sizeof(AVISTREAMINFOA) );
-    AVIFILE_strncpyAtoW( siw.szName, pasi->szName,
-        sizeof(siw.szName)/sizeof(siw.szName[0]) );
-    siw.szName[sizeof(siw.szName)/sizeof(siw.szName[0])-1] = 0;
-
-    hr = AVIFileCreateStreamW(pfile,ppas,&siw);
-
-    return hr;
-}
-
-/***********************************************************************
- *      AVIFileWriteData (AVIFIL32.@)
+        AVISTREAMINFOW  siw;
+        HRESULT         hr;
+
+        memcpy( &siw,pasi,sizeof(AVISTREAMINFOA) );
+        AVIFILE_strncpyAtoW( siw.szName, pasi->szName,
+                sizeof(siw.szName)/sizeof(siw.szName[0]) );
+        siw.szName[sizeof(siw.szName)/sizeof(siw.szName[0])-1] = 0;
+
+        hr = AVIFileCreateStreamW(pfile,ppas,&siw);
+
+        return hr;
+}
+
+/***********************************************************************
+ *              AVIFileWriteData (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileWriteData(
-    PAVIFILE pfile,DWORD dwChunkId,LPVOID lpvData,LONG cbData )
-{
-    return IAVIFile_WriteData( pfile,dwChunkId,lpvData,cbData );
-}
-
-/***********************************************************************
- *      AVIFileReadData (AVIFIL32.@)
+        PAVIFILE pfile,DWORD dwChunkId,LPVOID lpvData,LONG cbData )
+{
+        return IAVIFile_WriteData( pfile,dwChunkId,lpvData,cbData );
+}
+
+/***********************************************************************
+ *              AVIFileReadData (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileReadData(
-    PAVIFILE pfile,DWORD dwChunkId,LPVOID lpvData,LPLONG pcbData )
-{
-    return IAVIFile_ReadData( pfile,dwChunkId,lpvData,pcbData );
-}
-
-/***********************************************************************
- *      AVIFileEndRecord (AVIFIL32.@)
+        PAVIFILE pfile,DWORD dwChunkId,LPVOID lpvData,LPLONG pcbData )
+{
+        return IAVIFile_ReadData( pfile,dwChunkId,lpvData,pcbData );
+}
+
+/***********************************************************************
+ *              AVIFileEndRecord (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFileEndRecord( PAVIFILE pfile )
 {
-    return IAVIFile_EndRecord( pfile );
-}
-
-/***********************************************************************
- *      AVIStreamAddRef (AVIFIL32.@)
+        return IAVIFile_EndRecord( pfile );
+}
+
+/***********************************************************************
+ *              AVIStreamAddRef (AVIFIL32.@)
  */
 ULONG WINAPI AVIStreamAddRef(PAVISTREAM pas)
 {
-    return IAVIStream_Release(pas);
-}
-
-/***********************************************************************
- *      AVIStreamRelease (AVIFIL32.@)
+        return IAVIStream_Release(pas);
+}
+
+/***********************************************************************
+ *              AVIStreamRelease (AVIFIL32.@)
  */
 ULONG WINAPI AVIStreamRelease(PAVISTREAM pas)
 {
-    return IAVIStream_Release(pas);
-}
-
-/***********************************************************************
- *      AVIStreamInfoW (AVIFIL32.@)
+        return IAVIStream_Release(pas);
+}
+
+/***********************************************************************
+ *              AVIStreamInfoW (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamInfoW(PAVISTREAM pas,AVISTREAMINFOW* psi,LONG lSize)
 {
-    return IAVIStream_Info(pas,psi,lSize);
-}
-
-/***********************************************************************
- *      AVIStreamInfo  (AVIFIL32.@)
- *      AVIStreamInfoA (AVIFIL32.@)
+        return IAVIStream_Info(pas,psi,lSize);
+}
+
+/***********************************************************************
+ *              AVIStreamInfo  (AVIFIL32.@)
+ *              AVIStreamInfoA (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamInfoA(PAVISTREAM pas,AVISTREAMINFOA* psi,LONG lSize)
 {
-    AVISTREAMINFOW  siw;
-    HRESULT     hr;
-
-    if (lSize < sizeof(AVISTREAMINFOA))
-        return AVIERR_BADSIZE;
-    hr = AVIStreamInfoW(pas,&siw,sizeof(AVISTREAMINFOW));
-    if ( hr != S_OK )
-        return hr;
-    memcpy( psi,&siw,sizeof(AVIFILEINFOA) );
-    AVIFILE_strncpyWtoA( psi->szName, siw.szName, sizeof(psi->szName) );
-    psi->szName[sizeof(psi->szName)-1] = 0;
-
-    return hr;
-}
-
-/***********************************************************************
- *      AVIStreamFindSample (AVIFIL32.@)
+        AVISTREAMINFOW  siw;
+        HRESULT         hr;
+
+        if (lSize < sizeof(AVISTREAMINFOA))
+                return AVIERR_BADSIZE;
+        hr = AVIStreamInfoW(pas,&siw,sizeof(AVISTREAMINFOW));
+        if ( hr != S_OK )
+                return hr;
+        memcpy( psi,&siw,sizeof(AVIFILEINFOA) );
+        AVIFILE_strncpyWtoA( psi->szName, siw.szName, sizeof(psi->szName) );
+        psi->szName[sizeof(psi->szName)-1] = 0;
+
+        return hr;
+}
+
+/***********************************************************************
+ *              AVIStreamFindSample (AVIFIL32.@)
  */
 LONG WINAPI AVIStreamFindSample(PAVISTREAM pas,LONG lPos,LONG lFlags)
 {
-    return IAVIStream_FindSample(pas,lPos,lFlags);
-}
-
-/***********************************************************************
- *      AVIStreamReadFormat (AVIFIL32.@)
+        return IAVIStream_FindSample(pas,lPos,lFlags);
+}
+
+/***********************************************************************
+ *              AVIStreamReadFormat (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamReadFormat(PAVISTREAM pas,LONG pos,LPVOID format,LONG *formatsize) {
-    return IAVIStream_ReadFormat(pas,pos,format,formatsize);
-}
-
-/***********************************************************************
- *      AVIStreamSetFormat (AVIFIL32.@)
+        return IAVIStream_ReadFormat(pas,pos,format,formatsize);
+}
+
+/***********************************************************************
+ *              AVIStreamSetFormat (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamSetFormat(PAVISTREAM pas,LONG pos,LPVOID format,LONG formatsize) {
-    return IAVIStream_SetFormat(pas,pos,format,formatsize);
-}
-
-/***********************************************************************
- *      AVIStreamReadData (AVIFIL32.@)
+        return IAVIStream_SetFormat(pas,pos,format,formatsize);
+}
+
+/***********************************************************************
+ *              AVIStreamReadData (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamReadData(PAVISTREAM pas,DWORD fcc,LPVOID lp,LONG *lpread) {
-    return IAVIStream_ReadData(pas,fcc,lp,lpread);
-}
-
-/***********************************************************************
- *      AVIStreamWriteData (AVIFIL32.@)
+        return IAVIStream_ReadData(pas,fcc,lp,lpread);
+}
+
+/***********************************************************************
+ *              AVIStreamWriteData (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamWriteData(PAVISTREAM pas,DWORD fcc,LPVOID lp,LONG size) {
-    return IAVIStream_WriteData(pas,fcc,lp,size);
-}
-
-/***********************************************************************
- *      AVIStreamRead (AVIFIL32.@)
+        return IAVIStream_WriteData(pas,fcc,lp,size);
+}
+
+/***********************************************************************
+ *              AVIStreamRead (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamRead(PAVISTREAM pas,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread)
 {
-    return IAVIStream_Read(pas,start,samples,buffer,buffersize,bytesread,samplesread);
-}
-
-/***********************************************************************
- *      AVIStreamWrite (AVIFIL32.@)
+        return IAVIStream_Read(pas,start,samples,buffer,buffersize,bytesread,samplesread);
+}
+
+/***********************************************************************
+ *              AVIStreamWrite (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamWrite(PAVISTREAM pas,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten) {
-    return IAVIStream_Write(pas,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
-}
-
-
-/***********************************************************************
- *      AVIStreamStart (AVIFIL32.@)
+        return IAVIStream_Write(pas,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
+}
+
+
+/***********************************************************************
+ *              AVIStreamStart (AVIFIL32.@)
  */
 LONG WINAPI AVIStreamStart(PAVISTREAM pas)
 {
-    AVISTREAMINFOW  si;
-    HRESULT         hr;
-
-    hr = IAVIStream_Info(pas,&si,sizeof(si));
-    if (hr != S_OK)
-        return -1;
-    return (LONG)si.dwStart;
-}
-
-/***********************************************************************
- *      AVIStreamLength (AVIFIL32.@)
+        AVISTREAMINFOW  si;
+        HRESULT                 hr;
+
+        hr = IAVIStream_Info(pas,&si,sizeof(si));
+        if (hr != S_OK)
+                return -1;
+        return (LONG)si.dwStart;
+}
+
+/***********************************************************************
+ *              AVIStreamLength (AVIFIL32.@)
  */
 LONG WINAPI AVIStreamLength(PAVISTREAM pas)
 {
-    AVISTREAMINFOW  si;
-    HRESULT         hr;
-
-    hr = IAVIStream_Info(pas,&si,sizeof(si));
-    if (hr != S_OK)
-        return -1;
-    return (LONG)si.dwLength;
-}
-
-/***********************************************************************
- *      AVIStreamTimeToSample (AVIFIL32.@)
+        AVISTREAMINFOW  si;
+        HRESULT                 hr;
+
+        hr = IAVIStream_Info(pas,&si,sizeof(si));
+        if (hr != S_OK)
+                return -1;
+        return (LONG)si.dwLength;
+}
+
+/***********************************************************************
+ *              AVIStreamTimeToSample (AVIFIL32.@)
  */
 LONG WINAPI AVIStreamTimeToSample(PAVISTREAM pas,LONG lTime)
 {
-    AVISTREAMINFOW  si;
-    HRESULT         hr;
-
-    hr = IAVIStream_Info(pas,&si,sizeof(si));
-    if (hr != S_OK)
-        return -1;
-
-    /* I am too lazy... */
-    FIXME("(%p,%ld)",pas,lTime);
-    return (LONG)-1L;
-}
-
-/***********************************************************************
- *      AVIStreamSampleToTime (AVIFIL32.@)
+        AVISTREAMINFOW  si;
+        HRESULT                 hr;
+
+        hr = IAVIStream_Info(pas,&si,sizeof(si));
+        if (hr != S_OK)
+                return -1;
+
+        /* I am too lazy... */
+        FIXME("(%p,%ld)",pas,lTime);
+        return (LONG)-1L;
+}
+
+/***********************************************************************
+ *              AVIStreamSampleToTime (AVIFIL32.@)
  */
 LONG WINAPI AVIStreamSampleToTime(PAVISTREAM pas,LONG lSample)
 {
-    AVISTREAMINFOW  si;
-    HRESULT         hr;
-
-    hr = IAVIStream_Info(pas,&si,sizeof(si));
-    if (hr != S_OK)
-        return -1;
-
-    /* I am too lazy... */
-    FIXME("(%p,%ld)",pas,lSample);
-    return (LONG)-1L;
-}
-
-/***********************************************************************
- *      AVIStreamBeginStreaming (AVIFIL32.@)
+        AVISTREAMINFOW  si;
+        HRESULT                 hr;
+
+        hr = IAVIStream_Info(pas,&si,sizeof(si));
+        if (hr != S_OK)
+                return -1;
+
+        /* I am too lazy... */
+        FIXME("(%p,%ld)",pas,lSample);
+        return (LONG)-1L;
+}
+
+/***********************************************************************
+ *              AVIStreamBeginStreaming (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamBeginStreaming(PAVISTREAM pas,LONG lStart,LONG lEnd,LONG lRate)
 {
-    FIXME("(%p)->(%ld,%ld,%ld),stub!\n",pas,lStart,lEnd,lRate);
-    return E_FAIL;
-}
-
-/***********************************************************************
- *      AVIStreamEndStreaming (AVIFIL32.@)
+        FIXME("(%p)->(%ld,%ld,%ld),stub!\n",pas,lStart,lEnd,lRate);
+        return E_FAIL;
+}
+
+/***********************************************************************
+ *              AVIStreamEndStreaming (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamEndStreaming(PAVISTREAM pas)
 {
-    FIXME("(%p)->(),stub!\n",pas);
-    return E_FAIL;
-}
-
-/***********************************************************************
- *      AVIStreamGetFrameOpen (AVIFIL32.@)
+        FIXME("(%p)->(),stub!\n",pas);
+        return E_FAIL;
+}
+
+/***********************************************************************
+ *              AVIStreamGetFrameOpen (AVIFIL32.@)
  */
 PGETFRAME WINAPI AVIStreamGetFrameOpen(PAVISTREAM pas,LPBITMAPINFOHEADER pbi)
 {
-    IGetFrame*  pgf;
-    HRESULT     hr;
-    AVISTREAMINFOW  si;
-
-    FIXME("(%p,%p)\n",pas,pbi);
-
-    hr = IAVIStream_Info(pas,&si,sizeof(si));
-    if (hr != S_OK)
-        return NULL;
-
-    hr = AVIFILE_CreateIGetFrame((void**)&pgf,pas,pbi);
-    if ( hr != S_OK )
-        return NULL;
-    hr = IGetFrame_Begin( pgf, si.dwStart, si.dwLength, 1000 );
-    if ( hr != S_OK )
-    {
-        IGetFrame_Release( pgf );
-        return NULL;
-    }
-
-    return pgf;
-}
-
-/***********************************************************************
- *      AVIStreamGetFrame (AVIFIL32.@)
+        IGetFrame*      pgf;
+        HRESULT         hr;
+        AVISTREAMINFOW  si;
+
+        FIXME("(%p,%p)\n",pas,pbi);
+
+        hr = IAVIStream_Info(pas,&si,sizeof(si));
+        if (hr != S_OK)
+                return NULL;
+
+        hr = AVIFILE_CreateIGetFrame((void**)&pgf,pas,pbi);
+        if ( hr != S_OK )
+                return NULL;
+        hr = IGetFrame_Begin( pgf, si.dwStart, si.dwLength, 1000 );
+        if ( hr != S_OK )
+        {
+                IGetFrame_Release( pgf );
+                return NULL;
+        }
+
+        return pgf;
+}
+
+/***********************************************************************
+ *              AVIStreamGetFrame (AVIFIL32.@)
  */
 LPVOID WINAPI AVIStreamGetFrame(PGETFRAME pgf, LONG lPos)
 {
-    return IGetFrame_GetFrame(pgf,lPos);
-}
-
-/***********************************************************************
- *      AVIStreamGetFrameClose (AVIFIL32.@)
+        return IGetFrame_GetFrame(pgf,lPos);
+}
+
+/***********************************************************************
+ *              AVIStreamGetFrameClose (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamGetFrameClose(PGETFRAME pgf)
 {
-    return IGetFrame_End(pgf);
-}
-
-/***********************************************************************
- *      AVIStreamOpenFromFileA (AVIFIL32.@)
+        return IGetFrame_End(pgf);
+}
+
+/***********************************************************************
+ *              AVIStreamOpenFromFileA (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamOpenFromFileA(PAVISTREAM* ppas, LPCSTR szFile, DWORD fccType, LONG lParam, UINT uMode, CLSID* lpHandler)
 {
-    WCHAR*  pwsz;
-    HRESULT hr;
-
-    pwsz = AVIFILE_strdupAtoW( szFile );
-    if ( pwsz == NULL )
-        return AVIERR_MEMORY;
-    hr = AVIStreamOpenFromFileW(ppas,pwsz,fccType,lParam,uMode,lpHandler);
-    HeapFree( AVIFILE_data.hHeap, 0, pwsz );
-    return hr;
-}
-
-/***********************************************************************
- *      AVIStreamOpenFromFileW (AVIFIL32.@)
+        WCHAR*  pwsz;
+        HRESULT hr;
+
+        pwsz = AVIFILE_strdupAtoW( szFile );
+        if ( pwsz == NULL )
+                return AVIERR_MEMORY;
+        hr = AVIStreamOpenFromFileW(ppas,pwsz,fccType,lParam,uMode,lpHandler);
+        HeapFree( AVIFILE_data.hHeap, 0, pwsz );
+        return hr;
+}
+
+/***********************************************************************
+ *              AVIStreamOpenFromFileW (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamOpenFromFileW(PAVISTREAM* ppas, LPCWSTR szFile, DWORD fccType, LONG lParam, UINT uMode, CLSID* lpHandler)
 {
-    HRESULT hr;
-    PAVIFILE    paf;
-    AVIFILEINFOW    fi;
-
-    *ppas = NULL;
-    hr = AVIFileOpenW(&paf,szFile,uMode,lpHandler);
-    if ( hr != S_OK )
-        return hr;
-    hr = AVIFileInfoW(paf,&fi,sizeof(AVIFILEINFOW));
-    if ( hr == S_OK )
-        hr = AVIFileGetStream(paf,ppas,fccType,lParam);
-
-    IAVIFile_Release(paf);
-
-    return hr;
-}
-
-/***********************************************************************
- *      AVIStreamCreate (AVIFIL32.@)
+        HRESULT hr;
+        PAVIFILE        paf;
+        AVIFILEINFOW    fi;
+
+        *ppas = NULL;
+        hr = AVIFileOpenW(&paf,szFile,uMode,lpHandler);
+        if ( hr != S_OK )
+                return hr;
+        hr = AVIFileInfoW(paf,&fi,sizeof(AVIFILEINFOW));
+        if ( hr == S_OK )
+                hr = AVIFileGetStream(paf,ppas,fccType,lParam);
+
+        IAVIFile_Release(paf);
+
+        return hr;
+}
+
+/***********************************************************************
+ *              AVIStreamCreate (AVIFIL32.@)
  */
 HRESULT WINAPI AVIStreamCreate(PAVISTREAM* ppas, LONG lParam1, LONG lParam2, CLSID* lpHandler)
 {
-    HRESULT hr;
-    IClassFactory*  pcf;
-
-    *ppas = NULL;
-
-    if ( lpHandler == NULL )
-    {
-        hr = AVIFILE_DllGetClassObject(&CLSID_AVIFile,
-                           &IID_IClassFactory,(void**)&pcf);
-    }
-    else
-    {
-        if ( !AVIFILE_data.fInitCOM )
-            return E_UNEXPECTED;
-        hr = CoGetClassObject(lpHandler,CLSCTX_INPROC_SERVER,
-                      NULL,&IID_IClassFactory,(void**)&pcf);
-    }
-    if ( hr != S_OK )
-        return hr;
-
-    hr = IClassFactory_CreateInstance( pcf, NULL, &IID_IAVIStream,
-                       (void**)ppas );
-    IClassFactory_Release( pcf );
-
-    if ( hr == S_OK )
-    {
-        hr = IAVIStream_Create((*ppas),lParam1,lParam2);
-        if ( hr != S_OK )
-        {
-            IAVIStream_Release((*ppas));
-            *ppas = NULL;
-        }
-    }
-
-    return hr;
-}
-
-/***********************************************************************
- *      AVIMakeCompressedStream (AVIFIL32.@)
+        HRESULT hr;
+        IClassFactory*  pcf;
+
+        *ppas = NULL;
+
+        if ( lpHandler == NULL )
+        {
+                hr = AVIFILE_DllGetClassObject(&CLSID_AVIFile,
+                                               &IID_IClassFactory,(void**)&pcf);
+        }
+        else
+        {
+                if ( !AVIFILE_data.fInitCOM )
+                        return E_UNEXPECTED;
+                hr = CoGetClassObject(lpHandler,CLSCTX_INPROC_SERVER,
+                                      NULL,&IID_IClassFactory,(void**)&pcf);
+        }
+        if ( hr != S_OK )
+                return hr;
+
+        hr = IClassFactory_CreateInstance( pcf, NULL, &IID_IAVIStream,
+                                           (void**)ppas );
+        IClassFactory_Release( pcf );
+
+        if ( hr == S_OK )
+        {
+                hr = IAVIStream_Create((*ppas),lParam1,lParam2);
+                if ( hr != S_OK )
+                {
+                        IAVIStream_Release((*ppas));
+                        *ppas = NULL;
+                }
+        }
+
+        return hr;
+}
+
+/***********************************************************************
+ *              AVIMakeCompressedStream (AVIFIL32.@)
  */
 HRESULT WINAPI AVIMakeCompressedStream(PAVISTREAM *ppsCompressed,PAVISTREAM ppsSource,AVICOMPRESSOPTIONS *aco,CLSID *pclsidHandler)
 {
-    FIXME("(%p,%p,%p,%p)\n",ppsCompressed,ppsSource,aco,pclsidHandler);
-    return E_FAIL;
-}
-
+        FIXME("(%p,%p,%p,%p)\n",ppsCompressed,ppsSource,aco,pclsidHandler);
+        return E_FAIL;
+}
+

trunk/src/avifil32/comentry.c

@@ -1 @@
-/* $Id: comentry.c,v 1.2 2001-09-05 12:00:53 bird Exp $
- *
+/*
  * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
  */
@@ -28 +27 @@
 static ICOM_VTABLE(IClassFactory) iclassfact =
 {
-    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
-    IClassFactory_fnQueryInterface,
-    IClassFactory_fnAddRef,
-    IClassFactory_fnRelease,
-    IClassFactory_fnCreateInstance,
-    IClassFactory_fnLockServer
+        ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+        IClassFactory_fnQueryInterface,
+        IClassFactory_fnAddRef,
+        IClassFactory_fnRelease,
+        IClassFactory_fnCreateInstance,
+        IClassFactory_fnLockServer
 };
 
 typedef struct
 {
-    /* IUnknown fields */
-    ICOM_VFIELD(IClassFactory);
-    DWORD   ref;
+        /* IUnknown fields */
+        ICOM_VFIELD(IClassFactory);
+        DWORD   ref;
 } IClassFactoryImpl;
 
@@ -50 +49 @@
 IClassFactory_fnQueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj)
 {
-    ICOM_THIS(IClassFactoryImpl,iface);
+        ICOM_THIS(IClassFactoryImpl,iface);
 
-    TRACE("(%p)->(%p,%p)\n",This,riid,ppobj);
-    if ( ( IsEqualGUID( &IID_IUnknown, riid ) ) ||
-         ( IsEqualGUID( &IID_IClassFactory, riid ) ) )
-    {
-        *ppobj = iface;
-        IClassFactory_AddRef(iface);
-        return S_OK;
-    }
+        TRACE("(%p)->(%p,%p)\n",This,riid,ppobj);
+        if ( ( IsEqualGUID( &IID_IUnknown, riid ) ) ||
+             ( IsEqualGUID( &IID_IClassFactory, riid ) ) )
+        {
+                *ppobj = iface;
+                IClassFactory_AddRef(iface);
+                return S_OK;
+        }
 
-    return E_NOINTERFACE;
+        return E_NOINTERFACE;
 }
 
 static ULONG WINAPI IClassFactory_fnAddRef(LPCLASSFACTORY iface)
 {
-    ICOM_THIS(IClassFactoryImpl,iface);
+        ICOM_THIS(IClassFactoryImpl,iface);
 
-    TRACE("(%p)->()\n",This);
-    if ( (This->ref) == 0 )
-        AVIFILE_data.dwClassObjRef ++;
+        TRACE("(%p)->()\n",This);
+        if ( (This->ref) == 0 )
+                AVIFILE_data.dwClassObjRef ++;
 
-    return ++(This->ref);
+        return ++(This->ref);
 }
 
 static ULONG WINAPI IClassFactory_fnRelease(LPCLASSFACTORY iface)
 {
-    ICOM_THIS(IClassFactoryImpl,iface);
+        ICOM_THIS(IClassFactoryImpl,iface);
 
-    TRACE("(%p)->()\n",This);
-    if ( (--(This->ref)) > 0 )
-        return This->ref;
+        TRACE("(%p)->()\n",This);
+        if ( (--(This->ref)) > 0 )
+                return This->ref;
 
-    AVIFILE_data.dwClassObjRef --;
-    return 0;
+        AVIFILE_data.dwClassObjRef --;
+        return 0;
 }
 
@@ -91 +90 @@
     /*ICOM_THIS(IClassFactoryImpl,iface);*/
 
-    *ppobj = NULL;
-    if ( pOuter != NULL )
-        return E_FAIL;
+        *ppobj = NULL;
+        if ( pOuter != NULL )
+                return E_FAIL;
 
-    if ( IsEqualGUID( &IID_IAVIFile, riid ) )
-        return AVIFILE_CreateIAVIFile(ppobj);
-    if ( IsEqualGUID( &IID_IAVIStream, riid ) )
-        return AVIFILE_CreateIAVIStream(ppobj);
+        if ( IsEqualGUID( &IID_IAVIFile, riid ) )
+                return AVIFILE_CreateIAVIFile(ppobj);
+        if ( IsEqualGUID( &IID_IAVIStream, riid ) )
+                return AVIFILE_CreateIAVIStream(ppobj);
 
-    return E_NOINTERFACE;
+        return E_NOINTERFACE;
 }
 
 static HRESULT WINAPI IClassFactory_fnLockServer(LPCLASSFACTORY iface,BOOL dolock)
 {
-    ICOM_THIS(IClassFactoryImpl,iface);
-    HRESULT hr;
+        ICOM_THIS(IClassFactoryImpl,iface);
+        HRESULT hr;
 
-    FIXME("(%p)->(%d),stub!\n",This,dolock);
-    if (dolock)
-        hr = IClassFactory_AddRef(iface);
-    else
-        hr = IClassFactory_Release(iface);
+        FIXME("(%p)->(%d),stub!\n",This,dolock);
+        if (dolock)
+                hr = IClassFactory_AddRef(iface);
+        else
+                hr = IClassFactory_Release(iface);
 
-    return hr;
+        return hr;
 }
 
 
 /***********************************************************************
- *      DllGetClassObject (AVIFIL32.@)
+ *              DllGetClassObject (AVIFIL32.@)
  */
 HRESULT WINAPI AVIFILE_DllGetClassObject(const CLSID* pclsid,const IID* piid,void** ppv)
 {
-    *ppv = NULL;
-    if ( IsEqualCLSID( &IID_IClassFactory, piid ) )
-    {
-        *ppv = (LPVOID)&AVIFILE_GlobalCF;
-        IClassFactory_AddRef((IClassFactory*)*ppv);
-        return S_OK;
-    }
+        *ppv = NULL;
+        if ( IsEqualCLSID( &IID_IClassFactory, piid ) )
+        {
+                *ppv = (LPVOID)&AVIFILE_GlobalCF;
+                IClassFactory_AddRef((IClassFactory*)*ppv);
+                return S_OK;
+        }
 
-    return CLASS_E_CLASSNOTAVAILABLE;
+        return CLASS_E_CLASSNOTAVAILABLE;
 }
 
 /*****************************************************************************
- *      DllCanUnloadNow (AVIFIL32.@)
+ *              DllCanUnloadNow (AVIFIL32.@)
  */
 DWORD WINAPI AVIFILE_DllCanUnloadNow(void)
 {
-    return ( AVIFILE_data.dwClassObjRef == 0 ) ? S_OK : S_FALSE;
+        return ( AVIFILE_data.dwClassObjRef == 0 ) ? S_OK : S_FALSE;
 }
 

trunk/src/avifil32/guid.c

@@ -1 @@
-/* $Id: guid.c,v 1.2 2001-09-05 14:16:44 bird Exp $ */
 #define INITGUID
 

trunk/src/avifil32/iafile.c

@@ -1 @@
-/* $Id: iafile.c,v 1.2 2001-09-05 14:16:44 bird Exp $ */
 /*
  * Copyright 1999 Marcus Meissner
@@ -21 +20 @@
 DEFAULT_DEBUG_CHANNEL(avifile);
 
-#define AVIFILE_STREAMS_MAX 4
+#define AVIFILE_STREAMS_MAX     4
 
 
@@ -53 +52 @@
 typedef struct IAVIFileImpl
 {
-    ICOM_VFIELD(IAVIFile);
-    /* IUnknown stuff */
-    DWORD           ref;
-    /* IAVIFile stuff */
-    HANDLE          hf;
-    DWORD           dwAVIFileCaps;
-    DWORD           dwAVIFileScale;
-    DWORD           dwAVIFileRate;
-    DWORD           dwAVIFileLength;
-    DWORD           dwAVIFileEditCount;
-    MainAVIHeader       hdr;
-    IAVIStream*     pStreams[AVIFILE_STREAMS_MAX];
-    AVIStreamHeader     strhdrs[AVIFILE_STREAMS_MAX];
-    DWORD           dwMoviTop;
-    DWORD           dwCountOfIndexEntry;
-    AVIINDEXENTRY*      pIndexEntry;
-    AVIINDEXENTRY*      pStreamIndexEntry[AVIFILE_STREAMS_MAX+1];
+        ICOM_VFIELD(IAVIFile);
+        /* IUnknown stuff */
+        DWORD                   ref;
+        /* IAVIFile stuff */
+        HANDLE                  hf;
+        DWORD                   dwAVIFileCaps;
+        DWORD                   dwAVIFileScale;
+        DWORD                   dwAVIFileRate;
+        DWORD                   dwAVIFileLength;
+        DWORD                   dwAVIFileEditCount;
+        MainAVIHeader           hdr;
+        IAVIStream*             pStreams[AVIFILE_STREAMS_MAX];
+        AVIStreamHeader         strhdrs[AVIFILE_STREAMS_MAX];
+        DWORD                   dwMoviTop;
+        DWORD                   dwCountOfIndexEntry;
+        AVIINDEXENTRY*          pIndexEntry;
+        AVIINDEXENTRY*          pStreamIndexEntry[AVIFILE_STREAMS_MAX+1];
 } IAVIFileImpl;
 
@@ -78 +77 @@
 
 static HRESULT AVIFILE_IAVIFile_ReadNextChunkHeader(
-        IAVIFileImpl* This, FOURCC* pfcc, DWORD* pdwSize )
-{
-    BYTE    buf[8];
-    DWORD   dwRead;
-
-    if ( ( !ReadFile( This->hf, buf, 8, &dwRead, NULL ) ) ||
-         ( 8 != dwRead ) )
-        return AVIERR_FILEREAD;
-    *pfcc = mmioFOURCC(buf[0],buf[1],buf[2],buf[3]);
-    *pdwSize = ( ((DWORD)buf[4])       ) |
-           ( ((DWORD)buf[5]) <<  8 ) |
-           ( ((DWORD)buf[6]) << 16 ) |
-           ( ((DWORD)buf[7]) << 24 );
-
-    return S_OK;
+                IAVIFileImpl* This, FOURCC* pfcc, DWORD* pdwSize )
+{
+        BYTE    buf[8];
+        DWORD   dwRead;
+
+        if ( ( !ReadFile( This->hf, buf, 8, &dwRead, NULL ) ) ||
+             ( 8 != dwRead ) )
+                return AVIERR_FILEREAD;
+        *pfcc = mmioFOURCC(buf[0],buf[1],buf[2],buf[3]);
+        *pdwSize = ( ((DWORD)buf[4])       ) |
+                   ( ((DWORD)buf[5]) <<  8 ) |
+                   ( ((DWORD)buf[6]) << 16 ) |
+                   ( ((DWORD)buf[7]) << 24 );
+
+        return S_OK;
 }
 
 static HRESULT AVIFILE_IAVIFile_SkipChunkData(
-        IAVIFileImpl* This, DWORD dwChunkSize )
-{
-    LONG    lHigh = 0;
-    DWORD   dwRes;
-
-    if ( dwChunkSize == 0 )
-        return S_OK;
-
-    SetLastError(NO_ERROR);
-    dwRes = SetFilePointer( This->hf, (LONG)dwChunkSize,
-                &lHigh, FILE_CURRENT );
-    if ( dwRes == (DWORD)0xffffffff && GetLastError() != NO_ERROR )
-        return AVIERR_FILEREAD;
-
-    return S_OK;
+                IAVIFileImpl* This, DWORD dwChunkSize )
+{
+        LONG    lHigh = 0;
+        DWORD   dwRes;
+
+        if ( dwChunkSize == 0 )
+                return S_OK;
+
+        SetLastError(NO_ERROR);
+        dwRes = SetFilePointer( This->hf, (LONG)dwChunkSize,
+                                &lHigh, FILE_CURRENT );
+        if ( dwRes == (DWORD)0xffffffff && GetLastError() != NO_ERROR )
+                return AVIERR_FILEREAD;
+
+        return S_OK;
 }
 
 static HRESULT AVIFILE_IAVIFile_ReadChunkData(
-        IAVIFileImpl* This, DWORD dwChunkSize,
-        LPVOID lpvBuf, DWORD dwBufSize, LPDWORD lpdwRead )
-{
-    if ( dwBufSize > dwChunkSize )
-        dwBufSize = dwChunkSize;
-    if ( ( !ReadFile( This->hf, lpvBuf, dwBufSize, lpdwRead, NULL ) ) ||
-         ( dwBufSize != *lpdwRead ) )
-        return AVIERR_FILEREAD;
-
-    return AVIFILE_IAVIFile_SkipChunkData( This, dwChunkSize - dwBufSize );
+                IAVIFileImpl* This, DWORD dwChunkSize,
+                LPVOID lpvBuf, DWORD dwBufSize, LPDWORD lpdwRead )
+{
+        if ( dwBufSize > dwChunkSize )
+                dwBufSize = dwChunkSize;
+        if ( ( !ReadFile( This->hf, lpvBuf, dwBufSize, lpdwRead, NULL ) ) ||
+             ( dwBufSize != *lpdwRead ) )
+                return AVIERR_FILEREAD;
+
+        return AVIFILE_IAVIFile_SkipChunkData( This, dwChunkSize - dwBufSize );
 }
 
 static HRESULT AVIFILE_IAVIFile_SeekToSpecifiedChunk(
-        IAVIFileImpl* This, FOURCC fccType, DWORD* pdwLen )
-{
-    HRESULT hr;
-    FOURCC  fcc;
-    BYTE    buf[4];
-    DWORD   dwRead;
-
-    while ( 1 )
-    {
-        hr = AVIFILE_IAVIFile_ReadNextChunkHeader(
-                This, &fcc, pdwLen );
-        if ( hr != S_OK )
-            return hr;
-        if ( fcc == fccType )
-            return S_OK;
-
-        if ( fcc == FOURCC_LIST )
-        {
-            if ( ( !ReadFile( This->hf, buf, 4, &dwRead, NULL ) ) ||
-             ( 4 != dwRead ) )
-            return AVIERR_FILEREAD;
-        }
-        else
-        {
-            hr = AVIFILE_IAVIFile_SkipChunkData(
-                    This, *pdwLen );
-            if ( hr != S_OK )
-            return hr;
-        }
-    }
+                IAVIFileImpl* This, FOURCC fccType, DWORD* pdwLen )
+{
+        HRESULT hr;
+        FOURCC  fcc;
+        BYTE    buf[4];
+        DWORD   dwRead;
+
+        while ( 1 )
+        {
+                hr = AVIFILE_IAVIFile_ReadNextChunkHeader(
+                                This, &fcc, pdwLen );
+                if ( hr != S_OK )
+                        return hr;
+                if ( fcc == fccType )
+                        return S_OK;
+
+                if ( fcc == FOURCC_LIST )
+                {
+                    if ( ( !ReadFile( This->hf, buf, 4, &dwRead, NULL ) ) ||
+                         ( 4 != dwRead ) )
+                        return AVIERR_FILEREAD;
+                }
+                else
+                {
+                    hr = AVIFILE_IAVIFile_SkipChunkData(
+                                        This, *pdwLen );
+                    if ( hr != S_OK )
+                        return hr;
+                }
+        }
 }
 
@@ -162 +161 @@
 WINE_AVISTREAM_DATA* AVIFILE_Alloc_IAVIStreamData( DWORD dwFmtLen )
 {
-    WINE_AVISTREAM_DATA*    pData;
-
-    pData = (WINE_AVISTREAM_DATA*)
-        HeapAlloc( AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
-               sizeof(WINE_AVISTREAM_DATA) );
-    if ( pData == NULL )
-        return NULL;
-    if ( dwFmtLen > 0 )
-    {
-        pData->pbFmt = (BYTE*)
-            HeapAlloc( AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
-                   sizeof(BYTE)*dwFmtLen );
-        if ( pData->pbFmt == NULL )
-        {
-            AVIFILE_Free_IAVIStreamData( pData );
-            return NULL;
-        }
-    }
-    pData->dwFmtLen = dwFmtLen;
-
-    return pData;
+        WINE_AVISTREAM_DATA*    pData;
+
+        pData = (WINE_AVISTREAM_DATA*)
+                HeapAlloc( AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
+                           sizeof(WINE_AVISTREAM_DATA) );
+        if ( pData == NULL )
+                return NULL;
+        if ( dwFmtLen > 0 )
+        {
+                pData->pbFmt = (BYTE*)
+                        HeapAlloc( AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
+                                   sizeof(BYTE)*dwFmtLen );
+                if ( pData->pbFmt == NULL )
+                {
+                        AVIFILE_Free_IAVIStreamData( pData );
+                        return NULL;
+                }
+        }
+        pData->dwFmtLen = dwFmtLen;
+
+        return pData;
 }
 
 void AVIFILE_Free_IAVIStreamData( WINE_AVISTREAM_DATA* pData )
 {
-    if ( pData != NULL )
-    {
-        if ( pData->pbFmt != NULL )
-            HeapFree( AVIFILE_data.hHeap,0,pData->pbFmt );
-        HeapFree( AVIFILE_data.hHeap,0,pData );
-    }
+        if ( pData != NULL )
+        {
+                if ( pData->pbFmt != NULL )
+                        HeapFree( AVIFILE_data.hHeap,0,pData->pbFmt );
+                HeapFree( AVIFILE_data.hHeap,0,pData );
+        }
 }
 
 static void AVIFILE_IAVIFile_InitIndexTable(
-        IAVIFileImpl* This,
-        AVIINDEXENTRY* pIndexBuf,
-        AVIINDEXENTRY* pIndexData,
-        DWORD dwCountOfIndexEntry )
-{
-    DWORD   dwStreamIndex;
-    DWORD   dwIndex;
-    FOURCC  ckid;
-
-    dwStreamIndex = 0;
-    for ( ; dwStreamIndex < (AVIFILE_STREAMS_MAX+1); dwStreamIndex ++ )
-        This->pStreamIndexEntry[dwStreamIndex] = NULL;
-
-    dwStreamIndex = 0;
-    for ( ; dwStreamIndex < This->hdr.dwStreams; dwStreamIndex ++ )
-    {
-        ckid = mmioFOURCC('0','0'+dwStreamIndex,0,0);
-        TRACE( "testing ckid %c%c%c%c\n",
-            (int)(ckid>> 0)&0xff,
-            (int)(ckid>> 8)&0xff,
-            (int)(ckid>>16)&0xff,
-            (int)(ckid>>24)&0xff );
-        This->pStreamIndexEntry[dwStreamIndex] = pIndexBuf;
-        FIXME( "pIndexBuf = %p\n", pIndexBuf );
-        for ( dwIndex = 0; dwIndex < dwCountOfIndexEntry; dwIndex++ )
-        {
-            TRACE( "ckid %c%c%c%c\n",
-                (int)(pIndexData[dwIndex].ckid>> 0)&0xff,
+                IAVIFileImpl* This,
+                AVIINDEXENTRY* pIndexBuf,
+                AVIINDEXENTRY* pIndexData,
+                DWORD dwCountOfIndexEntry )
+{
+        DWORD   dwStreamIndex;
+        DWORD   dwIndex;
+        FOURCC  ckid;
+
+        dwStreamIndex = 0;
+        for ( ; dwStreamIndex < (AVIFILE_STREAMS_MAX+1); dwStreamIndex ++ )
+                This->pStreamIndexEntry[dwStreamIndex] = NULL;
+
+        dwStreamIndex = 0;
+        for ( ; dwStreamIndex < This->hdr.dwStreams; dwStreamIndex ++ )
+        {
+                ckid = mmioFOURCC('0','0'+dwStreamIndex,0,0);
+                TRACE( "testing ckid %c%c%c%c\n",
+                        (int)(ckid>> 0)&0xff,
+                        (int)(ckid>> 8)&0xff,
+                        (int)(ckid>>16)&0xff,
+                        (int)(ckid>>24)&0xff );
+                This->pStreamIndexEntry[dwStreamIndex] = pIndexBuf;
+                FIXME( "pIndexBuf = %p\n", pIndexBuf );
+                for ( dwIndex = 0; dwIndex < dwCountOfIndexEntry; dwIndex++ )
+                {
+                    TRACE( "ckid %c%c%c%c\n",
+                            (int)(pIndexData[dwIndex].ckid>> 0)&0xff,
                             (int)(pIndexData[dwIndex].ckid>> 8)&0xff,
                             (int)(pIndexData[dwIndex].ckid>>16)&0xff,
                             (int)(pIndexData[dwIndex].ckid>>24)&0xff );
-
-            if ( (pIndexData[dwIndex].ckid & mmioFOURCC(0xff,0xff,0,0))
-                                == ckid )
-            {
-            memcpy( pIndexBuf, &pIndexData[dwIndex],
-                sizeof(AVIINDEXENTRY) );
-            pIndexBuf ++;
-            }
-        }
+                            
+                    if ( (pIndexData[dwIndex].ckid & mmioFOURCC(0xff,0xff,0,0))
+                                                                == ckid )
+                    {
+                        memcpy( pIndexBuf, &pIndexData[dwIndex],
+                                sizeof(AVIINDEXENTRY) );
+                        pIndexBuf ++;
+                    }
+                }
                 FIXME( "pIndexBuf = %p\n", pIndexBuf );
-    }
-    This->pStreamIndexEntry[This->hdr.dwStreams] = pIndexBuf;
+        }
+        This->pStreamIndexEntry[This->hdr.dwStreams] = pIndexBuf;
 }
 
@@ -251 +250 @@
 HRESULT AVIFILE_CreateIAVIFile(void** ppobj)
 {
-    IAVIFileImpl    *This;
-    HRESULT     hr;
-
-    TRACE("(%p)\n",ppobj);
-    *ppobj = NULL;
-    This = (IAVIFileImpl*)HeapAlloc(AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
-                    sizeof(IAVIFileImpl));
-    if ( This == NULL )
-        return AVIERR_MEMORY;
-    This->ref = 1;
-    ICOM_VTBL(This) = &iavift;
-    hr = AVIFILE_IAVIFile_Construct( This );
-    if ( hr != S_OK )
-    {
-        AVIFILE_IAVIFile_Destruct( This );
-        return hr;
-    }
-
-    TRACE("new -> %p\n",This);
-    *ppobj = (LPVOID)This;
-
-    return S_OK;
+        IAVIFileImpl    *This;
+        HRESULT         hr;
+
+        TRACE("(%p)\n",ppobj);
+        *ppobj = NULL;
+        This = (IAVIFileImpl*)HeapAlloc(AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
+                                        sizeof(IAVIFileImpl));
+        if ( This == NULL )
+                return AVIERR_MEMORY;
+        This->ref = 1;
+        ICOM_VTBL(This) = &iavift;
+        hr = AVIFILE_IAVIFile_Construct( This );
+        if ( hr != S_OK )
+        {
+                AVIFILE_IAVIFile_Destruct( This );
+                return hr;
+        }
+
+        TRACE("new -> %p\n",This);
+        *ppobj = (LPVOID)This;
+
+        return S_OK;
 }
 
@@ -280 +279 @@
 
 static HRESULT WINAPI IAVIFile_fnQueryInterface(IAVIFile* iface,REFIID refiid,LPVOID *obj) {
-    ICOM_THIS(IAVIFileImpl,iface);
-
-    TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
-    if ( IsEqualGUID(&IID_IUnknown,refiid) ||
-         IsEqualGUID(&IID_IAVIFile,refiid) )
-    {
-        *obj = iface;
-        IAVIFile_AddRef(iface);
-        return S_OK;
-    }
-    return OLE_E_ENUM_NOMORE;
+        ICOM_THIS(IAVIFileImpl,iface);
+
+        TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
+        if ( IsEqualGUID(&IID_IUnknown,refiid) ||
+             IsEqualGUID(&IID_IAVIFile,refiid) )
+        {
+                *obj = iface;
+                IAVIFile_AddRef(iface);
+                return S_OK;
+        }
+        return OLE_E_ENUM_NOMORE;
 }
 
 static ULONG WINAPI IAVIFile_fnAddRef(IAVIFile* iface) {
-    ICOM_THIS(IAVIFileImpl,iface);
-
-    TRACE("(%p)->AddRef()\n",iface);
-    return ++(This->ref);
+        ICOM_THIS(IAVIFileImpl,iface);
+
+        TRACE("(%p)->AddRef()\n",iface);
+        return ++(This->ref);
 }
 
 static ULONG WINAPI IAVIFile_fnRelease(IAVIFile* iface) {
-    ICOM_THIS(IAVIFileImpl,iface);
-
-    TRACE("(%p)->Release()\n",iface);
-    if ( (--(This->ref)) > 0 )
-        return This->ref;
-
-    AVIFILE_IAVIFile_Destruct(This);
-    HeapFree(AVIFILE_data.hHeap,0,iface);
-    return 0;
+        ICOM_THIS(IAVIFileImpl,iface);
+
+        TRACE("(%p)->Release()\n",iface);
+        if ( (--(This->ref)) > 0 )
+                return This->ref;
+
+        AVIFILE_IAVIFile_Destruct(This);
+        HeapFree(AVIFILE_data.hHeap,0,iface);
+        return 0;
 }
 
@@ -318 +317 @@
 static HRESULT AVIFILE_IAVIFile_Construct( IAVIFileImpl* This )
 {
-    DWORD   dwIndex;
-
-    This->hf = INVALID_HANDLE_VALUE;
-    This->dwAVIFileCaps = 0;
-    This->dwAVIFileScale = 0;
-    This->dwAVIFileRate = 0;
-    This->dwAVIFileLength = 0;
-    This->dwAVIFileEditCount = 0;
-    for ( dwIndex = 0; dwIndex < AVIFILE_STREAMS_MAX; dwIndex++ )
-        This->pStreams[dwIndex] = NULL;
-    This->dwCountOfIndexEntry = 0;
-    This->pIndexEntry = NULL;
-
-    AVIFILE_data.dwClassObjRef ++;
-
-    return S_OK;
+        DWORD   dwIndex;
+
+        This->hf = INVALID_HANDLE_VALUE;
+        This->dwAVIFileCaps = 0;
+        This->dwAVIFileScale = 0;
+        This->dwAVIFileRate = 0;
+        This->dwAVIFileLength = 0;
+        This->dwAVIFileEditCount = 0;
+        for ( dwIndex = 0; dwIndex < AVIFILE_STREAMS_MAX; dwIndex++ )
+                This->pStreams[dwIndex] = NULL;
+        This->dwCountOfIndexEntry = 0;
+        This->pIndexEntry = NULL;
+
+        AVIFILE_data.dwClassObjRef ++;
+
+        return S_OK;
 }
 
 static void AVIFILE_IAVIFile_Destruct( IAVIFileImpl* This )
 {
-    DWORD   dwIndex;
-
-    if ( This->pIndexEntry != NULL )
-    {
-        HeapFree(AVIFILE_data.hHeap,0,This->pIndexEntry);
-        This->pIndexEntry = NULL;
-    }
-
-    for ( dwIndex = 0; dwIndex < AVIFILE_STREAMS_MAX; dwIndex++ )
-    {
-        if ( This->pStreams[dwIndex] != NULL )
-        {
-            IAVIStream_Release( This->pStreams[dwIndex] );
-            This->pStreams[dwIndex] = NULL;
-        }
-    }
-
-    if ( This->hf != INVALID_HANDLE_VALUE )
-        CloseHandle( This->hf );
-
-    AVIFILE_data.dwClassObjRef --;
+        DWORD   dwIndex;
+
+        if ( This->pIndexEntry != NULL )
+        {
+                HeapFree(AVIFILE_data.hHeap,0,This->pIndexEntry);
+                This->pIndexEntry = NULL;
+        }
+
+        for ( dwIndex = 0; dwIndex < AVIFILE_STREAMS_MAX; dwIndex++ )
+        {
+                if ( This->pStreams[dwIndex] != NULL )
+                {
+                        IAVIStream_Release( This->pStreams[dwIndex] );
+                        This->pStreams[dwIndex] = NULL;
+                }
+        }
+
+        if ( This->hf != INVALID_HANDLE_VALUE )
+                CloseHandle( This->hf );
+
+        AVIFILE_data.dwClassObjRef --;
 }
 
 static HRESULT WINAPI IAVIFile_fnInfo(IAVIFile*iface,AVIFILEINFOW*afi,LONG size)
 {
-    ICOM_THIS(IAVIFileImpl,iface);
-    AVIFILEINFOW    fiw;
-
-    FIXME("(%p)->Info(%p,%ld)\n",iface,afi,size);
-
-    memset( &fiw, 0, sizeof(fiw) );
-    fiw.dwMaxBytesPerSec = This->hdr.dwMaxBytesPerSec;
-    fiw.dwFlags = This->hdr.dwFlags;
-    fiw.dwCaps = This->dwAVIFileCaps;
-    fiw.dwStreams = This->hdr.dwStreams;
-    fiw.dwSuggestedBufferSize = This->hdr.dwSuggestedBufferSize;
-    fiw.dwWidth = This->hdr.dwWidth;
-    fiw.dwHeight = This->hdr.dwHeight;
-    fiw.dwScale = This->dwAVIFileScale; /* FIXME */
-    fiw.dwRate = This->dwAVIFileRate; /* FIXME */
-    fiw.dwLength = This->dwAVIFileLength; /* FIXME */
-    fiw.dwEditCount = This->dwAVIFileEditCount; /* FIXME */
-    /* fiw.szFileType[64]; */
-
-    if ( size > sizeof(AVIFILEINFOW) )
-        size = sizeof(AVIFILEINFOW);
-    memcpy( afi, &fiw, size );
-
-    return S_OK;
+        ICOM_THIS(IAVIFileImpl,iface);
+        AVIFILEINFOW    fiw;
+
+        FIXME("(%p)->Info(%p,%ld)\n",iface,afi,size);
+
+        memset( &fiw, 0, sizeof(fiw) );
+        fiw.dwMaxBytesPerSec = This->hdr.dwMaxBytesPerSec;
+        fiw.dwFlags = This->hdr.dwFlags;
+        fiw.dwCaps = This->dwAVIFileCaps;
+        fiw.dwStreams = This->hdr.dwStreams;
+        fiw.dwSuggestedBufferSize = This->hdr.dwSuggestedBufferSize;
+        fiw.dwWidth = This->hdr.dwWidth;
+        fiw.dwHeight = This->hdr.dwHeight;
+        fiw.dwScale = This->dwAVIFileScale; /* FIXME */
+        fiw.dwRate = This->dwAVIFileRate; /* FIXME */
+        fiw.dwLength = This->dwAVIFileLength; /* FIXME */
+        fiw.dwEditCount = This->dwAVIFileEditCount; /* FIXME */
+        /* fiw.szFileType[64]; */
+
+        if ( size > sizeof(AVIFILEINFOW) )
+                size = sizeof(AVIFILEINFOW);
+        memcpy( afi, &fiw, size );
+
+        return S_OK;
 }
 
 static HRESULT WINAPI IAVIFile_fnGetStream(IAVIFile*iface,PAVISTREAM*avis,DWORD fccType,LONG lParam)
 {
-    ICOM_THIS(IAVIFileImpl,iface);
-
-    FIXME("(%p)->GetStream(%p,0x%08lx,%ld)\n",iface,avis,fccType,lParam);
-    if ( fccType != 0 )
-        return E_FAIL;
-    if ( lParam < 0 || lParam >= This->hdr.dwStreams )
-        return E_FAIL;
-    *avis = This->pStreams[lParam];
-    IAVIStream_AddRef( *avis );
-
-    return S_OK;
+        ICOM_THIS(IAVIFileImpl,iface);
+
+        FIXME("(%p)->GetStream(%p,0x%08lx,%ld)\n",iface,avis,fccType,lParam);
+        if ( fccType != 0 )
+                return E_FAIL;
+        if ( lParam < 0 || lParam >= This->hdr.dwStreams )
+                return E_FAIL;
+        *avis = This->pStreams[lParam];
+        IAVIStream_AddRef( *avis );
+
+        return S_OK;
 }
 
 static HRESULT WINAPI IAVIFile_fnCreateStream(IAVIFile*iface,PAVISTREAM*avis,AVISTREAMINFOW*asi)
 {
-    ICOM_THIS(IAVIFileImpl,iface);
-
-    FIXME("(%p,%p,%p)\n",This,avis,asi);
-    return E_FAIL;
+        ICOM_THIS(IAVIFileImpl,iface);
+
+        FIXME("(%p,%p,%p)\n",This,avis,asi);
+        return E_FAIL;
 }
 
 static HRESULT WINAPI IAVIFile_fnWriteData(IAVIFile*iface,DWORD ckid,LPVOID lpData,LONG size)
 {
-    ICOM_THIS(IAVIFileImpl,iface);
-
-    FIXME("(%p)->WriteData(0x%08lx,%p,%ld)\n",This,ckid,lpData,size);
-    /* FIXME: write data to file */
-    return E_FAIL;
+        ICOM_THIS(IAVIFileImpl,iface);
+
+        FIXME("(%p)->WriteData(0x%08lx,%p,%ld)\n",This,ckid,lpData,size);
+        /* FIXME: write data to file */
+        return E_FAIL;
 }
 
 static HRESULT WINAPI IAVIFile_fnReadData(IAVIFile*iface,DWORD ckid,LPVOID lpData,LONG *size)
 {
-    ICOM_THIS(IAVIFileImpl,iface);
-
-    FIXME("(%p)->ReadData(0x%08lx,%p,%p)\n",This,ckid,lpData,size);
-    /* FIXME: read at most size bytes from file */
-
-    return E_FAIL;
+        ICOM_THIS(IAVIFileImpl,iface);
+
+        FIXME("(%p)->ReadData(0x%08lx,%p,%p)\n",This,ckid,lpData,size);
+        /* FIXME: read at most size bytes from file */
+
+        return E_FAIL;
 }
 
 static HRESULT WINAPI IAVIFile_fnEndRecord(IAVIFile*iface)
 {
-    ICOM_THIS(IAVIFileImpl,iface);
-
-    FIXME("(%p)->EndRecord()\n",This);
-    /* FIXME: end record? */
-    return E_FAIL;
+        ICOM_THIS(IAVIFileImpl,iface);
+
+        FIXME("(%p)->EndRecord()\n",This);
+        /* FIXME: end record? */
+        return E_FAIL;
 }
 
 static HRESULT WINAPI IAVIFile_fnDeleteStream(IAVIFile*iface,DWORD fccType,LONG lParam)
 {
-    ICOM_THIS(IAVIFileImpl,iface);
-
-    FIXME("(%p)->DeleteStream(0x%08lx,%ld)\n",This,fccType,lParam);
-    /* FIXME: delete stream? */
-    return E_FAIL;
+        ICOM_THIS(IAVIFileImpl,iface);
+
+        FIXME("(%p)->DeleteStream(0x%08lx,%ld)\n",This,fccType,lParam);
+        /* FIXME: delete stream? */
+        return E_FAIL;
 }
 
 /*****************************************************************************
- *  AVIFILE_IAVIFile_Open (internal)
+ *      AVIFILE_IAVIFile_Open (internal)
  */
 HRESULT AVIFILE_IAVIFile_Open( PAVIFILE paf, LPCWSTR szFile, UINT uMode )
 {
-    ICOM_THIS(IAVIFileImpl,paf);
-    HRESULT     hr;
-    DWORD       dwAcc;
-    DWORD       dwShared;
-    DWORD       dwCreate;
-    BYTE        buf[12];
-    DWORD       dwRead;
-    FOURCC      fccFileType;
-    DWORD       dwLen;
-    DWORD       dwIndex;
-
-    FIXME("(%p)->Open(%p,%u)\n",This,szFile,uMode);
-
-    if ( This->hf != INVALID_HANDLE_VALUE )
-    {
-        CloseHandle( This->hf );
-        This->hf = INVALID_HANDLE_VALUE;
-    }
-
-    switch ( uMode & 0x3 )
-    {
-    case OF_READ: /* 0x0 */
-        dwAcc = GENERIC_READ;
-        dwCreate = OPEN_EXISTING;
-        This->dwAVIFileCaps = AVIFILECAPS_CANREAD;
-        break;
-    case OF_WRITE: /* 0x1 */
-        dwAcc = GENERIC_WRITE;
-        dwCreate = OPEN_ALWAYS;
-        This->dwAVIFileCaps = AVIFILECAPS_CANWRITE;
-        break;
-    case OF_READWRITE: /* 0x2 */
-        dwAcc = GENERIC_READ|GENERIC_WRITE;
-        dwCreate = OPEN_ALWAYS;
-        This->dwAVIFileCaps = AVIFILECAPS_CANREAD|AVIFILECAPS_CANWRITE;
-        break;
-    default:
-        return E_FAIL;
-    }
-
-    if ( This->dwAVIFileCaps & AVIFILECAPS_CANWRITE )
-    {
-        FIXME( "editing AVI is currently not supported!\n" );
-        return E_FAIL;
-    }
-
-    switch ( uMode & 0x70 )
-    {
-    case OF_SHARE_COMPAT: /* 0x00 */
-        dwShared = FILE_SHARE_READ|FILE_SHARE_WRITE;
-        break;
-    case OF_SHARE_EXCLUSIVE: /* 0x10 */
-        dwShared = 0;
-        break;
-    case OF_SHARE_DENY_WRITE: /* 0x20 */
-        dwShared = FILE_SHARE_READ;
-        break;
-    case OF_SHARE_DENY_READ: /* 0x30 */
-        dwShared = FILE_SHARE_WRITE;
-        break;
-    case OF_SHARE_DENY_NONE: /* 0x40 */
-        dwShared = FILE_SHARE_READ|FILE_SHARE_WRITE;
-        break;
-    default:
-        return E_FAIL;
-    }
-    if ( uMode & OF_CREATE )
-        dwCreate = CREATE_ALWAYS;
-
-    This->hf = CreateFileW( szFile, dwAcc, dwShared, NULL,
-                dwCreate, FILE_ATTRIBUTE_NORMAL,
-                (HANDLE)NULL );
-    if ( This->hf == INVALID_HANDLE_VALUE )
-        return AVIERR_FILEOPEN;
-
-    if ( dwAcc & GENERIC_READ )
-    {
-        if ( !ReadFile( This->hf, buf, 12, &dwRead, NULL ) )
-        return AVIERR_FILEREAD;
-        if ( dwRead == 12 )
-        {
-        if ( mmioFOURCC(buf[0],buf[1],buf[2],buf[3]) != FOURCC_RIFF )
-            return AVIERR_BADFORMAT;
-
-        fccFileType = mmioFOURCC(buf[8],buf[9],buf[10],buf[11]);
-        if ( fccFileType != formtypeAVI )
-            return AVIERR_BADFORMAT;
-
-        /* get AVI main header. */
-        hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
-                This, ckidAVIMAINHDR, &dwLen );
-        if ( hr != S_OK )
-            return hr;
-        if ( dwLen < (sizeof(DWORD)*10) )
-            return AVIERR_BADFORMAT;
-        hr = AVIFILE_IAVIFile_ReadChunkData(
-                This, dwLen,
-                &(This->hdr), sizeof(MainAVIHeader), &dwLen );
-        if ( This->hdr.dwStreams == 0 ||
-             This->hdr.dwStreams > AVIFILE_STREAMS_MAX )
-            return AVIERR_BADFORMAT;
-
-        /* get stream headers. */
-        dwIndex = 0;
-        while ( dwIndex < This->hdr.dwStreams )
-        {
-            WINE_AVISTREAM_DATA*    pData;
-
-            hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
-                    This, ckidSTREAMHEADER, &dwLen );
-            if ( hr != S_OK )
-                return hr;
-            if ( dwLen < (sizeof(DWORD)*12) )
-                return AVIERR_BADFORMAT;
-            hr = AVIFILE_IAVIFile_ReadChunkData(
-                This, dwLen,
-                &This->strhdrs[dwIndex],
-                sizeof(AVIStreamHeader), &dwLen );
-
-            hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
-                    This, ckidSTREAMFORMAT, &dwLen );
-            if ( hr != S_OK )
-                return hr;
-            pData = AVIFILE_Alloc_IAVIStreamData( dwLen );
-            if ( pData == NULL )
-                return AVIERR_MEMORY;
-            hr = AVIFILE_IAVIFile_ReadChunkData(
-                This, dwLen,
-                pData->pbFmt, dwLen, &dwLen );
-            if ( hr != S_OK )
-            {
-                AVIFILE_Free_IAVIStreamData( pData );
-                return hr;
-            }
-            pData->dwStreamIndex = dwIndex;
-            pData->pstrhdr = &This->strhdrs[dwIndex];
-
-            hr = AVIStreamCreate(&This->pStreams[dwIndex],
-                         (LONG)paf, (LONG)(pData), NULL );
-            if ( hr != S_OK )
-            {
-                AVIFILE_Free_IAVIStreamData( pData );
-                return hr;
-            }
-
-            if ( (This->strhdrs[dwIndex].fccType
-                    == mmioFOURCC('v','i','d','s')) ||
-                 (This->strhdrs[dwIndex].fccType
-                    == mmioFOURCC('V','I','D','S')) )
-            {
-                This->dwAVIFileScale =
-                    This->strhdrs[dwIndex].dwScale;
-                This->dwAVIFileRate =
-                    This->strhdrs[dwIndex].dwRate;
-                This->dwAVIFileLength =
-                    This->strhdrs[dwIndex].dwLength;
-            }
-            else
-            if ( This->dwAVIFileScale == 0 )
-            {
-                This->dwAVIFileScale =
-                    This->strhdrs[dwIndex].dwScale;
-                This->dwAVIFileRate =
-                    This->strhdrs[dwIndex].dwRate;
-                This->dwAVIFileLength =
-                    This->strhdrs[dwIndex].dwLength;
-            }
-
-            dwIndex ++;
-        }
-
-        /* skip movi. */
-        while ( 1 )
-        {
-            hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
-                    This, FOURCC_LIST, &dwLen );
-            if ( hr != S_OK )
-                return hr;
-            if ( dwLen < 4 )
-                return AVIERR_BADFORMAT;
-
-            This->dwMoviTop = SetFilePointer( This->hf,0,NULL,FILE_CURRENT );
-            if ( This->dwMoviTop == 0xffffffff )
-                return AVIERR_BADFORMAT;
-
-            if ( ( !ReadFile(This->hf, buf, 4, &dwRead, NULL) ) ||
-                 ( dwRead != 4 ) )
-                return AVIERR_FILEREAD;
-
-            hr = AVIFILE_IAVIFile_SkipChunkData(
-                    This, dwLen - 4 );
-            if ( hr != S_OK )
-                return hr;
-            if ( mmioFOURCC(buf[0],buf[1],buf[2],buf[3])
-                == mmioFOURCC('m', 'o', 'v', 'i') )
-                break;
-        }
-
-        /* get idx1. */
-        hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
-                This, ckidAVINEWINDEX, &dwLen );
-        if ( hr != S_OK )
-            return hr;
-
-        This->dwCountOfIndexEntry = dwLen / sizeof(AVIINDEXENTRY);
-        This->pIndexEntry = (AVIINDEXENTRY*)
-            HeapAlloc(AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
-                  sizeof(AVIINDEXENTRY) *
-                  This->dwCountOfIndexEntry * 2 );
-        if ( This->pIndexEntry == NULL )
-            return AVIERR_MEMORY;
-        hr = AVIFILE_IAVIFile_ReadChunkData(
-                This, dwLen,
-                This->pIndexEntry + This->dwCountOfIndexEntry,
-                sizeof(AVIINDEXENTRY) *
-                This->dwCountOfIndexEntry, &dwLen );
-        if ( hr != S_OK )
-            return hr;
-        AVIFILE_IAVIFile_InitIndexTable(
-                This, This->pIndexEntry,
-                This->pIndexEntry + This->dwCountOfIndexEntry,
-                This->dwCountOfIndexEntry );
-        }
-        else
-        {
-        /* FIXME - create the handle has GENERIC_WRITE access. */
-        return AVIERR_FILEREAD;
-        }
-    }
-    else
-    {
-        return AVIERR_FILEOPEN; /* FIXME */
-    }
-
-    return S_OK;
+        ICOM_THIS(IAVIFileImpl,paf);
+        HRESULT         hr;
+        DWORD           dwAcc;
+        DWORD           dwShared;
+        DWORD           dwCreate;
+        BYTE            buf[12];
+        DWORD           dwRead;
+        FOURCC          fccFileType;
+        DWORD           dwLen;
+        DWORD           dwIndex;
+
+        FIXME("(%p)->Open(%p,%u)\n",This,szFile,uMode);
+
+        if ( This->hf != INVALID_HANDLE_VALUE )
+        {
+                CloseHandle( This->hf );
+                This->hf = INVALID_HANDLE_VALUE;
+        }
+
+        switch ( uMode & 0x3 )
+        {
+        case OF_READ: /* 0x0 */
+                dwAcc = GENERIC_READ;
+                dwCreate = OPEN_EXISTING;
+                This->dwAVIFileCaps = AVIFILECAPS_CANREAD;
+                break;
+        case OF_WRITE: /* 0x1 */
+                dwAcc = GENERIC_WRITE;
+                dwCreate = OPEN_ALWAYS;
+                This->dwAVIFileCaps = AVIFILECAPS_CANWRITE;
+                break;
+        case OF_READWRITE: /* 0x2 */
+                dwAcc = GENERIC_READ|GENERIC_WRITE;
+                dwCreate = OPEN_ALWAYS;
+                This->dwAVIFileCaps = AVIFILECAPS_CANREAD|AVIFILECAPS_CANWRITE;
+                break;
+        default:
+                return E_FAIL;
+        }
+
+        if ( This->dwAVIFileCaps & AVIFILECAPS_CANWRITE )
+        {
+                FIXME( "editing AVI is currently not supported!\n" );
+                return E_FAIL;
+        }
+
+        switch ( uMode & 0x70 )
+        {
+        case OF_SHARE_COMPAT: /* 0x00 */
+                dwShared = FILE_SHARE_READ|FILE_SHARE_WRITE;
+                break;
+        case OF_SHARE_EXCLUSIVE: /* 0x10 */
+                dwShared = 0;
+                break;
+        case OF_SHARE_DENY_WRITE: /* 0x20 */
+                dwShared = FILE_SHARE_READ;
+                break;
+        case OF_SHARE_DENY_READ: /* 0x30 */
+                dwShared = FILE_SHARE_WRITE;
+                break;
+        case OF_SHARE_DENY_NONE: /* 0x40 */
+                dwShared = FILE_SHARE_READ|FILE_SHARE_WRITE;
+                break;
+        default:
+                return E_FAIL;
+        }
+        if ( uMode & OF_CREATE )
+                dwCreate = CREATE_ALWAYS;
+
+        This->hf = CreateFileW( szFile, dwAcc, dwShared, NULL,
+                                dwCreate, FILE_ATTRIBUTE_NORMAL,
+                                (HANDLE)NULL );
+        if ( This->hf == INVALID_HANDLE_VALUE )
+                return AVIERR_FILEOPEN;
+
+        if ( dwAcc & GENERIC_READ )
+        {
+            if ( !ReadFile( This->hf, buf, 12, &dwRead, NULL ) )
+                return AVIERR_FILEREAD;
+            if ( dwRead == 12 )
+            {
+                if ( mmioFOURCC(buf[0],buf[1],buf[2],buf[3]) != FOURCC_RIFF )
+                        return AVIERR_BADFORMAT;
+
+                fccFileType = mmioFOURCC(buf[8],buf[9],buf[10],buf[11]);
+                if ( fccFileType != formtypeAVI )
+                        return AVIERR_BADFORMAT;
+
+                /* get AVI main header. */
+                hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
+                                This, ckidAVIMAINHDR, &dwLen );
+                if ( hr != S_OK )
+                        return hr;
+                if ( dwLen < (sizeof(DWORD)*10) )
+                        return AVIERR_BADFORMAT;
+                hr = AVIFILE_IAVIFile_ReadChunkData(
+                                This, dwLen,
+                                &(This->hdr), sizeof(MainAVIHeader), &dwLen );
+                if ( This->hdr.dwStreams == 0 ||
+                     This->hdr.dwStreams > AVIFILE_STREAMS_MAX )
+                        return AVIERR_BADFORMAT;
+
+                /* get stream headers. */
+                dwIndex = 0;
+                while ( dwIndex < This->hdr.dwStreams )
+                {
+                        WINE_AVISTREAM_DATA*    pData;
+
+                        hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
+                                        This, ckidSTREAMHEADER, &dwLen );
+                        if ( hr != S_OK )
+                                return hr;
+                        if ( dwLen < (sizeof(DWORD)*12) )
+                                return AVIERR_BADFORMAT;
+                        hr = AVIFILE_IAVIFile_ReadChunkData(
+                                This, dwLen,
+                                &This->strhdrs[dwIndex],
+                                sizeof(AVIStreamHeader), &dwLen );
+
+                        hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
+                                        This, ckidSTREAMFORMAT, &dwLen );
+                        if ( hr != S_OK )
+                                return hr;
+                        pData = AVIFILE_Alloc_IAVIStreamData( dwLen );
+                        if ( pData == NULL )
+                                return AVIERR_MEMORY;
+                        hr = AVIFILE_IAVIFile_ReadChunkData(
+                                This, dwLen,
+                                pData->pbFmt, dwLen, &dwLen );
+                        if ( hr != S_OK )
+                        {
+                                AVIFILE_Free_IAVIStreamData( pData );
+                                return hr;
+                        }
+                        pData->dwStreamIndex = dwIndex;
+                        pData->pstrhdr = &This->strhdrs[dwIndex];
+
+                        hr = AVIStreamCreate(&This->pStreams[dwIndex],
+                                             (LONG)paf, (LONG)(pData), NULL );
+                        if ( hr != S_OK )
+                        {
+                                AVIFILE_Free_IAVIStreamData( pData );
+                                return hr;
+                        }
+
+                        if ( (This->strhdrs[dwIndex].fccType
+                                        == mmioFOURCC('v','i','d','s')) ||
+                             (This->strhdrs[dwIndex].fccType
+                                        == mmioFOURCC('V','I','D','S')) )
+                        {
+                                This->dwAVIFileScale =
+                                        This->strhdrs[dwIndex].dwScale;
+                                This->dwAVIFileRate =
+                                        This->strhdrs[dwIndex].dwRate;
+                                This->dwAVIFileLength =
+                                        This->strhdrs[dwIndex].dwLength;
+                        }
+                        else
+                        if ( This->dwAVIFileScale == 0 )
+                        {
+                                This->dwAVIFileScale =
+                                        This->strhdrs[dwIndex].dwScale;
+                                This->dwAVIFileRate =
+                                        This->strhdrs[dwIndex].dwRate;
+                                This->dwAVIFileLength =
+                                        This->strhdrs[dwIndex].dwLength;
+                        }
+
+                        dwIndex ++;
+                }
+
+                /* skip movi. */
+                while ( 1 )
+                {
+                        hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
+                                        This, FOURCC_LIST, &dwLen );
+                        if ( hr != S_OK )
+                                return hr;
+                        if ( dwLen < 4 )
+                                return AVIERR_BADFORMAT;
+
+                        This->dwMoviTop = SetFilePointer( This->hf,0,NULL,FILE_CURRENT );
+                        if ( This->dwMoviTop == 0xffffffff )
+                                return AVIERR_BADFORMAT;
+
+                        if ( ( !ReadFile(This->hf, buf, 4, &dwRead, NULL) ) ||
+                             ( dwRead != 4 ) )
+                                return AVIERR_FILEREAD;
+
+                        hr = AVIFILE_IAVIFile_SkipChunkData(
+                                        This, dwLen - 4 );
+                        if ( hr != S_OK )
+                                return hr;
+                        if ( mmioFOURCC(buf[0],buf[1],buf[2],buf[3])
+                                == mmioFOURCC('m', 'o', 'v', 'i') )
+                                break;
+                }
+
+                /* get idx1. */
+                hr = AVIFILE_IAVIFile_SeekToSpecifiedChunk(
+                                This, ckidAVINEWINDEX, &dwLen );
+                if ( hr != S_OK )
+                        return hr;
+
+                This->dwCountOfIndexEntry = dwLen / sizeof(AVIINDEXENTRY);
+                This->pIndexEntry = (AVIINDEXENTRY*)
+                        HeapAlloc(AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
+                                  sizeof(AVIINDEXENTRY) *
+                                  This->dwCountOfIndexEntry * 2 );
+                if ( This->pIndexEntry == NULL )
+                        return AVIERR_MEMORY;
+                hr = AVIFILE_IAVIFile_ReadChunkData(
+                                This, dwLen,
+                                This->pIndexEntry + This->dwCountOfIndexEntry,
+                                sizeof(AVIINDEXENTRY) *
+                                This->dwCountOfIndexEntry, &dwLen );
+                if ( hr != S_OK )
+                        return hr;
+                AVIFILE_IAVIFile_InitIndexTable(
+                                This, This->pIndexEntry,
+                                This->pIndexEntry + This->dwCountOfIndexEntry,
+                                This->dwCountOfIndexEntry );
+            }
+            else
+            {
+                /* FIXME - create the handle has GENERIC_WRITE access. */
+                return AVIERR_FILEREAD;
+            }
+        }
+        else
+        {
+            return AVIERR_FILEOPEN; /* FIXME */
+        }
+
+        return S_OK;
 }
 
 /*****************************************************************************
- *  AVIFILE_IAVIFile_GetIndexTable (internal)
+ *      AVIFILE_IAVIFile_GetIndexTable (internal)
  */
 HRESULT AVIFILE_IAVIFile_GetIndexTable( PAVIFILE paf, DWORD dwStreamIndex,
-                    AVIINDEXENTRY** ppIndexEntry,
-                    DWORD* pdwCountOfIndexEntry )
-{
-    ICOM_THIS(IAVIFileImpl,paf);
-
-    if ( dwStreamIndex < 0 || dwStreamIndex >= This->hdr.dwStreams )
-    {
-        FIXME( "invalid stream index %lu\n", dwStreamIndex );
-        return E_FAIL;
-    }
-    FIXME( "cur %p, next %p\n",
-        This->pStreamIndexEntry[dwStreamIndex],
-        This->pStreamIndexEntry[dwStreamIndex+1] );
-    *ppIndexEntry = This->pStreamIndexEntry[dwStreamIndex];
-    *pdwCountOfIndexEntry =
-        This->pStreamIndexEntry[dwStreamIndex+1] -
-            This->pStreamIndexEntry[dwStreamIndex];
-
-    return S_OK;
+                                        AVIINDEXENTRY** ppIndexEntry,
+                                        DWORD* pdwCountOfIndexEntry )
+{
+        ICOM_THIS(IAVIFileImpl,paf);
+
+        if ( dwStreamIndex < 0 || dwStreamIndex >= This->hdr.dwStreams )
+        {
+                FIXME( "invalid stream index %lu\n", dwStreamIndex );
+                return E_FAIL;
+        }
+        FIXME( "cur %p, next %p\n",
+                This->pStreamIndexEntry[dwStreamIndex],
+                This->pStreamIndexEntry[dwStreamIndex+1] );
+        *ppIndexEntry = This->pStreamIndexEntry[dwStreamIndex];
+        *pdwCountOfIndexEntry =
+                This->pStreamIndexEntry[dwStreamIndex+1] -
+                        This->pStreamIndexEntry[dwStreamIndex];
+
+        return S_OK;
 }
 
 /*****************************************************************************
- *  AVIFILE_IAVIFile_ReadMovieData (internal)
+ *      AVIFILE_IAVIFile_ReadMovieData (internal)
  */
 HRESULT AVIFILE_IAVIFile_ReadMovieData( PAVIFILE paf, DWORD dwOffset,
-                    DWORD dwLength, LPVOID lpvBuf )
-{
-    ICOM_THIS(IAVIFileImpl,paf);
-    LONG    lHigh = 0;
-    DWORD   dwRes;
-
-    if ( dwLength == 0 )
-        return S_OK;
-    SetLastError(NO_ERROR);
-    dwRes = SetFilePointer( This->hf, (LONG)(dwOffset+This->dwMoviTop),
-                &lHigh, FILE_BEGIN );
-    if ( dwRes == (DWORD)0xffffffff && GetLastError() != NO_ERROR )
-        return AVIERR_FILEREAD;
-
-    if ( ( !ReadFile(This->hf, lpvBuf, dwLength, &dwRes, NULL) ) ||
-         ( dwLength != dwRes ) )
-    {
-        FIXME( "error in ReadFile()\n" );
-        return AVIERR_FILEREAD;
-    }
-
-    return S_OK;
-}
-
+                                        DWORD dwLength, LPVOID lpvBuf )
+{
+        ICOM_THIS(IAVIFileImpl,paf);
+        LONG    lHigh = 0;
+        DWORD   dwRes;
+
+        if ( dwLength == 0 )
+                return S_OK;
+        SetLastError(NO_ERROR);
+        dwRes = SetFilePointer( This->hf, (LONG)(dwOffset+This->dwMoviTop),
+                                &lHigh, FILE_BEGIN );
+        if ( dwRes == (DWORD)0xffffffff && GetLastError() != NO_ERROR )
+                return AVIERR_FILEREAD;
+
+        if ( ( !ReadFile(This->hf, lpvBuf, dwLength, &dwRes, NULL) ) ||
+             ( dwLength != dwRes ) )
+        {
+                FIXME( "error in ReadFile()\n" );
+                return AVIERR_FILEREAD;
+        }
+
+        return S_OK;
+}
+

trunk/src/avifil32/iastream.c

@@ -1 @@
-/* $Id: iastream.c,v 1.2 2001-09-05 14:16:45 bird Exp $ */
 /*
  * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
@@ -56 +55 @@
 typedef struct IAVIStreamImpl
 {
-    ICOM_VFIELD(IAVIStream);
-    /* IUnknown stuff */
-    DWORD       ref;
-    /* IAVIStream stuff */
-    IAVIFile*       paf;
-    WINE_AVISTREAM_DATA*    pData;
+        ICOM_VFIELD(IAVIStream);
+        /* IUnknown stuff */
+        DWORD           ref;
+        /* IAVIStream stuff */
+        IAVIFile*               paf;
+        WINE_AVISTREAM_DATA*    pData;
 } IAVIStreamImpl;
 
@@ -69 +68 @@
 HRESULT AVIFILE_CreateIAVIStream(void** ppobj)
 {
-    IAVIStreamImpl  *This;
-    HRESULT     hr;
-
-    *ppobj = NULL;
-    This = (IAVIStreamImpl*)HeapAlloc(AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
-                      sizeof(IAVIStreamImpl));
-    This->ref = 1;
-    ICOM_VTBL(This) = &iavist;
-    hr = IAVIStream_Construct( This );
-    if ( hr != S_OK )
-    {
-        IAVIStream_Destruct( This );
-        return hr;
-    }
-
-    *ppobj = (LPVOID)This;
-
-    return S_OK;
+        IAVIStreamImpl  *This;
+        HRESULT         hr;
+
+        *ppobj = NULL;
+        This = (IAVIStreamImpl*)HeapAlloc(AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
+                                          sizeof(IAVIStreamImpl));
+        This->ref = 1;
+        ICOM_VTBL(This) = &iavist;
+        hr = IAVIStream_Construct( This );
+        if ( hr != S_OK )
+        {
+                IAVIStream_Destruct( This );
+                return hr;
+        }
+
+        *ppobj = (LPVOID)This;
+
+        return S_OK;
 }
 
@@ -95 +94 @@
 
 static HRESULT WINAPI IAVIStream_fnQueryInterface(IAVIStream*iface,REFIID refiid,LPVOID *obj) {
-    ICOM_THIS(IAVIStreamImpl,iface);
-
-    TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
-    if ( IsEqualGUID(&IID_IUnknown,refiid) ||
-         IsEqualGUID(&IID_IAVIStream,refiid) )
-    {
-        IAVIStream_AddRef(iface);
-        *obj = iface;
-        return S_OK;
-    }
-    /* can return IGetFrame interface too */
-
-    return OLE_E_ENUM_NOMORE;
+        ICOM_THIS(IAVIStreamImpl,iface);
+
+        TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
+        if ( IsEqualGUID(&IID_IUnknown,refiid) ||
+             IsEqualGUID(&IID_IAVIStream,refiid) )
+        {
+                IAVIStream_AddRef(iface);
+                *obj = iface;
+                return S_OK;
+        }
+        /* can return IGetFrame interface too */
+
+        return OLE_E_ENUM_NOMORE;
 }
 
 static ULONG WINAPI IAVIStream_fnAddRef(IAVIStream*iface) {
-    ICOM_THIS(IAVIStreamImpl,iface);
-
-    TRACE("(%p)->AddRef()\n",iface);
-    return ++(This->ref);
+        ICOM_THIS(IAVIStreamImpl,iface);
+
+        TRACE("(%p)->AddRef()\n",iface);
+        return ++(This->ref);
 }
 
 static ULONG WINAPI IAVIStream_fnRelease(IAVIStream* iface) {
-    ICOM_THIS(IAVIStreamImpl,iface);
-
-    TRACE("(%p)->Release()\n",iface);
-    if ((--(This->ref)) > 0 )
-        return This->ref;
-    IAVIStream_Destruct(This);
-
-    HeapFree(AVIFILE_data.hHeap,0,iface);
-    return 0;
+        ICOM_THIS(IAVIStreamImpl,iface);
+
+        TRACE("(%p)->Release()\n",iface);
+        if ((--(This->ref)) > 0 )
+                return This->ref;
+        IAVIStream_Destruct(This);
+
+        HeapFree(AVIFILE_data.hHeap,0,iface);
+        return 0;
 }
 
@@ -135 +134 @@
 static HRESULT IAVIStream_Construct( IAVIStreamImpl* This )
 {
-    This->paf = NULL;
-    This->pData = NULL;
-
-    AVIFILE_data.dwClassObjRef ++;
-
-    return S_OK;
+        This->paf = NULL;
+        This->pData = NULL;
+
+        AVIFILE_data.dwClassObjRef ++;
+
+        return S_OK;
 }
 
 static void IAVIStream_Destruct( IAVIStreamImpl* This )
 {
-    AVIFILE_data.dwClassObjRef --;
+        AVIFILE_data.dwClassObjRef --;
 }
 
 static HRESULT WINAPI IAVIStream_fnCreate(IAVIStream*iface,LPARAM lParam1,LPARAM lParam2)
 {
-    ICOM_THIS(IAVIStreamImpl,iface);
-
-    FIXME("(%p)->Create(%ld,%ld)\n",iface,lParam1,lParam2);
-
-    This->paf = (IAVIFile*)lParam1;
-    This->pData = (WINE_AVISTREAM_DATA*)lParam2;
-
-    return S_OK;
+        ICOM_THIS(IAVIStreamImpl,iface);
+
+        FIXME("(%p)->Create(%ld,%ld)\n",iface,lParam1,lParam2);
+
+        This->paf = (IAVIFile*)lParam1;
+        This->pData = (WINE_AVISTREAM_DATA*)lParam2;
+
+        return S_OK;
 }
 
 static HRESULT WINAPI IAVIStream_fnInfo(IAVIStream*iface,AVISTREAMINFOW *psi,LONG size)
 {
-    ICOM_THIS(IAVIStreamImpl,iface);
-    AVISTREAMINFOW  siw;
-
-    FIXME("(%p)->Info(%p,%ld)\n",iface,psi,size);
-    if ( This->pData == NULL )
-        return E_UNEXPECTED;
-
-    memset( &siw, 0, sizeof(AVISTREAMINFOW) );
-    siw.fccType = This->pData->pstrhdr->fccType;
-    siw.fccHandler = This->pData->pstrhdr->fccHandler;
-    siw.dwFlags = This->pData->pstrhdr->dwFlags;
-    siw.dwCaps = 0; /* FIXME */
-    siw.wPriority = This->pData->pstrhdr->wPriority;
-    siw.wLanguage = This->pData->pstrhdr->wLanguage;
-    siw.dwScale = This->pData->pstrhdr->dwScale;
-    siw.dwRate = This->pData->pstrhdr->dwRate;
-    siw.dwStart = This->pData->pstrhdr->dwStart;
-    siw.dwLength = This->pData->pstrhdr->dwLength;
-    siw.dwInitialFrames = This->pData->pstrhdr->dwInitialFrames;
-    siw.dwSuggestedBufferSize = This->pData->pstrhdr->dwSuggestedBufferSize;
-    siw.dwQuality = This->pData->pstrhdr->dwQuality;
-    siw.dwSampleSize = This->pData->pstrhdr->dwSampleSize;
-    siw.rcFrame.left = This->pData->pstrhdr->rcFrame.left;
-    siw.rcFrame.top = This->pData->pstrhdr->rcFrame.top;
-    siw.rcFrame.right = This->pData->pstrhdr->rcFrame.right;
-    siw.rcFrame.bottom = This->pData->pstrhdr->rcFrame.bottom;
-    siw.dwEditCount = 0; /* FIXME */
-    siw.dwFormatChangeCount = 0; /* FIXME */
-    /* siw.szName[64] */
-
-    if ( size > sizeof(AVISTREAMINFOW) )
-        size = sizeof(AVISTREAMINFOW);
-    memcpy( psi, &siw, size );
-
-    return S_OK;
+        ICOM_THIS(IAVIStreamImpl,iface);
+        AVISTREAMINFOW  siw;
+
+        FIXME("(%p)->Info(%p,%ld)\n",iface,psi,size);
+        if ( This->pData == NULL )
+                return E_UNEXPECTED;
+
+        memset( &siw, 0, sizeof(AVISTREAMINFOW) );
+        siw.fccType = This->pData->pstrhdr->fccType;
+        siw.fccHandler = This->pData->pstrhdr->fccHandler;
+        siw.dwFlags = This->pData->pstrhdr->dwFlags;
+        siw.dwCaps = 0; /* FIXME */
+        siw.wPriority = This->pData->pstrhdr->wPriority;
+        siw.wLanguage = This->pData->pstrhdr->wLanguage;
+        siw.dwScale = This->pData->pstrhdr->dwScale;
+        siw.dwRate = This->pData->pstrhdr->dwRate;
+        siw.dwStart = This->pData->pstrhdr->dwStart;
+        siw.dwLength = This->pData->pstrhdr->dwLength;
+        siw.dwInitialFrames = This->pData->pstrhdr->dwInitialFrames;
+        siw.dwSuggestedBufferSize = This->pData->pstrhdr->dwSuggestedBufferSize;
+        siw.dwQuality = This->pData->pstrhdr->dwQuality;
+        siw.dwSampleSize = This->pData->pstrhdr->dwSampleSize;
+        siw.rcFrame.left = This->pData->pstrhdr->rcFrame.left;
+        siw.rcFrame.top = This->pData->pstrhdr->rcFrame.top;
+        siw.rcFrame.right = This->pData->pstrhdr->rcFrame.right;
+        siw.rcFrame.bottom = This->pData->pstrhdr->rcFrame.bottom;
+        siw.dwEditCount = 0; /* FIXME */
+        siw.dwFormatChangeCount = 0; /* FIXME */
+        /* siw.szName[64] */
+
+        if ( size > sizeof(AVISTREAMINFOW) )
+                size = sizeof(AVISTREAMINFOW);
+        memcpy( psi, &siw, size );
+
+        return S_OK;
 }
 
 static LONG WINAPI IAVIStream_fnFindSample(IAVIStream*iface,LONG pos,LONG flags)
 {
-    ICOM_THIS(IAVIStreamImpl,iface);
-    HRESULT hr;
-    AVIINDEXENTRY*  pIndexEntry;
-    DWORD       dwCountOfIndexEntry;
-    LONG        lCur, lAdd, lEnd;
-
-    FIXME("(%p)->FindSample(%ld,0x%08lx)\n",This,pos,flags);
-
-    hr = AVIFILE_IAVIFile_GetIndexTable(
-        This->paf, This->pData->dwStreamIndex,
-        &pIndexEntry, &dwCountOfIndexEntry );
-    if ( hr != S_OK )
-        return -1L;
-
-    if ( flags & (~(FIND_DIR|FIND_TYPE|FIND_RET)) )
-    {
-        FIXME( "unknown flag %08lx\n", flags );
-        return -1L;
-    }
-
-    switch ( flags & FIND_DIR )
-    {
-    case FIND_NEXT:
-        lCur = pos;
-        lAdd = 1;
-        lEnd = dwCountOfIndexEntry;
-        if ( lCur > dwCountOfIndexEntry )
-            return -1L;
-        break;
-    case FIND_PREV:
-        lCur = pos;
-        if ( lCur > dwCountOfIndexEntry )
-            lCur = dwCountOfIndexEntry;
-        lAdd = -1;
-        lEnd = 0;
-        break;
-    case FIND_FROM_START:
-        lCur = 0;
-        lAdd = 1;
-        lEnd = dwCountOfIndexEntry;
-        break;
-    default:
-        FIXME( "unknown direction flag %08lx\n", (flags & FIND_DIR) );
-        return -1L;
-    }
-
-    switch ( flags & FIND_TYPE )
-    {
-    case FIND_KEY:
-        while ( 1 )
-        {
-            if ( pIndexEntry[lCur].dwFlags & AVIIF_KEYFRAME )
-                break;
-            if ( lCur == lEnd )
-                return -1L;
-            lCur += lAdd;
-        }
-        break;
-    case FIND_ANY:
-        while ( 1 )
-        {
-            if ( !(pIndexEntry[lCur].dwFlags & AVIIF_NOTIME) )
-                break;
-            if ( lCur == lEnd )
-                return -1L;
-            lCur += lAdd;
-        }
-        break;
-    case FIND_FORMAT:
-        FIXME( "FIND_FORMAT is not implemented.\n" );
-        return -1L;
-    default:
-        FIXME( "unknown type flag %08lx\n", (flags & FIND_TYPE) );
-        return -1L;
-    }
-
-    switch ( flags & FIND_RET )
-    {
-    case FIND_POS:
-        return lCur;
-    case FIND_LENGTH:
-        FIXME( "FIND_LENGTH is not implemented.\n" );
-        return -1L;
-    case FIND_OFFSET:
-        return pIndexEntry[lCur].dwChunkOffset;
-    case FIND_SIZE:
-        return pIndexEntry[lCur].dwChunkLength;
-    case FIND_INDEX:
-        FIXME( "FIND_INDEX is not implemented.\n" );
-        return -1L;
-    default:
-        FIXME( "unknown return type flag %08lx\n", (flags & FIND_RET) );
-        break;
-    }
-
-    return -1L;
+        ICOM_THIS(IAVIStreamImpl,iface);
+        HRESULT hr;
+        AVIINDEXENTRY*  pIndexEntry;
+        DWORD           dwCountOfIndexEntry;
+        LONG            lCur, lAdd, lEnd;
+
+        FIXME("(%p)->FindSample(%ld,0x%08lx)\n",This,pos,flags);
+
+        hr = AVIFILE_IAVIFile_GetIndexTable(
+                This->paf, This->pData->dwStreamIndex,
+                &pIndexEntry, &dwCountOfIndexEntry );
+        if ( hr != S_OK )
+                return -1L;
+
+        if ( flags & (~(FIND_DIR|FIND_TYPE|FIND_RET)) )
+        {
+                FIXME( "unknown flag %08lx\n", flags );
+                return -1L;
+        }
+
+        switch ( flags & FIND_DIR )
+        {
+        case FIND_NEXT:
+                lCur = pos;
+                lAdd = 1;
+                lEnd = dwCountOfIndexEntry;
+                if ( lCur > dwCountOfIndexEntry )
+                        return -1L;
+                break;
+        case FIND_PREV:
+                lCur = pos;
+                if ( lCur > dwCountOfIndexEntry )
+                        lCur = dwCountOfIndexEntry;
+                lAdd = -1;
+                lEnd = 0;
+                break;
+        case FIND_FROM_START:
+                lCur = 0;
+                lAdd = 1;
+                lEnd = dwCountOfIndexEntry;
+                break;
+        default:
+                FIXME( "unknown direction flag %08lx\n", (flags & FIND_DIR) );
+                return -1L;
+        }
+
+        switch ( flags & FIND_TYPE )
+        {
+        case FIND_KEY:
+                while ( 1 )
+                {
+                        if ( pIndexEntry[lCur].dwFlags & AVIIF_KEYFRAME )
+                                break;
+                        if ( lCur == lEnd )
+                                return -1L;
+                        lCur += lAdd;
+                }
+                break;
+        case FIND_ANY:
+                while ( 1 )
+                {
+                        if ( !(pIndexEntry[lCur].dwFlags & AVIIF_NOTIME) )
+                                break;
+                        if ( lCur == lEnd )
+                                return -1L;
+                        lCur += lAdd;
+                }
+                break;
+        case FIND_FORMAT:
+                FIXME( "FIND_FORMAT is not implemented.\n" );
+                return -1L;
+        default:
+                FIXME( "unknown type flag %08lx\n", (flags & FIND_TYPE) );
+                return -1L;
+        }
+
+        switch ( flags & FIND_RET )
+        {
+        case FIND_POS:
+                return lCur;
+        case FIND_LENGTH:
+                FIXME( "FIND_LENGTH is not implemented.\n" );
+                return -1L;
+        case FIND_OFFSET:
+                return pIndexEntry[lCur].dwChunkOffset;
+        case FIND_SIZE:
+                return pIndexEntry[lCur].dwChunkLength;
+        case FIND_INDEX:
+                FIXME( "FIND_INDEX is not implemented.\n" );
+                return -1L;
+        default:
+                FIXME( "unknown return type flag %08lx\n", (flags & FIND_RET) );
+                break;
+        }
+
+        return -1L;
 }
 
 static HRESULT WINAPI IAVIStream_fnReadFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG *formatsize) {
-    ICOM_THIS(IAVIStreamImpl,iface);
-
-    TRACE("(%p)->ReadFormat(%ld,%p,%p)\n",This,pos,format,formatsize);
-    if ( This->pData == NULL )
-        return E_UNEXPECTED;
-
-    /* FIXME - check pos. */
-    if ( format == NULL )
-    {
-        *formatsize = This->pData->dwFmtLen;
-        return S_OK;
-    }
-    if ( (*formatsize) < This->pData->dwFmtLen )
-        return AVIERR_BUFFERTOOSMALL;
-
-    memcpy( format, This->pData->pbFmt, This->pData->dwFmtLen );
-    *formatsize = This->pData->dwFmtLen;
-
-    return S_OK;
+        ICOM_THIS(IAVIStreamImpl,iface);
+
+        TRACE("(%p)->ReadFormat(%ld,%p,%p)\n",This,pos,format,formatsize);
+        if ( This->pData == NULL )
+                return E_UNEXPECTED;
+
+        /* FIXME - check pos. */
+        if ( format == NULL )
+        {
+                *formatsize = This->pData->dwFmtLen;
+                return S_OK;
+        }
+        if ( (*formatsize) < This->pData->dwFmtLen )
+                return AVIERR_BUFFERTOOSMALL;
+
+        memcpy( format, This->pData->pbFmt, This->pData->dwFmtLen );
+        *formatsize = This->pData->dwFmtLen;
+
+        return S_OK;
 }
 
 static HRESULT WINAPI IAVIStream_fnSetFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG formatsize) {
-    ICOM_THIS(IAVIStreamImpl,iface);
-
-    FIXME("(%p)->SetFormat(%ld,%p,%ld)\n",This,pos,format,formatsize);
-    return E_FAIL;
+        ICOM_THIS(IAVIStreamImpl,iface);
+
+        FIXME("(%p)->SetFormat(%ld,%p,%ld)\n",This,pos,format,formatsize);
+        return E_FAIL;
 }
 
 static HRESULT WINAPI IAVIStream_fnRead(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread) {
-    ICOM_THIS(IAVIStreamImpl,iface);
-    HRESULT hr;
-    AVIINDEXENTRY*  pIndexEntry;
-    DWORD       dwCountOfIndexEntry;
-    DWORD       dwFrameLength;
-
-    FIXME("(%p)->Read(%ld,%ld,%p,%ld,%p,%p)\n",This,start,samples,buffer,buffersize,bytesread,samplesread);
-
-    *bytesread = 0;
-    *samplesread = 0;
-
-    hr = AVIFILE_IAVIFile_GetIndexTable(
-        This->paf, This->pData->dwStreamIndex,
-        &pIndexEntry, &dwCountOfIndexEntry );
-    if ( hr != S_OK )
-        return hr;
-    if ( start < 0 )
-        return E_FAIL;
-    if ( start >= dwCountOfIndexEntry || samples <= 0 )
-    {
-        FIXME("start %ld,samples %ld,total %ld\n",start,samples,dwCountOfIndexEntry);
-        return S_OK;
-    }
-
-    /* FIXME - is this data valid??? */
-    dwFrameLength = pIndexEntry[start].dwChunkLength + sizeof(DWORD)*2;
-
-    if ( buffer == NULL )
-    {
-        *bytesread = dwFrameLength;
-        *samplesread = 1;
-        return S_OK;
-    }
-    if ( buffersize < dwFrameLength )
-    {
-        FIXME( "buffer is too small!\n" );
-        return AVIERR_BUFFERTOOSMALL;
-    }
-
-    hr = AVIFILE_IAVIFile_ReadMovieData(
-            This->paf,
-            pIndexEntry[start].dwChunkOffset,
-            dwFrameLength, buffer );
-    if ( hr != S_OK )
-    {
-        FIXME( "ReadMovieData failed!\n");
-        return hr;
-    }
-    *bytesread = dwFrameLength;
-    *samplesread = 1;
-
-    return S_OK;
+        ICOM_THIS(IAVIStreamImpl,iface);
+        HRESULT hr;
+        AVIINDEXENTRY*  pIndexEntry;
+        DWORD           dwCountOfIndexEntry;
+        DWORD           dwFrameLength;
+
+        FIXME("(%p)->Read(%ld,%ld,%p,%ld,%p,%p)\n",This,start,samples,buffer,buffersize,bytesread,samplesread);
+
+        *bytesread = 0;
+        *samplesread = 0;
+
+        hr = AVIFILE_IAVIFile_GetIndexTable(
+                This->paf, This->pData->dwStreamIndex,
+                &pIndexEntry, &dwCountOfIndexEntry );
+        if ( hr != S_OK )
+                return hr;
+        if ( start < 0 )
+                return E_FAIL;
+        if ( start >= dwCountOfIndexEntry || samples <= 0 )
+        {
+                FIXME("start %ld,samples %ld,total %ld\n",start,samples,dwCountOfIndexEntry);
+                return S_OK;
+        }
+
+        /* FIXME - is this data valid??? */
+        dwFrameLength = pIndexEntry[start].dwChunkLength + sizeof(DWORD)*2;
+
+        if ( buffer == NULL )
+        {
+                *bytesread = dwFrameLength;
+                *samplesread = 1;
+                return S_OK;
+        }
+        if ( buffersize < dwFrameLength )
+        {
+                FIXME( "buffer is too small!\n" );
+                return AVIERR_BUFFERTOOSMALL;
+        }
+
+        hr = AVIFILE_IAVIFile_ReadMovieData(
+                        This->paf,
+                        pIndexEntry[start].dwChunkOffset,
+                        dwFrameLength, buffer );
+        if ( hr != S_OK )
+        {
+                FIXME( "ReadMovieData failed!\n");
+                return hr;
+        }
+        *bytesread = dwFrameLength;
+        *samplesread = 1;
+
+        return S_OK;
 }
 
 static HRESULT WINAPI IAVIStream_fnWrite(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten) {
-    ICOM_THIS(IAVIStreamImpl,iface);
-
-
-    FIXME("(%p)->Write(%ld,%ld,%p,%ld,0x%08lx,%p,%p)\n",This,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
-    return E_FAIL;
+        ICOM_THIS(IAVIStreamImpl,iface);
+
+
+        FIXME("(%p)->Write(%ld,%ld,%p,%ld,0x%08lx,%p,%p)\n",This,start,samples,buffer,buffersize,flags,sampwritten,byteswritten);
+        return E_FAIL;
 }
 
 static HRESULT WINAPI IAVIStream_fnDelete(IAVIStream*iface,LONG start,LONG samples) {
-    ICOM_THIS(IAVIStreamImpl,iface);
-
-    FIXME("(%p)->Delete(%ld,%ld)\n",This,start,samples);
-    return E_FAIL;
+        ICOM_THIS(IAVIStreamImpl,iface);
+
+        FIXME("(%p)->Delete(%ld,%ld)\n",This,start,samples);
+        return E_FAIL;
 }
 static HRESULT WINAPI IAVIStream_fnReadData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG *lpread) {
-    ICOM_THIS(IAVIStreamImpl,iface);
-
-    FIXME("(%p)->ReadData(0x%08lx,%p,%p)\n",This,fcc,lp,lpread);
-    return E_FAIL;
+        ICOM_THIS(IAVIStreamImpl,iface);
+
+        FIXME("(%p)->ReadData(0x%08lx,%p,%p)\n",This,fcc,lp,lpread);
+        return E_FAIL;
 }
 
 static HRESULT WINAPI IAVIStream_fnWriteData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG size) {
-    ICOM_THIS(IAVIStreamImpl,iface);
-
-    FIXME("(%p)->WriteData(0x%08lx,%p,%ld)\n",This,fcc,lp,size);
-    return E_FAIL;
+        ICOM_THIS(IAVIStreamImpl,iface);
+
+        FIXME("(%p)->WriteData(0x%08lx,%p,%ld)\n",This,fcc,lp,size);
+        return E_FAIL;
 }
 
 static HRESULT WINAPI IAVIStream_fnSetInfo(IAVIStream*iface,AVISTREAMINFOW*info,LONG infolen) {
-    ICOM_THIS(IAVIStreamImpl,iface);
-
-    FIXME("(%p)->SetInfo(%p,%ld)\n",This,info,infolen);
-
-    return E_FAIL;
-}
-
+        ICOM_THIS(IAVIStreamImpl,iface);
+
+        FIXME("(%p)->SetInfo(%p,%ld)\n",This,info,infolen);
+
+        return E_FAIL;
+}
+

trunk/src/avifil32/igframe.c

@@ -1 @@
-/* $Id: igframe.c,v 1.2 2001-09-05 14:16:45 bird Exp $ */
 /*
  * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
@@ -30 +29 @@
 struct ICOM_VTABLE(IGetFrame) igetfrm = {
     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
-    IGetFrame_fnQueryInterface,
-    IGetFrame_fnAddRef,
-    IGetFrame_fnRelease,
-    IGetFrame_fnGetFrame,
-    IGetFrame_fnBegin,
-    IGetFrame_fnEnd,
-    IGetFrame_fnSetFormat,
+        IGetFrame_fnQueryInterface,
+        IGetFrame_fnAddRef,
+        IGetFrame_fnRelease,
+        IGetFrame_fnGetFrame,
+        IGetFrame_fnBegin,
+        IGetFrame_fnEnd,
+        IGetFrame_fnSetFormat,
 };
 
 typedef struct IGetFrameImpl
 {
-    ICOM_VFIELD(IGetFrame);
-    /* IUnknown stuff */
-    DWORD           ref;
-    /* IGetFrame stuff */
-    IAVIStream*     pas;
-    HIC         hIC;
-    LONG            lCachedFrame;
-    BITMAPINFO*     pbiICIn;
-    BITMAPINFO*     pbiICOut;
-    LPVOID          pvICOutBits;
-    LPVOID          pvICInFmtBuf;
-    DWORD           dwICInDataBufSize;
-    LPVOID          pvICInDataBuf;
-    LPVOID          pvICOutBuf;
+        ICOM_VFIELD(IGetFrame);
+        /* IUnknown stuff */
+        DWORD                   ref;
+        /* IGetFrame stuff */
+        IAVIStream*             pas;
+        HIC                     hIC;
+        LONG                    lCachedFrame;
+        BITMAPINFO*             pbiICIn;
+        BITMAPINFO*             pbiICOut;
+        LPVOID                  pvICOutBits;
+        LPVOID                  pvICInFmtBuf;
+        DWORD                   dwICInDataBufSize;
+        LPVOID                  pvICInDataBuf;
+        LPVOID                  pvICOutBuf;
 } IGetFrameImpl;
 
 static HRESULT IGetFrame_Construct( IGetFrameImpl* This,
-                    IAVIStream* pstr,
-                    LPBITMAPINFOHEADER lpbi );
+                                    IAVIStream* pstr,
+                                    LPBITMAPINFOHEADER lpbi );
 static void IGetFrame_Destruct( IGetFrameImpl* This );
 
@@ -67 +66 @@
 static LPVOID AVIFILE_IGetFrame_DecodeFrame(IGetFrameImpl* This,LONG lPos)
 {
-    HRESULT hr;
-    DWORD   dwRes;
-    LONG    lFrameLength;
-    LONG    lSampleCount;
-    ICDECOMPRESS    icd;
-
-    if ( This->hIC == (HIC)NULL )
-        return NULL;
-
-    hr = IAVIStream_Read(This->pas,lPos,1,NULL,0,
-                 &lFrameLength,&lSampleCount);
-    if ( hr != S_OK || lSampleCount <= 0 )
-    {
-        FIXME( "IAVIStream_Read failed! res = %08lx\n", hr );
-        return NULL;
-    }
-    TRACE( "frame length = %ld\n", lFrameLength );
-
-    if ( This->dwICInDataBufSize < lFrameLength )
-    {
-        LPVOID  lpv;
-
-        if ( This->pvICInDataBuf == NULL )
-        {
-            lpv = HeapAlloc(
-                AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
-                lFrameLength );
-        }
-        else
-        {
-            lpv = HeapReAlloc(
-                AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
-                This->pvICInDataBuf,lFrameLength );
-        }
-        if ( lpv == NULL )
-        {
-            ERR( "out of memory!\n" );
-            return NULL;
-        }
-        This->pvICInDataBuf = lpv;
-        This->dwICInDataBufSize = lFrameLength;
-    }
-
-    hr = IAVIStream_Read(This->pas,lPos,1,
-                 This->pvICInDataBuf,This->dwICInDataBufSize,
-                 &lFrameLength,&lSampleCount);
-    if ( hr != S_OK || lSampleCount <= 0 )
-    {
-        FIXME( "IAVIStream_Read to buffer failed! res = %08lx\n", hr );
-        return NULL;
-    }
-
-    This->pbiICIn->bmiHeader.biSizeImage = lFrameLength;
-
-    TRACE( "call ICM_DECOMPRESS\n" );
-    icd.dwFlags = (*(BYTE*)This->pvICInDataBuf) == 'c' ?
-                      ICDECOMPRESS_NOTKEYFRAME : 0;
-    icd.lpbiInput = &This->pbiICIn->bmiHeader;
-    icd.lpInput = (BYTE*)This->pvICInDataBuf + 8;
-    icd.lpbiOutput = &This->pbiICOut->bmiHeader;
-    icd.lpOutput = This->pvICOutBits;
-    icd.ckid = *((DWORD*)This->pvICInDataBuf);
-    dwRes = ICSendMessage(This->hIC,ICM_DECOMPRESS,
-                  (DWORD)(&icd),sizeof(ICDECOMPRESS) );
-    TRACE( "returned from ICM_DECOMPRESS\n" );
-    if ( dwRes != ICERR_OK )
-    {
-        ERR( "ICDecompress failed!\n" );
-        return NULL;
-    }
-
-    This->lCachedFrame = lPos;
-
-    return This->pvICOutBits;
+        HRESULT hr;
+        DWORD   dwRes;
+        LONG    lFrameLength;
+        LONG    lSampleCount;
+        ICDECOMPRESS    icd;
+
+        if ( This->hIC == (HIC)NULL )
+                return NULL;
+
+        hr = IAVIStream_Read(This->pas,lPos,1,NULL,0,
+                             &lFrameLength,&lSampleCount);
+        if ( hr != S_OK || lSampleCount <= 0 )
+        {
+                FIXME( "IAVIStream_Read failed! res = %08lx\n", hr );
+                return NULL;
+        }
+        TRACE( "frame length = %ld\n", lFrameLength );
+
+        if ( This->dwICInDataBufSize < lFrameLength )
+        {
+                LPVOID  lpv;
+
+                if ( This->pvICInDataBuf == NULL )
+                {
+                        lpv = HeapAlloc(
+                                AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
+                                lFrameLength );
+                }
+                else
+                {
+                        lpv = HeapReAlloc(
+                                AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
+                                This->pvICInDataBuf,lFrameLength );
+                }
+                if ( lpv == NULL )
+                {
+                        ERR( "out of memory!\n" );
+                        return NULL;
+                }
+                This->pvICInDataBuf = lpv;
+                This->dwICInDataBufSize = lFrameLength;
+        }
+
+        hr = IAVIStream_Read(This->pas,lPos,1,
+                             This->pvICInDataBuf,This->dwICInDataBufSize,
+                             &lFrameLength,&lSampleCount);
+        if ( hr != S_OK || lSampleCount <= 0 )
+        {
+                FIXME( "IAVIStream_Read to buffer failed! res = %08lx\n", hr );
+                return NULL;
+        }
+
+        This->pbiICIn->bmiHeader.biSizeImage = lFrameLength;
+
+        TRACE( "call ICM_DECOMPRESS\n" );
+        icd.dwFlags = (*(BYTE*)This->pvICInDataBuf) == 'c' ?
+                                      ICDECOMPRESS_NOTKEYFRAME : 0;
+        icd.lpbiInput = &This->pbiICIn->bmiHeader;
+        icd.lpInput = (BYTE*)This->pvICInDataBuf + 8;
+        icd.lpbiOutput = &This->pbiICOut->bmiHeader;
+        icd.lpOutput = This->pvICOutBits;
+        icd.ckid = *((DWORD*)This->pvICInDataBuf);
+        dwRes = ICSendMessage(This->hIC,ICM_DECOMPRESS,
+                              (DWORD)(&icd),sizeof(ICDECOMPRESS) );
+        TRACE( "returned from ICM_DECOMPRESS\n" );
+        if ( dwRes != ICERR_OK )
+        {
+                ERR( "ICDecompress failed!\n" );
+                return NULL;
+        }
+
+        This->lCachedFrame = lPos;
+
+        return This->pvICOutBits;
 }
 
@@ -146 +145 @@
 
 HRESULT AVIFILE_CreateIGetFrame(void** ppobj,
-                IAVIStream* pstr,LPBITMAPINFOHEADER lpbi)
-{
-    IGetFrameImpl   *This;
-    HRESULT     hr;
-
-    *ppobj = NULL;
-    This = (IGetFrameImpl*)HeapAlloc(AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
-                      sizeof(IGetFrameImpl));
-    This->ref = 1;
-    ICOM_VTBL(This) = &igetfrm;
-    hr = IGetFrame_Construct( This, pstr, lpbi );
-    if ( hr != S_OK )
-    {
-        IGetFrame_Destruct( This );
-        return hr;
-    }
-
-    *ppobj = (LPVOID)This;
-
-    return S_OK;
+                                IAVIStream* pstr,LPBITMAPINFOHEADER lpbi)
+{
+        IGetFrameImpl   *This;
+        HRESULT         hr;
+
+        *ppobj = NULL;
+        This = (IGetFrameImpl*)HeapAlloc(AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
+                                          sizeof(IGetFrameImpl));
+        This->ref = 1;
+        ICOM_VTBL(This) = &igetfrm;
+        hr = IGetFrame_Construct( This, pstr, lpbi );
+        if ( hr != S_OK )
+        {
+                IGetFrame_Destruct( This );
+                return hr;
+        }
+
+        *ppobj = (LPVOID)This;
+
+        return S_OK;
 }
 
@@ -174 +173 @@
 static HRESULT WINAPI IGetFrame_fnQueryInterface(IGetFrame* iface,REFIID refiid,LPVOID *obj)
 {
-    ICOM_THIS(IGetFrameImpl,iface);
-
-    TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
-    if ( IsEqualGUID(&IID_IUnknown,refiid) ||
-         IsEqualGUID(&IID_IGetFrame,refiid) )
-    {
-        IGetFrame_AddRef(iface);
-        *obj = iface;
-        return S_OK;
-    }
-
-    return OLE_E_ENUM_NOMORE;
+        ICOM_THIS(IGetFrameImpl,iface);
+
+        TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(refiid),obj);
+        if ( IsEqualGUID(&IID_IUnknown,refiid) ||
+             IsEqualGUID(&IID_IGetFrame,refiid) )
+        {
+                IGetFrame_AddRef(iface);
+                *obj = iface;
+                return S_OK;
+        }
+
+        return OLE_E_ENUM_NOMORE;
 }
 
 static ULONG WINAPI IGetFrame_fnAddRef(IGetFrame* iface)
 {
-    ICOM_THIS(IGetFrameImpl,iface);
-
-    TRACE("(%p)->AddRef()\n",iface);
-    return ++(This->ref);
+        ICOM_THIS(IGetFrameImpl,iface);
+
+        TRACE("(%p)->AddRef()\n",iface);
+        return ++(This->ref);
 }
 
 static ULONG WINAPI IGetFrame_fnRelease(IGetFrame* iface)
 {
-    ICOM_THIS(IGetFrameImpl,iface);
-
-    TRACE("(%p)->Release()\n",iface);
-    if ((--(This->ref)) > 0 )
-        return This->ref;
-    IGetFrame_Destruct(This);
-    if ( This->pas != NULL )
-        IAVIStream_Release( This->pas );
-
-    HeapFree(AVIFILE_data.hHeap,0,iface);
-    return 0;
+        ICOM_THIS(IGetFrameImpl,iface);
+
+        TRACE("(%p)->Release()\n",iface);
+        if ((--(This->ref)) > 0 )
+                return This->ref;
+        IGetFrame_Destruct(This);
+        if ( This->pas != NULL )
+                IAVIStream_Release( This->pas );
+
+        HeapFree(AVIFILE_data.hHeap,0,iface);
+        return 0;
 }
 
@@ -217 +216 @@
 static LPVOID WINAPI IGetFrame_fnGetFrame(IGetFrame* iface,LONG lPos)
 {
-    ICOM_THIS(IGetFrameImpl,iface);
-    LPVOID  lpv;
-    LONG    lKeyFrame;
-
-    TRACE( "(%p)->(%ld)\n", This, lPos );
-
-    if ( lPos < 0 )
-        return NULL;
-
-    if ( This->lCachedFrame == lPos )
-        return This->pvICOutBits;
-    if ( (This->lCachedFrame+1) != lPos )
-    {
-        lKeyFrame = IAVIStream_FindSample( This->pas, lPos,
-                           FIND_KEY | FIND_PREV );
-        if ( lKeyFrame < 0 || lKeyFrame > lPos )
-            return NULL;
-        while ( ++lKeyFrame < lPos )
-        {
-            lpv = AVIFILE_IGetFrame_DecodeFrame(This, lKeyFrame);
-            if ( lpv == NULL )
-                return NULL;
-        }
-    }
-
-    lpv = AVIFILE_IGetFrame_DecodeFrame(This, lPos);
-    TRACE( "lpv = %p\n",lpv );
-    if ( lpv == NULL )
-        return NULL;
-
-    return lpv;
+        ICOM_THIS(IGetFrameImpl,iface);
+        LPVOID  lpv;
+        LONG    lKeyFrame;
+
+        TRACE( "(%p)->(%ld)\n", This, lPos );
+
+        if ( lPos < 0 )
+                return NULL;
+
+        if ( This->lCachedFrame == lPos )
+                return This->pvICOutBits;
+        if ( (This->lCachedFrame+1) != lPos )
+        {
+                lKeyFrame = IAVIStream_FindSample( This->pas, lPos,
+                                                   FIND_KEY | FIND_PREV );
+                if ( lKeyFrame < 0 || lKeyFrame > lPos )
+                        return NULL;
+                while ( ++lKeyFrame < lPos )
+                {
+                        lpv = AVIFILE_IGetFrame_DecodeFrame(This, lKeyFrame);
+                        if ( lpv == NULL )
+                                return NULL;
+                }
+        }
+
+        lpv = AVIFILE_IGetFrame_DecodeFrame(This, lPos);
+        TRACE( "lpv = %p\n",lpv );
+        if ( lpv == NULL )
+                return NULL;
+
+        return lpv;
 }
 
 static HRESULT WINAPI IGetFrame_fnBegin(IGetFrame* iface,LONG lStart,LONG lEnd,LONG lRate)
 {
-    ICOM_THIS(IGetFrameImpl,iface);
-
-    TRACE( "(%p)->(%ld,%ld,%ld)\n", This, lStart, lEnd, lRate );
-
-    if ( This->hIC == (HIC)NULL )
-        return E_UNEXPECTED;
-
-    if ( ICDecompressBegin( This->hIC,
-                This->pbiICIn,
-                This->pbiICOut ) != ICERR_OK )
-        return E_FAIL;
-
-    return S_OK;
+        ICOM_THIS(IGetFrameImpl,iface);
+
+        TRACE( "(%p)->(%ld,%ld,%ld)\n", This, lStart, lEnd, lRate );
+
+        if ( This->hIC == (HIC)NULL )
+                return E_UNEXPECTED;
+
+        if ( ICDecompressBegin( This->hIC,
+                                This->pbiICIn,
+                                This->pbiICOut ) != ICERR_OK )
+                return E_FAIL;
+
+        return S_OK;
 }
 
 static HRESULT WINAPI IGetFrame_fnEnd(IGetFrame* iface)
 {
-    ICOM_THIS(IGetFrameImpl,iface);
-
-    TRACE( "(%p)->()\n", This );
-
-    if ( This->hIC == (HIC)NULL )
-        return E_UNEXPECTED;
-
-    if ( ICDecompressEnd( This->hIC ) != ICERR_OK )
-        return E_FAIL;
-
-    return S_OK;
+        ICOM_THIS(IGetFrameImpl,iface);
+
+        TRACE( "(%p)->()\n", This );
+
+        if ( This->hIC == (HIC)NULL )
+                return E_UNEXPECTED;
+
+        if ( ICDecompressEnd( This->hIC ) != ICERR_OK )
+                return E_FAIL;
+
+        return S_OK;
 }
 
 static HRESULT WINAPI IGetFrame_fnSetFormat(IGetFrame* iface,LPBITMAPINFOHEADER lpbi,LPVOID lpBits,INT x,INT y,INT dx,INT dy)
 {
-    ICOM_THIS(IGetFrameImpl,iface);
-    HRESULT hr;
-    LONG    fmtlen;
-    BITMAPINFOHEADER    biTemp;
-    DWORD   dwSizeImage;
-
-    FIXME( "(%p)->(%p,%p,%d,%d,%d,%d)\n",This,lpbi,lpBits,x,y,dx,dy );
-
-    IGetFrame_Destruct(This);
-
-    hr = IAVIStream_ReadFormat(This->pas,0,NULL,&fmtlen);
-    if ( hr != S_OK )
-        return hr;
-    This->pvICInFmtBuf = HeapAlloc(
-        AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,fmtlen);
-    if ( This->pvICInFmtBuf == NULL )
-        return AVIERR_MEMORY;
-    hr = IAVIStream_ReadFormat(This->pas,0,This->pvICInFmtBuf,&fmtlen);
-    if ( hr != S_OK )
-        return hr;
-    This->pbiICIn = (LPBITMAPINFO)This->pvICInFmtBuf;
-
-    This->hIC = (HIC)ICOpen( ICTYPE_VIDEO,
-                 This->pbiICIn->bmiHeader.biCompression,
-                 ICMODE_DECOMPRESS );
-    if ( This->hIC == (HIC)NULL )
-    {
-        ERR( "no AVI decompressor for %c%c%c%c.\n",
-             (int)(This->pbiICIn->bmiHeader.biCompression>> 0)&0xff,
-             (int)(This->pbiICIn->bmiHeader.biCompression>> 8)&0xff,
-             (int)(This->pbiICIn->bmiHeader.biCompression>>16)&0xff,
-             (int)(This->pbiICIn->bmiHeader.biCompression>>24)&0xff );
-        return E_FAIL;
-    }
-
-    if ( lpbi == NULL || lpbi == ((LPBITMAPINFOHEADER)1) )
-    {
-        memset( &biTemp, 0, sizeof(biTemp) );
-        biTemp.biSize = sizeof(BITMAPINFOHEADER);
-        biTemp.biWidth = This->pbiICIn->bmiHeader.biWidth;
-        biTemp.biHeight = This->pbiICIn->bmiHeader.biHeight;
-        biTemp.biPlanes = 1;
-        biTemp.biBitCount = 24;
-        biTemp.biCompression = 0;
-        lpbi = &biTemp;
-    }
-
-    if ( lpbi->biPlanes != 1 || lpbi->biCompression != 0 )
-        return E_FAIL;
-
-    dwSizeImage =
-        ((This->pbiICIn->bmiHeader.biWidth*lpbi->biBitCount+7)/8)*
-                    This->pbiICIn->bmiHeader.biHeight;
-    This->pvICOutBuf = HeapAlloc(
-        AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
-        (sizeof(BITMAPINFO)+sizeof(RGBQUAD)*256)*2+
-        dwSizeImage );
-    if ( This->pvICOutBuf == NULL )
-        return AVIERR_MEMORY;
-
-    This->pbiICOut = (BITMAPINFO*)This->pvICOutBuf;
-    This->pvICOutBits = (LPVOID)( (BYTE*)This->pvICOutBuf +
-                sizeof(BITMAPINFO) + sizeof(RGBQUAD)*256 );
-
-    This->pbiICOut->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-    This->pbiICOut->bmiHeader.biWidth = This->pbiICIn->bmiHeader.biWidth;
-    This->pbiICOut->bmiHeader.biHeight = This->pbiICIn->bmiHeader.biHeight;
-    This->pbiICOut->bmiHeader.biPlanes = 1;
-    This->pbiICOut->bmiHeader.biBitCount = lpbi->biBitCount;
-    This->pbiICOut->bmiHeader.biSizeImage = dwSizeImage;
-    memcpy( This->pvICOutBits, This->pbiICOut, sizeof(BITMAPINFOHEADER) );
-
-    return S_OK;
+        ICOM_THIS(IGetFrameImpl,iface);
+        HRESULT hr;
+        LONG    fmtlen;
+        BITMAPINFOHEADER        biTemp;
+        DWORD   dwSizeImage;
+
+        FIXME( "(%p)->(%p,%p,%d,%d,%d,%d)\n",This,lpbi,lpBits,x,y,dx,dy );
+
+        IGetFrame_Destruct(This);
+
+        hr = IAVIStream_ReadFormat(This->pas,0,NULL,&fmtlen);
+        if ( hr != S_OK )
+                return hr;
+        This->pvICInFmtBuf = HeapAlloc(
+                AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,fmtlen);
+        if ( This->pvICInFmtBuf == NULL )
+                return AVIERR_MEMORY;
+        hr = IAVIStream_ReadFormat(This->pas,0,This->pvICInFmtBuf,&fmtlen);
+        if ( hr != S_OK )
+                return hr;
+        This->pbiICIn = (LPBITMAPINFO)This->pvICInFmtBuf;
+
+        This->hIC = (HIC)ICOpen( ICTYPE_VIDEO,
+                                 This->pbiICIn->bmiHeader.biCompression,
+                                 ICMODE_DECOMPRESS );
+        if ( This->hIC == (HIC)NULL )
+        {
+                ERR( "no AVI decompressor for %c%c%c%c.\n",
+                     (int)(This->pbiICIn->bmiHeader.biCompression>> 0)&0xff,
+                     (int)(This->pbiICIn->bmiHeader.biCompression>> 8)&0xff,
+                     (int)(This->pbiICIn->bmiHeader.biCompression>>16)&0xff,
+                     (int)(This->pbiICIn->bmiHeader.biCompression>>24)&0xff );
+                return E_FAIL;
+        }
+
+        if ( lpbi == NULL || lpbi == ((LPBITMAPINFOHEADER)1) )
+        {
+                memset( &biTemp, 0, sizeof(biTemp) );
+                biTemp.biSize = sizeof(BITMAPINFOHEADER);
+                biTemp.biWidth = This->pbiICIn->bmiHeader.biWidth;
+                biTemp.biHeight = This->pbiICIn->bmiHeader.biHeight;
+                biTemp.biPlanes = 1;
+                biTemp.biBitCount = 24;
+                biTemp.biCompression = 0;
+                lpbi = &biTemp;
+        }
+
+        if ( lpbi->biPlanes != 1 || lpbi->biCompression != 0 )
+                return E_FAIL;
+
+        dwSizeImage =
+                ((This->pbiICIn->bmiHeader.biWidth*lpbi->biBitCount+7)/8)*
+                                        This->pbiICIn->bmiHeader.biHeight;
+        This->pvICOutBuf = HeapAlloc(
+                AVIFILE_data.hHeap,HEAP_ZERO_MEMORY,
+                (sizeof(BITMAPINFO)+sizeof(RGBQUAD)*256)*2+
+                dwSizeImage );
+        if ( This->pvICOutBuf == NULL )
+                return AVIERR_MEMORY;
+
+        This->pbiICOut = (BITMAPINFO*)This->pvICOutBuf;
+        This->pvICOutBits = (LPVOID)( (BYTE*)This->pvICOutBuf +
+                                sizeof(BITMAPINFO) + sizeof(RGBQUAD)*256 );
+
+        This->pbiICOut->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+        This->pbiICOut->bmiHeader.biWidth = This->pbiICIn->bmiHeader.biWidth;
+        This->pbiICOut->bmiHeader.biHeight = This->pbiICIn->bmiHeader.biHeight;
+        This->pbiICOut->bmiHeader.biPlanes = 1;
+        This->pbiICOut->bmiHeader.biBitCount = lpbi->biBitCount;
+        This->pbiICOut->bmiHeader.biSizeImage = dwSizeImage;
+        memcpy( This->pvICOutBits, This->pbiICOut, sizeof(BITMAPINFOHEADER) );
+
+        return S_OK;
 }
 
 static HRESULT IGetFrame_Construct( IGetFrameImpl* This,
-                    IAVIStream* pstr,
-                    LPBITMAPINFOHEADER lpbi )
-{
-    HRESULT hr;
-
-    TRACE( "(%p)->(%p,%p)\n",This,pstr,lpbi );
-
-    IAVIStream_AddRef( pstr );
-    This->pas = pstr;
-    This->hIC = (HIC)NULL;
-    This->lCachedFrame = -1L;
-    This->pbiICIn = NULL;
-    This->pbiICOut = NULL;
-    This->pvICInFmtBuf = NULL;
-    This->pvICInDataBuf = NULL;
-    This->dwICInDataBufSize = 0;
-    This->pvICOutBuf = NULL;
-
-    hr = IGetFrame_SetFormat((IGetFrame*)This,lpbi,NULL,0,0,0,0);
-    if ( hr != S_OK )
-        return hr;
-
-    return S_OK;
+                                    IAVIStream* pstr,
+                                    LPBITMAPINFOHEADER lpbi )
+{
+        HRESULT hr;
+
+        TRACE( "(%p)->(%p,%p)\n",This,pstr,lpbi );
+
+        IAVIStream_AddRef( pstr );
+        This->pas = pstr;
+        This->hIC = (HIC)NULL;
+        This->lCachedFrame = -1L;
+        This->pbiICIn = NULL;
+        This->pbiICOut = NULL;
+        This->pvICInFmtBuf = NULL;
+        This->pvICInDataBuf = NULL;
+        This->dwICInDataBufSize = 0;
+        This->pvICOutBuf = NULL;
+
+        hr = IGetFrame_SetFormat((IGetFrame*)This,lpbi,NULL,0,0,0,0);
+        if ( hr != S_OK )
+                return hr;
+
+        return S_OK;
 }
 
 static void IGetFrame_Destruct( IGetFrameImpl* This )
 {
-    if ( This->hIC != (HIC)NULL )
-    {
-        ICClose( This->hIC );
-        This->hIC = (HIC)NULL;
-    }
-    if ( This->pvICInFmtBuf != NULL )
-    {
-        HeapFree( AVIFILE_data.hHeap, 0, This->pvICInFmtBuf );
-        This->pvICInFmtBuf = NULL;
-    }
-    if ( This->pvICInDataBuf != NULL )
-    {
-        HeapFree( AVIFILE_data.hHeap, 0, This->pvICInDataBuf );
-        This->pvICInDataBuf = NULL;
-    }
-    if ( This->pvICOutBuf != NULL )
-    {
-        HeapFree( AVIFILE_data.hHeap, 0, This->pvICOutBuf );
-        This->pvICOutBuf = NULL;
-    }
-
-    This->lCachedFrame = -1L;
-    This->pbiICIn = NULL;
-    This->pbiICOut = NULL;
-    This->dwICInDataBufSize = 0;
-}
+        if ( This->hIC != (HIC)NULL )
+        {
+                ICClose( This->hIC );
+                This->hIC = (HIC)NULL;
+        }
+        if ( This->pvICInFmtBuf != NULL )
+        {
+                HeapFree( AVIFILE_data.hHeap, 0, This->pvICInFmtBuf );
+                This->pvICInFmtBuf = NULL;
+        }
+        if ( This->pvICInDataBuf != NULL )
+        {
+                HeapFree( AVIFILE_data.hHeap, 0, This->pvICInDataBuf );
+                This->pvICInDataBuf = NULL;
+        }
+        if ( This->pvICOutBuf != NULL )
+        {
+                HeapFree( AVIFILE_data.hHeap, 0, This->pvICOutBuf );
+                This->pvICOutBuf = NULL;
+        }
+
+        This->lCachedFrame = -1L;
+        This->pbiICIn = NULL;
+        This->pbiICOut = NULL;
+        This->dwICInDataBufSize = 0;
+}

trunk/src/avifil32/main.c

@@ -1 @@
-/* $Id: main.c,v 1.2 2001-09-05 14:16:45 bird Exp $ */
 /*
  * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
@@ -22 +21 @@
 
 /***********************************************************************
- *      AVIFILE_InitProcess (internal)
+ *              AVIFILE_InitProcess (internal)
  */
 static BOOL AVIFILE_InitProcess( void )
 {
-    TRACE("()\n");
+        TRACE("()\n");
 
-    AVIFILE_data.dwAVIFileRef = 0;
-    AVIFILE_data.dwClassObjRef = 0;
-    AVIFILE_data.hHeap = (HANDLE)NULL;
+        AVIFILE_data.dwAVIFileRef = 0;
+        AVIFILE_data.dwClassObjRef = 0;
+        AVIFILE_data.hHeap = (HANDLE)NULL;
 
-    AVIFILE_data.hHeap = HeapCreate( 0, 0x10000, 0 );
-    if ( AVIFILE_data.hHeap  == (HANDLE)NULL )
-    {
-        ERR( "cannot allocate heap for AVIFILE.\n" );
-        return FALSE;
-    }
+        AVIFILE_data.hHeap = HeapCreate( 0, 0x10000, 0 );
+        if ( AVIFILE_data.hHeap  == (HANDLE)NULL )
+        {
+                ERR( "cannot allocate heap for AVIFILE.\n" );
+                return FALSE;
+        }
 
-    return TRUE;
+        return TRUE;
 }
 
 /***********************************************************************
- *      AVIFILE_UninitProcess (internal)
+ *              AVIFILE_UninitProcess (internal)
  */
 static void AVIFILE_UninitProcess( void )
 {
-    TRACE("()\n");
+        TRACE("()\n");
 
-    if ( AVIFILE_data.dwAVIFileRef != 0 )
-        ERR( "you must call AVIFileExit()\n" );
+        if ( AVIFILE_data.dwAVIFileRef != 0 )
+                ERR( "you must call AVIFileExit()\n" );
 
-    if ( AVIFILE_data.dwClassObjRef != 0 )
-        ERR( "you must release some objects allocated from AVIFile.\n" );
+        if ( AVIFILE_data.dwClassObjRef != 0 )
+                ERR( "you must release some objects allocated from AVIFile.\n" );
 
-    if ( AVIFILE_data.hHeap != (HANDLE)NULL )
-    {
-        HeapDestroy( AVIFILE_data.hHeap );
-        AVIFILE_data.hHeap = (HANDLE)NULL;
-    }
+        if ( AVIFILE_data.hHeap != (HANDLE)NULL )
+        {
+                HeapDestroy( AVIFILE_data.hHeap );
+                AVIFILE_data.hHeap = (HANDLE)NULL;
+        }
 }
 
 /***********************************************************************
- *      AVIFILE_DllMain
+ *              AVIFILE_DllMain
  */
 BOOL WINAPI AVIFILE_DllMain(
-    HINSTANCE hInstDLL,
-    DWORD fdwReason,
-    LPVOID lpvReserved )
+        HINSTANCE hInstDLL,
+        DWORD fdwReason,
+        LPVOID lpvReserved )
 {
-    switch ( fdwReason )
-    {
-    case DLL_PROCESS_ATTACH:
-        if ( !AVIFILE_InitProcess() )
-            return FALSE;
-        break;
-    case DLL_PROCESS_DETACH:
-        AVIFILE_UninitProcess();
-        break;
-    case DLL_THREAD_ATTACH:
-        break;
-    case DLL_THREAD_DETACH:
-        break;
-    }
+        switch ( fdwReason )
+        {
+        case DLL_PROCESS_ATTACH:
+                if ( !AVIFILE_InitProcess() )
+                        return FALSE;
+                break;
+        case DLL_PROCESS_DETACH:
+                AVIFILE_UninitProcess();
+                break;
+        case DLL_THREAD_ATTACH:
+                break;
+        case DLL_THREAD_DETACH:
+                break;
+        }
 
-    return TRUE;
+        return TRUE;
 }
 

trunk/src/avifil32/string.c

@@ -1 @@
-/* $Id: string.c,v 1.2 2001-09-05 14:16:46 bird Exp $ */
 /*
  * Copyright 2001 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
@@ -25 +24 @@
 INT AVIFILE_strlenAtoW( LPCSTR lpstr )
 {
-    INT len;
+        INT     len;
 
-    len = MultiByteToWideChar( CP_ACP, 0, lpstr, -1, NULL, 0 );
-    return ( len > 0 ) ? (len-1) : 0;
+        len = MultiByteToWideChar( CP_ACP, 0, lpstr, -1, NULL, 0 );
+        return ( len > 0 ) ? (len-1) : 0;
 }
 
 INT AVIFILE_strlenWtoA( LPCWSTR lpwstr )
 {
-    INT len;
+        INT     len;
 
-    len = WideCharToMultiByte( CP_ACP, 0, lpwstr, -1,
-                   NULL, 0, NULL, NULL );
-    return ( len > 0 ) ? (len-1) : 0;
+        len = WideCharToMultiByte( CP_ACP, 0, lpwstr, -1,
+                                   NULL, 0, NULL, NULL );
+        return ( len > 0 ) ? (len-1) : 0;
 }
 
 LPWSTR AVIFILE_strncpyAtoW( LPWSTR lpwstr, LPCSTR lpstr, INT wbuflen )
 {
-    INT len;
+        INT     len;
 
-    len = MultiByteToWideChar( CP_ACP, 0, lpstr, -1, lpwstr, wbuflen );
-    if ( len == 0 )
-        *lpwstr = 0;
-    return lpwstr;
+        len = MultiByteToWideChar( CP_ACP, 0, lpstr, -1, lpwstr, wbuflen );
+        if ( len == 0 )
+                *lpwstr = 0;
+        return lpwstr;
 }
 
 LPSTR AVIFILE_strncpyWtoA( LPSTR lpstr, LPCWSTR lpwstr, INT abuflen )
 {
-    INT len;
+        INT     len;
 
-    len = WideCharToMultiByte( CP_ACP, 0, lpwstr, -1,
-                   lpstr, abuflen, NULL, NULL );
-    if ( len == 0 )
-        *lpstr = 0;
-    return lpstr;
+        len = WideCharToMultiByte( CP_ACP, 0, lpwstr, -1,
+                                   lpstr, abuflen, NULL, NULL );
+        if ( len == 0 )
+                *lpstr = 0;
+        return lpstr;
 }
 
 LPWSTR AVIFILE_strdupAtoW( LPCSTR lpstr )
 {
-    INT len;
-    LPWSTR lpwstr = NULL;
+        INT len;
+        LPWSTR lpwstr = NULL;
 
-    len = AVIFILE_strlenAtoW( lpstr );
-    if ( len > 0 )
-    {
-        lpwstr = (LPWSTR)HeapAlloc( AVIFILE_data.hHeap, 0, sizeof(WCHAR)*(len+1) );
-        if ( lpwstr != NULL )
-            (void)AVIFILE_strncpyAtoW( lpwstr, lpstr, len+1 );
-    }
+        len = AVIFILE_strlenAtoW( lpstr );
+        if ( len > 0 )
+        {
+                lpwstr = (LPWSTR)HeapAlloc( AVIFILE_data.hHeap, 0, sizeof(WCHAR)*(len+1) );
+                if ( lpwstr != NULL )
+                        (void)AVIFILE_strncpyAtoW( lpwstr, lpstr, len+1 );
+        }
 
-    return lpwstr;
+        return lpwstr;
 }
 
 LPSTR AVIFILE_strdupWtoA( LPCWSTR lpwstr )
 {
-    INT len;
-    LPSTR lpstr = NULL;
+        INT len;
+        LPSTR lpstr = NULL;
 
-    len = AVIFILE_strlenWtoA( lpwstr );
-    if ( len > 0 )
-    {
-        lpstr = (LPSTR)HeapAlloc( AVIFILE_data.hHeap, 0, sizeof(CHAR)*(len+1) );
-        if ( lpstr != NULL )
-            (void)AVIFILE_strncpyWtoA( lpstr, lpwstr, len+1 );
-    }
+        len = AVIFILE_strlenWtoA( lpwstr );
+        if ( len > 0 )
+        {
+                lpstr = (LPSTR)HeapAlloc( AVIFILE_data.hHeap, 0, sizeof(CHAR)*(len+1) );
+                if ( lpstr != NULL )
+                        (void)AVIFILE_strncpyWtoA( lpstr, lpwstr, len+1 );
+        }
 
-    return lpstr;
+        return lpstr;
 }
 

trunk/src/crtdll/crtdll.cpp

@@ -1 @@
-/* $Id: crtdll.cpp,v 1.30 2001-09-05 12:14:23 bird Exp $ */
 /*
  * The C RunTime DLL
- *
+ * 
  * Implements C run-time functionality as known from UNIX.
  *
- * TODO:
+ * TODO: 
  *   - Check setjmp(3)
  *   - fix *ALL* functions for the FS: wrapper problem
@@ -73 +72 @@
 // Definitions for internal functions
 //
-void        qsort1 (char*, char*, size_t,
+void            qsort1 (char*, char*, size_t,
                     int (* CDECL)(const void*, const void*));
 
@@ -445 +444 @@
 
 /*********************************************************************
- *  _cscanf                     (CRTDLL.67)
+ *      _cscanf                                 (CRTDLL.67)
  */
 INT CDECL CRTDLL__cscanf( char *s, va_list arg )
@@ -605 +604 @@
 
 /*********************************************************************
- *  _ftime                  (CRTDLL.112)
+ *      _ftime                                  (CRTDLL.112)
  */
 void CDECL CRTDLL__ftime( struct timeb *timebuf )
@@ -619 +618 @@
 LONG CDECL CRTDLL__ftol(void)
 {
-    /* don't just do DO_FPU("fistp",retval), because the rounding
-     * mode must also be set to "round towards zero"... */
-    double fl;
-    POP_FPU(fl);
-    return (LONG)fl;
+        /* don't just do DO_FPU("fistp",retval), because the rounding
+         * mode must also be set to "round towards zero"... */
+        double fl;
+        POP_FPU(fl);
+        return (LONG)fl;
 }
 
@@ -776 +775 @@
 
 /*********************************************************************
- *                  _ltoa   (CRTDLL.179)
+ *                  _ltoa       (CRTDLL.179)
  */
 LPSTR  CDECL CRTDLL__ltoa(long x,LPSTR buf,INT radix)
@@ -785 +784 @@
 
 /*********************************************************************
- *                  _matherr    (CRTDLL.181)
+ *                  _matherr    (CRTDLL.181)
  */
 double CDECL CRTDLL__matherr( struct exception * excep )
@@ -882 +881 @@
 
 /*********************************************************************
- *           CRTDLL__searchenv   (CRTDLL.260)
+ *           CRTDLL__searchenv   (CRTDLL.260)
  */
 void CDECL CRTDLL__searchenv(char *file, char *var,char *path )
@@ -892 +891 @@
 
 /*********************************************************************
- *           CRTDLL__seterrormode    (CRTDLL.261)
+ *           CRTDLL__seterrormode        (CRTDLL.261)
  */
 void CDECL CRTDLL__seterrormode(int uMode)
@@ -903 +902 @@
 
 /*********************************************************************
- *           CRTDLL__setjmp      (CRTDLL.262)
+ *           CRTDLL__setjmp      (CRTDLL.262)
  */
 int CDECL CRTDLL__setjmp( jmp_buf env )
@@ -938 +937 @@
 
 /*********************************************************************
- *  _sopen                  (CRTDLL.268)
+ *      _sopen                                  (CRTDLL.268)
  */
 int CDECL CRTDLL__sopen( const char *s, int i1, int i2, va_list arg )
@@ -948 +947 @@
 
 /*********************************************************************
- *           CRTDLL__spawnl      (CRTDLL.269)
+ *           CRTDLL__spawnl      (CRTDLL.269)
  */
 int CDECL CRTDLL__spawnl(int nMode, char* szPath, char* szArgv0, va_list arg)
@@ -958 +957 @@
 
 /*********************************************************************
- *           CRTDLL__spawnle     (CRTDLL.270)
+ *           CRTDLL__spawnle     (CRTDLL.270)
  */
 int CDECL CRTDLL__spawnle( int mode, char *path, char **szArgv0, va_list arg )
@@ -968 +967 @@
 
 /*********************************************************************
- *           CRTDLL__spawnlp     (CRTDLL.271)
+ *           CRTDLL__spawnlp     (CRTDLL.271)
  */
 int CDECL CRTDLL__spawnlp(int nMode, char* szPath, char* szArgv0, va_list arg)
@@ -978 +977 @@
 
 /*********************************************************************
- *           CRTDLL__spawnlpe    (CRTDLL.272)
+ *           CRTDLL__spawnlpe    (CRTDLL.272)
  */
 int CDECL CRTDLL__spawnlpe( int mode, char *path, char *szArgv0, va_list arg )
@@ -988 +987 @@
 
 /*********************************************************************
- *           CRTDLL__spawnv      (CRTDLL.273)
+ *           CRTDLL__spawnv      (CRTDLL.273)
  */
 int CDECL CRTDLL__spawnv( int i, char *s1, char ** s2 )
@@ -998 +997 @@
 
 /*********************************************************************
- *           CRTDLL__spawnvp     (CRTDLL.275)
+ *           CRTDLL__spawnvp     (CRTDLL.275)
  */
 int CDECL CRTDLL__spawnvp( int i, char *s1, char ** s2 )
@@ -1007 +1006 @@
 
 /*********************************************************************
- *           CRTDLL__spawnv      (CRTDLL.276)
+ *           CRTDLL__spawnv      (CRTDLL.276)
  */
 int CDECL CRTDLL__spawnvpe( int i, char *s1, char ** s2, char ** s3 )
@@ -1017 +1016 @@
 
 /*********************************************************************
- *           CRTDLL__statusfp    (CRTDLL.279)
+ *           CRTDLL__statusfp    (CRTDLL.279)
  */
 unsigned int CDECL CRTDLL__statusfp( void )
@@ -1024 +1023 @@
   return (_status87());
 }
-
-
-/*********************************************************************
- *           _ultoa      (CRTDLL.309)
+        
+
+/*********************************************************************
+ *           _ultoa              (CRTDLL.309)
  */
 LPSTR  CDECL CRTDLL__ultoa(long x,LPSTR buf,INT radix)
@@ -1037 +1036 @@
 
 /*********************************************************************
- *           CRTDLL__ungetch     (CRTDLL.311)
+ *           CRTDLL__ungetch     (CRTDLL.311)
  */
 int CDECL CRTDLL__ungetch( int i )
@@ -1047 +1046 @@
 
 /*********************************************************************
- *           _utime      (CRTDLL.314)
+ *           _utime              (CRTDLL.314)
  */
 int CDECL CRTDLL__utime( char *path, struct utimbuf * times )
@@ -1057 +1056 @@
 
 /*********************************************************************
- *  _vsnprintf              (CRTDLL.315)
+ *      _vsnprintf                              (CRTDLL.315)
  */
 int CDECL CRTDLL__vsnprintf( char *s, size_t bufsize, const char *format, va_list arg )
@@ -1101 +1100 @@
 
 /*********************************************************************
- *                  abs     (CRTDLL.336)
+ *                  abs         (CRTDLL.336)
  */
 double CDECL CRTDLL_abs(double d)
@@ -1113 +1112 @@
 
 /*********************************************************************
- *                  acos    (CRTDLL.337)
+ *                  acos        (CRTDLL.337)
  */
 double CDECL CRTDLL_acos( double x )
@@ -1123 +1122 @@
 
 /*********************************************************************
- *                  asctime (CRTDLL.338)
+ *                  asctime     (CRTDLL.338)
  */
 char * CDECL CRTDLL_asctime( const struct tm *timeptr )
@@ -1133 +1132 @@
 
 /*********************************************************************
- *                  asin    (CRTDLL.339)
+ *                  asin        (CRTDLL.339)
  */
 double CDECL CRTDLL_asin( double x )
@@ -1143 +1142 @@
 
 /*********************************************************************
- *                  atan    (CRTDLL.340)
+ *                  atan        (CRTDLL.340)
  */
 double CDECL CRTDLL_atan(double d)
@@ -1155 +1154 @@
 
 /*********************************************************************
- *                  atan2   (CRTDLL.341)
+ *                  atan2       (CRTDLL.341)
  */
 double CDECL CRTDLL_atan2( double y, double x )
@@ -1165 +1164 @@
 
 /*********************************************************************
- *                  atof    (CRTDLL.343)
+ *                  atof        (CRTDLL.343)
  */
 double CDECL CRTDLL_atof( const char *nptr )
@@ -1175 +1174 @@
 
 /*********************************************************************
- *                  atoi    (CRTDLL.344)
+ *                  atoi        (CRTDLL.344)
  */
 int CDECL CRTDLL_atoi(LPSTR str)
@@ -1187 +1186 @@
 
 /*********************************************************************
- *                  atol    (CRTDLL.345)
+ *                  atol        (CRTDLL.345)
  */
 long CDECL CRTDLL_atol(LPSTR str)
@@ -1199 +1198 @@
 
 /*********************************************************************
- *                  bsearch (CRTDLL.346)
+ *                  bsearch     (CRTDLL.346)
  */
 void *CDECL CRTDLL_bsearch (const void *key, const void *base, size_t num, size_t width,
@@ -1206 +1205 @@
   int left, right, median, sign;
   const void *element;
-
+  
   if (width == 0)
     return 0;
@@ -1227 +1226 @@
 
 /*********************************************************************
- *                  ceil    (CRTDLL.348)
+ *                  ceil        (CRTDLL.348)
  */
 double CDECL CRTDLL_ceil(double d)
@@ -1238 +1237 @@
 
 /*********************************************************************
- *                  clock   (CRTDLL.350)
+ *                  clock       (CRTDLL.350)
  */
 clock_t CDECL CRTDLL_clock( void )
@@ -1248 +1247 @@
 
 /*********************************************************************
- *                  cos     (CRTDLL.351)
+ *                  cos         (CRTDLL.351)
  */
 double CDECL CRTDLL_cos(double d)
@@ -1260 +1259 @@
 
 /*********************************************************************
- *                  cosh    (CRTDLL.352)
+ *                  cosh        (CRTDLL.352)
  */
 double CDECL CRTDLL_cosh( double x )
@@ -1270 +1269 @@
 
 /*********************************************************************
- *                  ctime   (CRTDLL.353)
+ *                  ctime       (CRTDLL.353)
  */
 char * CDECL CRTDLL_ctime( const time_t *timer )
@@ -1280 +1279 @@
 
 /*********************************************************************
- *                  difftime    (CRTDLL.354)
+ *                  difftime    (CRTDLL.354)
  */
 double CDECL CRTDLL_difftime( time_t t1, time_t t0 )
@@ -1290 +1289 @@
 
 /*********************************************************************
- *                  div     (CRTDLL.355)
+ *                  div         (CRTDLL.355)
  */
 ULONG CDECL CRTDLL_div( int number, int denom )
@@ -1304 +1303 @@
 
 /*********************************************************************
- *                  exp     (CRTDLL.357)
+ *                  exp         (CRTDLL.357)
  */
 double CDECL CRTDLL_exp( double x )
@@ -1314 +1313 @@
 
 /*********************************************************************
- *                  fabs    (CRTDLL.358)
+ *                  fabs        (CRTDLL.358)
  */
 double CDECL CRTDLL_fabs(double d)
@@ -1326 +1325 @@
 
 /*********************************************************************
- *                  floor       (CRTDLL.367)
+ *                  floor               (CRTDLL.367)
  */
 double CDECL CRTDLL_floor(double d)
@@ -1338 +1337 @@
 
 /*********************************************************************
- *                  fmod    (CRTDLL.368)
+ *                  fmod        (CRTDLL.368)
  */
 double CDECL CRTDLL_fmod(double x, double y )
@@ -1348 +1347 @@
 
 /*********************************************************************
- *                  frexp     (CRTDLL.377)
+ *                  frexp         (CRTDLL.377)
  */
 double CDECL CRTDLL_frexp( double value, int *exp )
@@ -1490 +1489 @@
 
 /*********************************************************************
- *                  labs    (CRTDLL.416)
+ *                  labs        (CRTDLL.416)
  */
 long int CDECL CRTDLL_labs( long int j )
@@ -1500 +1499 @@
 
 /*********************************************************************
- *                  ldexp   (CRTDLL.417)
- */
-double CDECL CRTDLL_ldexp( double x, int exp )
+ *                  ldexp       (CRTDLL.417)
+ */
+double CDECL CRTDLL_ldexp( double x, int exp ) 
 {
   dprintf2(("CRTDLL: ldexp\n"));
@@ -1510 +1509 @@
 
 /*********************************************************************
- *                  ldiv    (CRTDLL.418)
- */
-ldiv_t CDECL CRTDLL_ldiv( long int numer, long int denom )
+ *                  ldiv        (CRTDLL.418)
+ */
+ldiv_t CDECL CRTDLL_ldiv( long int numer, long int denom ) 
 {
   dprintf2(("CRTDLL: ldiv\n"));
@@ -1520 +1519 @@
 
 /*********************************************************************
- *                  localeconv  (CRTDLL.419)
+ *                  localeconv  (CRTDLL.419)
  */
 struct lconv * CDECL CRTDLL_localeconv(void)
@@ -1530 +1529 @@
 
 /*********************************************************************
- *                  localtime   (CRTDLL.420)
+ *                  localtime   (CRTDLL.420)
  */
 struct tm * CDECL CRTDLL_localtime( const time_t *timer )
@@ -1540 +1539 @@
 
 /*********************************************************************
- *                  log     (CRTDLL.421)
+ *                  log         (CRTDLL.421)
  */
 double CDECL CRTDLL_log( double x )
@@ -1550 +1549 @@
 
 /*********************************************************************
- *                  log10   (CRTDLL.422)
+ *                  log10       (CRTDLL.422)
  */
 double CDECL CRTDLL_log10( double x )
@@ -1582 +1581 @@
  *                  pow      (CRTDLL.436)
  */
-double CDECL CRTDLL_pow( double x, double y )
+double CDECL CRTDLL_pow( double x, double y )   
 {
     dprintf2(("CRTDLL: pow(%08xh, %08xh)\n",x, y));
@@ -1622 +1621 @@
 
 /*********************************************************************
- *  scanf                   (CRTDLL.448)
+ *      scanf                                   (CRTDLL.448)
  */
 int CDECL CRTDLL_scanf( const char *format, va_list arg )
@@ -1706 +1705 @@
 
 /*********************************************************************
- *  sscanf                  (CRTDLL.458)
+ *      sscanf                                  (CRTDLL.458)
  */
 int CDECL CRTDLL_sscanf( const char *s, const char *format, va_list arg )
@@ -1783 +1782 @@
 
 /*********************************************************************
- *  ungetc                  (CRTDLL.492)
+ *      ungetc                                  (CRTDLL.492)
  */
 INT CDECL CRTDLL_ungetc(int c, FILE *f)
@@ -1813 +1812 @@
 
 /*********************************************************************
- *           CRTDLL__setjmp3     (CRTDLL.600)
+ *           CRTDLL__setjmp3     (CRTDLL.600)
  */
 int CDECL CRTDLL__setjmp3( jmp_buf env )

trunk/src/crtdll/crtdll_main.c

@@ -1 @@
-/* $Id: crtdll_main.c,v 1.2 2001-09-05 12:14:24 bird Exp $ */
 /*
  * The C RunTime DLL
- *
+ * 
  * Implements C run-time functionality as known from UNIX.
  *
@@ -14 +13 @@
 Unresolved issues Uwe Bonnes 970904:
 - tested with ftp://ftp.remcomp.com/pub/remcomp/lcc-win32.zip, a C-Compiler
-        for Win32, based on lcc, from Jacob Navia
+                for Win32, based on lcc, from Jacob Navia
 UB 000416:
 - probably not thread safe
 */
 
-/* NOTE: This file also implements the wcs* functions. They _ARE_ in
+/* NOTE: This file also implements the wcs* functions. They _ARE_ in 
  * the newer Linux libcs, but use 4 byte wide characters, so are unusable,
  * since we need 2 byte wide characters. - Marcus Meissner, 981031
@@ -64 +63 @@
 UINT CRTDLL_winminor_dll;     /* CRTDLL.330 */
 UINT CRTDLL_winver_dll;       /* CRTDLL.331 */
-INT  CRTDLL_doserrno = 0;
+INT  CRTDLL_doserrno = 0; 
 INT  CRTDLL_errno = 0;
 const INT  CRTDLL__sys_nerr = 43;
@@ -78 +77 @@
  *                  CRTDLL_MainInit  (CRTDLL.init)
  */
-
+ 
 BOOL WINAPI CRTDLL_Init(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 {
   FS_OS2
-
+    
     // call i/o initializer in file.c
-    if (fdwReason == DLL_PROCESS_ATTACH)
+    if (fdwReason == DLL_PROCESS_ATTACH) 
     {
       __CRTDLL__init_io();
     }
-
+    
   /*
     PH 2000/11/21 this code doesn't look very useful
-
+    
     if (fdwReason == DLL_PROCESS_ATTACH) {
       _fdopen(0,"r");
@@ -104 +103 @@
       }
   */
-
+  
   FS_WIN32
   return TRUE;
@@ -177 +176 @@
         char *cmdline;
         char  **xargv;
-    int xargc,end,last_arg,afterlastspace;
-    DWORD   version;
-
-    TRACE("(%p,%p,%p,%ld).\n",
-        argc,argv,environ,flag
-    );
-
-    if (CRTDLL_acmdln_dll != NULL)
-        HeapFree(GetProcessHeap(), 0, CRTDLL_acmdln_dll);
-
-    CRTDLL_acmdln_dll = cmdline = CRTDLL__strdup( GetCommandLineA() );
-    TRACE("got '%s'\n", cmdline);
-
-    version = GetVersion();
-    CRTDLL_osver_dll       = version >> 16;
-    CRTDLL_winminor_dll    = version & 0xFF;
-    CRTDLL_winmajor_dll    = (version>>8) & 0xFF;
-    CRTDLL_baseversion_dll = version >> 16;
-    CRTDLL_winver_dll      = ((version >> 8) & 0xFF) + ((version & 0xFF) << 8);
-    CRTDLL_baseminor_dll   = (version >> 16) & 0xFF;
-    CRTDLL_basemajor_dll   = (version >> 24) & 0xFF;
-    CRTDLL_osversion_dll   = version & 0xFFFF;
-    CRTDLL_osminor_dll     = version & 0xFF;
-    CRTDLL_osmajor_dll     = (version>>8) & 0xFF;
-
-    /* missing threading init */
-
-    end=0;last_arg=0;xargv=NULL;xargc=0;afterlastspace=0;
-    while (1)
-    {
-        if ((cmdline[end]==' ') || (cmdline[end]=='\0'))
-        {
-        if (cmdline[end]=='\0')
-            last_arg=1;
-        else
-            cmdline[end]='\0';
-        /* alloc xargc + NULL entry */
-            xargv=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv,
-                                     sizeof(char*)*(xargc+1));
-        if (strlen(cmdline+afterlastspace))
-        {
-            xargv[xargc] = CRTDLL__strdup(cmdline+afterlastspace);
-            xargc++;
+        int     xargc,end,last_arg,afterlastspace;
+        DWORD   version;
+
+        TRACE("(%p,%p,%p,%ld).\n",
+                argc,argv,environ,flag
+        );
+
+        if (CRTDLL_acmdln_dll != NULL)
+                HeapFree(GetProcessHeap(), 0, CRTDLL_acmdln_dll);
+
+        CRTDLL_acmdln_dll = cmdline = CRTDLL__strdup( GetCommandLineA() );
+        TRACE("got '%s'\n", cmdline);
+
+        version = GetVersion();
+        CRTDLL_osver_dll       = version >> 16;
+        CRTDLL_winminor_dll    = version & 0xFF;
+        CRTDLL_winmajor_dll    = (version>>8) & 0xFF;
+        CRTDLL_baseversion_dll = version >> 16;
+        CRTDLL_winver_dll      = ((version >> 8) & 0xFF) + ((version & 0xFF) << 8);
+        CRTDLL_baseminor_dll   = (version >> 16) & 0xFF;
+        CRTDLL_basemajor_dll   = (version >> 24) & 0xFF;
+        CRTDLL_osversion_dll   = version & 0xFFFF;
+        CRTDLL_osminor_dll     = version & 0xFF;
+        CRTDLL_osmajor_dll     = (version>>8) & 0xFF;
+
+        /* missing threading init */
+
+        end=0;last_arg=0;xargv=NULL;xargc=0;afterlastspace=0;
+        while (1)
+        {
+            if ((cmdline[end]==' ') || (cmdline[end]=='\0'))
+            {
+                if (cmdline[end]=='\0')
+                    last_arg=1;
+                else
+                    cmdline[end]='\0';
+                /* alloc xargc + NULL entry */
+                        xargv=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv,
+                                             sizeof(char*)*(xargc+1));
+                if (strlen(cmdline+afterlastspace))
+                {
+                    xargv[xargc] = CRTDLL__strdup(cmdline+afterlastspace);
+                    xargc++;
                     if (!last_arg) /* need to seek to the next arg ? */
-            {
-            end++;
-            while (cmdline[end]==' ')
-                end++;
-    }
-            afterlastspace=end;
-        }
-        else
-        {
-            xargv[xargc] = NULL; /* the last entry is NULL */
-            break;
-        }
-        }
-        else
-        end++;
-    }
-    CRTDLL_argc_dll = xargc;
-    *argc       = xargc;
-    CRTDLL_argv_dll = xargv;
-    *argv       = xargv;
-
-    TRACE("found %d arguments\n",
-        CRTDLL_argc_dll);
-    CRTDLL_environ_dll = *environ = GetEnvironmentStringsA();
-    return environ;
+                    {
+                        end++;
+                        while (cmdline[end]==' ')
+                            end++;
+        }
+                    afterlastspace=end;
+                }
+                else
+                {
+                    xargv[xargc] = NULL; /* the last entry is NULL */
+                    break;
+                }
+            }
+            else
+                end++;
+        }
+        CRTDLL_argc_dll = xargc;
+        *argc           = xargc;
+        CRTDLL_argv_dll = xargv;
+        *argv           = xargv;
+
+        TRACE("found %d arguments\n",
+                CRTDLL_argc_dll);
+        CRTDLL_environ_dll = *environ = GetEnvironmentStringsA();
+        return environ;
 }
 
@@ -254 +253 @@
 DWORD CDECL CRTDLL__initterm(_INITTERMFUN *start,_INITTERMFUN *end)
 {
-    _INITTERMFUN    *current;
-
-    TRACE("(%p,%p)\n",start,end);
-    current=start;
-    while (current<end) {
-        if (*current) (*current)();
-        current++;
-    }
-    return 0;
+        _INITTERMFUN    *current;
+
+        TRACE("(%p,%p)\n",start,end);
+        current=start;
+        while (current<end) {
+                if (*current) (*current)();
+                current++;
+        }
+        return 0;
 }
 
@@ -310 +309 @@
 INT CDECL CRTDLL_rand()
 {
-    return (rand() & CRTDLL_RAND_MAX);
+    return (rand() & CRTDLL_RAND_MAX); 
 }
 
@@ -320 +319 @@
 {
   // return (_rotl(value, shift));
-
+  
     shift &= 31;
     return (x << shift) | (x >> (32-shift));
@@ -332 +331 @@
 {
   // return (_lrotl(value, shift));
-
+  
     shift &= 31;
     return (x << shift) | (x >> (32-shift));
@@ -344 +343 @@
 {
   // return (_lrotr(value, shift));
-
+  
     shift &= 0x1f;
     return (x >> shift) | (x << (32-shift));
@@ -356 +355 @@
 {
   // return (_rotr(value, shift));
-
+  
     shift &= 0x1f;
     return (x >> shift) | (x << (32-shift));
@@ -368 +367 @@
 {
   // return (vswprintf(s, t, format, arg));
-
+  
     return wvsprintfW( buffer, spec, args );
 }
@@ -389 +388 @@
 {
   return (setlocale(category, locale));
-
+  
   /*
     LPSTR categorystr;
@@ -438 +437 @@
 {
   // return (_fullpath(buf, path, size));
-
+  
   if (!buf)
   {
@@ -456 +455 @@
 {
   // _splitpath( path, drive, dir, fname, ext);
-
+  
   /* drive includes :
      directory includes leading and trailing (forward and backward slashes)
@@ -520 +519 @@
 {
   // _makepath(path, drive, dir, fname, ext);
-
+  
     char ch;
     TRACE("CRTDLL__makepath got %s %s %s %s\n", drive, directory,
@@ -568 +567 @@
 {
   // return (_errno());
-
+  
   return &CRTDLL_errno;
 }
@@ -575 +574 @@
 /*********************************************************************
  *                  __doserrno       (CRTDLL.26)
- *
+ * 
  * Return the address of the DOS errno (holding the last OS error).
  * @@@PH Note: veeeery strange ...
@@ -584 +583 @@
 {
   // return (__doserrno());
-
+  
   return &CRTDLL_doserrno;
 }
@@ -602 +601 @@
 {
   // return (_strerror((char*)s));
-
+  
   static char strerrbuff[256];
   sprintf(strerrbuff,"%s: %s\n",err,CRTDLL_strerror(CRTDLL_errno));
@@ -617 +616 @@
 {
   // perror( s );
-
+  
   char *err_str = CRTDLL_strerror(CRTDLL_errno);
   CRTDLL_fprintf(CRTDLL_stderr,"%s: %s\n",err,err_str);
   CRTDLL_free(err_str);
 }
-
+ 
 
 /*********************************************************************
@@ -632 +631 @@
  * The caller does not own the string returned.
  */
-extern char *strerror(int errnum);
+extern char *strerror(int errnum); 
 
 LPSTR CDECL CRTDLL_strerror (INT err)
@@ -646 +645 @@
 {
   //return (signal(sig, ptr));
-
+  
   FIXME("(%d %p):stub.\n", sig, ptr);
   return (void*)-1;
@@ -668 +667 @@
 {
   // return (getenv(name));
-
+  
      LPSTR environ = GetEnvironmentStringsA();
      LPSTR pp,pos = NULL;
@@ -675 +674 @@
      for (pp = environ; (*pp); pp = pp + strlen(pp) +1)
        {
-     pos =strchr(pp,'=');
-     if (pos)
-       length = pos -pp;
-     else
-       length = strlen(pp);
-     if (!strncmp(pp,name,length)) break;
+         pos =strchr(pp,'=');
+         if (pos)
+           length = pos -pp;
+         else
+           length = strlen(pp);
+         if (!strncmp(pp,name,length)) break;
        }
-     if ((pp)&& (pos))
+     if ((pp)&& (pos)) 
        {
-     pp = pos+1;
-     TRACE("got %s\n",pp);
+         pp = pos+1;
+         TRACE("got %s\n",pp);
        }
      FreeEnvironmentStringsA( environ );
@@ -696 +695 @@
  */
 INT CDECL CRTDLL__except_handler2 (
-    PEXCEPTION_RECORD rec,
-    PEXCEPTION_FRAME frame,
-    PCONTEXT context,
-    PEXCEPTION_FRAME  *dispatcher)
-{
-    FIXME ("exception %lx flags=%lx at %p handler=%p %p %p stub\n",
-    rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress,
-    frame->Handler, context, dispatcher);
-    return ExceptionContinueSearch;
+        PEXCEPTION_RECORD rec,
+        PEXCEPTION_FRAME frame,
+        PCONTEXT context,
+        PEXCEPTION_FRAME  *dispatcher)
+{
+        FIXME ("exception %lx flags=%lx at %p handler=%p %p %p stub\n",
+        rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress,
+        frame->Handler, context, dispatcher);
+        return ExceptionContinueSearch;
 }
 
@@ -725 +724 @@
 {
   // return (_toascii(c));
-
+  
   return c & 0x7f;
 }
@@ -755 +754 @@
 {
   // return (_iscsym(c));
-
+  
   return (isalnum(c) || c == '_');
 }
@@ -774 +773 @@
 {
   // return (_iscsymf(c));
-
+  
   return (isalpha(c) || c == '_');
 }
@@ -847 +846 @@
     {
       if (cf((LPVOID*)match, (LPVOID*)pStart) == 0)
-    return pStart; /* found */
+        return pStart; /* found */
       pStart += elem_size;
     } while (--size);
@@ -915 +914 @@
 {
   // return (_toupper(n));
-
+  
   return toupper(c);
 }
@@ -926 +925 @@
 {
   // return (_tolower(n));
-
+  
   return tolower(c);
 }
@@ -947 +946 @@
 {
   // return (_cabs(c));
-
+  
   return sqrt(c.real * c.real + c.imaginary * c.imaginary);
 }
@@ -1007 +1006 @@
  *
  * Reset the state of the floating point processor.
- *
+ * 
  * PARAMS
  *   None.

trunk/src/crtdll/dir.c

@@ -1 @@
-/* $Id: dir.c,v 1.5 2001-09-05 12:14:24 bird Exp $ */
 /*
  * CRTDLL drive/directory functions
- *
+ * 
  * Copyright 1996,1998 Marcus Meissner
  * Copyright 1996 Jukka Iivonen
@@ -58 +57 @@
  * RETURNS
  * Sucess:  0
- *
+ * 
  * Failure: -1
  */
@@ -65 +64 @@
   dprintf(("CRTDLL: _chdir(%s)\n",
           newdir));
-
+  
   if (!SetCurrentDirectoryA(newdir))
   {
@@ -85 +84 @@
  * RETURNS
  * Sucess:  0
- *
- * Failure: 1
+ * 
+ * Failure: 1 
  */
 BOOL CDECL CRTDLL__chdrive(INT newdrive)
@@ -92 +91 @@
   char buffer[3] = "A:";
   buffer[0] += newdrive - 1;
-
+  
   dprintf(("CRTDLL: _chdrive(%s)\n",
           buffer));
-
+  
   if (!SetCurrentDirectoryA( buffer ))
   {
@@ -109 +108 @@
 /*********************************************************************
  *                  _findclose     (CRTDLL.098)
- *
+ * 
  * Free the resources from a search handle created from _findfirst.
  *
@@ -124 +123 @@
   dprintf(("CRTDLL: _findclose(%08xh)\n",
           hand));
-
+  
   if (!FindClose((HANDLE)hand))
   {
@@ -142 +141 @@
  * PARAMS
  *   fspec [in]  File specification string for search, e.g "C:\*.BAT"
- *
+ * 
  *   ft [out]    A pointer to a find_t structure to populate.
  *
@@ -156 +155 @@
   WIN32_FIND_DATAA find_data;
   HANDLE hfind;
-
+  
   dprintf(("CRTDLL: _findfirst(%s)\n",
           fspec));
@@ -174 +173 @@
 /*********************************************************************
  *                  _findnext     (CRTDLL.100)
- *
+ * 
  * Return the next matching file/directory from a search hadle.
  *
  * PARAMS
  *   hand [in] Search handle from a pervious call to _findfirst
- *
+ * 
  *   ft [out]  A pointer to a find_t structure to populate.
  *
@@ -191 +190 @@
 {
   WIN32_FIND_DATAA find_data;
-
+  
   dprintf(("CRTDLL: _findnext(%08xh)\n",
           hand));
-
+  
   if (!FindNextFileA(hand, &find_data))
   {
@@ -225 +224 @@
 {
   // return (_getcwd(buf, size));
-
+  
   char dir[_MAX_PATH];
   int dir_len = GetCurrentDirectoryA(_MAX_PATH,dir);
-
+  
   dprintf(("CRTDLL: _getcwd()\n"));
-
+  
   if (dir_len < 1)
     return NULL; /* FIXME: Real return value untested */
@@ -259 +258 @@
 {
   // return (_getdcwd(drive, buffer, maxlen));
-
+  
   static CHAR* dummy;
-
+  
   dprintf(("CRTDLL: _getdcwd()\n"));
-
+  
   if (!drive || drive == CRTDLL__getdrive())
     return CRTDLL__getcwd(buf,size); /* current */
@@ -306 +305 @@
   DWORD ret[4];
   UINT err;
-
+  
   dprintf(("CRTDLL: _getdiskfree(%08xh)\n", disk));
-
+  
   if (disk > 26)
     return ERROR_INVALID_PARAMETER; /* CRTDLL doesn't set errno here */
@@ -336 +335 @@
 {
   // return DRIVE_GetCurrentDrive() + 1;
-
+  
   char buffer[MAX_PATH];
-
+  
   dprintf(("CRTDLL: _getdrive()\n"));
 
-  if (!GetCurrentDirectoryA( sizeof(buffer), buffer ))
-    return 0;
-  if (buffer[1] != ':')
+  if (!GetCurrentDirectoryA( sizeof(buffer), buffer )) 
+    return 0;
+  if (buffer[1] != ':') 
     return 0;
   return toupper(buffer[0]) - 'A' + 1;
@@ -358 +357 @@
   dprintf(("CRTDLL: _mkdir(%s)\n",
           newdir));
-
+  
   if (CreateDirectoryA(newdir,NULL))
     return 0;
@@ -369 +368 @@
  *                  _rmdir           (CRTDLL.255)
  *
- * Delete a directory
+ * Delete a directory 
  *
  */
@@ -376 +375 @@
   dprintf(("CRTDLL: _rmdir(%s)\n",
           dir));
-
+  
   if (RemoveDirectoryA(dir))
     return 0;

trunk/src/crtdll/exit.c

@@ -1 @@
-/* $Id: exit.c,v 1.2 2001-09-05 12:14:24 bird Exp $ */
 /*
  * CRTDLL exit/abort/atexit functions
- *
+ * 
  * Copyright 1996,1998 Marcus Meissner
  * Copyright 1996 Jukka Iivonen
@@ -11 +10 @@
  * and whether they return to the caller (really!).
  *            return      do
- *  Name      to caller?  cleanup?
+ *  Name      to caller?  cleanup? 
  *  _c_exit     Y           N
  *  _cexit      Y           Y
@@ -55 +54 @@
 
 /*********************************************************************
- *  __dllonexit                     (CRTDLL.25)
+ *      __dllonexit                             (CRTDLL.25)
  */
 VOID CDECL CRTDLL___dllonexit ()
-{
+{       
   dprintf(("__dllonexit not implemented.\n"));
   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
@@ -65 +64 @@
 
 /*********************************************************************
- *  _abnormal_termination           (CRTDLL.36)
+ *      _abnormal_termination                   (CRTDLL.36)
  */
 int CDECL CRTDLL__abnormal_termination(void)
@@ -84 +83 @@
 {
   dprintf2(("CRTDLL: _amsg_exit\n"));
-
+  
   // fprintf(stderr,strerror(errnum));
   // ExitProcess(-1);
-
+  
   CRTDLL_fprintf(CRTDLL_stderr,"\nrun-time error:\nError Code %d\n",errnum);
   CRTDLL__exit(255);
@@ -96 +95 @@
  *                  _assert     (CRTDLL.041)
  *
- * Print an assertion message and call abort(). Really only present
+ * Print an assertion message and call abort(). Really only present 
  * for win binaries. Winelib programs would typically use libc's
  * version.
@@ -103 +102 @@
 {
   dprintf2(("CRTDLL: _assert\n"));
-
+  
   CRTDLL_fprintf(CRTDLL_stderr,"Assertion failed: %s, file %s, line %d\n\n",
                  (char*)str,(char*)file, line);
   CRTDLL_abort();
-
+  
   // _assert(str, file, line);
 }
@@ -120 +119 @@
   dprintf2(("_c_exit(%d)\n",ret));
   FIXME("not calling CRTDLL cleanup\n");
-
+  
   /* dont exit, return to caller */
-
+  
   ExitProcess(ret);
 }
@@ -136 +135 @@
   FIXME("not calling CRTDLL cleanup\n");
   /* dont exit, return to caller */
-
+  
   ExitProcess(ret);
 }
@@ -146 +145 @@
 VOID CDECL CRTDLL__exit(LONG ret)
 {
-  dprintf2(("CRTDLL: _exit (%08xh)\n",
+  dprintf2(("CRTDLL: _exit (%08xh)\n", 
             ret));
   TRACE(":exit code %ld\n",ret);
@@ -200 +199 @@
 {
   dprintf2(("CRTDLL: abort\n"));
-
+  
   CRTDLL_fprintf(CRTDLL_stderr,"\nabnormal program termination\n");
   CRTDLL__exit(3);
@@ -208 +207 @@
 
 /*********************************************************************
- *                  atexit  (CRTDLL.342)
+ *                  atexit      (CRTDLL.342)
  *
  * Register a function to be called when the process terminates.
@@ -215 +214 @@
 {
   dprintf(("CRTDLL: atexit\n"));
-
+  
   return CRTDLL__onexit(func) == func ? 0 : -1;
-
+  
   // if (_atexit_n >= sizeof (_atexit_v) / sizeof (_atexit_v[0]))
   //   return -1;

trunk/src/crtdll/file.c

@@ -1 @@
-/* $Id: file.c,v 1.3 2001-09-05 12:14:24 bird Exp $ */
 /*
  * CRTDLL file functions
- *
+ * 
  * Copyright 1996,1998 Marcus Meissner
  * Copyright 1996 Jukka Iivonen
@@ -9 +8 @@
  *
  * Implementation Notes:
- * Mapping is performed between FILE*, fd and HANDLE's. This allows us to
- * implement all calls using the Win32 API, support remapping fd's to
+ * Mapping is performed between FILE*, fd and HANDLE's. This allows us to 
+ * implement all calls using the Win32 API, support remapping fd's to 
  * FILES and do some other tricks as well (like closeall, _get_osfhandle).
  * For mix and matching with the host libc, processes can use the Win32 HANDLE
@@ -129 +128 @@
   else
     while(__CRTDLL_fdstart < __CRTDLL_fdend &&
-      __CRTDLL_handles[__CRTDLL_fdstart] != INVALID_HANDLE_VALUE)
+          __CRTDLL_handles[__CRTDLL_fdstart] != INVALID_HANDLE_VALUE)
       __CRTDLL_fdstart++;
 
@@ -144 +143 @@
 {
   TRACE(":fd (%d) allocating FILE*\n",fd);
-  if (fd < 0 || fd >= __CRTDLL_fdend ||
+  if (fd < 0 || fd >= __CRTDLL_fdend || 
       __CRTDLL_handles[fd] == INVALID_HANDLE_VALUE)
   {
@@ -179 +178 @@
 
   TRACE(":handles (%d)(%d)(%d)\n",__CRTDLL_handles[0],
-    __CRTDLL_handles[1],__CRTDLL_handles[2]);
+        __CRTDLL_handles[1],__CRTDLL_handles[2]);
 
   for (i = 0; i < 3; i++)
@@ -196 +195 @@
 {
   // return (_access(path, mode));
-
+  
   DWORD attr = GetFileAttributesA(filename);
 
@@ -203 +202 @@
     if (!filename)
     {
-    /* FIXME: Should GetFileAttributesA() return this? */
+        /* FIXME: Should GetFileAttributesA() return this? */
       __CRTDLL__set_errno(ERROR_INVALID_DATA);
       return -1;
@@ -304 +303 @@
 {
   // return (__eof(_fd));
-
+  
   DWORD curpos,endpos;
   HANDLE hand = __CRTDLL__fdtoh(fd);
@@ -339 +338 @@
 {
   // return (_fcloseall());
-
+  
   int num_closed = 0, i = 3;
 
@@ -362 +361 @@
 {
   // return (_fdopen(handle, mode));
-
+  
   CRTDLL_FILE* file = __CRTDLL__alloc_fp(fd);
 
@@ -379 +378 @@
 {
   // return (_fgetchar());
-
+  
   return CRTDLL_fgetc(CRTDLL_stdin);
 }
@@ -391 +390 @@
  * becomes negative. We ensure that _cnt is always 0 after any read
  * so this function is always called. Our implementation simply calls
- * fgetc as all the underlying buffering is handled by Wines
+ * fgetc as all the underlying buffering is handled by Wines 
  * implementation of the Win32 file I/O calls.
  */
@@ -411 +410 @@
 {
   // return (_fileno(f));
-
+  
   TRACE(":FILE* (%p) fd (%d)\n",file,file->_file);
   return file->_file;
@@ -441 +440 @@
 {
   // return (_flushall());
-
+  
   int num_flushed = 0, i = 3;
 
@@ -448 +447 @@
     {
       if (CRTDLL__commit(i) == -1)
-    if (__CRTDLL_files[i])
-      __CRTDLL_files[i]->_flag |= _IOERR;
+        if (__CRTDLL_files[i])
+          __CRTDLL_files[i]->_flag |= _IOERR;
       num_flushed++;
     }
@@ -466 +465 @@
 {
   // return(_fputchar(c));
-
+  
   return CRTDLL_fputc(c, CRTDLL_stdout);
 }
@@ -485 +484 @@
 /*********************************************************************
  *                  _fstat        (CRTDLL.111)
- *
+ * 
  * Get information about an open file.
  */
@@ -491 +490 @@
 {
   // return (_fstat(file, buf));
-
+  
   DWORD dw;
   BY_HANDLE_FILE_INFORMATION hfi;
@@ -549 +548 @@
   {
     /* FIXME: I'm not convinced that I should be copying the
-     * handle here - it may be leaked if the app doesn't
+     * handle here - it may be leaked if the app doesn't 
      * close it (and the API docs dont say that it should)
      * Not duplicating it means that it can't be inherited
@@ -558 +557 @@
      */
     DuplicateHandle(GetCurrentProcess(),hand,GetCurrentProcess(),
-            &newhand,0,TRUE,DUPLICATE_SAME_ACCESS );
+                    &newhand,0,TRUE,DUPLICATE_SAME_ACCESS );
   }
   return newhand;
@@ -589 +588 @@
 {
   // return (_lseek(handle, offset, origin));
-
+  
   LONG ret;
   HANDLE hand = __CRTDLL__fdtoh(fd);
@@ -778 +777 @@
 {
   // return (_setmode(fh, mode));
-
+  
   if (mode & _O_TEXT)
     FIXME("fd (%d) mode (%d) TEXT not implemented\n",fd,mode);
@@ -791 +790 @@
 {
   // return(_stat(s1, n));
-
+  
   DWORD dw;
   WIN32_FILE_ATTRIBUTE_DATA hfi;
@@ -827 +826 @@
     {
       unsigned int ext = tolower(path[plen-1]) | (tolower(path[plen-2]) << 8)
-    | (tolower(path[plen-3]) << 16);
+        | (tolower(path[plen-3]) << 16);
       if (ext == EXE || ext == BAT || ext == CMD || ext == COM)
-    mode |= CRTDLL_S_IEXEC;
+        mode |= CRTDLL_S_IEXEC;
     }
   }
@@ -844 +843 @@
   buf->st_mtime = buf->st_ctime = dw;
   TRACE("\n%d %d %d %d %d %d\n", buf->st_mode,buf->st_nlink,buf->st_size,
-    buf->st_atime,buf->st_mtime, buf->st_ctime);
+        buf->st_atime,buf->st_mtime, buf->st_ctime);
   return 0;
 }
@@ -857 +856 @@
 {
   // return (_tell(i));
-
+  
   return CRTDLL__lseek(fd, 0, SEEK_CUR);
 }
@@ -864 +863 @@
 /*********************************************************************
  *                  _tempnam           (CRTDLL.305)
- *
+ * 
  */
 LPSTR CDECL CRTDLL__tempnam(LPCSTR dir, LPCSTR prefix)
 {
   // return (_tempnam(dir, prefix));
-
+  
   char tmpbuf[MAX_PATH];
 
@@ -891 +890 @@
 {
   // return (_umask(i));
-
+  
   INT old_umask = __CRTDLL_umask;
   TRACE("umask (%d)\n",umask);
@@ -977 +976 @@
 {
   // return (fclose(fp));
-
+  
   return CRTDLL__close(file->_file);
 }
@@ -990 +989 @@
 {
   // return (feof(fp));
-
+  
   return file->_flag & _IOEOF;
 }
@@ -1003 +1002 @@
 {
   // return (ferror(fp));
-
+  
   return file->_flag & _IOERR;
 }
@@ -1025 +1024 @@
 {
   // return (fgetc(fp));
-
+  
   char c;
   if (CRTDLL__read(file->_file,&c,1) != 1)
@@ -1051 +1050 @@
 {
   // return (fgets(s, n, fp));
-
+  
   int    cc;
   LPSTR  buf_start = s;
 
   TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
-    file,file->_file,s,size);
+        file,file->_file,s,size);
 
   /* BAD, for the whole WINE process blocks... just done this way to test
@@ -1089 +1088 @@
 {
   // return (fputs(s, fp));
-
+  
   return CRTDLL_fwrite(s,strlen(s),1,file);
 }
@@ -1100 +1099 @@
 {
     // return (fprintf(file, format, arg));
-
+  
     va_list valist;
     INT res;
@@ -1119 +1118 @@
 {
   // return (fopen( filename, mode));
-
+  
   CRTDLL_FILE* file;
   INT flags = 0, plus = 0, fd;
@@ -1183 +1182 @@
 {
   // return (fputc(c, fp));
-
+  
   return CRTDLL__write(file->_file, &c, 1) == 1? c : EOF;
 }
@@ -1194 +1193 @@
 {
   // return (fread(ptr, size, n, fp));
-
+  
   DWORD read = CRTDLL__read(file->_file,ptr, size * nmemb);
   if (read <= 0)
@@ -1204 +1203 @@
 /*********************************************************************
  *                  freopen    (CRTDLL.379)
- *
+ * 
  */
 CRTDLL_FILE* CDECL CRTDLL_freopen(LPCSTR path, LPCSTR mode,CRTDLL_FILE* file)
 {
   // return (freopen(filename, mode, fp));
-
+  
   CRTDLL_FILE* newfile;
   INT fd;
@@ -1257 +1256 @@
 {
   // return (fsetpos(fp, pos));
-
+  
   return CRTDLL__lseek(file->_file,*pos,SEEK_SET);
 }
@@ -1393 +1392 @@
 {
   // return (fseek(file, offset, whence));
-
+  
   return CRTDLL__lseek(file->_file,offset,whence);
 }
@@ -1404 +1403 @@
 {
   // return (ftell(fp));
-
+  
   return CRTDLL__tell(file->_file);
 }
@@ -1429 +1428 @@
 {
   // return (getchar());
-
+  
   return CRTDLL_fgetc(CRTDLL_stdin);
 }
@@ -1460 +1459 @@
      */
     for(cc = CRTDLL_fgetc(CRTDLL_stdin); cc != EOF && cc != '\n';
-    cc = CRTDLL_fgetc(CRTDLL_stdin))
-    if(cc != '\r') *buf++ = (char)cc;
+        cc = CRTDLL_fgetc(CRTDLL_stdin))
+        if(cc != '\r') *buf++ = (char)cc;
 
     *buf = '\0';
@@ -1498 +1497 @@
 {
   // return puts( s );
-
+  
   return CRTDLL_fputs(s, CRTDLL_stdout);
 }
@@ -1512 +1511 @@
 {
   // rewind(fp);
-
+  
   TRACE(":file (%p) fd (%d)\n",file,file->_file);
   CRTDLL__lseek(file->_file,0,SEEK_SET);
@@ -1525 +1524 @@
 {
   // return (remove(file));
-
+  
   TRACE(":path (%s)\n",path);
   if (DeleteFileA(path))
@@ -1541 +1540 @@
 {
   // return (rename(old, new2));
-
+  
   TRACE(":from %s to %s\n",oldpath,newpath);
   if (MoveFileExA( oldpath, newpath, MOVEFILE_REPLACE_EXISTING))
@@ -1557 +1556 @@
 {
   // setbuf(fp, buf);
-
+  
   TRACE(":file (%p) fd (%d) buf (%p)\n", file, file->_file,buf);
   if (buf)
@@ -1570 +1569 @@
  *
  * lcclnk from lcc-win32 relies on a terminating dot in the name returned
- *
+ * 
  */
 LPSTR CDECL CRTDLL_tmpnam(LPSTR s)
 {
   // return (tmpnam(s));
-
+  
   char tmpbuf[MAX_PATH];
   char* prefix = "TMP";
@@ -1600 +1599 @@
 {
   // return (vfprintf(file, format, args));
-
+  
   /* FIXME: We should parse the format string, calculate the maximum,
    * length of each arg, malloc a buffer, print to it, and fwrite that.

trunk/src/crtdll/initterm.cpp

@@ -1 @@
-/* $Id: initterm.cpp,v 1.7 2001-09-05 12:14:25 bird Exp $ */
 /*
  * DLL entry point
@@ -56 +55 @@
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
-    return CRTDLL_Init(hinstDLL, fdwReason, fImpLoad);
+        return CRTDLL_Init(hinstDLL, fdwReason, fImpLoad);
 
    case DLL_PROCESS_DETACH:
-    CRTDLL_Init(hinstDLL, fdwReason, fImpLoad);
-    ctordtorTerm();
-    return TRUE;
+        CRTDLL_Init(hinstDLL, fdwReason, fImpLoad);
+        ctordtorTerm();
+        return TRUE;
    }
    return FALSE;
@@ -91 +90 @@
          CheckVersionFromHMOD(PE2LX_VERSION, hModule); /*PLF Wed  98-03-18 05:28:48*/
 
-     dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab);
-         if(dllHandle == 0)
-        return 0UL;
+//       dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab);
+//         if(dllHandle == 0) 
+//              return 0UL;
 
          break;
       case 1 :
-         if(dllHandle) {
-        UnregisterLxDll(dllHandle);
-         }
+//         if(dllHandle) {
+//              UnregisterLxDll(dllHandle);
+//         }
          break;
 

trunk/src/crtdll/memory.c

@@ -1 @@
-/* $Id: memory.c,v 1.3 2001-09-05 12:14:25 bird Exp $ */
 /*
  * CRTDLL memory functions
- *
+ * 
  * Copyright 1996,1998 Marcus Meissner
  * Copyright 1996 Jukka Iivonen
@@ -33 +32 @@
     VOID* result;
     if(!(result = HeapAlloc(GetProcessHeap(),0,size)) && new_handler)
-    (*new_handler)();
+        (*new_handler)();
     return result;
 }
@@ -80 +79 @@
 {
   // return (_heapchk());
-
+  
   if (!HeapValidate( GetProcessHeap(), 0, NULL))
   {
@@ -98 +97 @@
 {
   // return (_heapmin());
-
+  
   if (!HeapCompact( GetProcessHeap(), 0 ))
   {
@@ -117 +116 @@
 {
   // return (_heapset(fill));
-
+  
   INT retVal;
   struct _heapinfo heap;
@@ -145 +144 @@
   phe.wFlags = next->_useflag == _USEDENTRY ? PROCESS_HEAP_ENTRY_BUSY : 0;
 
-  if (phe.lpData && phe.wFlags & PROCESS_HEAP_ENTRY_BUSY &&
+  if (phe.lpData && phe.wFlags & PROCESS_HEAP_ENTRY_BUSY && 
       !HeapValidate( GetProcessHeap(), 0, phe.lpData ))
   {
@@ -181 +180 @@
 {
   // return (_msize(ptr));
-
+  
   LONG size = HeapSize(GetProcessHeap(),0,mem);
   if (size == -1)
@@ -216 +215 @@
 /*********************************************************************
  *                  malloc        (CRTDLL.424)
- *
+ * 
  * Alocate memory from the heap.
  */

trunk/src/crtdll/spawn.c

@@ -1 @@
-/* $Id: spawn.c,v 1.3 2001-09-05 12:14:25 bird Exp $ */
 /*
  * CRTDLL spawn functions
- *
+ * 
  * Copyright 1996,1998 Marcus Meissner
  * Copyright 1996 Jukka Iivonen
@@ -25 +24 @@
  * Implementation Notes:
  * MT Safe - But only because of missing functionality.
- *
+ * 
  * After translating input arguments into the required format for
  * CreateProcess(), the internal function __CRTDLL__spawn() is
@@ -83 +82 @@
 
   if (!CreateProcessA(exe, args, NULL, NULL, TRUE,
-              flags == _P_DETACH ? DETACHED_PROCESS : 0,
-              env, NULL, &si, &pi))
+                      flags == _P_DETACH ? DETACHED_PROCESS : 0,
+                      env, NULL, &si, &pi))
   {
     __CRTDLL__set_errno(GetLastError());
@@ -158 +157 @@
 {
   // return (_spawnve(i, s1, s2, s3));
-
+  
   LPSTR args = __CRTDLL__argvtos(argv,' ');
   LPSTR envs = __CRTDLL__argvtos(envv,0);
@@ -187 +186 @@
 {
   // return system(string);
-
+  
     /* FIXME: should probably launch cmd interpreter in COMSPEC */
     return __CRTDLL__spawn(_P_WAIT, NULL, x, NULL);

trunk/src/msacm32/driver.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
-/* $Id: driver.c,v 1.2 2001-09-05 13:11:25 bird Exp $ */
+
 /*
  *      MSACM32 library
  *
  *      Copyright 1998  Patrik Stridvall
- *        1999  Eric Pouech
+ *                1999  Eric Pouech
  */
 
@@ -29 +29 @@
 
 DEFAULT_DEBUG_CHANNEL(msacm);
-
+        
 /***********************************************************************
  *           acmDriverAddA (MSACM32.2)
  */
 MMRESULT WINAPI acmDriverAddA(PHACMDRIVERID phadid, HINSTANCE hinstModule,
-                  LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
+                              LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
 {
     if (!phadid)
-    return MMSYSERR_INVALPARAM;
-
+        return MMSYSERR_INVALPARAM;
+    
     /* Check if any unknown flags */
-    if (fdwAdd &
-    ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
-      ACM_DRIVERADDF_GLOBAL))
-    return MMSYSERR_INVALFLAG;
-
+    if (fdwAdd & 
+        ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
+          ACM_DRIVERADDF_GLOBAL))
+        return MMSYSERR_INVALFLAG;
+    
     /* Check if any incompatible flags */
-    if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
-    (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND))
-    return MMSYSERR_INVALFLAG;
-
-    /* FIXME: in fact, should GetModuleFileName(hinstModule) and do a
+    if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) && 
+        (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND))
+        return MMSYSERR_INVALFLAG;
+    
+    /* FIXME: in fact, should GetModuleFileName(hinstModule) and do a 
      * LoadDriver on it, to be sure we can call SendDriverMessage on the
      * hDrvr handle.
      */
     *phadid = (HACMDRIVERID) MSACM_RegisterDriver(NULL, NULL, hinstModule);
-
+    
     /* FIXME: lParam, dwPriority and fdwAdd ignored */
-
+    
     return MMSYSERR_NOERROR;
 }
@@ -67 +67 @@
  */
 MMRESULT WINAPI acmDriverAddW(PHACMDRIVERID phadid, HINSTANCE hinstModule,
-                  LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
+                              LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
 {
     FIXME("(%p, 0x%08x, %ld, %ld, %ld): stub\n",
-      phadid, hinstModule, lParam, dwPriority, fdwAdd);
-
+          phadid, hinstModule, lParam, dwPriority, fdwAdd);
+    
     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     return MMSYSERR_ERROR;
@@ -81 +81 @@
 MMRESULT WINAPI acmDriverClose(HACMDRIVER had, DWORD fdwClose)
 {
-    PWINE_ACMDRIVER pad;
-    PWINE_ACMDRIVERID   padid;
-    PWINE_ACMDRIVER*    tpad;
+    PWINE_ACMDRIVER     pad;
+    PWINE_ACMDRIVERID   padid;
+    PWINE_ACMDRIVER*    tpad;
 
     if (fdwClose)
-    return MMSYSERR_INVALFLAG;
-
+        return MMSYSERR_INVALFLAG;
+    
     pad = MSACM_GetDriver(had);
     if (!pad)
-    return MMSYSERR_INVALHANDLE;
+        return MMSYSERR_INVALHANDLE;
 
     padid = pad->obj.pACMDriverID;
@@ -96 +96 @@
     /* remove driver from list */
     for (tpad = &(padid->pACMDriverList); *tpad; *tpad = (*tpad)->pNextACMDriver) {
-    if (*tpad == pad) {
-        *tpad = (*tpad)->pNextACMDriver;
-        break;
-    }
-    }
-
+        if (*tpad == pad) {
+            *tpad = (*tpad)->pNextACMDriver;
+            break;
+        }
+    }
+    
     /* close driver if it has been opened */
     if (pad->hDrvr && !padid->hInstModule)
-    CloseDriver(pad->hDrvr, 0, 0);
-
+        CloseDriver(pad->hDrvr, 0, 0);
+    
     HeapFree(MSACM_hHeap, 0, pad);
-
+    
     return MMSYSERR_NOERROR;
 }
@@ -117 +117 @@
 {
     MMRESULT mmr;
-    ACMDRIVERDETAILSW   addw;
-
+    ACMDRIVERDETAILSW   addw;
+    
     addw.cbStruct = sizeof(addw);
     mmr = acmDriverDetailsW(hadid, &addw, fdwDetails);
     if (mmr == 0) {
-    padd->fccType = addw.fccType;
-    padd->fccComp = addw.fccComp;
-    padd->wMid = addw.wMid;
-    padd->wPid = addw.wPid;
-    padd->vdwACM = addw.vdwACM;
-    padd->vdwDriver = addw.vdwDriver;
-    padd->fdwSupport = addw.fdwSupport;
-    padd->cFormatTags = addw.cFormatTags;
-    padd->cFilterTags = addw.cFilterTags;
-    padd->hicon = addw.hicon;
+        padd->fccType = addw.fccType; 
+        padd->fccComp = addw.fccComp; 
+        padd->wMid = addw.wMid; 
+        padd->wPid = addw.wPid; 
+        padd->vdwACM = addw.vdwACM; 
+        padd->vdwDriver = addw.vdwDriver; 
+        padd->fdwSupport = addw.fdwSupport; 
+        padd->cFormatTags = addw.cFormatTags; 
+        padd->cFilterTags = addw.cFilterTags; 
+        padd->hicon = addw.hicon; 
         WideCharToMultiByte( CP_ACP, 0, addw.szShortName, -1, padd->szShortName,
                              sizeof(padd->szShortName), NULL, NULL );
@@ -153 +153 @@
     HACMDRIVER acmDrvr;
     MMRESULT mmr;
-
+    
     if (fdwDetails)
-    return MMSYSERR_INVALFLAG;
-
+        return MMSYSERR_INVALFLAG;
+    
     mmr = acmDriverOpen(&acmDrvr, hadid, 0);
     if (mmr == MMSYSERR_NOERROR) {
-    mmr = (MMRESULT)MSACM_Message(acmDrvr, ACMDM_DRIVER_DETAILS, (LPARAM)padd,  0);
-
-    acmDriverClose(acmDrvr, 0);
-    }
-
+        mmr = (MMRESULT)MSACM_Message(acmDrvr, ACMDM_DRIVER_DETAILS, (LPARAM)padd,  0);
+    
+        acmDriverClose(acmDrvr, 0);
+    }
+    
     return mmr;
 }
@@ -172 +172 @@
 MMRESULT WINAPI acmDriverEnum(ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
 {
-    PWINE_ACMDRIVERID   p;
-    ACMDRIVERDETAILSW   add;
+    PWINE_ACMDRIVERID   p;
+    ACMDRIVERDETAILSW   add;
 
     if (!fnCallback) return MMSYSERR_INVALPARAM;
-
+    
     if (fdwEnum && ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED))
-    return MMSYSERR_INVALFLAG;
-
+        return MMSYSERR_INVALFLAG;
+    
     add.cbStruct = sizeof(add);
     for (p = MSACM_pFirstACMDriverID; p; p = p->pNextACMDriverID) {
-    if (acmDriverDetailsW((HACMDRIVERID)p, &add, 0) != MMSYSERR_NOERROR)
-        continue;
-    if (!p->bEnabled) {
-        if (fdwEnum & ACM_DRIVERENUMF_DISABLED)
-        add.fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
-        else
-        continue;
-    }
-    if (!(*fnCallback)((HACMDRIVERID)p, dwInstance, add.fdwSupport))
-        break;
-    }
-
+        if (acmDriverDetailsW((HACMDRIVERID)p, &add, 0) != MMSYSERR_NOERROR)
+            continue;
+        if (!p->bEnabled) {
+            if (fdwEnum & ACM_DRIVERENUMF_DISABLED)
+                add.fdwSupport |= ACMDRIVERDETAILS_SUPPORTF_DISABLED;
+            else
+                continue;
+        }
+        if (!(*fnCallback)((HACMDRIVERID)p, dwInstance, add.fdwSupport))
+            break;
+    }
+    
     return MMSYSERR_NOERROR;
 }
@@ -203 +203 @@
 {
     PWINE_ACMOBJ pao;
-
+    
     if (!phadid)
-    return MMSYSERR_INVALPARAM;
-
+        return MMSYSERR_INVALPARAM;
+    
     if (fdwDriverID)
-    return MMSYSERR_INVALFLAG;
-
+        return MMSYSERR_INVALFLAG;
+    
     pao = MSACM_GetObj(hao, WINE_ACMOBJ_DONTCARE);
     if (!pao)
-    return MMSYSERR_INVALHANDLE;
-
+        return MMSYSERR_INVALHANDLE;
+    
     *phadid = (HACMDRIVERID) pao->pACMDriverID;
-
+    
     return MMSYSERR_NOERROR;
 }
@@ -226 +226 @@
 {
     if ((uMsg >= ACMDM_USER && uMsg < ACMDM_RESERVED_LOW) ||
-    uMsg == ACMDM_DRIVER_ABOUT ||
-    uMsg == DRV_QUERYCONFIGURE ||
-    uMsg == DRV_CONFIGURE)
-    return MSACM_Message(had, uMsg, lParam1, lParam2);
+        uMsg == ACMDM_DRIVER_ABOUT ||
+        uMsg == DRV_QUERYCONFIGURE ||
+        uMsg == DRV_CONFIGURE)
+        return MSACM_Message(had, uMsg, lParam1, lParam2);
     return MMSYSERR_INVALPARAM;
 }
@@ -239 +239 @@
 MMRESULT WINAPI acmDriverOpen(PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
 {
-    PWINE_ACMDRIVERID   padid;
-    PWINE_ACMDRIVER pad;
+    PWINE_ACMDRIVERID   padid;
+    PWINE_ACMDRIVER     pad;
 
     TRACE("(%p, %x, %08lu)\n", phad, hadid, fdwOpen);
 
     if (!phad)
-    return MMSYSERR_INVALPARAM;
-
+        return MMSYSERR_INVALPARAM;
+    
     if (fdwOpen)
-    return MMSYSERR_INVALFLAG;
-
-    padid = MSACM_GetDriverID(hadid);
+        return MMSYSERR_INVALFLAG;
+    
+    padid = MSACM_GetDriverID(hadid); 
     if (!padid)
-    return MMSYSERR_INVALHANDLE;
-
+        return MMSYSERR_INVALHANDLE;
+    
     pad = HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER));
     if (!pad) return MMSYSERR_NOMEM;
@@ -259 +259 @@
     pad->obj.dwType = WINE_ACMOBJ_DRIVER;
     pad->obj.pACMDriverID = padid;
-
+    
     if (!(pad->hDrvr = padid->hInstModule) && padid->pszDriverAlias)
-    pad->hDrvr = OpenDriverA(padid->pszDriverAlias, NULL, 0);
+        pad->hDrvr = OpenDriverA(padid->pszDriverAlias, NULL, 0);
     if (!pad->hDrvr) {
-    HeapFree(MSACM_hHeap, 0, pad);
-    return MMSYSERR_ERROR;
+        HeapFree(MSACM_hHeap, 0, pad);
+        return MMSYSERR_ERROR;
     }
 
@@ -289 +289 @@
     HKEY hPriorityKey;
     DWORD dwPriorityCounter;
-
+    
     padid = MSACM_GetDriverID(hadid);
     if (!padid)
-    return MMSYSERR_INVALHANDLE;
-
+        return MMSYSERR_INVALHANDLE;
+    
     /* Check for unknown flags */
-    if (fdwPriority &
-    ~(ACM_DRIVERPRIORITYF_ENABLE|ACM_DRIVERPRIORITYF_DISABLE|
-      ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END))
-    return MMSYSERR_INVALFLAG;
-
+    if (fdwPriority & 
+        ~(ACM_DRIVERPRIORITYF_ENABLE|ACM_DRIVERPRIORITYF_DISABLE|
+          ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END))
+        return MMSYSERR_INVALFLAG;
+    
     /* Check for incompatible flags */
     if ((fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) &&
-    (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE))
-    return MMSYSERR_INVALFLAG;
-
+        (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE))
+        return MMSYSERR_INVALFLAG;
+    
     /* Check for incompatible flags */
     if ((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) &&
-    (fdwPriority & ACM_DRIVERPRIORITYF_END))
-    return MMSYSERR_INVALFLAG;
-
-    lError = RegOpenKeyA(HKEY_CURRENT_USER,
-             "Software\\Microsoft\\Multimedia\\"
-             "Audio Compression Manager\\Priority v4.00",
-             &hPriorityKey
-             );
+        (fdwPriority & ACM_DRIVERPRIORITYF_END))
+        return MMSYSERR_INVALFLAG;
+    
+    lError = RegOpenKeyA(HKEY_CURRENT_USER, 
+                         "Software\\Microsoft\\Multimedia\\"
+                         "Audio Compression Manager\\Priority v4.00",
+                         &hPriorityKey
+                         );
     /* FIXME: Create key */
     if (lError != ERROR_SUCCESS)
+        return MMSYSERR_ERROR;
+    
+    for (dwPriorityCounter = 1; ; dwPriorityCounter++)  {
+        snprintf(szSubKey, 17, "Priorty%ld", dwPriorityCounter);
+        lError = RegQueryValueA(hPriorityKey, szSubKey, szBuffer, &lBufferLength);
+        if (lError != ERROR_SUCCESS)
+            break;
+        
+        FIXME("(0x%08x, %ld, %ld): stub (partial)\n", 
+              hadid, dwPriority, fdwPriority);
+        break;
+    }
+    
+    RegCloseKey(hPriorityKey);
+    
     return MMSYSERR_ERROR;
-
-    for (dwPriorityCounter = 1; ; dwPriorityCounter++)  {
-    snprintf(szSubKey, 17, "Priorty%ld", dwPriorityCounter);
-    lError = RegQueryValueA(hPriorityKey, szSubKey, szBuffer, &lBufferLength);
-    if (lError != ERROR_SUCCESS)
-        break;
-
-    FIXME("(0x%08x, %ld, %ld): stub (partial)\n",
-          hadid, dwPriority, fdwPriority);
-    break;
-    }
-
-    RegCloseKey(hPriorityKey);
-
-    return MMSYSERR_ERROR;
 }
 
@@ -341 +341 @@
 {
     PWINE_ACMDRIVERID padid;
-
+    
     padid = MSACM_GetDriverID(hadid);
     if (!padid)
-    return MMSYSERR_INVALHANDLE;
-
+        return MMSYSERR_INVALHANDLE;
+    
     if (fdwRemove)
-    return MMSYSERR_INVALFLAG;
-
+        return MMSYSERR_INVALFLAG;
+    
     MSACM_UnregisterDriver(padid);
-
-    return MMSYSERR_NOERROR;
-}
-
+    
+    return MMSYSERR_NOERROR;
+}
+

trunk/src/msacm32/filter.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
-/* $Id: filter.c,v 1.2 2001-09-05 13:11:25 bird Exp $ */
+
 /*
  *      MSACM32 library
@@ -42 +42 @@
  *           acmFilterDetailsA (MSACM32.15)
  */
-MMRESULT WINAPI acmFilterDetailsA(HACMDRIVER had, PACMFILTERDETAILSA pafd,
-                  DWORD fdwDetails)
-{
-    ACMFILTERDETAILSW   afdw;
-    MMRESULT        mmr;
+MMRESULT WINAPI acmFilterDetailsA(HACMDRIVER had, PACMFILTERDETAILSA pafd, 
+                                  DWORD fdwDetails)
+{
+    ACMFILTERDETAILSW   afdw;
+    MMRESULT            mmr;
 
     memset(&afdw, 0, sizeof(afdw));
     afdw.cbStruct = sizeof(afdw);
     afdw.dwFilterIndex = pafd->dwFilterIndex;
-    afdw.dwFilterTag = pafd->dwFilterTag;
+    afdw.dwFilterTag = pafd->dwFilterTag; 
     afdw.pwfltr = pafd->pwfltr;
     afdw.cbwfltr = pafd->cbwfltr;
@@ -57 +57 @@
     mmr = acmFilterDetailsW(had, &afdw, fdwDetails);
     if (mmr == MMSYSERR_NOERROR) {
-    pafd->dwFilterTag = afdw.dwFilterTag;
-    pafd->fdwSupport = afdw.fdwSupport;
+        pafd->dwFilterTag = afdw.dwFilterTag; 
+        pafd->fdwSupport = afdw.fdwSupport; 
         WideCharToMultiByte( CP_ACP, 0, afdw.szFilter, -1, pafd->szFilter,
                              sizeof(pafd->szFilter), NULL, NULL );
@@ -68 +68 @@
  *           acmFilterDetailsW (MSACM32.16)
  */
-MMRESULT WINAPI acmFilterDetailsW(HACMDRIVER had, PACMFILTERDETAILSW pafd,
-                  DWORD fdwDetails)
-{
-    MMRESULT            mmr;
-    ACMFILTERTAGDETAILSA    aftd;
+MMRESULT WINAPI acmFilterDetailsW(HACMDRIVER had, PACMFILTERDETAILSW pafd, 
+                                  DWORD fdwDetails)
+{
+    MMRESULT                    mmr;
+    ACMFILTERTAGDETAILSA        aftd;
 
     TRACE("(0x%08x, %p, %ld)\n", had, pafd, fdwDetails);
@@ -80 +80 @@
 
     if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
-
+        
     switch (fdwDetails) {
     case ACM_FILTERDETAILSF_FILTER:
-    if (pafd->dwFilterTag != pafd->pwfltr->dwFilterTag) {
-        mmr = MMSYSERR_INVALPARAM;
-        break;
-    }
-    if (had == (HACMDRIVER)NULL) {
-        PWINE_ACMDRIVERID       padid;
-
-        mmr = ACMERR_NOTPOSSIBLE;
-        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-        /* should check for codec only */
-        if (padid->bEnabled &&
-            acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
-            mmr = MSACM_Message(had, ACMDM_FILTER_DETAILS,
-                    (LPARAM)pafd, (LPARAM)fdwDetails);
-            acmDriverClose(had, 0);
-            if (mmr == MMSYSERR_NOERROR) break;
-        }
-        }
-    } else {
-        mmr = MSACM_Message(had, ACMDM_FILTER_DETAILS,
-                (LPARAM)pafd, (LPARAM)fdwDetails);
-    }
-    break;
+        if (pafd->dwFilterTag != pafd->pwfltr->dwFilterTag) {
+            mmr = MMSYSERR_INVALPARAM;
+            break;
+        }
+        if (had == (HACMDRIVER)NULL) {
+            PWINE_ACMDRIVERID           padid;
+
+            mmr = ACMERR_NOTPOSSIBLE;
+            for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+                /* should check for codec only */
+                if (padid->bEnabled && 
+                    acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
+                    mmr = MSACM_Message(had, ACMDM_FILTER_DETAILS,
+                                        (LPARAM)pafd, (LPARAM)fdwDetails);
+                    acmDriverClose(had, 0);
+                    if (mmr == MMSYSERR_NOERROR) break;
+                }
+            }               
+        } else {
+            mmr = MSACM_Message(had, ACMDM_FILTER_DETAILS,
+                                (LPARAM)pafd, (LPARAM)fdwDetails);
+        }
+        break;
     case ACM_FILTERDETAILSF_INDEX:
-    /* should check pafd->dwFilterIndex < aftd->cStandardFilters */
-    mmr = MSACM_Message(had, ACMDM_FILTER_DETAILS,
-                (LPARAM)pafd, (LPARAM)fdwDetails);
-    break;
+        /* should check pafd->dwFilterIndex < aftd->cStandardFilters */
+        mmr = MSACM_Message(had, ACMDM_FILTER_DETAILS,
+                            (LPARAM)pafd, (LPARAM)fdwDetails);
+        break;
     default:
-    WARN("Unknown fdwDetails %08lx\n", fdwDetails);
-    mmr = MMSYSERR_INVALFLAG;
-    break;
+        WARN("Unknown fdwDetails %08lx\n", fdwDetails);
+        mmr = MMSYSERR_INVALFLAG;
+        break;
     }
 
@@ -122 +122 @@
 
 struct MSACM_FilterEnumWtoA_Instance {
-    PACMFILTERDETAILSA  pafda;
-    DWORD       dwInstance;
-    ACMFILTERENUMCBA    fnCallback;
+    PACMFILTERDETAILSA  pafda;
+    DWORD               dwInstance;
+    ACMFILTERENUMCBA    fnCallback;
 };
 
 static BOOL CALLBACK MSACM_FilterEnumCallbackWtoA(HACMDRIVERID hadid,
-                          PACMFILTERDETAILSW pafdw,
-                          DWORD dwInstance,
-                          DWORD fdwSupport)
+                                                  PACMFILTERDETAILSW pafdw,  
+                                                  DWORD dwInstance,             
+                                                  DWORD fdwSupport)
 {
     struct MSACM_FilterEnumWtoA_Instance* pafei;
@@ -136 +136 @@
     pafei = (struct MSACM_FilterEnumWtoA_Instance*)dwInstance;
 
-    pafei->pafda->dwFilterIndex = pafdw->dwFilterIndex;
-    pafei->pafda->dwFilterTag = pafdw->dwFilterTag;
-    pafei->pafda->fdwSupport = pafdw->fdwSupport;
+    pafei->pafda->dwFilterIndex = pafdw->dwFilterIndex; 
+    pafei->pafda->dwFilterTag = pafdw->dwFilterTag; 
+    pafei->pafda->fdwSupport = pafdw->fdwSupport; 
     WideCharToMultiByte( CP_ACP, 0, pafdw->szFilter, -1, pafei->pafda->szFilter,
                          sizeof(pafei->pafda->szFilter), NULL, NULL );
 
-    return (pafei->fnCallback)(hadid, pafei->pafda,
-                   pafei->dwInstance, fdwSupport);
+    return (pafei->fnCallback)(hadid, pafei->pafda, 
+                               pafei->dwInstance, fdwSupport);
 }
 
@@ -149 +149 @@
  *           acmFilterEnumA (MSACM32.17)
  */
-MMRESULT WINAPI acmFilterEnumA(HACMDRIVER had, PACMFILTERDETAILSA pafda,
-                   ACMFILTERENUMCBA fnCallback, DWORD dwInstance,
-                   DWORD fdwEnum)
-{
-    ACMFILTERDETAILSW       afdw;
+MMRESULT WINAPI acmFilterEnumA(HACMDRIVER had, PACMFILTERDETAILSA pafda, 
+                               ACMFILTERENUMCBA fnCallback, DWORD dwInstance, 
+                               DWORD fdwEnum)
+{
+    ACMFILTERDETAILSW           afdw;
     struct MSACM_FilterEnumWtoA_Instance afei;
 
@@ -167 +167 @@
     afei.fnCallback = fnCallback;
 
-    return acmFilterEnumW(had, &afdw, MSACM_FilterEnumCallbackWtoA,
-              (DWORD)&afei, fdwEnum);
-}
-
-static BOOL MSACM_FilterEnumHelper(PWINE_ACMDRIVERID padid, HACMDRIVER had,
-                   PACMFILTERDETAILSW pafd,
-                   ACMFILTERENUMCBW fnCallback, DWORD dwInstance,
-                   DWORD fdwEnum)
-{
-    ACMDRIVERDETAILSW       add;
-    ACMFILTERTAGDETAILSW    aftd;
-    int             i, j;
+    return acmFilterEnumW(had, &afdw, MSACM_FilterEnumCallbackWtoA, 
+                          (DWORD)&afei, fdwEnum);
+}
+
+static BOOL MSACM_FilterEnumHelper(PWINE_ACMDRIVERID padid, HACMDRIVER had, 
+                                   PACMFILTERDETAILSW pafd, 
+                                   ACMFILTERENUMCBW fnCallback, DWORD dwInstance,  
+                                   DWORD fdwEnum)
+{
+    ACMDRIVERDETAILSW           add;
+    ACMFILTERTAGDETAILSW        aftd;
+    int                         i, j;
 
     add.cbStruct = sizeof(add);
-
+    
     if (acmDriverDetailsW((HACMDRIVERID)padid, &add, 0) != MMSYSERR_NOERROR) return FALSE;
 
     for (i = 0; i < add.cFilterTags; i++) {
-    memset(&aftd, 0, sizeof(aftd));
-    aftd.cbStruct = sizeof(aftd);
-    aftd.dwFilterTagIndex = i;
-    if (acmFilterTagDetailsW(had, &aftd, ACM_FILTERTAGDETAILSF_INDEX) != MMSYSERR_NOERROR)
-        continue;
-
-    if ((fdwEnum & ACM_FILTERENUMF_DWFILTERTAG) &&
-        aftd.dwFilterTag != pafd->pwfltr->dwFilterTag)
-        continue;
-
-    for (j = 0; j < aftd.cStandardFilters; j++) {
-        pafd->dwFilterIndex = j;
-        pafd->dwFilterTag = aftd.dwFilterTag;
-        if (acmFilterDetailsW(had, pafd, ACM_FILTERDETAILSF_INDEX) != MMSYSERR_NOERROR)
-        continue;
-
-        if (!(fnCallback)((HACMDRIVERID)padid, pafd, dwInstance, add.fdwSupport))
-        return FALSE;
-    }
+        memset(&aftd, 0, sizeof(aftd));
+        aftd.cbStruct = sizeof(aftd);
+        aftd.dwFilterTagIndex = i;
+        if (acmFilterTagDetailsW(had, &aftd, ACM_FILTERTAGDETAILSF_INDEX) != MMSYSERR_NOERROR)
+            continue;
+        
+        if ((fdwEnum & ACM_FILTERENUMF_DWFILTERTAG) && 
+            aftd.dwFilterTag != pafd->pwfltr->dwFilterTag)
+            continue;
+        
+        for (j = 0; j < aftd.cStandardFilters; j++) {
+            pafd->dwFilterIndex = j;
+            pafd->dwFilterTag = aftd.dwFilterTag;
+            if (acmFilterDetailsW(had, pafd, ACM_FILTERDETAILSF_INDEX) != MMSYSERR_NOERROR) 
+                continue;
+            
+            if (!(fnCallback)((HACMDRIVERID)padid, pafd, dwInstance, add.fdwSupport))
+                return FALSE; 
+        }
     }
     return TRUE;
@@ -211 +211 @@
  *           acmFilterEnumW (MSACM32.18)
  */
-MMRESULT WINAPI acmFilterEnumW(HACMDRIVER had, PACMFILTERDETAILSW pafd,
-                   ACMFILTERENUMCBW fnCallback, DWORD dwInstance,
-                   DWORD fdwEnum)
-{
-    PWINE_ACMDRIVERID       padid;
-    BOOL            ret;
+MMRESULT WINAPI acmFilterEnumW(HACMDRIVER had, PACMFILTERDETAILSW pafd, 
+                               ACMFILTERENUMCBW fnCallback, DWORD dwInstance, 
+                               DWORD fdwEnum)
+{
+    PWINE_ACMDRIVERID           padid;
+    BOOL                        ret;
 
     TRACE("(0x%08x, %p, %p, %ld, %ld)\n",
-      had, pafd, fnCallback, dwInstance, fdwEnum);
+          had, pafd, fnCallback, dwInstance, fdwEnum);
 
     if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
 
     if (fdwEnum & ~(ACM_FILTERENUMF_DWFILTERTAG))
-    FIXME("Unsupported fdwEnum values\n");
+        FIXME("Unsupported fdwEnum values\n");
 
     if (had) {
-    HACMDRIVERID    hadid;
-
-    if (acmDriverID(had, &hadid, 0) != MMSYSERR_NOERROR)
-        return MMSYSERR_INVALHANDLE;
-    MSACM_FilterEnumHelper(MSACM_GetDriverID(hadid), had, pafd,
-                   fnCallback, dwInstance, fdwEnum);
+        HACMDRIVERID    hadid;
+
+        if (acmDriverID(had, &hadid, 0) != MMSYSERR_NOERROR)
+            return MMSYSERR_INVALHANDLE;
+        MSACM_FilterEnumHelper(MSACM_GetDriverID(hadid), had, pafd,
+                               fnCallback, dwInstance, fdwEnum);
+        return MMSYSERR_NOERROR;
+    }
+    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+            /* should check for codec only */
+            if (!padid->bEnabled || acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
+                continue;
+            ret = MSACM_FilterEnumHelper(padid, had, pafd, 
+                                         fnCallback, dwInstance, fdwEnum);
+            acmDriverClose(had, 0);
+            if (!ret) break;
+    }
     return MMSYSERR_NOERROR;
-    }
-    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-        /* should check for codec only */
-        if (!padid->bEnabled || acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
-        continue;
-        ret = MSACM_FilterEnumHelper(padid, had, pafd,
-                     fnCallback, dwInstance, fdwEnum);
-        acmDriverClose(had, 0);
-        if (!ret) break;
-    }
-    return MMSYSERR_NOERROR;
 }
 
@@ -250 +250 @@
  *           acmFilterTagDetailsA (MSACM32.19)
  */
-MMRESULT WINAPI acmFilterTagDetailsA(HACMDRIVER had, PACMFILTERTAGDETAILSA paftda,
-                     DWORD fdwDetails)
-{
-    ACMFILTERTAGDETAILSW    aftdw;
-    MMRESULT            mmr;
+MMRESULT WINAPI acmFilterTagDetailsA(HACMDRIVER had, PACMFILTERTAGDETAILSA paftda, 
+                                     DWORD fdwDetails)
+{
+    ACMFILTERTAGDETAILSW        aftdw;
+    MMRESULT                    mmr;
 
     memset(&aftdw, 0, sizeof(aftdw));
@@ -263 +263 @@
     mmr = acmFilterTagDetailsW(had, &aftdw, fdwDetails);
     if (mmr == MMSYSERR_NOERROR) {
-    paftda->dwFilterTag = aftdw.dwFilterTag;
-    paftda->dwFilterTagIndex = aftdw.dwFilterTagIndex;
-    paftda->cbFilterSize = aftdw.cbFilterSize;
-    paftda->fdwSupport = aftdw.fdwSupport;
-    paftda->cStandardFilters = aftdw.cStandardFilters;
+        paftda->dwFilterTag = aftdw.dwFilterTag; 
+        paftda->dwFilterTagIndex = aftdw.dwFilterTagIndex;
+        paftda->cbFilterSize = aftdw.cbFilterSize; 
+        paftda->fdwSupport = aftdw.fdwSupport; 
+        paftda->cStandardFilters = aftdw.cStandardFilters; 
         WideCharToMultiByte( CP_ACP, 0, aftdw.szFilterTag, -1, paftda->szFilterTag,
                              sizeof(paftda->szFilterTag), NULL, NULL );
@@ -277 +277 @@
  *           acmFilterTagDetailsW (MSACM32.20)
  */
-MMRESULT WINAPI acmFilterTagDetailsW(HACMDRIVER had, PACMFILTERTAGDETAILSW paftd,
-                     DWORD fdwDetails)
-{
-    PWINE_ACMDRIVERID   padid;
-    MMRESULT        mmr;
+MMRESULT WINAPI acmFilterTagDetailsW(HACMDRIVER had, PACMFILTERTAGDETAILSW paftd, 
+                                     DWORD fdwDetails)
+{
+    PWINE_ACMDRIVERID   padid;
+    MMRESULT            mmr;
 
     TRACE("(0x%08x, %p, %ld)\n", had, paftd, fdwDetails);
 
     if (fdwDetails & ~(ACM_FILTERTAGDETAILSF_FILTERTAG|ACM_FILTERTAGDETAILSF_INDEX|
-               ACM_FILTERTAGDETAILSF_LARGESTSIZE))
-    return MMSYSERR_INVALFLAG;
+                       ACM_FILTERTAGDETAILSF_LARGESTSIZE))
+        return MMSYSERR_INVALFLAG;
 
     switch (fdwDetails) {
     case ACM_FILTERTAGDETAILSF_FILTERTAG:
-    if (had == (HACMDRIVER)NULL) {
-        mmr = ACMERR_NOTPOSSIBLE;
-        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-        /* should check for codec only */
-        if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
-            mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
-                    (LPARAM)paftd, (LPARAM)fdwDetails);
-            acmDriverClose(had, 0);
-            if (mmr == MMSYSERR_NOERROR) break;
-        }
-        }
-    } else {
-        mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
-                (LPARAM)paftd, (LPARAM)fdwDetails);
-    }
-    break;
+        if (had == (HACMDRIVER)NULL) {
+            mmr = ACMERR_NOTPOSSIBLE;
+            for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+                /* should check for codec only */
+                if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
+                    mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
+                                        (LPARAM)paftd, (LPARAM)fdwDetails);
+                    acmDriverClose(had, 0);
+                    if (mmr == MMSYSERR_NOERROR) break;
+                }
+            }
+        } else {
+            mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
+                                (LPARAM)paftd, (LPARAM)fdwDetails);
+        }
+        break;
 
     case ACM_FILTERTAGDETAILSF_INDEX:
-    /* FIXME should check paftd->dwFilterTagIndex < add.cFilterTags */
-    mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
-                (LPARAM)paftd, (LPARAM)fdwDetails);
-    break;
+        /* FIXME should check paftd->dwFilterTagIndex < add.cFilterTags */
+        mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
+                            (LPARAM)paftd, (LPARAM)fdwDetails);
+        break;
 
     case ACM_FILTERTAGDETAILSF_LARGESTSIZE:
-    if (had == (HACMDRIVER)NULL) {
-        ACMFILTERTAGDETAILSW    tmp;
-        DWORD           ft = paftd->dwFilterTag;
-
-        mmr = ACMERR_NOTPOSSIBLE;
-        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-        /* should check for codec only */
-        if (padid->bEnabled &&
-            acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
-
-            memset(&tmp, 0, sizeof(tmp));
-            tmp.cbStruct = sizeof(tmp);
-            tmp.dwFilterTag = ft;
-
-            if (MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
-                      (LPARAM)&tmp,
-                      (LPARAM)fdwDetails) == MMSYSERR_NOERROR) {
-            if (mmr == ACMERR_NOTPOSSIBLE ||
-                paftd->cbFilterSize < tmp.cbFilterSize) {
-                *paftd = tmp;
-                mmr = MMSYSERR_NOERROR;
-            }
-            }
-            acmDriverClose(had, 0);
-        }
-        }
-    } else {
-        mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
-                (LPARAM)paftd, (LPARAM)fdwDetails);
-    }
-    break;
+        if (had == (HACMDRIVER)NULL) {
+            ACMFILTERTAGDETAILSW        tmp;
+            DWORD                       ft = paftd->dwFilterTag;
+
+            mmr = ACMERR_NOTPOSSIBLE;
+            for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+                /* should check for codec only */
+                if (padid->bEnabled && 
+                    acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
+
+                    memset(&tmp, 0, sizeof(tmp));
+                    tmp.cbStruct = sizeof(tmp);
+                    tmp.dwFilterTag = ft;
+
+                    if (MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
+                                      (LPARAM)&tmp, 
+                                      (LPARAM)fdwDetails) == MMSYSERR_NOERROR) {
+                        if (mmr == ACMERR_NOTPOSSIBLE ||
+                            paftd->cbFilterSize < tmp.cbFilterSize) {
+                            *paftd = tmp;
+                            mmr = MMSYSERR_NOERROR;
+                        } 
+                    }
+                    acmDriverClose(had, 0);
+                }
+            }
+        } else {
+            mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
+                                (LPARAM)paftd, (LPARAM)fdwDetails);
+        }
+        break;
 
     default:
-    WARN("Unsupported fdwDetails=%08lx\n", fdwDetails);
-    mmr = MMSYSERR_ERROR;
-    }
-
-    if (mmr == MMSYSERR_NOERROR &&
-    paftd->dwFilterTag == WAVE_FORMAT_PCM && paftd->szFilterTag[0] == 0)
+        WARN("Unsupported fdwDetails=%08lx\n", fdwDetails);
+        mmr = MMSYSERR_ERROR;
+    }
+
+    if (mmr == MMSYSERR_NOERROR && 
+        paftd->dwFilterTag == WAVE_FORMAT_PCM && paftd->szFilterTag[0] == 0)
         MultiByteToWideChar( CP_ACP, 0, "PCM", -1, paftd->szFilterTag,
                              sizeof(paftd->szFilterTag)/sizeof(WCHAR) );
@@ -361 +361 @@
 
 struct MSACM_FilterTagEnumWtoA_Instance {
-    PACMFILTERTAGDETAILSA   paftda;
-    DWORD           dwInstance;
-    ACMFILTERTAGENUMCBA     fnCallback;
+    PACMFILTERTAGDETAILSA       paftda;
+    DWORD                       dwInstance;
+    ACMFILTERTAGENUMCBA         fnCallback;
 };
 
 static BOOL CALLBACK MSACM_FilterTagEnumCallbackWtoA(HACMDRIVERID hadid,
-                             PACMFILTERTAGDETAILSW paftdw,
-                             DWORD dwInstance,
-                             DWORD fdwSupport)
+                                                     PACMFILTERTAGDETAILSW paftdw,  
+                                                     DWORD dwInstance,             
+                                                     DWORD fdwSupport)
 {
     struct MSACM_FilterTagEnumWtoA_Instance* paftei;
@@ -375 +375 @@
     paftei = (struct MSACM_FilterTagEnumWtoA_Instance*)dwInstance;
 
-    paftei->paftda->dwFilterTagIndex = paftdw->dwFilterTagIndex;
-    paftei->paftda->dwFilterTag = paftdw->dwFilterTag;
-    paftei->paftda->cbFilterSize = paftdw->cbFilterSize;
-    paftei->paftda->fdwSupport = paftdw->fdwSupport;
-    paftei->paftda->cStandardFilters = paftdw->cStandardFilters;
+    paftei->paftda->dwFilterTagIndex = paftdw->dwFilterTagIndex; 
+    paftei->paftda->dwFilterTag = paftdw->dwFilterTag; 
+    paftei->paftda->cbFilterSize = paftdw->cbFilterSize; 
+    paftei->paftda->fdwSupport = paftdw->fdwSupport; 
+    paftei->paftda->cStandardFilters = paftdw->cStandardFilters; 
     WideCharToMultiByte( CP_ACP, 0, paftdw->szFilterTag, -1, paftei->paftda->szFilterTag,
                          sizeof(paftei->paftda->szFilterTag), NULL, NULL );
 
-    return (paftei->fnCallback)(hadid, paftei->paftda,
-                paftei->dwInstance, fdwSupport);
+    return (paftei->fnCallback)(hadid, paftei->paftda, 
+                                paftei->dwInstance, fdwSupport);
 }
 
@@ -391 +391 @@
  */
 MMRESULT WINAPI acmFilterTagEnumA(HACMDRIVER had, PACMFILTERTAGDETAILSA paftda,
-                  ACMFILTERTAGENUMCBA fnCallback, DWORD dwInstance,
-                  DWORD fdwEnum)
-{
-    ACMFILTERTAGDETAILSW    aftdw;
+                                  ACMFILTERTAGENUMCBA fnCallback, DWORD dwInstance, 
+                                  DWORD fdwEnum)
+{
+    ACMFILTERTAGDETAILSW        aftdw;
     struct MSACM_FilterTagEnumWtoA_Instance aftei;
 
@@ -406 +406 @@
     aftei.fnCallback = fnCallback;
 
-    return acmFilterTagEnumW(had, &aftdw, MSACM_FilterTagEnumCallbackWtoA,
-                 (DWORD)&aftei, fdwEnum);
+    return acmFilterTagEnumW(had, &aftdw, MSACM_FilterTagEnumCallbackWtoA, 
+                             (DWORD)&aftei, fdwEnum);
 }
 
@@ -414 +414 @@
  */
 MMRESULT WINAPI acmFilterTagEnumW(HACMDRIVER had, PACMFILTERTAGDETAILSW paftd,
-                  ACMFILTERTAGENUMCBW fnCallback, DWORD dwInstance,
-                  DWORD fdwEnum)
-{
-    PWINE_ACMDRIVERID       padid;
-    ACMDRIVERDETAILSW       add;
-    int             i;
+                                  ACMFILTERTAGENUMCBW fnCallback, DWORD dwInstance, 
+                                  DWORD fdwEnum)
+{
+    PWINE_ACMDRIVERID           padid;
+    ACMDRIVERDETAILSW           add;
+    int                         i;
 
     TRACE("(0x%08x, %p, %p, %ld, %ld)\n",
-      had, paftd, fnCallback, dwInstance, fdwEnum);
+          had, paftd, fnCallback, dwInstance, fdwEnum); 
 
     if (paftd->cbStruct < sizeof(*paftd)) return MMSYSERR_INVALPARAM;
 
     if (had) FIXME("had != NULL, not supported\n");
-
+    
     for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-    /* should check for codec only */
-    if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == MMSYSERR_NOERROR) {
-        add.cbStruct = sizeof(add);
-
-        if (acmDriverDetailsW((HACMDRIVERID)padid, &add, 0) == MMSYSERR_NOERROR) {
-        for (i = 0; i < add.cFilterTags; i++) {
-            paftd->dwFilterTagIndex = i;
-            if (acmFilterTagDetailsW(had, paftd, ACM_FILTERTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
-            if (!(fnCallback)((HACMDRIVERID)padid, paftd, dwInstance,
-                      add.fdwSupport)) {
-                padid = NULL;
-                break;
-            }
-            }
-        }
-        }
-    }
-    acmDriverClose(had, 0);
+        /* should check for codec only */
+        if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == MMSYSERR_NOERROR) {
+            add.cbStruct = sizeof(add);
+
+            if (acmDriverDetailsW((HACMDRIVERID)padid, &add, 0) == MMSYSERR_NOERROR) {
+                for (i = 0; i < add.cFilterTags; i++) {
+                    paftd->dwFilterTagIndex = i;
+                    if (acmFilterTagDetailsW(had, paftd, ACM_FILTERTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
+                        if (!(fnCallback)((HACMDRIVERID)padid, paftd, dwInstance, 
+                                          add.fdwSupport)) {
+                            padid = NULL;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        acmDriverClose(had, 0);
     }
     return MMSYSERR_NOERROR;

trunk/src/msacm32/format.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
-/* $Id: format.c,v 1.2 2001-09-05 13:11:25 bird Exp $ */
+
 /*
  *      MSACM32 library
  *
  *      Copyright 1998  Patrik Stridvall
- *        2000  Eric Pouech
+ *                2000  Eric Pouech
  */
 
@@ -24 +24 @@
 DEFAULT_DEBUG_CHANNEL(msacm);
 
-static  PACMFORMATCHOOSEA   afc;
+static  PACMFORMATCHOOSEA       afc;
 
 struct MSACM_FillFormatData {
-    HWND        hWnd;
-#define WINE_ACMFF_TAG      0
-#define WINE_ACMFF_FORMAT   1
-#define WINE_ACMFF_WFX      2
-    int         mode;
-    char        szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS];
-    PACMFORMATCHOOSEA   afc;
-    DWORD       ret;
+    HWND                hWnd;
+#define WINE_ACMFF_TAG          0
+#define WINE_ACMFF_FORMAT       1
+#define WINE_ACMFF_WFX          2
+    int                 mode;
+    char                szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS];
+    PACMFORMATCHOOSEA   afc;
+    DWORD               ret;
 };
 
-static BOOL CALLBACK MSACM_FillFormatTagsCB(HACMDRIVERID hadid,
-                        PACMFORMATTAGDETAILSA paftd,
-                        DWORD dwInstance, DWORD fdwSupport)
-{
-    struct MSACM_FillFormatData*    affd = (struct MSACM_FillFormatData*)dwInstance;
+static BOOL CALLBACK MSACM_FillFormatTagsCB(HACMDRIVERID hadid, 
+                                            PACMFORMATTAGDETAILSA paftd,
+                                            DWORD dwInstance, DWORD fdwSupport)
+{
+    struct MSACM_FillFormatData*        affd = (struct MSACM_FillFormatData*)dwInstance;
 
     switch (affd->mode) {
     case WINE_ACMFF_TAG:
-    if (SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
-                CB_FINDSTRINGEXACT,
-                (WPARAM)-1, (LPARAM)paftd->szFormatTag) == CB_ERR)
-        SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
-                CB_ADDSTRING, 0, (DWORD)paftd->szFormatTag);
-    break;
+        if (SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, 
+                                CB_FINDSTRINGEXACT, 
+                                (WPARAM)-1, (LPARAM)paftd->szFormatTag) == CB_ERR)
+            SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, 
+                                CB_ADDSTRING, 0, (DWORD)paftd->szFormatTag);
+        break;
     case WINE_ACMFF_FORMAT:
-    if (strcmp(affd->szFormatTag, paftd->szFormatTag) == 0) {
-        HACMDRIVER      had;
-
-        if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
-        ACMFORMATDETAILSA   afd;
-        int         i, idx;
-        MMRESULT        mmr;
-        char            buffer[64];
-
-        afd.cbStruct = sizeof(afd);
-        afd.dwFormatTag = paftd->dwFormatTag;
-        afd.pwfx = HeapAlloc(GetProcessHeap(), 0, paftd->cbFormatSize);
-        afd.pwfx->wFormatTag = paftd->dwFormatTag;
-        afd.pwfx->cbSize = paftd->cbFormatSize;
-        afd.cbwfx = paftd->cbFormatSize;
-
-        for (i = 0; i < paftd->cStandardFormats; i++) {
-            afd.dwFormatIndex = i;
-            mmr = acmFormatDetailsA(had, &afd, ACM_FORMATDETAILSF_INDEX);
-            if (mmr == MMSYSERR_NOERROR) {
-            strcpy(buffer, afd.szFormat);
-            for (idx = strlen(buffer);
-                 idx < ACMFORMATTAGDETAILS_FORMATTAG_CHARS; idx++)
-                buffer[idx] = ' ';
-            wsprintfA(buffer + ACMFORMATTAGDETAILS_FORMATTAG_CHARS,
-                  "%d Ko/s",
-                  (afd.pwfx->nAvgBytesPerSec + 512) / 1024);
-            SendDlgItemMessageA(affd->hWnd,
-                        IDD_ACMFORMATCHOOSE_CMB_FORMAT,
-                        CB_ADDSTRING, 0, (DWORD)buffer);
-            }
-        }
-        acmDriverClose(had, 0);
-        SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT,
-                    CB_SETCURSEL, 0, 0);
-        }
-    }
-    break;
+        if (strcmp(affd->szFormatTag, paftd->szFormatTag) == 0) {
+            HACMDRIVER          had;
+
+            if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
+                ACMFORMATDETAILSA       afd;
+                int                     i, idx;
+                MMRESULT                mmr;
+                char                    buffer[64];
+
+                afd.cbStruct = sizeof(afd);
+                afd.dwFormatTag = paftd->dwFormatTag;
+                afd.pwfx = HeapAlloc(GetProcessHeap(), 0, paftd->cbFormatSize);
+                afd.pwfx->wFormatTag = paftd->dwFormatTag;
+                afd.pwfx->cbSize = paftd->cbFormatSize;
+                afd.cbwfx = paftd->cbFormatSize;
+
+                for (i = 0; i < paftd->cStandardFormats; i++) {
+                    afd.dwFormatIndex = i;
+                    mmr = acmFormatDetailsA(had, &afd, ACM_FORMATDETAILSF_INDEX);
+                    if (mmr == MMSYSERR_NOERROR) {
+                        strcpy(buffer, afd.szFormat);
+                        for (idx = strlen(buffer); 
+                             idx < ACMFORMATTAGDETAILS_FORMATTAG_CHARS; idx++)
+                            buffer[idx] = ' ';
+                        wsprintfA(buffer + ACMFORMATTAGDETAILS_FORMATTAG_CHARS, 
+                                  "%d Ko/s", 
+                                  (afd.pwfx->nAvgBytesPerSec + 512) / 1024);
+                        SendDlgItemMessageA(affd->hWnd, 
+                                            IDD_ACMFORMATCHOOSE_CMB_FORMAT, 
+                                            CB_ADDSTRING, 0, (DWORD)buffer);
+                    }
+                }
+                acmDriverClose(had, 0);
+                SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, 
+                                    CB_SETCURSEL, 0, 0);
+            } 
+        }
+        break;
     case WINE_ACMFF_WFX:
-    if (strcmp(affd->szFormatTag, paftd->szFormatTag) == 0) {
-        HACMDRIVER      had;
-
-        if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
-        ACMFORMATDETAILSA   afd;
-
-        afd.cbStruct = sizeof(afd);
-        afd.dwFormatTag = paftd->dwFormatTag;
-        afd.pwfx = affd->afc->pwfx;
-        afd.cbwfx = affd->afc->cbwfx;
-
-        afd.dwFormatIndex = SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_GETCURSEL, 0, 0);;
-        affd->ret = acmFormatDetailsA(had, &afd, ACM_FORMATDETAILSF_INDEX);
-        acmDriverClose(had, 0);
-        return TRUE;
-        }
-    }
-    break;
+        if (strcmp(affd->szFormatTag, paftd->szFormatTag) == 0) {
+            HACMDRIVER          had;
+
+            if (acmDriverOpen(&had, hadid, 0) == MMSYSERR_NOERROR) {
+                ACMFORMATDETAILSA       afd;
+
+                afd.cbStruct = sizeof(afd);
+                afd.dwFormatTag = paftd->dwFormatTag;
+                afd.pwfx = affd->afc->pwfx;
+                afd.cbwfx = affd->afc->cbwfx;
+
+                afd.dwFormatIndex = SendDlgItemMessageA(affd->hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_GETCURSEL, 0, 0);;
+                affd->ret = acmFormatDetailsA(had, &afd, ACM_FORMATDETAILSF_INDEX);
+                acmDriverClose(had, 0);
+                return TRUE;
+            } 
+        }
+        break;
     default:
-    FIXME("Unknown mode (%d)\n", affd->mode);
-    break;
+        FIXME("Unknown mode (%d)\n", affd->mode);
+        break;
     }
     return TRUE;
@@ -118 +118 @@
 static BOOL MSACM_FillFormatTags(HWND hWnd)
 {
-    ACMFORMATTAGDETAILSA    aftd;
-    struct MSACM_FillFormatData affd;
+    ACMFORMATTAGDETAILSA        aftd;
+    struct MSACM_FillFormatData affd;
 
     memset(&aftd, 0, sizeof(aftd));
@@ -134 +134 @@
 static BOOL MSACM_FillFormat(HWND hWnd)
 {
-    ACMFORMATTAGDETAILSA    aftd;
-    struct MSACM_FillFormatData affd;
+    ACMFORMATTAGDETAILSA        aftd;
+    struct MSACM_FillFormatData affd;
 
     SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_RESETCONTENT, 0, 0);
@@ -144 +144 @@
     affd.hWnd = hWnd;
     affd.mode = WINE_ACMFF_FORMAT;
-    SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
-            CB_GETLBTEXT,
-            SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG,
-                        CB_GETCURSEL, 0, 0),
-            (DWORD)affd.szFormatTag);
-
+    SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, 
+                        CB_GETLBTEXT,
+                        SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMATTAG, 
+                                            CB_GETCURSEL, 0, 0),
+                        (DWORD)affd.szFormatTag);
+    
     acmFormatTagEnumA((HACMDRIVER)0, &aftd, MSACM_FillFormatTagsCB, (DWORD)&affd, 0);
     SendDlgItemMessageA(hWnd, IDD_ACMFORMATCHOOSE_CMB_FORMAT, CB_SETCURSEL, 0, 0);
@@ -157 +157 @@
 static MMRESULT MSACM_GetWFX(HWND hWnd, PACMFORMATCHOOSEA afc)
 {
-    ACMFORMATTAGDETAILSA    aftd;
-    struct MSACM_FillFormatData affd;
+    ACMFORMATTAGDETAILSA        aftd;
+    struct MSACM_FillFormatData affd;
 
     memset(&aftd, 0, sizeof(aftd));
@@ -172 +172 @@
 }
 
-static BOOL WINAPI FormatChooseDlgProc(HWND hWnd, UINT msg,
-                       WPARAM wParam, LPARAM lParam)
-{
-
+static BOOL WINAPI FormatChooseDlgProc(HWND hWnd, UINT msg, 
+                                       WPARAM wParam, LPARAM lParam)
+{
+    
     TRACE("hwnd=%i msg=%i 0x%08x 0x%08lx\n", hWnd,  msg, wParam, lParam );
-
+    
     switch (msg) {
     case WM_INITDIALOG:
-    afc = (PACMFORMATCHOOSEA)lParam;
-    MSACM_FillFormatTags(hWnd);
-    MSACM_FillFormat(hWnd);
-    if ((afc->fdwStyle & ~(ACMFORMATCHOOSE_STYLEF_CONTEXTHELP|
-                   ACMFORMATCHOOSE_STYLEF_SHOWHELP)) != 0)
-        FIXME("Unsupported style %08lx\n", ((PACMFORMATCHOOSEA)lParam)->fdwStyle);
-    if (!(afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP))
-        ShowWindow(GetDlgItem(hWnd, IDD_ACMFORMATCHOOSE_BTN_HELP), SW_HIDE);
-    return TRUE;
-
+        afc = (PACMFORMATCHOOSEA)lParam;
+        MSACM_FillFormatTags(hWnd);
+        MSACM_FillFormat(hWnd);
+        if ((afc->fdwStyle & ~(ACMFORMATCHOOSE_STYLEF_CONTEXTHELP|
+                               ACMFORMATCHOOSE_STYLEF_SHOWHELP)) != 0)
+            FIXME("Unsupported style %08lx\n", ((PACMFORMATCHOOSEA)lParam)->fdwStyle);
+        if (!(afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP))
+            ShowWindow(GetDlgItem(hWnd, IDD_ACMFORMATCHOOSE_BTN_HELP), SW_HIDE);
+        return TRUE;
+        
     case WM_COMMAND:
-    switch (LOWORD(wParam)) {
-    case IDOK:
-        EndDialog(hWnd, MSACM_GetWFX(hWnd, afc));
-        return TRUE;
-    case IDCANCEL:
-        EndDialog(hWnd, ACMERR_CANCELED);
-        return TRUE;
-    case IDD_ACMFORMATCHOOSE_CMB_FORMATTAG:
-        switch (HIWORD(wParam)) {
-        case CBN_SELCHANGE:
-        MSACM_FillFormat(hWnd);
-        break;
-        default:
-        TRACE("Dropped dlgNotif (fmtTag): 0x%08x 0x%08lx\n",
-              HIWORD(wParam), lParam);
-        break;
-        }
-        break;
-    case IDD_ACMFORMATCHOOSE_BTN_HELP:
-        if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP)
-        SendMessageA(afc->hwndOwner,
-                 RegisterWindowMessageA(ACMHELPMSGSTRINGA), 0L, 0L);
-        break;
-
-    default:
-        TRACE("Dropped dlgCmd: ctl=%d ntf=0x%04x 0x%08lx\n",
-          LOWORD(wParam), HIWORD(wParam), lParam);
-        break;
-    }
-    break;
+        switch (LOWORD(wParam)) {
+        case IDOK:
+            EndDialog(hWnd, MSACM_GetWFX(hWnd, afc));
+            return TRUE;
+        case IDCANCEL:
+            EndDialog(hWnd, ACMERR_CANCELED);
+            return TRUE;
+        case IDD_ACMFORMATCHOOSE_CMB_FORMATTAG:
+            switch (HIWORD(wParam)) {
+            case CBN_SELCHANGE:
+                MSACM_FillFormat(hWnd);
+                break;
+            default:
+                TRACE("Dropped dlgNotif (fmtTag): 0x%08x 0x%08lx\n", 
+                      HIWORD(wParam), lParam);
+                break;
+            }
+            break;
+        case IDD_ACMFORMATCHOOSE_BTN_HELP:
+            if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP)
+                SendMessageA(afc->hwndOwner, 
+                             RegisterWindowMessageA(ACMHELPMSGSTRINGA), 0L, 0L);
+            break;
+            
+        default:
+            TRACE("Dropped dlgCmd: ctl=%d ntf=0x%04x 0x%08lx\n", 
+                  LOWORD(wParam), HIWORD(wParam), lParam);
+            break;
+        }
+        break;
     case WM_CONTEXTMENU:
-    if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
-        SendMessageA(afc->hwndOwner,
-             RegisterWindowMessageA(ACMHELPMSGCONTEXTMENUA),
-             wParam, lParam);
-    break;
+        if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
+            SendMessageA(afc->hwndOwner, 
+                         RegisterWindowMessageA(ACMHELPMSGCONTEXTMENUA), 
+                         wParam, lParam);
+        break;
 #if defined(WM_CONTEXTHELP)
     case WM_CONTEXTHELP:
-    if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
-        SendMessageA(afc->hwndOwner,
-             RegisterWindowMessageA(ACMHELPMSGCONTEXTHELPA),
-             wParam, lParam);
-    break;
-#endif
+        if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
+            SendMessageA(afc->hwndOwner, 
+                         RegisterWindowMessageA(ACMHELPMSGCONTEXTHELPA), 
+                         wParam, lParam);
+        break;
+#endif       
     default:
-    TRACE("Dropped dlgMsg: hwnd=%i msg=%i 0x%08x 0x%08lx\n",
-          hWnd,  msg, wParam, lParam );
-    break;
+        TRACE("Dropped dlgMsg: hwnd=%i msg=%i 0x%08x 0x%08lx\n", 
+              hWnd,  msg, wParam, lParam );
+        break;
     }
     return FALSE;
@@ -249 +249 @@
 {
     return DialogBoxParamA(MSACM_hInstance32, MAKEINTRESOURCEA(DLG_ACMFORMATCHOOSE_ID),
-               pafmtc->hwndOwner, FormatChooseDlgProc, (INT)pafmtc);
+                           pafmtc->hwndOwner, FormatChooseDlgProc, (INT)pafmtc);
 }
 
@@ -265 +265 @@
  *           acmFormatDetailsA (MSACM32.25)
  */
-MMRESULT WINAPI acmFormatDetailsA(HACMDRIVER had, PACMFORMATDETAILSA pafd,
-                  DWORD fdwDetails)
-{
-    ACMFORMATDETAILSW   afdw;
-    MMRESULT        mmr;
+MMRESULT WINAPI acmFormatDetailsA(HACMDRIVER had, PACMFORMATDETAILSA pafd, 
+                                  DWORD fdwDetails)
+{
+    ACMFORMATDETAILSW   afdw;
+    MMRESULT            mmr;
 
     memset(&afdw, 0, sizeof(afdw));
     afdw.cbStruct = sizeof(afdw);
     afdw.dwFormatIndex = pafd->dwFormatIndex;
-    afdw.dwFormatTag = pafd->dwFormatTag;
-    afdw.pwfx = pafd->pwfx;
-    afdw.cbwfx = pafd->cbwfx;
+    afdw.dwFormatTag = pafd->dwFormatTag; 
+    afdw.pwfx = pafd->pwfx; 
+    afdw.cbwfx = pafd->cbwfx; 
 
     mmr = acmFormatDetailsW(had, &afdw, fdwDetails);
     if (mmr == MMSYSERR_NOERROR) {
-    pafd->dwFormatTag = afdw.dwFormatTag;
-    pafd->fdwSupport = afdw.fdwSupport;
+        pafd->dwFormatTag = afdw.dwFormatTag; 
+        pafd->fdwSupport = afdw.fdwSupport; 
         WideCharToMultiByte( CP_ACP, 0, afdw.szFormat, -1,
                              pafd->szFormat, sizeof(pafd->szFormat), NULL, NULL );
@@ -291 +291 @@
  *           acmFormatDetailsW (MSACM32.26)
  */
-MMRESULT WINAPI acmFormatDetailsW(HACMDRIVER had, PACMFORMATDETAILSW pafd,
-                  DWORD fdwDetails)
-{
-    MMRESULT            mmr;
-    static WCHAR        fmt1[] = {'%','d',' ','H','z',0};
-    static WCHAR        fmt2[] = {';',' ','%','d',' ','b','i','t','s',0};
-    ACMFORMATTAGDETAILSA    aftd;
+MMRESULT WINAPI acmFormatDetailsW(HACMDRIVER had, PACMFORMATDETAILSW pafd, 
+                                  DWORD fdwDetails)
+{
+    MMRESULT                    mmr;
+    static WCHAR                fmt1[] = {'%','d',' ','H','z',0};
+    static WCHAR                fmt2[] = {';',' ','%','d',' ','b','i','t','s',0};
+    ACMFORMATTAGDETAILSA        aftd;
 
     TRACE("(0x%08x, %p, %ld)\n", had, pafd, fdwDetails);
@@ -305 +305 @@
 
     if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
-
+        
     switch (fdwDetails) {
     case ACM_FORMATDETAILSF_FORMAT:
-    if (pafd->dwFormatTag != pafd->pwfx->wFormatTag) {
-        mmr = MMSYSERR_INVALPARAM;
-        break;
-    }
-    if (had == (HACMDRIVER)NULL) {
-        PWINE_ACMDRIVERID       padid;
-
-        mmr = ACMERR_NOTPOSSIBLE;
-        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-        /* should check for codec only */
-        if (padid->bEnabled &&
-            acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
-            mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS,
-                    (LPARAM)pafd, (LPARAM)fdwDetails);
-            acmDriverClose(had, 0);
-            if (mmr == MMSYSERR_NOERROR) break;
-        }
-        }
-    } else {
-        mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS,
-                (LPARAM)pafd, (LPARAM)fdwDetails);
-    }
-    break;
+        if (pafd->dwFormatTag != pafd->pwfx->wFormatTag) {
+            mmr = MMSYSERR_INVALPARAM;
+            break;
+        }
+        if (had == (HACMDRIVER)NULL) {
+            PWINE_ACMDRIVERID           padid;
+
+            mmr = ACMERR_NOTPOSSIBLE;
+            for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+                /* should check for codec only */
+                if (padid->bEnabled && 
+                    acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
+                    mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS,
+                                        (LPARAM)pafd, (LPARAM)fdwDetails);
+                    acmDriverClose(had, 0);
+                    if (mmr == MMSYSERR_NOERROR) break;
+                }
+            }               
+        } else {
+            mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS,
+                                (LPARAM)pafd, (LPARAM)fdwDetails);
+        }
+        break;
     case ACM_FORMATDETAILSF_INDEX:
-    /* should check pafd->dwFormatIndex < aftd->cStandardFormats */
-    mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS,
-                (LPARAM)pafd, (LPARAM)fdwDetails);
-    break;
+        /* should check pafd->dwFormatIndex < aftd->cStandardFormats */
+        mmr = MSACM_Message(had, ACMDM_FORMAT_DETAILS,
+                            (LPARAM)pafd, (LPARAM)fdwDetails);
+        break;
     default:
-    WARN("Unknown fdwDetails %08lx\n", fdwDetails);
-    mmr = MMSYSERR_INVALFLAG;
-    break;
+        WARN("Unknown fdwDetails %08lx\n", fdwDetails);
+        mmr = MMSYSERR_INVALFLAG;
+        break;
     }
 
     if (mmr == MMSYSERR_NOERROR && pafd->szFormat[0] == (WCHAR)0) {
-    wsprintfW(pafd->szFormat, fmt1, pafd->pwfx->nSamplesPerSec);
-    if (pafd->pwfx->wBitsPerSample) {
-        wsprintfW(pafd->szFormat + lstrlenW(pafd->szFormat), fmt2,
-              pafd->pwfx->wBitsPerSample);
-    }
+        wsprintfW(pafd->szFormat, fmt1, pafd->pwfx->nSamplesPerSec);
+        if (pafd->pwfx->wBitsPerSample) {
+            wsprintfW(pafd->szFormat + lstrlenW(pafd->szFormat), fmt2, 
+                      pafd->pwfx->wBitsPerSample);
+        }
         MultiByteToWideChar( CP_ACP, 0, (pafd->pwfx->nChannels == 1) ? "; Mono" : "; Stereo", -1,
                              pafd->szFormat + strlenW(pafd->szFormat),
@@ -358 +358 @@
 
 struct MSACM_FormatEnumWtoA_Instance {
-    PACMFORMATDETAILSA  pafda;
-    DWORD       dwInstance;
-    ACMFORMATENUMCBA    fnCallback;
+    PACMFORMATDETAILSA  pafda;
+    DWORD               dwInstance;
+    ACMFORMATENUMCBA    fnCallback;
 };
 
 static BOOL CALLBACK MSACM_FormatEnumCallbackWtoA(HACMDRIVERID hadid,
-                          PACMFORMATDETAILSW pafdw,
-                          DWORD dwInstance,
-                          DWORD fdwSupport)
+                                                  PACMFORMATDETAILSW pafdw,  
+                                                  DWORD dwInstance,             
+                                                  DWORD fdwSupport)
 {
     struct MSACM_FormatEnumWtoA_Instance* pafei;
@@ -372 +372 @@
     pafei = (struct MSACM_FormatEnumWtoA_Instance*)dwInstance;
 
-    pafei->pafda->dwFormatIndex = pafdw->dwFormatIndex;
-    pafei->pafda->dwFormatTag = pafdw->dwFormatTag;
-    pafei->pafda->fdwSupport = pafdw->fdwSupport;
+    pafei->pafda->dwFormatIndex = pafdw->dwFormatIndex; 
+    pafei->pafda->dwFormatTag = pafdw->dwFormatTag; 
+    pafei->pafda->fdwSupport = pafdw->fdwSupport; 
     WideCharToMultiByte( CP_ACP, 0, pafdw->szFormat, -1,
                          pafei->pafda->szFormat, sizeof(pafei->pafda->szFormat), NULL, NULL );
 
-    return (pafei->fnCallback)(hadid, pafei->pafda,
-                   pafei->dwInstance, fdwSupport);
+    return (pafei->fnCallback)(hadid, pafei->pafda, 
+                               pafei->dwInstance, fdwSupport);
 }
 
@@ -386 +386 @@
  */
 MMRESULT WINAPI acmFormatEnumA(HACMDRIVER had, PACMFORMATDETAILSA pafda,
-                   ACMFORMATENUMCBA fnCallback, DWORD dwInstance,
-                   DWORD fdwEnum)
-{
-    ACMFORMATDETAILSW       afdw;
+                               ACMFORMATENUMCBA fnCallback, DWORD dwInstance, 
+                               DWORD fdwEnum)
+{
+    ACMFORMATDETAILSW           afdw;
     struct MSACM_FormatEnumWtoA_Instance afei;
 
@@ -403 +403 @@
     afei.fnCallback = fnCallback;
 
-    return acmFormatEnumW(had, &afdw, MSACM_FormatEnumCallbackWtoA,
-              (DWORD)&afei, fdwEnum);
+    return acmFormatEnumW(had, &afdw, MSACM_FormatEnumCallbackWtoA, 
+                          (DWORD)&afei, fdwEnum);
 }
 
@@ -410 +410 @@
  *           acmFormatEnumW (MSACM32.28)
  */
-static BOOL MSACM_FormatEnumHelper(PWINE_ACMDRIVERID padid, HACMDRIVER had,
-                   PACMFORMATDETAILSW pafd, PWAVEFORMATEX pwfxRef,
-                   ACMFORMATENUMCBW fnCallback, DWORD dwInstance,
-                   DWORD fdwEnum)
-{
-    ACMDRIVERDETAILSW       add;
-    ACMFORMATTAGDETAILSW    aftd;
-    int             i, j;
+static BOOL MSACM_FormatEnumHelper(PWINE_ACMDRIVERID padid, HACMDRIVER had, 
+                                   PACMFORMATDETAILSW pafd, PWAVEFORMATEX pwfxRef, 
+                                   ACMFORMATENUMCBW fnCallback, DWORD dwInstance,  
+                                   DWORD fdwEnum)
+{
+    ACMDRIVERDETAILSW           add;
+    ACMFORMATTAGDETAILSW        aftd;
+    int                         i, j;
 
     add.cbStruct = sizeof(add);
-
+    
     if (acmDriverDetailsW((HACMDRIVERID)padid, &add, 0) != MMSYSERR_NOERROR) return FALSE;
 
     for (i = 0; i < add.cFormatTags; i++) {
-    memset(&aftd, 0, sizeof(aftd));
-    aftd.cbStruct = sizeof(aftd);
-    aftd.dwFormatTagIndex = i;
-    if (acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_INDEX) != MMSYSERR_NOERROR)
-        continue;
-
-    if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) && aftd.dwFormatTag != pwfxRef->wFormatTag)
-        continue;
-
-    for (j = 0; j < aftd.cStandardFormats; j++) {
-        pafd->dwFormatIndex = j;
-        pafd->dwFormatTag = aftd.dwFormatTag;
-        if (acmFormatDetailsW(had, pafd, ACM_FORMATDETAILSF_INDEX) != MMSYSERR_NOERROR)
-        continue;
-
-        if ((fdwEnum & ACM_FORMATENUMF_NCHANNELS) &&
-        pafd->pwfx->nChannels != pwfxRef->nChannels)
-        continue;
-        if ((fdwEnum & ACM_FORMATENUMF_NSAMPLESPERSEC) &&
-        pafd->pwfx->nSamplesPerSec != pwfxRef->nSamplesPerSec)
-        continue;
-        if ((fdwEnum & ACM_FORMATENUMF_WBITSPERSAMPLE) &&
-        pafd->pwfx->wBitsPerSample != pwfxRef->wBitsPerSample)
-        continue;
-        if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
-        !(pafd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_HARDWARE))
-        continue;
-
-        /* more checks to be done on fdwEnum */
-
-        if (!(fnCallback)((HACMDRIVERID)padid, pafd, dwInstance, add.fdwSupport))
-        return FALSE;
-    }
-    /* the "formats" used by the filters are also reported */
+        memset(&aftd, 0, sizeof(aftd));
+        aftd.cbStruct = sizeof(aftd);
+        aftd.dwFormatTagIndex = i;
+        if (acmFormatTagDetailsW(had, &aftd, ACM_FORMATTAGDETAILSF_INDEX) != MMSYSERR_NOERROR)
+            continue;
+        
+        if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) && aftd.dwFormatTag != pwfxRef->wFormatTag)
+            continue;
+        
+        for (j = 0; j < aftd.cStandardFormats; j++) {
+            pafd->dwFormatIndex = j;
+            pafd->dwFormatTag = aftd.dwFormatTag;
+            if (acmFormatDetailsW(had, pafd, ACM_FORMATDETAILSF_INDEX) != MMSYSERR_NOERROR) 
+                continue;
+            
+            if ((fdwEnum & ACM_FORMATENUMF_NCHANNELS) && 
+                pafd->pwfx->nChannels != pwfxRef->nChannels)
+                continue;
+            if ((fdwEnum & ACM_FORMATENUMF_NSAMPLESPERSEC) && 
+                pafd->pwfx->nSamplesPerSec != pwfxRef->nSamplesPerSec)
+                continue;
+            if ((fdwEnum & ACM_FORMATENUMF_WBITSPERSAMPLE) && 
+                pafd->pwfx->wBitsPerSample != pwfxRef->wBitsPerSample)
+                continue;
+            if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
+                !(pafd->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_HARDWARE))
+                continue;
+            
+            /* more checks to be done on fdwEnum */
+
+            if (!(fnCallback)((HACMDRIVERID)padid, pafd, dwInstance, add.fdwSupport))
+                return FALSE; 
+        }
+        /* the "formats" used by the filters are also reported */
     }
     return TRUE;
@@ -465 +465 @@
 
 MMRESULT WINAPI acmFormatEnumW(HACMDRIVER had, PACMFORMATDETAILSW pafd,
-                   ACMFORMATENUMCBW fnCallback, DWORD dwInstance,
-                   DWORD fdwEnum)
-{
-    PWINE_ACMDRIVERID       padid;
-    WAVEFORMATEX        wfxRef;
-    BOOL            ret;
+                               ACMFORMATENUMCBW fnCallback, DWORD dwInstance,  
+                               DWORD fdwEnum)
+{
+    PWINE_ACMDRIVERID           padid;
+    WAVEFORMATEX                wfxRef;
+    BOOL                        ret;
 
     TRACE("(0x%08x, %p, %p, %ld, %ld)\n",
-      had, pafd, fnCallback, dwInstance, fdwEnum);
+          had, pafd, fnCallback, dwInstance, fdwEnum);
 
     if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
 
     if (fdwEnum & (ACM_FORMATENUMF_WFORMATTAG|ACM_FORMATENUMF_NCHANNELS|
-           ACM_FORMATENUMF_NSAMPLESPERSEC|ACM_FORMATENUMF_WBITSPERSAMPLE|
-           ACM_FORMATENUMF_CONVERT|ACM_FORMATENUMF_SUGGEST))
+                   ACM_FORMATENUMF_NSAMPLESPERSEC|ACM_FORMATENUMF_WBITSPERSAMPLE|
+                   ACM_FORMATENUMF_CONVERT|ACM_FORMATENUMF_SUGGEST))
         wfxRef = *pafd->pwfx;
 
-    if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) &&
-    !(fdwEnum & (ACM_FORMATENUMF_INPUT|ACM_FORMATENUMF_OUTPUT)))
-    return MMSYSERR_INVALPARAM;
+    if ((fdwEnum & ACM_FORMATENUMF_HARDWARE) && 
+        !(fdwEnum & (ACM_FORMATENUMF_INPUT|ACM_FORMATENUMF_OUTPUT)))
+        return MMSYSERR_INVALPARAM;
 
     if ((fdwEnum & ACM_FORMATENUMF_WFORMATTAG) &&
-    (pafd->dwFormatTag != pafd->pwfx->wFormatTag))
-    return MMSYSERR_INVALPARAM;
+        (pafd->dwFormatTag != pafd->pwfx->wFormatTag))
+        return MMSYSERR_INVALPARAM;
 
     if (fdwEnum & (ACM_FORMATENUMF_CONVERT|ACM_FORMATENUMF_SUGGEST|
-           ACM_FORMATENUMF_INPUT|ACM_FORMATENUMF_OUTPUT))
-    FIXME("Unsupported fdwEnum values %08lx\n", fdwEnum);
+                   ACM_FORMATENUMF_INPUT|ACM_FORMATENUMF_OUTPUT))
+        FIXME("Unsupported fdwEnum values %08lx\n", fdwEnum);
 
     if (had) {
-    HACMDRIVERID    hadid;
-
-    if (acmDriverID(had, &hadid, 0) != MMSYSERR_NOERROR)
-        return MMSYSERR_INVALHANDLE;
-    MSACM_FormatEnumHelper(MSACM_GetDriverID(hadid), had, pafd, &wfxRef,
-                   fnCallback, dwInstance, fdwEnum);
+        HACMDRIVERID    hadid;
+
+        if (acmDriverID(had, &hadid, 0) != MMSYSERR_NOERROR)
+            return MMSYSERR_INVALHANDLE;
+        MSACM_FormatEnumHelper(MSACM_GetDriverID(hadid), had, pafd, &wfxRef, 
+                               fnCallback, dwInstance, fdwEnum);
+        return MMSYSERR_NOERROR;
+    }
+    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+            /* should check for codec only */
+            if (!padid->bEnabled || acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
+                continue;
+            ret = MSACM_FormatEnumHelper(padid, had, pafd, &wfxRef, 
+                                         fnCallback, dwInstance, fdwEnum);
+            acmDriverClose(had, 0);
+            if (!ret) break;
+    }
     return MMSYSERR_NOERROR;
-    }
-    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-        /* should check for codec only */
-        if (!padid->bEnabled || acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
-        continue;
-        ret = MSACM_FormatEnumHelper(padid, had, pafd, &wfxRef,
-                     fnCallback, dwInstance, fdwEnum);
-        acmDriverClose(had, 0);
-        if (!ret) break;
-    }
-    return MMSYSERR_NOERROR;
 }
 
@@ -518 +518 @@
  *           acmFormatSuggest (MSACM32.29)
  */
-MMRESULT WINAPI acmFormatSuggest(HACMDRIVER had, PWAVEFORMATEX pwfxSrc,
-                 PWAVEFORMATEX pwfxDst, DWORD cbwfxDst, DWORD fdwSuggest)
-{
-    ACMDRVFORMATSUGGEST adfg;
-    MMRESULT        mmr;
-
-    TRACE("(0x%08x, %p, %p, %ld, %ld)\n",
-      had, pwfxSrc, pwfxDst, cbwfxDst, fdwSuggest);
+MMRESULT WINAPI acmFormatSuggest(HACMDRIVER had, PWAVEFORMATEX pwfxSrc, 
+                                 PWAVEFORMATEX pwfxDst, DWORD cbwfxDst, DWORD fdwSuggest)
+{
+    ACMDRVFORMATSUGGEST adfg;
+    MMRESULT            mmr;
+
+    TRACE("(0x%08x, %p, %p, %ld, %ld)\n", 
+          had, pwfxSrc, pwfxDst, cbwfxDst, fdwSuggest);
 
     if (fdwSuggest & ~(ACM_FORMATSUGGESTF_NCHANNELS|ACM_FORMATSUGGESTF_NSAMPLESPERSEC|
-               ACM_FORMATSUGGESTF_WBITSPERSAMPLE|ACM_FORMATSUGGESTF_WFORMATTAG))
-    return MMSYSERR_INVALFLAG;
+                       ACM_FORMATSUGGESTF_WBITSPERSAMPLE|ACM_FORMATSUGGESTF_WFORMATTAG))
+        return MMSYSERR_INVALFLAG;
 
     adfg.cbStruct = sizeof(adfg);
@@ -535 +535 @@
     adfg.pwfxSrc = pwfxSrc;
     adfg.cbwfxSrc = (pwfxSrc->wFormatTag == WAVE_FORMAT_PCM) ?
-    sizeof(WAVEFORMATEX) : pwfxSrc->cbSize;
+        sizeof(WAVEFORMATEX) : pwfxSrc->cbSize;
     adfg.pwfxDst = pwfxDst;
     adfg.cbwfxDst = cbwfxDst;
 
     if (had == (HACMDRIVER)NULL) {
-    PWINE_ACMDRIVERID   padid;
-
-    /* MS doc says: ACM finds the best suggestion.
-     * Well, first found will be the "best"
-     */
-    mmr = ACMERR_NOTPOSSIBLE;
-    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-        /* should check for codec only */
-        if (!padid->bEnabled ||
-        acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
-        continue;
-
-        if (MSACM_Message(had, ACMDM_FORMAT_SUGGEST,
-                  (LPARAM)&adfg, 0L) == MMSYSERR_NOERROR) {
-        mmr = MMSYSERR_NOERROR;
-        break;
-        }
-        acmDriverClose(had, 0);
-    }
+        PWINE_ACMDRIVERID       padid;
+        
+        /* MS doc says: ACM finds the best suggestion. 
+         * Well, first found will be the "best"
+         */
+        mmr = ACMERR_NOTPOSSIBLE;
+        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+            /* should check for codec only */
+            if (!padid->bEnabled ||
+                acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
+                continue;
+            
+            if (MSACM_Message(had, ACMDM_FORMAT_SUGGEST, 
+                              (LPARAM)&adfg, 0L) == MMSYSERR_NOERROR) {
+                mmr = MMSYSERR_NOERROR;
+                break;
+            }
+            acmDriverClose(had, 0);
+        }
     } else {
-    mmr = MSACM_Message(had, ACMDM_FORMAT_SUGGEST, (LPARAM)&adfg, 0L);
+        mmr = MSACM_Message(had, ACMDM_FORMAT_SUGGEST, (LPARAM)&adfg, 0L);
     }
     return mmr;
@@ -568 +568 @@
  *           acmFormatTagDetailsA (MSACM32.30)
  */
-MMRESULT WINAPI acmFormatTagDetailsA(HACMDRIVER had, PACMFORMATTAGDETAILSA paftda,
-                     DWORD fdwDetails)
-{
-    ACMFORMATTAGDETAILSW    aftdw;
-    MMRESULT            mmr;
+MMRESULT WINAPI acmFormatTagDetailsA(HACMDRIVER had, PACMFORMATTAGDETAILSA paftda, 
+                                     DWORD fdwDetails)
+{
+    ACMFORMATTAGDETAILSW        aftdw;
+    MMRESULT                    mmr;
 
     memset(&aftdw, 0, sizeof(aftdw));
@@ -581 +581 @@
     mmr = acmFormatTagDetailsW(had, &aftdw, fdwDetails);
     if (mmr == MMSYSERR_NOERROR) {
-    paftda->dwFormatTag = aftdw.dwFormatTag;
-    paftda->dwFormatTagIndex = aftdw.dwFormatTagIndex;
-    paftda->cbFormatSize = aftdw.cbFormatSize;
-    paftda->fdwSupport = aftdw.fdwSupport;
-    paftda->cStandardFormats = aftdw.cStandardFormats;
+        paftda->dwFormatTag = aftdw.dwFormatTag; 
+        paftda->dwFormatTagIndex = aftdw.dwFormatTagIndex;
+        paftda->cbFormatSize = aftdw.cbFormatSize; 
+        paftda->fdwSupport = aftdw.fdwSupport; 
+        paftda->cStandardFormats = aftdw.cStandardFormats; 
         WideCharToMultiByte( CP_ACP, 0, aftdw.szFormatTag, -1, paftda->szFormatTag,
                              sizeof(paftda->szFormatTag), NULL, NULL );
@@ -595 +595 @@
  *           acmFormatTagDetailsW (MSACM32.31)
  */
-MMRESULT WINAPI acmFormatTagDetailsW(HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
-                     DWORD fdwDetails)
-{
-    PWINE_ACMDRIVERID   padid;
-    MMRESULT        mmr;
+MMRESULT WINAPI acmFormatTagDetailsW(HACMDRIVER had, PACMFORMATTAGDETAILSW paftd, 
+                                     DWORD fdwDetails)
+{
+    PWINE_ACMDRIVERID   padid;
+    MMRESULT            mmr;
 
     TRACE("(0x%08x, %p, %ld)\n", had, paftd, fdwDetails);
 
     if (fdwDetails & ~(ACM_FORMATTAGDETAILSF_FORMATTAG|ACM_FORMATTAGDETAILSF_INDEX|
-               ACM_FORMATTAGDETAILSF_LARGESTSIZE))
-    return MMSYSERR_INVALFLAG;
+                       ACM_FORMATTAGDETAILSF_LARGESTSIZE))
+        return MMSYSERR_INVALFLAG;
 
     switch (fdwDetails) {
     case ACM_FORMATTAGDETAILSF_FORMATTAG:
-    if (had == (HACMDRIVER)NULL) {
-        mmr = ACMERR_NOTPOSSIBLE;
-        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-        /* should check for codec only */
-        if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
-            mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
-                    (LPARAM)paftd, (LPARAM)fdwDetails);
-            acmDriverClose(had, 0);
-            if (mmr == MMSYSERR_NOERROR) break;
-        }
-        }
-    } else {
-        mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
-                (LPARAM)paftd, (LPARAM)fdwDetails);
-    }
-    break;
+        if (had == (HACMDRIVER)NULL) {
+            mmr = ACMERR_NOTPOSSIBLE;
+            for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+                /* should check for codec only */
+                if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
+                    mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
+                                        (LPARAM)paftd, (LPARAM)fdwDetails);
+                    acmDriverClose(had, 0);
+                    if (mmr == MMSYSERR_NOERROR) break;
+                }
+            }
+        } else {
+            mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
+                                (LPARAM)paftd, (LPARAM)fdwDetails);
+        }
+        break;
 
     case ACM_FORMATTAGDETAILSF_INDEX:
-    /* FIXME should check paftd->dwFormatTagIndex < add.cFormatTags */
-    mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
-                (LPARAM)paftd, (LPARAM)fdwDetails);
-    break;
+        /* FIXME should check paftd->dwFormatTagIndex < add.cFormatTags */
+        mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
+                            (LPARAM)paftd, (LPARAM)fdwDetails);
+        break;
 
     case ACM_FORMATTAGDETAILSF_LARGESTSIZE:
-    if (had == (HACMDRIVER)NULL) {
-        ACMFORMATTAGDETAILSW    tmp;
-        DWORD           ft = paftd->dwFormatTag;
-
-        mmr = ACMERR_NOTPOSSIBLE;
-        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-        /* should check for codec only */
-        if (padid->bEnabled &&
-            acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
-
-            memset(&tmp, 0, sizeof(tmp));
-            tmp.cbStruct = sizeof(tmp);
-            tmp.dwFormatTag = ft;
-
-            if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
-                      (LPARAM)&tmp,
-                      (LPARAM)fdwDetails) == MMSYSERR_NOERROR) {
-            if (mmr == ACMERR_NOTPOSSIBLE ||
-                paftd->cbFormatSize < tmp.cbFormatSize) {
-                *paftd = tmp;
-                mmr = MMSYSERR_NOERROR;
-            }
-            }
-            acmDriverClose(had, 0);
-        }
-        }
-    } else {
-        mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
-                (LPARAM)paftd, (LPARAM)fdwDetails);
-    }
-    break;
+        if (had == (HACMDRIVER)NULL) {
+            ACMFORMATTAGDETAILSW        tmp;
+            DWORD                       ft = paftd->dwFormatTag;
+
+            mmr = ACMERR_NOTPOSSIBLE;
+            for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
+                /* should check for codec only */
+                if (padid->bEnabled && 
+                    acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
+
+                    memset(&tmp, 0, sizeof(tmp));
+                    tmp.cbStruct = sizeof(tmp);
+                    tmp.dwFormatTag = ft;
+
+                    if (MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
+                                      (LPARAM)&tmp, 
+                                      (LPARAM)fdwDetails) == MMSYSERR_NOERROR) {
+                        if (mmr == ACMERR_NOTPOSSIBLE ||
+                            paftd->cbFormatSize < tmp.cbFormatSize) {
+                            *paftd = tmp;
+                            mmr = MMSYSERR_NOERROR;
+                        } 
+                    }
+                    acmDriverClose(had, 0);
+                }
+            }
+        } else {
+            mmr = MSACM_Message(had, ACMDM_FORMATTAG_DETAILS,
+                                (LPARAM)paftd, (LPARAM)fdwDetails);
+        }
+        break;
 
     default:
-    WARN("Unsupported fdwDetails=%08lx\n", fdwDetails);
-    mmr = MMSYSERR_ERROR;
-    }
-
-    if (mmr == MMSYSERR_NOERROR &&
-    paftd->dwFormatTag == WAVE_FORMAT_PCM && paftd->szFormatTag[0] == 0)
+        WARN("Unsupported fdwDetails=%08lx\n", fdwDetails);
+        mmr = MMSYSERR_ERROR;
+    }
+
+    if (mmr == MMSYSERR_NOERROR && 
+        paftd->dwFormatTag == WAVE_FORMAT_PCM && paftd->szFormatTag[0] == 0)
         MultiByteToWideChar( CP_ACP, 0, "PCM", -1, paftd->szFormatTag,
                              sizeof(paftd->szFormatTag)/sizeof(WCHAR) );
@@ -679 +679 @@
 
 struct MSACM_FormatTagEnumWtoA_Instance {
-    PACMFORMATTAGDETAILSA   paftda;
-    DWORD           dwInstance;
-    ACMFORMATTAGENUMCBA     fnCallback;
+    PACMFORMATTAGDETAILSA       paftda;
+    DWORD                       dwInstance;
+    ACMFORMATTAGENUMCBA         fnCallback;
 };
 
 static BOOL CALLBACK MSACM_FormatTagEnumCallbackWtoA(HACMDRIVERID hadid,
-                             PACMFORMATTAGDETAILSW paftdw,
-                             DWORD dwInstance,
-                             DWORD fdwSupport)
+                                                     PACMFORMATTAGDETAILSW paftdw,  
+                                                     DWORD dwInstance,             
+                                                     DWORD fdwSupport)
 {
     struct MSACM_FormatTagEnumWtoA_Instance* paftei;
@@ -693 +693 @@
     paftei = (struct MSACM_FormatTagEnumWtoA_Instance*)dwInstance;
 
-    paftei->paftda->dwFormatTagIndex = paftdw->dwFormatTagIndex;
-    paftei->paftda->dwFormatTag = paftdw->dwFormatTag;
-    paftei->paftda->cbFormatSize = paftdw->cbFormatSize;
-    paftei->paftda->fdwSupport = paftdw->fdwSupport;
-    paftei->paftda->cStandardFormats = paftdw->cStandardFormats;
+    paftei->paftda->dwFormatTagIndex = paftdw->dwFormatTagIndex; 
+    paftei->paftda->dwFormatTag = paftdw->dwFormatTag; 
+    paftei->paftda->cbFormatSize = paftdw->cbFormatSize; 
+    paftei->paftda->fdwSupport = paftdw->fdwSupport; 
+    paftei->paftda->cStandardFormats = paftdw->cStandardFormats; 
     WideCharToMultiByte( CP_ACP, 0, paftdw->szFormatTag, -1, paftei->paftda->szFormatTag,
                          sizeof(paftei->paftda->szFormatTag), NULL, NULL );
 
-    return (paftei->fnCallback)(hadid, paftei->paftda,
-                paftei->dwInstance, fdwSupport);
+    return (paftei->fnCallback)(hadid, paftei->paftda, 
+                                paftei->dwInstance, fdwSupport);
 }
 
@@ -709 +709 @@
  */
 MMRESULT WINAPI acmFormatTagEnumA(HACMDRIVER had, PACMFORMATTAGDETAILSA paftda,
-                  ACMFORMATTAGENUMCBA fnCallback, DWORD dwInstance,
-                  DWORD fdwEnum)
-{
-    ACMFORMATTAGDETAILSW    aftdw;
+                                  ACMFORMATTAGENUMCBA fnCallback, DWORD dwInstance, 
+                                  DWORD fdwEnum)
+{
+    ACMFORMATTAGDETAILSW        aftdw;
     struct MSACM_FormatTagEnumWtoA_Instance aftei;
 
@@ -724 +724 @@
     aftei.fnCallback = fnCallback;
 
-    return acmFormatTagEnumW(had, &aftdw, MSACM_FormatTagEnumCallbackWtoA,
-                 (DWORD)&aftei, fdwEnum);
+    return acmFormatTagEnumW(had, &aftdw, MSACM_FormatTagEnumCallbackWtoA, 
+                             (DWORD)&aftei, fdwEnum);
 }
 
@@ -732 +732 @@
  */
 MMRESULT WINAPI acmFormatTagEnumW(HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
-                  ACMFORMATTAGENUMCBW fnCallback, DWORD dwInstance,
-                  DWORD fdwEnum)
-{
-    PWINE_ACMDRIVERID       padid;
-    ACMDRIVERDETAILSW       add;
-    int             i;
-    BOOL            bPcmDone = FALSE;
+                                  ACMFORMATTAGENUMCBW fnCallback, DWORD dwInstance, 
+                                  DWORD fdwEnum)
+{
+    PWINE_ACMDRIVERID           padid;
+    ACMDRIVERDETAILSW           add;
+    int                         i;
+    BOOL                        bPcmDone = FALSE;
 
     TRACE("(0x%08x, %p, %p, %ld, %ld)\n",
-      had, paftd, fnCallback, dwInstance, fdwEnum);
+          had, paftd, fnCallback, dwInstance, fdwEnum); 
 
     if (paftd->cbStruct < sizeof(*paftd)) return MMSYSERR_INVALPARAM;
 
     if (had) FIXME("had != NULL, not supported\n");
-
+    
     for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
-    /* should check for codec only */
-    if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == MMSYSERR_NOERROR) {
-        add.cbStruct = sizeof(add);
-
-        if (acmDriverDetailsW((HACMDRIVERID)padid, &add, 0) == MMSYSERR_NOERROR) {
-        for (i = 0; i < add.cFormatTags; i++) {
-            paftd->dwFormatTagIndex = i;
-            if (acmFormatTagDetailsW(had, paftd, ACM_FORMATTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
-            if (paftd->dwFormatTag == WAVE_FORMAT_PCM) {
-                /* FIXME (EPP): I'm not sure this is the correct
-                 * algorithm (should make more sense to apply the same
-                 * for all already loaded formats, but this will do
-                 * for now
-                 */
-                if (bPcmDone) continue;
-                bPcmDone = TRUE;
-            }
-            if (!(fnCallback)((HACMDRIVERID)padid, paftd, dwInstance,
-                      add.fdwSupport)) {
-                padid = NULL;
-                break;
-            }
-            }
-        }
-        }
-    }
-    acmDriverClose(had, 0);
+        /* should check for codec only */
+        if (padid->bEnabled && acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == MMSYSERR_NOERROR) {
+            add.cbStruct = sizeof(add);
+
+            if (acmDriverDetailsW((HACMDRIVERID)padid, &add, 0) == MMSYSERR_NOERROR) {
+                for (i = 0; i < add.cFormatTags; i++) {
+                    paftd->dwFormatTagIndex = i;
+                    if (acmFormatTagDetailsW(had, paftd, ACM_FORMATTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
+                        if (paftd->dwFormatTag == WAVE_FORMAT_PCM) {
+                            /* FIXME (EPP): I'm not sure this is the correct 
+                             * algorithm (should make more sense to apply the same
+                             * for all already loaded formats, but this will do 
+                             * for now
+                             */
+                            if (bPcmDone) continue;
+                            bPcmDone = TRUE;
+                        }
+                        if (!(fnCallback)((HACMDRIVERID)padid, paftd, dwInstance, 
+                                          add.fdwSupport)) {
+                            padid = NULL;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        acmDriverClose(had, 0);
     }
     return MMSYSERR_NOERROR;

trunk/src/msacm32/initterm.cpp

@@ -1 @@
-/* $Id: initterm.cpp,v 1.7 2001-09-05 13:11:25 bird Exp $
- *
+/*
  * DLL entry point
  *
@@ -54 +53 @@
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
-    return MSACM32_LibMain(hinstDLL, fdwReason, fImpLoad);
+        return MSACM32_LibMain(hinstDLL, fdwReason, fImpLoad);
 
    case DLL_PROCESS_DETACH:
-    MSACM32_LibMain(hinstDLL, fdwReason, fImpLoad);
-    ctordtorTerm();
-    return TRUE;
+        MSACM32_LibMain(hinstDLL, fdwReason, fImpLoad);
+        ctordtorTerm();
+        return TRUE;
    }
    return FALSE;
@@ -89 +88 @@
          CheckVersionFromHMOD(PE2LX_VERSION, hModule); /*PLF Wed  98-03-18 05:28:48*/
 
-     dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab);
-         if(dllHandle == 0)
-        return 0UL;
+         dllHandle = RegisterLxDll(hModule, LibMain, (PVOID)&_Resource_PEResTab);
+         if(dllHandle == 0) 
+                return 0UL;
 
          break;
       case 1 :
          if(dllHandle) {
-        UnregisterLxDll(dllHandle);
+                UnregisterLxDll(dllHandle);
          }
          break;

trunk/src/msacm32/internal.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
-/* $Id: internal.c,v 1.2 2001-09-05 13:11:26 bird Exp $ */
+
 /*
  *      MSACM32 library
  *
  *      Copyright 1998  Patrik Stridvall
- *        1999  Eric Pouech
+ *                1999  Eric Pouech
  */
 
@@ -34 +34 @@
 
 /***********************************************************************
- *           MSACM_RegisterDriver()
+ *           MSACM_RegisterDriver() 
  */
 PWINE_ACMDRIVERID MSACM_RegisterDriver(LPSTR pszDriverAlias, LPSTR pszFileName,
-                       HINSTANCE hinstModule)
-{
+                                       HINSTANCE hinstModule)
+{ 
     PWINE_ACMDRIVERID padid;
 
@@ -64 +64 @@
     padid->pPrevACMDriverID = MSACM_pLastACMDriverID;
     if (MSACM_pLastACMDriverID)
-    MSACM_pLastACMDriverID->pNextACMDriverID = padid;
+        MSACM_pLastACMDriverID->pNextACMDriverID = padid;
     MSACM_pLastACMDriverID = padid;
     if (!MSACM_pFirstACMDriverID)
-    MSACM_pFirstACMDriverID = padid;
-
+        MSACM_pFirstACMDriverID = padid;
+    
     return padid;
 }
 
 /***********************************************************************
- *           MSACM_RegisterAllDrivers()
+ *           MSACM_RegisterAllDrivers() 
  */
 void MSACM_RegisterAllDrivers(void)
@@ -80 +80 @@
     DWORD dwBufferLength;
 
-    /* FIXME
+    /* FIXME 
      *  What if the user edits system.ini while the program is running?
      *  Does Windows handle that?
      */
     if (MSACM_pFirstACMDriverID)
-    return;
-
+        return;
+    
     /* FIXME: Do not work! How do I determine the section length? */
     dwBufferLength = 1024;
-/* EPP  GetPrivateProfileSectionA("drivers32", NULL, 0, "system.ini"); */
-
+/* EPP  GetPrivateProfileSectionA("drivers32", NULL, 0, "system.ini"); */
+    
     pszBuffer = (LPSTR) HeapAlloc(MSACM_hHeap, 0, dwBufferLength);
     if (GetPrivateProfileSectionA("drivers32", pszBuffer, dwBufferLength, "system.ini")) {
-    char* s = pszBuffer;
-    while (*s) {
-        if (!strncasecmp("MSACM.", s, 6)) {
-        char *s2 = s;
-        while (*s2 != '\0' && *s2 != '=') s2++;
-        if (*s2) {
-            *s2 = '\0';
-            MSACM_RegisterDriver(s, s2 + 1, 0);
-            *s2 = '=';
-        }
-        }
-        s += strlen(s) + 1; /* Either next char or \0 */
+        char* s = pszBuffer;
+        while (*s) {
+            if (!strncasecmp("MSACM.", s, 6)) {
+                char *s2 = s;
+                while (*s2 != '\0' && *s2 != '=') s2++;
+                if (*s2) {
+                    *s2 = '\0';
+                    MSACM_RegisterDriver(s, s2 + 1, 0);
+                    *s2 = '=';
+                }
+            }  
+            s += strlen(s) + 1; /* Either next char or \0 */
+        }
     }
-    }
-
+    
     HeapFree(MSACM_hHeap, 0, pszBuffer);
 
@@ -119 +119 @@
 {
     PWINE_ACMDRIVERID pNextACMDriverID;
-
+    
     while (p->pACMDriverList)
-    acmDriverClose((HACMDRIVER) p->pACMDriverList, 0);
-
+        acmDriverClose((HACMDRIVER) p->pACMDriverList, 0);
+    
     if (p->pszDriverAlias)
-    HeapFree(MSACM_hHeap, 0, p->pszDriverAlias);
+        HeapFree(MSACM_hHeap, 0, p->pszDriverAlias);
     if (p->pszFileName)
-    HeapFree(MSACM_hHeap, 0, p->pszFileName);
-
+        HeapFree(MSACM_hHeap, 0, p->pszFileName);
+    
     if (p == MSACM_pFirstACMDriverID)
-    MSACM_pFirstACMDriverID = p->pNextACMDriverID;
+        MSACM_pFirstACMDriverID = p->pNextACMDriverID;
     if (p == MSACM_pLastACMDriverID)
-    MSACM_pLastACMDriverID = p->pPrevACMDriverID;
+        MSACM_pLastACMDriverID = p->pPrevACMDriverID;
 
     if (p->pPrevACMDriverID)
-    p->pPrevACMDriverID->pNextACMDriverID = p->pNextACMDriverID;
+        p->pPrevACMDriverID->pNextACMDriverID = p->pNextACMDriverID;
     if (p->pNextACMDriverID)
-    p->pNextACMDriverID->pPrevACMDriverID = p->pPrevACMDriverID;
-
+        p->pNextACMDriverID->pPrevACMDriverID = p->pPrevACMDriverID;
+    
     pNextACMDriverID = p->pNextACMDriverID;
-
+    
     HeapFree(MSACM_hHeap, 0, p);
-
+    
     return pNextACMDriverID;
 }
@@ -162 +162 @@
 PWINE_ACMOBJ MSACM_GetObj(HACMOBJ hObj, DWORD type)
 {
-    PWINE_ACMOBJ    pao = (PWINE_ACMOBJ)hObj;
+    PWINE_ACMOBJ        pao = (PWINE_ACMOBJ)hObj;
 
     if (pao == NULL || IsBadReadPtr(pao, sizeof(WINE_ACMOBJ)) ||
-    ((type != WINE_ACMOBJ_DONTCARE) && (type != pao->dwType)))
-    return NULL;
+        ((type != WINE_ACMOBJ_DONTCARE) && (type != pao->dwType)))
+        return NULL;
     return pao;
 }
 
 /***********************************************************************
- *           MSACM_GetDriverID()
+ *           MSACM_GetDriverID() 
  */
 PWINE_ACMDRIVERID MSACM_GetDriverID(HACMDRIVERID hDriverID)
@@ -191 +191 @@
 MMRESULT MSACM_Message(HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
 {
-    PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
+    PWINE_ACMDRIVER     pad = MSACM_GetDriver(had);
 
     return pad ? SendDriverMessage(pad->hDrvr, uMsg, lParam1, lParam2) : MMSYSERR_INVALHANDLE;

trunk/src/msacm32/msacm32_main.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
-/* $Id: msacm32_main.c,v 1.2 2001-09-05 13:11:26 bird Exp $ */
+
 /*
  *      MSACM32 library
  *
  *      Copyright 1998  Patrik Stridvall
- *        1999  Eric Pouech
+ *                1999  Eric Pouech
  */
 
@@ -17 +17 @@
 
 DEFAULT_DEBUG_CHANNEL(msacm);
-
+        
 /**********************************************************************/
-
-HINSTANCE   MSACM_hInstance32 = 0;
+        
+HINSTANCE       MSACM_hInstance32 = 0;
 
 /***********************************************************************
- *           MSACM_LibMain (MSACM32.init)
+ *           MSACM_LibMain (MSACM32.init) 
  */
 BOOL WINAPI MSACM32_LibMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved)
@@ -34 +34 @@
         MSACM_hInstance32 = hInstDLL;
         MSACM_RegisterAllDrivers();
-    break;
+        break;
     case DLL_PROCESS_DETACH:
         MSACM_UnregisterAllDrivers();
@@ -40 +40 @@
         MSACM_hHeap = (HANDLE) NULL;
         MSACM_hInstance32 = (HINSTANCE)NULL;
-    break;
+        break;
     case DLL_THREAD_ATTACH:
-    break;
+        break;
     case DLL_THREAD_DETACH:
-    break;
+        break;
     default:
-    break;
+        break;
     }
     return TRUE;
@@ -67 +67 @@
     {
     case VER_PLATFORM_WIN32_NT:
-    return 0x04000565; /* 4.0.1381 */
+        return 0x04000565; /* 4.0.1381 */
     default:
         FIXME("%ld not supported",version.dwPlatformId);
     case VER_PLATFORM_WIN32_WINDOWS:
-    return 0x04000000; /* 4.0.0 */
+        return 0x04000000; /* 4.0.0 */
   }
 }
@@ -86 +86 @@
 MMRESULT WINAPI acmMetrics(HACMOBJ hao, UINT uMetric, LPVOID pMetric)
 {
-    PWINE_ACMOBJ    pao = MSACM_GetObj(hao, WINE_ACMOBJ_DONTCARE);
-    BOOL        bLocal = TRUE;
-    PWINE_ACMDRIVERID   padid;
-    DWORD       val = 0;
-    MMRESULT        mmr = MMSYSERR_NOERROR;
+    PWINE_ACMOBJ        pao = MSACM_GetObj(hao, WINE_ACMOBJ_DONTCARE);
+    BOOL                bLocal = TRUE;
+    PWINE_ACMDRIVERID   padid;
+    DWORD               val = 0;
+    MMRESULT            mmr = MMSYSERR_NOERROR;
 
     TRACE("(0x%08x, %d, %p);\n", hao, uMetric, pMetric);
-
+    
     switch (uMetric) {
     case ACM_METRIC_COUNT_DRIVERS:
-    bLocal = FALSE;
-    /* fall thru */
+        bLocal = FALSE;
+        /* fall thru */
     case ACM_METRIC_COUNT_LOCAL_DRIVERS:
-    if (!pao)
-        return MMSYSERR_INVALHANDLE;
-    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
-        if (padid->bEnabled /* && (local(padid) || !bLocal) */)
-        val++;
-    *(LPDWORD)pMetric = val;
-    break;
+        if (!pao)
+            return MMSYSERR_INVALHANDLE;
+        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
+            if (padid->bEnabled /* && (local(padid) || !bLocal) */)
+                val++;
+        *(LPDWORD)pMetric = val;
+        break;
 
     case ACM_METRIC_COUNT_CODECS:
-    if (!pao)
-        return MMSYSERR_INVALHANDLE;
-    bLocal = FALSE;
-    /* fall thru */
+        if (!pao)
+            return MMSYSERR_INVALHANDLE;
+        bLocal = FALSE;
+        /* fall thru */
     case ACM_METRIC_COUNT_LOCAL_CODECS:
-    /* FIXME: don't know how to differentiate codec, converters & filters yet */
-    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
-        if (padid->bEnabled /* && (local(padid) || !bLocal) */)
-        val++;
-    *(LPDWORD)pMetric = val;
-    break;
+        /* FIXME: don't know how to differentiate codec, converters & filters yet */
+        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
+            if (padid->bEnabled /* && (local(padid) || !bLocal) */)
+                val++;
+        *(LPDWORD)pMetric = val;
+        break;
 
     case ACM_METRIC_COUNT_CONVERTERS:
-    bLocal = FALSE;
-    /* fall thru */
+        bLocal = FALSE;
+        /* fall thru */
     case ACM_METRIC_COUNT_LOCAL_CONVERTERS:
-    /* FIXME: don't know how to differentiate codec, converters & filters yet */
-    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
-        if (padid->bEnabled /* && (local(padid) || !bLocal) */)
-        val++;
-    *(LPDWORD)pMetric = val;
-    break;
+        /* FIXME: don't know how to differentiate codec, converters & filters yet */
+        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
+            if (padid->bEnabled /* && (local(padid) || !bLocal) */)
+                val++;
+        *(LPDWORD)pMetric = val;
+        break;
 
     case ACM_METRIC_COUNT_FILTERS:
-    bLocal = FALSE;
-    /* fall thru */
+        bLocal = FALSE;
+        /* fall thru */
     case ACM_METRIC_COUNT_LOCAL_FILTERS:
-    /* FIXME: don't know how to differentiate codec, converters & filters yet */
-    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
-        if (padid->bEnabled /* && (local(padid) || !bLocal) */)
-        val++;
-    *(LPDWORD)pMetric = val;
-    break;
+        /* FIXME: don't know how to differentiate codec, converters & filters yet */
+        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
+            if (padid->bEnabled /* && (local(padid) || !bLocal) */)
+                val++;
+        *(LPDWORD)pMetric = val;
+        break;
 
     case ACM_METRIC_COUNT_DISABLED:
-    bLocal = FALSE;
-    /* fall thru */
+        bLocal = FALSE;
+        /* fall thru */
     case ACM_METRIC_COUNT_LOCAL_DISABLED:
-    if (!pao)
-        return MMSYSERR_INVALHANDLE;
-    for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
-        if (!padid->bEnabled /* && (local(padid) || !bLocal) */)
-        val++;
-    *(LPDWORD)pMetric = val;
-    break;
+        if (!pao)
+            return MMSYSERR_INVALHANDLE;  
+        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
+            if (!padid->bEnabled /* && (local(padid) || !bLocal) */)
+                val++;
+        *(LPDWORD)pMetric = val;
+        break;
+    
+    case ACM_METRIC_MAX_SIZE_FORMAT:
+        {
+            ACMFORMATTAGDETAILSW        aftd;
 
-    case ACM_METRIC_MAX_SIZE_FORMAT:
-    {
-        ACMFORMATTAGDETAILSW    aftd;
+            aftd.cbStruct = sizeof(aftd);
+            aftd.dwFormatTag = WAVE_FORMAT_UNKNOWN;
 
-        aftd.cbStruct = sizeof(aftd);
-        aftd.dwFormatTag = WAVE_FORMAT_UNKNOWN;
-
-        if (hao == (HACMOBJ)NULL) {
-        mmr = acmFormatTagDetailsW((HACMDRIVER)NULL, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
-        } else if (MSACM_GetObj(hao, WINE_ACMOBJ_DRIVER)) {
-        mmr = acmFormatTagDetailsW((HACMDRIVER)hao, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
-        } else if (MSACM_GetObj(hao, WINE_ACMOBJ_DRIVERID)) {
-        HACMDRIVER  had;
-
-        if (acmDriverOpen(&had, (HACMDRIVERID)hao, 0) == 0) {
-            mmr = acmFormatTagDetailsW((HACMDRIVER)hao, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
-            acmDriverClose(had, 0);
-        }
-        } else {
-        mmr = MMSYSERR_INVALHANDLE;
-        }
-        if (mmr == MMSYSERR_NOERROR) *(LPDWORD)pMetric = aftd.cbFormatSize;
-    }
+            if (hao == (HACMOBJ)NULL) {
+                mmr = acmFormatTagDetailsW((HACMDRIVER)NULL, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
+            } else if (MSACM_GetObj(hao, WINE_ACMOBJ_DRIVER)) {
+                mmr = acmFormatTagDetailsW((HACMDRIVER)hao, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
+            } else if (MSACM_GetObj(hao, WINE_ACMOBJ_DRIVERID)) {
+                HACMDRIVER      had;
+                
+                if (acmDriverOpen(&had, (HACMDRIVERID)hao, 0) == 0) {
+                    mmr = acmFormatTagDetailsW((HACMDRIVER)hao, &aftd, ACM_FORMATTAGDETAILSF_LARGESTSIZE);
+                    acmDriverClose(had, 0);
+                }
+            } else {
+                mmr = MMSYSERR_INVALHANDLE;
+            }
+            if (mmr == MMSYSERR_NOERROR) *(LPDWORD)pMetric = aftd.cbFormatSize;
+        }
         break;
 
@@ -186 +186 @@
     case ACM_METRIC_DRIVER_PRIORITY:
     default:
-    FIXME("(0x%08x, %d, %p): stub\n", hao, uMetric, pMetric);
-    mmr = MMSYSERR_NOTSUPPORTED;
+        FIXME("(0x%08x, %d, %p): stub\n", hao, uMetric, pMetric);
+        mmr = MMSYSERR_NOTSUPPORTED;
     }
     return mmr;

trunk/src/msacm32/pcmconverter.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
-/* $Id: pcmconverter.c,v 1.2 2001-09-05 13:11:26 bird Exp $ */
+
 /*
  *      MSACM32 library
  *
- *      Copyright 2000      Eric Pouech
- *
- *  FIXME / TODO list
- *  + most of the computation should be done in fixed point arithmetic
- *    instead of floating point (16 bits for integral part, and 16 bits
- *    for fractional part for example)
- *  + implement PCM_FormatSuggest function
- *  + get rid of hack for PCM_DriverProc (msacm32.dll shouldn't export
- *    a DriverProc, but this would require implementing a generic
- *    embedded driver handling scheme in msacm32.dll which isn't done yet
+ *      Copyright 2000          Eric Pouech
+ *
+ *      FIXME / TODO list
+ *      + most of the computation should be done in fixed point arithmetic 
+ *        instead of floating point (16 bits for integral part, and 16 bits
+ *        for fractional part for example)
+ *      + implement PCM_FormatSuggest function
+ *      + get rid of hack for PCM_DriverProc (msacm32.dll shouldn't export
+ *        a DriverProc, but this would require implementing a generic
+ *        embedded driver handling scheme in msacm32.dll which isn't done yet
  */
 
@@ -35 +35 @@
  *           PCM_drvOpen
  */
-static  DWORD   PCM_drvOpen(LPCSTR str)
+static  DWORD   PCM_drvOpen(LPCSTR str)
 {
     return 1;
@@ -43 +43 @@
  *           PCM_drvClose
  */
-static  DWORD   PCM_drvClose(DWORD dwDevID)
+static  DWORD   PCM_drvClose(DWORD dwDevID)
 {
     return 1;
 }
 
-#define NUM_PCM_FORMATS (sizeof(PCM_Formats) / sizeof(PCM_Formats[0]))
-#define NUM_OF(a,b) (((a)+(b)-1)/(b))
+#define NUM_PCM_FORMATS (sizeof(PCM_Formats) / sizeof(PCM_Formats[0]))
+#define NUM_OF(a,b)     (((a)+(b)-1)/(b))
 
 /* flags for fdwDriver */
-#define PCM_RESAMPLE    1
+#define PCM_RESAMPLE    1
 
 /* data used while converting */
@@ -58 +58 @@
     /* conversion routine, depending if rate conversion is required */
     union {
-    void (*cvtKeepRate)(const unsigned char*, int, unsigned char*);
-    void (*cvtChangeRate)(struct tagAcmPcmData*, const unsigned char*,
-                  LPDWORD, unsigned char*, LPDWORD);
+        void (*cvtKeepRate)(const unsigned char*, int, unsigned char*);
+        void (*cvtChangeRate)(struct tagAcmPcmData*, const unsigned char*, 
+                              LPDWORD, unsigned char*, LPDWORD);
     } cvt;
     /* the following fields are used only with rate conversion) */
-    DWORD   srcPos;     /* position in source stream */
-    double  dstPos;     /* position in destination stream */
-    double  dstIncr;    /* value to increment dst stream when src stream
-                   is incremented by 1 */
+    DWORD       srcPos;         /* position in source stream */
+    double      dstPos;         /* position in destination stream */
+    double      dstIncr;        /* value to increment dst stream when src stream 
+                                   is incremented by 1 */
     /* last source stream value read */
     union {
-    unsigned char   b;  /*  8 bit value */
-    short       s;  /* 16 bit value */
+        unsigned char   b;      /*  8 bit value */
+        short           s;      /* 16 bit value */
     } last[2]; /* two channels max (stereo) */
 } AcmPcmData;
@@ -77 +77 @@
  * also helps given a unique index to each of the supported formats
  */
-static  struct {
-    int     nChannels;
-    int     nBits;
-    int     rate;
+static  struct {
+    int         nChannels;
+    int         nBits;
+    int         rate;
 } PCM_Formats[] = {
     {1,  8,  8000}, {2,  8,  8000}, {1, 16,  8000}, {2, 16,  8000},
@@ -91 +91 @@
  *           PCM_GetFormatIndex
  */
-static  DWORD   PCM_GetFormatIndex(LPWAVEFORMATEX wfx)
+static  DWORD   PCM_GetFormatIndex(LPWAVEFORMATEX wfx)
 {
     int i;
-
+    
     for (i = 0; i < NUM_PCM_FORMATS; i++) {
-    if (wfx->nChannels == PCM_Formats[i].nChannels &&
-        wfx->nSamplesPerSec == PCM_Formats[i].rate &&
-        wfx->wBitsPerSample == PCM_Formats[i].nBits)
-        return i;
+        if (wfx->nChannels == PCM_Formats[i].nChannels &&
+            wfx->nSamplesPerSec == PCM_Formats[i].rate &&
+            wfx->wBitsPerSample == PCM_Formats[i].nBits)
+            return i;
     }
     return 0xFFFFFFFF;
@@ -107 +107 @@
  *
  * parameters:
- *  + 8 bit unsigned vs 16 bit signed
- *  + mono vs stereo (1 or 2 channels)
- *  + sampling rate (8.0, 11.025, 22.05, 44.1 kHz are defined, but algo shall work
- *    in all cases)
+ *      + 8 bit unsigned vs 16 bit signed
+ *      + mono vs stereo (1 or 2 channels)
+ *      + sampling rate (8.0, 11.025, 22.05, 44.1 kHz are defined, but algo shall work
+ *        in all cases)
  *
  * mono => stereo: copy the same sample on Left & Right channels
  * stereo =) mono: use the average value of samples from Left & Right channels
  * resampling; we lookup for each destination sample the two source adjacent samples
- *  were src <= dst < src+1 (dst is increased by a fractional value which is
- *  equivalent to the increment by one on src); then we use a linear
- *  interpolation between src and src+1
+ *      were src <= dst < src+1 (dst is increased by a fractional value which is 
+ *      equivalent to the increment by one on src); then we use a linear
+ *      interpolation between src and src+1
  */
 
@@ -125 +125 @@
  * Converts a 8 bit sample to a 16 bit one
  */
-static inline short C816(unsigned char b)
+static inline short C816(unsigned char b) 
 {
     return (short)(b ^ 0x80) * 256;
@@ -135 +135 @@
  * Converts a 16 bit sample to a 8 bit one (data loss !!)
  */
-static inline unsigned char C168(short s)
+static inline unsigned char C168(short s) 
 {
     return HIBYTE(s) ^ (unsigned char)0x80;
@@ -164 +164 @@
  *           M16
  *
- * Convert the (l,r) 16 bit stereo sample into a 16 bit mono
+ * Convert the (l,r) 16 bit stereo sample into a 16 bit mono 
  * (takes the mid-point of the two values)
  */
@@ -175 +175 @@
  *           M8
  *
- * Convert the (l,r) 8 bit stereo sample into a 8 bit mono
+ * Convert the (l,r) 8 bit stereo sample into a 8 bit mono 
  * (takes the mid-point of the two values)
  */
@@ -194 +194 @@
  */
 
-static  void cvtMM88K(const unsigned char* src, int ns, unsigned char* dst)
+static  void cvtMM88K(const unsigned char* src, int ns, unsigned char* dst)
 {
     memcpy(dst, src, ns);
 }
 
-static  void cvtSS88K(const unsigned char* src, int ns, unsigned char* dst)
+static  void cvtSS88K(const unsigned char* src, int ns, unsigned char* dst)
 {
     memcpy(dst, src, ns * 2);
 }
 
-static  void cvtMM1616K(const unsigned char* src, int ns, unsigned char* dst)
+static  void cvtMM1616K(const unsigned char* src, int ns, unsigned char* dst)
 {
     memcpy(dst, src, ns * 2);
 }
 
-static  void cvtSS1616K(const unsigned char* src, int ns, unsigned char* dst)
+static  void cvtSS1616K(const unsigned char* src, int ns, unsigned char* dst)
 {
     memcpy(dst, src, ns * 4);
 }
 
-static  void cvtMS88K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    while (ns--) {
-    *dst++ = *src;
-    *dst++ = *src++;
-    }
-}
-
-static  void cvtMS816K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    short   v;
-
-    while (ns--) {
-    v = C816(*src++);
-    W16(dst, v);        dst += 2;
-    W16(dst, v);        dst += 2;
-    }
-}
-
-static  void cvtMS168K(const unsigned char* src, int ns, unsigned char* dst)
+static  void cvtMS88K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    while (ns--) {
+        *dst++ = *src;
+        *dst++ = *src++;
+    }
+}
+
+static  void cvtMS816K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    short       v;
+    
+    while (ns--) {
+        v = C816(*src++);
+        W16(dst, v);            dst += 2;
+        W16(dst, v);            dst += 2;
+    }
+}
+
+static  void cvtMS168K(const unsigned char* src, int ns, unsigned char* dst)
 {
     unsigned char v;
-
-    while (ns--) {
-    v = C168(R16(src));     src += 2;
-    *dst++ = v;
-    *dst++ = v;
-    }
-}
-
-static  void cvtMS1616K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    short   v;
-
-    while (ns--) {
-    v = R16(src);       src += 2;
-    W16(dst, v);        dst += 2;
-    W16(dst, v);        dst += 2;
-    }
-}
-
-static  void cvtSM88K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    while (ns--) {
-    *dst++ = M8(src[0], src[1]);
-    src += 2;
-    }
-}
-
-static  void cvtSM816K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    short   v;
-
-    while (ns--) {
-    v = M16(C816(src[0]), C816(src[1]));
-    src += 2;
-    W16(dst, v);        dst += 2;
-    }
-}
-
-static  void cvtSM168K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    while (ns--) {
-    *dst++ = C168(M16(R16(src), R16(src + 2)));
-    src += 4;
-    }
-}
-
-static  void cvtSM1616K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    while (ns--) {
-    W16(dst, M16(R16(src),R16(src+2))); dst += 2;
-    src += 4;
-    }
-}
-
-static  void cvtMM816K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    while (ns--) {
-    W16(dst, C816(*src++));     dst += 2;
-    }
-}
-
-static  void cvtSS816K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    while (ns--) {
-    W16(dst, C816(*src++)); dst += 2;
-    W16(dst, C816(*src++)); dst += 2;
-    }
-}
-
-static  void cvtMM168K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    while (ns--) {
-    *dst++ = C168(R16(src));    src += 2;
-    }
-}
-
-static  void cvtSS168K(const unsigned char* src, int ns, unsigned char* dst)
-{
-    while (ns--) {
-    *dst++ = C168(R16(src));    src += 2;
-    *dst++ = C168(R16(src));    src += 2;
-    }
-}
-
-static  void (*PCM_ConvertKeepRate[16])(const unsigned char*, int, unsigned char*) = {
-    cvtSS88K,   cvtSM88K,   cvtMS88K,   cvtMM88K,
-    cvtSS816K,  cvtSM816K,  cvtMS816K,  cvtMM816K,
-    cvtSS168K,  cvtSM168K,  cvtMS168K,  cvtMM168K,
+    
+    while (ns--) {
+        v = C168(R16(src));             src += 2;
+        *dst++ = v;
+        *dst++ = v;
+    }
+}
+
+static  void cvtMS1616K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    short       v;
+
+    while (ns--) {
+        v = R16(src);           src += 2;
+        W16(dst, v);            dst += 2;
+        W16(dst, v);            dst += 2;
+    }
+}
+
+static  void cvtSM88K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    while (ns--) {
+        *dst++ = M8(src[0], src[1]);
+        src += 2;
+    }
+}
+
+static  void cvtSM816K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    short       v;
+    
+    while (ns--) {
+        v = M16(C816(src[0]), C816(src[1]));
+        src += 2;
+        W16(dst, v);            dst += 2;
+    }
+}
+
+static  void cvtSM168K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    while (ns--) {
+        *dst++ = C168(M16(R16(src), R16(src + 2)));
+        src += 4;
+    }
+}
+
+static  void cvtSM1616K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    while (ns--) {
+        W16(dst, M16(R16(src),R16(src+2)));     dst += 2;
+        src += 4;
+    }
+}
+
+static  void cvtMM816K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    while (ns--) {
+        W16(dst, C816(*src++));         dst += 2;
+    }
+}
+
+static  void cvtSS816K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    while (ns--) {
+        W16(dst, C816(*src++)); dst += 2;
+        W16(dst, C816(*src++)); dst += 2;
+    }
+}
+
+static  void cvtMM168K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    while (ns--) {
+        *dst++ = C168(R16(src));        src += 2;
+    }
+}
+
+static  void cvtSS168K(const unsigned char* src, int ns, unsigned char* dst)
+{
+    while (ns--) {
+        *dst++ = C168(R16(src));        src += 2;
+        *dst++ = C168(R16(src));        src += 2;
+    }
+}
+
+static  void (*PCM_ConvertKeepRate[16])(const unsigned char*, int, unsigned char*) = {
+    cvtSS88K,   cvtSM88K,   cvtMS88K,   cvtMM88K,
+    cvtSS816K,  cvtSM816K,  cvtMS816K,  cvtMM816K,
+    cvtSS168K,  cvtSM168K,  cvtMS168K,  cvtMM168K,
     cvtSS1616K, cvtSM1616K, cvtMS1616K, cvtMM1616K,
 };
@@ -333 +333 @@
  * Linear interpolation is used
  */
-static  inline double   I(double v1, double v2, double r)
+static  inline double   I(double v1, double v2, double r)
 {
     if (0.0 >= r || r > 1.0) FIXME("r!! %f\n", r);
@@ -339 +339 @@
 }
 
-static  void cvtSS88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
-              unsigned char* dst, LPDWORD ndst)
-{
-    double          r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-        if (*nsrc == 0) return;
-        apd->last[0].b = *src++;
-        apd->last[1].b = *src++;
-        apd->srcPos++;
-        (*nsrc)--;
-    }
-    /* now do the interpolation */
-    *dst++ = I(apd->last[0].b, src[0], r);
-    *dst++ = I(apd->last[1].b, src[1], r);
-    apd->dstPos += apd->dstIncr;
-    (*ndst)--;
+static  void cvtSS88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
+                      unsigned char* dst, LPDWORD ndst)
+{
+    double              r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+            if (*nsrc == 0) return;
+            apd->last[0].b = *src++;
+            apd->last[1].b = *src++;
+            apd->srcPos++;
+            (*nsrc)--;
+        }
+        /* now do the interpolation */
+        *dst++ = I(apd->last[0].b, src[0], r);
+        *dst++ = I(apd->last[1].b, src[1], r);
+        apd->dstPos += apd->dstIncr;
+        (*ndst)--;
     }
 }
@@ -368 +368 @@
  *
  */
-static  void cvtSM88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
-              unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-        if (*nsrc == 0) return;
-        apd->last[0].b = *src++;
-        apd->last[1].b = *src++;
-        apd->srcPos++;
-        (*nsrc)--;
-    }
-    /* now do the interpolation */
-    *dst++ = I(M8(apd->last[0].b, apd->last[1].b), M8(src[0], src[1]), r);
-    apd->dstPos += apd->dstIncr;
-    (*ndst)--;
-    }
-}
-
-static  void cvtMS88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
-              unsigned char* dst, LPDWORD ndst)
-{
-    double  r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-        if (*nsrc == 0) return;
-        apd->last[0].b = *src++;
-        apd->srcPos++;
-        (*nsrc)--;
-    }
-    /* now do the interpolation */
-    dst[0] = dst[1] = I(apd->last[0].b, src[0], r);
-    dst += 2;
-    apd->dstPos += apd->dstIncr;
-    (*ndst)--;
-    }
-}
-
-static  void cvtMM88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
-              unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-        if (*nsrc == 0) return;
-        apd->last[0].b = *src++;
-        apd->srcPos++;
-        (*nsrc)--;
-    }
-    /* now do the interpolation */
-    *dst++ = I(apd->last[0].b, src[0], r);
-    apd->dstPos += apd->dstIncr;
-    (*ndst)--;
-    }
-}
-
-static  void cvtSS816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
-               unsigned char* dst, LPDWORD ndst)
-{
-    double  r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-        if (*nsrc == 0) return;
-        apd->last[0].b = *src++;
-        apd->last[1].b = *src++;
-        apd->srcPos++;
-        (*nsrc)--;
-    }
-    /* now do the interpolation */
-    W16(dst, I(C816(apd->last[0].b), C816(src[0]), r)); dst += 2;
-    W16(dst, I(C816(apd->last[1].b), C816(src[1]), r)); dst += 2;
-    apd->dstPos += apd->dstIncr;
-    (*ndst)--;
-    }
-}
-
-static  void cvtSM816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
-            unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-        if (*nsrc == 0) return;
-        apd->last[0].b = *src++;
-        apd->last[1].b = *src++;
-        apd->srcPos++;
-        (*nsrc)--;
-    }
-    /* now do the interpolation */
-    W16(dst, I(M16(C816(apd->last[0].b), C816(apd->last[1].b)),
-            M16(C816(src[0]), C816(src[1])), r));
-    dst += 2;
-    apd->dstPos += apd->dstIncr;
-    (*ndst)--;
-    }
-}
-
-static  void cvtMS816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
-            unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-    short   v;
-
-    while (*nsrc != 0 && *ndst != 0) {
-    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-        if (*nsrc == 0) return;
-        apd->last[0].b = *src++;
-        apd->srcPos++;
-        (*nsrc)--;
-    }
-    /* now do the interpolation */
-    v = I(C816(apd->last[0].b), C816(src[0]), r);
-    W16(dst, v);        dst += 2;
-    W16(dst, v);        dst += 2;
-    apd->dstPos += apd->dstIncr;
-    (*ndst)--;
-    }
-}
-
-static  void cvtMM816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
-            unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-        if (*nsrc == 0) return;
-        apd->last[0].b = *src++;
-        apd->srcPos++;
-        (*nsrc)--;
-    }
-    /* now do the interpolation */
-    W16(dst, I(C816(apd->last[0].b), C816(src[0]), r));
-    dst += 2;
-    apd->dstPos += apd->dstIncr;
-    (*ndst)--;
-    }
-}
-
-static  void cvtSS168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
-            unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-        if (*nsrc == 0) return;
-        apd->last[0].s = R16(src);  src += 2;
-        apd->last[1].s = R16(src);  src += 2;
-        apd->srcPos++;
-        (*nsrc)--;
-    }
-    /* now do the interpolation */
-    *dst++ = C168(I(apd->last[0].s, R16(src)  , r));
-    *dst++ = C168(I(apd->last[1].s, R16(src+2), r));
-    apd->dstPos += apd->dstIncr;
-    (*ndst)--;
-    }
-}
-
-static  void cvtSM168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
-            unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-        if (*nsrc == 0) return;
-        apd->last[0].s = R16(src);  src += 2;
-        apd->last[1].s = R16(src);  src += 2;
-        apd->srcPos++;
-        (*nsrc)--;
-    }
-    /* now do the interpolation */
-    *dst++ = C168(I(M16(apd->last[0].s, apd->last[1].s),
-            M16(R16(src), R16(src + 2)), r));
-    apd->dstPos += apd->dstIncr;
-    (*ndst)--;
-    }
-}
-
-
-static  void cvtMS168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
-            unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-        if (*nsrc == 0) return;
-        apd->last[0].s = R16(src);  src += 2;
-        apd->srcPos++;
-        (*nsrc)--;
-    }
-    /* now do the interpolation */
-    dst[0] = dst[1] = C168(I(apd->last[0].s, R16(src), r)); dst += 2;
-    apd->dstPos += apd->dstIncr;
-    (*ndst)--;
-    }
-}
-
-
-static  void cvtMM168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
-            unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-        if (*nsrc == 0) return;
-        apd->last[0].s = R16(src);  src += 2;
-        apd->srcPos++;
-        (*nsrc)--;
-    }
-    /* now do the interpolation */
-    *dst++ = C168(I(apd->last[0].s, R16(src), r));
-    apd->dstPos += apd->dstIncr;
-    (*ndst)--;
-    }
-}
-
-static  void cvtSS1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
-            unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-        if (*nsrc == 0) return;
-        apd->last[0].s = R16(src);  src += 2;
-        apd->last[1].s = R16(src);  src += 2;
-        apd->srcPos++;
-        (*nsrc)--;
-    }
-    /* now do the interpolation */
-    W16(dst, I(apd->last[0].s, R16(src)  , r)); dst += 2;
-    W16(dst, I(apd->last[1].s, R16(src+2), r)); dst += 2;
-    apd->dstPos += apd->dstIncr;
-    (*ndst)--;
-    }
-}
-
-static  void cvtSM1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
-            unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-        if (*nsrc == 0) return;
-        apd->last[0].s = R16(src);  src += 2;
-        apd->last[1].s = R16(src);  src += 2;
-        apd->srcPos++;
-        (*nsrc)--;
-    }
-    /* now do the interpolation */
-    W16(dst, I(M16(apd->last[0].s, apd->last[1].s),
-           M16(R16(src), R16(src+2)), r));
-    dst += 2;
-    apd->dstPos += apd->dstIncr;
-    (*ndst)--;
-    }
-}
-
-static  void cvtMS1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
-            unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-    short   v;
-
-    while (*nsrc != 0 && *ndst != 0) {
-    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-        if (*nsrc == 0) return;
-        apd->last[0].s = R16(src);  src += 2;
-        apd->srcPos++;
-        (*nsrc)--;
-    }
-    /* now do the interpolation */
-    v = I(apd->last[0].s, R16(src), r);
-    W16(dst, v);        dst += 2;
-    W16(dst, v);        dst += 2;
-    apd->dstPos += apd->dstIncr;
-    (*ndst)--;
-    }
-}
-
-static  void cvtMM1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc,
-            unsigned char* dst, LPDWORD ndst)
-{
-    double      r;
-
-    while (*nsrc != 0 && *ndst != 0) {
-    while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
-        if (*nsrc == 0) return;
-        apd->last[0].s = R16(src);  src += 2;
-        apd->srcPos++;
-        (*nsrc)--;
-    }
-    /* now do the interpolation */
-    W16(dst, I(apd->last[0].s, R16(src), r));   dst += 2;
-    apd->dstPos += apd->dstIncr;
-    (*ndst)--;
-    }
-}
-
-static  void (*PCM_ConvertChangeRate[16])(AcmPcmData* apd,
-                      const unsigned char* src, LPDWORD nsrc,
-                      unsigned char* dst, LPDWORD ndst) = {
+static  void cvtSM88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
+                      unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+            if (*nsrc == 0) return;
+            apd->last[0].b = *src++;
+            apd->last[1].b = *src++;
+            apd->srcPos++;
+            (*nsrc)--;
+        }
+        /* now do the interpolation */
+        *dst++ = I(M8(apd->last[0].b, apd->last[1].b), M8(src[0], src[1]), r);
+        apd->dstPos += apd->dstIncr;
+        (*ndst)--;
+    }
+}
+
+static  void cvtMS88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
+                      unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+            if (*nsrc == 0) return;
+            apd->last[0].b = *src++;
+            apd->srcPos++;
+            (*nsrc)--;
+        }
+        /* now do the interpolation */
+        dst[0] = dst[1] = I(apd->last[0].b, src[0], r);
+        dst += 2;
+        apd->dstPos += apd->dstIncr;
+        (*ndst)--;
+    }
+}
+
+static  void cvtMM88C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
+                      unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+            if (*nsrc == 0) return;
+            apd->last[0].b = *src++;
+            apd->srcPos++;
+            (*nsrc)--;
+        }
+        /* now do the interpolation */
+        *dst++ = I(apd->last[0].b, src[0], r);
+        apd->dstPos += apd->dstIncr;
+        (*ndst)--;
+    }
+}
+
+static  void cvtSS816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
+                       unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+        
+    while (*nsrc != 0 && *ndst != 0) {
+        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+            if (*nsrc == 0) return;
+            apd->last[0].b = *src++;
+            apd->last[1].b = *src++;
+            apd->srcPos++;
+            (*nsrc)--;
+        }
+        /* now do the interpolation */
+        W16(dst, I(C816(apd->last[0].b), C816(src[0]), r));     dst += 2;
+        W16(dst, I(C816(apd->last[1].b), C816(src[1]), r));     dst += 2;
+        apd->dstPos += apd->dstIncr;
+        (*ndst)--;
+    }
+}
+
+static  void cvtSM816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
+                        unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+            if (*nsrc == 0) return;
+            apd->last[0].b = *src++;
+            apd->last[1].b = *src++;
+            apd->srcPos++;
+            (*nsrc)--;
+        }
+        /* now do the interpolation */
+        W16(dst, I(M16(C816(apd->last[0].b), C816(apd->last[1].b)),
+                    M16(C816(src[0]), C816(src[1])), r));
+        dst += 2;
+        apd->dstPos += apd->dstIncr;
+        (*ndst)--;
+    }
+}
+
+static  void cvtMS816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
+                        unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+    short       v;
+
+    while (*nsrc != 0 && *ndst != 0) {
+        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+            if (*nsrc == 0) return;
+            apd->last[0].b = *src++;
+            apd->srcPos++;
+            (*nsrc)--;
+        }
+        /* now do the interpolation */
+        v = I(C816(apd->last[0].b), C816(src[0]), r);
+        W16(dst, v);            dst += 2;
+        W16(dst, v);            dst += 2;
+        apd->dstPos += apd->dstIncr;
+        (*ndst)--;
+    }
+}
+
+static  void cvtMM816C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
+                        unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+            if (*nsrc == 0) return;
+            apd->last[0].b = *src++;
+            apd->srcPos++;
+            (*nsrc)--;
+        }
+        /* now do the interpolation */
+        W16(dst, I(C816(apd->last[0].b), C816(src[0]), r));
+        dst += 2;
+        apd->dstPos += apd->dstIncr;
+        (*ndst)--;
+    }
+}
+
+static  void cvtSS168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
+                        unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+            if (*nsrc == 0) return;
+            apd->last[0].s = R16(src);  src += 2;
+            apd->last[1].s = R16(src);  src += 2;
+            apd->srcPos++;
+            (*nsrc)--;
+        }
+        /* now do the interpolation */
+        *dst++ = C168(I(apd->last[0].s, R16(src)  , r));
+        *dst++ = C168(I(apd->last[1].s, R16(src+2), r));
+        apd->dstPos += apd->dstIncr;
+        (*ndst)--;
+    }
+}
+
+static  void cvtSM168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
+                        unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+            if (*nsrc == 0) return;
+            apd->last[0].s = R16(src);  src += 2;
+            apd->last[1].s = R16(src);  src += 2;
+            apd->srcPos++;
+            (*nsrc)--;
+        }
+        /* now do the interpolation */
+        *dst++ = C168(I(M16(apd->last[0].s, apd->last[1].s), 
+                        M16(R16(src), R16(src + 2)), r));
+        apd->dstPos += apd->dstIncr;
+        (*ndst)--;
+    }
+}
+
+
+static  void cvtMS168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
+                        unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+            if (*nsrc == 0) return;
+            apd->last[0].s = R16(src);  src += 2;
+            apd->srcPos++;
+            (*nsrc)--;
+        }
+        /* now do the interpolation */
+        dst[0] = dst[1] = C168(I(apd->last[0].s, R16(src), r)); dst += 2;
+        apd->dstPos += apd->dstIncr;
+        (*ndst)--;
+    }
+}
+
+
+static  void cvtMM168C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
+                        unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+            if (*nsrc == 0) return;
+            apd->last[0].s = R16(src);  src += 2;
+            apd->srcPos++;
+            (*nsrc)--;
+        }
+        /* now do the interpolation */
+        *dst++ = C168(I(apd->last[0].s, R16(src), r));
+        apd->dstPos += apd->dstIncr;
+        (*ndst)--;
+    }
+}
+
+static  void cvtSS1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
+                        unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+            if (*nsrc == 0) return;
+            apd->last[0].s = R16(src);  src += 2;
+            apd->last[1].s = R16(src);  src += 2;
+            apd->srcPos++;
+            (*nsrc)--;
+        }
+        /* now do the interpolation */
+        W16(dst, I(apd->last[0].s, R16(src)  , r));     dst += 2;
+        W16(dst, I(apd->last[1].s, R16(src+2), r));     dst += 2;
+        apd->dstPos += apd->dstIncr;
+        (*ndst)--;
+    }
+}
+
+static  void cvtSM1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
+                        unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+            if (*nsrc == 0) return;
+            apd->last[0].s = R16(src);  src += 2;
+            apd->last[1].s = R16(src);  src += 2;
+            apd->srcPos++;
+            (*nsrc)--;
+        }
+        /* now do the interpolation */
+        W16(dst, I(M16(apd->last[0].s, apd->last[1].s),
+                   M16(R16(src), R16(src+2)), r));
+        dst += 2;
+        apd->dstPos += apd->dstIncr;
+        (*ndst)--;
+    }
+}
+
+static  void cvtMS1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
+                        unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+    short       v;
+
+    while (*nsrc != 0 && *ndst != 0) {
+        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+            if (*nsrc == 0) return;
+            apd->last[0].s = R16(src);  src += 2;
+            apd->srcPos++;
+            (*nsrc)--;
+        }
+        /* now do the interpolation */
+        v = I(apd->last[0].s, R16(src), r);
+        W16(dst, v);            dst += 2;
+        W16(dst, v);            dst += 2;
+        apd->dstPos += apd->dstIncr;
+        (*ndst)--;
+    }
+}
+
+static  void cvtMM1616C(AcmPcmData* apd, const unsigned char* src, LPDWORD nsrc, 
+                        unsigned char* dst, LPDWORD ndst)
+{
+    double      r;
+
+    while (*nsrc != 0 && *ndst != 0) {
+        while ((r = (double)apd->srcPos - apd->dstPos) <= 0) {
+            if (*nsrc == 0) return;
+            apd->last[0].s = R16(src);  src += 2;
+            apd->srcPos++;
+            (*nsrc)--;
+        }
+        /* now do the interpolation */
+        W16(dst, I(apd->last[0].s, R16(src), r));       dst += 2;
+        apd->dstPos += apd->dstIncr;
+        (*ndst)--;
+    }
+}
+
+static  void (*PCM_ConvertChangeRate[16])(AcmPcmData* apd, 
+                                          const unsigned char* src, LPDWORD nsrc, 
+                                          unsigned char* dst, LPDWORD ndst) = {
     cvtSS88C,   cvtSM88C,   cvtMS88C,   cvtMM88C,
-    cvtSS816C,  cvtSM816C,  cvtMS816C,  cvtMM816C,
-    cvtSS168C,  cvtSM168C,  cvtMS168C,  cvtMM168C,
+    cvtSS816C,  cvtSM816C,  cvtMS816C,  cvtMM816C,
+    cvtSS168C,  cvtSM168C,  cvtMS168C,  cvtMM168C,
     cvtSS1616C, cvtSM1616C, cvtMS1616C, cvtMM1616C,
 };
@@ -691 +691 @@
  *
  */
-static  LRESULT PCM_DriverDetails(PACMDRIVERDETAILSW add)
+static  LRESULT PCM_DriverDetails(PACMDRIVERDETAILSW add)
 {
     add->fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
@@ -712 +712 @@
                          add->szLicensing, sizeof(add->szLicensing)/sizeof(WCHAR) );
     add->szFeatures[0] = 0;
-
+    
     return MMSYSERR_NOERROR;
 }
@@ -720 +720 @@
  *
  */
-static  LRESULT PCM_FormatTagDetails(PACMFORMATTAGDETAILSW aftd, DWORD dwQuery)
+static  LRESULT PCM_FormatTagDetails(PACMFORMATTAGDETAILSW aftd, DWORD dwQuery)
 {
     switch (dwQuery) {
     case ACM_FORMATTAGDETAILSF_INDEX:
-    if (aftd->dwFormatTagIndex != 0) return ACMERR_NOTPOSSIBLE;
-    break;
-    case ACM_FORMATTAGDETAILSF_FORMATTAG:
-    if (aftd->dwFormatTag != WAVE_FORMAT_PCM) return ACMERR_NOTPOSSIBLE;
-    break;
+        if (aftd->dwFormatTagIndex != 0) return ACMERR_NOTPOSSIBLE;
+        break;
+    case ACM_FORMATTAGDETAILSF_FORMATTAG: 
+        if (aftd->dwFormatTag != WAVE_FORMAT_PCM) return ACMERR_NOTPOSSIBLE;
+        break;
     case ACM_FORMATTAGDETAILSF_LARGESTSIZE:
-    if (aftd->dwFormatTag != WAVE_FORMAT_UNKNOWN &&
-        aftd->dwFormatTag != WAVE_FORMAT_UNKNOWN)
-        return ACMERR_NOTPOSSIBLE;
-    break;
+        if (aftd->dwFormatTag != WAVE_FORMAT_UNKNOWN && 
+            aftd->dwFormatTag != WAVE_FORMAT_UNKNOWN)
+            return ACMERR_NOTPOSSIBLE;
+        break;
     default:
-    WARN("Unsupported query %08lx\n", dwQuery);
-    return MMSYSERR_NOTSUPPORTED;
-    }
-
+        WARN("Unsupported query %08lx\n", dwQuery);
+        return MMSYSERR_NOTSUPPORTED;
+    }
+    
     aftd->dwFormatTagIndex = 0;
     aftd->dwFormatTag = WAVE_FORMAT_PCM;
@@ -745 +745 @@
     aftd->cStandardFormats = NUM_PCM_FORMATS;
     aftd->szFormatTag[0] = 0;
-
+    
     return MMSYSERR_NOERROR;
 }
@@ -753 +753 @@
  *
  */
-static  LRESULT PCM_FormatDetails(PACMFORMATDETAILSW afd, DWORD dwQuery)
+static  LRESULT PCM_FormatDetails(PACMFORMATDETAILSW afd, DWORD dwQuery)
 {
     switch (dwQuery) {
     case ACM_FORMATDETAILSF_FORMAT:
-    afd->dwFormatIndex = PCM_GetFormatIndex(afd->pwfx);
-    if (afd->dwFormatIndex == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
-    break;
+        afd->dwFormatIndex = PCM_GetFormatIndex(afd->pwfx);
+        if (afd->dwFormatIndex == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
+        break;
     case ACM_FORMATDETAILSF_INDEX:
-    assert(afd->dwFormatIndex < NUM_PCM_FORMATS);
-    afd->pwfx->wFormatTag = WAVE_FORMAT_PCM;
-    afd->pwfx->nChannels = PCM_Formats[afd->dwFormatIndex].nChannels;
-    afd->pwfx->nSamplesPerSec = PCM_Formats[afd->dwFormatIndex].rate;
-    afd->pwfx->wBitsPerSample = PCM_Formats[afd->dwFormatIndex].nBits;
-    /* native MSACM uses a PCMWAVEFORMAT structure, so cbSize is not accessible
-     * afd->pwfx->cbSize = 0;
-     */
-    afd->pwfx->nBlockAlign =
-        (afd->pwfx->nChannels * afd->pwfx->wBitsPerSample) / 8;
-    afd->pwfx->nAvgBytesPerSec =
-        afd->pwfx->nSamplesPerSec * afd->pwfx->nBlockAlign;
-    break;
+        assert(afd->dwFormatIndex < NUM_PCM_FORMATS);
+        afd->pwfx->wFormatTag = WAVE_FORMAT_PCM;
+        afd->pwfx->nChannels = PCM_Formats[afd->dwFormatIndex].nChannels;
+        afd->pwfx->nSamplesPerSec = PCM_Formats[afd->dwFormatIndex].rate;
+        afd->pwfx->wBitsPerSample = PCM_Formats[afd->dwFormatIndex].nBits;
+        /* native MSACM uses a PCMWAVEFORMAT structure, so cbSize is not accessible
+         * afd->pwfx->cbSize = 0; 
+         */
+        afd->pwfx->nBlockAlign = 
+            (afd->pwfx->nChannels * afd->pwfx->wBitsPerSample) / 8;
+        afd->pwfx->nAvgBytesPerSec = 
+            afd->pwfx->nSamplesPerSec * afd->pwfx->nBlockAlign;
+        break;
     default:
-    WARN("Unsupported query %08lx\n", dwQuery);
-    return MMSYSERR_NOTSUPPORTED;
-    }
-
+        WARN("Unsupported query %08lx\n", dwQuery);
+        return MMSYSERR_NOTSUPPORTED;   
+    }
+    
     afd->dwFormatTag = WAVE_FORMAT_PCM;
     afd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CONVERTER;
     afd->szFormat[0] = 0; /* let MSACM format this for us... */
-
+    
     return MMSYSERR_NOERROR;
 }
@@ -790 +790 @@
  *
  */
-static  LRESULT PCM_FormatSuggest(PACMDRVFORMATSUGGEST adfs)
+static  LRESULT PCM_FormatSuggest(PACMDRVFORMATSUGGEST adfs)
 {
     FIXME("(%p);\n", adfs);
@@ -800 +800 @@
  *
  */
-static  void    PCM_Reset(AcmPcmData* apd, int srcNumBits)
+static  void    PCM_Reset(AcmPcmData* apd, int srcNumBits)
 {
     apd->srcPos = 0;
@@ -806 +806 @@
     /* initialize with neutral value */
     if (srcNumBits == 16) {
-    apd->last[0].s = 0;
-    apd->last[1].s = 0;
+        apd->last[0].s = 0;
+        apd->last[1].s = 0;
     } else {
-    apd->last[0].b = (BYTE)0x80;
-    apd->last[1].b = (BYTE)0x80;
+        apd->last[0].b = (BYTE)0x80;
+        apd->last[1].b = (BYTE)0x80;
     }
 }
@@ -818 +818 @@
  *
  */
-static  LRESULT PCM_StreamOpen(PACMDRVSTREAMINSTANCE adsi)
-{
-    AcmPcmData* apd;
-    int     idx = 0;
+static  LRESULT PCM_StreamOpen(PACMDRVSTREAMINSTANCE adsi)
+{
+    AcmPcmData* apd;
+    int         idx = 0;
 
     assert(!(adsi->fdwOpen & ACM_STREAMOPENF_ASYNC));
-
+    
     if (PCM_GetFormatIndex(adsi->pwfxSrc) == 0xFFFFFFFF ||
-    PCM_GetFormatIndex(adsi->pwfxDst) == 0xFFFFFFFF)
-    return ACMERR_NOTPOSSIBLE;
+        PCM_GetFormatIndex(adsi->pwfxDst) == 0xFFFFFFFF)
+        return ACMERR_NOTPOSSIBLE;
 
     apd = HeapAlloc(GetProcessHeap(), 0, sizeof(AcmPcmData));
@@ -834 +834 @@
     adsi->dwDriver = (DWORD)apd;
     adsi->fdwDriver = 0;
-
+    
     if (adsi->pwfxSrc->wBitsPerSample == 16) idx += 8;
     if (adsi->pwfxDst->wBitsPerSample == 16) idx += 4;
@@ -841 +841 @@
 
     if (adsi->pwfxSrc->nSamplesPerSec == adsi->pwfxDst->nSamplesPerSec) {
-    apd->cvt.cvtKeepRate = PCM_ConvertKeepRate[idx];
+        apd->cvt.cvtKeepRate = PCM_ConvertKeepRate[idx];
     } else {
-    adsi->fdwDriver |= PCM_RESAMPLE;
-    apd->dstIncr = (double)(adsi->pwfxSrc->nSamplesPerSec) /
-        (double)(adsi->pwfxDst->nSamplesPerSec);
-    PCM_Reset(apd, adsi->pwfxSrc->wBitsPerSample);
-    apd->cvt.cvtChangeRate = PCM_ConvertChangeRate[idx];
+        adsi->fdwDriver |= PCM_RESAMPLE;
+        apd->dstIncr = (double)(adsi->pwfxSrc->nSamplesPerSec) /
+            (double)(adsi->pwfxDst->nSamplesPerSec);
+        PCM_Reset(apd, adsi->pwfxSrc->wBitsPerSample);
+        apd->cvt.cvtChangeRate = PCM_ConvertChangeRate[idx];
     }
 
@@ -857 +857 @@
  *
  */
-static  LRESULT PCM_StreamClose(PACMDRVSTREAMINSTANCE adsi)
+static  LRESULT PCM_StreamClose(PACMDRVSTREAMINSTANCE adsi)
 {
     HeapFree(GetProcessHeap(), 0, (void*)adsi->dwDriver);
@@ -867 +867 @@
  *
  */
-static  inline DWORD    PCM_round(DWORD a, DWORD b, DWORD c)
+static  inline DWORD    PCM_round(DWORD a, DWORD b, DWORD c)
 {
     assert(a && b && c);
@@ -878 +878 @@
  *
  */
-static  LRESULT PCM_StreamSize(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMSIZE adss)
+static  LRESULT PCM_StreamSize(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMSIZE adss)
 {
     switch (adss->fdwSize) {
     case ACM_STREAMSIZEF_DESTINATION:
-    /* cbDstLength => cbSrcLength */
-    adss->cbSrcLength = PCM_round(adss->cbDstLength,
-                      adsi->pwfxSrc->nAvgBytesPerSec,
-                      adsi->pwfxDst->nAvgBytesPerSec);
-    break;
+        /* cbDstLength => cbSrcLength */
+        adss->cbSrcLength = PCM_round(adss->cbDstLength, 
+                                      adsi->pwfxSrc->nAvgBytesPerSec, 
+                                      adsi->pwfxDst->nAvgBytesPerSec);
+        break;
     case ACM_STREAMSIZEF_SOURCE:
-    /* cbSrcLength => cbDstLength */
-    adss->cbDstLength =  PCM_round(adss->cbSrcLength,
-                       adsi->pwfxDst->nAvgBytesPerSec,
-                       adsi->pwfxSrc->nAvgBytesPerSec);
-    break;
+        /* cbSrcLength => cbDstLength */
+        adss->cbDstLength =  PCM_round(adss->cbSrcLength, 
+                                       adsi->pwfxDst->nAvgBytesPerSec, 
+                                       adsi->pwfxSrc->nAvgBytesPerSec);
+        break;
     default:
-    WARN("Unsupported query %08lx\n", adss->fdwSize);
-    return MMSYSERR_NOTSUPPORTED;
+        WARN("Unsupported query %08lx\n", adss->fdwSize);
+        return MMSYSERR_NOTSUPPORTED;   
     }
     return MMSYSERR_NOERROR;
@@ -906 +906 @@
 static LRESULT PCM_StreamConvert(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMHEADER adsh)
 {
-    AcmPcmData* apd = (AcmPcmData*)adsi->dwDriver;
-    DWORD   nsrc = NUM_OF(adsh->cbSrcLength, adsi->pwfxSrc->nBlockAlign);
-    DWORD   ndst = NUM_OF(adsh->cbDstLength, adsi->pwfxDst->nBlockAlign);
-
-    if (adsh->fdwConvert &
-    ~(ACM_STREAMCONVERTF_BLOCKALIGN|
-      ACM_STREAMCONVERTF_END|
-      ACM_STREAMCONVERTF_START)) {
-    FIXME("Unsupported fdwConvert (%08lx), ignoring it\n", adsh->fdwConvert);
+    AcmPcmData* apd = (AcmPcmData*)adsi->dwDriver;
+    DWORD       nsrc = NUM_OF(adsh->cbSrcLength, adsi->pwfxSrc->nBlockAlign);
+    DWORD       ndst = NUM_OF(adsh->cbDstLength, adsi->pwfxDst->nBlockAlign);
+
+    if (adsh->fdwConvert & 
+        ~(ACM_STREAMCONVERTF_BLOCKALIGN|
+          ACM_STREAMCONVERTF_END|
+          ACM_STREAMCONVERTF_START)) {
+        FIXME("Unsupported fdwConvert (%08lx), ignoring it\n", adsh->fdwConvert);
     }
     /* ACM_STREAMCONVERTF_BLOCKALIGN
-     *  currently all conversions are block aligned, so do nothing for this flag
+     *  currently all conversions are block aligned, so do nothing for this flag
      * ACM_STREAMCONVERTF_END
-     *  no pending data, so do nothing for this flag
+     *  no pending data, so do nothing for this flag
      */
-    if ((adsh->fdwConvert & ACM_STREAMCONVERTF_START) &&
-    (adsi->fdwDriver & PCM_RESAMPLE)) {
-    PCM_Reset(apd, adsi->pwfxSrc->wBitsPerSample);
+    if ((adsh->fdwConvert & ACM_STREAMCONVERTF_START) && 
+        (adsi->fdwDriver & PCM_RESAMPLE)) {
+        PCM_Reset(apd, adsi->pwfxSrc->wBitsPerSample);
     }
 
     /* do the job */
     if (adsi->fdwDriver & PCM_RESAMPLE) {
-    DWORD   nsrc2 = nsrc;
-    DWORD   ndst2 = ndst;
-
-    apd->cvt.cvtChangeRate(apd, adsh->pbSrc, &nsrc2, adsh->pbDst, &ndst2);
-    nsrc -= nsrc2;
-    ndst -= ndst2;
+        DWORD   nsrc2 = nsrc;
+        DWORD   ndst2 = ndst;
+
+        apd->cvt.cvtChangeRate(apd, adsh->pbSrc, &nsrc2, adsh->pbDst, &ndst2);
+        nsrc -= nsrc2;
+        ndst -= ndst2;
     } else {
-    if (nsrc < ndst) ndst = nsrc; else nsrc = ndst;
-
-    /* nsrc is now equal to ndst */
-    apd->cvt.cvtKeepRate(adsh->pbSrc, nsrc, adsh->pbDst);
+        if (nsrc < ndst) ndst = nsrc; else nsrc = ndst;
+
+        /* nsrc is now equal to ndst */
+        apd->cvt.cvtKeepRate(adsh->pbSrc, nsrc, adsh->pbDst);
     }
 
@@ -948 +948 @@
 
 /**************************************************************************
- *          PCM_DriverProc          [exported]
- */
-LRESULT CALLBACK    PCM_DriverProc(DWORD dwDevID, HDRVR hDriv, UINT wMsg,
-                       LPARAM dwParam1, LPARAM dwParam2)
-{
-    TRACE("(%08lx %08lx %u %08lx %08lx);\n",
-      dwDevID, (DWORD)hDriv, wMsg, dwParam1, dwParam2);
-
+ *                      PCM_DriverProc                  [exported]
+ */
+LRESULT CALLBACK        PCM_DriverProc(DWORD dwDevID, HDRVR hDriv, UINT wMsg, 
+                                       LPARAM dwParam1, LPARAM dwParam2)
+{
+    TRACE("(%08lx %08lx %u %08lx %08lx);\n", 
+          dwDevID, (DWORD)hDriv, wMsg, dwParam1, dwParam2);
+    
     switch (wMsg) {
-    case DRV_LOAD:      return 1;
-    case DRV_FREE:      return 1;
-    case DRV_OPEN:      return PCM_drvOpen((LPSTR)dwParam1);
-    case DRV_CLOSE:     return PCM_drvClose(dwDevID);
-    case DRV_ENABLE:        return 1;
-    case DRV_DISABLE:       return 1;
-    case DRV_QUERYCONFIGURE:    return 1;
-    case DRV_CONFIGURE:     MessageBoxA(0, "MSACM PCM filter !", "Wine Driver", MB_OK); return 1;
-    case DRV_INSTALL:       return DRVCNF_RESTART;
-    case DRV_REMOVE:        return DRVCNF_RESTART;
-
+    case DRV_LOAD:              return 1;
+    case DRV_FREE:              return 1;
+    case DRV_OPEN:              return PCM_drvOpen((LPSTR)dwParam1);
+    case DRV_CLOSE:             return PCM_drvClose(dwDevID);
+    case DRV_ENABLE:            return 1;       
+    case DRV_DISABLE:           return 1;
+    case DRV_QUERYCONFIGURE:    return 1;
+    case DRV_CONFIGURE:         MessageBoxA(0, "MSACM PCM filter !", "Wine Driver", MB_OK); return 1;
+    case DRV_INSTALL:           return DRVCNF_RESTART;
+    case DRV_REMOVE:            return DRVCNF_RESTART;
+        
     case ACMDM_DRIVER_NOTIFY:
-    /* no caching from other ACM drivers is done so far */
-    return MMSYSERR_NOERROR;
-
+        /* no caching from other ACM drivers is done so far */
+        return MMSYSERR_NOERROR;
+        
     case ACMDM_DRIVER_DETAILS:
-    return PCM_DriverDetails((PACMDRIVERDETAILSW)dwParam1);
-
+        return PCM_DriverDetails((PACMDRIVERDETAILSW)dwParam1);
+        
     case ACMDM_FORMATTAG_DETAILS:
-    return PCM_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2);
-
+        return PCM_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2);
+        
     case ACMDM_FORMAT_DETAILS:
-    return PCM_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2);
-
+        return PCM_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2);
+        
     case ACMDM_FORMAT_SUGGEST:
-    return PCM_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1);
-
+        return PCM_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1);
+        
     case ACMDM_STREAM_OPEN:
-    return PCM_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1);
-
+        return PCM_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1);
+        
     case ACMDM_STREAM_CLOSE:
-    return PCM_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1);
-
+        return PCM_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1);
+        
     case ACMDM_STREAM_SIZE:
-    return PCM_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2);
-
+        return PCM_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2);
+        
     case ACMDM_STREAM_CONVERT:
-    return PCM_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2);
-
+        return PCM_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2);
+        
     case ACMDM_HARDWARE_WAVE_CAPS_INPUT:
     case ACMDM_HARDWARE_WAVE_CAPS_OUTPUT:
-    /* this converter is not a hardware driver */
+        /* this converter is not a hardware driver */
     case ACMDM_FILTERTAG_DETAILS:
     case ACMDM_FILTER_DETAILS:
-    /* this converter is not a filter */
+        /* this converter is not a filter */
     case ACMDM_STREAM_RESET:
-    /* only needed for asynchronous driver... we aren't, so just say it */
+        /* only needed for asynchronous driver... we aren't, so just say it */
     case ACMDM_STREAM_PREPARE:
     case ACMDM_STREAM_UNPREPARE:
-    /* nothing special to do here... so don't do anything */
-    return MMSYSERR_NOTSUPPORTED;
-
+        /* nothing special to do here... so don't do anything */
+        return MMSYSERR_NOTSUPPORTED;
+        
     default:
-    return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
+        return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
     }
     return 0;

trunk/src/msacm32/stream.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
-/* $Id: stream.c,v 1.2 2001-09-05 13:11:26 bird Exp $ */
+
 /*
  *      MSACM32 library
  *
  *      Copyright 1998  Patrik Stridvall
- *        1999  Eric Pouech
+ *                1999  Eric Pouech
  */
 
 /* TODO
- *  + asynchronous conversion is not implemented
- *  + callback/notification
- *  * acmStreamMessage
- *  + properly close ACM streams
+ *      + asynchronous conversion is not implemented
+ *      + callback/notification
+ *      * acmStreamMessage
+ *      + properly close ACM streams
  */
 
@@ -26 +26 @@
 
 DEFAULT_DEBUG_CHANNEL(msacm);
-
-static PWINE_ACMSTREAM  ACM_GetStream(HACMSTREAM has)
+    
+static PWINE_ACMSTREAM  ACM_GetStream(HACMSTREAM has)
 {
     return (PWINE_ACMSTREAM)has;
@@ -37 +37 @@
 MMRESULT WINAPI acmStreamClose(HACMSTREAM has, DWORD fdwClose)
 {
-    PWINE_ACMSTREAM was;
-    MMRESULT        ret;
-
+    PWINE_ACMSTREAM     was;
+    MMRESULT            ret;
+                
     TRACE("(0x%08x, %ld)\n", has, fdwClose);
-
+    
     if ((was = ACM_GetStream(has)) == NULL) {
-    return MMSYSERR_INVALHANDLE;
+        return MMSYSERR_INVALHANDLE;
     }
     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_CLOSE, (DWORD)&was->drvInst, 0);
     if (ret == MMSYSERR_NOERROR) {
-    if (was->hAcmDriver)
-        acmDriverClose(was->hAcmDriver, 0L);
-    HeapFree(MSACM_hHeap, 0, was);
+        if (was->hAcmDriver)
+            acmDriverClose(was->hAcmDriver, 0L);        
+        HeapFree(MSACM_hHeap, 0, was);
     }
     TRACE("=> (%d)\n", ret);
@@ -58 +58 @@
  *           acmStreamConvert (MSACM32.38)
  */
-MMRESULT WINAPI acmStreamConvert(HACMSTREAM has, PACMSTREAMHEADER pash,
-                 DWORD fdwConvert)
-{
-    PWINE_ACMSTREAM was;
-    MMRESULT        ret = MMSYSERR_NOERROR;
-    PACMDRVSTREAMHEADER padsh;
+MMRESULT WINAPI acmStreamConvert(HACMSTREAM has, PACMSTREAMHEADER pash, 
+                                 DWORD fdwConvert)
+{
+    PWINE_ACMSTREAM     was;
+    MMRESULT            ret = MMSYSERR_NOERROR;
+    PACMDRVSTREAMHEADER padsh;
 
     TRACE("(0x%08x, %p, %ld)\n", has, pash, fdwConvert);
-
+    
     if ((was = ACM_GetStream(has)) == NULL)
-    return MMSYSERR_INVALHANDLE;
+        return MMSYSERR_INVALHANDLE;
     if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER))
-    return MMSYSERR_INVALPARAM;
+        return MMSYSERR_INVALPARAM;
 
     if (!(pash->fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED))
-    return ACMERR_UNPREPARED;
+        return ACMERR_UNPREPARED;
 
     /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
@@ -83 +83 @@
     /* check that pointers have not been modified */
     if (padsh->pbPreparedSrc != padsh->pbSrc ||
-    padsh->cbPreparedSrcLength < padsh->cbSrcLength ||
-    padsh->pbPreparedDst != padsh->pbDst ||
-    padsh->cbPreparedDstLength < padsh->cbDstLength) {
-    return MMSYSERR_INVALPARAM;
-    }
+        padsh->cbPreparedSrcLength < padsh->cbSrcLength ||
+        padsh->pbPreparedDst != padsh->pbDst ||
+        padsh->cbPreparedDstLength < padsh->cbDstLength) {
+        return MMSYSERR_INVALPARAM;
+    }   
 
     padsh->fdwConvert = fdwConvert;
@@ -93 +93 @@
     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_CONVERT, (DWORD)&was->drvInst, (DWORD)padsh);
     if (ret == MMSYSERR_NOERROR) {
-    padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_DONE;
+        padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_DONE;
     }
     TRACE("=> (%d)\n", ret);
@@ -102 +102 @@
  *           acmStreamMessage (MSACM32.39)
  */
-MMRESULT WINAPI acmStreamMessage(HACMSTREAM has, UINT uMsg, LPARAM lParam1,
-                 LPARAM lParam2)
+MMRESULT WINAPI acmStreamMessage(HACMSTREAM has, UINT uMsg, LPARAM lParam1, 
+                                 LPARAM lParam2)
 {
     FIXME("(0x%08x, %u, %ld, %ld): stub\n", has, uMsg, lParam1, lParam2);
@@ -114 +114 @@
  */
 MMRESULT WINAPI acmStreamOpen(PHACMSTREAM phas, HACMDRIVER had, PWAVEFORMATEX pwfxSrc,
-                  PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD dwCallback,
-                  DWORD dwInstance, DWORD fdwOpen)
-{
-    PWINE_ACMSTREAM was;
-    PWINE_ACMDRIVER wad;
-    MMRESULT        ret;
-    int         wfxSrcSize;
-    int         wfxDstSize;
-
+                              PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD dwCallback,
+                              DWORD dwInstance, DWORD fdwOpen)
+{
+    PWINE_ACMSTREAM     was;
+    PWINE_ACMDRIVER     wad;
+    MMRESULT            ret;
+    int                 wfxSrcSize;
+    int                 wfxDstSize;
+    
     TRACE("(%p, 0x%08x, %p, %p, %p, %ld, %ld, %ld)\n",
-      phas, had, pwfxSrc, pwfxDst, pwfltr, dwCallback, dwInstance, fdwOpen);
-
-    TRACE("src [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
-      pwfxSrc->wFormatTag, pwfxSrc->nChannels, pwfxSrc->nSamplesPerSec, pwfxSrc->nAvgBytesPerSec,
-      pwfxSrc->nBlockAlign, pwfxSrc->wBitsPerSample, pwfxSrc->cbSize);
-
-    TRACE("dst [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
-      pwfxDst->wFormatTag, pwfxDst->nChannels, pwfxDst->nSamplesPerSec, pwfxDst->nAvgBytesPerSec,
-      pwfxDst->nBlockAlign, pwfxDst->wBitsPerSample, pwfxDst->cbSize);
+          phas, had, pwfxSrc, pwfxDst, pwfltr, dwCallback, dwInstance, fdwOpen);
+
+    TRACE("src [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n", 
+          pwfxSrc->wFormatTag, pwfxSrc->nChannels, pwfxSrc->nSamplesPerSec, pwfxSrc->nAvgBytesPerSec, 
+          pwfxSrc->nBlockAlign, pwfxSrc->wBitsPerSample, pwfxSrc->cbSize);
+
+    TRACE("dst [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n", 
+          pwfxDst->wFormatTag, pwfxDst->nChannels, pwfxDst->nSamplesPerSec, pwfxDst->nAvgBytesPerSec, 
+          pwfxDst->nBlockAlign, pwfxDst->wBitsPerSample, pwfxDst->cbSize);
 
     if ((fdwOpen & ACM_STREAMOPENF_QUERY) && phas) return MMSYSERR_INVALPARAM;
@@ -143 +143 @@
     was = HeapAlloc(MSACM_hHeap, 0, sizeof(*was) + wfxSrcSize + wfxDstSize + ((pwfltr) ? sizeof(WAVEFILTER) : 0));
     if (was == NULL)
-    return MMSYSERR_NOMEM;
-
+        return MMSYSERR_NOMEM;
+    
     was->drvInst.cbStruct = sizeof(was->drvInst);
     was->drvInst.pwfxSrc = (PWAVEFORMATEX)((LPSTR)was + sizeof(*was));
@@ -151 +151 @@
     memcpy(was->drvInst.pwfxDst, pwfxDst, wfxDstSize);
     if (pwfltr) {
-    was->drvInst.pwfltr = (PWAVEFILTER)((LPSTR)was + sizeof(*was) + wfxSrcSize + wfxDstSize);
-    memcpy(was->drvInst.pwfltr, pwfltr, sizeof(WAVEFILTER));
+        was->drvInst.pwfltr = (PWAVEFILTER)((LPSTR)was + sizeof(*was) + wfxSrcSize + wfxDstSize);
+        memcpy(was->drvInst.pwfltr, pwfltr, sizeof(WAVEFILTER));
     } else {
-    was->drvInst.pwfltr = NULL;
-    }
-    was->drvInst.dwCallback = dwCallback;
+        was->drvInst.pwfltr = NULL;
+    }
+    was->drvInst.dwCallback = dwCallback;    
     was->drvInst.dwInstance = dwInstance;
     was->drvInst.fdwOpen = fdwOpen;
-    was->drvInst.fdwDriver = 0L;
-    was->drvInst.dwDriver = 0L;
+    was->drvInst.fdwDriver = 0L;  
+    was->drvInst.dwDriver = 0L;     
     was->drvInst.has = (HACMSTREAM)was;
-
+    
     if (had) {
-    if (!(wad = MSACM_GetDriver(had))) {
-        ret = MMSYSERR_INVALPARAM;
-        goto errCleanUp;
-    }
-
-    was->obj.dwType = WINE_ACMOBJ_STREAM;
-    was->obj.pACMDriverID = wad->obj.pACMDriverID;
-    was->pDrv = wad;
-    was->hAcmDriver = 0; /* not to close it in acmStreamClose */
-
-    ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
-    if (ret != MMSYSERR_NOERROR)
-        goto errCleanUp;
+        if (!(wad = MSACM_GetDriver(had))) {
+            ret = MMSYSERR_INVALPARAM;
+            goto errCleanUp;
+        }
+        
+        was->obj.dwType = WINE_ACMOBJ_STREAM;
+        was->obj.pACMDriverID = wad->obj.pACMDriverID;
+        was->pDrv = wad;
+        was->hAcmDriver = 0; /* not to close it in acmStreamClose */
+
+        ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
+        if (ret != MMSYSERR_NOERROR)
+            goto errCleanUp;
     } else {
-    PWINE_ACMDRIVERID wadi;
-
-    ret = ACMERR_NOTPOSSIBLE;
-    for (wadi = MSACM_pFirstACMDriverID; wadi; wadi = wadi->pNextACMDriverID) {
-        ret = acmDriverOpen(&had, (HACMDRIVERID)wadi, 0L);
-        if (ret == MMSYSERR_NOERROR) {
-        if ((wad = MSACM_GetDriver(had)) != 0) {
-            was->obj.dwType = WINE_ACMOBJ_STREAM;
-            was->obj.pACMDriverID = wad->obj.pACMDriverID;
-            was->pDrv = wad;
-            was->hAcmDriver = had;
-
-            ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
-            if (ret == MMSYSERR_NOERROR) {
-            if (fdwOpen & ACM_STREAMOPENF_QUERY) {
-                acmDriverClose(had, 0L);
-            }
-            break;
-            }
-        }
-        /* no match, close this acm driver and try next one */
-        acmDriverClose(had, 0L);
-        }
-    }
-    if (ret != MMSYSERR_NOERROR) {
-        ret = ACMERR_NOTPOSSIBLE;
-        goto errCleanUp;
-    }
+        PWINE_ACMDRIVERID wadi;
+        
+        ret = ACMERR_NOTPOSSIBLE;
+        for (wadi = MSACM_pFirstACMDriverID; wadi; wadi = wadi->pNextACMDriverID) {
+            ret = acmDriverOpen(&had, (HACMDRIVERID)wadi, 0L);
+            if (ret == MMSYSERR_NOERROR) {
+                if ((wad = MSACM_GetDriver(had)) != 0) {
+                    was->obj.dwType = WINE_ACMOBJ_STREAM;
+                    was->obj.pACMDriverID = wad->obj.pACMDriverID;
+                    was->pDrv = wad;
+                    was->hAcmDriver = had;
+                    
+                    ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
+                    if (ret == MMSYSERR_NOERROR) {
+                        if (fdwOpen & ACM_STREAMOPENF_QUERY) {
+                            acmDriverClose(had, 0L);
+                        }
+                        break;
+                    }
+                }
+                /* no match, close this acm driver and try next one */
+                acmDriverClose(had, 0L);
+            }
+        }
+        if (ret != MMSYSERR_NOERROR) {
+            ret = ACMERR_NOTPOSSIBLE;
+            goto errCleanUp;
+        }
     }
     ret = MMSYSERR_NOERROR;
     if (!(fdwOpen & ACM_STREAMOPENF_QUERY)) {
+        if (phas)
+            *phas = (HACMSTREAM)was;
+        TRACE("=> (%d)\n", ret);
+        return ret;
+    }
+errCleanUp:             
     if (phas)
-        *phas = (HACMSTREAM)was;
-    TRACE("=> (%d)\n", ret);
-    return ret;
-    }
-errCleanUp:
-    if (phas)
-    *phas = (HACMSTREAM)0;
+        *phas = (HACMSTREAM)0;
     HeapFree(MSACM_hHeap, 0, was);
     TRACE("=> (%d)\n", ret);
@@ -226 +226 @@
  *           acmStreamPrepareHeader (MSACM32.41)
  */
-MMRESULT WINAPI acmStreamPrepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
-                       DWORD fdwPrepare)
-{
-    PWINE_ACMSTREAM was;
-    MMRESULT        ret = MMSYSERR_NOERROR;
-    PACMDRVSTREAMHEADER padsh;
+MMRESULT WINAPI acmStreamPrepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash, 
+                                       DWORD fdwPrepare)
+{
+    PWINE_ACMSTREAM     was;
+    MMRESULT            ret = MMSYSERR_NOERROR;
+    PACMDRVSTREAMHEADER padsh;
 
     TRACE("(0x%08x, %p, %ld)\n", has, pash, fdwPrepare);
-
+    
     if ((was = ACM_GetStream(has)) == NULL)
-    return MMSYSERR_INVALHANDLE;
+        return MMSYSERR_INVALHANDLE;
     if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER))
-    return MMSYSERR_INVALPARAM;
+        return MMSYSERR_INVALPARAM;
     if (fdwPrepare)
-    ret = MMSYSERR_INVALFLAG;
+        ret = MMSYSERR_INVALFLAG;
 
     if (pash->fdwStatus & ACMSTREAMHEADER_STATUSF_DONE)
-    return MMSYSERR_NOERROR;
+        return MMSYSERR_NOERROR;
 
     /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
@@ -264 +264 @@
     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_PREPARE, (DWORD)&was->drvInst, (DWORD)padsh);
     if (ret == MMSYSERR_NOERROR || ret == MMSYSERR_NOTSUPPORTED) {
-    ret = MMSYSERR_NOERROR;
-    padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_DONE|ACMSTREAMHEADER_STATUSF_INQUEUE);
-    padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_PREPARED;
-    padsh->fdwPrepared = padsh->fdwStatus;
-    padsh->dwPrepared = 0;
-    padsh->pbPreparedSrc = padsh->pbSrc;
-    padsh->cbPreparedSrcLength = padsh->cbSrcLength;
-    padsh->pbPreparedDst = padsh->pbDst;
-    padsh->cbPreparedDstLength = padsh->cbDstLength;
+        ret = MMSYSERR_NOERROR;
+        padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_DONE|ACMSTREAMHEADER_STATUSF_INQUEUE);
+        padsh->fdwStatus |= ACMSTREAMHEADER_STATUSF_PREPARED;
+        padsh->fdwPrepared = padsh->fdwStatus;
+        padsh->dwPrepared = 0;
+        padsh->pbPreparedSrc = padsh->pbSrc;
+        padsh->cbPreparedSrcLength = padsh->cbSrcLength;
+        padsh->pbPreparedDst = padsh->pbDst;
+        padsh->cbPreparedDstLength = padsh->cbDstLength;
     } else {
-    padsh->fdwPrepared = 0;
-    padsh->dwPrepared = 0;
-    padsh->pbPreparedSrc = 0;
-    padsh->cbPreparedSrcLength = 0;
-    padsh->pbPreparedDst = 0;
-    padsh->cbPreparedDstLength = 0;
+        padsh->fdwPrepared = 0;
+        padsh->dwPrepared = 0;
+        padsh->pbPreparedSrc = 0;
+        padsh->cbPreparedSrcLength = 0;
+        padsh->pbPreparedDst = 0;
+        padsh->cbPreparedDstLength = 0;
     }
     TRACE("=> (%d)\n", ret);
@@ -290 +290 @@
 MMRESULT WINAPI acmStreamReset(HACMSTREAM has, DWORD fdwReset)
 {
-    PWINE_ACMSTREAM was;
-    MMRESULT        ret = MMSYSERR_NOERROR;
+    PWINE_ACMSTREAM     was;
+    MMRESULT            ret = MMSYSERR_NOERROR;
 
     TRACE("(0x%08x, %ld)\n", has, fdwReset);
 
     if (fdwReset) {
-    ret = MMSYSERR_INVALFLAG;
+        ret = MMSYSERR_INVALFLAG;
     } else if ((was = ACM_GetStream(has)) == NULL) {
-    return MMSYSERR_INVALHANDLE;
+        return MMSYSERR_INVALHANDLE;
     } else if (was->drvInst.fdwOpen & ACM_STREAMOPENF_ASYNC) {
-    ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_RESET, (DWORD)&was->drvInst, 0);
+        ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_RESET, (DWORD)&was->drvInst, 0);
     }
     TRACE("=> (%d)\n", ret);
@@ -309 +309 @@
  *           acmStreamSize (MSACM32.43)
  */
-MMRESULT WINAPI acmStreamSize(HACMSTREAM has, DWORD cbInput,
-                  LPDWORD pdwOutputBytes, DWORD fdwSize)
-{
-    PWINE_ACMSTREAM was;
-    ACMDRVSTREAMSIZE    adss;
-    MMRESULT        ret;
-
+MMRESULT WINAPI acmStreamSize(HACMSTREAM has, DWORD cbInput, 
+                              LPDWORD pdwOutputBytes, DWORD fdwSize)
+{
+    PWINE_ACMSTREAM     was;
+    ACMDRVSTREAMSIZE    adss;
+    MMRESULT            ret;
+    
     TRACE("(0x%08x, %ld, %p, %ld)\n", has, cbInput, pdwOutputBytes, fdwSize);
-
+    
     if ((was = ACM_GetStream(has)) == NULL) {
-    return MMSYSERR_INVALHANDLE;
+        return MMSYSERR_INVALHANDLE;
     }
     if ((fdwSize & ~ACM_STREAMSIZEF_QUERYMASK) != 0) {
-    return MMSYSERR_INVALFLAG;
+        return MMSYSERR_INVALFLAG;
     }
 
     *pdwOutputBytes = 0L;
-
+    
     switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
     case ACM_STREAMSIZEF_DESTINATION:
-    adss.cbDstLength = cbInput;
-    adss.cbSrcLength = 0;
-    break;
+        adss.cbDstLength = cbInput;
+        adss.cbSrcLength = 0;
+        break;
     case ACM_STREAMSIZEF_SOURCE:
-    adss.cbSrcLength = cbInput;
-    adss.cbDstLength = 0;
-    break;
-    default:
-    return MMSYSERR_INVALFLAG;
-    }
-
+        adss.cbSrcLength = cbInput;
+        adss.cbDstLength = 0;
+        break;
+    default:    
+        return MMSYSERR_INVALFLAG;
+    }
+    
     adss.cbStruct = sizeof(adss);
     adss.fdwSize = fdwSize;
-    ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_SIZE,
-                (DWORD)&was->drvInst, (DWORD)&adss);
+    ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_SIZE, 
+                            (DWORD)&was->drvInst, (DWORD)&adss);
     if (ret == MMSYSERR_NOERROR) {
-    switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
-    case ACM_STREAMSIZEF_DESTINATION:
-        *pdwOutputBytes = adss.cbSrcLength;
-        break;
-    case ACM_STREAMSIZEF_SOURCE:
-        *pdwOutputBytes = adss.cbDstLength;
-        break;
-    }
+        switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
+        case ACM_STREAMSIZEF_DESTINATION:
+            *pdwOutputBytes = adss.cbSrcLength;
+            break;
+        case ACM_STREAMSIZEF_SOURCE:
+            *pdwOutputBytes = adss.cbDstLength;
+            break;
+        }
     }
     TRACE("=> (%d) [%lu]\n", ret, *pdwOutputBytes);
@@ -361 +361 @@
  *           acmStreamUnprepareHeader (MSACM32.44)
  */
-MMRESULT WINAPI acmStreamUnprepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
-                     DWORD fdwUnprepare)
-{
-    PWINE_ACMSTREAM was;
-    MMRESULT        ret = MMSYSERR_NOERROR;
-    PACMDRVSTREAMHEADER padsh;
+MMRESULT WINAPI acmStreamUnprepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash, 
+                                         DWORD fdwUnprepare)
+{
+    PWINE_ACMSTREAM     was;
+    MMRESULT            ret = MMSYSERR_NOERROR;
+    PACMDRVSTREAMHEADER padsh;
 
     TRACE("(0x%08x, %p, %ld)\n", has, pash, fdwUnprepare);
-
+    
     if ((was = ACM_GetStream(has)) == NULL)
-    return MMSYSERR_INVALHANDLE;
+        return MMSYSERR_INVALHANDLE;
     if (!pash || pash->cbStruct < sizeof(ACMSTREAMHEADER))
-    return MMSYSERR_INVALPARAM;
+        return MMSYSERR_INVALPARAM;
 
     if (!(pash->fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED))
-    return ACMERR_UNPREPARED;
+        return ACMERR_UNPREPARED;
 
     /* Note: the ACMSTREAMHEADER and ACMDRVSTREAMHEADER structs are of same
@@ -386 +386 @@
     /* check that pointers have not been modified */
     if (padsh->pbPreparedSrc != padsh->pbSrc ||
-    padsh->cbPreparedSrcLength < padsh->cbSrcLength ||
-    padsh->pbPreparedDst != padsh->pbDst ||
-    padsh->cbPreparedDstLength < padsh->cbDstLength) {
-    return MMSYSERR_INVALPARAM;
-    }
+        padsh->cbPreparedSrcLength < padsh->cbSrcLength ||
+        padsh->pbPreparedDst != padsh->pbDst ||
+        padsh->cbPreparedDstLength < padsh->cbDstLength) {
+        return MMSYSERR_INVALPARAM;
+    }   
 
     padsh->fdwConvert = fdwUnprepare;
@@ -396 +396 @@
     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_UNPREPARE, (DWORD)&was->drvInst, (DWORD)padsh);
     if (ret == MMSYSERR_NOERROR || ret == MMSYSERR_NOTSUPPORTED) {
-    ret = MMSYSERR_NOERROR;
-    padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_DONE|ACMSTREAMHEADER_STATUSF_INQUEUE|ACMSTREAMHEADER_STATUSF_PREPARED);
-    }
-    TRACE("=> (%d)\n", ret);
-    return ret;
-}
+        ret = MMSYSERR_NOERROR;
+        padsh->fdwStatus &= ~(ACMSTREAMHEADER_STATUSF_DONE|ACMSTREAMHEADER_STATUSF_INQUEUE|ACMSTREAMHEADER_STATUSF_PREPARED);
+    }
+    TRACE("=> (%d)\n", ret);
+    return ret;
+}

trunk/src/msacm32/wineacm.h

@@ -3 +3 @@
 #define __WINE_WINEACM_H
 
-#ifndef __WIN32OS2__
+#ifdef __WIN32OS2__
+#include "windef.h"
+#else
 #include "wine/windef16.h"
 #include "wine/mmsystem16.h"

trunk/src/msvfw32/drawdib.c

@@ -1 @@
-/* $Id: drawdib.c,v 1.2 2001-09-05 13:12:34 bird Exp $ */
-/*
+/* 
  * Copyright 2000 Bradley Baetz
  *
@@ -22 +21 @@
 
 typedef struct {
-    HDC hdc;
-    INT dxDst;
-    INT dyDst;
-    LPBITMAPINFOHEADER lpbi;
-    INT dxSrc;
-    INT dySrc;
-    HPALETTE hpal;              /* Palette to use for the DIB */
-    BOOL begun;                 /* DrawDibBegin has been called */
-    LPBITMAPINFOHEADER lpbiOut; /* Output format */
-    HIC hic;                    /* HIC for decompression */
-    HDC hMemDC;                 /* DC for buffering */
-    HBITMAP hOldDib;            /* Original Dib */
-    HBITMAP hDib;               /* DibSection */
-    LPVOID lpvbits;             /* Buffer for holding decompressed dib */
+        HDC hdc;
+        INT dxDst;
+        INT dyDst;
+        LPBITMAPINFOHEADER lpbi;
+        INT dxSrc;
+        INT dySrc;
+        HPALETTE hpal;                          /* Palette to use for the DIB */
+        BOOL begun;                                     /* DrawDibBegin has been called */
+        LPBITMAPINFOHEADER lpbiOut;     /* Output format */
+        HIC hic;                                        /* HIC for decompression */
+        HDC hMemDC;                                     /* DC for buffering */
+        HBITMAP hOldDib;                        /* Original Dib */
+        HBITMAP hDib;                           /* DibSection */
+        LPVOID lpvbits;                         /* Buffer for holding decompressed dib */
 } WINE_HDD;
 
@@ -59 +58 @@
 
 /***********************************************************************
- *      DrawDibOpen     [MSVFW32.@]
+ *              DrawDibOpen             [MSVFW32.@]
  */
 HDRAWDIB VFWAPI DrawDibOpen(void) {
-    HDRAWDIB hdd;
-
-    TRACE("(void)\n");
-    hdd = GlobalAlloc16(GHND,sizeof(WINE_HDD));
-    TRACE("=> %d\n",hdd);
-    return hdd;
-}
-
-/***********************************************************************
- *      DrawDibOpen     [MSVIDEO.102]
+        HDRAWDIB hdd;
+
+        TRACE("(void)\n");
+        hdd = GlobalAlloc16(GHND,sizeof(WINE_HDD));
+        TRACE("=> %d\n",hdd);
+        return hdd;
+}
+
+/***********************************************************************
+ *              DrawDibOpen             [MSVIDEO.102]
  */
 HDRAWDIB16 VFWAPI DrawDibOpen16(void) {
-    return (HDRAWDIB16)DrawDibOpen();
-}
-
-/***********************************************************************
- *      DrawDibClose        [MSVFW32.@]
+        return (HDRAWDIB16)DrawDibOpen();
+}
+
+/***********************************************************************
+ *              DrawDibClose            [MSVFW32.@]
  */
 BOOL VFWAPI DrawDibClose(HDRAWDIB hdd) {
-    WINE_HDD *whdd = GlobalLock16(hdd);
-
-    TRACE("(0x%08lx)\n",(DWORD)hdd);
-
-    if (!whdd)
-        return FALSE;
-
-    if (whdd->begun)
-        DrawDibEnd(hdd);
-
-    GlobalUnlock16(hdd);
-    GlobalFree16(hdd);
-    return TRUE;
-}
-
-/***********************************************************************
- *      DrawDibClose        [MSVIDEO.103]
+        WINE_HDD *whdd = GlobalLock16(hdd);
+
+        TRACE("(0x%08lx)\n",(DWORD)hdd);
+
+        if (!whdd)
+                return FALSE;
+
+        if (whdd->begun)
+                DrawDibEnd(hdd);
+
+        GlobalUnlock16(hdd);
+        GlobalFree16(hdd);
+        return TRUE;
+}
+
+/***********************************************************************
+ *              DrawDibClose            [MSVIDEO.103]
  */
 BOOL16 VFWAPI DrawDibClose16(HDRAWDIB16 hdd) {
-    return DrawDibClose(hdd);
-}
-
-/***********************************************************************
- *      DrawDibEnd      [MSVFW32.@]
+        return DrawDibClose(hdd);
+}
+
+/***********************************************************************
+ *              DrawDibEnd              [MSVFW32.@]
  */
 BOOL VFWAPI DrawDibEnd(HDRAWDIB hdd) {
-    BOOL ret = TRUE;
-    WINE_HDD *whdd = GlobalLock16(hdd);
-
-    TRACE("(0x%08lx)\n",(DWORD)hdd);
-
-    whdd->hpal = 0; /* Do not free this */
-    whdd->hdc = 0;
-    if (whdd->lpbi) {
-        HeapFree(GetProcessHeap(),0,whdd->lpbi);
-        whdd->lpbi = NULL;
-    }
-    if (whdd->lpbiOut) {
-        HeapFree(GetProcessHeap(),0,whdd->lpbiOut);
-        whdd->lpbiOut = NULL;
-    }
-
-    whdd->begun = FALSE;
-
-    /*if (whdd->lpvbits)
-      HeapFree(GetProcessHeap(),0,whdd->lpvbuf);*/
-
-    if (whdd->hMemDC) {
-        SelectObject(whdd->hMemDC,whdd->hOldDib);
-        DeleteDC(whdd->hMemDC);
-    }
-
-    if (whdd->hDib)
-        DeleteObject(whdd->hDib);
-
-    if (whdd->hic) {
-        ICDecompressEnd(whdd->hic);
-        ICClose(whdd->hic);
-    }
-
-    whdd->lpvbits = NULL;
-
-    GlobalUnlock16(hdd);
-    return ret;
-}
-
-/***********************************************************************
- *      DrawDibEnd      [MSVIDEO.105]
+        BOOL ret = TRUE;
+        WINE_HDD *whdd = GlobalLock16(hdd);
+        
+        TRACE("(0x%08lx)\n",(DWORD)hdd);
+
+        whdd->hpal = 0; /* Do not free this */
+        whdd->hdc = 0;
+        if (whdd->lpbi) {
+                HeapFree(GetProcessHeap(),0,whdd->lpbi);
+                whdd->lpbi = NULL;
+        }
+        if (whdd->lpbiOut) {
+                HeapFree(GetProcessHeap(),0,whdd->lpbiOut);
+                whdd->lpbiOut = NULL;
+        }
+
+        whdd->begun = FALSE;
+
+        /*if (whdd->lpvbits)
+          HeapFree(GetProcessHeap(),0,whdd->lpvbuf);*/
+
+        if (whdd->hMemDC) {
+                SelectObject(whdd->hMemDC,whdd->hOldDib);
+                DeleteDC(whdd->hMemDC);
+        }
+
+        if (whdd->hDib)
+                DeleteObject(whdd->hDib);
+        
+        if (whdd->hic) {
+                ICDecompressEnd(whdd->hic);
+                ICClose(whdd->hic);
+        }
+
+        whdd->lpvbits = NULL;
+
+        GlobalUnlock16(hdd);
+        return ret;
+}
+
+/***********************************************************************
+ *              DrawDibEnd              [MSVIDEO.105]
  */
 BOOL16 VFWAPI DrawDibEnd16(HDRAWDIB16 hdd) {
-    return DrawDibEnd(hdd);
+        return DrawDibEnd(hdd);
 }
 
@@ -158 +157 @@
  */
 BOOL VFWAPI DrawDibBegin(HDRAWDIB hdd,
-                         HDC      hdc,
-                         INT      dxDst,
-                         INT      dyDst,
-                         LPBITMAPINFOHEADER lpbi,
-                         INT      dxSrc,
-                         INT      dySrc,
-                         UINT     wFlags) {
-    BOOL ret = TRUE;
-    WINE_HDD *whdd;
-
-    TRACE("(%d,0x%lx,%d,%d,%p,%d,%d,0x%08lx)\n",
-        hdd,(DWORD)hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,(DWORD)wFlags
-    );
-    TRACE("lpbi: %ld,%ld/%ld,%d,%d,%ld,%ld,%ld,%ld,%ld,%ld\n",
-          lpbi->biSize, lpbi->biWidth, lpbi->biHeight, lpbi->biPlanes,
-          lpbi->biBitCount, lpbi->biCompression, lpbi->biSizeImage,
-          lpbi->biXPelsPerMeter, lpbi->biYPelsPerMeter, lpbi->biClrUsed,
-          lpbi->biClrImportant);
-
-    if (wFlags & ~(DDF_BUFFER))
-        FIXME("wFlags == 0x%08x not handled\n", wFlags & ~(DDF_BUFFER));
-
-    whdd = (WINE_HDD*)GlobalLock16(hdd);
-    if (!whdd) return FALSE;
-
-    if (whdd->begun)
-        DrawDibEnd(hdd);
-
-    if (lpbi->biCompression) {
-        DWORD size = 0;
-
-        whdd->hic = ICOpen(ICTYPE_VIDEO,lpbi->biCompression,ICMODE_DECOMPRESS);
-        if (!whdd->hic) {
-            WARN("Could not open IC. biCompression == 0x%08lx\n",lpbi->biCompression);
-            ret = FALSE;
-        }
-
-        if (ret) {
-            size = ICDecompressGetFormat(whdd->hic,lpbi,NULL);
-            if (size == ICERR_UNSUPPORTED) {
-                WARN("Codec doesn't support GetFormat, giving up.\n");
-                ret = FALSE;
-            }
-        }
-
-        if (ret) {
-            whdd->lpbiOut = HeapAlloc(GetProcessHeap(),0,size);
-
-            if (ICDecompressGetFormat(whdd->hic,lpbi,whdd->lpbiOut) != ICERR_OK)
-                ret = FALSE;
-        }
-
-        if (ret) {
-            /* FIXME: Use Ex functions if available? */
-            if (ICDecompressBegin(whdd->hic,lpbi,whdd->lpbiOut) != ICERR_OK)
-                ret = FALSE;
-
-            TRACE("biSizeImage == %ld\n",whdd->lpbiOut->biSizeImage);
-            TRACE("biCompression == %ld\n",whdd->lpbiOut->biCompression);
-            TRACE("biBitCount == %d\n",whdd->lpbiOut->biBitCount);
-        }
-    } else {
-        DWORD dwSize;
-        /* No compression */
-        TRACE("Not compressed!\n");
-        dwSize = lpbi->biSize + lpbi->biClrUsed*sizeof(RGBQUAD);
-        whdd->lpbiOut = HeapAlloc(GetProcessHeap(),0,dwSize);
-        memcpy(whdd->lpbiOut,lpbi,dwSize);
-    }
-
-    if (ret) {
-        /*whdd->lpvbuf = HeapAlloc(GetProcessHeap(),0,whdd->lpbiOut->biSizeImage);*/
-
-        whdd->hMemDC = CreateCompatibleDC(hdc);
-        TRACE("Creating: %ld,%p\n",whdd->lpbiOut->biSize,whdd->lpvbits);
-        whdd->hDib = CreateDIBSection(whdd->hMemDC,(BITMAPINFO *)whdd->lpbiOut,DIB_RGB_COLORS,&(whdd->lpvbits),0,0);
-        if (!whdd->hDib) {
-            TRACE("Error: %ld\n",GetLastError());
-        }
-        TRACE("Created: %d,%p\n",whdd->hDib,whdd->lpvbits);
-        whdd->hOldDib = SelectObject(whdd->hMemDC,whdd->hDib);
-    }
-
-    if (ret) {
-        whdd->hdc = hdc;
-        whdd->dxDst = dxDst;
-        whdd->dyDst = dyDst;
-        whdd->lpbi = HeapAlloc(GetProcessHeap(),0,lpbi->biSize);
-        memcpy(whdd->lpbi,lpbi,lpbi->biSize);
-        whdd->dxSrc = dxSrc;
-        whdd->dySrc = dySrc;
-        whdd->begun = TRUE;
-        whdd->hpal = 0;
-    } else {
-        if (whdd->hic)
-            ICClose(whdd->hic);
-        if (whdd->lpbiOut) {
-            HeapFree(GetProcessHeap(),0,whdd->lpbiOut);
-            whdd->lpbiOut = NULL;
-        }
-    }
-
-    GlobalUnlock16(hdd);
-
-    return ret;
+                                                 HDC      hdc,
+                                                 INT      dxDst,
+                                                 INT      dyDst,
+                                                 LPBITMAPINFOHEADER lpbi,
+                                                 INT      dxSrc,
+                                                 INT      dySrc,
+                                                 UINT     wFlags) {
+        BOOL ret = TRUE;
+        WINE_HDD *whdd;
+
+        TRACE("(%d,0x%lx,%d,%d,%p,%d,%d,0x%08lx)\n",
+                hdd,(DWORD)hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,(DWORD)wFlags
+        );
+        TRACE("lpbi: %ld,%ld/%ld,%d,%d,%ld,%ld,%ld,%ld,%ld,%ld\n",
+                  lpbi->biSize, lpbi->biWidth, lpbi->biHeight, lpbi->biPlanes, 
+                  lpbi->biBitCount, lpbi->biCompression, lpbi->biSizeImage, 
+                  lpbi->biXPelsPerMeter, lpbi->biYPelsPerMeter, lpbi->biClrUsed, 
+                  lpbi->biClrImportant);
+
+        if (wFlags & ~(DDF_BUFFER))
+                FIXME("wFlags == 0x%08x not handled\n", wFlags & ~(DDF_BUFFER));
+
+        whdd = (WINE_HDD*)GlobalLock16(hdd);
+        if (!whdd) return FALSE;
+
+        if (whdd->begun)
+                DrawDibEnd(hdd);
+
+        if (lpbi->biCompression) {
+                DWORD size = 0;
+
+                whdd->hic = ICOpen(ICTYPE_VIDEO,lpbi->biCompression,ICMODE_DECOMPRESS);
+                if (!whdd->hic) {
+                        WARN("Could not open IC. biCompression == 0x%08lx\n",lpbi->biCompression);
+                        ret = FALSE;
+                }
+
+                if (ret) {
+                        size = ICDecompressGetFormat(whdd->hic,lpbi,NULL);
+                        if (size == ICERR_UNSUPPORTED) {
+                                WARN("Codec doesn't support GetFormat, giving up.\n");
+                                ret = FALSE;
+                        }
+                }
+
+                if (ret) {
+                        whdd->lpbiOut = HeapAlloc(GetProcessHeap(),0,size);
+
+                        if (ICDecompressGetFormat(whdd->hic,lpbi,whdd->lpbiOut) != ICERR_OK)
+                                ret = FALSE;
+                }
+
+                if (ret) {
+                        /* FIXME: Use Ex functions if available? */
+                        if (ICDecompressBegin(whdd->hic,lpbi,whdd->lpbiOut) != ICERR_OK)
+                                ret = FALSE;
+
+                        TRACE("biSizeImage == %ld\n",whdd->lpbiOut->biSizeImage);
+                        TRACE("biCompression == %ld\n",whdd->lpbiOut->biCompression);
+                        TRACE("biBitCount == %d\n",whdd->lpbiOut->biBitCount);
+                }
+        } else {
+                DWORD dwSize;
+                /* No compression */
+                TRACE("Not compressed!\n");
+                dwSize = lpbi->biSize + lpbi->biClrUsed*sizeof(RGBQUAD);
+                whdd->lpbiOut = HeapAlloc(GetProcessHeap(),0,dwSize);
+                memcpy(whdd->lpbiOut,lpbi,dwSize);
+        }
+
+        if (ret) {
+                /*whdd->lpvbuf = HeapAlloc(GetProcessHeap(),0,whdd->lpbiOut->biSizeImage);*/
+                
+                whdd->hMemDC = CreateCompatibleDC(hdc);
+                TRACE("Creating: %ld,%p\n",whdd->lpbiOut->biSize,whdd->lpvbits);
+                whdd->hDib = CreateDIBSection(whdd->hMemDC,(BITMAPINFO *)whdd->lpbiOut,DIB_RGB_COLORS,&(whdd->lpvbits),0,0);
+                if (!whdd->hDib) {
+                        TRACE("Error: %ld\n",GetLastError());
+                }
+                TRACE("Created: %d,%p\n",whdd->hDib,whdd->lpvbits);
+                whdd->hOldDib = SelectObject(whdd->hMemDC,whdd->hDib);
+        }
+
+        if (ret) {
+                whdd->hdc = hdc;
+                whdd->dxDst = dxDst;
+                whdd->dyDst = dyDst;
+                whdd->lpbi = HeapAlloc(GetProcessHeap(),0,lpbi->biSize);
+                memcpy(whdd->lpbi,lpbi,lpbi->biSize);
+                whdd->dxSrc = dxSrc;
+                whdd->dySrc = dySrc;
+                whdd->begun = TRUE;
+                whdd->hpal = 0;
+        } else {
+                if (whdd->hic)
+                        ICClose(whdd->hic);
+                if (whdd->lpbiOut) {
+                        HeapFree(GetProcessHeap(),0,whdd->lpbiOut);
+                        whdd->lpbiOut = NULL;
+                }
+        }
+
+        GlobalUnlock16(hdd);
+
+        return ret;
 }
 
 /************************************************************************
- *      DrawDibBegin        [MSVIDEO.104]
+ *              DrawDibBegin            [MSVIDEO.104]
  */
 BOOL16 VFWAPI DrawDibBegin16(HDRAWDIB16 hdd,
-                           HDC16      hdc,
-                           INT16      dxDst,
-                           INT16      dyDst,
-                           LPBITMAPINFOHEADER lpbi,
-                           INT16      dxSrc,
-                           INT16      dySrc,
-                           UINT16     wFlags) {
-    return DrawDibBegin(hdd,hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,wFlags);
+                                                   HDC16      hdc,
+                                                   INT16      dxDst,
+                                                   INT16      dyDst,
+                                                   LPBITMAPINFOHEADER lpbi,
+                                                   INT16      dxSrc,
+                                                   INT16      dySrc,
+                                                   UINT16     wFlags) {
+        return DrawDibBegin(hdd,hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,wFlags);
 }
 
 /**********************************************************************
- *      DrawDibDraw     [MSVFW32.@]
+ *              DrawDibDraw             [MSVFW32.@]
  */
 BOOL VFWAPI DrawDibDraw(HDRAWDIB hdd, HDC hdc,
-    INT xDst, INT yDst, INT dxDst, INT dyDst,
-    LPBITMAPINFOHEADER lpbi,
-    LPVOID lpBits,
-    INT xSrc, INT ySrc, INT dxSrc, INT dySrc,
-    UINT wFlags
+        INT xDst, INT yDst, INT dxDst, INT dyDst,
+        LPBITMAPINFOHEADER lpbi,
+        LPVOID lpBits,
+        INT xSrc, INT ySrc, INT dxSrc, INT dySrc,
+        UINT wFlags
 ) {
-    WINE_HDD *whdd;
-    BOOL ret = TRUE;
-
-    TRACE("(%d,0x%lx,%d,%d,%d,%d,%p,%p,%d,%d,%d,%d,0x%08lx)\n",
-          hdd,(DWORD)hdc,xDst,yDst,dxDst,dyDst,lpbi,lpBits,xSrc,ySrc,dxSrc,dySrc,(DWORD)wFlags
-    );
-
-    if (wFlags & ~(DDF_SAME_HDC | DDF_SAME_DRAW | DDF_NOTKEYFRAME |
-                   DDF_UPDATE | DDF_DONTDRAW))
-        FIXME("wFlags == 0x%08lx not handled\n",(DWORD)wFlags);
-
-    if (!lpBits) {
-        /* Undocumented? */
-        lpBits = (LPSTR)lpbi + (WORD)(lpbi->biSize) + (WORD)(lpbi->biClrUsed*sizeof(RGBQUAD));
-    }
-
-    whdd = GlobalLock16(hdd);
+        WINE_HDD *whdd;
+        BOOL ret = TRUE;
+
+        TRACE("(%d,0x%lx,%d,%d,%d,%d,%p,%p,%d,%d,%d,%d,0x%08lx)\n",
+                  hdd,(DWORD)hdc,xDst,yDst,dxDst,dyDst,lpbi,lpBits,xSrc,ySrc,dxSrc,dySrc,(DWORD)wFlags
+        );
+
+        if (wFlags & ~(DDF_SAME_HDC | DDF_SAME_DRAW | DDF_NOTKEYFRAME | 
+                                   DDF_UPDATE | DDF_DONTDRAW))
+                FIXME("wFlags == 0x%08lx not handled\n",(DWORD)wFlags);
+
+        if (!lpBits) {
+                /* Undocumented? */
+                lpBits = (LPSTR)lpbi + (WORD)(lpbi->biSize) + (WORD)(lpbi->biClrUsed*sizeof(RGBQUAD));
+        }
+
+        whdd = GlobalLock16(hdd);
 
 #define CHANGED(x) (whdd->x != x)
 
-    if ((!whdd->begun) || (!(wFlags & DDF_SAME_HDC) && CHANGED(hdc)) || (!(wFlags & DDF_SAME_DRAW) &&
-         (CHANGED(lpbi) || CHANGED(dxSrc) || CHANGED(dySrc) || CHANGED(dxDst) || CHANGED(dyDst)))) {
-        TRACE("Something changed!\n");
-        ret = DrawDibBegin(hdd,hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,0);
-    }
+        if ((!whdd->begun) || (!(wFlags & DDF_SAME_HDC) && CHANGED(hdc)) || (!(wFlags & DDF_SAME_DRAW) &&
+                 (CHANGED(lpbi) || CHANGED(dxSrc) || CHANGED(dySrc) || CHANGED(dxDst) || CHANGED(dyDst)))) {
+                TRACE("Something changed!\n");
+                ret = DrawDibBegin(hdd,hdc,dxDst,dyDst,lpbi,dxSrc,dySrc,0);
+        }
 
 #undef CHANGED
 
         if ((dxDst == -1) && (dyDst == -1)) {
-        dxDst = dxSrc;
-        dyDst = dySrc;
-    }
-
-    if (!(wFlags & DDF_UPDATE)) {
-        /* biSizeImage may be set to 0 for BI_RGB (uncompressed) bitmaps */
-        if ((lpbi->biCompression == BI_RGB) && (lpbi->biSizeImage == 0))
-            lpbi->biSizeImage = ((lpbi->biWidth * lpbi->biBitCount + 31) / 32) * 4 * lpbi->biHeight;
-
-        if (lpbi->biCompression) {
-            DWORD flags = 0;
-
-            TRACE("Compression == 0x%08lx\n",lpbi->biCompression);
-
-            if (wFlags & DDF_NOTKEYFRAME)
-                flags |= ICDECOMPRESS_NOTKEYFRAME;
-
-            ICDecompress(whdd->hic,flags,lpbi,lpBits,whdd->lpbiOut,whdd->lpvbits);
-        } else {
-            memcpy(whdd->lpvbits,lpBits,lpbi->biSizeImage);
-        }
-    }
-    if (!(wFlags & DDF_DONTDRAW) && whdd->hpal)
-        SelectPalette(hdc,whdd->hpal,FALSE);
-
-    if (!(StretchBlt(whdd->hdc,xDst,yDst,dxDst,dyDst,whdd->hMemDC,xSrc,ySrc,dxSrc,dySrc,SRCCOPY)))
-        ret = FALSE;
-
-    GlobalUnlock16(hdd);
-    return ret;
+                dxDst = dxSrc;
+                dyDst = dySrc;
+        }
+
+        if (!(wFlags & DDF_UPDATE)) {
+            /* biSizeImage may be set to 0 for BI_RGB (uncompressed) bitmaps */
+            if ((lpbi->biCompression == BI_RGB) && (lpbi->biSizeImage == 0))
+                    lpbi->biSizeImage = ((lpbi->biWidth * lpbi->biBitCount + 31) / 32) * 4 * lpbi->biHeight;
+
+                if (lpbi->biCompression) {
+                    DWORD flags = 0;
+                
+                        TRACE("Compression == 0x%08lx\n",lpbi->biCompression);
+                
+                        if (wFlags & DDF_NOTKEYFRAME)
+                            flags |= ICDECOMPRESS_NOTKEYFRAME;
+                
+                        ICDecompress(whdd->hic,flags,lpbi,lpBits,whdd->lpbiOut,whdd->lpvbits);
+                } else {
+                    memcpy(whdd->lpvbits,lpBits,lpbi->biSizeImage);
+                }       
+        }
+        if (!(wFlags & DDF_DONTDRAW) && whdd->hpal)
+            SelectPalette(hdc,whdd->hpal,FALSE);
+
+        if (!(StretchBlt(whdd->hdc,xDst,yDst,dxDst,dyDst,whdd->hMemDC,xSrc,ySrc,dxSrc,dySrc,SRCCOPY)))
+            ret = FALSE;
+
+        GlobalUnlock16(hdd);
+        return ret;
 }
 
 /**********************************************************************
- *      DrawDibDraw     [MSVIDEO.106]
- */
-BOOL16 VFWAPI DrawDibDraw16(HDRAWDIB16 hdd,
-                          HDC16 hdc,
-                          INT16 xDst,
-                          INT16 yDst,
-                          INT16 dxDst,
-                          INT16 dyDst,
-                          LPBITMAPINFOHEADER lpbi,
-                          LPVOID lpBits,
-                          INT16 xSrc,
-                          INT16 ySrc,
-                          INT16 dxSrc,
-                          INT16 dySrc,
-                          UINT16 wFlags) {
-    return DrawDibDraw(hdd,hdc,xDst,yDst,dxDst,dyDst,lpbi,lpBits,xSrc,ySrc,dxSrc,dySrc,wFlags);
+ *              DrawDibDraw             [MSVIDEO.106]
+ */
+BOOL16 VFWAPI DrawDibDraw16(HDRAWDIB16 hdd,             
+                                                  HDC16 hdc,
+                                                  INT16 xDst,
+                                                  INT16 yDst,
+                                                  INT16 dxDst,
+                                                  INT16 dyDst,
+                                                  LPBITMAPINFOHEADER lpbi,
+                                                  LPVOID lpBits,
+                                                  INT16 xSrc,
+                                                  INT16 ySrc,
+                                                  INT16 dxSrc,
+                                                  INT16 dySrc,
+                                                  UINT16 wFlags) {
+        return DrawDibDraw(hdd,hdc,xDst,yDst,dxDst,dyDst,lpbi,lpBits,xSrc,ySrc,dxSrc,dySrc,wFlags);
 }
 
 /*************************************************************************
- *      DrawDibStart        [MSVFW32.@]
+ *              DrawDibStart            [MSVFW32.@]
  */
 BOOL VFWAPI DrawDibStart(HDRAWDIB hdd, DWORD rate) {
-    FIXME("(0x%08lx,%ld), stub\n",(DWORD)hdd,rate);
-    return TRUE;
+        FIXME("(0x%08lx,%ld), stub\n",(DWORD)hdd,rate);
+        return TRUE;
 }
 
 /*************************************************************************
- *      DrawDibStart        [MSVIDEO.118]
+ *              DrawDibStart            [MSVIDEO.118]
  */
 BOOL16 VFWAPI DrawDibStart16(HDRAWDIB16 hdd, DWORD rate) {
-    return DrawDibStart(hdd,rate);
+        return DrawDibStart(hdd,rate);
 }
 
 /*************************************************************************
- *      DrawDibStop     [MSVFW32.@]
+ *              DrawDibStop             [MSVFW32.@]
  */
 BOOL VFWAPI DrawDibStop(HDRAWDIB hdd) {
-    FIXME("(0x%08lx), stub\n",(DWORD)hdd);
-    return TRUE;
+        FIXME("(0x%08lx), stub\n",(DWORD)hdd);
+        return TRUE;
 }
 
 /*************************************************************************
- *      DrawDibStop     [MSVIDEO.119]
+ *              DrawDibStop             [MSVIDEO.119]
  */
 BOOL16 DrawDibStop16(HDRAWDIB16 hdd) {
-    return DrawDibStop(hdd);
+        return DrawDibStop(hdd);
 }
 
@@ -403 +402 @@
  */
 BOOL VFWAPI DrawDibSetPalette(HDRAWDIB hdd, HPALETTE hpal) {
-    WINE_HDD *whdd;
-
-    TRACE("(0x%08lx,0x%08lx)\n",(DWORD)hdd,(DWORD)hpal);
-
-    whdd = GlobalLock16(hdd);
-    whdd->hpal = hpal;
-
-    if (whdd->begun) {
-        SelectPalette(whdd->hdc,hpal,0);
-        RealizePalette(whdd->hdc);
-    }
-    GlobalUnlock16(hdd);
-    return TRUE;
+        WINE_HDD *whdd;
+
+        TRACE("(0x%08lx,0x%08lx)\n",(DWORD)hdd,(DWORD)hpal);
+
+        whdd = GlobalLock16(hdd);
+        whdd->hpal = hpal;
+        
+        if (whdd->begun) {
+                SelectPalette(whdd->hdc,hpal,0);
+                RealizePalette(whdd->hdc);
+        }
+        GlobalUnlock16(hdd);
+        return TRUE;
 }
 
@@ -422 +421 @@
  */
 BOOL16 VFWAPI DrawDibSetPalette16(HDRAWDIB16 hdd, HPALETTE16 hpal) {
-    return DrawDibSetPalette(hdd,hpal);
+        return DrawDibSetPalette(hdd,hpal);
 }
 
@@ -429 +428 @@
  */
 HPALETTE VFWAPI DrawDibGetPalette(HDRAWDIB hdd) {
-    WINE_HDD *whdd;
-    HPALETTE ret;
-
-    TRACE("(0x%08lx)\n",(DWORD)hdd);
-
-    whdd = GlobalLock16(hdd);
-    ret = whdd->hpal;
-    GlobalUnlock16(hdd);
-    return ret;
+        WINE_HDD *whdd;
+        HPALETTE ret;
+
+        TRACE("(0x%08lx)\n",(DWORD)hdd);
+
+        whdd = GlobalLock16(hdd);
+        ret = whdd->hpal;
+        GlobalUnlock16(hdd);
+        return ret;
 }
 
@@ -444 +443 @@
  */
 HPALETTE16 VFWAPI DrawDibGetPalette16(HDRAWDIB16 hdd) {
-    return (HPALETTE16)DrawDibGetPalette(hdd);
+        return (HPALETTE16)DrawDibGetPalette(hdd);
 }
 
@@ -451 +450 @@
  */
 UINT VFWAPI DrawDibRealize(HDRAWDIB hdd, HDC hdc, BOOL fBackground) {
-    WINE_HDD *whdd;
-    HPALETTE oldPal;
-    UINT ret = 0;
-
-    FIXME("(%d,0x%08lx,%d), stub\n",hdd,(DWORD)hdc,fBackground);
-
-    whdd = GlobalLock16(hdd);
-
-    if (!whdd || !(whdd->begun)) {
-        ret = 0;
-        goto out;
-    }
-
-    if (!whdd->hpal)
-        whdd->hpal = CreateHalftonePalette(hdc);
-
-    oldPal = SelectPalette(hdc,whdd->hpal,fBackground);
-    ret = RealizePalette(hdc);
-
+        WINE_HDD *whdd;
+        HPALETTE oldPal;
+        UINT ret = 0;
+
+        FIXME("(%d,0x%08lx,%d), stub\n",hdd,(DWORD)hdc,fBackground);
+        
+        whdd = GlobalLock16(hdd);
+
+        if (!whdd || !(whdd->begun)) {
+                ret = 0;
+                goto out;
+        }
+        
+        if (!whdd->hpal)
+                whdd->hpal = CreateHalftonePalette(hdc);
+
+        oldPal = SelectPalette(hdc,whdd->hpal,fBackground);
+        ret = RealizePalette(hdc);
+        
  out:
-    GlobalUnlock16(hdd);
-
-    TRACE("=> %u\n",ret);
-    return ret;
+        GlobalUnlock16(hdd);
+
+        TRACE("=> %u\n",ret);
+        return ret;
 }
 
@@ -481 +480 @@
  */
 UINT16 VFWAPI DrawDibRealize16(HDRAWDIB16 hdd, HDC16 hdc, BOOL16 fBackground) {
-    return (UINT16)DrawDibRealize(hdd,hdc,fBackground);
-}
+        return (UINT16)DrawDibRealize(hdd,hdc,fBackground);
+}

trunk/src/msvfw32/msvideo_main.c

@@ -1 @@
-/* $Id: msvideo_main.c,v 1.2 2001-09-05 13:12:35 bird Exp $ */
 /*
  * Copyright 1998 Marcus Meissner
- * Copyright 2000 Bradley Baetz
+ * Copyright 2000 Bradley Baetz 
  *
  * FIXME: This all assumes 32 bit codecs
- *      Win95 appears to prefer 32 bit codecs, even from 16 bit code.
- *      There is the ICOpenFunction16 to worry about still, though.
+ *              Win95 appears to prefer 32 bit codecs, even from 16 bit code.
+ *              There is the ICOpenFunction16 to worry about still, though.
  */
 
@@ -35 +34 @@
 #define GlobalFree16 GlobalFree
 #undef SEGPTR_NEW
-#define SEGPTR_NEW(a)   malloc(sizeof(a))
+#define SEGPTR_NEW(a)   malloc(sizeof(a))
 #define SEGPTR_FREE(a)  free(a)
 #define SEGPTR_GET(a)   a
@@ -60 +59 @@
 
 /***********************************************************************
- *      VideoForWindowsVersion      [MSVFW32.2]
- *      VideoForWindowsVersion      [MSVIDEO.2]
+ *              VideoForWindowsVersion          [MSVFW32.2]
+ *              VideoForWindowsVersion          [MSVIDEO.2]
  * Returns the version in major.minor form.
  * In Windows95 this returns 0x040003b6 (4.950)
  */
 DWORD WINAPI VideoForWindowsVersion(void) {
-    return 0x040003B6; /* 4.950 */
-}
-
-/***********************************************************************
- *      VideoCapDriverDescAndVer    [MSVIDEO.22]
+        return 0x040003B6; /* 4.950 */
+}
+
+/***********************************************************************
+ *              VideoCapDriverDescAndVer        [MSVIDEO.22]
  */
 DWORD WINAPI VideoCapDriverDescAndVer(
-    WORD nr,LPSTR buf1,WORD buf1len,LPSTR buf2,WORD buf2len
+        WORD nr,LPSTR buf1,WORD buf1len,LPSTR buf2,WORD buf2len
 ) {
-    DWORD   verhandle;
-    WORD    xnr = nr;
-    DWORD   infosize;
-    UINT    subblocklen;
-    char    *s,buf[2000],fn[260];
-    LPBYTE  infobuf;
-    LPVOID  subblock;
-
-    TRACE("(%d,%p,%d,%p,%d)\n",nr,buf1,buf1len,buf2,buf2len);
-    if (GetPrivateProfileStringA("drivers32",NULL,NULL,buf,sizeof(buf),"system.ini")) {
-        s = buf;
-        while (*s) {
-                if (!strncasecmp(s,"vid",3)) {
-                if (!xnr)
-                break;
-                xnr--;
-            }
-            s=s+strlen(s)+1; /* either next char or \0 */
-        }
-    } else
-        return 20; /* hmm, out of entries even if we don't have any */
-    if (xnr) {
-        FIXME("No more VID* entries found\n");
-        return 20;
-    }
-    GetPrivateProfileStringA("drivers32",s,NULL,fn,sizeof(fn),"system.ini");
-    infosize = GetFileVersionInfoSizeA(fn,&verhandle);
-    if (!infosize) {
-        TRACE("%s has no fileversioninfo.\n",fn);
-        return 18;
-    }
-    infobuf = HeapAlloc(GetProcessHeap(),0,infosize);
-    if (GetFileVersionInfoA(fn,verhandle,infosize,infobuf)) {
-        char    vbuf[200];
-        /* Yes, two space behind : */
-        /* FIXME: test for buflen */
-        sprintf(vbuf,"Version:  %d.%d.%d.%d\n",
-            ((WORD*)infobuf)[0x0f],
-            ((WORD*)infobuf)[0x0e],
-            ((WORD*)infobuf)[0x11],
-            ((WORD*)infobuf)[0x10]
-        );
-        TRACE("version of %s is %s\n",fn,vbuf);
-        strncpy(buf2,vbuf,buf2len);
-    } else {
-        TRACE("GetFileVersionInfoA failed for %s.\n",fn);
-        strncpy(buf2,fn,buf2len); /* msvideo.dll appears to copy fn*/
-    }
-    /* FIXME: language problem? */
-    if (VerQueryValueA( infobuf,
-                "\\StringFileInfo\\040904E4\\FileDescription",
-                &subblock,
-                &subblocklen
-    )) {
-        TRACE("VQA returned %s\n",(LPCSTR)subblock);
-        strncpy(buf1,subblock,buf1len);
-    } else {
-        TRACE("VQA did not return on query \\StringFileInfo\\040904E4\\FileDescription?\n");
-        strncpy(buf1,fn,buf1len); /* msvideo.dll appears to copy fn*/
-    }
-    HeapFree(GetProcessHeap(),0,infobuf);
-    return 0;
+        DWORD   verhandle;
+        WORD    xnr = nr;
+        DWORD   infosize;
+        UINT    subblocklen;
+        char    *s,buf[2000],fn[260];
+        LPBYTE  infobuf;
+        LPVOID  subblock;
+
+        TRACE("(%d,%p,%d,%p,%d)\n",nr,buf1,buf1len,buf2,buf2len);
+        if (GetPrivateProfileStringA("drivers32",NULL,NULL,buf,sizeof(buf),"system.ini")) {
+                s = buf;
+                while (*s) {
+                        if (!strncasecmp(s,"vid",3)) {
+                            if (!xnr)
+                                break;
+                            xnr--;
+                        }
+                        s=s+strlen(s)+1; /* either next char or \0 */
+                }
+        } else
+            return 20; /* hmm, out of entries even if we don't have any */
+        if (xnr) {
+                FIXME("No more VID* entries found\n");
+                return 20;
+        }
+        GetPrivateProfileStringA("drivers32",s,NULL,fn,sizeof(fn),"system.ini");
+        infosize = GetFileVersionInfoSizeA(fn,&verhandle);
+        if (!infosize) {
+            TRACE("%s has no fileversioninfo.\n",fn);
+            return 18;
+        }
+        infobuf = HeapAlloc(GetProcessHeap(),0,infosize);
+        if (GetFileVersionInfoA(fn,verhandle,infosize,infobuf)) {
+            char        vbuf[200];
+            /* Yes, two space behind : */
+            /* FIXME: test for buflen */
+            sprintf(vbuf,"Version:  %d.%d.%d.%d\n",
+                    ((WORD*)infobuf)[0x0f],
+                    ((WORD*)infobuf)[0x0e],
+                    ((WORD*)infobuf)[0x11],
+                    ((WORD*)infobuf)[0x10]
+            );
+            TRACE("version of %s is %s\n",fn,vbuf);
+            strncpy(buf2,vbuf,buf2len);
+        } else {
+            TRACE("GetFileVersionInfoA failed for %s.\n",fn);
+            strncpy(buf2,fn,buf2len); /* msvideo.dll appears to copy fn*/
+        }
+        /* FIXME: language problem? */
+        if (VerQueryValueA(     infobuf,
+                                "\\StringFileInfo\\040904E4\\FileDescription",
+                                &subblock,
+                                &subblocklen
+        )) {
+            TRACE("VQA returned %s\n",(LPCSTR)subblock);
+            strncpy(buf1,subblock,buf1len);
+        } else {
+            TRACE("VQA did not return on query \\StringFileInfo\\040904E4\\FileDescription?\n");
+            strncpy(buf1,fn,buf1len); /* msvideo.dll appears to copy fn*/
+        }
+        HeapFree(GetProcessHeap(),0,infobuf);
+        return 0;
 }
 
@@ -142 +141 @@
 
 /***********************************************************************
- *      ICInfo              [MSVFW32.@]
+ *              ICInfo                          [MSVFW32.@]
  * Get information about an installable compressor. Return TRUE if there
  * is one.
  */
 BOOL VFWAPI ICInfo(
-    DWORD fccType,      /* [in] type of compressor ('vidc') */
-    DWORD fccHandler,   /* [in] <n>th compressor */
-    ICINFO *lpicinfo)   /* [out] information about compressor */
+        DWORD fccType,          /* [in] type of compressor ('vidc') */
+        DWORD fccHandler,       /* [in] <n>th compressor */
+        ICINFO *lpicinfo)       /* [out] information about compressor */
 {
-    char    type[5],buf[2000];
-
-    memcpy(type,&fccType,4);type[4]=0;
-    TRACE("(%s,%ld,%p).\n",type,fccHandler,lpicinfo);
-    /* does OpenDriver/CloseDriver */
-    lpicinfo->dwSize = sizeof(ICINFO);
-    lpicinfo->fccType = fccType;
-    lpicinfo->dwFlags = 0;
-    if (GetPrivateProfileStringA("drivers32",NULL,NULL,buf,2000,"system.ini")) {
-        char *s = buf;
-        while (*s) {
-            if (!strncasecmp(type,s,4)) {
-                if(!fccHandler--) {
-                    lpicinfo->fccHandler = mmioStringToFOURCCA(s+5,0);
-                    return TRUE;
-                }
-            }
-            s=s+strlen(s)+1; /* either next char or \0 */
-        }
-    }
-    return FALSE;
+        char    type[5],buf[2000];
+
+        memcpy(type,&fccType,4);type[4]=0;
+        TRACE("(%s,%ld,%p).\n",type,fccHandler,lpicinfo);
+        /* does OpenDriver/CloseDriver */
+        lpicinfo->dwSize = sizeof(ICINFO);
+        lpicinfo->fccType = fccType;
+        lpicinfo->dwFlags = 0;
+        if (GetPrivateProfileStringA("drivers32",NULL,NULL,buf,2000,"system.ini")) {
+                char *s = buf;
+                while (*s) {
+                        if (!strncasecmp(type,s,4)) {
+                                if(!fccHandler--) {
+                                        lpicinfo->fccHandler = mmioStringToFOURCCA(s+5,0);
+                                        return TRUE;
+                                }
+                        }
+                        s=s+strlen(s)+1; /* either next char or \0 */
+                }
+        }
+        return FALSE;
 }
 #ifndef __WIN32OS2__
 /***********************************************************************
- *      ICInfo              [MSVIDEO.200]
+ *              ICInfo                          [MSVIDEO.200]
  */
 BOOL16 VFWAPI ICInfo16(
-    DWORD     fccType,    /* [in] */
-    DWORD     fccHandler, /* [in] */
-    ICINFO16 *lpicinfo)   /* [in/out] NOTE: SEGPTR */
+        DWORD     fccType,    /* [in] */
+        DWORD     fccHandler, /* [in] */
+        ICINFO16 *lpicinfo)   /* [in/out] NOTE: SEGPTR */
 {
-    BOOL16 ret;
-    LPVOID lpv;
-    DWORD lParam = (DWORD)lpicinfo;
-    DWORD size = ((ICINFO*)(MapSL((SEGPTR)lpicinfo)))->dwSize;
-
-    /* Use the mapping functions to map the ICINFO structure */
-    lpv = MSVIDEO_MapMsg16To32(ICM_GETINFO,&lParam,&size);
-
-    ret = ICInfo(fccType,fccHandler,(ICINFO*)lParam);
-
-    MSVIDEO_UnmapMsg16To32(ICM_GETINFO,lpv,&lParam,&size);
-
-    return ret;
-}
-#endif
-/***********************************************************************
- *      ICOpen              [MSVFW32.@]
+        BOOL16 ret;
+        LPVOID lpv;
+        DWORD lParam = (DWORD)lpicinfo;
+        DWORD size = ((ICINFO*)(MapSL((SEGPTR)lpicinfo)))->dwSize;
+
+        /* Use the mapping functions to map the ICINFO structure */
+        lpv = MSVIDEO_MapMsg16To32(ICM_GETINFO,&lParam,&size);
+
+        ret = ICInfo(fccType,fccHandler,(ICINFO*)lParam);
+
+        MSVIDEO_UnmapMsg16To32(ICM_GETINFO,lpv,&lParam,&size);
+        
+        return ret;
+}
+#endif
+/***********************************************************************
+ *              ICOpen                          [MSVFW32.@]
  * Opens an installable compressor. Return special handle.
  */
 HIC VFWAPI ICOpen(DWORD fccType,DWORD fccHandler,UINT wMode) {
-    char        type[5],handler[5],codecname[20];
-    ICOPEN      icopen;
-    HDRVR       hdrv;
-    HIC16       hic;
-    WINE_HIC    *whic;
-
-    memcpy(type,&fccType,4);type[4]=0;
-    memcpy(handler,&fccHandler,4);handler[4]=0;
-    TRACE("(%s,%s,0x%08lx)\n",type,handler,(DWORD)wMode);
-
-    sprintf(codecname,"%s.%s",type,handler);
-
-    /* Well, lParam2 is in fact a LPVIDEO_OPEN_PARMS, but it has the
-     * same layout as ICOPEN
-     */
-    icopen.fccType      = fccType;
-    icopen.fccHandler   = fccHandler;
-    icopen.dwSize       = sizeof(ICOPEN);
-    icopen.dwFlags      = wMode;
-    /* FIXME: do we need to fill out the rest too? */
-    hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
-    if (!hdrv) {
-        if (!strcasecmp(type,"vids")) {
-        sprintf(codecname,"vidc.%s",handler);
-        fccType = mmioFOURCC('v','i','d','c');
-        }
-        hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
-        if (!hdrv)
-            return 0;
-    }
-    /* The handle should be a valid 16-bit handle as well */
-    hic = GlobalAlloc16(GHND,sizeof(WINE_HIC));
-    whic = (WINE_HIC*)GlobalLock16(hic);
-    whic->hdrv  = hdrv;
-    whic->driverproc= NULL;
+        char            type[5],handler[5],codecname[20];
+        ICOPEN          icopen;
+        HDRVR           hdrv;
+        HIC16           hic;
+        WINE_HIC        *whic;
+
+        memcpy(type,&fccType,4);type[4]=0;
+        memcpy(handler,&fccHandler,4);handler[4]=0;
+        TRACE("(%s,%s,0x%08lx)\n",type,handler,(DWORD)wMode);
+
+        sprintf(codecname,"%s.%s",type,handler);
+
+        /* Well, lParam2 is in fact a LPVIDEO_OPEN_PARMS, but it has the 
+         * same layout as ICOPEN
+         */
+        icopen.fccType          = fccType;
+        icopen.fccHandler       = fccHandler;
+        icopen.dwSize           = sizeof(ICOPEN);
+        icopen.dwFlags          = wMode;
+        /* FIXME: do we need to fill out the rest too? */
+        hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
+        if (!hdrv) {
+            if (!strcasecmp(type,"vids")) {
+                sprintf(codecname,"vidc.%s",handler);
+                fccType = mmioFOURCC('v','i','d','c');
+            }
+            hdrv=OpenDriverA(codecname,"drivers32",(LPARAM)&icopen);
+            if (!hdrv)
+                    return 0;
+        }
+        /* The handle should be a valid 16-bit handle as well */
+        hic = GlobalAlloc16(GHND,sizeof(WINE_HIC));
+        whic = (WINE_HIC*)GlobalLock16(hic);
+        whic->hdrv      = hdrv;
+        whic->driverproc= NULL;
 #ifdef __WIN32OS2__
-    whic->privatevfw    = 0;
+        whic->privatevfw        = 0;
 #else
-    whic->private   = 0;
-#endif
-    GlobalUnlock16(hic);
-    TRACE("=> 0x%08lx\n",(DWORD)hic);
-    return hic;
+        whic->private   = 0;
+#endif
+        GlobalUnlock16(hic);
+        TRACE("=> 0x%08lx\n",(DWORD)hic);
+        return hic;
 }
 
 HIC MSVIDEO_OpenFunc(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler, BOOL bFrom32) {
-    char    type[5],handler[5],codecname[20];
-    HIC16   hic;
-    ICOPEN*  icopen = SEGPTR_NEW(ICOPEN);
-    WINE_HIC    *whic;
-
-    memcpy(type,&fccType,4);type[4]=0;
-    memcpy(handler,&fccHandler,4);handler[4]=0;
-    TRACE("(%s,%s,%d,%p,%d)\n",type,handler,wMode,lpfnHandler,bFrom32?32:16);
-
-    icopen->fccType     = fccType;
-    icopen->fccHandler  = fccHandler;
-    icopen->dwSize      = sizeof(ICOPEN);
-    icopen->dwFlags     = wMode;
-
-    sprintf(codecname,"%s.%s",type,handler);
-
-    hic = GlobalAlloc16(GHND,sizeof(WINE_HIC));
-    if (!hic)
-        return 0;
-    whic = GlobalLock16(hic);
-    whic->driverproc = lpfnHandler;
-
+        char    type[5],handler[5],codecname[20];
+        HIC16   hic;
+        ICOPEN*  icopen = SEGPTR_NEW(ICOPEN);
+        WINE_HIC        *whic;
+
+        memcpy(type,&fccType,4);type[4]=0;
+        memcpy(handler,&fccHandler,4);handler[4]=0;
+        TRACE("(%s,%s,%d,%p,%d)\n",type,handler,wMode,lpfnHandler,bFrom32?32:16);
+        
+        icopen->fccType         = fccType;
+        icopen->fccHandler      = fccHandler;
+        icopen->dwSize          = sizeof(ICOPEN);
+        icopen->dwFlags         = wMode;
+        
+        sprintf(codecname,"%s.%s",type,handler);
+
+        hic = GlobalAlloc16(GHND,sizeof(WINE_HIC));
+        if (!hic)
+                return 0;
+        whic = GlobalLock16(hic);
+        whic->driverproc = lpfnHandler;
+        
 #ifdef __WIN32OS2__
-    whic->privatevfw    = bFrom32;
+        whic->privatevfw        = bFrom32;
 #else
-    whic->private = bFrom32;
-#endif
-
-    /* Now try opening/loading the driver. Taken from DRIVER_AddToList */
-    /* What if the function is used more than once? */
-
-    if (MSVIDEO_SendMessage(hic,DRV_LOAD,0L,0L,bFrom32) != DRV_SUCCESS) {
-        WARN("DRV_LOAD failed for hic 0x%08lx\n",(DWORD)hic);
-        GlobalFree16(hic);
-        return 0;
-    }
-    /* return value is not checked */
-    MSVIDEO_SendMessage(hic,DRV_ENABLE,0L,0L,bFrom32);
-
-    whic->hdrv = MSVIDEO_SendMessage(hic,DRV_OPEN,0,(LPARAM)(SEGPTR_GET(icopen)),FALSE);
-    if (whic->hdrv == 0) {
-        WARN("DRV_OPEN failed for hic 0x%08lx\n",(DWORD)hic);
-        GlobalFree16(hic);
-        return 0;
-    }
-
-    GlobalUnlock16(hic);
-    TRACE("=> 0x%08lx\n",(DWORD)hic);
-    return hic;
-}
-
-/***********************************************************************
- *      ICOpenFunction          [MSVFW32.@]
+        whic->private = bFrom32;
+#endif
+        
+        /* Now try opening/loading the driver. Taken from DRIVER_AddToList */
+        /* What if the function is used more than once? */
+        
+        if (MSVIDEO_SendMessage(hic,DRV_LOAD,0L,0L,bFrom32) != DRV_SUCCESS) {
+                WARN("DRV_LOAD failed for hic 0x%08lx\n",(DWORD)hic);
+                GlobalFree16(hic);
+                return 0;
+        }
+        /* return value is not checked */
+        MSVIDEO_SendMessage(hic,DRV_ENABLE,0L,0L,bFrom32);
+
+        whic->hdrv = MSVIDEO_SendMessage(hic,DRV_OPEN,0,(LPARAM)(SEGPTR_GET(icopen)),FALSE);
+        if (whic->hdrv == 0) {
+                WARN("DRV_OPEN failed for hic 0x%08lx\n",(DWORD)hic);
+                GlobalFree16(hic);
+                return 0;
+        }
+
+        GlobalUnlock16(hic);
+        TRACE("=> 0x%08lx\n",(DWORD)hic);
+        return hic;
+}
+
+/***********************************************************************
+ *              ICOpenFunction                  [MSVFW32.@]
  */
 HIC VFWAPI ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler) {
-    return MSVIDEO_OpenFunc(fccType,fccHandler,wMode,lpfnHandler,TRUE);
+        return MSVIDEO_OpenFunc(fccType,fccHandler,wMode,lpfnHandler,TRUE);
 }
 
 #ifndef __WIN32OS2__
 /***********************************************************************
- *      ICOpen              [MSVIDEO.203]
+ *              ICOpen                          [MSVIDEO.203]
  */
 HIC16 VFWAPI ICOpen16(DWORD fccType, DWORD fccHandler, UINT16 wMode) {
-    return (HIC16)ICOpen(fccType, fccHandler, wMode);
-}
-
-/***********************************************************************
- *      ICOpenFunction          [MSVIDEO.206]
+        return (HIC16)ICOpen(fccType, fccHandler, wMode);
+}
+
+/***********************************************************************
+ *              ICOpenFunction                  [MSVIDEO.206]
  */
 HIC16 VFWAPI ICOpenFunction16(DWORD fccType, DWORD fccHandler, UINT16 wMode, FARPROC16 lpfnHandler)
 {
-    return MSVIDEO_OpenFunc(fccType, fccHandler, wMode, (FARPROC)lpfnHandler,FALSE);
-}
-#endif
-
-/***********************************************************************
- *      ICGetInfo           [MSVFW32.@]
+        return MSVIDEO_OpenFunc(fccType, fccHandler, wMode, (FARPROC)lpfnHandler,FALSE);
+}
+#endif
+
+/***********************************************************************
+ *              ICGetInfo                       [MSVFW32.@]
  */
 LRESULT VFWAPI ICGetInfo(HIC hic,ICINFO *picinfo,DWORD cb) {
-    LRESULT     ret;
-
-    TRACE("(0x%08lx,%p,%ld)\n",(DWORD)hic,picinfo,cb);
-    ret = ICSendMessage(hic,ICM_GETINFO,(DWORD)picinfo,cb);
-    TRACE(" -> 0x%08lx\n",ret);
-    return ret;
+        LRESULT         ret;
+
+        TRACE("(0x%08lx,%p,%ld)\n",(DWORD)hic,picinfo,cb);
+        ret = ICSendMessage(hic,ICM_GETINFO,(DWORD)picinfo,cb);
+        TRACE(" -> 0x%08lx\n",ret);
+        return ret;
 }
 
 #ifndef __WIN32OS2__
 /***********************************************************************
- *      ICGetInfo           [MSVIDEO.212]
+ *              ICGetInfo                       [MSVIDEO.212]
  */
 LRESULT VFWAPI ICGetInfo16(HIC16 hic, ICINFO16 *picinfo,DWORD cb) {
-    LRESULT     ret;
-
-    TRACE("(0x%08lx,%p,%ld)\n",(DWORD)hic,picinfo,cb);
-    ret = ICSendMessage16(hic,ICM_GETINFO,(DWORD)picinfo,cb);
-    TRACE(" -> 0x%08lx\n",ret);
-    return ret;
-}
-#endif
-
-/***********************************************************************
- *      ICLocate            [MSVFW32.@]
+        LRESULT         ret;
+
+        TRACE("(0x%08lx,%p,%ld)\n",(DWORD)hic,picinfo,cb);
+        ret = ICSendMessage16(hic,ICM_GETINFO,(DWORD)picinfo,cb);
+        TRACE(" -> 0x%08lx\n",ret);
+        return ret;
+}
+#endif
+
+/***********************************************************************
+ *              ICLocate                        [MSVFW32.@]
  */
 HIC VFWAPI ICLocate(
-    DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
-    LPBITMAPINFOHEADER lpbiOut, WORD wMode)
+        DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
+        LPBITMAPINFOHEADER lpbiOut, WORD wMode)
 {
-    char    type[5],handler[5];
-    HIC hic;
-    DWORD   querymsg;
-    LPSTR pszBuffer;
-
-    type[4]=0;memcpy(type,&fccType,4);
-    handler[4]=0;memcpy(handler,&fccHandler,4);
-
-    TRACE("(%s,%s,%p,%p,0x%04x)\n", type, handler, lpbiIn, lpbiOut, wMode);
-
-    switch (wMode) {
-    case ICMODE_FASTCOMPRESS:
-    case ICMODE_COMPRESS:
-        querymsg = ICM_COMPRESS_QUERY;
-        break;
-    case ICMODE_FASTDECOMPRESS:
-    case ICMODE_DECOMPRESS:
-        querymsg = ICM_DECOMPRESS_QUERY;
-        break;
-    case ICMODE_DRAW:
-        querymsg = ICM_DRAW_QUERY;
-        break;
-    default:
-        WARN("Unknown mode (%d)\n",wMode);
-        return 0;
-    }
-
-    /* Easy case: handler/type match, we just fire a query and return */
-    hic = ICOpen(fccType,fccHandler,wMode);
-    if (hic) {
-        if (!ICSendMessage(hic,querymsg,(DWORD)lpbiIn,(DWORD)lpbiOut))
-            return hic;
-        ICClose(hic);
-    }
-
-    type[4]='.';memcpy(type,&fccType,4);
-    handler[4]='.';memcpy(handler,&fccHandler,4);
-
-    /* Now try each driver in turn. 32 bit codecs only. */
-    /* FIXME: Move this to an init routine? */
-
-    pszBuffer = (LPSTR)HeapAlloc(GetProcessHeap(),0,1024);
-    if (GetPrivateProfileSectionA("drivers32",pszBuffer,1024,"system.ini")) {
-        char* s = pszBuffer;
-        while (*s) {
-            if (!strncasecmp(type,s,5)) {
-                char *s2 = s;
-                while (*s2 != '\0' && *s2 != '.') s2++;
-                if (*s2++) {
-                    HIC h;
-
-                    h = ICOpen(fccType,*(DWORD*)s2,wMode);
-                    if (h) {
-                        if (!ICSendMessage(h,querymsg,(DWORD)lpbiIn,(DWORD)lpbiOut))
-                            return h;
-                        ICClose(h);
-                    }
-                }
-            }
-            s += strlen(s) + 1;
-        }
-    }
-    HeapFree(GetProcessHeap(),0,pszBuffer);
-
-    if (fccType==streamtypeVIDEO) {
-        hic = ICLocate(ICTYPE_VIDEO,fccHandler,lpbiIn,lpbiOut,wMode);
-        if (hic)
-            return hic;
-    }
-
-    type[4] = handler[4] = '\0';
-    WARN("(%.4s,%.4s,%p,%p,0x%04x) not found!\n",type,handler,lpbiIn,lpbiOut,wMode);
-    return 0;
+        char    type[5],handler[5];
+        HIC     hic;
+        DWORD   querymsg;
+        LPSTR pszBuffer;
+
+        type[4]=0;memcpy(type,&fccType,4);
+        handler[4]=0;memcpy(handler,&fccHandler,4);
+
+        TRACE("(%s,%s,%p,%p,0x%04x)\n", type, handler, lpbiIn, lpbiOut, wMode);
+
+        switch (wMode) {
+        case ICMODE_FASTCOMPRESS:
+        case ICMODE_COMPRESS: 
+                querymsg = ICM_COMPRESS_QUERY;
+                break;
+        case ICMODE_FASTDECOMPRESS:
+        case ICMODE_DECOMPRESS:
+                querymsg = ICM_DECOMPRESS_QUERY;
+                break;
+        case ICMODE_DRAW:
+                querymsg = ICM_DRAW_QUERY;
+                break;
+        default:
+                WARN("Unknown mode (%d)\n",wMode);
+                return 0;
+        }
+
+        /* Easy case: handler/type match, we just fire a query and return */
+        hic = ICOpen(fccType,fccHandler,wMode);
+        if (hic) {
+                if (!ICSendMessage(hic,querymsg,(DWORD)lpbiIn,(DWORD)lpbiOut))
+                        return hic;
+                ICClose(hic);
+        }
+
+        type[4]='.';memcpy(type,&fccType,4);
+        handler[4]='.';memcpy(handler,&fccHandler,4);
+
+        /* Now try each driver in turn. 32 bit codecs only. */
+        /* FIXME: Move this to an init routine? */
+        
+        pszBuffer = (LPSTR)HeapAlloc(GetProcessHeap(),0,1024);
+        if (GetPrivateProfileSectionA("drivers32",pszBuffer,1024,"system.ini")) {
+                char* s = pszBuffer;
+                while (*s) {
+                        if (!strncasecmp(type,s,5)) {
+                                char *s2 = s;
+                                while (*s2 != '\0' && *s2 != '.') s2++;
+                                if (*s2++) {
+                                        HIC h;
+
+                                        h = ICOpen(fccType,*(DWORD*)s2,wMode);
+                                        if (h) {
+                                                if (!ICSendMessage(h,querymsg,(DWORD)lpbiIn,(DWORD)lpbiOut))
+                                                        return h;
+                                                ICClose(h);
+                                        }
+                                }
+                        }
+                        s += strlen(s) + 1;
+                }
+        }
+        HeapFree(GetProcessHeap(),0,pszBuffer);
+        
+        if (fccType==streamtypeVIDEO) {
+                hic = ICLocate(ICTYPE_VIDEO,fccHandler,lpbiIn,lpbiOut,wMode);
+                if (hic)
+                        return hic;
+        }
+
+        type[4] = handler[4] = '\0';
+        WARN("(%.4s,%.4s,%p,%p,0x%04x) not found!\n",type,handler,lpbiIn,lpbiOut,wMode);
+        return 0;
 }
 
 #ifndef __WIN32OS2__
 /***********************************************************************
- *      ICLocate            [MSVIDEO.213]
+ *              ICLocate                        [MSVIDEO.213]
  */
 HIC16 VFWAPI ICLocate16(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn,
-                        LPBITMAPINFOHEADER lpbiOut, WORD wFlags) {
-    return (HIC16)ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, wFlags);
-}
-#endif
-
-/***********************************************************************
- *      ICGetDisplayFormat          [MSVFW32.@]
+                                                LPBITMAPINFOHEADER lpbiOut, WORD wFlags) {
+        return (HIC16)ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, wFlags);
+}
+#endif
+
+/***********************************************************************
+ *              ICGetDisplayFormat                      [MSVFW32.@]
  */
 HIC VFWAPI ICGetDisplayFormat(
-    HIC hic,LPBITMAPINFOHEADER lpbiIn,LPBITMAPINFOHEADER lpbiOut,
-    INT depth,INT dx,INT dy)
+        HIC hic,LPBITMAPINFOHEADER lpbiIn,LPBITMAPINFOHEADER lpbiOut,
+        INT depth,INT dx,INT dy)
 {
-    HIC tmphic = hic;
-
-    FIXME("(0x%08lx,%p,%p,%d,%d,%d),stub!\n",(DWORD)hic,lpbiIn,lpbiOut,depth,dx,dy);
-    if (!tmphic) {
-        tmphic=ICLocate(ICTYPE_VIDEO,0,lpbiIn,NULL,ICMODE_DECOMPRESS);
-        if (!tmphic)
-            return tmphic;
-    }
-    if ((dy == lpbiIn->biHeight) && (dx == lpbiIn->biWidth))
-        dy = dx = 0; /* no resize needed */
-
-    /* Can we decompress it ? */
-    if (ICDecompressQuery(tmphic,lpbiIn,NULL) != 0)
-        goto errout; /* no, sorry */
-
-    ICDecompressGetFormat(tmphic,lpbiIn,lpbiOut);
-
-    if (lpbiOut->biCompression != 0) {
-       FIXME("Ooch, how come decompressor outputs compressed data (%ld)??\n",
-             lpbiOut->biCompression);
-    }
-    if (lpbiOut->biSize < sizeof(*lpbiOut)) {
-       FIXME("Ooch, size of output BIH is too small (%ld)\n",
-             lpbiOut->biSize);
-       lpbiOut->biSize = sizeof(*lpbiOut);
-    }
-    if (!depth) {
-        HDC hdc;
-
-        hdc = GetDC(0);
-        depth = GetDeviceCaps(hdc,BITSPIXEL)*GetDeviceCaps(hdc,PLANES);
-        ReleaseDC(0,hdc);
-        if (depth==15)  depth = 16;
-        if (depth<8)    depth =  8;
-    }
-    if (lpbiIn->biBitCount == 8)
-        depth = 8;
-
-    TRACE("=> 0x%08lx\n",(DWORD)tmphic);
-    return tmphic;
+        HIC     tmphic = hic; 
+
+        FIXME("(0x%08lx,%p,%p,%d,%d,%d),stub!\n",(DWORD)hic,lpbiIn,lpbiOut,depth,dx,dy);
+        if (!tmphic) {
+                tmphic=ICLocate(ICTYPE_VIDEO,0,lpbiIn,NULL,ICMODE_DECOMPRESS);
+                if (!tmphic)
+                        return tmphic;
+        }
+        if ((dy == lpbiIn->biHeight) && (dx == lpbiIn->biWidth))
+                dy = dx = 0; /* no resize needed */
+
+        /* Can we decompress it ? */
+        if (ICDecompressQuery(tmphic,lpbiIn,NULL) != 0)
+                goto errout; /* no, sorry */
+
+        ICDecompressGetFormat(tmphic,lpbiIn,lpbiOut);
+
+        if (lpbiOut->biCompression != 0) {
+           FIXME("Ooch, how come decompressor outputs compressed data (%ld)??\n",
+                         lpbiOut->biCompression);
+        }
+        if (lpbiOut->biSize < sizeof(*lpbiOut)) {
+           FIXME("Ooch, size of output BIH is too small (%ld)\n",
+                         lpbiOut->biSize);
+           lpbiOut->biSize = sizeof(*lpbiOut);
+        }
+        if (!depth) {
+                HDC     hdc;
+
+                hdc = GetDC(0);
+                depth = GetDeviceCaps(hdc,BITSPIXEL)*GetDeviceCaps(hdc,PLANES);
+                ReleaseDC(0,hdc);
+                if (depth==15)  depth = 16;
+                if (depth<8)    depth =  8;
+        }
+        if (lpbiIn->biBitCount == 8)
+                depth = 8;
+        
+        TRACE("=> 0x%08lx\n",(DWORD)tmphic);
+        return tmphic;
 errout:
-    if (hic!=tmphic)
-        ICClose(tmphic);
-
-    TRACE("=> 0\n");
-    return 0;
+        if (hic!=tmphic)
+                ICClose(tmphic);
+
+        TRACE("=> 0\n");
+        return 0;
 }
 
 #ifndef __WIN32OS2__
 /***********************************************************************
- *      ICGetDisplayFormat          [MSVIDEO.239]
+ *              ICGetDisplayFormat                      [MSVIDEO.239]
  */
 HIC16 VFWAPI ICGetDisplayFormat16(HIC16 hic, LPBITMAPINFOHEADER lpbiIn,
-                                  LPBITMAPINFOHEADER lpbiOut, INT16 depth, INT16 dx, INT16 dy) {
-    return (HIC16)ICGetDisplayFormat(hic,lpbiIn,lpbiOut,depth,dx,dy);
-}
-#endif
-
-/***********************************************************************
- *      ICCompress          [MSVFW32.@]
+                                                                  LPBITMAPINFOHEADER lpbiOut, INT16 depth, INT16 dx, INT16 dy) {
+        return (HIC16)ICGetDisplayFormat(hic,lpbiIn,lpbiOut,depth,dx,dy);
+}
+#endif
+
+/***********************************************************************
+ *              ICCompress                      [MSVFW32.@]
  */
 DWORD VFWAPIV
 ICCompress(
-    HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiOutput,LPVOID lpData,
-    LPBITMAPINFOHEADER lpbiInput,LPVOID lpBits,LPDWORD lpckid,
-    LPDWORD lpdwFlags,LONG lFrameNum,DWORD dwFrameSize,DWORD dwQuality,
-    LPBITMAPINFOHEADER lpbiPrev,LPVOID lpPrev)
+        HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiOutput,LPVOID lpData,
+        LPBITMAPINFOHEADER lpbiInput,LPVOID lpBits,LPDWORD lpckid,
+        LPDWORD lpdwFlags,LONG lFrameNum,DWORD dwFrameSize,DWORD dwQuality,
+        LPBITMAPINFOHEADER lpbiPrev,LPVOID lpPrev)
 {
-    ICCOMPRESS  iccmp;
-
-    TRACE("(0x%08lx,%ld,%p,%p,%p,%p,...)\n",(DWORD)hic,dwFlags,lpbiOutput,lpData,lpbiInput,lpBits);
-
-    iccmp.dwFlags       = dwFlags;
-
-    iccmp.lpbiOutput    = lpbiOutput;
-    iccmp.lpOutput      = lpData;
-    iccmp.lpbiInput     = lpbiInput;
-    iccmp.lpInput       = lpBits;
-
-    iccmp.lpckid        = lpckid;
-    iccmp.lpdwFlags     = lpdwFlags;
-    iccmp.lFrameNum     = lFrameNum;
-    iccmp.dwFrameSize   = dwFrameSize;
-    iccmp.dwQuality     = dwQuality;
-    iccmp.lpbiPrev      = lpbiPrev;
-    iccmp.lpPrev        = lpPrev;
-    return ICSendMessage(hic,ICM_COMPRESS,(DWORD)&iccmp,sizeof(iccmp));
+        ICCOMPRESS      iccmp;
+
+        TRACE("(0x%08lx,%ld,%p,%p,%p,%p,...)\n",(DWORD)hic,dwFlags,lpbiOutput,lpData,lpbiInput,lpBits);
+
+        iccmp.dwFlags           = dwFlags;
+
+        iccmp.lpbiOutput        = lpbiOutput;
+        iccmp.lpOutput          = lpData;
+        iccmp.lpbiInput         = lpbiInput;
+        iccmp.lpInput           = lpBits;
+
+        iccmp.lpckid            = lpckid;
+        iccmp.lpdwFlags         = lpdwFlags;
+        iccmp.lFrameNum         = lFrameNum;
+        iccmp.dwFrameSize       = dwFrameSize;
+        iccmp.dwQuality         = dwQuality;
+        iccmp.lpbiPrev          = lpbiPrev;
+        iccmp.lpPrev            = lpPrev;
+        return ICSendMessage(hic,ICM_COMPRESS,(DWORD)&iccmp,sizeof(iccmp));
 }
 
 #ifndef __WIN32OS2__
 /***********************************************************************
- *      _ICCompress         [MSVIDEO.224]
+ *              _ICCompress                     [MSVIDEO.224]
  */
 DWORD VFWAPIV ICCompress16(HIC16 hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiOutput, LPVOID lpData,
-                           LPBITMAPINFOHEADER lpbiInput, LPVOID lpBits, LPDWORD lpckid,
-                           LPDWORD lpdwFlags, LONG lFrameNum, DWORD dwFrameSize, DWORD dwQuality,
-                           LPBITMAPINFOHEADER lpbiPrev, LPVOID lpPrev) {
-
-    DWORD ret;
-    ICCOMPRESS *iccmp = SEGPTR_NEW(ICCOMPRESS);
-
-    TRACE("(0x%08lx,%ld,%p,%p,%p,%p,...)\n",(DWORD)hic,dwFlags,lpbiOutput,lpData,lpbiInput,lpBits);
-
-    iccmp->dwFlags      = dwFlags;
-
-    iccmp->lpbiOutput   = lpbiOutput;
-    iccmp->lpOutput     = lpData;
-    iccmp->lpbiInput        = lpbiInput;
-    iccmp->lpInput      = lpBits;
-
-    iccmp->lpckid       = lpckid;
-    iccmp->lpdwFlags        = lpdwFlags;
-    iccmp->lFrameNum        = lFrameNum;
-    iccmp->dwFrameSize  = dwFrameSize;
-    iccmp->dwQuality        = dwQuality;
-    iccmp->lpbiPrev     = lpbiPrev;
-    iccmp->lpPrev       = lpPrev;
-    ret = ICSendMessage16(hic,ICM_COMPRESS,(DWORD)SEGPTR_GET(iccmp),sizeof(ICCOMPRESS));
-    SEGPTR_FREE(iccmp);
-    return ret;
-}
-#endif
-
-/***********************************************************************
- *      ICDecompress            [MSVFW32.@]
+                                                   LPBITMAPINFOHEADER lpbiInput, LPVOID lpBits, LPDWORD lpckid,
+                                                   LPDWORD lpdwFlags, LONG lFrameNum, DWORD dwFrameSize, DWORD dwQuality,
+                                                   LPBITMAPINFOHEADER lpbiPrev, LPVOID lpPrev) {
+
+        DWORD ret;
+        ICCOMPRESS *iccmp = SEGPTR_NEW(ICCOMPRESS);
+
+        TRACE("(0x%08lx,%ld,%p,%p,%p,%p,...)\n",(DWORD)hic,dwFlags,lpbiOutput,lpData,lpbiInput,lpBits);
+
+        iccmp->dwFlags          = dwFlags;
+
+        iccmp->lpbiOutput       = lpbiOutput;
+        iccmp->lpOutput         = lpData;
+        iccmp->lpbiInput                = lpbiInput;
+        iccmp->lpInput          = lpBits;
+
+        iccmp->lpckid           = lpckid;
+        iccmp->lpdwFlags                = lpdwFlags;
+        iccmp->lFrameNum                = lFrameNum;
+        iccmp->dwFrameSize      = dwFrameSize;
+        iccmp->dwQuality                = dwQuality;
+        iccmp->lpbiPrev         = lpbiPrev;
+        iccmp->lpPrev           = lpPrev;
+        ret = ICSendMessage16(hic,ICM_COMPRESS,(DWORD)SEGPTR_GET(iccmp),sizeof(ICCOMPRESS));
+        SEGPTR_FREE(iccmp);
+        return ret;
+}
+#endif
+
+/***********************************************************************
+ *              ICDecompress                    [MSVFW32.@]
  */
 DWORD VFWAPIV  ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,
-                LPVOID lpData,LPBITMAPINFOHEADER lpbi,LPVOID lpBits)
+                                LPVOID lpData,LPBITMAPINFOHEADER lpbi,LPVOID lpBits)
 {
-    ICDECOMPRESS    icd;
-    DWORD ret;
-
-    TRACE("(0x%08lx,%ld,%p,%p,%p,%p)\n",(DWORD)hic,dwFlags,lpbiFormat,lpData,lpbi,lpBits);
-
-    TRACE("lpBits[0] == %ld\n",((LPDWORD)lpBits)[0]);
-
-    icd.dwFlags = dwFlags;
-    icd.lpbiInput   = lpbiFormat;
-    icd.lpInput = lpData;
-
-    icd.lpbiOutput  = lpbi;
-    icd.lpOutput    = lpBits;
-    icd.ckid    = 0;
-    ret = ICSendMessage(hic,ICM_DECOMPRESS,(DWORD)&icd,sizeof(ICDECOMPRESS));
-
-    TRACE("lpBits[0] == %ld\n",((LPDWORD)lpBits)[0]);
-
-    TRACE("-> %ld\n",ret);
-
-    return ret;
+        ICDECOMPRESS    icd;
+        DWORD ret;
+
+        TRACE("(0x%08lx,%ld,%p,%p,%p,%p)\n",(DWORD)hic,dwFlags,lpbiFormat,lpData,lpbi,lpBits);
+
+        TRACE("lpBits[0] == %ld\n",((LPDWORD)lpBits)[0]);
+
+        icd.dwFlags     = dwFlags;
+        icd.lpbiInput   = lpbiFormat;
+        icd.lpInput     = lpData;
+
+        icd.lpbiOutput  = lpbi;
+        icd.lpOutput    = lpBits;
+        icd.ckid        = 0;
+        ret = ICSendMessage(hic,ICM_DECOMPRESS,(DWORD)&icd,sizeof(ICDECOMPRESS));
+
+        TRACE("lpBits[0] == %ld\n",((LPDWORD)lpBits)[0]);
+
+        TRACE("-> %ld\n",ret);
+
+        return ret;
 }
 
 #ifndef __WIN32OS2__
 /***********************************************************************
- *      _ICDecompress           [MSVIDEO.230]
+ *              _ICDecompress                   [MSVIDEO.230]
  */
 DWORD VFWAPIV ICDecompress16(HIC16 hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiFormat,
-                             LPVOID lpData, LPBITMAPINFOHEADER lpbi, LPVOID lpBits) {
-
-    ICDECOMPRESS *icd = SEGPTR_NEW(ICDECOMPRESS);
-    DWORD ret;
-
-    TRACE("(0x%08lx,%ld,%p,%p,%p,%p)\n",(DWORD)hic,dwFlags,lpbiFormat,lpData,lpbi,lpBits);
-
-    icd->dwFlags = dwFlags;
-    icd->lpbiInput = lpbiFormat;
-    icd->lpInput = lpData;
-    icd->lpbiOutput = lpbi;
-    icd->lpOutput = lpBits;
-    icd->ckid = 0;
-
-    ret = ICSendMessage16(hic,ICM_DECOMPRESS,(DWORD)SEGPTR_GET(icd),sizeof(ICDECOMPRESS));
-
-    SEGPTR_FREE(icd);
-    return ret;
+                                                         LPVOID lpData, LPBITMAPINFOHEADER lpbi, LPVOID lpBits) {
+
+        ICDECOMPRESS *icd = SEGPTR_NEW(ICDECOMPRESS);
+        DWORD ret;
+        
+        TRACE("(0x%08lx,%ld,%p,%p,%p,%p)\n",(DWORD)hic,dwFlags,lpbiFormat,lpData,lpbi,lpBits);
+
+        icd->dwFlags = dwFlags;
+        icd->lpbiInput = lpbiFormat;
+        icd->lpInput = lpData;
+        icd->lpbiOutput = lpbi;
+        icd->lpOutput = lpBits;
+        icd->ckid = 0;
+
+        ret = ICSendMessage16(hic,ICM_DECOMPRESS,(DWORD)SEGPTR_GET(icd),sizeof(ICDECOMPRESS));
+
+        SEGPTR_FREE(icd);
+        return ret;
 }
 
@@ -629 +628 @@
 
 LPVOID MSVIDEO_MapICDEX16To32(LPDWORD lParam) {
-    LPVOID ret;
-
-    ICDECOMPRESSEX *icdx = HeapAlloc(GetProcessHeap(),0,sizeof(ICDECOMPRESSEX));
-    ICDECOMPRESSEX16 *icdx16 = MapSL(*lParam);
-    ret = icdx16;
-
-    COPY(icdx,dwFlags);
-    COPYPTR(icdx,lpbiSrc);
-    COPYPTR(icdx,lpSrc);
-    COPYPTR(icdx,lpbiDst);
-    COPYPTR(icdx,lpDst);
-    COPY(icdx,xDst);
-    COPY(icdx,yDst);
-    COPY(icdx,dxDst);
-    COPY(icdx,dyDst);
-    COPY(icdx,xSrc);
-    COPY(icdx,ySrc);
-    COPY(icdx,dxSrc);
-    COPY(icdx,dySrc);
-
-    *lParam = (DWORD)(icdx);
-    return ret;
+        LPVOID ret;
+
+        ICDECOMPRESSEX *icdx = HeapAlloc(GetProcessHeap(),0,sizeof(ICDECOMPRESSEX));
+        ICDECOMPRESSEX16 *icdx16 = MapSL(*lParam);
+        ret = icdx16;
+        
+        COPY(icdx,dwFlags);
+        COPYPTR(icdx,lpbiSrc);
+        COPYPTR(icdx,lpSrc);
+        COPYPTR(icdx,lpbiDst);
+        COPYPTR(icdx,lpDst);
+        COPY(icdx,xDst);
+        COPY(icdx,yDst);
+        COPY(icdx,dxDst);
+        COPY(icdx,dyDst);
+        COPY(icdx,xSrc);
+        COPY(icdx,ySrc);
+        COPY(icdx,dxSrc);
+        COPY(icdx,dySrc);
+        
+        *lParam = (DWORD)(icdx);
+        return ret;
 }
 
 LPVOID MSVIDEO_MapMsg16To32(UINT msg, LPDWORD lParam1, LPDWORD lParam2) {
-    LPVOID ret = 0;
-
-    TRACE("Mapping %d\n",msg);
-
-    switch (msg) {
-    case DRV_LOAD:
-    case DRV_ENABLE:
-    case DRV_CLOSE:
-    case DRV_DISABLE:
-    case DRV_FREE:
-    case ICM_ABOUT:
-    case ICM_CONFIGURE:
-    case ICM_COMPRESS_END:
-    case ICM_DECOMPRESS_END:
-    case ICM_DECOMPRESSEX_END:
-    case ICM_SETQUALITY:
-    case ICM_DRAW_START_PLAY:
-    case ICM_DRAW_STOP_PLAY:
-    case ICM_DRAW_REALIZE:
-    case ICM_DRAW_RENDERBUFFER:
-    case ICM_DRAW_END:
-        break;
-    case DRV_OPEN:
-    case ICM_GETDEFAULTQUALITY:
-    case ICM_GETQUALITY:
-    case ICM_SETSTATE:
-    case ICM_DRAW_WINDOW:
-    case ICM_GETBUFFERSWANTED:
-        *lParam1 = (DWORD)MapSL(*lParam1);
-        break;
-    case ICM_GETINFO:
-        {
-            ICINFO *ici = HeapAlloc(GetProcessHeap(),0,sizeof(ICINFO));
-            ICINFO16 *ici16;
-
-            ici16 = MapSL(*lParam1);
-            ret = ici16;
-
-            ici->dwSize = sizeof(ICINFO);
-            COPY(ici,fccType);
-            COPY(ici,fccHandler);
-            COPY(ici,dwFlags);
-            COPY(ici,dwVersion);
-            COPY(ici,dwVersionICM);
+        LPVOID ret = 0;
+        
+        TRACE("Mapping %d\n",msg);
+
+        switch (msg) {
+        case DRV_LOAD:
+        case DRV_ENABLE:
+        case DRV_CLOSE:
+        case DRV_DISABLE:
+        case DRV_FREE:
+        case ICM_ABOUT:
+        case ICM_CONFIGURE:
+        case ICM_COMPRESS_END:
+        case ICM_DECOMPRESS_END:
+        case ICM_DECOMPRESSEX_END:
+        case ICM_SETQUALITY:
+        case ICM_DRAW_START_PLAY:
+        case ICM_DRAW_STOP_PLAY:
+        case ICM_DRAW_REALIZE:
+        case ICM_DRAW_RENDERBUFFER:
+        case ICM_DRAW_END:
+                break;
+        case DRV_OPEN:
+        case ICM_GETDEFAULTQUALITY:
+        case ICM_GETQUALITY:
+        case ICM_SETSTATE:
+        case ICM_DRAW_WINDOW:
+        case ICM_GETBUFFERSWANTED:
+                *lParam1 = (DWORD)MapSL(*lParam1);
+                break;
+        case ICM_GETINFO:
+                {
+                        ICINFO *ici = HeapAlloc(GetProcessHeap(),0,sizeof(ICINFO));
+                        ICINFO16 *ici16;
+
+                        ici16 = MapSL(*lParam1);
+                        ret = ici16;
+
+                        ici->dwSize = sizeof(ICINFO);
+                        COPY(ici,fccType);
+                        COPY(ici,fccHandler);
+                        COPY(ici,dwFlags);
+                        COPY(ici,dwVersion);
+                        COPY(ici,dwVersionICM);
                         MultiByteToWideChar( CP_ACP, 0, ici16->szName, -1, ici->szName, 16 );
                         MultiByteToWideChar( CP_ACP, 0, ici16->szDescription, -1, ici->szDescription, 128 );
                         MultiByteToWideChar( CP_ACP, 0, ici16->szDriver, -1, ici->szDriver, 128 );
-            *lParam1 = (DWORD)(ici);
-            *lParam2 = sizeof(ICINFO);
-        }
-        break;
-    case ICM_COMPRESS:
-        {
-            ICCOMPRESS *icc = HeapAlloc(GetProcessHeap(),0,sizeof(ICCOMPRESS));
-            ICCOMPRESS *icc16;
-
-            icc16 = MapSL(*lParam1);
-            ret = icc16;
-
-            COPY(icc,dwFlags);
-            COPYPTR(icc,lpbiOutput);
-            COPYPTR(icc,lpOutput);
-            COPYPTR(icc,lpbiInput);
-            COPYPTR(icc,lpInput);
-            COPYPTR(icc,lpckid);
-            COPYPTR(icc,lpdwFlags);
-            COPY(icc,lFrameNum);
-            COPY(icc,dwFrameSize);
-            COPY(icc,dwQuality);
-            COPYPTR(icc,lpbiPrev);
-            COPYPTR(icc,lpPrev);
-
-            *lParam1 = (DWORD)(icc);
-            *lParam2 = sizeof(ICCOMPRESS);
-        }
-        break;
-    case ICM_DECOMPRESS:
-        {
-            ICDECOMPRESS *icd = HeapAlloc(GetProcessHeap(),0,sizeof(ICDECOMPRESS));
-            ICDECOMPRESS *icd16; /* Same structure except for the pointers */
-
-            icd16 = MapSL(*lParam1);
-            ret = icd16;
-
-            COPY(icd,dwFlags);
-            COPYPTR(icd,lpbiInput);
-            COPYPTR(icd,lpInput);
-            COPYPTR(icd,lpbiOutput);
-            COPYPTR(icd,lpOutput);
-            COPY(icd,ckid);
-
-            *lParam1 = (DWORD)(icd);
-            *lParam2 = sizeof(ICDECOMPRESS);
-        }
-        break;
-    case ICM_COMPRESS_BEGIN:
-    case ICM_COMPRESS_GET_FORMAT:
-    case ICM_COMPRESS_GET_SIZE:
-    case ICM_COMPRESS_QUERY:
-    case ICM_DECOMPRESS_GET_FORMAT:
-    case ICM_DECOMPRESS_QUERY:
-    case ICM_DECOMPRESS_BEGIN:
-    case ICM_DECOMPRESS_SET_PALETTE:
-    case ICM_DECOMPRESS_GET_PALETTE:
-        *lParam1 = (DWORD)MapSL(*lParam1);
-        *lParam2 = (DWORD)MapSL(*lParam2);
-        break;
-    case ICM_DECOMPRESSEX_QUERY:
-        if ((*lParam2 != sizeof(ICDECOMPRESSEX16)) && (*lParam2 != 0))
-            WARN("*lParam2 has unknown value %p\n",(ICDECOMPRESSEX16*)*lParam2);
-        /* FIXME: *lParm2 is meant to be 0 or an ICDECOMPRESSEX16*, but is sizeof(ICDECOMRPESSEX16)
-         * This is because of ICMessage(). Special case it?
-         {
-         LPVOID* addr = HeapAlloc(GetProcessHeap(),0,2*sizeof(LPVOID));
-         addr[0] = MSVIDEO_MapICDEX16To32(lParam1);
-         if (*lParam2)
-         addr[1] = MSVIDEO_MapICDEX16To32(lParam2);
-         else
-         addr[1] = 0;
-
-         ret = addr;
-         }
-         break;*/
-    case ICM_DECOMPRESSEX_BEGIN:
-    case ICM_DECOMPRESSEX:
-        ret = MSVIDEO_MapICDEX16To32(lParam1);
-        *lParam2 = sizeof(ICDECOMPRESSEX);
-        break;
-    case ICM_DRAW_BEGIN:
-        {
-            ICDRAWBEGIN *icdb = HeapAlloc(GetProcessHeap(),0,sizeof(ICDRAWBEGIN));
-            ICDRAWBEGIN16 *icdb16 = MapSL(*lParam1);
-            ret = icdb16;
-
-            COPY(icdb,dwFlags);
-            COPY(icdb,hpal);
-            COPY(icdb,hwnd);
-            COPY(icdb,hdc);
-            COPY(icdb,xDst);
-            COPY(icdb,yDst);
-            COPY(icdb,dxDst);
-            COPY(icdb,dyDst);
-            COPYPTR(icdb,lpbi);
-            COPY(icdb,xSrc);
-            COPY(icdb,ySrc);
-            COPY(icdb,dxSrc);
-            COPY(icdb,dySrc);
-            COPY(icdb,dwRate);
-            COPY(icdb,dwScale);
-
-            *lParam1 = (DWORD)(icdb);
-            *lParam2 = sizeof(ICDRAWBEGIN);
-        }
-        break;
-    case ICM_DRAW_SUGGESTFORMAT:
-        {
-            ICDRAWSUGGEST *icds = HeapAlloc(GetProcessHeap(),0,sizeof(ICDRAWSUGGEST));
-            ICDRAWSUGGEST16 *icds16 = MapSL(*lParam1);
-
-            ret = icds16;
-
-            COPY(icds,dwFlags);
-            COPYPTR(icds,lpbiIn);
-            COPYPTR(icds,lpbiSuggest);
-            COPY(icds,dxSrc);
-            COPY(icds,dySrc);
-            COPY(icds,dxDst);
-            COPY(icds,dyDst);
-            COPY(icds,hicDecompressor);
-
-            *lParam1 = (DWORD)(icds);
-            *lParam2 = sizeof(ICDRAWSUGGEST);
-        }
-        break;
-    case ICM_DRAW:
-        {
-            ICDRAW *icd = HeapAlloc(GetProcessHeap(),0,sizeof(ICDRAW));
-            ICDRAW *icd16 = MapSL(*lParam1);
-            ret = icd16;
-
-            COPY(icd,dwFlags);
-            COPYPTR(icd,lpFormat);
-            COPYPTR(icd,lpData);
-            COPY(icd,cbData);
-            COPY(icd,lTime);
-
-            *lParam1 = (DWORD)(icd);
-            *lParam2 = sizeof(ICDRAW);
-        }
-        break;
-    case ICM_DRAW_START:
-    case ICM_DRAW_STOP:
-        break;
-    default:
-        FIXME("%d is not yet handled. Expect a crash.\n",msg);
-    }
-    return ret;
+                        *lParam1 = (DWORD)(ici);
+                        *lParam2 = sizeof(ICINFO);
+                }
+                break;
+        case ICM_COMPRESS:
+                {
+                        ICCOMPRESS *icc = HeapAlloc(GetProcessHeap(),0,sizeof(ICCOMPRESS));
+                        ICCOMPRESS *icc16;
+
+                        icc16 = MapSL(*lParam1);
+                        ret = icc16;
+
+                        COPY(icc,dwFlags);
+                        COPYPTR(icc,lpbiOutput);
+                        COPYPTR(icc,lpOutput);
+                        COPYPTR(icc,lpbiInput);
+                        COPYPTR(icc,lpInput);
+                        COPYPTR(icc,lpckid);
+                        COPYPTR(icc,lpdwFlags);
+                        COPY(icc,lFrameNum);
+                        COPY(icc,dwFrameSize);
+                        COPY(icc,dwQuality);
+                        COPYPTR(icc,lpbiPrev);
+                        COPYPTR(icc,lpPrev);
+                        
+                        *lParam1 = (DWORD)(icc);
+                        *lParam2 = sizeof(ICCOMPRESS);
+                }
+                break;
+        case ICM_DECOMPRESS:
+                {
+                        ICDECOMPRESS *icd = HeapAlloc(GetProcessHeap(),0,sizeof(ICDECOMPRESS));
+                        ICDECOMPRESS *icd16; /* Same structure except for the pointers */
+                        
+                        icd16 = MapSL(*lParam1);
+                        ret = icd16;
+                        
+                        COPY(icd,dwFlags);
+                        COPYPTR(icd,lpbiInput);
+                        COPYPTR(icd,lpInput);
+                        COPYPTR(icd,lpbiOutput);
+                        COPYPTR(icd,lpOutput);
+                        COPY(icd,ckid);
+                        
+                        *lParam1 = (DWORD)(icd);
+                        *lParam2 = sizeof(ICDECOMPRESS);
+                }
+                break;
+        case ICM_COMPRESS_BEGIN:
+        case ICM_COMPRESS_GET_FORMAT:
+        case ICM_COMPRESS_GET_SIZE:
+        case ICM_COMPRESS_QUERY:
+        case ICM_DECOMPRESS_GET_FORMAT:
+        case ICM_DECOMPRESS_QUERY:
+        case ICM_DECOMPRESS_BEGIN:
+        case ICM_DECOMPRESS_SET_PALETTE:
+        case ICM_DECOMPRESS_GET_PALETTE:
+                *lParam1 = (DWORD)MapSL(*lParam1);
+                *lParam2 = (DWORD)MapSL(*lParam2);
+                break;
+        case ICM_DECOMPRESSEX_QUERY:
+                if ((*lParam2 != sizeof(ICDECOMPRESSEX16)) && (*lParam2 != 0))
+                        WARN("*lParam2 has unknown value %p\n",(ICDECOMPRESSEX16*)*lParam2);
+                /* FIXME: *lParm2 is meant to be 0 or an ICDECOMPRESSEX16*, but is sizeof(ICDECOMRPESSEX16)
+                 * This is because of ICMessage(). Special case it?
+                 {
+                 LPVOID* addr = HeapAlloc(GetProcessHeap(),0,2*sizeof(LPVOID));
+                 addr[0] = MSVIDEO_MapICDEX16To32(lParam1);
+                 if (*lParam2)
+                 addr[1] = MSVIDEO_MapICDEX16To32(lParam2);
+                 else
+                 addr[1] = 0;
+                 
+                 ret = addr;
+                 }
+                 break;*/
+        case ICM_DECOMPRESSEX_BEGIN:
+        case ICM_DECOMPRESSEX:
+                ret = MSVIDEO_MapICDEX16To32(lParam1);
+                *lParam2 = sizeof(ICDECOMPRESSEX);
+                break;
+        case ICM_DRAW_BEGIN:
+                {
+                        ICDRAWBEGIN *icdb = HeapAlloc(GetProcessHeap(),0,sizeof(ICDRAWBEGIN));
+                        ICDRAWBEGIN16 *icdb16 = MapSL(*lParam1);
+                        ret = icdb16;
+
+                        COPY(icdb,dwFlags);
+                        COPY(icdb,hpal);
+                        COPY(icdb,hwnd);
+                        COPY(icdb,hdc);
+                        COPY(icdb,xDst);
+                        COPY(icdb,yDst);
+                        COPY(icdb,dxDst);
+                        COPY(icdb,dyDst);
+                        COPYPTR(icdb,lpbi);
+                        COPY(icdb,xSrc);
+                        COPY(icdb,ySrc);
+                        COPY(icdb,dxSrc);
+                        COPY(icdb,dySrc);
+                        COPY(icdb,dwRate);
+                        COPY(icdb,dwScale);
+
+                        *lParam1 = (DWORD)(icdb);
+                        *lParam2 = sizeof(ICDRAWBEGIN);
+                }
+                break;
+        case ICM_DRAW_SUGGESTFORMAT:
+                {
+                        ICDRAWSUGGEST *icds = HeapAlloc(GetProcessHeap(),0,sizeof(ICDRAWSUGGEST));
+                        ICDRAWSUGGEST16 *icds16 = MapSL(*lParam1);
+                        
+                        ret = icds16;
+
+                        COPY(icds,dwFlags);
+                        COPYPTR(icds,lpbiIn);
+                        COPYPTR(icds,lpbiSuggest);
+                        COPY(icds,dxSrc);
+                        COPY(icds,dySrc);
+                        COPY(icds,dxDst);
+                        COPY(icds,dyDst);
+                        COPY(icds,hicDecompressor);
+
+                        *lParam1 = (DWORD)(icds);
+                        *lParam2 = sizeof(ICDRAWSUGGEST);
+                }
+                break;
+        case ICM_DRAW:
+                {
+                        ICDRAW *icd = HeapAlloc(GetProcessHeap(),0,sizeof(ICDRAW));
+                        ICDRAW *icd16 = MapSL(*lParam1);
+                        ret = icd16;
+
+                        COPY(icd,dwFlags);
+                        COPYPTR(icd,lpFormat);
+                        COPYPTR(icd,lpData);
+                        COPY(icd,cbData);
+                        COPY(icd,lTime);
+
+                        *lParam1 = (DWORD)(icd);
+                        *lParam2 = sizeof(ICDRAW);
+                }
+                break;
+        case ICM_DRAW_START:
+        case ICM_DRAW_STOP:
+                break;
+        default:
+                FIXME("%d is not yet handled. Expect a crash.\n",msg);
+        }
+        return ret;
 }
 
@@ -857 +856 @@
 
 void MSVIDEO_UnmapMsg16To32(UINT msg, LPVOID data16, LPDWORD lParam1, LPDWORD lParam2) {
-    TRACE("Unmapping %d\n",msg);
+        TRACE("Unmapping %d\n",msg);
 
 #define UNCOPY(x,y) (x##16->y = x->y);
 
-    switch (msg) {
-    case ICM_GETINFO:
-        {
-            ICINFO *ici = (ICINFO*)(*lParam1);
-            ICINFO16 *ici16 = (ICINFO16*)data16;
-
-            UNCOPY(ici,fccType);
-            UNCOPY(ici,fccHandler);
-            UNCOPY(ici,dwFlags);
-            UNCOPY(ici,dwVersion);
-            UNCOPY(ici,dwVersionICM);
+        switch (msg) {
+        case ICM_GETINFO:
+                {
+                        ICINFO *ici = (ICINFO*)(*lParam1);
+                        ICINFO16 *ici16 = (ICINFO16*)data16;
+
+                        UNCOPY(ici,fccType);
+                        UNCOPY(ici,fccHandler);
+                        UNCOPY(ici,dwFlags);
+                        UNCOPY(ici,dwVersion);
+                        UNCOPY(ici,dwVersionICM);
                         WideCharToMultiByte( CP_ACP, 0, ici->szName, -1, ici16->szName,
                                              sizeof(ici16->szName), NULL, NULL );
@@ -878 +877 @@
                                              sizeof(ici16->szDescription), NULL, NULL );
                         ici16->szDescription[sizeof(ici16->szDescription)-1] = 0;
-            /* This just gives garbage for some reason - BB
-               lstrcpynWtoA(ici16->szDriver,ici->szDriver,128);*/
-
-            HeapFree(GetProcessHeap(),0,ici);
-        }
-        break;
-    case ICM_DECOMPRESS_QUERY:
-        /*{
-          LPVOID* x = data16;
-          HeapFree(GetProcessHeap(),0,x[0]);
-          if (x[1])
-          HeapFree(GetProcessHeap(),0,x[1]);
-          }
-          break;*/
-    case ICM_COMPRESS:
-    case ICM_DECOMPRESS:
-    case ICM_DECOMPRESSEX_QUERY:
-    case ICM_DECOMPRESSEX_BEGIN:
-    case ICM_DECOMPRESSEX:
-    case ICM_DRAW_BEGIN:
-    case ICM_DRAW_SUGGESTFORMAT:
-    case ICM_DRAW:
-        HeapFree(GetProcessHeap(),0,data16);
-        break;
-    default:
-        ERR("Unmapping unmapped msg %d\n",msg);
-    }
-#undef UNCOPY
+                        /* This just gives garbage for some reason - BB
+                           lstrcpynWtoA(ici16->szDriver,ici->szDriver,128);*/
+
+                        HeapFree(GetProcessHeap(),0,ici);
+                }
+                break;
+        case ICM_DECOMPRESS_QUERY:
+                /*{
+                  LPVOID* x = data16;
+                  HeapFree(GetProcessHeap(),0,x[0]);
+                  if (x[1])
+                  HeapFree(GetProcessHeap(),0,x[1]);
+                  }
+                  break;*/
+        case ICM_COMPRESS:
+        case ICM_DECOMPRESS:
+        case ICM_DECOMPRESSEX_QUERY:
+        case ICM_DECOMPRESSEX_BEGIN:
+        case ICM_DECOMPRESSEX:
+        case ICM_DRAW_BEGIN:
+        case ICM_DRAW_SUGGESTFORMAT:
+        case ICM_DRAW:
+                HeapFree(GetProcessHeap(),0,data16);
+                break;
+        default:
+                ERR("Unmapping unmapped msg %d\n",msg);
+        }
+#undef UNCOPY           
 }
 #endif
 
 LRESULT MSVIDEO_SendMessage(HIC hic,UINT msg,DWORD lParam1,DWORD lParam2, BOOL bFrom32) {
-    LRESULT     ret;
-    WINE_HIC    *whic = GlobalLock16(hic);
-    LPVOID data16 = 0;
-    BOOL bDrv32;
+        LRESULT         ret;
+        WINE_HIC        *whic = GlobalLock16(hic);
+        LPVOID data16 = 0;
+        BOOL bDrv32;
 
 #define XX(x) case x: TRACE("(0x%08lx,"#x",0x%08lx,0x%08lx,%d)\n",(DWORD)hic,lParam1,lParam2,bFrom32?32:16);break;
 
-    switch (msg) {
-        /* DRV_* */
-        XX(DRV_LOAD);
-        XX(DRV_ENABLE);
-        XX(DRV_OPEN);
-        XX(DRV_CLOSE);
-        XX(DRV_DISABLE);
-        XX(DRV_FREE);
-        /* ICM_RESERVED+X */
-        XX(ICM_ABOUT);
-        XX(ICM_CONFIGURE);
-        XX(ICM_GET);
-        XX(ICM_GETINFO);
-        XX(ICM_GETDEFAULTQUALITY);
-        XX(ICM_GETQUALITY);
-        XX(ICM_GETSTATE);
-        XX(ICM_SETQUALITY);
-        XX(ICM_SET);
-        XX(ICM_SETSTATE);
-        /* ICM_USER+X */
-        XX(ICM_COMPRESS_FRAMES_INFO);
-        XX(ICM_COMPRESS_GET_FORMAT);
-        XX(ICM_COMPRESS_GET_SIZE);
-        XX(ICM_COMPRESS_QUERY);
-        XX(ICM_COMPRESS_BEGIN);
-        XX(ICM_COMPRESS);
-        XX(ICM_COMPRESS_END);
-        XX(ICM_DECOMPRESS_GET_FORMAT);
-        XX(ICM_DECOMPRESS_QUERY);
-        XX(ICM_DECOMPRESS_BEGIN);
-        XX(ICM_DECOMPRESS);
-        XX(ICM_DECOMPRESS_END);
-        XX(ICM_DECOMPRESS_SET_PALETTE);
-        XX(ICM_DECOMPRESS_GET_PALETTE);
-        XX(ICM_DRAW_QUERY);
-        XX(ICM_DRAW_BEGIN);
-        XX(ICM_DRAW_GET_PALETTE);
-        XX(ICM_DRAW_START);
-        XX(ICM_DRAW_STOP);
-        XX(ICM_DRAW_END);
-        XX(ICM_DRAW_GETTIME);
-        XX(ICM_DRAW);
-        XX(ICM_DRAW_WINDOW);
-        XX(ICM_DRAW_SETTIME);
-        XX(ICM_DRAW_REALIZE);
-        XX(ICM_DRAW_FLUSH);
-        XX(ICM_DRAW_RENDERBUFFER);
-        XX(ICM_DRAW_START_PLAY);
-        XX(ICM_DRAW_STOP_PLAY);
-        XX(ICM_DRAW_SUGGESTFORMAT);
-        XX(ICM_DRAW_CHANGEPALETTE);
-        XX(ICM_GETBUFFERSWANTED);
-        XX(ICM_GETDEFAULTKEYFRAMERATE);
-        XX(ICM_DECOMPRESSEX_BEGIN);
-        XX(ICM_DECOMPRESSEX_QUERY);
-        XX(ICM_DECOMPRESSEX);
-        XX(ICM_DECOMPRESSEX_END);
-        XX(ICM_SET_STATUS_PROC);
-    default:
-        FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx,%i) unknown message\n",(DWORD)hic,(DWORD)msg,lParam1,lParam2,bFrom32?32:16);
-    }
+        switch (msg) {
+                /* DRV_* */
+                XX(DRV_LOAD);
+                XX(DRV_ENABLE);
+                XX(DRV_OPEN);
+                XX(DRV_CLOSE);
+                XX(DRV_DISABLE);
+                XX(DRV_FREE);
+                /* ICM_RESERVED+X */
+                XX(ICM_ABOUT);
+                XX(ICM_CONFIGURE);
+                XX(ICM_GET);
+                XX(ICM_GETINFO);
+                XX(ICM_GETDEFAULTQUALITY);
+                XX(ICM_GETQUALITY);
+                XX(ICM_GETSTATE);
+                XX(ICM_SETQUALITY);
+                XX(ICM_SET);
+                XX(ICM_SETSTATE);
+                /* ICM_USER+X */
+                XX(ICM_COMPRESS_FRAMES_INFO);
+                XX(ICM_COMPRESS_GET_FORMAT);
+                XX(ICM_COMPRESS_GET_SIZE);
+                XX(ICM_COMPRESS_QUERY);
+                XX(ICM_COMPRESS_BEGIN);
+                XX(ICM_COMPRESS);
+                XX(ICM_COMPRESS_END);
+                XX(ICM_DECOMPRESS_GET_FORMAT);
+                XX(ICM_DECOMPRESS_QUERY);
+                XX(ICM_DECOMPRESS_BEGIN);
+                XX(ICM_DECOMPRESS);
+                XX(ICM_DECOMPRESS_END);
+                XX(ICM_DECOMPRESS_SET_PALETTE);
+                XX(ICM_DECOMPRESS_GET_PALETTE);
+                XX(ICM_DRAW_QUERY);
+                XX(ICM_DRAW_BEGIN);
+                XX(ICM_DRAW_GET_PALETTE);
+                XX(ICM_DRAW_START);
+                XX(ICM_DRAW_STOP);
+                XX(ICM_DRAW_END);
+                XX(ICM_DRAW_GETTIME);
+                XX(ICM_DRAW);
+                XX(ICM_DRAW_WINDOW);
+                XX(ICM_DRAW_SETTIME);
+                XX(ICM_DRAW_REALIZE);
+                XX(ICM_DRAW_FLUSH);
+                XX(ICM_DRAW_RENDERBUFFER);
+                XX(ICM_DRAW_START_PLAY);
+                XX(ICM_DRAW_STOP_PLAY);
+                XX(ICM_DRAW_SUGGESTFORMAT);
+                XX(ICM_DRAW_CHANGEPALETTE);
+                XX(ICM_GETBUFFERSWANTED);
+                XX(ICM_GETDEFAULTKEYFRAMERATE);
+                XX(ICM_DECOMPRESSEX_BEGIN);
+                XX(ICM_DECOMPRESSEX_QUERY);
+                XX(ICM_DECOMPRESSEX);
+                XX(ICM_DECOMPRESSEX_END);
+                XX(ICM_SET_STATUS_PROC);
+        default:
+                FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx,%i) unknown message\n",(DWORD)hic,(DWORD)msg,lParam1,lParam2,bFrom32?32:16);
+        }
 
 #undef XX
 
-    if (!whic) return ICERR_BADHANDLE;
-
-    if (whic->driverproc) { /* IC is a function */
+        if (!whic) return ICERR_BADHANDLE;
+
+        if (whic->driverproc) { /* IC is a function */
 #ifdef __WIN32OS2__
-            bDrv32 = whic->privatevfw;
+                bDrv32 = whic->privatevfw;
 #else
-        bDrv32 = whic->private;
-#endif
-    } else {
-        bDrv32 = ((GetDriverFlags(whic->hdrv) & (WINE_GDF_EXIST|WINE_GDF_16BIT)) == WINE_GDF_EXIST);
-    }
+                bDrv32 = whic->private;
+#endif
+        } else {
+                bDrv32 = ((GetDriverFlags(whic->hdrv) & (WINE_GDF_EXIST|WINE_GDF_16BIT)) == WINE_GDF_EXIST);
+        }
 
 #ifndef __WIN32OS2__
-    if (!bFrom32) {
-        if (bDrv32)
-            data16 = MSVIDEO_MapMsg16To32(msg,&lParam1,&lParam2);
-    } else {
-        if (!bDrv32) {
-            ERR("Can't do 32->16 mappings\n");
-            ret = -1;
-            goto out;
-        }
-    }
-#endif
-
-    if (whic->driverproc) {
+        if (!bFrom32) {
+                if (bDrv32)
+                        data16 = MSVIDEO_MapMsg16To32(msg,&lParam1,&lParam2);
+        } else {
+                if (!bDrv32) {
+                        ERR("Can't do 32->16 mappings\n");
+                        ret = -1;
+                        goto out;
+                }
+        }
+#endif
+        
+        if (whic->driverproc) {
 #ifdef __WIN32OS2__
-            ret = whic->driverproc(whic->hdrv,hic,msg,lParam1,lParam2);
+                ret = whic->driverproc(whic->hdrv,hic,msg,lParam1,lParam2);
 #else
-        if (bDrv32) {
-            ret = whic->driverproc(whic->hdrv,hic,msg,lParam1,lParam2);
-        } else {
-            ret = MSVIDEO_CallTo16_long_lwwll((FARPROC16)whic->driverproc,whic->hdrv,hic,msg,lParam1,lParam2);
-        }
-#endif
-    } else {
-        ret = SendDriverMessage(whic->hdrv,msg,lParam1,lParam2);
-    }
+                if (bDrv32) {
+                        ret = whic->driverproc(whic->hdrv,hic,msg,lParam1,lParam2);
+                } else {
+                        ret = MSVIDEO_CallTo16_long_lwwll((FARPROC16)whic->driverproc,whic->hdrv,hic,msg,lParam1,lParam2);
+                }
+#endif
+        } else {
+                ret = SendDriverMessage(whic->hdrv,msg,lParam1,lParam2);
+        }
 
 #ifndef __WIN32OS2__
-    if (data16)
-        MSVIDEO_UnmapMsg16To32(msg,data16,&lParam1,&lParam2);
-#endif
-
+        if (data16)
+                MSVIDEO_UnmapMsg16To32(msg,data16,&lParam1,&lParam2);
+#endif
+ 
  out:
-    GlobalUnlock16(hic);
-
-    TRACE(" -> 0x%08lx\n",ret);
-    return ret;
-}
-
-/***********************************************************************
- *      ICSendMessage           [MSVFW32.@]
+        GlobalUnlock16(hic);
+        
+        TRACE(" -> 0x%08lx\n",ret);
+        return ret;
+}
+
+/***********************************************************************
+ *              ICSendMessage                   [MSVFW32.@]
  */
 LRESULT VFWAPI ICSendMessage(HIC hic, UINT msg, DWORD lParam1, DWORD lParam2) {
-    return MSVIDEO_SendMessage(hic,msg,lParam1,lParam2,TRUE);
+        return MSVIDEO_SendMessage(hic,msg,lParam1,lParam2,TRUE);
 }
 #ifndef __WIN32OS2__
 /***********************************************************************
- *      ICSendMessage           [MSVIDEO.205]
+ *              ICSendMessage                   [MSVIDEO.205]
  */
 LRESULT VFWAPI ICSendMessage16(HIC16 hic, UINT16 msg, DWORD lParam1, DWORD lParam2) {
-    return MSVIDEO_SendMessage(hic,msg,lParam1,lParam2,FALSE);
-}
-
-/***********************************************************************
- *      _ICMessage          [MSVIDEO.207]
+        return MSVIDEO_SendMessage(hic,msg,lParam1,lParam2,FALSE);
+}
+
+/***********************************************************************
+ *              _ICMessage                      [MSVIDEO.207]
  */
 LRESULT VFWAPIV ICMessage16(void) {
-    HIC16 hic;
-    UINT16 msg;
-    UINT16 cb;
-    LPWORD lpData;
-    LRESULT ret;
-    UINT16 i;
-
-    VA_LIST16 valist;
-
-    VA_START16(valist);
-    hic = VA_ARG16(valist, HIC16);
-    msg = VA_ARG16(valist, UINT16);
-    cb  = VA_ARG16(valist, UINT16);
-
-    lpData = SEGPTR_ALLOC(cb);
-
-    TRACE("0x%08lx, %u, %u, ...)\n",(DWORD)hic,msg,cb);
-
-    for(i=0;i<cb/sizeof(WORD);i++) {
-        lpData[i] = VA_ARG16(valist, WORD);
-    }
-
-    VA_END16(valist);
-    ret = ICSendMessage16(hic, msg, (DWORD)(SEGPTR_GET(lpData)), (DWORD)cb);
-
-    SEGPTR_FREE(lpData);
-    return ret;
-}
-#endif
-/***********************************************************************
- *      ICDrawBegin     [MSVFW32.@]
+        HIC16 hic;
+        UINT16 msg;
+        UINT16 cb;
+        LPWORD lpData;
+        LRESULT ret;
+        UINT16 i;
+
+        VA_LIST16 valist;
+        
+        VA_START16(valist);
+        hic = VA_ARG16(valist, HIC16);
+        msg = VA_ARG16(valist, UINT16);
+        cb  = VA_ARG16(valist, UINT16);
+
+        lpData = SEGPTR_ALLOC(cb);
+
+        TRACE("0x%08lx, %u, %u, ...)\n",(DWORD)hic,msg,cb);
+
+        for(i=0;i<cb/sizeof(WORD);i++) {
+                lpData[i] = VA_ARG16(valist, WORD);
+        }
+                
+        VA_END16(valist);
+        ret = ICSendMessage16(hic, msg, (DWORD)(SEGPTR_GET(lpData)), (DWORD)cb);
+
+        SEGPTR_FREE(lpData);
+        return ret;
+}
+#endif
+/***********************************************************************
+ *              ICDrawBegin             [MSVFW32.@]
  */
 DWORD VFWAPIV ICDrawBegin(
-    HIC                hic,     /* [in] */
-    DWORD              dwFlags, /* [in] flags */
-    HPALETTE           hpal,    /* [in] palette to draw with */
-    HWND               hwnd,    /* [in] window to draw to */
-    HDC                hdc,     /* [in] HDC to draw to */
-    INT                xDst,    /* [in] destination rectangle */
-    INT                yDst,    /* [in] */
-    INT                dxDst,   /* [in] */
-    INT                dyDst,   /* [in] */
-    LPBITMAPINFOHEADER lpbi,    /* [in] format of frame to draw */
-    INT                xSrc,    /* [in] source rectangle */
-    INT                ySrc,    /* [in] */
-    INT                dxSrc,   /* [in] */
-    INT                dySrc,   /* [in] */
-    DWORD              dwRate,  /* [in] frames/second = (dwRate/dwScale) */
-    DWORD              dwScale) /* [in] */
+        HIC                hic,     /* [in] */
+        DWORD              dwFlags, /* [in] flags */
+        HPALETTE           hpal,    /* [in] palette to draw with */
+        HWND               hwnd,    /* [in] window to draw to */
+        HDC                hdc,     /* [in] HDC to draw to */
+        INT                xDst,    /* [in] destination rectangle */
+        INT                yDst,    /* [in] */
+        INT                dxDst,   /* [in] */
+        INT                dyDst,   /* [in] */
+        LPBITMAPINFOHEADER lpbi,    /* [in] format of frame to draw */
+        INT                xSrc,    /* [in] source rectangle */
+        INT                ySrc,    /* [in] */
+        INT                dxSrc,   /* [in] */
+        INT                dySrc,   /* [in] */
+        DWORD              dwRate,  /* [in] frames/second = (dwRate/dwScale) */
+        DWORD              dwScale) /* [in] */
 {
-
-    ICDRAWBEGIN icdb;
-
-    TRACE("(0x%08lx,%ld,0x%08lx,0x%08lx,0x%08lx,%u,%u,%u,%u,%p,%u,%u,%u,%u,%ld,%ld)\n",
-          (DWORD)hic, dwFlags, (DWORD)hpal, (DWORD)hwnd, (DWORD)hdc, xDst, yDst, dxDst, dyDst,
-          lpbi, xSrc, ySrc, dxSrc, dySrc, dwRate, dwScale);
-
-    icdb.dwFlags = dwFlags;
-    icdb.hpal = hpal;
-    icdb.hwnd = hwnd;
-    icdb.hdc = hdc;
-    icdb.xDst = xDst;
-    icdb.yDst = yDst;
-    icdb.dxDst = dxDst;
-    icdb.dyDst = dyDst;
-    icdb.lpbi = lpbi;
-    icdb.xSrc = xSrc;
-    icdb.ySrc = ySrc;
-    icdb.dxSrc = dxSrc;
-    icdb.dySrc = dySrc;
-    icdb.dwRate = dwRate;
-    icdb.dwScale = dwScale;
-    return ICSendMessage(hic,ICM_DRAW_BEGIN,(DWORD)&icdb,sizeof(icdb));
+        
+        ICDRAWBEGIN     icdb;
+
+        TRACE("(0x%08lx,%ld,0x%08lx,0x%08lx,0x%08lx,%u,%u,%u,%u,%p,%u,%u,%u,%u,%ld,%ld)\n",
+                  (DWORD)hic, dwFlags, (DWORD)hpal, (DWORD)hwnd, (DWORD)hdc, xDst, yDst, dxDst, dyDst,
+                  lpbi, xSrc, ySrc, dxSrc, dySrc, dwRate, dwScale);
+
+        icdb.dwFlags = dwFlags;
+        icdb.hpal = hpal;
+        icdb.hwnd = hwnd;
+        icdb.hdc = hdc;
+        icdb.xDst = xDst;
+        icdb.yDst = yDst;
+        icdb.dxDst = dxDst;
+        icdb.dyDst = dyDst;
+        icdb.lpbi = lpbi;
+        icdb.xSrc = xSrc;
+        icdb.ySrc = ySrc;
+        icdb.dxSrc = dxSrc;
+        icdb.dySrc = dySrc;
+        icdb.dwRate = dwRate;
+        icdb.dwScale = dwScale;
+        return ICSendMessage(hic,ICM_DRAW_BEGIN,(DWORD)&icdb,sizeof(icdb));
 }
 
 #ifndef __WIN32OS2__
 /***********************************************************************
- *      _ICDrawBegin        [MSVIDEO.232]
+ *              _ICDrawBegin            [MSVIDEO.232]
  */
 DWORD VFWAPIV ICDrawBegin16(
-    HIC16               hic,     /* [in] */
-    DWORD               dwFlags, /* [in] flags */
-    HPALETTE16          hpal,    /* [in] palette to draw with */
-    HWND16              hwnd,    /* [in] window to draw to */
-    HDC16               hdc,     /* [in] HDC to draw to */
-    INT16               xDst,    /* [in] destination rectangle */
-    INT16               yDst,    /* [in] */
-    INT16               dxDst,   /* [in] */
-    INT16               dyDst,   /* [in] */
-    LPBITMAPINFOHEADER  lpbi,    /* [in] format of frame to draw NOTE: SEGPTR */
-    INT16           xSrc,    /* [in] source rectangle */
-    INT16           ySrc,    /* [in] */
-    INT16           dxSrc,   /* [in] */
-    INT16           dySrc,   /* [in] */
-    DWORD           dwRate,  /* [in] frames/second = (dwRate/dwScale) */
-    DWORD           dwScale) /* [in] */
+        HIC16               hic,     /* [in] */
+        DWORD               dwFlags, /* [in] flags */
+        HPALETTE16          hpal,    /* [in] palette to draw with */
+        HWND16              hwnd,    /* [in] window to draw to */
+        HDC16               hdc,     /* [in] HDC to draw to */
+        INT16               xDst,    /* [in] destination rectangle */
+        INT16               yDst,    /* [in] */
+        INT16               dxDst,   /* [in] */
+        INT16               dyDst,   /* [in] */
+        LPBITMAPINFOHEADER  lpbi,    /* [in] format of frame to draw NOTE: SEGPTR */
+        INT16               xSrc,    /* [in] source rectangle */
+        INT16               ySrc,    /* [in] */
+        INT16               dxSrc,   /* [in] */
+        INT16               dySrc,   /* [in] */
+        DWORD               dwRate,  /* [in] frames/second = (dwRate/dwScale) */
+        DWORD               dwScale) /* [in] */
 {
-    DWORD ret;
-    ICDRAWBEGIN16* icdb = SEGPTR_NEW(ICDRAWBEGIN16); /* SEGPTR for mapper to deal with */
-
-    TRACE("(0x%08lx,%ld,0x%08lx,0x%08lx,0x%08lx,%u,%u,%u,%u,%p,%u,%u,%u,%u,%ld,%ld)\n",
-          (DWORD)hic, dwFlags, (DWORD)hpal, (DWORD)hwnd, (DWORD)hdc, xDst, yDst, dxDst, dyDst,
-          lpbi, xSrc, ySrc, dxSrc, dySrc, dwRate, dwScale);
-
-    icdb->dwFlags = dwFlags;
-    icdb->hpal = hpal;
-    icdb->hwnd = hwnd;
-    icdb->hdc = hdc;
-    icdb->xDst = xDst;
-    icdb->yDst = yDst;
-    icdb->dxDst = dxDst;
-    icdb->dyDst = dyDst;
-    icdb->lpbi = lpbi; /* Keep this as SEGPTR for the mapping code to deal with */
-    icdb->xSrc = xSrc;
-    icdb->ySrc = ySrc;
-    icdb->dxSrc = dxSrc;
-    icdb->dySrc = dySrc;
-    icdb->dwRate = dwRate;
-    icdb->dwScale = dwScale;
-
-    ret = (DWORD)ICSendMessage16(hic,ICM_DRAW_BEGIN,(DWORD)SEGPTR_GET(icdb),sizeof(ICDRAWBEGIN16));
-    SEGPTR_FREE(icdb);
-    return ret;
-}
-#endif
-
-/***********************************************************************
- *      ICDraw          [MSVFW32.@]
+        DWORD ret;
+        ICDRAWBEGIN16* icdb = SEGPTR_NEW(ICDRAWBEGIN16); /* SEGPTR for mapper to deal with */
+
+        TRACE("(0x%08lx,%ld,0x%08lx,0x%08lx,0x%08lx,%u,%u,%u,%u,%p,%u,%u,%u,%u,%ld,%ld)\n",
+                  (DWORD)hic, dwFlags, (DWORD)hpal, (DWORD)hwnd, (DWORD)hdc, xDst, yDst, dxDst, dyDst,
+                  lpbi, xSrc, ySrc, dxSrc, dySrc, dwRate, dwScale);
+
+        icdb->dwFlags = dwFlags;
+        icdb->hpal = hpal;
+        icdb->hwnd = hwnd;
+        icdb->hdc = hdc;
+        icdb->xDst = xDst;
+        icdb->yDst = yDst;
+        icdb->dxDst = dxDst;
+        icdb->dyDst = dyDst;
+        icdb->lpbi = lpbi; /* Keep this as SEGPTR for the mapping code to deal with */
+        icdb->xSrc = xSrc;
+        icdb->ySrc = ySrc;
+        icdb->dxSrc = dxSrc;
+        icdb->dySrc = dySrc;
+        icdb->dwRate = dwRate;
+        icdb->dwScale = dwScale;
+        
+        ret = (DWORD)ICSendMessage16(hic,ICM_DRAW_BEGIN,(DWORD)SEGPTR_GET(icdb),sizeof(ICDRAWBEGIN16));
+        SEGPTR_FREE(icdb);
+        return ret;
+}
+#endif
+
+/***********************************************************************
+ *              ICDraw                  [MSVFW32.@]
  */
 DWORD VFWAPIV ICDraw(HIC hic, DWORD dwFlags, LPVOID lpFormat, LPVOID lpData, DWORD cbData, LONG lTime) {
-    ICDRAW  icd;
-
-    TRACE("(0x%09lx,%ld,%p,%p,%ld,%ld)\n",(DWORD)hic,dwFlags,lpFormat,lpData,cbData,lTime);
-
-    icd.dwFlags = dwFlags;
-    icd.lpFormat = lpFormat;
-    icd.lpData = lpData;
-    icd.cbData = cbData;
-    icd.lTime = lTime;
-
-    return ICSendMessage(hic,ICM_DRAW,(DWORD)&icd,sizeof(icd));
+        ICDRAW  icd;
+
+        TRACE("(0x%09lx,%ld,%p,%p,%ld,%ld)\n",(DWORD)hic,dwFlags,lpFormat,lpData,cbData,lTime);
+
+        icd.dwFlags = dwFlags;
+        icd.lpFormat = lpFormat;
+        icd.lpData = lpData;
+        icd.cbData = cbData;
+        icd.lTime = lTime;
+
+        return ICSendMessage(hic,ICM_DRAW,(DWORD)&icd,sizeof(icd));
 }
 
 #ifndef __WIN32OS2__
 /***********************************************************************
- *      _ICDraw         [MSVIDEO.234]
+ *              _ICDraw                 [MSVIDEO.234]
  */
 DWORD VFWAPIV ICDraw16(
-    HIC16 hic,
-    DWORD dwFlags,
-    LPVOID lpFormat, /* [???] NOTE: SEGPTR */
-    LPVOID lpData,   /* [???] NOTE: SEGPTR */
-    DWORD cbData,
-    LONG lTime)
+        HIC16 hic,
+        DWORD dwFlags,
+        LPVOID lpFormat, /* [???] NOTE: SEGPTR */
+        LPVOID lpData,   /* [???] NOTE: SEGPTR */
+        DWORD cbData, 
+        LONG lTime) 
 {
-    ICDRAW* icd = SEGPTR_NEW(ICDRAW); /* SEGPTR for mapper to deal with */
-
-    TRACE("(0x%08lx,0x%08lx,%p,%p,%ld,%ld)\n",(DWORD)hic,dwFlags,lpFormat,lpData,cbData,lTime);
-    icd->dwFlags = dwFlags;
-    icd->lpFormat = lpFormat;
-    icd->lpData = lpData;
-    icd->cbData = cbData;
-    icd->lTime = lTime;
-
-    return ICSendMessage16(hic,ICM_DRAW,(DWORD)SEGPTR_GET(icd),sizeof(ICDRAW));
-}
-#endif
-
-/***********************************************************************
- *      ICClose         [MSVFW32.@]
+        ICDRAW* icd = SEGPTR_NEW(ICDRAW); /* SEGPTR for mapper to deal with */
+
+        TRACE("(0x%08lx,0x%08lx,%p,%p,%ld,%ld)\n",(DWORD)hic,dwFlags,lpFormat,lpData,cbData,lTime);
+        icd->dwFlags = dwFlags;
+        icd->lpFormat = lpFormat;
+        icd->lpData = lpData;
+        icd->cbData = cbData;
+        icd->lTime = lTime;
+
+        return ICSendMessage16(hic,ICM_DRAW,(DWORD)SEGPTR_GET(icd),sizeof(ICDRAW));
+}
+#endif
+
+/***********************************************************************
+ *              ICClose                 [MSVFW32.@]
  */
 LRESULT WINAPI ICClose(HIC hic) {
-    WINE_HIC *whic = GlobalLock16(hic);
-    TRACE("(0x%08lx)\n",(DWORD)hic);
-    if (whic->driverproc) {
-        ICSendMessage(hic,DRV_CLOSE,0,0);
-        ICSendMessage(hic,DRV_DISABLE,0,0);
-        ICSendMessage(hic,DRV_FREE,0,0);
-    } else {
-        CloseDriver(whic->hdrv,0,0);
-    }
-
-    GlobalUnlock16(hic);
-    GlobalFree16(hic);
-    return 0;
+        WINE_HIC *whic = GlobalLock16(hic);
+        TRACE("(0x%08lx)\n",(DWORD)hic);
+        if (whic->driverproc) {
+                ICSendMessage(hic,DRV_CLOSE,0,0);
+                ICSendMessage(hic,DRV_DISABLE,0,0);
+                ICSendMessage(hic,DRV_FREE,0,0);
+        } else {
+                CloseDriver(whic->hdrv,0,0);
+        }
+
+        GlobalUnlock16(hic);
+        GlobalFree16(hic);
+        return 0;
 }
 
 #ifndef __WIN32OS2__
 /***********************************************************************
- *      ICClose         [MSVIDEO.204]
+ *              ICClose                 [MSVIDEO.204]
  */
 LRESULT WINAPI ICClose16(HIC16 hic) {
-    return ICClose(hic);
-}
-#endif
-
-/***********************************************************************
- *      MCIWndCreate        [MSVFW32.@]
- *      MCIWndCreateA       [MSVFW32.@]
+        return ICClose(hic);
+}
+#endif
+
+/***********************************************************************
+ *              MCIWndCreate            [MSVFW32.@]
+ *              MCIWndCreateA           [MSVFW32.@]
  */
 HWND VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance,
                       DWORD dwStyle,LPCSTR szFile)
 {
-    FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, szFile);
-    return 0;
-}
-
-/***********************************************************************
- *      MCIWndCreateW       [MSVFW32.@]
+        FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, szFile);
+        return 0;
+}
+
+/***********************************************************************
+ *              MCIWndCreateW           [MSVFW32.@]
  */
 HWND VFWAPIV MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance,
                       DWORD dwStyle,LPCWSTR szFile)
 {
-    FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, debugstr_w(szFile));
-    return 0;
-}
+        FIXME("%x %x %lx %s\n",hwndParent, hInstance, dwStyle, debugstr_w(szFile));
+        return 0;
+}

trunk/src/setupapi/devinst.c

@@ -1 @@
-/* $Id: devinst.c,v 1.2 2001-09-05 13:38:23 bird Exp $ */
 /*
  * SetupAPI device installer
@@ -13 +12 @@
 
 /***********************************************************************
- *      DiGetClassDevs (SETUPX.304)
+ *              DiGetClassDevs (SETUPX.304)
  * Return a list of installed system devices.
  * Uses HKLM\\ENUM to list devices.

trunk/src/setupapi/infparse.c

@@ -1 @@
-/* $Id: infparse.c,v 1.2 2001-09-05 13:38:23 bird Exp $ */
 /*
  * SetupX .inf file parsing functions
@@ -30 +29 @@
 
     if (!lphInf)
-    return IP_ERROR;
+        return IP_ERROR;
 
     /* this could be improved by checking for already freed handles */
-    if (IP_curr_handle == 0xffff)
-    return ERR_IP_OUT_OF_HANDLES;
+    if (IP_curr_handle == 0xffff) 
+        return ERR_IP_OUT_OF_HANDLES; 
 
     if (hFile != HFILE_ERROR)
     {
-    InfList = HeapReAlloc(GetProcessHeap(), 0, InfList, InfNumEntries+1);
-    InfList[InfNumEntries].hInf = IP_curr_handle++;
-    InfList[InfNumEntries].hInfFile = hFile;
-    InfList[InfNumEntries].lpInfFileName = HeapAlloc( GetProcessHeap(), 0,
+        InfList = HeapReAlloc(GetProcessHeap(), 0, InfList, InfNumEntries+1);
+        InfList[InfNumEntries].hInf = IP_curr_handle++;
+        InfList[InfNumEntries].hInfFile = hFile;
+        InfList[InfNumEntries].lpInfFileName = HeapAlloc( GetProcessHeap(), 0,
                                                           strlen(lpInfFileName)+1);
         strcpy( InfList[InfNumEntries].lpInfFileName, lpInfFileName );
         *lphInf = InfList[InfNumEntries].hInf;
-    InfNumEntries++;
-    TRACE("ret handle %d.\n", *lphInf);
-    return OK;
+        InfNumEntries++;
+        TRACE("ret handle %d.\n", *lphInf);
+        return OK;
     }
     *lphInf = 0xffff;
@@ -58 +57 @@
 
     for (n=0; n < InfNumEntries; n++)
-    if (InfList[n].hInf == hInf)
-    {
-        *ret = n;
-        return TRUE;
-    }
+        if (InfList[n].hInf == hInf)
+        {
+            *ret = n;
+            return TRUE;
+        }
     return FALSE;
 }
-
+        
 
 LPCSTR IP_GetFileName(HINF16 hInf)
@@ -72 +71 @@
     if (IP_FindInf(hInf, &n))
     {
-    return InfList[n].lpInfFileName;
+        return InfList[n].lpInfFileName;
     }
     return NULL;
@@ -85 +84 @@
     if (IP_FindInf(hInf, &n))
     {
-    _lclose(InfList[n].hInfFile);
-    HeapFree(GetProcessHeap(), 0, InfList[n].lpInfFileName);
-    for (i=n; i < InfNumEntries-1; i++)
-        InfList[i] = InfList[i+1];
-    InfNumEntries--;
-    InfList = HeapReAlloc(GetProcessHeap(), 0, InfList, InfNumEntries);
-    res = OK;
+        _lclose(InfList[n].hInfFile);
+        HeapFree(GetProcessHeap(), 0, InfList[n].lpInfFileName);
+        for (i=n; i < InfNumEntries-1; i++)
+            InfList[i] = InfList[i+1];
+        InfNumEntries--;
+        InfList = HeapReAlloc(GetProcessHeap(), 0, InfList, InfNumEntries);
+        res = OK;
     }
     return res;
@@ -97 +96 @@
 
 /***********************************************************************
- *      IpOpen16
+ *              IpOpen16
  *
  */
@@ -107 +106 @@
 
 /***********************************************************************
- *      IpClose16
+ *              IpClose16
  */
 RETERR16 WINAPI IpClose16(HINF16 hInf)
@@ -115 +114 @@
 
 /***********************************************************************
- *      IpGetProfileString16
+ *              IpGetProfileString16
  */
-RETERR16 WINAPI IpGetProfileString16(HINF16 hInf, LPCSTR section, LPCSTR entry, LPSTR buffer, WORD buflen)
+RETERR16 WINAPI IpGetProfileString16(HINF16 hInf, LPCSTR section, LPCSTR entry, LPSTR buffer, WORD buflen) 
 {
     TRACE("'%s': section '%s' entry '%s'\n", IP_GetFileName(hInf), section, entry);

trunk/src/setupapi/setupx_main.c

@@ -1 @@
-/* $Id: setupx_main.c,v 1.2 2001-09-05 13:38:23 bird Exp $ */
 /*
  *      SETUPX library
@@ -27 +26 @@
  *
  * SETUPX consists of several parts with the following acronyms/prefixes:
- * Di   device installer (devinst.c ?)
- * Gen  generic installer (geninst.c ?)
- * Ip   .INF parsing (infparse.c)
- * LDD  logical device descriptor (ldd.c ?)
- * LDID logical device ID
+ * Di   device installer (devinst.c ?)
+ * Gen  generic installer (geninst.c ?)
+ * Ip   .INF parsing (infparse.c)
+ * LDD  logical device descriptor (ldd.c ?)
+ * LDID logical device ID 
  * SU   setup (setup.c ?)
- * Tp   text processing (textproc.c ?)
- * Vcp  virtual copy module (vcp.c ?)
+ * Tp   text processing (textproc.c ?)
+ * Vcp  virtual copy module (vcp.c ?)
  * ...
  *
@@ -56 +55 @@
 
 /***********************************************************************
- *      SURegOpenKey
+ *              SURegOpenKey
  */
 DWORD WINAPI SURegOpenKey( HKEY hkey, LPCSTR lpszSubKey, LPHKEY retkey )
@@ -65 +64 @@
 
 /***********************************************************************
- *      SURegQueryValueEx
+ *              SURegQueryValueEx
  */
 DWORD WINAPI SURegQueryValueEx( HKEY hkey, LPSTR lpszValueName,
@@ -95 +94 @@
     while (1)
     {
-    /* find beginning of real substring */
-    while ( (*p == ' ') || (*p == '\t') || (*p == '"') ) p++;
-
-    /* find end of real substring */
-    q = p;
-    while ( (*q)
-         && (*q != ' ') && (*q != '\t') && (*q != '"')
-         && (*q != ';') && (*q != delimiter) ) q++;
-    if (q == p)
-        break;
-    len = (int)q - (int)p;
-
-    /* alloc entry for new substring in steps of 32 units and copy over */
-    if (count % 32 == 0)
-    { /* 1 for count field + current count + 32 */
-        res = HeapReAlloc(GetProcessHeap(), 0, res, (1+count+32)*sizeof(LPSTR));
-    }
-    *(res+1+count) = HeapAlloc(GetProcessHeap(), 0, len+1);
-    strncpy(*(res+1+count), p, len);
-    (*(res+1+count))[len] = '\0';
-    count++;
-
-    /* we are still within last substring (before delimiter),
-     * so get out of it */
-    while ((*q) && (*q != ';') && (*q != delimiter)) q++;
-    if ((!*q) || (*q == ';'))
-        break;
-    p = q+1;
-    }
-
+        /* find beginning of real substring */
+        while ( (*p == ' ') || (*p == '\t') || (*p == '"') ) p++;
+
+        /* find end of real substring */
+        q = p;
+        while ( (*q)
+             && (*q != ' ') && (*q != '\t') && (*q != '"')
+             && (*q != ';') && (*q != delimiter) ) q++;
+        if (q == p)
+            break;
+        len = (int)q - (int)p;
+
+        /* alloc entry for new substring in steps of 32 units and copy over */
+        if (count % 32 == 0)
+        { /* 1 for count field + current count + 32 */
+            res = HeapReAlloc(GetProcessHeap(), 0, res, (1+count+32)*sizeof(LPSTR));
+        }
+        *(res+1+count) = HeapAlloc(GetProcessHeap(), 0, len+1);
+        strncpy(*(res+1+count), p, len);
+        (*(res+1+count))[len] = '\0';
+        count++;
+
+        /* we are still within last substring (before delimiter),
+         * so get out of it */
+        while ((*q) && (*q != ';') && (*q != delimiter)) q++;
+        if ((!*q) || (*q == ';'))
+            break;
+        p = q+1;
+    }
+    
     /* put number of entries at beginning of list */
     *(DWORD *)res = count;
@@ -137 +136 @@
 
     for (n=0; n < count; n++)
-    HeapFree(GetProcessHeap(), 0, *pStrings++);
+        HeapFree(GetProcessHeap(), 0, *pStrings++);
 
     HeapFree(GetProcessHeap(), 0, substr);
@@ -164 +163 @@
  *        Hmm, but on the other hand SETUPX_GetSubStrings() will probably
  *        soon be replaced by InitSubstrData() etc. anyway.
- *
+ * 
  */
 static BOOL SETUPX_LookupRegistryString(LPSTR regstr, LPSTR buffer, DWORD buflen)
@@ -182 +181 @@
     for (n=0; n < 5; n++)
     {
-    q = strchr(p, ',');
-    if (!q)
-    {
-        if (n == 4)
-        q = p+strlen(p);
-        else
-        return FALSE;
-    }
-    next = q+1;
-    if (q < regstr)
+        q = strchr(p, ',');
+        if (!q)
+        {
+            if (n == 4)
+                q = p+strlen(p);
+            else
+                return FALSE;
+        }
+        next = q+1;
+        if (q < regstr)
             return FALSE;
         SETUPX_IsolateSubString(&p, &q);
@@ -198 +197 @@
         strncpy(items[n], p, len);
         items[n][len] = '\0';
-    p = next;
+        p = next;
     }
     TRACE("got '%s','%s','%s','%s','%s'\n",
-            items[0], items[1], items[2], items[3], items[4]);
-
+                        items[0], items[1], items[2], items[3], items[4]);
+    
     /* check root key */
     if (!strcasecmp(items[0], "HKCR"))
-    hkey = HKEY_CLASSES_ROOT;
+        hkey = HKEY_CLASSES_ROOT;
     else
     if (!strcasecmp(items[0], "HKCU"))
-    hkey = HKEY_CURRENT_USER;
+        hkey = HKEY_CURRENT_USER;
     else
     if (!strcasecmp(items[0], "HKLM"))
-    hkey = HKEY_LOCAL_MACHINE;
+        hkey = HKEY_LOCAL_MACHINE;
     else
     if (!strcasecmp(items[0], "HKU"))
-    hkey = HKEY_USERS;
+        hkey = HKEY_USERS;
     else
     { /* HKR ? -> relative to key passed to GenInstallEx */
-    FIXME("unsupported regkey '%s'\n", items[0]);
+        FIXME("unsupported regkey '%s'\n", items[0]);
         goto regfailed;
     }
@@ -225 +224 @@
 
     if (RegQueryValueExA(hsubkey, items[2], NULL, &dwType, buffer, &buflen)
-        != ERROR_SUCCESS)
+                != ERROR_SUCCESS)
         goto regfailed;
     goto done;
@@ -235 +234 @@
         HeapFree(heap, 0, items[n]);
     if (buffer)
-    TRACE("return '%s'\n", buffer);
+        TRACE("return '%s'\n", buffer);
     return TRUE;
 }
@@ -245 +244 @@
 
     do {
-    buf = HeapReAlloc(GetProcessHeap(), 0, buf, len);
-    res = GetPrivateProfileStringA(NULL, NULL, NULL, buf, len, filename);
-    len *= 2;
+        buf = HeapReAlloc(GetProcessHeap(), 0, buf, len);
+        res = GetPrivateProfileStringA(NULL, NULL, NULL, buf, len, filename);
+        len *= 2;
     } while ((!res) && (len < 1048576));
     if (!res)
     {
-    HeapFree(GetProcessHeap(), 0, buf);
-    return NULL;
+        HeapFree(GetProcessHeap(), 0, buf);
+        return NULL;
     }
     return buf;
@@ -263 +262 @@
 
     do {
-    buf = HeapReAlloc(GetProcessHeap(), 0, buf, len);
-    res = GetPrivateProfileSectionA(section, buf, len, filename);
-    len *= 2;
+        buf = HeapReAlloc(GetProcessHeap(), 0, buf, len);
+        res = GetPrivateProfileSectionA(section, buf, len, filename);
+        len *= 2;
     } while ((!res) && (len < 1048576));
     if (!res)
     {
-    HeapFree(GetProcessHeap(), 0, buf);
-    return NULL;
+        HeapFree(GetProcessHeap(), 0, buf);
+        return NULL;
     }
     return buf;
@@ -277 +276 @@
 
 /***********************************************************************
- *      InstallHinfSection
+ *              InstallHinfSection
  *
  * hwnd = parent window
@@ -284 +283 @@
  * Here "DefaultInstall" is the .inf file section to be installed (optional).
  * The 132 value is made of the HOW_xxx flags and sometimes 128 (-> setupx16.h).
- *
+ * 
  * nCmdShow = nCmdShow of CreateProcess
  */
@@ -298 +297 @@
     HMODULE hMod;
     MSGBOX_PROC pMessageBoxA;
-
+    
     TRACE("(%04x, %04x, %s, %d);\n", hwnd, hinst, lpszCmdLine, nCmdShow);
-
+    
     pSub = SETUPX_GetSubStrings((LPSTR)lpszCmdLine, ' ');
 
     count = *(DWORD *)pSub;
     if (count < 2) /* invalid number of arguments ? */
-    goto end;
+        goto end;
     if (IpOpen16(*(pSub+count), &hInf) != OK)
     {
-    res = ERROR_FILE_NOT_FOUND; /* yes, correct */
-    goto end;
+        res = ERROR_FILE_NOT_FOUND; /* yes, correct */
+        goto end;
     }
     if (GenInstall16(hInf, *(pSub+count-2), GENINSTALL_DO_ALL) != OK)
-    goto end;
+        goto end;
     wFlags = atoi(*(pSub+count-1)) & ~128;
     switch (wFlags)
     {
-    case HOW_ALWAYS_SILENT_REBOOT:
-    case HOW_SILENT_REBOOT:
-        reboot = TRUE;
-        break;
-    case HOW_ALWAYS_PROMPT_REBOOT:
-    case HOW_PROMPT_REBOOT:
-        if ((hMod = GetModuleHandleA("user32.dll")))
-        {
-          if ((pMessageBoxA = (MSGBOX_PROC)GetProcAddress( hMod, "MessageBoxA" )))
-          {
-
-            if (pMessageBoxA(hwnd, "You must restart Wine before the new settings will take effect.\n\nDo you want to exit Wine now ?", "Systems Settings Change", MB_YESNO|MB_ICONQUESTION) == IDYES)
-          reboot = TRUE;
-          }
-        }
-        break;
-    default:
-        ERR("invalid flags %d !\n", wFlags);
-        goto end;
-    }
-
+        case HOW_ALWAYS_SILENT_REBOOT:
+        case HOW_SILENT_REBOOT:
+            reboot = TRUE;
+            break;
+        case HOW_ALWAYS_PROMPT_REBOOT:
+        case HOW_PROMPT_REBOOT:
+            if ((hMod = GetModuleHandleA("user32.dll")))
+            {
+              if ((pMessageBoxA = (MSGBOX_PROC)GetProcAddress( hMod, "MessageBoxA" )))
+              {
+                 
+                if (pMessageBoxA(hwnd, "You must restart Wine before the new settings will take effect.\n\nDo you want to exit Wine now ?", "Systems Settings Change", MB_YESNO|MB_ICONQUESTION) == IDYES)
+                  reboot = TRUE;
+              }
+            }
+            break;
+        default:
+            ERR("invalid flags %d !\n", wFlags);
+            goto end;
+    }
+    
     res = OK;
 end:
@@ -343 +342 @@
     if (reboot)
     {
-    /* FIXME: we should have a means of terminating all wine + wineserver */
-    MESSAGE("Program or user told me to restart. Exiting Wine...\n");
-    ExitProcess(1);
+        /* FIXME: we should have a means of terminating all wine + wineserver */
+        MESSAGE("Program or user told me to restart. Exiting Wine...\n");
+        ExitProcess(1);
     }
 
@@ -360 +359 @@
 {
     { /* 0 (LDID_NULL) -- not defined */
-    NULL,
-    NULL
+        NULL,
+        NULL
     },
     { /* 1 (LDID_SRCPATH) = source of installation. hmm, what to do here ? */
-    "SourcePath", /* hmm, does SETUPX have to care about updating it ?? */
-    NULL
+        "SourcePath", /* hmm, does SETUPX have to care about updating it ?? */
+        NULL
     },
     { /* 2 (LDID_SETUPTEMP) = setup temp dir */
-    "SetupTempDir",
-    NULL
+        "SetupTempDir",
+        NULL
     },
     { /* 3 (LDID_UNINSTALL) = uninstall backup dir */
-    "UninstallDir",
-    NULL
+        "UninstallDir",
+        NULL
     },
     { /* 4 (LDID_BACKUP) = backup dir */
-    "BackupDir",
-    NULL
+        "BackupDir",
+        NULL
     },
     { /* 5 (LDID_SETUPSCRATCH) = setup scratch dir */
-    "SetupScratchDir",
-    NULL
+        "SetupScratchDir",
+        NULL
     },
     { /* 6 -- not defined */
-    NULL,
-    NULL
+        NULL,
+        NULL
     },
     { /* 7 -- not defined */
-    NULL,
-    NULL
+        NULL,
+        NULL
     },
     { /* 8 -- not defined */
-    NULL,
-    NULL
+        NULL,
+        NULL
     },
     { /* 9 -- not defined */
-    NULL,
-    NULL
+        NULL,
+        NULL
     },
     { /* 10 (LDID_WIN) = windows dir */
-    "WinDir",
+        "WinDir",
         ""
     },
     { /* 11 (LDID_SYS) = system dir */
-    "SysDir",
-    NULL /* call GetSystemDirectory() instead */
+        "SysDir",
+        NULL /* call GetSystemDirectory() instead */
     },
     { /* 12 (LDID_IOS) = IOSubSys dir */
         NULL, /* FIXME: registry string ? */
-    "SYSTEM\\IOSUBSYS"
+        "SYSTEM\\IOSUBSYS"
     },
     { /* 13 (LDID_CMD) = COMMAND dir */
-    NULL, /* FIXME: registry string ? */
-    "COMMAND"
+        NULL, /* FIXME: registry string ? */
+        "COMMAND"
     },
     { /* 14 (LDID_CPL) = control panel dir */
-    NULL,
-    ""
+        NULL,
+        ""
     },
     { /* 15 (LDID_PRINT) = windows printer dir */
-    NULL,
-    "SYSTEM" /* correct ?? */
+        NULL,
+        "SYSTEM" /* correct ?? */
     },
     { /* 16 (LDID_MAIL) = destination mail dir */
-    NULL,
-    ""
+        NULL,
+        ""
     },
     { /* 17 (LDID_INF) = INF dir */
-    "SetupScratchDir", /* correct ? */
-    "INF"
+        "SetupScratchDir", /* correct ? */
+        "INF"
     },
     { /* 18 (LDID_HELP) = HELP dir */
-    NULL, /* ??? */
-    "HELP"
+        NULL, /* ??? */
+        "HELP"
     },
     { /* 19 (LDID_WINADMIN) = Admin dir */
-    "WinAdminDir",
-    ""
+        "WinAdminDir",
+        ""
     },
     { /* 20 (LDID_FONTS) = Fonts dir */
-    NULL, /* ??? */
-    "FONTS"
+        NULL, /* ??? */
+        "FONTS"
     },
     { /* 21 (LDID_VIEWERS) = Viewers */
-    NULL, /* ??? */
-    "SYSTEM\\VIEWERS"
+        NULL, /* ??? */
+        "SYSTEM\\VIEWERS"
     },
     { /* 22 (LDID_VMM32) = VMM32 dir */
-    NULL, /* ??? */
-    "SYSTEM\\VMM32"
+        NULL, /* ??? */
+        "SYSTEM\\VMM32"
     },
     { /* 23 (LDID_COLOR) = ICM dir */
-    "ICMPath",
-    "SYSTEM\\COLOR"
+        "ICMPath",
+        "SYSTEM\\COLOR"
     },
     { /* 24 (LDID_APPS) = root of boot drive ? */
-    "AppsDir",
-    "C:\\"
+        "AppsDir",
+        "C:\\"
     },
     { /* 25 (LDID_SHARED) = shared dir */
-    "SharedDir",
-    ""
+        "SharedDir",
+        ""
     },
     { /* 26 (LDID_WINBOOT) = Windows boot dir */
-    "WinBootDir",
-    ""
+        "WinBootDir",
+        ""
     },
     { /* 27 (LDID_MACHINE) = machine specific files */
-    "MachineDir",
-    NULL
+        "MachineDir",
+        NULL
     },
     { /* 28 (LDID_HOST_WINBOOT) = Host Windows boot dir */
-    "HostWinBootDir",
-    NULL
+        "HostWinBootDir",
+        NULL
     },
     { /* 29 -- not defined */
-    NULL,
-    NULL
+        NULL,
+        NULL
     },
     { /* 30 (LDID_BOOT) = Root of boot drive */
-    "BootDir",
-    NULL
+        "BootDir",
+        NULL
     },
     { /* 31 (LDID_BOOT_HOST) = Root of boot drive host */
-    "BootHost",
-    NULL
+        "BootHost",
+        NULL
     },
     { /* 32 (LDID_OLD_WINBOOT) = subdir of root */
-    "OldWinBootDir",
-    NULL
+        "OldWinBootDir",
+        NULL
     },
     { /* 33 (LDID_OLD_WIN) = old win dir */
-    "OldWinDir",
-    NULL
+        "OldWinDir",
+        NULL
     }
     /* the rest (34-38) isn't too interesting, so I'll forget about it */
 };
 
-/*
+/* 
  * LDD  == Logical Device Descriptor
  * LDID == Logical Device ID
@@ -528 +527 @@
     for (n=0; n < sizeof(LDID_Data)/sizeof(LDID_DATA); n++)
     {
-    buffer[0] = '\0';
-
-    len = MAX_PATH;
-    if ( (hKey) && (LDID_Data[n].RegValName)
-    &&   (RegQueryValueExA(hKey, LDID_Data[n].RegValName,
-        NULL, &type, buffer, &len) == ERROR_SUCCESS)
-    &&   (type == REG_SZ) )
-    {
-        TRACE("found value '%s' for LDID %d\n", buffer, n);
-    }
-    else
+        buffer[0] = '\0';
+
+        len = MAX_PATH;
+        if ( (hKey) && (LDID_Data[n].RegValName)
+        &&   (RegQueryValueExA(hKey, LDID_Data[n].RegValName,
+                NULL, &type, buffer, &len) == ERROR_SUCCESS)
+        &&   (type == REG_SZ) )
+        {
+            TRACE("found value '%s' for LDID %d\n", buffer, n);
+        }
+        else
         switch(n)
-    {
-        case LDID_SRCPATH:
-        FIXME("LDID_SRCPATH: what exactly do we have to do here ?\n");
-        strcpy(buffer, "X:\\FIXME");
-        break;
-        case LDID_SYS:
-            GetSystemDirectoryA(buffer, MAX_PATH);
-        break;
-        case LDID_APPS:
-        case LDID_MACHINE:
-        case LDID_HOST_WINBOOT:
-        case LDID_BOOT:
-        case LDID_BOOT_HOST:
-        strcpy(buffer, "C:\\");
-        break;
-        default:
-        if (LDID_Data[n].StdString)
-        {
-            DWORD len = GetWindowsDirectoryA(buffer, MAX_PATH);
-            LPSTR p;
-            p = buffer + len;
-            *p++ = '\\';
-            strcpy(p, LDID_Data[n].StdString);
+        {
+            case LDID_SRCPATH:
+                FIXME("LDID_SRCPATH: what exactly do we have to do here ?\n");
+                strcpy(buffer, "X:\\FIXME");
+                break;
+            case LDID_SYS:
+                GetSystemDirectoryA(buffer, MAX_PATH);
+                break;
+            case LDID_APPS:
+            case LDID_MACHINE:
+            case LDID_HOST_WINBOOT:
+            case LDID_BOOT:
+            case LDID_BOOT_HOST:
+                strcpy(buffer, "C:\\");
+                break;
+            default:
+                if (LDID_Data[n].StdString)
+                {
+                    DWORD len = GetWindowsDirectoryA(buffer, MAX_PATH);
+                    LPSTR p;
+                    p = buffer + len;
+                    *p++ = '\\';
+                    strcpy(p, LDID_Data[n].StdString);
+                }
+                break;
         }
-        break;
-        }
-    if (buffer[0])
-    {
-        INIT_LDD(ldd, n);
-        ldd.pszPath = buffer;
-        TRACE("LDID %d -> '%s'\n", ldd.ldid, ldd.pszPath);
-        CtlSetLdd16(&ldd);
-    }
+        if (buffer[0])
+        {
+            INIT_LDD(ldd, n);
+            ldd.pszPath = buffer;
+            TRACE("LDID %d -> '%s'\n", ldd.ldid, ldd.pszPath);
+            CtlSetLdd16(&ldd);
+        }
     }
     if (hKey) RegCloseKey(hKey);
 }
-
-/***********************************************************************
- * CtlDelLdd        (SETUPX.37)
+        
+/***********************************************************************
+ * CtlDelLdd            (SETUPX.37)
  *
  * RETURN
@@ -590 +589 @@
 
     if (!std_LDDs_done)
-    SETUPX_CreateStandardLDDs();
+        SETUPX_CreateStandardLDDs();
 
     if (ldid < LDID_ASSIGN_START)
-    return ERR_VCP_LDDINVALID;
+        return ERR_VCP_LDDINVALID;
 
     pCurr = pFirstLDD;
@@ -599 +598 @@
     while ((pCurr != NULL) && (ldid > pCurr->pldd->ldid))
     {
-     pPrev = pCurr;
-     pCurr = pCurr->next;
+         pPrev = pCurr;
+         pCurr = pCurr->next;
     }
     if ( (pCurr == NULL) /* hit end of list */
       || (ldid != pCurr->pldd->ldid) )
-    return ERR_VCP_LDDFIND; /* correct ? */
+        return ERR_VCP_LDDFIND; /* correct ? */
 
     /* ok, found our victim: eliminate it */
 
     if (pPrev)
-    pPrev->next = pCurr->next;
+        pPrev->next = pCurr->next;
 
     if (pCurr == pFirstLDD)
-    pFirstLDD = NULL;
+        pFirstLDD = NULL;
     HeapFree(GetProcessHeap(), 0, pCurr);
-
+    
     return OK;
 }
 
 /***********************************************************************
- *      CtlDelLdd (SETUPX.37)
+ *              CtlDelLdd (SETUPX.37)
  */
 RETERR16 WINAPI CtlDelLdd16(LOGDISKID16 ldid)
@@ -628 +627 @@
 
 /***********************************************************************
- * CtlFindLdd       (SETUPX.35)
+ * CtlFindLdd           (SETUPX.35)
  *
  * doesn't check pldd ptr validity: crash (W98SE)
@@ -635 +634 @@
  *   ERR_VCP_LDDINVALID if pldd->cbSize != structsize
  *   1 in all other cases ??
- *
+ * 
  */
 RETERR16 WINAPI CtlFindLdd16(LPLOGDISKDESC pldd)
@@ -642 +641 @@
 
     TRACE("(%p)\n", pldd);
-
+   
     if (!std_LDDs_done)
-    SETUPX_CreateStandardLDDs();
+        SETUPX_CreateStandardLDDs();
 
     if (pldd->cbSize != sizeof(LOGDISKDESC_S))
@@ -653 +652 @@
     while ((pCurr != NULL) && (pldd->ldid > pCurr->pldd->ldid))
     {
-    pPrev = pCurr;
-    pCurr = pCurr->next;
+        pPrev = pCurr;
+        pCurr = pCurr->next;
     }
     if ( (pCurr == NULL) /* hit end of list */
       || (pldd->ldid != pCurr->pldd->ldid) )
-    return ERR_VCP_LDDFIND; /* correct ? */
+        return ERR_VCP_LDDFIND; /* correct ? */
 
     memcpy(pldd, pCurr->pldd, pldd->cbSize);
     /* hmm, we probably ought to strcpy() the string ptrs here */
-
+    
     return 1; /* what is this ?? */
 }
 
 /***********************************************************************
- * CtlSetLdd            (SETUPX.33)
+ * CtlSetLdd                    (SETUPX.33)
  *
  * Set an LDD entry.
@@ -685 +684 @@
 
     if (!std_LDDs_done)
-    SETUPX_CreateStandardLDDs();
+        SETUPX_CreateStandardLDDs();
 
     if (pldd->cbSize != sizeof(LOGDISKDESC_S))
-    return ERR_VCP_LDDINVALID;
+        return ERR_VCP_LDDINVALID;
 
     heap = GetProcessHeap();
@@ -695 +694 @@
     while ((pCurr != NULL) && (pldd->ldid > pCurr->pldd->ldid))
     {
-     pPrev = pCurr;
-     pCurr = pCurr->next;
+         pPrev = pCurr;
+         pCurr = pCurr->next;
     }
     if (pCurr == NULL) /* hit end of list */
     {
-    is_new = TRUE;
+        is_new = TRUE;
         pCurr = HeapAlloc(heap, 0, sizeof(LDD_LIST));
         pCurr->pldd = HeapAlloc(heap, 0, sizeof(LOGDISKDESC_S));
@@ -709 +708 @@
     {
         pCurrLDD = pCurr->pldd;
-    if (pCurrLDD->pszPath)      HeapFree(heap, 0, pCurrLDD->pszPath);
-    if (pCurrLDD->pszVolLabel)  HeapFree(heap, 0, pCurrLDD->pszVolLabel);
-    if (pCurrLDD->pszDiskName)  HeapFree(heap, 0, pCurrLDD->pszDiskName);
+        if (pCurrLDD->pszPath)          HeapFree(heap, 0, pCurrLDD->pszPath);
+        if (pCurrLDD->pszVolLabel)      HeapFree(heap, 0, pCurrLDD->pszVolLabel);
+        if (pCurrLDD->pszDiskName)      HeapFree(heap, 0, pCurrLDD->pszDiskName);
     }
 
@@ -717 +716 @@
 
     if (pldd->pszPath)
-        pCurrLDD->pszPath   = HEAP_strdupA(heap, 0, pldd->pszPath);
+        pCurrLDD->pszPath       = HEAP_strdupA(heap, 0, pldd->pszPath);
     if (pldd->pszVolLabel)
-    pCurrLDD->pszVolLabel   = HEAP_strdupA(heap, 0, pldd->pszVolLabel);
+        pCurrLDD->pszVolLabel   = HEAP_strdupA(heap, 0, pldd->pszVolLabel);
     if (pldd->pszDiskName)
-    pCurrLDD->pszDiskName   = HEAP_strdupA(heap, 0, pldd->pszDiskName);
+        pCurrLDD->pszDiskName   = HEAP_strdupA(heap, 0, pldd->pszDiskName);
 
     if (is_new) /* link into list */
     {
         if (pPrev)
-    {
-        pCurr->next = pPrev->next;
+        {
+            pCurr->next = pPrev->next;
             pPrev->next = pCurr;
-    }
-    if (!pFirstLDD)
-        pFirstLDD = pCurr;
-    }
-
+        }
+        if (!pFirstLDD)
+            pFirstLDD = pCurr;
+    }
+    
     return OK;
 }
@@ -739 +738 @@
 
 /***********************************************************************
- * CtlAddLdd        (SETUPX.36)
+ * CtlAddLdd            (SETUPX.36)
  *
  * doesn't check pldd ptr validity: crash (W98SE)
@@ -752 +751 @@
 
 /***********************************************************************
- * CtlGetLdd        (SETUPX.34)
+ * CtlGetLdd            (SETUPX.34)
  *
  * doesn't check pldd ptr validity: crash (W98SE)
@@ -759 +758 @@
  * RETURN
  *   ERR_VCP_LDDINVALID if pldd->cbSize != structsize
- *
+ * 
  */
 static RETERR16 SETUPX_GetLdd(LPLOGDISKDESC pldd)
@@ -766 +765 @@
 
     if (!std_LDDs_done)
-    SETUPX_CreateStandardLDDs();
+        SETUPX_CreateStandardLDDs();
 
     if (pldd->cbSize != sizeof(LOGDISKDESC_S))
@@ -775 +774 @@
     while ((pCurr != NULL) && (pldd->ldid > pCurr->pldd->ldid))
     {
-     pPrev = pCurr;
-     pCurr = pCurr->next;
+         pPrev = pCurr;
+         pCurr = pCurr->next;
     }
     if (pCurr == NULL) /* hit end of list */
-    return ERR_VCP_LDDFIND; /* correct ? */
+        return ERR_VCP_LDDFIND; /* correct ? */
 
     memcpy(pldd, pCurr->pldd, pldd->cbSize);
@@ -796 +795 @@
 
 /***********************************************************************
- *      CtlGetLddPath       (SETUPX.38)
+ *              CtlGetLddPath           (SETUPX.38)
  *
  * Gets the path of an LDD.
@@ -810 +809 @@
     if (szPath)
     {
-    LOGDISKDESC_S ldd;
-    INIT_LDD(ldd, ldid);
-    if (CtlFindLdd16(&ldd) == ERR_VCP_LDDFIND)
-        return ERR_VCP_LDDUNINIT;
-    SETUPX_GetLdd(&ldd);
+        LOGDISKDESC_S ldd;
+        INIT_LDD(ldd, ldid);
+        if (CtlFindLdd16(&ldd) == ERR_VCP_LDDFIND)
+            return ERR_VCP_LDDUNINIT;
+        SETUPX_GetLdd(&ldd);
         strcpy(szPath, ldd.pszPath);
-    TRACE("ret '%s' for LDID %d\n", szPath, ldid);
+        TRACE("ret '%s' for LDID %d\n", szPath, ldid);
     }
     return OK;
@@ -822 +821 @@
 
 /***********************************************************************
- *      CtlSetLddPath       (SETUPX.508)
+ *              CtlSetLddPath           (SETUPX.508)
  *
  * Sets the path of an LDD.
@@ -831 +830 @@
     LOGDISKDESC_S ldd;
     TRACE("(%d, '%s');\n", ldid, szPath);
-
+    
     INIT_LDD(ldd, ldid);
     ldd.pszPath = szPath;
@@ -848 +847 @@
  * -- registry lookup -->
  * C:\Program Files (or C:\ if not found in registry)
- *
+ * 
  * FIXME:
  * - maybe we ought to add a caching array for speed ? - I don't care :)
@@ -854 +853 @@
  *   LDIDs for both install and removal sections.
  * - probably the whole function can be removed as installers add that on their
- *   own
+ *   own 
  */
 static BOOL SETUPX_AddCustomLDID(int ldid, INT16 hInf)
@@ -870 +869 @@
     if (!(sectionbuf = SETUPX_GetSections(filename)))
     {
-    ERR("couldn't get sections !\n");
-    return FALSE;
+        ERR("couldn't get sections !\n");
+        return FALSE;
     }
     for (pSec=sectionbuf; *pSec; pSec += strlen(pSec)+1)
     {
-    if (!(entrybuf = SETUPX_GetSectionEntries(filename, pSec)))
-    {
-        ERR("couldn't get section entries !\n");
-        goto end;
-    }
-    for (pEnt=entrybuf; *pEnt; pEnt += strlen(pEnt)+1)
-    {
-        if (strstr(pEnt, ldidstr))
-        {
-        pEqual = strchr(pEnt, '=');
-        if (!pEqual) /* crippled entry ?? */
-            continue;
-
-        /* make sure we found the LDID on left side of the equation */
-        if (pEnt+strlen(ldidstr) <= pEqual)
-        { /* found */
-
-            /* but we don't want entries in the strings section */
-            if (!strcasecmp(pSec, "Strings"))
-            goto next_section;
-            p = pEqual+1;
-            goto found;
-        }
-        }
-    }
+        if (!(entrybuf = SETUPX_GetSectionEntries(filename, pSec)))
+        {
+            ERR("couldn't get section entries !\n");
+            goto end;
+        }
+        for (pEnt=entrybuf; *pEnt; pEnt += strlen(pEnt)+1)
+        {
+            if (strstr(pEnt, ldidstr))
+            {
+                pEqual = strchr(pEnt, '=');
+                if (!pEqual) /* crippled entry ?? */
+                    continue;
+
+                /* make sure we found the LDID on left side of the equation */
+                if (pEnt+strlen(ldidstr) <= pEqual)
+                { /* found */
+
+                    /* but we don't want entries in the strings section */
+                    if (!strcasecmp(pSec, "Strings"))
+                        goto next_section;
+                    p = pEqual+1;
+                    goto found;
+                }
+            }
+        }
 next_section:
     }
@@ -908 +907 @@
     if (*(DWORD *)pSub > 2)
     {
-    ERR("malformed entry '%s' ?\n", p);
-    goto end;
+        ERR("malformed entry '%s' ?\n", p);
+        goto end;
     }
     TRACE("found section '%s'\n", *(pSub+1));
@@ -917 +916 @@
     if (!(regsectionbuf = SETUPX_GetSectionEntries(filename, *(pSub+1))))
     {
-    ERR("couldn't get registry section entries !\n");
-    goto end;
+        ERR("couldn't get registry section entries !\n");
+        goto end;
     }
     /* sectionbuf is > 1024 bytes anyway, so use it */
@@ -929 +928 @@
 end:
     SETUPX_FreeSubStrings(pSub);
-    if (sectionbuf) HeapFree(GetProcessHeap(), 0, sectionbuf);
-    if (entrybuf)   HeapFree(GetProcessHeap(), 0, entrybuf);
-    if (regsectionbuf)  HeapFree(GetProcessHeap(), 0, regsectionbuf);
+    if (sectionbuf)     HeapFree(GetProcessHeap(), 0, sectionbuf);
+    if (entrybuf)       HeapFree(GetProcessHeap(), 0, entrybuf);
+    if (regsectionbuf)  HeapFree(GetProcessHeap(), 0, regsectionbuf);
     return ret;
 }
@@ -948 +947 @@
     if (CtlFindLdd16(&ldd) == ERR_VCP_LDDFIND)
     {
-    /* hmm, it seems the installers already do the work for us
-     * (by calling CtlSetLddPath) that SETUPX_AddCustomLDID
-     * is supposed to do. Grmbl ;-)
-     * Well, I'll leave it here anyway, but print error... */
-    ERR("hmm, LDID %d not registered yet !?\n", ldid);
-    handled = SETUPX_AddCustomLDID(ldid, hInf);
+        /* hmm, it seems the installers already do the work for us
+         * (by calling CtlSetLddPath) that SETUPX_AddCustomLDID
+         * is supposed to do. Grmbl ;-)
+         * Well, I'll leave it here anyway, but print error... */
+        ERR("hmm, LDID %d not registered yet !?\n", ldid);
+        handled = SETUPX_AddCustomLDID(ldid, hInf);
     }
     else
-    handled = TRUE;
-
+        handled = TRUE;
+    
     SETUPX_GetLdd(&ldd);
-
+    
     if (!handled)
     {
         FIXME("What is LDID %d ??\n", ldid);
-    *p = "LDID_FIXME";
+        *p = "LDID_FIXME";
     }
     else
-    *p = ldd.pszPath;
+        *p = ldd.pszPath;
 
     return handled;
@@ -972 +971 @@
 
 /***********************************************************************
- *      GenFormStrWithoutPlaceHolders
+ *              GenFormStrWithoutPlaceHolders
  *
  * ought to be pretty much implemented, I guess...
@@ -981 +980 @@
     LPSTR pDst = szDst, p, pPHBegin;
     int count;
-
+    
     TRACE("(%p, '%s', %04x);\n", szDst, szSrc, hInf);
     while (pSrc < pSrcEnd)
     {
-    p = strchr(pSrc, '%');
-    if (p)
-    {
-        count = (int)p - (int)pSrc;
-        strncpy(pDst, pSrc, count);
-        pSrc += count;
-        pDst += count;
-        pPHBegin = p+1;
-        p = strchr(pPHBegin, '%');
-        if (p)
-        {
-        char placeholder[80]; /* that really ought to be enough ;) */
-        int ldid;
-        BOOL done = TRUE;
-        count = (int)p - (int)pPHBegin;
-        strncpy(placeholder, pPHBegin, count);
-        placeholder[count] = '\0';
-        ldid = atoi(placeholder);
-        if (ldid)
-        {
-            LPSTR p;
-            done = SETUPX_IP_TranslateLDID(ldid, &p, hInf);
-            strcpy(pDst, p);
-            if (done)
-            pDst += strlen(pDst);
-        }
-        else
-        { /* hmm, string placeholder. Need to look up
-             in the [strings] section of the hInf */
-            DWORD ret;
-            char buf[256]; /* long enough ? */
-
-            ret = GetPrivateProfileStringA("strings", placeholder, "",
-                        buf, 256, IP_GetFileName(hInf));
-            if (ret)
-            {
-            strcpy(pDst, buf);
-            pDst += strlen(buf);
-            }
-            else
-            {
-                ERR("placeholder string '%s' not found !\n", placeholder);
-            done = FALSE;
-            }
-        }
-        if (!done)
-        { /* copy raw placeholder string over */
-            count = (int)p - (int)pPHBegin + 2;
-            strncpy(pDst, pPHBegin-1, count);
-            pDst += count;
-
-        }
-        pSrc = p+1;
-        continue;
-        }
-    }
-
-    /* copy the remaining source string over */
-    strncpy(pDst, pSrc, (int)pSrcEnd - (int)pSrc + 1);
-    break;
+        p = strchr(pSrc, '%');
+        if (p)
+        {
+            count = (int)p - (int)pSrc;
+            strncpy(pDst, pSrc, count);
+            pSrc += count;
+            pDst += count;
+            pPHBegin = p+1;
+            p = strchr(pPHBegin, '%');
+            if (p)
+            {
+                char placeholder[80]; /* that really ought to be enough ;) */
+                int ldid;
+                BOOL done = TRUE;
+                count = (int)p - (int)pPHBegin;
+                strncpy(placeholder, pPHBegin, count);
+                placeholder[count] = '\0';
+                ldid = atoi(placeholder);
+                if (ldid)
+                {
+                    LPSTR p;
+                    done = SETUPX_IP_TranslateLDID(ldid, &p, hInf);
+                    strcpy(pDst, p);
+                    if (done)
+                        pDst += strlen(pDst);
+                }
+                else
+                { /* hmm, string placeholder. Need to look up
+                     in the [strings] section of the hInf */
+                    DWORD ret;
+                    char buf[256]; /* long enough ? */
+                    
+                    ret = GetPrivateProfileStringA("strings", placeholder, "",
+                                        buf, 256, IP_GetFileName(hInf));
+                    if (ret)
+                    {
+                        strcpy(pDst, buf);
+                        pDst += strlen(buf);
+                    }
+                    else
+                    {
+                        ERR("placeholder string '%s' not found !\n", placeholder);
+                        done = FALSE;
+                    }
+                }
+                if (!done)
+                { /* copy raw placeholder string over */
+                    count = (int)p - (int)pPHBegin + 2;
+                    strncpy(pDst, pPHBegin-1, count);
+                    pDst += count;
+                    
+                }
+                pSrc = p+1;
+                continue;
+            }
+        }
+
+        /* copy the remaining source string over */
+        strncpy(pDst, pSrc, (int)pSrcEnd - (int)pSrc + 1);
+        break;
     }
     TRACE("ret '%s'\n", szDst);
@@ -1050 +1049 @@
 
 /***********************************************************************
- *      VcpOpen
+ *              VcpOpen
  *
  * No idea what to do here.
@@ -1061 +1060 @@
 
 /***********************************************************************
- *      VcpClose
+ *              VcpClose
  *
  * Is fl related to VCPDISKINFO.fl ?
@@ -1092 +1091 @@
     for (n=0; n < *(DWORD *)pSub; n++)
     {
-    pCopyEntry = *(pSub+1+n);
-    if (*pCopyEntry == '@')
-    {
-        ERR("single file not handled yet !\n");
-        continue;
-    }
-
-    /* get source directory for that entry */
-    INIT_LDD(ldd, LDID_SRCPATH);
-    SETUPX_GetLdd(&ldd);
-    pSrcDir = ldd.pszPath;
-
+        pCopyEntry = *(pSub+1+n);
+        if (*pCopyEntry == '@')
+        {
+            ERR("single file not handled yet !\n");
+            continue;
+        }
+
+        /* get source directory for that entry */
+        INIT_LDD(ldd, LDID_SRCPATH);
+        SETUPX_GetLdd(&ldd);
+        pSrcDir = ldd.pszPath;
+        
         /* get destination directory for that entry */
-    if (!(GetPrivateProfileStringA("DestinationDirs", pCopyEntry, "",
-                    pDestStr, sizeof(pDestStr), filename)))
-        continue;
-
-    /* translate destination dir if given as LDID */
-    ldid = atoi(pDestStr);
-    if (ldid)
-    {
-        if (!(SETUPX_IP_TranslateLDID(ldid, &pDstDir, hInf)))
-        continue;
-    }
-    else
-        pDstDir = pDestStr;
-
-    /* now that we have the destination dir, iterate over files to copy */
-    pFileEntries = SETUPX_GetSectionEntries(filename, pCopyEntry);
+        if (!(GetPrivateProfileStringA("DestinationDirs", pCopyEntry, "",
+                                        pDestStr, sizeof(pDestStr), filename)))
+            continue;
+
+        /* translate destination dir if given as LDID */
+        ldid = atoi(pDestStr);
+        if (ldid)
+        {
+            if (!(SETUPX_IP_TranslateLDID(ldid, &pDstDir, hInf)))
+                continue;
+        }
+        else
+            pDstDir = pDestStr;
+        
+        /* now that we have the destination dir, iterate over files to copy */
+        pFileEntries = SETUPX_GetSectionEntries(filename, pCopyEntry);
         for (p=pFileEntries; *p; p +=strlen(p)+1)
-    {
-        pSubFile = SETUPX_GetSubStrings(p, ',');
-        pSrcFile = *(pSubFile+1);
-        pDstFile = (*(DWORD *)pSubFile > 1) ? *(pSubFile+2) : pSrcFile;
-        TRACE("copying file '%s\\%s' to '%s\\%s'\n", pSrcDir, pSrcFile, pDstDir, pDstFile);
-        if (*(DWORD *)pSubFile > 2)
-        {
-        WORD flag;
-        if ((flag = atoi(*(pSubFile+3)))) /* ah, flag */
-        {
-            if (flag & 0x2c)
-            FIXME("VNLP_xxx flag %d not handled yet.\n", flag);
-        }
-        else
-            FIXME("temp file name '%s' given. Need to register in wininit.ini !\n", *(pSubFile+3)); /* strong guess that this is VcpQueueCopy() */
-        }
-        SETUPX_FreeSubStrings(pSubFile);
-        /* we don't copy ANYTHING yet ! (I'm too lazy and want to verify
-         * this first before destroying whole partitions ;-) */
-    }
-    }
-
+        {
+            pSubFile = SETUPX_GetSubStrings(p, ',');
+            pSrcFile = *(pSubFile+1);
+            pDstFile = (*(DWORD *)pSubFile > 1) ? *(pSubFile+2) : pSrcFile;
+            TRACE("copying file '%s\\%s' to '%s\\%s'\n", pSrcDir, pSrcFile, pDstDir, pDstFile);
+            if (*(DWORD *)pSubFile > 2)
+            {
+                WORD flag;
+                if ((flag = atoi(*(pSubFile+3)))) /* ah, flag */
+                {
+                    if (flag & 0x2c)
+                    FIXME("VNLP_xxx flag %d not handled yet.\n", flag);
+                }
+                else
+                    FIXME("temp file name '%s' given. Need to register in wininit.ini !\n", *(pSubFile+3)); /* strong guess that this is VcpQueueCopy() */
+            }
+            SETUPX_FreeSubStrings(pSubFile);
+            /* we don't copy ANYTHING yet ! (I'm too lazy and want to verify
+             * this first before destroying whole partitions ;-) */
+        }
+    }
+            
     return res;
 }
 
 /***********************************************************************
- *      GenInstall
+ *              GenInstall
  *
  * general install function for .INF file sections
  *
  * This is not perfect - patch whenever you can !
- *
+ * 
  * wFlags == GENINSTALL_DO_xxx
  * e.g. NetMeeting:
@@ -1170 +1169 @@
     if (!pEntries)
     {
-    ERR("couldn't find entries for section '%s' !\n", szInstallSection);
-    return ERR_IP_SECT_NOT_FOUND;
+        ERR("couldn't find entries for section '%s' !\n", szInstallSection);
+        return ERR_IP_SECT_NOT_FOUND;
     }
     for (p=pEntries; *p; p +=strlen(p)+1)
     {
-    pEnd = strchr(p, '=');
-    if (!pEnd) continue;
-    pSub = SETUPX_GetSubStrings(pEnd+1, ','); /* split entries after the '=' */
-    SETUPX_IsolateSubString(&p, &pEnd);
-    len = (int)pEnd - (int)p;
-
-    if (wFlags & GENINSTALL_DO_FILES)
-    {
-        if (!strncasecmp(p, "CopyFiles", len))
-        {
-            SETUPX_CopyFiles(pSub, hInfFile);
-        continue;
-        }
+        pEnd = strchr(p, '=');
+        if (!pEnd) continue;
+        pSub = SETUPX_GetSubStrings(pEnd+1, ','); /* split entries after the '=' */
+        SETUPX_IsolateSubString(&p, &pEnd);
+        len = (int)pEnd - (int)p;
+
+        if (wFlags & GENINSTALL_DO_FILES)
+        {
+            if (!strncasecmp(p, "CopyFiles", len))
+            {
+                SETUPX_CopyFiles(pSub, hInfFile);
+                continue;
+            }
 #if IMPLEMENT_THAT
-        else
-        if (!strncasecmp(p, "DelFiles", len))
-        {
-            SETUPX_DelFiles(filename, szInstallSection, pSub);
-        continue;
-        }
+            else
+            if (!strncasecmp(p, "DelFiles", len))
+            {
+                SETUPX_DelFiles(filename, szInstallSection, pSub);
+                continue;
+            }
 #endif
-    }
-    if (wFlags & GENINSTALL_DO_INI)
-    {
+        }
+        if (wFlags & GENINSTALL_DO_INI)
+        {
 #if IMPLEMENT_THAT
-        if (!strncasecmp(p, "UpdateInis", len))
-        {
-            SETUPX_UpdateInis(filename, szInstallSection, pSub);
-        continue;
-        }
+            if (!strncasecmp(p, "UpdateInis", len))
+            {
+                SETUPX_UpdateInis(filename, szInstallSection, pSub);
+                continue;
+            }
 #endif
-    }
-    if (wFlags & GENINSTALL_DO_REG)
-    {
+        }
+        if (wFlags & GENINSTALL_DO_REG)
+        {
 #if IMPLEMENT_THAT
-        /* probably use SUReg*() functions here */
-        if (!strncasecmp(p, "AddReg", len))
-        {
-            SETUPX_AddReg(filename, szInstallSection, pSub);
-        continue;
-        }
-        else
-        if (!strncasecmp(p, "DelReg", len))
-        {
-            SETUPX_DelReg(filename, szInstallSection, pSub);
-        continue;
-        }
+            /* probably use SUReg*() functions here */
+            if (!strncasecmp(p, "AddReg", len))
+            {
+                SETUPX_AddReg(filename, szInstallSection, pSub);
+                continue;
+            }
+            else
+            if (!strncasecmp(p, "DelReg", len))
+            {
+                SETUPX_DelReg(filename, szInstallSection, pSub);
+                continue;
+            }
 #endif
-    }
-
-    SETUPX_FreeSubStrings(pSub);
+        }
+        
+        SETUPX_FreeSubStrings(pSub);
     }
     HeapFree(GetProcessHeap(), 0, pEntries);

trunk/src/setupapi/stubs.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 8 -*- */
-/* $Id: stubs.c,v 1.2 2001-09-05 13:38:24 bird Exp $ */
 /*
  * SetupAPI stubs
@@ -17 +16 @@
 
 /***********************************************************************
- *      SetupCloseFileQueue
+ *              SetupCloseFileQueue
  */
 VOID WINAPI SetupCloseFileQueue(HSPFILEQ QueueHandle)
 {
-    FIXME("not implemented (setupapi.dll) \n");
-}
-
-/***********************************************************************
- *      SetupCommitFileQueueA
+        FIXME("not implemented (setupapi.dll) \n");
+}
+
+/***********************************************************************
+ *              SetupCommitFileQueueA
  */
 BOOL WINAPI SetupCommitFileQueueA(HWND Owner, HSPFILEQ QueueHandle,
-                  PSP_FILE_CALLBACK_A MsgHandler,
-                  PVOID Context)
-{
-    FIXME("not implemented (setupapi.dll) \n");
-    return FALSE;
-}
-
-/***********************************************************************
- *      SetupIterateCabinetA
+                                  PSP_FILE_CALLBACK_A MsgHandler,
+                                  PVOID Context)
+{
+        FIXME("not implemented (setupapi.dll) \n");
+        return FALSE;
+}
+
+/***********************************************************************
+ *              SetupIterateCabinetA
  */
 BOOL WINAPI SetupIterateCabinetA(PCSTR CabinetFile, DWORD Reserved,
                                  PSP_FILE_CALLBACK_A MsgHandler, PVOID Context)
 {
-    FIXME("not implemented (setupapi.dll) \n");
-    return 0;
-}
-
-/***********************************************************************
- *      SetupIterateCabinetW
+        FIXME("not implemented (setupapi.dll) \n");
+        return 0;
+}
+
+/***********************************************************************
+ *              SetupIterateCabinetW
  */
 BOOL WINAPI SetupIterateCabinetW(PWSTR CabinetFile, DWORD Reserved,
-                                 PSP_FILE_CALLBACK_W MsgHandler, PVOID Context)
-{
-    FIXME("not implemented (setupapi.dll) \n");
-    return 0;
-}
-
-
-/***********************************************************************
- *      SetupGetLineTextA
+                                 PSP_FILE_CALLBACK_W MsgHandler, PVOID Context) 
+{
+        FIXME("not implemented (setupapi.dll) \n");
+        return 0;
+}
+
+
+/***********************************************************************
+ *              SetupGetLineTextA
  */
 BOOL WINAPI SetupGetLineTextA (PINFCONTEXT Context, HINF InfHandle,
@@ -63 +62 @@
                         DWORD ReturnBufferSize, PDWORD RequiredSize)
 {
-    FIXME("not implemented (setupapi.dll) \n");
-    return 0;
-}
-
-/***********************************************************************
- *      SetupGetStringFieldA
- */
-BOOL WINAPI SetupGetStringFieldA(PINFCONTEXT Context, DWORD FieldIndex,
+        FIXME("not implemented (setupapi.dll) \n");
+        return 0;
+}
+
+/***********************************************************************
+ *              SetupGetStringFieldA
+ */
+BOOL WINAPI SetupGetStringFieldA(PINFCONTEXT Context, DWORD FieldIndex, 
                                  LPSTR ReturnBuffer, DWORD ReturnBufferSize,
                                  PDWORD RequiredSize)
 {
-    FIXME("not implemented (setupapi.dll) \n");
-    return 0;
-}
-
-
-/***********************************************************************
- *      SetupFindNextLine
+        FIXME("not implemented (setupapi.dll) \n");
+        return 0;
+}
+
+
+/***********************************************************************
+ *              SetupFindNextLine
  */
 BOOL WINAPI SetupFindNextLine (PINFCONTEXT ContextIn, PINFCONTEXT ContextOut)
 {
-    FIXME("not implemented (setupapi.dll) \n");
-    return 0;
-}
-
-
-/***********************************************************************
- *      SetupInitDefaultQueueCallback
+        FIXME("not implemented (setupapi.dll) \n");
+        return 0;
+}
+
+
+/***********************************************************************
+ *              SetupInitDefaultQueueCallback
  */
 PVOID WINAPI SetupInitDefaultQueueCallback(HWND OwnerWindow)
 {
-    FIXME("not implemented (setupapi.dll) \n");
-    return 0;
-}
-
-/***********************************************************************
- *      SetupInitDefaultQueueCallbackEx
+        FIXME("not implemented (setupapi.dll) \n");
+        return 0;
+}
+
+/***********************************************************************
+ *              SetupInitDefaultQueueCallbackEx
  */
 PVOID WINAPI SetupInitDefaultQueueCallbackEx(HWND OwnerWindow,
-                         HWND AlternativeProgressWindow,
-                         UINT ProgressMessage,
-                         DWORD res1,
-                         PVOID res2)
-{
-    FIXME("not implemented (setupapi.dll) \n");
-    return 0;
-}
-
-/***********************************************************************
- *      SetupCloseInfFile
+                                             HWND AlternativeProgressWindow,
+                                             UINT ProgressMessage,
+                                             DWORD res1,
+                                             PVOID res2)
+{
+        FIXME("not implemented (setupapi.dll) \n");
+        return 0;
+}
+
+/***********************************************************************
+ *              SetupCloseInfFile
  */
 VOID WINAPI SetupCloseInfFile (HINF InfHandle)
 {
-    FIXME("not implemented (setupapi.dll) \n");
-}
-
-
-/***********************************************************************
- *      SetupDefaultQueueCallbackA
+        FIXME("not implemented (setupapi.dll) \n");
+}
+
+
+/***********************************************************************
+ *              SetupDefaultQueueCallbackA
  */
 UINT WINAPI SetupDefaultQueueCallbackA (PVOID Context, UINT Notification,
                                         UINT Param1, UINT Param2)
 {
-    FIXME("not implemented (setupapi.dll) \n");
-    return 0;
-}
-
-
-/***********************************************************************
- *      SetupFindFirstLineA
+        FIXME("not implemented (setupapi.dll) \n");
+        return 0;
+}
+
+
+/***********************************************************************
+ *              SetupFindFirstLineA
  */
 BOOL WINAPI SetupFindFirstLineA (HINF InfHandle, PCSTR Section, PCSTR Key,
                                  PINFCONTEXT Context)
 {
-    FIXME("not implemented (setupapi.dll) \n");
-    return 0;
-}
-
-/***********************************************************************
- *      SetupGetLineByIndexA
+        FIXME("not implemented (setupapi.dll) \n");
+        return 0;
+}
+
+/***********************************************************************
+ *              SetupGetLineByIndexA
  */
 BOOL WINAPI SetupGetLineByIndexA (HINF InfHandle, PCSTR Section, DWORD Index,
                                  PINFCONTEXT Context)
 {
-    FIXME("not implemented (setupapi.dll) \n");
-    return FALSE;
-}
-
-
-/***********************************************************************
- *      SetupInstallFromInfSectionA
+        FIXME("not implemented (setupapi.dll) \n");
+        return FALSE;
+}
+
+
+/***********************************************************************
+ *              SetupInstallFromInfSectionA
  */
 BOOL WINAPI SetupInstallFromInfSectionA (HWND Owner, HINF InfHandle, PCSTR SectionName,
@@ -161 +160 @@
                                          PSP_DEVINFO_DATA DeviceInfoData)
 {
-    FIXME("not implemented (setupapi.dll) \n");
-    return 0;
-}
-
-/***********************************************************************
- *      SetupOpenAppendInfFileA
+        FIXME("not implemented (setupapi.dll) \n");
+        return 0;
+}
+
+/***********************************************************************
+ *              SetupOpenAppendInfFileA
  */
 BOOL WINAPI SetupOpenAppendInfFileA (PCSTR FileName, HINF InfHandle,
-                    PUINT ErrorLine)
-{
-    FIXME("not implemented (setupapi.dll) \n");
-    return FALSE;
-}
-
-/***********************************************************************
- *      SetupOpenFileQueue
+                                    PUINT ErrorLine)
+{
+        FIXME("not implemented (setupapi.dll) \n");
+        return FALSE;
+}
+
+/***********************************************************************
+ *              SetupOpenFileQueue
  */
 HSPFILEQ WINAPI SetupOpenFileQueue (VOID)
 {
-    FIXME("not implemented (setupapi.dll) \n");
-    return (HSPFILEQ) INVALID_HANDLE_VALUE;
-}
-
-/***********************************************************************
- *      SetupOpenInfFileA
+        FIXME("not implemented (setupapi.dll) \n");
+        return (HSPFILEQ) INVALID_HANDLE_VALUE;
+}
+
+/***********************************************************************
+ *              SetupOpenInfFileA
  */
 HINF WINAPI SetupOpenInfFileA (PCSTR FileName, PCSTR InfClass, DWORD InfStyle,
                                PUINT ErrorLine)
 {
-    FIXME("not implemented (setupapi.dll) \n");
-    return 0;
-}
-
-/***********************************************************************
- *      SetupQueueCopyA
+        FIXME("not implemented (setupapi.dll) \n");
+        return 0;
+}
+
+/***********************************************************************
+ *              SetupQueueCopyA
  */
 BOOL WINAPI SetupQueueCopyA (HSPFILEQ QueueHandle, PCSTR SourceRootPath, PCSTR SourcePath,
-                 PCSTR SourceFileName, PCSTR SourceDescription, PCSTR SourceTagFile,
-                 PCSTR TargetDirectory, PCSTR TargetFileName, DWORD CopyStyle)
-{
-    FIXME("not implemented (setupapi.dll) \n");
-    return FALSE;
-}
-
-/***********************************************************************
- *      SetupSetDirectoryIdA
+                             PCSTR SourceFileName, PCSTR SourceDescription, PCSTR SourceTagFile,
+                             PCSTR TargetDirectory, PCSTR TargetFileName, DWORD CopyStyle)
+{
+        FIXME("not implemented (setupapi.dll) \n");
+        return FALSE;
+}
+
+/***********************************************************************
+ *              SetupSetDirectoryIdA
  */
 BOOL WINAPI SetupSetDirectoryIdA (HINF InfHandle,
-                  DWORD Id,
-                  PCSTR Directory)
-{
-    FIXME("not implemented (setupapi.dll) \n");
-    return FALSE;
-}
-
-
-/***********************************************************************
- *      SetupTermDefaultQueueCallback
+                                  DWORD Id,
+                                  PCSTR Directory)
+{
+        FIXME("not implemented (setupapi.dll) \n");
+        return FALSE;
+}
+
+
+/***********************************************************************
+ *              SetupTermDefaultQueueCallback
  */
 VOID WINAPI SetupTermDefaultQueueCallback (PVOID Callback)
 {
-    FIXME("not implemented (setupapi.dll) \n");
-}
-
+        FIXME("not implemented (setupapi.dll) \n");
+}
+

trunk/src/shdocvw/classinfo.c

@@ -1 @@
-/* $Id: classinfo.c,v 1.2 2001-09-05 13:39:11 bird Exp $ */
 /*
  * Implementation of IProvideClassInfo interfaces for IE Web Browser control
@@ -57 +56 @@
  */
 
-static ICOM_VTABLE(IProvideClassInfo) WBPCI_Vtbl =
+static ICOM_VTABLE(IProvideClassInfo) WBPCI_Vtbl = 
 {
     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
@@ -142 +141 @@
  */
 
-static ICOM_VTABLE(IProvideClassInfo2) WBPCI2_Vtbl =
+static ICOM_VTABLE(IProvideClassInfo2) WBPCI2_Vtbl = 
 {
     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE

trunk/src/shdocvw/events.c

@@ -1 @@
-/* $Id: events.c,v 1.2 2001-09-05 13:39:11 bird Exp $ */
 /*
  * Implementation of event-related interfaces for IE Web Browser control:
@@ -87 +86 @@
  */
 
-static ICOM_VTABLE(IConnectionPointContainer) WBCPC_Vtbl =
+static ICOM_VTABLE(IConnectionPointContainer) WBCPC_Vtbl = 
 {
     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
@@ -182 +181 @@
  */
 
-static ICOM_VTABLE(IConnectionPoint) WBCP_Vtbl =
+static ICOM_VTABLE(IConnectionPoint) WBCP_Vtbl = 
 {
     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE

trunk/src/shdocvw/factory.c

@@ -1 @@
-/* $Id: factory.c,v 1.2 2001-09-05 13:39:11 bird Exp $ */
 /*
  * Implementation of class factory for IE Web Browser
@@ -96 +95 @@
 }
 
-static ICOM_VTABLE(IClassFactory) WBCF_Vtbl =
+static ICOM_VTABLE(IClassFactory) WBCF_Vtbl = 
 {
     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE

trunk/src/shdocvw/misc.c

@@ -1 @@
-/* $Id: misc.c,v 1.2 2001-09-05 13:39:12 bird Exp $ */
 /*
  * Implementation of miscellaneous interfaces for IE Web Browser control:
@@ -68 +67 @@
  */
 
-static ICOM_VTABLE(IQuickActivate) WBQA_Vtbl =
+static ICOM_VTABLE(IQuickActivate) WBQA_Vtbl = 
 {
     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE

trunk/src/shdocvw/oleobject.c

@@ -1 @@
-/* $Id: oleobject.c,v 1.2 2001-09-05 13:39:12 bird Exp $ */
 /*
  * Implementation of IOleObject interfaces for IE Web Browser
@@ -397 +396 @@
  */
 
-static ICOM_VTABLE(IOleObject) WBOOBJ_Vtbl =
+static ICOM_VTABLE(IOleObject) WBOOBJ_Vtbl = 
 {
     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
@@ -515 +514 @@
  */
 
-static ICOM_VTABLE(IOleInPlaceObject) WBOIPO_Vtbl =
+static ICOM_VTABLE(IOleInPlaceObject) WBOIPO_Vtbl = 
 {
     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
@@ -590 +589 @@
  */
 
-static ICOM_VTABLE(IOleControl) WBOC_Vtbl =
+static ICOM_VTABLE(IOleControl) WBOC_Vtbl = 
 {
     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE

trunk/src/shdocvw/persist.c

@@ -1 @@
-/* $Id: persist.c,v 1.2 2001-09-05 13:39:12 bird Exp $ */
 /*
  * Implementation of IPersist interfaces for IE Web Browser control
@@ -82 +81 @@
  */
 
-static ICOM_VTABLE(IPersistStorage) WBPS_Vtbl =
+static ICOM_VTABLE(IPersistStorage) WBPS_Vtbl = 
 {
     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
@@ -171 +170 @@
  */
 
-static ICOM_VTABLE(IPersistStreamInit) WBPSI_Vtbl =
+static ICOM_VTABLE(IPersistStreamInit) WBPSI_Vtbl = 
 {
     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE

trunk/src/shdocvw/shdocvw_main.c

@@ -1 @@
-/* $Id: shdocvw_main.c,v 1.2 2001-09-05 13:39:12 bird Exp $ */
 /*
  * SHDOCVW - Internet Explorer Web Control
@@ -67 +66 @@
 
 /***********************************************************************
- *      DllRegisterServer (SHDOCVW.124)
+ *              DllRegisterServer (SHDOCVW.124)
  */
 HRESULT WINAPI SHDOCVW_DllRegisterServer()
@@ -76 +75 @@
 
 /***********************************************************************
- *      DllUnregisterServer (SHDOCVW.127)
+ *              DllUnregisterServer (SHDOCVW.127)
  */
 HRESULT WINAPI SHDOCVW_DllUnregisterServer()

trunk/src/shdocvw/webbrowser.c

@@ -1 @@
-/* $Id: webbrowser.c,v 1.2 2001-09-05 13:39:12 bird Exp $ */
 /*
  * Implementation of IWebBrowser interface for IE Web Browser control
@@ -229 +228 @@
  */
 
-static ICOM_VTABLE(IWebBrowser) WB_Vtbl =
+static ICOM_VTABLE(IWebBrowser) WB_Vtbl = 
 {
     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE

trunk/src/shlwapi/ordinal.c

@@ -1 @@
-/* $Id: ordinal.c,v 1.6 2001-09-05 13:48:37 bird Exp $ */
 /*
  * SHLWAPI ordinal functions
@@ -66 +65 @@
 #ifndef __WIN32OS2__
 /*************************************************************************
- *      SHLWAPI_1   [SHLWAPI.1]
+ *      SHLWAPI_1       [SHLWAPI.1]
  */
 DWORD WINAPI SHLWAPI_1 (
-    LPSTR   lpURL,
-    LPDWORD lpdwFlags)
+        LPSTR   lpURL,
+        LPDWORD lpdwFlags)
 {
   if (lpURL == NULL)
     return E_INVALIDARG;
-
+  
   if (lpdwFlags == NULL)
     return E_INVALIDARG;
-
+  
   // verify flags
   if (*lpdwFlags != 0x18)   // some unknown flag
     return E_INVALIDARG;      // some unknown error condition
-
+  
   FIXME("(%p %s %p %s)\n",lpStr, debugstr_a(lpStr),x, debugstr_a(x));
   return 0;
@@ -87 +86 @@
 
 /*************************************************************************
- *      SHLWAPI_2   [SHLWAPI.2]
+ *      SHLWAPI_2       [SHLWAPI.2]
  */
 DWORD WINAPI SHLWAPI_2 (LPCWSTR x,LPVOID y)
 {
-    FIXME("(%s,%p)\n",debugstr_w(x),y);
-    return 0;
-}
-
-/*************************************************************************
- *      SHLWAPI_16  [SHLWAPI.16]
+        FIXME("(%s,%p)\n",debugstr_w(x),y);
+        return 0;
+}
+
+/*************************************************************************
+ *      SHLWAPI_16      [SHLWAPI.16]
  */
 HRESULT WINAPI SHLWAPI_16 (
-    LPVOID w,
-    LPVOID x,
-    LPVOID y,
-    LPWSTR z)
-{
-    FIXME("(%p %p %p %p)stub\n",w,x,y,z);
-    return 0xabba1252;
-}
-#endif
-
-/*************************************************************************
- *      SHLWAPI_23  [SHLWAPI.23]
+        LPVOID w,
+        LPVOID x,
+        LPVOID y,
+        LPWSTR z)
+{
+        FIXME("(%p %p %p %p)stub\n",w,x,y,z);
+        return 0xabba1252;
+}
+#endif
+
+/*************************************************************************
+ *      SHLWAPI_23      [SHLWAPI.23]
  *
  * NOTES
- *  converts a guid to a string
- *  returns strlen(str)
+ *      converts a guid to a string
+ *      returns strlen(str)
  */
 DWORD WINAPI SHLWAPI_23 (
-    REFGUID guid,   /* [in]  clsid */
-    LPSTR str,  /* [out] buffer */
-    INT cmax)   /* [in]  size of buffer */
-{
-    char xguid[40];
+        REFGUID guid,   /* [in]  clsid */
+        LPSTR str,      /* [out] buffer */
+        INT cmax)       /* [in]  size of buffer */
+{
+        char xguid[40];
 
         sprintf( xguid, "{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
@@ -127 +126 @@
                  guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
                  guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7] );
-    TRACE("(%s %p 0x%08x)stub\n", xguid, str, cmax);
-    if (strlen(xguid)>=cmax) return 0;
-    strcpy(str,xguid);
-    return strlen(xguid) + 1;
-}
-
-/*************************************************************************
- *      SHLWAPI_24  [SHLWAPI.24]
+        TRACE("(%s %p 0x%08x)stub\n", xguid, str, cmax);
+        if (strlen(xguid)>=cmax) return 0;
+        strcpy(str,xguid);
+        return strlen(xguid) + 1;
+}
+
+/*************************************************************************
+ *      SHLWAPI_24      [SHLWAPI.24]
  *
  * NOTES
- *  converts a guid to a string
- *  returns strlen(str)
+ *      converts a guid to a string
+ *      returns strlen(str)
  */
 DWORD WINAPI SHLWAPI_24 (
-    REFGUID guid,   /* [in]  clsid */
-    LPWSTR str, /* [out] buffer */
-    INT cmax)   /* [in]  size of buffer */
+        REFGUID guid,   /* [in]  clsid */
+        LPWSTR str,     /* [out] buffer */
+        INT cmax)       /* [in]  size of buffer */
 {
     char xguid[40];
@@ -155 +154 @@
 
 /*************************************************************************
- *      SHLWAPI_30  [SHLWAPI.30]
+ *      SHLWAPI_30      [SHLWAPI.30]
  *
  * Seems to be an isspaceW.
@@ -174 +173 @@
 
 /*************************************************************************
- *      SHLWAPI_32  [SHLWAPI.32]
+ *      SHLWAPI_32      [SHLWAPI.32]
  */
 BOOL WINAPI SHLWAPI_32(LPCWSTR lpcChar)
@@ -188 +187 @@
 
 /*************************************************************************
- *      SHLWAPI_40  [SHLWAPI.40]
+ *      SHLWAPI_40      [SHLWAPI.40]
  *
  * Get pointer to next Unicode character.
@@ -198 +197 @@
 
 /*************************************************************************
- *      SHLWAPI_74  [SHLWAPI.74]
+ *      SHLWAPI_74      [SHLWAPI.74]
  *
  * Get the text from a given dialog item.
@@ -213 +212 @@
 }
 /*************************************************************************
- *      SHLWAPI_151 [SHLWAPI.151]
+ *      SHLWAPI_151     [SHLWAPI.151]
  */
 #ifdef __WIN32OS2__
@@ -239 +238 @@
 
 /*************************************************************************
- *      SHLWAPI_152 [SHLWAPI.152]
+ *      SHLWAPI_152     [SHLWAPI.152]
  */
 DWORD WINAPI SHLWAPI_152(LPWSTR str1, LPWSTR str2, INT len)
@@ -255 +254 @@
 
 /*************************************************************************
- *      SHLWAPI_153 [SHLWAPI.153]
+ *      SHLWAPI_153     [SHLWAPI.153]
  */
 #ifdef __WIN32OS2__
@@ -285 +284 @@
 
 /*************************************************************************
- *      SHLWAPI_156 [SHLWAPI.156]
- *
- *  Case sensitive string compare. Does not SetLastError().
+ *      SHLWAPI_156     [SHLWAPI.156]
+ *
+ *      Case sensitive string compare. Does not SetLastError().
  */
 DWORD WINAPI SHLWAPI_156 ( LPWSTR str1, LPWSTR str2)
@@ -296 +295 @@
 
 /*************************************************************************
- *      SHLWAPI_162 [SHLWAPI.162]
+ *      SHLWAPI_162     [SHLWAPI.162]
  *
  * Ensure a multibyte character string doesn't end in a hanging lead byte.
@@ -320 +319 @@
 
 /*************************************************************************
- *      SHLWAPI_165 [SHLWAPI.165]
+ *      SHLWAPI_165     [SHLWAPI.165]
  *
  * SetWindowLongA with mask.
@@ -335 +334 @@
 
 /*************************************************************************
- *      SHLWAPI_169 [SHLWAPI.169]
+ *      SHLWAPI_169     [SHLWAPI.169]
  */
 DWORD WINAPI SHLWAPI_169 (IUnknown * lpUnknown)
 {
-    TRACE("(%p)\n",lpUnknown);
+        TRACE("(%p)\n",lpUnknown);
 #if 0
-    if(!lpUnknown || !*((LPDWORD)lpUnknown)) return 0;
-    return IUnknown_Release(lpUnknown);
-#endif
-    return 0;
-}
-
-/*************************************************************************
- *      SHLWAPI_170 [SHLWAPI.170]
+        if(!lpUnknown || !*((LPDWORD)lpUnknown)) return 0;
+        return IUnknown_Release(lpUnknown);
+#endif
+        return 0;
+}
+
+/*************************************************************************
+ *      SHLWAPI_170     [SHLWAPI.170]
  *
  * Skip URL '//' sequence.
@@ -360 +359 @@
 
 /*************************************************************************
- *      SHLWAPI_181 [SHLWAPI.181]
- *
- *  Enable or disable a menu item.
+ *      SHLWAPI_181     [SHLWAPI.181]
+ *
+ *      Enable or disable a menu item.
  */
 UINT WINAPI SHLWAPI_181(HMENU hMenu, UINT wItemID, BOOL bEnable)
@@ -370 +369 @@
 
 /*************************************************************************
- *      SHLWAPI_183 [SHLWAPI.183]
+ *      SHLWAPI_183     [SHLWAPI.183]
  *
  * Register a window class if it isn't already.
@@ -383 +382 @@
 
 /*************************************************************************
- *      SHLWAPI_193 [SHLWAPI.193]
+ *      SHLWAPI_193     [SHLWAPI.193]
  */
 DWORD WINAPI SHLWAPI_193 ()
 {
-    HDC hdc;
-    DWORD ret;
-
-    TRACE("()\n");
-
-    hdc = GetDC(0);
-    ret = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
-    ReleaseDC(0, hdc);
-    return ret;
-}
-
-/*************************************************************************
- *      SHLWAPI_215 [SHLWAPI.215]
+        HDC hdc;
+        DWORD ret;
+
+        TRACE("()\n");
+
+        hdc = GetDC(0);
+        ret = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
+        ReleaseDC(0, hdc);
+        return ret;
+}
+
+/*************************************************************************
+ *      SHLWAPI_215     [SHLWAPI.215]
  *
  * NOTES
@@ -405 +404 @@
  */
 LPWSTR WINAPI SHLWAPI_215 (
-    LPWSTR lpStrSrc,
-    LPVOID lpwStrDest,
-    int len)
-{
-    WARN("(%p %p %u)\n",lpStrSrc,lpwStrDest,len);
-    return strncpyW(lpwStrDest, lpStrSrc, len);
-}
-
-/*************************************************************************
- *      SHLWAPI_218 [SHLWAPI.218]
+        LPWSTR lpStrSrc,
+        LPVOID lpwStrDest,
+        int len)
+{
+        WARN("(%p %p %u)\n",lpStrSrc,lpwStrDest,len);
+        return strncpyW(lpwStrDest, lpStrSrc, len);
+}
+
+/*************************************************************************
+ *      SHLWAPI_218     [SHLWAPI.218]
  *
  * WideCharToMultiByte with multi language support.
@@ -508 +507 @@
 
 /*************************************************************************
- *      SHLWAPI_217 [SHLWAPI.217]
+ *      SHLWAPI_217     [SHLWAPI.217]
  *
  */
@@ -518 +517 @@
 #ifndef __WIN32OS2__
 /*************************************************************************
- *      SHLWAPI_219 [SHLWAPI.219]
+ *      SHLWAPI_219     [SHLWAPI.219]
  *
  * NOTES
@@ -524 +523 @@
  */
 HRESULT WINAPI SHLWAPI_219 (
-    LPVOID w, /* [???] NOTE: returned by LocalAlloc, 0x450 bytes, iface */
-    LPVOID x,
-    REFIID riid,
-    LPWSTR z) /* [???] NOTE: OUT: path */
-{
-    FIXME("(%p %p %s %p)stub\n",w,x,debugstr_guid(riid),z);
-    return 0xabba1252;
-}
-#endif
-
-/*************************************************************************
- *      SHLWAPI_222 [SHLWAPI.222]
+        LPVOID w, /* [???] NOTE: returned by LocalAlloc, 0x450 bytes, iface */
+        LPVOID x,
+        REFIID riid,
+        LPWSTR z) /* [???] NOTE: OUT: path */
+{
+        FIXME("(%p %p %s %p)stub\n",w,x,debugstr_guid(riid),z);
+        return 0xabba1252;
+}
+#endif
+
+/*************************************************************************
+ *      SHLWAPI_222     [SHLWAPI.222]
  *
  * NOTES
@@ -542 +541 @@
 HANDLE WINAPI SHLWAPI_222 (LPCLSID guid)
 {
-    char lpstrName[80];
+        char lpstrName[80];
 
         sprintf( lpstrName, "shell.{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
@@ -548 +547 @@
                  guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
                  guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7] );
-    FIXME("(%s) stub\n", lpstrName);
-    return CreateSemaphoreA(NULL,0, 0x7fffffff, lpstrName);
-}
-
-/*************************************************************************
- *      SHLWAPI_223 [SHLWAPI.223]
+        FIXME("(%s) stub\n", lpstrName);
+        return CreateSemaphoreA(NULL,0, 0x7fffffff, lpstrName);
+}
+
+/*************************************************************************
+ *      SHLWAPI_223     [SHLWAPI.223]
  *
  * NOTES
@@ -560 +559 @@
 DWORD WINAPI SHLWAPI_223 (HANDLE handle)
 {
-    DWORD oldCount;
-
-    FIXME("(0x%08x) stub\n",handle);
-
-    ReleaseSemaphore( handle, 1, &oldCount);    /* +1 */
-    WaitForSingleObject( handle, 0 );       /* -1 */
-    return oldCount;
-}
-
-/*************************************************************************
- *      SHLWAPI_237 [SHLWAPI.237]
+        DWORD oldCount;
+
+        FIXME("(0x%08x) stub\n",handle);
+
+        ReleaseSemaphore( handle, 1, &oldCount);        /* +1 */
+        WaitForSingleObject( handle, 0 );               /* -1 */
+        return oldCount;
+}
+
+/*************************************************************************
+ *      SHLWAPI_237     [SHLWAPI.237]
  *
  * Unicode version of SHLWAPI_183.
@@ -576 +575 @@
 DWORD WINAPI SHLWAPI_237 (WNDCLASSW * lpWndClass)
 {
-    WNDCLASSW WndClass;
-
-    TRACE("(0x%08x %s)\n",lpWndClass->hInstance, debugstr_w(lpWndClass->lpszClassName));
-
-    if (GetClassInfoW(lpWndClass->hInstance, lpWndClass->lpszClassName, &WndClass))
-        return TRUE;
-    return RegisterClassW(lpWndClass);
-}
-
-/*************************************************************************
- *      SHLWAPI_240 [SHLWAPI.240]
- *
- *  Calls ASCII or Unicode WindowProc for the given window.
+        WNDCLASSW WndClass;
+
+        TRACE("(0x%08x %s)\n",lpWndClass->hInstance, debugstr_w(lpWndClass->lpszClassName));
+
+        if (GetClassInfoW(lpWndClass->hInstance, lpWndClass->lpszClassName, &WndClass))
+                return TRUE;
+        return RegisterClassW(lpWndClass);
+}
+
+/*************************************************************************
+ *      SHLWAPI_240     [SHLWAPI.240]
+ *
+ *      Calls ASCII or Unicode WindowProc for the given window.
  */
 LRESULT CALLBACK SHLWAPI_240(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
 {
-    if (IsWindowUnicode(hWnd))
-        return DefWindowProcW(hWnd, uMessage, wParam, lParam);
-    return DefWindowProcA(hWnd, uMessage, wParam, lParam);
+        if (IsWindowUnicode(hWnd))
+                return DefWindowProcW(hWnd, uMessage, wParam, lParam);
+        return DefWindowProcA(hWnd, uMessage, wParam, lParam);
 }
 #ifndef __WIN32OS2__
 /*************************************************************************
- *      SHLWAPI_241 [SHLWAPI.241]
+ *      SHLWAPI_241     [SHLWAPI.241]
  *
  */
 DWORD WINAPI SHLWAPI_241 ()
 {
-    FIXME("()stub\n");
-    return 0xabba1243;
-}
-
-/*************************************************************************
- *      SHLWAPI_266 [SHLWAPI.266]
+        FIXME("()stub\n");
+        return 0xabba1243;
+}
+
+/*************************************************************************
+ *      SHLWAPI_266     [SHLWAPI.266]
  */
 DWORD WINAPI SHLWAPI_266 (
-    LPVOID w,
-    LPVOID x,
-    LPVOID y,
-    LPVOID z)
-{
-    FIXME("(%p %p %p %p)stub\n",w,x,y,z);
-    return 0xabba1248;
-}
-
-/*************************************************************************
- *      SHLWAPI_267 [SHLWAPI.267]
+        LPVOID w,
+        LPVOID x,
+        LPVOID y,
+        LPVOID z)
+{
+        FIXME("(%p %p %p %p)stub\n",w,x,y,z);
+        return 0xabba1248;
+}
+
+/*************************************************************************
+ *      SHLWAPI_267     [SHLWAPI.267]
  */
 HRESULT WINAPI SHLWAPI_267 (
-    LPVOID w, /* [???] NOTE: same as 1th parameter of SHLWAPI_219 */
-    LPVOID x, /* [???] NOTE: same as 2nd parameter of SHLWAPI_219 */
-    LPVOID y,
-    LPVOID z)
-{
-    FIXME("(%p %p %p %p)stub\n",w,x,y,z);
-    *((LPDWORD)z) = 0xabba1200;
-    return 0xabba1254;
-}
-
-/*************************************************************************
- *      SHLWAPI_268 [SHLWAPI.268]
+        LPVOID w, /* [???] NOTE: same as 1th parameter of SHLWAPI_219 */
+        LPVOID x, /* [???] NOTE: same as 2nd parameter of SHLWAPI_219 */
+        LPVOID y,
+        LPVOID z)
+{
+        FIXME("(%p %p %p %p)stub\n",w,x,y,z);
+        *((LPDWORD)z) = 0xabba1200;
+        return 0xabba1254;
+}
+
+/*************************************************************************
+ *      SHLWAPI_268     [SHLWAPI.268]
  */
 DWORD WINAPI SHLWAPI_268 (
-    LPVOID w,
-    LPVOID x)
-{
-    FIXME("(%p %p)\n",w,x);
-    return 0xabba1251; /* 0 = failure */
-}
-
-/*************************************************************************
- *      SHLWAPI_276 [SHLWAPI.276]
+        LPVOID w,
+        LPVOID x)
+{
+        FIXME("(%p %p)\n",w,x);
+        return 0xabba1251; /* 0 = failure */
+}
+
+/*************************************************************************
+ *      SHLWAPI_276     [SHLWAPI.276]
  *
  */
 DWORD WINAPI SHLWAPI_276 ()
 {
-    FIXME("()stub\n");
-    return 0xabba1244;
-}
-#endif
-/*************************************************************************
- *      SHLWAPI_278 [SHLWAPI.278]
+        FIXME("()stub\n");
+        return 0xabba1244;
+}
+#endif
+/*************************************************************************
+ *      SHLWAPI_278     [SHLWAPI.278]
  *
  */
 DWORD WINAPI SHLWAPI_278 (
-    LONG wndProc,
-    HWND hWndParent,
-    DWORD dwExStyle,
-    DWORD dwStyle,
-    HMENU hMenu,
-    LONG z)
-{
-    WNDCLASSA wndclass;
-    HWND hwnd;
-    HCURSOR hCursor;
-    char * clsname = "WorkerA";
-
-    FIXME("(0x%08lx 0x%08x 0x%08lx 0x%08lx 0x%08x 0x%08lx)stub\n",
-      wndProc,hWndParent,dwExStyle,dwStyle,hMenu,z);
-
-    hCursor = LoadCursorA(0x00000000,IDC_ARROWA);
-
-    if(!GetClassInfoA(shlwapi_hInstance, clsname, &wndclass))
-    {
-      RtlZeroMemory(&wndclass, sizeof(WNDCLASSA));
-      wndclass.lpfnWndProc = DefWindowProcW;
-      wndclass.cbWndExtra = 4;
-      wndclass.hInstance = shlwapi_hInstance;
-      wndclass.hCursor = hCursor;
-      wndclass.hbrBackground = COLOR_BTNSHADOW;
-      wndclass.lpszMenuName = NULL;
-      wndclass.lpszClassName = clsname;
-      RegisterClassA (&wndclass);
-    }
-    hwnd = CreateWindowExA(dwExStyle, clsname, 0,dwStyle,0,0,0,0,hWndParent,
-        hMenu,shlwapi_hInstance,0);
-    SetWindowLongA(hwnd, 0, z);
-    SetWindowLongA(hwnd, GWL_WNDPROC, wndProc);
-    return hwnd;
-}
-
-/*************************************************************************
- *      SHLWAPI_289 [SHLWAPI.289]
+        LONG wndProc,
+        HWND hWndParent,
+        DWORD dwExStyle,
+        DWORD dwStyle,
+        HMENU hMenu,
+        LONG z)
+{
+        WNDCLASSA wndclass;
+        HWND hwnd;
+        HCURSOR hCursor;
+        char * clsname = "WorkerA";
+
+        FIXME("(0x%08lx 0x%08x 0x%08lx 0x%08lx 0x%08x 0x%08lx)stub\n",
+          wndProc,hWndParent,dwExStyle,dwStyle,hMenu,z);
+
+        hCursor = LoadCursorA(0x00000000,IDC_ARROWA);
+
+        if(!GetClassInfoA(shlwapi_hInstance, clsname, &wndclass))
+        {
+          RtlZeroMemory(&wndclass, sizeof(WNDCLASSA));
+          wndclass.lpfnWndProc = DefWindowProcW;
+          wndclass.cbWndExtra = 4;
+          wndclass.hInstance = shlwapi_hInstance;
+          wndclass.hCursor = hCursor;
+          wndclass.hbrBackground = COLOR_BTNSHADOW;
+          wndclass.lpszMenuName = NULL;
+          wndclass.lpszClassName = clsname;
+          RegisterClassA (&wndclass);
+        }
+        hwnd = CreateWindowExA(dwExStyle, clsname, 0,dwStyle,0,0,0,0,hWndParent,
+                hMenu,shlwapi_hInstance,0);
+        SetWindowLongA(hwnd, 0, z);
+        SetWindowLongA(hwnd, GWL_WNDPROC, wndProc);
+        return hwnd;
+}
+
+/*************************************************************************
+ *      SHLWAPI_289     [SHLWAPI.289]
  *
  * Late bound call to winmm.PlaySoundW
@@ -710 +709 @@
 
 /*************************************************************************
- *      SHLWAPI_313 [SHLWAPI.313]
+ *      SHLWAPI_313     [SHLWAPI.313]
  *
  * Late bound call to shell32.SHGetFileInfoW
@@ -724 +723 @@
 
 /*************************************************************************
- *      SHLWAPI_318 [SHLWAPI.318]
+ *      SHLWAPI_318     [SHLWAPI.318]
  *
  * Late bound call to shell32.DragQueryFileW
@@ -737 +736 @@
 
 /*************************************************************************
- *      SHLWAPI_333 [SHLWAPI.333]
+ *      SHLWAPI_333     [SHLWAPI.333]
  *
  * Late bound call to shell32.SHBrowseForFolderW
@@ -750 +749 @@
 
 /*************************************************************************
- *      SHLWAPI_334 [SHLWAPI.334]
+ *      SHLWAPI_334     [SHLWAPI.334]
  *
  * Late bound call to shell32.SHGetPathFromIDListW
@@ -763 +762 @@
 
 /*************************************************************************
- *      SHLWAPI_335 [SHLWAPI.335]
+ *      SHLWAPI_335     [SHLWAPI.335]
  *
  * Late bound call to shell32.ShellExecuteExW
@@ -776 +775 @@
 
 /*************************************************************************
- *      SHLWAPI_336 [SHLWAPI.336]
+ *      SHLWAPI_336     [SHLWAPI.336]
  *
  * Late bound call to shell32.SHFileOperationW.
@@ -789 +788 @@
 
 /*************************************************************************
- *      SHLWAPI_337 [SHLWAPI.337]
+ *      SHLWAPI_337     [SHLWAPI.337]
  *
  * Late bound call to shell32.ExtractIconExW.
@@ -804 +803 @@
 //Bugbug: is forwarder for InterlockedCompareExchange
 /*************************************************************************
- *      SHLWAPI_342 [SHLWAPI.342]
+ *      SHLWAPI_342     [SHLWAPI.342]
  *
  */
 DWORD WINAPI SHLWAPI_342 (
-    LPVOID w,
-    LPVOID x,
-    LPVOID y,
-    LPVOID z)
-{
-    FIXME("(%p %p %p %p)stub\n",w,x,y,z);
-    return 0xabba1249;
-}
-#endif
-/*************************************************************************
- *      SHLWAPI_346 [SHLWAPI.346]
+        LPVOID w,
+        LPVOID x,
+        LPVOID y,
+        LPVOID z)
+{
+        FIXME("(%p %p %p %p)stub\n",w,x,y,z);
+        return 0xabba1249;
+}
+#endif
+/*************************************************************************
+ *      SHLWAPI_346     [SHLWAPI.346]
  */
 DWORD WINAPI SHLWAPI_346 (
-    LPCWSTR src,
-    LPWSTR dest,
-    int len)
-{
-    FIXME("(%s %p 0x%08x)stub\n",debugstr_w(src),dest,len);
-    lstrcpynW(dest, src, len);
-    return lstrlenW(dest)+1;
-}
-
-/*************************************************************************
- *      SHLWAPI_357 [SHLWAPI.357]
+        LPCWSTR src,
+        LPWSTR dest,
+        int len)
+{
+        FIXME("(%s %p 0x%08x)stub\n",debugstr_w(src),dest,len);
+        lstrcpynW(dest, src, len);
+        return lstrlenW(dest)+1;
+}
+
+/*************************************************************************
+ *      SHLWAPI_357     [SHLWAPI.357]
  *
  * Late bound call to shell32.SHGetNewLinkInfoW
@@ -845 +844 @@
 
 /*************************************************************************
- *      SHLWAPI_358 [SHLWAPI.358]
+ *      SHLWAPI_358     [SHLWAPI.358]
  *
  * Late bound call to shell32.SHDefExtractIconW
@@ -860 +859 @@
 
 /*************************************************************************
- *      SHLWAPI_364 [SHLWAPI.364]
+ *      SHLWAPI_364     [SHLWAPI.364]
  *
  * Wrapper for lstrcpynA with src and dst swapped.
@@ -871 +870 @@
 
 /*************************************************************************
- *      SHLWAPI_370 [SHLWAPI.370]
+ *      SHLWAPI_370     [SHLWAPI.370]
  *
  * Late bound call to shell32.ExtractIconW
@@ -885 +884 @@
 
 /*************************************************************************
- *      SHLWAPI_376 [SHLWAPI.376]
+ *      SHLWAPI_376     [SHLWAPI.376]
  */
 DWORD WINAPI SHLWAPI_376 (LONG x)
 {
-    FIXME("(0x%08lx)stub\n", x );
+        FIXME("(0x%08lx)stub\n", x );
   /* FIXME: This should be a forward in the .spec file to the win2k function
    * kernel32.GetUserDefaultUILanguage, however that function isn't there yet.
@@ -897 +896 @@
 #ifndef __WIN32OS2__
 /*************************************************************************
- *      SHLWAPI_377 [SHLWAPI.377]
+ *      SHLWAPI_377     [SHLWAPI.377]
  */
 DWORD WINAPI SHLWAPI_377 (LPVOID x, LPVOID y, LPVOID z)
 {
-    FIXME("(%p %p %p)stub\n", x,y,z);
-    return 0xabba1246;
-}
-#endif
-/*************************************************************************
- *      SHLWAPI_378 [SHLWAPI.378]
+        FIXME("(%p %p %p)stub\n", x,y,z);
+        return 0xabba1246;
+}
+#endif
+/*************************************************************************
+ *      SHLWAPI_378     [SHLWAPI.378]
  */
 DWORD WINAPI SHLWAPI_378 (
-    LPSTR x,
-    LPVOID y, /* [???] 0x50000000 */
-    LPVOID z) /* [???] 4 */
-{
-    FIXME("(%s %p %p)stub\n", x,y,z);
-    return LoadLibraryA(x);
-}
-
-/*************************************************************************
- *      SHLWAPI_389 [SHLWAPI.389]
+        LPSTR x,
+        LPVOID y, /* [???] 0x50000000 */
+        LPVOID z) /* [???] 4 */
+{
+        FIXME("(%s %p %p)stub\n", x,y,z);
+        return LoadLibraryA(x);
+}
+
+/*************************************************************************
+ *      SHLWAPI_389     [SHLWAPI.389]
  *
  * Late bound call to comdlg32.GetSaveFileNameW
@@ -931 +930 @@
 
 /*************************************************************************
- *      SHLWAPI_390 [SHLWAPI.390]
+ *      SHLWAPI_390     [SHLWAPI.390]
  *
  * Late bound call to mpr.WNetRestoreConnectionW
@@ -945 +944 @@
 
 /*************************************************************************
- *      SHLWAPI_391 [SHLWAPI.391]
+ *      SHLWAPI_391     [SHLWAPI.391]
  *
  * Late bound call to mpr.WNetGetLastErrorW
@@ -960 +959 @@
 
 /*************************************************************************
- *      SHLWAPI_401 [SHLWAPI.401]
+ *      SHLWAPI_401     [SHLWAPI.401]
  *
  * Late bound call to comdlg32.PageSetupDlgW
@@ -973 +972 @@
 
 /*************************************************************************
- *      SHLWAPI_402 [SHLWAPI.402]
+ *      SHLWAPI_402     [SHLWAPI.402]
  *
  * Late bound call to comdlg32.PrintDlgW
@@ -986 +985 @@
 
 /*************************************************************************
- *      SHLWAPI_403 [SHLWAPI.403]
+ *      SHLWAPI_403     [SHLWAPI.403]
  *
  * Late bound call to comdlg32.GetOpenFileNameW
@@ -1017 +1016 @@
 
 /*************************************************************************
- *      ColorHLSToRGB   [SHLWAPI.404]
+ *      ColorHLSToRGB   [SHLWAPI.404]
  *
  * Convert from HLS color space into an RGB COLORREF.
@@ -1051 +1050 @@
 
 /*************************************************************************
- *      SHLWAPI_431 [SHLWAPI.431]
+ *      SHLWAPI_431     [SHLWAPI.431]
  */
 DWORD WINAPI SHLWAPI_431 (DWORD x)
 {
-    FIXME("(0x%08lx)stub\n", x);
-    return 0xabba1247;
+        FIXME("(0x%08lx)stub\n", x);
+        return 0xabba1247;
 }
 
 #ifndef __WIN32OS2__
 /*************************************************************************
- *      SHLWAPI_437 [SHLWAPI.437]
+ *      SHLWAPI_437     [SHLWAPI.437]
  *
  * NOTES
@@ -1074 +1073 @@
 DWORD WINAPI SHLWAPI_437 (DWORD functionToCall)
 {
-    FIXME("(0x%08lx)stub\n", functionToCall);
-    return 0xabba1247;
-}
-#endif
-
-/*************************************************************************
- *      SHCreateShellPalette    [SHLWAPI.@]
+        FIXME("(0x%08lx)stub\n", functionToCall);
+        return 0xabba1247;
+}
+#endif
+
+/*************************************************************************
+ *      SHCreateShellPalette    [SHLWAPI.@]
  */
 HPALETTE WINAPI SHCreateShellPalette(HDC hdc)
 {
-    FIXME("stub\n");
-    return CreateHalftonePalette(hdc);
-}
-
-/*************************************************************************
- *  SHGetInverseCMAP
+        FIXME("stub\n");
+        return CreateHalftonePalette(hdc);
+}
+
+/*************************************************************************
+ *      SHGetInverseCMAP
  */
 DWORD WINAPI SHGetInverseCMAP (LPVOID x, DWORD why)
 {
-    FIXME("(%p, %#lx)stub\n", x, why);
-    return 0;
+        FIXME("(%p, %#lx)stub\n", x, why);
+        return 0;
 }
 #ifndef __WIN32OS2__
 /*************************************************************************
- *      SHIsLowMemoryMachine    [SHLWAPI.@]
+ *      SHIsLowMemoryMachine    [SHLWAPI.@]
  */
 DWORD WINAPI SHIsLowMemoryMachine (DWORD x)
 {
-    FIXME("0x%08lx\n", x);
-    return 0;
-}
-#endif
-
-/*************************************************************************
- *      GetMenuPosFromID    [SHLWAPI.@]
+        FIXME("0x%08lx\n", x);
+        return 0;
+}
+#endif
+
+/*************************************************************************
+ *      GetMenuPosFromID        [SHLWAPI.@]
  */
 INT WINAPI GetMenuPosFromID(HMENU hMenu, UINT wID)
@@ -1126 +1125 @@
 
 /*************************************************************************
- *      _SHGetInstanceExplorer  [SHLWAPI.@]
+ *      _SHGetInstanceExplorer  [SHLWAPI.@]
  *
  * Late bound call to shell32.SHGetInstanceExplorer.

trunk/src/shlwapi/path.c

@@ -1 @@
-/* $Id: path.c,v 1.14 2001-09-05 13:48:38 bird Exp $ */
 /*
  * Path Functions
@@ -43 +42 @@
 #define isSlash(x) ((x)=='\\' || (x)=='/')
 /*
-    ########## Combining and Constructing paths ##########
+        ########## Combining and Constructing paths ##########
 */
 
 /*************************************************************************
- * PathAppendA      [SHLWAPI.@]
- *
+ * PathAppendA          [SHLWAPI.@]
+ * 
  * NOTES
  *  concat path lpszPath2 onto lpszPath1
@@ -56 +55 @@
  */
 BOOL WINAPI PathAppendA(
-    LPSTR lpszPath1,
-    LPCSTR lpszPath2)
-{
-    TRACE("%s %s\n",lpszPath1, lpszPath2);
-    while (lpszPath2[0]=='\\') lpszPath2++;
-    PathCombineA(lpszPath1,lpszPath1,lpszPath2);
-    return TRUE;
-}
-
-/*************************************************************************
- * PathAppendW      [SHLWAPI.@]
+        LPSTR lpszPath1,
+        LPCSTR lpszPath2) 
+{
+        TRACE("%s %s\n",lpszPath1, lpszPath2);
+        while (lpszPath2[0]=='\\') lpszPath2++;
+        PathCombineA(lpszPath1,lpszPath1,lpszPath2);
+        return TRUE;
+}
+
+/*************************************************************************
+ * PathAppendW          [SHLWAPI.@]
  */
 BOOL WINAPI PathAppendW(
-    LPWSTR lpszPath1,
-    LPCWSTR lpszPath2)
-{
-    TRACE("%s %s\n",debugstr_w(lpszPath1), debugstr_w(lpszPath2));
-    while (lpszPath2[0]=='\\') lpszPath2++;
-    PathCombineW(lpszPath1,lpszPath1,lpszPath2);
-    return TRUE;
-}
-
-/*************************************************************************
- * PathCombineA     [SHLWAPI.@]
- *
+        LPWSTR lpszPath1,
+        LPCWSTR lpszPath2) 
+{
+        TRACE("%s %s\n",debugstr_w(lpszPath1), debugstr_w(lpszPath2));
+        while (lpszPath2[0]=='\\') lpszPath2++;
+        PathCombineW(lpszPath1,lpszPath1,lpszPath2);
+        return TRUE;
+}
+
+/*************************************************************************
+ * PathCombineA         [SHLWAPI.@]
+ * 
  * NOTES
  *  if lpszFile='.' skip it
@@ -89 +88 @@
  */
 LPSTR WINAPI PathCombineA(
-    LPSTR szDest,
-    LPCSTR lpszDir,
-    LPCSTR lpszFile)
-{
-    char sTemp[MAX_PATH];
-    TRACE("%p %p->%s %p->%s\n",szDest, lpszDir, lpszDir, lpszFile, lpszFile);
-
-
-    if (!lpszFile || !lpszFile[0] || (lpszFile[0]=='.' && !lpszFile[1]) )
-    {
-      strcpy(szDest,lpszDir);
-      return szDest;
-    }
-
-    /*  if lpszFile is a complete path don't care about lpszDir */
-    if (PathGetDriveNumberA(lpszFile) != -1)
-    {
-      strcpy(szDest,lpszFile);
-    }
-    else if (lpszFile[0] == '\\' )
-    {
-      strcpy(sTemp,lpszDir);
-      PathStripToRootA(sTemp);
-      strcat(sTemp,lpszFile);
-      strcpy(szDest,sTemp);
-    }
-    else
-    {
-      strcpy(sTemp,lpszDir);
-      PathAddBackslashA(sTemp);
-      strcat(sTemp,lpszFile);
-      strcpy(szDest,sTemp);
-    }
-    return szDest;
-}
-
-/*************************************************************************
- * PathCombineW      [SHLWAPI.@]
+        LPSTR szDest,
+        LPCSTR lpszDir,
+        LPCSTR lpszFile) 
+{
+        char sTemp[MAX_PATH];
+        TRACE("%p %p->%s %p->%s\n",szDest, lpszDir, lpszDir, lpszFile, lpszFile);
+        
+        
+        if (!lpszFile || !lpszFile[0] || (lpszFile[0]=='.' && !lpszFile[1]) ) 
+        {
+          strcpy(szDest,lpszDir);
+          return szDest;
+        }
+
+        /*  if lpszFile is a complete path don't care about lpszDir */
+        if (PathGetDriveNumberA(lpszFile) != -1)
+        {
+          strcpy(szDest,lpszFile);
+        }
+        else if (lpszFile[0] == '\\' )
+        {
+          strcpy(sTemp,lpszDir);
+          PathStripToRootA(sTemp);
+          strcat(sTemp,lpszFile);
+          strcpy(szDest,sTemp);
+        }
+        else
+        {
+          strcpy(sTemp,lpszDir);
+          PathAddBackslashA(sTemp);
+          strcat(sTemp,lpszFile);
+          strcpy(szDest,sTemp);
+        }
+        return szDest;
+}
+
+/*************************************************************************
+ * PathCombineW          [SHLWAPI.@]
  */
 LPWSTR WINAPI PathCombineW(
-    LPWSTR szDest,
-    LPCWSTR lpszDir,
-    LPCWSTR lpszFile)
-{
-    WCHAR sTemp[MAX_PATH];
-    TRACE("%p %p->%s %p->%s\n",szDest, lpszDir, debugstr_w(lpszDir),
-             lpszFile, debugstr_w(lpszFile));
-
-
-    if (!lpszFile || !lpszFile[0] || (lpszFile[0]==(WCHAR)'.' && !lpszFile[1]) )
-    {
+        LPWSTR szDest,
+        LPCWSTR lpszDir,
+        LPCWSTR lpszFile) 
+{
+        WCHAR sTemp[MAX_PATH];
+        TRACE("%p %p->%s %p->%s\n",szDest, lpszDir, debugstr_w(lpszDir),
+                         lpszFile, debugstr_w(lpszFile));
+        
+        
+        if (!lpszFile || !lpszFile[0] || (lpszFile[0]==(WCHAR)'.' && !lpszFile[1]) ) 
+        {
           strcpyW(szDest,lpszDir);
-      return szDest;
-    }
-
-    /*  if lpszFile is a complete path don't care about lpszDir */
-    if (PathGetDriveNumberW(lpszFile) != -1)
-    {
+          return szDest;
+        }
+
+        /*  if lpszFile is a complete path don't care about lpszDir */
+        if (PathGetDriveNumberW(lpszFile) != -1)
+        {
             strcpyW(szDest,lpszFile);
-    }
-    else if (lpszFile[0] == (WCHAR)'\\' )
-    {
-      strcpyW(sTemp,lpszDir);
-      PathStripToRootW(sTemp);
-      strcatW(sTemp,lpszFile);
-      strcpyW(szDest,sTemp);
-    }
-    else
-    {
-      strcpyW(sTemp,lpszDir);
-      PathAddBackslashW(sTemp);
-      strcatW(sTemp,lpszFile);
-      strcpyW(szDest,sTemp);
-    }
-    return szDest;
-}
-
-/*************************************************************************
- * PathAddBackslashA    [SHLWAPI.@]
+        }
+        else if (lpszFile[0] == (WCHAR)'\\' )
+        {
+          strcpyW(sTemp,lpszDir);
+          PathStripToRootW(sTemp);
+          strcatW(sTemp,lpszFile);
+          strcpyW(szDest,sTemp);
+        }
+        else
+        {
+          strcpyW(sTemp,lpszDir);
+          PathAddBackslashW(sTemp);
+          strcatW(sTemp,lpszFile);
+          strcpyW(szDest,sTemp);
+        }
+        return szDest;
+}
+
+/*************************************************************************
+ * PathAddBackslashA    [SHLWAPI.@]
  *
  * NOTES
@@ -174 +173 @@
 LPSTR WINAPI PathAddBackslashA(LPSTR lpszPath)
 {
-    int len;
-    TRACE("%p->%s\n",lpszPath,lpszPath);
-
-    len = strlen(lpszPath);
-    if (len && lpszPath[len-1]!='\\')
-    {
-      lpszPath[len]  = '\\';
-      lpszPath[len+1]= 0x00;
-      return lpszPath+len+1;
-    }
-    return lpszPath+len;
-}
-
-/*************************************************************************
- * PathAddBackslashW    [SHLWAPI.@]
+        int len;
+        TRACE("%p->%s\n",lpszPath,lpszPath);
+
+        len = strlen(lpszPath);
+        if (len && lpszPath[len-1]!='\\') 
+        {
+          lpszPath[len]  = '\\';
+          lpszPath[len+1]= 0x00;
+          return lpszPath+len+1;
+        }
+        return lpszPath+len;
+}
+
+/*************************************************************************
+ * PathAddBackslashW    [SHLWAPI.@]
  */
 LPWSTR WINAPI PathAddBackslashW(LPWSTR lpszPath)
 {
-    int len;
-    TRACE("%p->%s\n",lpszPath,debugstr_w(lpszPath));
-
-    len = strlenW(lpszPath);
-    if (len && lpszPath[len-1]!=(WCHAR)'\\')
-    {
-      lpszPath[len]  = (WCHAR)'\\';
-      lpszPath[len+1]= 0x00;
-      return lpszPath+len+1;
-    }
-    return lpszPath+len;
-}
-
-/*************************************************************************
- * PathBuildRootA       [SHLWAPI.@]
- */
-LPSTR WINAPI PathBuildRootA(LPSTR lpszPath, int drive)
-{
-    TRACE("%p %i\n",lpszPath, drive);
-
-    strcpy(lpszPath,"A:\\");
-    lpszPath[0]+=drive;
-    return lpszPath;
-}
-
-/*************************************************************************
- * PathBuildRootW       [SHLWAPI.@]
- */
-LPWSTR WINAPI PathBuildRootW(LPWSTR lpszPath, int drive)
-{
-    lpszPath[0] = 'A' + drive;
-    lpszPath[1] = ':';
-    lpszPath[2] = '\\';
-    lpszPath[3] = 0;
-    TRACE("%p %i\n",debugstr_w(lpszPath), drive);
-    return lpszPath;
+        int len;
+        TRACE("%p->%s\n",lpszPath,debugstr_w(lpszPath));
+
+        len = strlenW(lpszPath);
+        if (len && lpszPath[len-1]!=(WCHAR)'\\') 
+        {
+          lpszPath[len]  = (WCHAR)'\\';
+          lpszPath[len+1]= 0x00;
+          return lpszPath+len+1;
+        }
+        return lpszPath+len;
+}
+
+/*************************************************************************
+ * PathBuildRootA               [SHLWAPI.@]
+ */
+LPSTR WINAPI PathBuildRootA(LPSTR lpszPath, int drive) 
+{
+        TRACE("%p %i\n",lpszPath, drive);
+
+        strcpy(lpszPath,"A:\\");
+        lpszPath[0]+=drive;
+        return lpszPath;
+}
+
+/*************************************************************************
+ * PathBuildRootW               [SHLWAPI.@]
+ */
+LPWSTR WINAPI PathBuildRootW(LPWSTR lpszPath, int drive) 
+{
+        lpszPath[0] = 'A' + drive;
+        lpszPath[1] = ':';
+        lpszPath[2] = '\\';
+        lpszPath[3] = 0;
+        TRACE("%p %i\n",debugstr_w(lpszPath), drive);
+        return lpszPath;
 }
 
 /*
-    Extracting Component Parts
+        Extracting Component Parts
 */
 
 /*************************************************************************
- * PathFindFileNameA    [SHLWAPI.@]
+ * PathFindFileNameA    [SHLWAPI.@]
  */
 LPSTR WINAPI PathFindFileNameA(LPCSTR lpszPath)
 {
-    LPCSTR lastSlash = lpszPath;
-
-    TRACE("%s\n",lpszPath);
-    while (*lpszPath)
-    {
-      if ( isSlash(lpszPath[0]) && lpszPath[1])
-          lastSlash = lpszPath+1;
-      lpszPath = CharNextA(lpszPath);
-    }
-    return (LPSTR)lastSlash;
-
-}
-
-/*************************************************************************
- * PathFindFileNameW    [SHLWAPI.@]
+        LPCSTR lastSlash = lpszPath;
+
+        TRACE("%s\n",lpszPath);
+        while (*lpszPath) 
+        {
+          if ( isSlash(lpszPath[0]) && lpszPath[1])
+              lastSlash = lpszPath+1;
+          lpszPath = CharNextA(lpszPath);
+        }
+        return (LPSTR)lastSlash;
+
+}
+
+/*************************************************************************
+ * PathFindFileNameW    [SHLWAPI.@]
  */
 LPWSTR WINAPI PathFindFileNameW(LPCWSTR lpszPath)
 {
-    LPCWSTR wslash;
-    wslash = lpszPath;
-
-    TRACE("%s\n",debugstr_w(wslash));
-    while (lpszPath[0])
-    {
-      if (((lpszPath[0]=='\\') || (lpszPath[0]==':')) && lpszPath[1] && lpszPath[1]!='\\')
-        wslash = lpszPath+1;
-      lpszPath = CharNextW(lpszPath);
-    }
-    return (LPWSTR)wslash;
-}
-
-/*************************************************************************
- * PathFindExtensionA   [SHLWAPI.@]
+        LPCWSTR wslash;
+        wslash = lpszPath;
+
+        TRACE("%s\n",debugstr_w(wslash));
+        while (lpszPath[0]) 
+        {
+          if (((lpszPath[0]=='\\') || (lpszPath[0]==':')) && lpszPath[1] && lpszPath[1]!='\\')
+            wslash = lpszPath+1;
+          lpszPath = CharNextW(lpszPath);
+        }
+        return (LPWSTR)wslash;  
+}
+
+/*************************************************************************
+ * PathFindExtensionA   [SHLWAPI.@]
  *
  * NOTES
@@ -277 +276 @@
  */
 
-LPSTR WINAPI PathFindExtensionA(LPCSTR lpszPath)
-{
-    LPCSTR   lastpoint = NULL;
-
-    TRACE("%p %s\n",lpszPath,lpszPath);
-
-    while (*lpszPath)
-    {
-      if (*lpszPath=='\\'||*lpszPath==' ')
-        lastpoint=NULL;
-      if (*lpszPath=='.')
-        lastpoint=lpszPath;
-      lpszPath = CharNextA(lpszPath);
-    }
-    return (LPSTR)(lastpoint?lastpoint:lpszPath);
-}
-
-/*************************************************************************
- * PathFindExtensionW   [SHLWAPI.@]
- */
-LPWSTR WINAPI PathFindExtensionW(LPCWSTR lpszPath)
-{
-    LPCWSTR   lastpoint = NULL;
-
-    TRACE("(%p %s)\n",lpszPath,debugstr_w(lpszPath));
-
-    while (*lpszPath)
-    {
-      if (*lpszPath==(WCHAR)'\\'||*lpszPath==(WCHAR)' ')
-        lastpoint=NULL;
-      if (*lpszPath==(WCHAR)'.')
-        lastpoint=lpszPath;
-      lpszPath = CharNextW(lpszPath);
-    }
-    return (LPWSTR)(lastpoint?lastpoint:lpszPath);
-}
-
-/*************************************************************************
- * PathGetArgsA     [SHLWAPI.@]
+LPSTR WINAPI PathFindExtensionA(LPCSTR lpszPath) 
+{
+        LPCSTR   lastpoint = NULL;
+
+        TRACE("%p %s\n",lpszPath,lpszPath);
+
+        while (*lpszPath) 
+        {
+          if (*lpszPath=='\\'||*lpszPath==' ')
+            lastpoint=NULL;
+          if (*lpszPath=='.')
+            lastpoint=lpszPath;
+          lpszPath = CharNextA(lpszPath);
+        }
+        return (LPSTR)(lastpoint?lastpoint:lpszPath);
+}
+
+/*************************************************************************
+ * PathFindExtensionW   [SHLWAPI.@]
+ */
+LPWSTR WINAPI PathFindExtensionW(LPCWSTR lpszPath) 
+{
+        LPCWSTR   lastpoint = NULL;
+
+        TRACE("(%p %s)\n",lpszPath,debugstr_w(lpszPath));
+
+        while (*lpszPath)
+        {
+          if (*lpszPath==(WCHAR)'\\'||*lpszPath==(WCHAR)' ')
+            lastpoint=NULL;
+          if (*lpszPath==(WCHAR)'.')
+            lastpoint=lpszPath;
+          lpszPath = CharNextW(lpszPath);
+        }
+        return (LPWSTR)(lastpoint?lastpoint:lpszPath);
+}
+
+/*************************************************************************
+ * PathGetArgsA         [SHLWAPI.@]
  *
  * NOTES
@@ -324 +323 @@
  *     quoting by '\'
  */
-LPSTR WINAPI PathGetArgsA(LPCSTR lpszPath)
-{
-    BOOL    qflag = FALSE;
-
-    TRACE("%s\n",lpszPath);
-
-    while (*lpszPath)
-    {
-      if ((*lpszPath==' ') && !qflag)
-        return (LPSTR)lpszPath+1;
-      if (*lpszPath=='"')
-        qflag=!qflag;
-      lpszPath = CharNextA(lpszPath);
-    }
-    return (LPSTR)lpszPath;
-}
-
-/*************************************************************************
- * PathGetArgsW     [SHLWAPI.@]
- */
-LPWSTR WINAPI PathGetArgsW(LPCWSTR lpszPath)
-{
-    BOOL    qflag = FALSE;
-
-    TRACE("%s\n",debugstr_w(lpszPath));
-
-    while (*lpszPath)
-    {
-      if ((*lpszPath==' ') && !qflag)
-        return (LPWSTR)lpszPath+1;
-      if (*lpszPath=='"')
-        qflag=!qflag;
-      lpszPath = CharNextW(lpszPath);
-    }
-    return (LPWSTR)lpszPath;
-}
-
-/*************************************************************************
- * PathGetDriveNumberA  [SHLWAPI.@]
+LPSTR WINAPI PathGetArgsA(LPCSTR lpszPath) 
+{
+        BOOL    qflag = FALSE;
+
+        TRACE("%s\n",lpszPath);
+
+        while (*lpszPath) 
+        {
+          if ((*lpszPath==' ') && !qflag)
+            return (LPSTR)lpszPath+1;
+          if (*lpszPath=='"')
+            qflag=!qflag;
+          lpszPath = CharNextA(lpszPath);
+        }
+        return (LPSTR)lpszPath;
+}
+
+/*************************************************************************
+ * PathGetArgsW         [SHLWAPI.@]
+ */
+LPWSTR WINAPI PathGetArgsW(LPCWSTR lpszPath) 
+{
+        BOOL    qflag = FALSE;
+
+        TRACE("%s\n",debugstr_w(lpszPath));
+
+        while (*lpszPath) 
+        {
+          if ((*lpszPath==' ') && !qflag)
+            return (LPWSTR)lpszPath+1;
+          if (*lpszPath=='"')
+            qflag=!qflag;
+          lpszPath = CharNextW(lpszPath);
+        }
+        return (LPWSTR)lpszPath;
+}
+
+/*************************************************************************
+ * PathGetDriveNumberA  [SHLWAPI.@]
  */
 int WINAPI PathGetDriveNumberA(LPCSTR lpszPath)
 {
-    int chr = tolower(lpszPath[0]);
-
-    TRACE ("%s\n",debugstr_a(lpszPath));
-
-    if (!lpszPath || lpszPath[1]!=':' || chr < 'a' || chr > 'z') return -1;
-    return tolower(lpszPath[0]) - 'a' ;
-}
-
-/*************************************************************************
- * PathGetDriveNumberW  [SHLWAPI.@]
+        int chr = tolower(lpszPath[0]);
+        
+        TRACE ("%s\n",debugstr_a(lpszPath));
+
+        if (!lpszPath || lpszPath[1]!=':' || chr < 'a' || chr > 'z') return -1;
+        return tolower(lpszPath[0]) - 'a' ;
+}
+
+/*************************************************************************
+ * PathGetDriveNumberW  [SHLWAPI.@]
  */
 int WINAPI PathGetDriveNumberW(LPCWSTR lpszPath)
 {
-    int chr = tolowerW(lpszPath[0]);
-
-    TRACE ("%s\n",debugstr_w(lpszPath));
-
-    if (!lpszPath || lpszPath[1]!=':' || chr < 'a' || chr > 'z') return -1;
-    return tolowerW(lpszPath[0]) - 'a' ;
-}
-
-/*************************************************************************
- * PathRemoveFileSpecA  [SHLWAPI.@]
- *
+        int chr = tolowerW(lpszPath[0]);
+        
+        TRACE ("%s\n",debugstr_w(lpszPath));
+
+        if (!lpszPath || lpszPath[1]!=':' || chr < 'a' || chr > 'z') return -1;
+        return tolowerW(lpszPath[0]) - 'a' ;
+}
+
+/*************************************************************************
+ * PathRemoveFileSpecA  [SHLWAPI.@]
+ * 
  * NOTES
  *     truncates passed argument to a valid path
@@ -395 +394 @@
  *     "\foo\xx\foo"-> "\foo\xx"
  *     "\" -> "\"
- *     "a:\foo" -> "a:\"
+ *     "a:\foo" -> "a:\"
  */
 BOOL WINAPI PathRemoveFileSpecA(LPSTR lpszPath)
 {
-    LPSTR cutplace = lpszPath;
-    BOOL ret = FALSE;
-
-    TRACE("%s\n",lpszPath);
-
-    if(lpszPath)
-    {
-      while (*lpszPath == '\\') cutplace = ++lpszPath;
-
-      while (*lpszPath)
-      {
-        if(lpszPath[0] == '\\') cutplace = lpszPath;
-
-        if(lpszPath[0] == ':')
-        {
-          cutplace = lpszPath + 1;
-          if (lpszPath[1] == '\\') cutplace++;
-          lpszPath++;
-        }
-        lpszPath = CharNextA(lpszPath);
-        if (!lpszPath) break;
-      }
-
-      ret = (*cutplace!='\0');
-      *cutplace = '\0';
-    }
-    return ret;
-}
-
-/*************************************************************************
- * PathRemoveFileSpecW  [SHLWAPI.@]
+        LPSTR cutplace = lpszPath;
+        BOOL ret = FALSE;
+        
+        TRACE("%s\n",lpszPath);
+
+        if(lpszPath)
+        {
+          while (*lpszPath == '\\') cutplace = ++lpszPath;
+          
+          while (*lpszPath)
+          {
+            if(lpszPath[0] == '\\') cutplace = lpszPath;
+          
+            if(lpszPath[0] == ':')
+            {
+              cutplace = lpszPath + 1;
+              if (lpszPath[1] == '\\') cutplace++;
+              lpszPath++;
+            }
+            lpszPath = CharNextA(lpszPath);
+            if (!lpszPath) break;
+          }
+          
+          ret = (*cutplace!='\0');
+          *cutplace = '\0';
+        }
+        return ret;
+}
+
+/*************************************************************************
+ * PathRemoveFileSpecW  [SHLWAPI.@]
  */
 BOOL WINAPI PathRemoveFileSpecW(LPWSTR lpszPath)
 {
-    LPWSTR cutplace = lpszPath;
-    BOOL ret = FALSE;
-
-    TRACE("%s\n",debugstr_w(lpszPath));
-
-    if(lpszPath)
-    {
-      while (*lpszPath == '\\') cutplace = ++lpszPath;
-
-      while (*lpszPath)
-      {
-        if(lpszPath[0] == '\\') cutplace = lpszPath;
-
-        if(lpszPath[0] == ':')
-        {
-          cutplace = lpszPath + 1;
-          if (lpszPath[1] == '\\') cutplace++;
-          lpszPath++;
-        }
-        lpszPath = CharNextW(lpszPath);
-        if (!lpszPath) break;
-      }
-
-      ret = (*cutplace!='\0');
-      *cutplace = '\0';
-    }
-    return ret;
-}
-
-/*************************************************************************
- * PathStripPathA   [SHELLWAPI.@]
- *
+        LPWSTR cutplace = lpszPath;
+        BOOL ret = FALSE;
+
+        TRACE("%s\n",debugstr_w(lpszPath));
+
+        if(lpszPath)
+        {
+          while (*lpszPath == '\\') cutplace = ++lpszPath;
+          
+          while (*lpszPath)
+          {
+            if(lpszPath[0] == '\\') cutplace = lpszPath;
+          
+            if(lpszPath[0] == ':')
+            {
+              cutplace = lpszPath + 1;
+              if (lpszPath[1] == '\\') cutplace++;
+              lpszPath++;
+            }
+            lpszPath = CharNextW(lpszPath);
+            if (!lpszPath) break;
+          }
+          
+          ret = (*cutplace!='\0');
+          *cutplace = '\0';
+        }
+        return ret;
+}
+
+/*************************************************************************
+ * PathStripPathA       [SHELLWAPI.@]
+ * 
  * NOTES
  *  removes the path from the beginning of a filename
@@ -470 +469 @@
 void WINAPI PathStripPathA(LPSTR lpszPath)
 {
-    LPSTR lpszFileName = PathFindFileNameA(lpszPath);
-
-    TRACE("%s\n", lpszPath);
-
-    if(lpszFileName)
-      RtlMoveMemory(lpszPath, lpszFileName, strlen(lpszFileName)+1);
-}
-
-/*************************************************************************
- * PathStripPathW   [SHELLWAPI.@]
+        LPSTR lpszFileName = PathFindFileNameA(lpszPath);
+
+        TRACE("%s\n", lpszPath);
+
+        if(lpszFileName)
+          RtlMoveMemory(lpszPath, lpszFileName, strlen(lpszFileName)+1); 
+}
+
+/*************************************************************************
+ * PathStripPathW       [SHELLWAPI.@]
  */
 void WINAPI PathStripPathW(LPWSTR lpszPath)
 {
-    LPWSTR lpszFileName = PathFindFileNameW(lpszPath);
-
-    TRACE("%s\n", debugstr_w(lpszPath));
-    if(lpszFileName)
-      RtlMoveMemory(lpszPath, lpszFileName, (strlenW(lpszFileName)+1)*sizeof(WCHAR));
-}
-
-/*************************************************************************
- * PathStripToRootA [SHLWAPI.@]
+        LPWSTR lpszFileName = PathFindFileNameW(lpszPath);
+
+        TRACE("%s\n", debugstr_w(lpszPath));
+        if(lpszFileName)
+          RtlMoveMemory(lpszPath, lpszFileName, (strlenW(lpszFileName)+1)*sizeof(WCHAR)); 
+}
+
+/*************************************************************************
+ * PathStripToRootA     [SHLWAPI.@]
  */
 BOOL WINAPI PathStripToRootA(LPSTR lpszPath)
 {
-    TRACE("%s\n", lpszPath);
-
-    if (!lpszPath) return FALSE;
-    while(!PathIsRootA(lpszPath))
-      if (!PathRemoveFileSpecA(lpszPath)) return FALSE;
-    return TRUE;
-}
-
-/*************************************************************************
- * PathStripToRootW [SHLWAPI.@]
+        TRACE("%s\n", lpszPath);
+
+        if (!lpszPath) return FALSE;
+        while(!PathIsRootA(lpszPath))
+          if (!PathRemoveFileSpecA(lpszPath)) return FALSE;
+        return TRUE;
+}
+
+/*************************************************************************
+ * PathStripToRootW     [SHLWAPI.@]
  */
 BOOL WINAPI PathStripToRootW(LPWSTR lpszPath)
 {
-    TRACE("%s\n", debugstr_w(lpszPath));
-
-    if (!lpszPath) return FALSE;
-    while(!PathIsRootW(lpszPath))
-      if (!PathRemoveFileSpecW(lpszPath)) return FALSE;
-    return TRUE;
-}
-
-/*************************************************************************
- * PathRemoveArgsA  [SHLWAPI.@]
+        TRACE("%s\n", debugstr_w(lpszPath));
+
+        if (!lpszPath) return FALSE;
+        while(!PathIsRootW(lpszPath))
+          if (!PathRemoveFileSpecW(lpszPath)) return FALSE;
+        return TRUE;
+}
+
+/*************************************************************************
+ * PathRemoveArgsA      [SHLWAPI.@]
  *
  */
 void WINAPI PathRemoveArgsA(LPSTR lpszPath)
 {
-    TRACE("%s\n",lpszPath);
-
-    if(lpszPath)
-    {
-      LPSTR lpszArgs = PathGetArgsA(lpszPath);
-      if (!*lpszArgs)
-      {
-        LPSTR lpszLastChar = CharPrevA(lpszPath, lpszArgs);
-        if(*lpszLastChar==' ') *lpszLastChar = '\0';
-      }
-    }
-}
-
-/*************************************************************************
- * PathRemoveArgsW  [SHLWAPI.@]
+        TRACE("%s\n",lpszPath);
+        
+        if(lpszPath)
+        {
+          LPSTR lpszArgs = PathGetArgsA(lpszPath);
+          if (!*lpszArgs)
+          {
+            LPSTR lpszLastChar = CharPrevA(lpszPath, lpszArgs);
+            if(*lpszLastChar==' ') *lpszLastChar = '\0';
+          }
+        }
+}
+
+/*************************************************************************
+ * PathRemoveArgsW      [SHLWAPI.@]
  */
 void WINAPI PathRemoveArgsW(LPWSTR lpszPath)
 {
-    TRACE("%s\n", debugstr_w(lpszPath));
-
-    if(lpszPath)
-    {
-      LPWSTR lpszArgs = PathGetArgsW(lpszPath);
-      if (!*lpszArgs)
-      {
-        LPWSTR lpszLastChar = CharPrevW(lpszPath, lpszArgs);
-        if(*lpszLastChar==' ') *lpszLastChar = '\0';
-      }
-    }
-}
-
-/*************************************************************************
- * PathRemoveExtensionA     [SHLWAPI.@]
+        TRACE("%s\n", debugstr_w(lpszPath));
+
+        if(lpszPath)
+        {
+          LPWSTR lpszArgs = PathGetArgsW(lpszPath);
+          if (!*lpszArgs)
+          {
+            LPWSTR lpszLastChar = CharPrevW(lpszPath, lpszArgs);
+            if(*lpszLastChar==' ') *lpszLastChar = '\0';
+          }
+        }
+}
+
+/*************************************************************************
+ * PathRemoveExtensionA         [SHLWAPI.@]
  */
 void WINAPI PathRemoveExtensionA(LPSTR lpszPath)
 {
-    LPSTR lpszExtension = PathFindExtensionA(lpszPath);
-
-    TRACE("%s\n", lpszPath);
-
-    if (lpszExtension) *lpszExtension='\0';
-}
-
-/*************************************************************************
- * PathRemoveExtensionW     [SHLWAPI.@]
+        LPSTR lpszExtension = PathFindExtensionA(lpszPath);
+
+        TRACE("%s\n", lpszPath);
+
+        if (lpszExtension) *lpszExtension='\0';
+}
+
+/*************************************************************************
+ * PathRemoveExtensionW         [SHLWAPI.@]
  */
 void WINAPI PathRemoveExtensionW(LPWSTR lpszPath)
 {
-    LPWSTR lpszExtension = PathFindExtensionW(lpszPath);
-
-    TRACE("%s\n", debugstr_w(lpszPath));
-
-    if (lpszExtension) *lpszExtension='\0';
-}
-
-/*************************************************************************
- * PathRemoveBackslashA [SHLWAPI.@]
+        LPWSTR lpszExtension = PathFindExtensionW(lpszPath);
+
+        TRACE("%s\n", debugstr_w(lpszPath));
+
+        if (lpszExtension) *lpszExtension='\0';
+}
+
+/*************************************************************************
+ * PathRemoveBackslashA [SHLWAPI.@]
  *
  * If the path ends in a backslash it is replaced by a NULL
  * and the address of the NULL is returned
- * Otherwise
+ * Otherwise 
  * the address of the last character is returned.
  *
@@ -590 +589 @@
 LPSTR WINAPI PathRemoveBackslashA( LPSTR lpszPath )
 {
-    int len;
-    LPSTR szTemp = NULL;
-
-    if(lpszPath)
-    {
-      len = strlen(lpszPath);
-      szTemp = CharPrevA(lpszPath, lpszPath+len);
-      if (! PathIsRootA(lpszPath))
-      {
-        if (*szTemp == '\\') *szTemp = '\0';
-      }
-    }
-    return szTemp;
-}
-
-/*************************************************************************
- * PathRemoveBackslashW [SHLWAPI.@]
+        int len;
+        LPSTR szTemp = NULL;
+        
+        if(lpszPath)
+        {
+          len = strlen(lpszPath);
+          szTemp = CharPrevA(lpszPath, lpszPath+len);
+          if (! PathIsRootA(lpszPath))
+          {
+            if (*szTemp == '\\') *szTemp = '\0';
+          }
+        }
+        return szTemp;
+}
+
+/*************************************************************************
+ * PathRemoveBackslashW [SHLWAPI.@]
  */
 LPWSTR WINAPI PathRemoveBackslashW( LPWSTR lpszPath )
 {
-    int len;
-    LPWSTR szTemp = NULL;
-
-    if(lpszPath)
-    {
-      len = strlenW(lpszPath);
-      szTemp = CharPrevW(lpszPath, lpszPath+len);
-      if (! PathIsRootW(lpszPath))
-      {
-        if (*szTemp == '\\') *szTemp = '\0';
-      }
-    }
-    return szTemp;
+        int len;
+        LPWSTR szTemp = NULL;
+        
+        if(lpszPath)
+        {
+          len = strlenW(lpszPath);
+          szTemp = CharPrevW(lpszPath, lpszPath+len);
+          if (! PathIsRootW(lpszPath))
+          {
+            if (*szTemp == '\\') *szTemp = '\0';
+          }
+        }
+        return szTemp;
 }
 
 
 /*
-    Path Manipulations
+        Path Manipulations
 */
 
 /*************************************************************************
  * PathRemoveBlanksA [SHLWAPI.@]
- *
+ * 
  * NOTES
  *     remove spaces from beginning and end of passed string
@@ -638 +637 @@
 void WINAPI PathRemoveBlanksA(LPSTR str)
 {
-    LPSTR x = str;
-
-    TRACE("%s\n",str);
-
-    if(str)
-    {
-      while (*x==' ') x = CharNextA(x);
-      if (x!=str) strcpy(str,x);
-      x=str+strlen(str)-1;
-      while (*x==' ') x = CharPrevA(str, x);
-      if (*x==' ') *x='\0';
-    }
+        LPSTR x = str;
+
+        TRACE("%s\n",str);
+
+        if(str)
+        {
+          while (*x==' ') x = CharNextA(x);
+          if (x!=str) strcpy(str,x);
+          x=str+strlen(str)-1;
+          while (*x==' ') x = CharPrevA(str, x);
+          if (*x==' ') *x='\0';
+        }
 }
 
@@ -657 +656 @@
 void WINAPI PathRemoveBlanksW(LPWSTR str)
 {
-    LPWSTR x = str;
-
-    TRACE("%s\n",debugstr_w(str));
-
-    if(str)
-    {
-      while (*x==' ') x = CharNextW(x);
-      if (x!=str) strcpyW(str,x);
-      x=str+strlenW(str)-1;
-      while (*x==' ') x = CharPrevW(str, x);
-      if (*x==' ') *x='\0';
-    }
+        LPWSTR x = str;
+
+        TRACE("%s\n",debugstr_w(str));
+
+        if(str)
+        {
+          while (*x==' ') x = CharNextW(x);
+          if (x!=str) strcpyW(str,x);
+          x=str+strlenW(str)-1;
+          while (*x==' ') x = CharPrevW(str, x);
+          if (*x==' ') *x='\0';
+        }
 }
 
 /*************************************************************************
  * PathQuoteSpacesA [SHLWAPI.@]
- *
+ * 
  */
 LPSTR WINAPI PathQuoteSpacesA(LPSTR lpszPath)
 {
-    TRACE("%s\n",lpszPath);
-
-    if(StrChrA(lpszPath,' '))
-    {
-      int len = strlen(lpszPath);
-      RtlMoveMemory(lpszPath+1, lpszPath, len);
-      *(lpszPath++) = '"';
-      lpszPath += len;
-      *(lpszPath++) = '"';
-      *(lpszPath) = '\0';
-      return --lpszPath;
-    }
-    return 0;
+        TRACE("%s\n",lpszPath);
+
+        if(StrChrA(lpszPath,' '))
+        {
+          int len = strlen(lpszPath);
+          RtlMoveMemory(lpszPath+1, lpszPath, len);
+          *(lpszPath++) = '"';
+          lpszPath += len;
+          *(lpszPath++) = '"';
+          *(lpszPath) = '\0';
+          return --lpszPath;
+        }
+        return 0;
 }
 
@@ -697 +696 @@
 LPWSTR WINAPI PathQuoteSpacesW(LPWSTR lpszPath)
 {
-    TRACE("%s\n",debugstr_w(lpszPath));
-
-    if(StrChrW(lpszPath,' '))
-    {
-      int len = strlenW(lpszPath);
-      RtlMoveMemory(lpszPath+1, lpszPath, len*sizeof(WCHAR));
-      *(lpszPath++) = '"';
-      lpszPath += len;
-      *(lpszPath++) = '"';
-      *(lpszPath) = '\0';
-      return --lpszPath;
-    }
-    return 0;
+        TRACE("%s\n",debugstr_w(lpszPath));
+
+        if(StrChrW(lpszPath,' '))
+        {
+          int len = strlenW(lpszPath);
+          RtlMoveMemory(lpszPath+1, lpszPath, len*sizeof(WCHAR));
+          *(lpszPath++) = '"';
+          lpszPath += len;
+          *(lpszPath++) = '"';
+          *(lpszPath) = '\0';
+          return --lpszPath;
+        }
+        return 0;
 }
 
 /*************************************************************************
  * PathUnquoteSpacesA [SHLWAPI.@]
- *
+ * 
  * NOTES
  *     unquote string (remove ")
  */
-VOID WINAPI PathUnquoteSpacesA(LPSTR str)
-{
-    DWORD len = strlen(str);
-
-    TRACE("%s\n",str);
-
-    if (*str!='"')
-      return;
-    if (str[len-1]!='"')
-      return;
-    str[len-1]='\0';
-    strcpy(str,str+1);
-    return;
+VOID WINAPI PathUnquoteSpacesA(LPSTR str) 
+{
+        DWORD len = strlen(str);
+
+        TRACE("%s\n",str);
+
+        if (*str!='"')
+          return;
+        if (str[len-1]!='"')
+          return;
+        str[len-1]='\0';
+        strcpy(str,str+1);
+        return;
 }
 
@@ -736 +735 @@
  * PathUnquoteSpacesW [SHLWAPI.@]
  */
-VOID WINAPI PathUnquoteSpacesW(LPWSTR str)
-{
-    DWORD len = strlenW(str);
-
-    TRACE("%s\n",debugstr_w(str));
-
-    if (*str!='"')
-      return;
-    if (str[len-1]!='"')
-      return;
-    str[len-1]='\0';
-    strcpyW(str,str+1);
-    return;
-}
-
-/*************************************************************************
- * PathParseIconLocationA   [SHLWAPI.@]
+VOID WINAPI PathUnquoteSpacesW(LPWSTR str) 
+{
+        DWORD len = strlenW(str);
+
+        TRACE("%s\n",debugstr_w(str));
+
+        if (*str!='"')
+          return;
+        if (str[len-1]!='"')
+          return;
+        str[len-1]='\0';
+        strcpyW(str,str+1);
+        return;
+}
+
+/*************************************************************************
+ * PathParseIconLocationA       [SHLWAPI.@]
  */
 int WINAPI PathParseIconLocationA(LPSTR lpszPath)
 {
-    LPSTR lpstrComma = strchr(lpszPath, ',');
-
-    FIXME("%s stub\n", debugstr_a(lpszPath));
-
-    if (lpstrComma && lpstrComma[1])
-    {
-      lpstrComma[0]='\0';
-/*    return atoi(&lpstrComma[1]);  FIXME */
-    }
-
-    PathUnquoteSpacesA(lpszPath);
-    return 0;
-}
-
-/*************************************************************************
- * PathParseIconLocationW   [SHLWAPI.@]
+        LPSTR lpstrComma = strchr(lpszPath, ',');
+        
+        FIXME("%s stub\n", debugstr_a(lpszPath));
+
+        if (lpstrComma && lpstrComma[1])
+        {
+          lpstrComma[0]='\0';
+/*        return atoi(&lpstrComma[1]);  FIXME */
+        }
+        
+        PathUnquoteSpacesA(lpszPath);
+        return 0;
+}
+
+/*************************************************************************
+ * PathParseIconLocationW       [SHLWAPI.@]
  */
 int WINAPI PathParseIconLocationW(LPWSTR lpszPath)
 {
-    LPWSTR lpstrComma = strchrW(lpszPath, ',');
-
-    FIXME("%s stub\n", debugstr_w(lpszPath));
-
-    if (lpstrComma && lpstrComma[1])
-    {
-      lpstrComma[0]='\0';
-/*    return _wtoi(&lpstrComma[1]); FIXME */
-    }
-    PathUnquoteSpacesW(lpszPath);
-    return 0;
+        LPWSTR lpstrComma = strchrW(lpszPath, ',');
+        
+        FIXME("%s stub\n", debugstr_w(lpszPath));
+
+        if (lpstrComma && lpstrComma[1])
+        {
+          lpstrComma[0]='\0';
+/*        return _wtoi(&lpstrComma[1]); FIXME */
+        }
+        PathUnquoteSpacesW(lpszPath);
+        return 0;
 }
 
 /*
-    ########## cleaning and resolving paths ##########
- */
-
-/*************************************************************************
- * PathFindOnPathA  [SHLWAPI.@]
+        ########## cleaning and resolving paths ##########
+ */
+
+/*************************************************************************
+ * PathFindOnPathA      [SHLWAPI.@]
  */
 BOOL WINAPI PathFindOnPathA(LPSTR sFile, LPCSTR sOtherDirs)
 {
-    FIXME("%s %s\n",sFile, sOtherDirs);
-    return FALSE;
-}
-
-/*************************************************************************
- * PathFindOnPathW  [SHLWAPI.@]
+        FIXME("%s %s\n",sFile, sOtherDirs);
+        return FALSE;
+}
+
+/*************************************************************************
+ * PathFindOnPathW      [SHLWAPI.@]
  */
 BOOL WINAPI PathFindOnPathW(LPWSTR sFile, LPCWSTR sOtherDirs)
 {
-    FIXME("%s %s\n",debugstr_w(sFile), debugstr_w(sOtherDirs));
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathCompactPathExA   [SHLWAPI.@]
+        FIXME("%s %s\n",debugstr_w(sFile), debugstr_w(sOtherDirs));
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathCompactPathExA   [SHLWAPI.@]
  */
 BOOL WINAPI PathCompactPathExA(
-    LPSTR pszOut,
-    LPCSTR pszSrc,
-    UINT cchMax,
-    DWORD dwFlags)
-{
-    FIXME("%p %s 0x%08x 0x%08lx\n", pszOut, pszSrc, cchMax, dwFlags);
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathCompactPathExW   [SHLWAPI.@]
+        LPSTR pszOut,
+        LPCSTR pszSrc,
+        UINT cchMax,
+        DWORD dwFlags)
+{
+        FIXME("%p %s 0x%08x 0x%08lx\n", pszOut, pszSrc, cchMax, dwFlags);
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathCompactPathExW   [SHLWAPI.@]
  */
 BOOL WINAPI PathCompactPathExW(
-    LPWSTR pszOut,
-    LPCWSTR pszSrc,
-    UINT cchMax,
-    DWORD dwFlags)
-{
-    FIXME("%p %s 0x%08x 0x%08lx\n", pszOut, debugstr_w(pszSrc), cchMax, dwFlags);
-    return FALSE;
+        LPWSTR pszOut,
+        LPCWSTR pszSrc,
+        UINT cchMax,
+        DWORD dwFlags)
+{
+        FIXME("%p %s 0x%08x 0x%08lx\n", pszOut, debugstr_w(pszSrc), cchMax, dwFlags);
+        return FALSE;
 }
 
 /*
-    ########## Path Testing ##########
+        ########## Path Testing ##########
 */
 
 /*************************************************************************
- * PathIsUNCA       [SHLWAPI.@]
- *
+ * PathIsUNCA           [SHLWAPI.@]
+ * 
  * NOTES
  *     PathIsUNC(char*path);
  */
-BOOL WINAPI PathIsUNCA(LPCSTR lpszPath)
-{
-    TRACE("%s\n",lpszPath);
-
-    return (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'));
-}
-
-/*************************************************************************
- * PathIsUNCW       [SHLWAPI.@]
- */
-BOOL WINAPI PathIsUNCW(LPCWSTR lpszPath)
-{
-    TRACE("%s\n",debugstr_w(lpszPath));
-
-    return (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'));
-}
-
-/*************************************************************************
- *  PathIsRelativeA [SHLWAPI.@]
+BOOL WINAPI PathIsUNCA(LPCSTR lpszPath) 
+{
+        TRACE("%s\n",lpszPath);
+
+        return (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'));
+}
+
+/*************************************************************************
+ * PathIsUNCW           [SHLWAPI.@]
+ */
+BOOL WINAPI PathIsUNCW(LPCWSTR lpszPath) 
+{
+        TRACE("%s\n",debugstr_w(lpszPath));
+
+        return (lpszPath && (lpszPath[0]=='\\') && (lpszPath[1]=='\\'));
+}
+
+/*************************************************************************
+ *  PathIsRelativeA     [SHLWAPI.@]
  */
 BOOL WINAPI PathIsRelativeA (LPCSTR lpszPath)
 {
-    TRACE("lpszPath=%s\n",lpszPath);
-
-    return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
-}
-
-/*************************************************************************
- *  PathIsRelativeW [SHLWAPI.@]
+        TRACE("lpszPath=%s\n",lpszPath);
+
+        return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
+}
+
+/*************************************************************************
+ *  PathIsRelativeW     [SHLWAPI.@]
  */
 BOOL WINAPI PathIsRelativeW (LPCWSTR lpszPath)
 {
-    TRACE("lpszPath=%s\n",debugstr_w(lpszPath));
-
-    return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
-}
-
-/*************************************************************************
- * PathIsRootA      [SHLWAPI.@]
+        TRACE("lpszPath=%s\n",debugstr_w(lpszPath));
+
+        return (lpszPath && (lpszPath[0]!='\\' && lpszPath[1]!=':'));
+}
+
+/*************************************************************************
+ * PathIsRootA          [SHLWAPI.@]
  *
  * notes
@@ -891 +890 @@
 BOOL WINAPI PathIsRootA(LPCSTR lpszPath)
 {
-    TRACE("%s\n",lpszPath);
-
-    /* X:\ */
-    if (lpszPath[1]==':' && lpszPath[2]=='\\' && lpszPath[3]=='\0')
-      return TRUE;
-
-    /* "\" */
-    if (lpszPath[0]=='\\' && lpszPath[1]=='\0')
-      return TRUE;
-
-    /* UNC "\\<computer>\<share>" */
-    if (lpszPath[0]=='\\' && lpszPath[1]=='\\')
-    {
-      int foundbackslash = 0;
-      lpszPath += 2;
-      while (*lpszPath)
-      {
-        if (*lpszPath=='\\') foundbackslash++;
-        lpszPath = CharNextA(lpszPath);
-      }
-      if (foundbackslash <= 1)
-        return TRUE;
-    }
-    return FALSE;
-}
-
-/*************************************************************************
- * PathIsRootW      [SHLWAPI.@]
- */
-BOOL WINAPI PathIsRootW(LPCWSTR lpszPath)
-{
-    TRACE("%s\n",debugstr_w(lpszPath));
-
-    /* X:\ */
-    if (lpszPath[1]==':' && lpszPath[2]=='\\' && lpszPath[3]=='\0')
-      return TRUE;
-
-    /* "\" */
-    if (lpszPath[0]=='\\' && lpszPath[1]=='\0')
-      return TRUE;
-
-    /* UNC "\\<computer>\<share>" */
-    if (lpszPath[0]=='\\' && lpszPath[1]=='\\')
-    {
-      int foundbackslash = 0;
-      lpszPath += 2;
-      while (*lpszPath)
-      {
-        if (*lpszPath=='\\') foundbackslash++;
-        lpszPath = CharNextW(lpszPath);
-      }
-      if (foundbackslash <= 1)
-        return TRUE;
-    }
-    return FALSE;
-
-}
-
-/*************************************************************************
- * PathIsDirectoryA [SHLWAPI.@]
+        TRACE("%s\n",lpszPath);
+
+        /* X:\ */
+        if (lpszPath[1]==':' && lpszPath[2]=='\\' && lpszPath[3]=='\0')
+          return TRUE;
+
+        /* "\" */
+        if (lpszPath[0]=='\\' && lpszPath[1]=='\0')
+          return TRUE;
+
+        /* UNC "\\<computer>\<share>" */
+        if (lpszPath[0]=='\\' && lpszPath[1]=='\\')             
+        {
+          int foundbackslash = 0;
+          lpszPath += 2;
+          while (*lpszPath)
+          {
+            if (*lpszPath=='\\') foundbackslash++;
+            lpszPath = CharNextA(lpszPath);
+          }
+          if (foundbackslash <= 1)
+            return TRUE;
+        }
+        return FALSE;
+}
+
+/*************************************************************************
+ * PathIsRootW          [SHLWAPI.@]
+ */
+BOOL WINAPI PathIsRootW(LPCWSTR lpszPath) 
+{
+        TRACE("%s\n",debugstr_w(lpszPath));
+
+        /* X:\ */
+        if (lpszPath[1]==':' && lpszPath[2]=='\\' && lpszPath[3]=='\0')
+          return TRUE;
+
+        /* "\" */
+        if (lpszPath[0]=='\\' && lpszPath[1]=='\0')
+          return TRUE;
+
+        /* UNC "\\<computer>\<share>" */
+        if (lpszPath[0]=='\\' && lpszPath[1]=='\\')             
+        {
+          int foundbackslash = 0;
+          lpszPath += 2;
+          while (*lpszPath)
+          {
+            if (*lpszPath=='\\') foundbackslash++;
+            lpszPath = CharNextW(lpszPath);
+          }
+          if (foundbackslash <= 1)
+            return TRUE;
+        }
+        return FALSE;
+
+}
+
+/*************************************************************************
+ * PathIsDirectoryA     [SHLWAPI.@]
  */
 BOOL WINAPI PathIsDirectoryA(LPCSTR lpszPath)
 {
-    DWORD dwAttr;
-
-    TRACE("%s\n", debugstr_a(lpszPath));
-
-    dwAttr = GetFileAttributesA(lpszPath);
-    return  (dwAttr != -1) ? dwAttr & FILE_ATTRIBUTE_DIRECTORY : 0;
-}
-
-/*************************************************************************
- * PathIsDirectoryW [SHLWAPI.@]
+        DWORD dwAttr;
+
+        TRACE("%s\n", debugstr_a(lpszPath));
+
+        dwAttr = GetFileAttributesA(lpszPath);
+        return  (dwAttr != -1) ? dwAttr & FILE_ATTRIBUTE_DIRECTORY : 0;
+}
+
+/*************************************************************************
+ * PathIsDirectoryW     [SHLWAPI.@]
  */
 BOOL WINAPI PathIsDirectoryW(LPCWSTR lpszPath)
 {
-    DWORD dwAttr;
-
-    TRACE("%s\n", debugstr_w(lpszPath));
-
-    dwAttr = GetFileAttributesW(lpszPath);
-    return  (dwAttr != -1) ? dwAttr & FILE_ATTRIBUTE_DIRECTORY : 0;
-}
-
-/*************************************************************************
- * PathFileExistsA  [SHLWAPI.@]
- *
+        DWORD dwAttr;
+        
+        TRACE("%s\n", debugstr_w(lpszPath));
+
+        dwAttr = GetFileAttributesW(lpszPath);
+        return  (dwAttr != -1) ? dwAttr & FILE_ATTRIBUTE_DIRECTORY : 0;
+}
+
+/*************************************************************************
+ * PathFileExistsA      [SHLWAPI.@]
+ * 
  * NOTES
  *     file_exists(char *fn);
  */
-BOOL WINAPI PathFileExistsA(LPCSTR lpszPath)
-{
-    TRACE("%s\n",lpszPath);
-    return  (GetFileAttributesA(lpszPath)!=-1);
-}
-
-/*************************************************************************
- * PathFileExistsW  [SHLWAPI.@]
- */
-BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath)
-{
-    TRACE("%s\n",debugstr_w(lpszPath));
-    return  (GetFileAttributesW(lpszPath)!=-1);
-}
-
-/*************************************************************************
- * PathMatchSingleMaskA [internal]
- *
+BOOL WINAPI PathFileExistsA(LPCSTR lpszPath) 
+{
+        TRACE("%s\n",lpszPath);
+        return  (GetFileAttributesA(lpszPath)!=-1);
+}
+
+/*************************************************************************
+ * PathFileExistsW      [SHLWAPI.@]
+ */
+BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath) 
+{
+        TRACE("%s\n",debugstr_w(lpszPath));
+        return  (GetFileAttributesW(lpszPath)!=-1);
+}
+
+/*************************************************************************
+ * PathMatchSingleMaskA [internal]
+ * 
  * NOTES
  *     internal (used by PathMatchSpec)
@@ -1004 +1003 @@
 static BOOL PathMatchSingleMaskA(LPCSTR name, LPCSTR mask)
 {
-    while (*name && *mask && *mask!=';')
-    {
-      if (*mask=='*')
-      {
-        do
-        {
-          if (PathMatchSingleMaskA(name,mask+1)) return 1;  /* try substrings */
-        } while (*name++);
-        return 0;
-      }
-      if (toupper(*mask)!=toupper(*name) && *mask!='?') return 0;
-      name = CharNextA(name);
-      mask = CharNextA(mask);
-    }
-    if (!*name)
-    {
-      while (*mask=='*') mask++;
-      if (!*mask || *mask==';') return 1;
-    }
-    return 0;
-}
-
-/*************************************************************************
- * PathMatchSingleMaskW [internal]
+        while (*name && *mask && *mask!=';') 
+        {
+          if (*mask=='*') 
+          {
+            do 
+            {
+              if (PathMatchSingleMaskA(name,mask+1)) return 1;  /* try substrings */
+            } while (*name++);
+            return 0;
+          }
+          if (toupper(*mask)!=toupper(*name) && *mask!='?') return 0;
+          name = CharNextA(name);
+          mask = CharNextA(mask);
+        }
+        if (!*name) 
+        {
+          while (*mask=='*') mask++;
+          if (!*mask || *mask==';') return 1;
+        }
+        return 0;
+}
+
+/*************************************************************************
+ * PathMatchSingleMaskW [internal]
  */
 static BOOL PathMatchSingleMaskW(LPCWSTR name, LPCWSTR mask)
 {
-    while (*name && *mask && *mask!=';')
-    {
-      if (*mask=='*')
-      {
-        do
-        {
-          if (PathMatchSingleMaskW(name,mask+1)) return 1;  /* try substrings */
-        } while (*name++);
-        return 0;
-      }
-      if (toupperW(*mask)!=toupperW(*name) && *mask!='?') return 0;
-      name = CharNextW(name);
-      mask = CharNextW(mask);
-    }
-    if (!*name)
-    {
-      while (*mask=='*') mask++;
-      if (!*mask || *mask==';') return 1;
-    }
-    return 0;
-}
-/*************************************************************************
- * PathMatchSpecA   [SHLWAPI.@]
- *
+        while (*name && *mask && *mask!=';') 
+        {
+          if (*mask=='*') 
+          {
+            do 
+            {
+              if (PathMatchSingleMaskW(name,mask+1)) return 1;  /* try substrings */
+            } while (*name++);
+            return 0;
+          }
+          if (toupperW(*mask)!=toupperW(*name) && *mask!='?') return 0;
+          name = CharNextW(name);
+          mask = CharNextW(mask);
+        }
+        if (!*name) 
+        {
+          while (*mask=='*') mask++;
+          if (!*mask || *mask==';') return 1;
+        }
+        return 0;
+}
+/*************************************************************************
+ * PathMatchSpecA       [SHLWAPI.@]
+ * 
  * NOTES
  *     used from COMDLG32
  */
-BOOL WINAPI PathMatchSpecA(LPCSTR name, LPCSTR mask)
-{
-    TRACE("%s %s\n",name,mask);
-
-    if (!lstrcmpA( mask, "*.*" )) return 1;   /* we don't require a period */
-
-    while (*mask)
-    {
-      if (PathMatchSingleMaskA(name,mask)) return 1;    /* helper function */
-      while (*mask && *mask!=';') mask = CharNextA(mask);
-      if (*mask==';')
-      {
-        mask++;
-        while (*mask==' ') mask++;      /*  masks may be separated by "; " */
-      }
-    }
-    return 0;
-}
-
-/*************************************************************************
- * PathMatchSpecW   [SHLWAPI.@]
- */
-BOOL WINAPI PathMatchSpecW(LPCWSTR name, LPCWSTR mask)
+BOOL WINAPI PathMatchSpecA(LPCSTR name, LPCSTR mask) 
+{
+        TRACE("%s %s\n",name,mask);
+
+        if (!lstrcmpA( mask, "*.*" )) return 1;   /* we don't require a period */
+
+        while (*mask) 
+        {
+          if (PathMatchSingleMaskA(name,mask)) return 1;    /* helper function */
+          while (*mask && *mask!=';') mask = CharNextA(mask);
+          if (*mask==';') 
+          {
+            mask++;
+            while (*mask==' ') mask++;      /*  masks may be separated by "; " */
+          }
+        }
+        return 0;
+}
+
+/*************************************************************************
+ * PathMatchSpecW       [SHLWAPI.@]
+ */
+BOOL WINAPI PathMatchSpecW(LPCWSTR name, LPCWSTR mask) 
 {
     static const WCHAR stemp[] = { '*','.','*',0 };
-    TRACE("%s %s\n",debugstr_w(name),debugstr_w(mask));
-
-    if (!lstrcmpW( mask, stemp )) return 1;   /* we don't require a period */
-
-    while (*mask)
-    {
-      if (PathMatchSingleMaskW(name,mask)) return 1;    /* helper function */
-      while (*mask && *mask!=';') mask = CharNextW(mask);
-      if (*mask==';')
-      {
-        mask++;
-        while (*mask==' ') mask++;       /* masks may be separated by "; " */
-      }
-    }
-    return 0;
-}
-
-/*************************************************************************
- * PathIsSameRootA  [SHLWAPI.@]
+        TRACE("%s %s\n",debugstr_w(name),debugstr_w(mask));
+
+        if (!lstrcmpW( mask, stemp )) return 1;   /* we don't require a period */
+
+        while (*mask) 
+        {
+          if (PathMatchSingleMaskW(name,mask)) return 1;    /* helper function */
+          while (*mask && *mask!=';') mask = CharNextW(mask);
+          if (*mask==';') 
+          {
+            mask++;
+            while (*mask==' ') mask++;       /* masks may be separated by "; " */
+          }
+        }
+        return 0;
+}
+
+/*************************************************************************
+ * PathIsSameRootA      [SHLWAPI.@]
  *
  * FIXME
@@ -1108 +1107 @@
 BOOL WINAPI PathIsSameRootA(LPCSTR lpszPath1, LPCSTR lpszPath2)
 {
-    TRACE("%s %s\n", lpszPath1, lpszPath2);
-
-    if (PathIsRelativeA(lpszPath1) || PathIsRelativeA(lpszPath2)) return FALSE;
-
-    /* usual path */
-    if ( toupper(lpszPath1[0])==toupper(lpszPath2[0]) &&
-         lpszPath1[1]==':' && lpszPath2[1]==':' &&
-         lpszPath1[2]=='\\' && lpszPath2[2]=='\\')
-      return TRUE;
-
-    /* UNC */
-    if (lpszPath1[0]=='\\' && lpszPath2[0]=='\\' &&
-        lpszPath1[1]=='\\' && lpszPath2[1]=='\\')
-    {
-      int pos=2, bsfound=0;
-      while (lpszPath1[pos] && lpszPath2[pos] &&
-            (lpszPath1[pos] == lpszPath2[pos]))
-      {
-        if (lpszPath1[pos]=='\\') bsfound++;
-        if (bsfound == 2) return TRUE;
-        pos++; /* fixme: use CharNext*/
-      }
-      return (lpszPath1[pos] == lpszPath2[pos]);
-    }
-    return FALSE;
-}
-
-/*************************************************************************
- * PathIsSameRootW  [SHLWAPI.@]
+        TRACE("%s %s\n", lpszPath1, lpszPath2);
+        
+        if (PathIsRelativeA(lpszPath1) || PathIsRelativeA(lpszPath2)) return FALSE;
+
+        /* usual path */
+        if ( toupper(lpszPath1[0])==toupper(lpszPath2[0]) &&
+             lpszPath1[1]==':' && lpszPath2[1]==':' &&
+             lpszPath1[2]=='\\' && lpszPath2[2]=='\\')
+          return TRUE;
+
+        /* UNC */
+        if (lpszPath1[0]=='\\' && lpszPath2[0]=='\\' &&
+            lpszPath1[1]=='\\' && lpszPath2[1]=='\\')
+        {
+          int pos=2, bsfound=0;
+          while (lpszPath1[pos] && lpszPath2[pos] &&
+                (lpszPath1[pos] == lpszPath2[pos]))
+          {
+            if (lpszPath1[pos]=='\\') bsfound++;
+            if (bsfound == 2) return TRUE;
+            pos++; /* fixme: use CharNext*/
+          }
+          return (lpszPath1[pos] == lpszPath2[pos]);
+        }
+        return FALSE;
+}
+
+/*************************************************************************
+ * PathIsSameRootW      [SHLWAPI.@]
  */
 BOOL WINAPI PathIsSameRootW(LPCWSTR lpszPath1, LPCWSTR lpszPath2)
 {
-    TRACE("%s %s\n", debugstr_w(lpszPath1), debugstr_w(lpszPath2));
-
-    if (PathIsRelativeW(lpszPath1) || PathIsRelativeW(lpszPath2)) return FALSE;
-
-    /* usual path */
-    if ( toupperW(lpszPath1[0])==toupperW(lpszPath2[0]) &&
-         lpszPath1[1]==':' && lpszPath2[1]==':' &&
-         lpszPath1[2]=='\\' && lpszPath2[2]=='\\')
-      return TRUE;
-
-    /* UNC */
-    if (lpszPath1[0]=='\\' && lpszPath2[0]=='\\' &&
-        lpszPath1[1]=='\\' && lpszPath2[1]=='\\')
-    {
-      int pos=2, bsfound=0;
-      while (lpszPath1[pos] && lpszPath2[pos] &&
-            (lpszPath1[pos] == lpszPath2[pos]))
-      {
-        if (lpszPath1[pos]=='\\') bsfound++;
-        if (bsfound == 2) return TRUE;
-        pos++;/* fixme: use CharNext*/
-      }
-      return (lpszPath1[pos] == lpszPath2[pos]);
-    }
-    return FALSE;
+        TRACE("%s %s\n", debugstr_w(lpszPath1), debugstr_w(lpszPath2));
+        
+        if (PathIsRelativeW(lpszPath1) || PathIsRelativeW(lpszPath2)) return FALSE;
+
+        /* usual path */
+        if ( toupperW(lpszPath1[0])==toupperW(lpszPath2[0]) &&
+             lpszPath1[1]==':' && lpszPath2[1]==':' &&
+             lpszPath1[2]=='\\' && lpszPath2[2]=='\\')
+          return TRUE;
+
+        /* UNC */
+        if (lpszPath1[0]=='\\' && lpszPath2[0]=='\\' &&
+            lpszPath1[1]=='\\' && lpszPath2[1]=='\\')
+        {
+          int pos=2, bsfound=0;
+          while (lpszPath1[pos] && lpszPath2[pos] &&
+                (lpszPath1[pos] == lpszPath2[pos]))
+          {
+            if (lpszPath1[pos]=='\\') bsfound++;
+            if (bsfound == 2) return TRUE;
+            pos++;/* fixme: use CharNext*/
+          }
+          return (lpszPath1[pos] == lpszPath2[pos]);
+        }
+        return FALSE;
 }
 
@@ -1180 +1179 @@
   // DWORD dwUnknown = SHREG_xxx; // 0x18
   // return SHLWAPI_1(lpstrPath, &dwUnknown);
-
-
-    LPSTR lpstrRes;
-    int iSize, i=0;
-    static LPSTR SupportedProtocol[] =
-      {"http","https","ftp","gopher","file","mailto",NULL};
-
-    if(!lpstrPath) return FALSE;
-
-    /* get protocol        */
-    lpstrRes = strchr(lpstrPath,':');
-    if(!lpstrRes) return FALSE;
-    iSize = lpstrRes - lpstrPath;
-
-    while(SupportedProtocol[i])
-    {
-      if (iSize == strlen(SupportedProtocol[i]))
-        if(!strncasecmp(lpstrPath, SupportedProtocol[i], iSize))
-          return TRUE;
-      i++;
-    }
-
-    return FALSE;
-}
+  
+  
+        LPSTR lpstrRes;
+        int iSize, i=0;
+        static LPSTR SupportedProtocol[] = 
+          {"http","https","ftp","gopher","file","mailto",NULL};
+
+        if(!lpstrPath) return FALSE;
+
+        /* get protocol        */
+        lpstrRes = strchr(lpstrPath,':');
+        if(!lpstrRes) return FALSE;
+        iSize = lpstrRes - lpstrPath;
+
+        while(SupportedProtocol[i])
+        {
+          if (iSize == strlen(SupportedProtocol[i]))
+            if(!strncasecmp(lpstrPath, SupportedProtocol[i], iSize))
+              return TRUE;
+          i++;
+        }
+
+        return FALSE;
+}  
 
 /*************************************************************************
@@ -1210 +1209 @@
 BOOL WINAPI PathIsURLW(LPCWSTR lpstrPath)
 {
-    LPWSTR lpstrRes;
-    int iSize, i=0;
-    static WCHAR SupportedProtocol[7][7] =
-      {{'h','t','t','p','\0'},{'h','t','t','p','s','\0'},{'f','t','p','\0'},
-      {'g','o','p','h','e','r','\0'},{'f','i','l','e','\0'},
-      {'m','a','i','l','t','o','\0'},{0}};
-
-    if(!lpstrPath) return FALSE;
-
-    /* get protocol        */
-    lpstrRes = strchrW(lpstrPath,':');
-    if(!lpstrRes) return FALSE;
-    iSize = lpstrRes - lpstrPath;
-
-    while(SupportedProtocol[i])
-    {
-      if (iSize == strlenW(SupportedProtocol[i]))
-        if(!strncmpiW(lpstrPath, SupportedProtocol[i], iSize))
-          return TRUE;
-      i++;
-    }
-
-    return FALSE;
-}
-
-
-/*************************************************************************
- *  PathIsContentTypeA   [SHLWAPI.@]
+        LPWSTR lpstrRes;
+        int iSize, i=0;
+        static WCHAR SupportedProtocol[7][7] = 
+          {{'h','t','t','p','\0'},{'h','t','t','p','s','\0'},{'f','t','p','\0'},
+          {'g','o','p','h','e','r','\0'},{'f','i','l','e','\0'},
+          {'m','a','i','l','t','o','\0'},{0}};
+
+        if(!lpstrPath) return FALSE;
+
+        /* get protocol        */
+        lpstrRes = strchrW(lpstrPath,':');
+        if(!lpstrRes) return FALSE;
+        iSize = lpstrRes - lpstrPath;
+
+        while(SupportedProtocol[i])
+        {
+          if (iSize == strlenW(SupportedProtocol[i]))
+            if(!strncmpiW(lpstrPath, SupportedProtocol[i], iSize))
+              return TRUE;
+          i++;
+        }
+
+        return FALSE;
+}  
+
+
+/*************************************************************************
+ *      PathIsContentTypeA   [SHLWAPI.@]
  */
 BOOL WINAPI PathIsContentTypeA(LPCSTR pszPath, LPCSTR pszContentType)
 {
-    FIXME("%s %s\n", pszPath, pszContentType);
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathIsContentTypeW   [SHLWAPI.@]
+        FIXME("%s %s\n", pszPath, pszContentType);
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathIsContentTypeW   [SHLWAPI.@]
  */
 BOOL WINAPI PathIsContentTypeW(LPCWSTR pszPath, LPCWSTR pszContentType)
 {
-    FIXME("%s %s\n", debugstr_w(pszPath), debugstr_w(pszContentType));
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathIsFileSpecA   [SHLWAPI.@]
+        FIXME("%s %s\n", debugstr_w(pszPath), debugstr_w(pszContentType));
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathIsFileSpecA   [SHLWAPI.@]
  */
 BOOL WINAPI PathIsFileSpecA(LPCSTR pszPath)
 {
-    FIXME("%s\n", pszPath);
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathIsFileSpecW   [SHLWAPI.@]
+        FIXME("%s\n", pszPath);
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathIsFileSpecW   [SHLWAPI.@]
  */
 BOOL WINAPI PathIsFileSpecW(LPCWSTR pszPath)
 {
-    FIXME("%s\n", debugstr_w(pszPath));
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathIsPrefixA   [SHLWAPI.@]
+        FIXME("%s\n", debugstr_w(pszPath));
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathIsPrefixA   [SHLWAPI.@]
  */
 BOOL WINAPI PathIsPrefixA(LPCSTR pszPrefix, LPCSTR pszPath)
 {
-    FIXME("%s %s\n", pszPrefix, pszPath);
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathIsPrefixW   [SHLWAPI.@]
+        FIXME("%s %s\n", pszPrefix, pszPath);
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathIsPrefixW   [SHLWAPI.@]
  */
 BOOL WINAPI PathIsPrefixW(LPCWSTR pszPrefix, LPCWSTR pszPath)
 {
-    FIXME("%s %s\n", debugstr_w(pszPrefix), debugstr_w(pszPath));
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathIsSystemFolderA   [SHLWAPI.@]
+        FIXME("%s %s\n", debugstr_w(pszPrefix), debugstr_w(pszPath));
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathIsSystemFolderA   [SHLWAPI.@]
  */
 BOOL WINAPI PathIsSystemFolderA(LPCSTR pszPath, DWORD dwAttrb)
 {
-    FIXME("%s 0x%08lx\n", pszPath, dwAttrb);
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathIsSystemFolderW   [SHLWAPI.@]
+        FIXME("%s 0x%08lx\n", pszPath, dwAttrb);
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathIsSystemFolderW   [SHLWAPI.@]
  */
 BOOL WINAPI PathIsSystemFolderW(LPCWSTR pszPath, DWORD dwAttrb)
 {
-    FIXME("%s 0x%08lx\n", debugstr_w(pszPath), dwAttrb);
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathIsUNCServerA   [SHLWAPI.@]
+        FIXME("%s 0x%08lx\n", debugstr_w(pszPath), dwAttrb);
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathIsUNCServerA   [SHLWAPI.@]
  */
 BOOL WINAPI PathIsUNCServerA(
-    LPCSTR pszPath)
-{
-    FIXME("%s\n", pszPath);
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathIsUNCServerW   [SHLWAPI.@]
+        LPCSTR pszPath)
+{
+        FIXME("%s\n", pszPath);
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathIsUNCServerW   [SHLWAPI.@]
  */
 BOOL WINAPI PathIsUNCServerW(
-    LPCWSTR pszPath)
-{
-    FIXME("%s\n", debugstr_w(pszPath));
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathIsUNCServerShareA   [SHLWAPI.@]
+        LPCWSTR pszPath)
+{
+        FIXME("%s\n", debugstr_w(pszPath));
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathIsUNCServerShareA   [SHLWAPI.@]
  */
 BOOL WINAPI PathIsUNCServerShareA(
-    LPCSTR pszPath)
-{
-    FIXME("%s\n", pszPath);
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathIsUNCServerShareW   [SHLWAPI.@]
+        LPCSTR pszPath)
+{
+        FIXME("%s\n", pszPath);
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathIsUNCServerShareW   [SHLWAPI.@]
  */
 BOOL WINAPI PathIsUNCServerShareW(
-    LPCWSTR pszPath)
-{
-    FIXME("%s\n", debugstr_w(pszPath));
-    return FALSE;
+        LPCWSTR pszPath)
+{
+        FIXME("%s\n", debugstr_w(pszPath));
+        return FALSE;
 }
 
@@ -1354 +1353 @@
  *   returnvalue, use CharNext
  */
-
+ 
 BOOL WINAPI PathCanonicalizeA(LPSTR pszBuf, LPCSTR pszPath)
 {
-    int OffsetMin = 0, OffsetSrc = 0, OffsetDst = 0, LenSrc = strlen(pszPath);
-    BOOL bModifyed = FALSE;
-
-    TRACE("%p %s\n", pszBuf, pszPath);
-
-    pszBuf[OffsetDst]='\0';
-
-    /* keep the root of the path */
-    if( LenSrc && (pszPath[OffsetSrc]=='\\'))
-    {
-      pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
-    }
-    else if ( (LenSrc >= 2) && (pszPath[OffsetSrc+1] == ':'))
-    {
-      pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
-      pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
-      if (LenSrc && (pszPath[OffsetSrc] == '\\'))
-      {
-        pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
-        if (LenSrc == 1 && pszPath[OffsetSrc]=='.')
-        {
-          /* C:\. */
-          OffsetSrc++; LenSrc--; bModifyed = TRUE;
-        }
-        else if (LenSrc == 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='.')
-        {
-          /* C:\.. */
-          OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
-        }
+        int OffsetMin = 0, OffsetSrc = 0, OffsetDst = 0, LenSrc = strlen(pszPath);
+        BOOL bModifyed = FALSE;
+
+        TRACE("%p %s\n", pszBuf, pszPath);
+        
+        pszBuf[OffsetDst]='\0';
+
+        /* keep the root of the path */
+        if( LenSrc && (pszPath[OffsetSrc]=='\\'))
+        {
+          pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
+        }
+        else if ( (LenSrc >= 2) && (pszPath[OffsetSrc+1] == ':'))
+        {
+          pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
+          pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
+          if (LenSrc && (pszPath[OffsetSrc] == '\\'))
+          {
+            pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
+            if (LenSrc == 1 && pszPath[OffsetSrc]=='.')
+            {
+              /* C:\. */
+              OffsetSrc++; LenSrc--; bModifyed = TRUE;
+            } 
+            else if (LenSrc == 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='.')
+            {
+              /* C:\.. */
+              OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
+            } 
           }
-    }
-
-    /* ".\" at the beginning of the path */
-    if (LenSrc >= 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='\\')
-    {
-      OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
-    }
-
-    while ( LenSrc )
-    {
-      if((LenSrc>=3) && (pszPath[OffsetSrc]=='\\') && (pszPath[OffsetSrc+1]=='.') && (pszPath[OffsetSrc+2]=='.'))
-      {
-        /* "\.." found, go one deeper */
-        while((OffsetDst > OffsetMin) && (pszBuf[OffsetDst]!='\\')) OffsetDst--;
-        OffsetSrc += 3; LenSrc -= 3; bModifyed = TRUE;
-        if(OffsetDst == OffsetMin && pszPath[OffsetSrc]=='\\') OffsetSrc++;
-        pszBuf[OffsetDst] = '\0';           /* important for \..\.. */
-      }
-      else if(LenSrc>=2 && pszPath[OffsetSrc]=='\\' && pszPath[OffsetSrc+1]=='.' )
-      {
-        /* "\." found, skip it */
-        OffsetSrc += 2; LenSrc-=2; bModifyed = TRUE;
-      }
-      else
-      {
-        pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; LenSrc--;
-      }
-    }
-    pszBuf[OffsetDst] = '\0';
-    TRACE("-- %s %u\n", pszBuf, bModifyed);
-    return bModifyed;
+        }
+        
+        /* ".\" at the beginning of the path */
+        if (LenSrc >= 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='\\')
+        {
+          OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
+        } 
+        
+        while ( LenSrc )
+        {
+          if((LenSrc>=3) && (pszPath[OffsetSrc]=='\\') && (pszPath[OffsetSrc+1]=='.') && (pszPath[OffsetSrc+2]=='.'))
+          {
+            /* "\.." found, go one deeper */
+            while((OffsetDst > OffsetMin) && (pszBuf[OffsetDst]!='\\')) OffsetDst--;
+            OffsetSrc += 3; LenSrc -= 3; bModifyed = TRUE;
+            if(OffsetDst == OffsetMin && pszPath[OffsetSrc]=='\\') OffsetSrc++;
+            pszBuf[OffsetDst] = '\0';                   /* important for \..\.. */
+          }
+          else if(LenSrc>=2 && pszPath[OffsetSrc]=='\\' && pszPath[OffsetSrc+1]=='.' )
+          {
+            /* "\." found, skip it */
+            OffsetSrc += 2; LenSrc-=2; bModifyed = TRUE;
+          }
+          else
+          {
+            pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; LenSrc--;
+          }
+        }
+        pszBuf[OffsetDst] = '\0';
+        TRACE("-- %s %u\n", pszBuf, bModifyed);
+        return bModifyed;
 }
 
@@ -1429 +1428 @@
 BOOL WINAPI PathCanonicalizeW(LPWSTR pszBuf, LPCWSTR pszPath)
 {
-    int OffsetMin = 0, OffsetSrc = 0, OffsetDst = 0, LenSrc = strlenW(pszPath);
-    BOOL bModifyed = FALSE;
-
-    TRACE("%p %s\n", pszBuf, debugstr_w(pszPath));
-
-    pszBuf[OffsetDst]='\0';
-
-    /* keep the root of the path */
-    if( LenSrc && (pszPath[OffsetSrc]=='\\'))
-    {
-      pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
-    }
-    else if ( (LenSrc >= 2) && (pszPath[OffsetSrc+1] == ':'))
-    {
-      pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
-      pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
-      if (LenSrc && (pszPath[OffsetSrc] == '\\'))
-      {
-        pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
-        if (LenSrc == 1 && pszPath[OffsetSrc]=='.')
-        {
-          /* C:\. */
-          OffsetSrc++; LenSrc--; bModifyed = TRUE;
-        }
-        else if (LenSrc == 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='.')
-        {
-          /* C:\.. */
-          OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
-        }
+        int OffsetMin = 0, OffsetSrc = 0, OffsetDst = 0, LenSrc = strlenW(pszPath);
+        BOOL bModifyed = FALSE;
+
+        TRACE("%p %s\n", pszBuf, debugstr_w(pszPath));
+        
+        pszBuf[OffsetDst]='\0';
+
+        /* keep the root of the path */
+        if( LenSrc && (pszPath[OffsetSrc]=='\\'))
+        {
+          pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
+        }
+        else if ( (LenSrc >= 2) && (pszPath[OffsetSrc+1] == ':'))
+        {
+          pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
+          pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
+          if (LenSrc && (pszPath[OffsetSrc] == '\\'))
+          {
+            pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; OffsetMin++; LenSrc--;
+            if (LenSrc == 1 && pszPath[OffsetSrc]=='.')
+            {
+              /* C:\. */
+              OffsetSrc++; LenSrc--; bModifyed = TRUE;
+            } 
+            else if (LenSrc == 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='.')
+            {
+              /* C:\.. */
+              OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
+            } 
           }
-    }
-
-    /* ".\" at the beginning of the path */
-    if (LenSrc >= 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='\\')
-    {
-      OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
-    }
-
-    while ( LenSrc )
-    {
-      if((LenSrc>=3) && (pszPath[OffsetSrc]=='\\') && (pszPath[OffsetSrc+1]=='.') && (pszPath[OffsetSrc+2]=='.'))
-      {
-        /* "\.." found, go one deeper */
-        while((OffsetDst > OffsetMin) && (pszBuf[OffsetDst]!='\\')) OffsetDst--;
-        OffsetSrc += 3; LenSrc -= 3; bModifyed = TRUE;
-        if(OffsetDst == OffsetMin && pszPath[OffsetSrc]=='\\') OffsetSrc++;
-        pszBuf[OffsetDst] = '\0';           /* important for \..\.. */
-      }
-      else if(LenSrc>=2 && pszPath[OffsetSrc]=='\\' && pszPath[OffsetSrc+1]=='.' )
-      {
-        /* "\." found, skip it */
-        OffsetSrc += 2; LenSrc-=2; bModifyed = TRUE;
-      }
-      else
-      {
-        pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; LenSrc--;
-      }
-    }
-    pszBuf[OffsetDst] = '\0';
-    TRACE("-- %s %u\n", debugstr_w(pszBuf), bModifyed);
-    return bModifyed;
+        }
+        
+        /* ".\" at the beginning of the path */
+        if (LenSrc >= 2 && pszPath[OffsetSrc]=='.' && pszPath[OffsetSrc+1]=='\\')
+        {
+          OffsetSrc+=2; LenSrc-=2; bModifyed = TRUE;
+        } 
+        
+        while ( LenSrc )
+        {
+          if((LenSrc>=3) && (pszPath[OffsetSrc]=='\\') && (pszPath[OffsetSrc+1]=='.') && (pszPath[OffsetSrc+2]=='.'))
+          {
+            /* "\.." found, go one deeper */
+            while((OffsetDst > OffsetMin) && (pszBuf[OffsetDst]!='\\')) OffsetDst--;
+            OffsetSrc += 3; LenSrc -= 3; bModifyed = TRUE;
+            if(OffsetDst == OffsetMin && pszPath[OffsetSrc]=='\\') OffsetSrc++;
+            pszBuf[OffsetDst] = '\0';                   /* important for \..\.. */
+          }
+          else if(LenSrc>=2 && pszPath[OffsetSrc]=='\\' && pszPath[OffsetSrc+1]=='.' )
+          {
+            /* "\." found, skip it */
+            OffsetSrc += 2; LenSrc-=2; bModifyed = TRUE;
+          }
+          else
+          {
+            pszBuf[OffsetDst++] = pszPath[OffsetSrc++]; LenSrc--;
+          }
+        }
+        pszBuf[OffsetDst] = '\0';
+        TRACE("-- %s %u\n", debugstr_w(pszBuf), bModifyed);
+        return bModifyed;
 }
 
@@ -1497 +1496 @@
  * NOTES
  * special cases:
- *  ""              null
- *  aa              "" (pointer to traling NULL)
- *  aa\             "" (pointer to traling NULL)
- *  aa\\            "" (pointer to traling NULL)
- *  aa\\bb          bb
- *  aa\\\bb         \bb
- *  c:\aa\          "aa\"
- *  \\aa            aa
- *  \\aa\b          aa\b
+ *      ""              null
+ *      aa              "" (pointer to traling NULL)
+ *      aa\             "" (pointer to traling NULL)
+ *      aa\\            "" (pointer to traling NULL)
+ *      aa\\bb          bb
+ *      aa\\\bb         \bb
+ *      c:\aa\          "aa\"
+ *      \\aa            aa
+ *      \\aa\b          aa\b
 */
 LPSTR WINAPI PathFindNextComponentA(LPCSTR pszPath)
 {
-    LPSTR pos;
-
-    TRACE("%s\n", pszPath);
-
-    if(!pszPath || !*pszPath) return NULL;
-    if(!(pos = StrChrA(pszPath, '\\')))
-      return (LPSTR) pszPath + strlen(pszPath);
-    pos++;
-    if(pos[0] == '\\') pos++;
-    return pos;
+        LPSTR pos;
+
+        TRACE("%s\n", pszPath);
+
+        if(!pszPath || !*pszPath) return NULL;
+        if(!(pos = StrChrA(pszPath, '\\')))
+          return (LPSTR) pszPath + strlen(pszPath);
+        pos++;
+        if(pos[0] == '\\') pos++;
+        return pos;
 }
 
@@ -1526 +1525 @@
 LPWSTR WINAPI PathFindNextComponentW(LPCWSTR pszPath)
 {
-    LPWSTR pos;
-
-    TRACE("%s\n", debugstr_w(pszPath));
-
-    if(!pszPath || !*pszPath) return NULL;
-    if (!(pos = StrChrW(pszPath, '\\')))
-      return (LPWSTR) pszPath + strlenW(pszPath);
-    pos++;
-    if(pos[0] == '\\') pos++;
-    return pos;
+        LPWSTR pos;
+
+        TRACE("%s\n", debugstr_w(pszPath));
+        
+        if(!pszPath || !*pszPath) return NULL;
+        if (!(pos = StrChrW(pszPath, '\\')))
+          return (LPWSTR) pszPath + strlenW(pszPath);
+        pos++;
+        if(pos[0] == '\\') pos++;
+        return pos;
 }
 
@@ -1544 +1543 @@
  *  it adds never a dot
  */
-
+ 
 BOOL WINAPI PathAddExtensionA(
-    LPSTR  pszPath,
-    LPCSTR pszExtension)
-{
-    if (*pszPath)
-    {
-      if (*(PathFindExtensionA(pszPath))) return FALSE;
-
-      if (!pszExtension || *pszExtension=='\0')
-        strcat(pszPath, "exe");
-      else
-        strcat(pszPath, pszExtension);
-    }
-
-    return TRUE;
-}
-
-/*************************************************************************
- *  PathAddExtensionW   [SHLWAPI.@]
+        LPSTR  pszPath,
+        LPCSTR pszExtension)
+{
+        if (*pszPath)
+        {
+          if (*(PathFindExtensionA(pszPath))) return FALSE;
+
+          if (!pszExtension || *pszExtension=='\0')
+            strcat(pszPath, "exe");
+          else
+            strcat(pszPath, pszExtension);
+        }
+
+        return TRUE;
+}
+
+/*************************************************************************
+ *      PathAddExtensionW   [SHLWAPI.@]
  */
 BOOL WINAPI PathAddExtensionW(
-    LPWSTR  pszPath,
-    LPCWSTR pszExtension)
-{
-    static const WCHAR ext[] = { 'e','x','e',0 };
-
-    if (*pszPath)
-    {
-      if (*(PathFindExtensionW(pszPath))) return FALSE;
-
-      if (!pszExtension || *pszExtension=='\0')
-        strcatW(pszPath, ext);
-      else
-        strcatW(pszPath, pszExtension);
-    }
-    return TRUE;
-
-}
-
-/*************************************************************************
- *  PathMakePrettyA   [SHLWAPI.@]
+        LPWSTR  pszPath,
+        LPCWSTR pszExtension)
+{
+        static const WCHAR ext[] = { 'e','x','e',0 };
+
+        if (*pszPath)
+        {
+          if (*(PathFindExtensionW(pszPath))) return FALSE;
+
+          if (!pszExtension || *pszExtension=='\0')
+            strcatW(pszPath, ext);
+          else
+            strcatW(pszPath, pszExtension);
+        }
+        return TRUE;
+
+}
+
+/*************************************************************************
+ *      PathMakePrettyA   [SHLWAPI.@]
  */
 BOOL WINAPI PathMakePrettyA(
-    LPSTR lpPath)
-{
-    FIXME("%s\n", lpPath);
-    return TRUE;
-}
-
-/*************************************************************************
- *  PathMakePrettyW   [SHLWAPI.@]
+        LPSTR lpPath)
+{
+        FIXME("%s\n", lpPath);
+        return TRUE;
+}
+
+/*************************************************************************
+ *      PathMakePrettyW   [SHLWAPI.@]
  */
 BOOL WINAPI PathMakePrettyW(
-    LPWSTR lpPath)
-{
-    FIXME("%s\n", debugstr_w(lpPath));
-    return TRUE;
-
-}
-
-/*************************************************************************
- *  PathCommonPrefixA   [SHLWAPI.@]
+        LPWSTR lpPath)
+{
+        FIXME("%s\n", debugstr_w(lpPath));
+        return TRUE;
+
+}
+
+/*************************************************************************
+ *      PathCommonPrefixA   [SHLWAPI.@]
  */
 int WINAPI PathCommonPrefixA(
-    LPCSTR pszFile1,
-    LPCSTR pszFile2,
-    LPSTR achPath)
-{
-    FIXME("%s %s %p\n", pszFile1, pszFile2, achPath);
-    return 0;
-}
-
-/*************************************************************************
- *  PathCommonPrefixW   [SHLWAPI.@]
+        LPCSTR pszFile1,
+        LPCSTR pszFile2,
+        LPSTR achPath)
+{
+        FIXME("%s %s %p\n", pszFile1, pszFile2, achPath);
+        return 0;
+}
+
+/*************************************************************************
+ *      PathCommonPrefixW   [SHLWAPI.@]
  */
 int WINAPI PathCommonPrefixW(
-    LPCWSTR pszFile1,
-    LPCWSTR pszFile2,
-    LPWSTR achPath)
-{
-    FIXME("%s %s %p\n", debugstr_w(pszFile1), debugstr_w(pszFile2),achPath );
-    return 0;
-}
-
-/*************************************************************************
- *  PathCompactPathA   [SHLWAPI.@]
+        LPCWSTR pszFile1,
+        LPCWSTR pszFile2,
+        LPWSTR achPath)
+{
+        FIXME("%s %s %p\n", debugstr_w(pszFile1), debugstr_w(pszFile2),achPath );
+        return 0;
+}
+
+/*************************************************************************
+ *      PathCompactPathA   [SHLWAPI.@]
  */
 BOOL WINAPI PathCompactPathA(HDC hDC, LPSTR pszPath, UINT dx)
 {
-    FIXME("0x%08x %s 0x%08x\n", hDC, pszPath, dx);
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathCompactPathW   [SHLWAPI.@]
+        FIXME("0x%08x %s 0x%08x\n", hDC, pszPath, dx);
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathCompactPathW   [SHLWAPI.@]
  */
 BOOL WINAPI PathCompactPathW(HDC hDC, LPWSTR pszPath, UINT dx)
 {
-    FIXME("0x%08x %s 0x%08x\n", hDC, debugstr_w(pszPath), dx);
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathGetCharTypeA   [SHLWAPI.@]
+        FIXME("0x%08x %s 0x%08x\n", hDC, debugstr_w(pszPath), dx);
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathGetCharTypeA   [SHLWAPI.@]
  */
 UINT WINAPI PathGetCharTypeA(UCHAR ch)
@@ -1654 +1653 @@
         UINT flags = 0;
 
-    TRACE("%c\n", ch);
-
-    /* We could use them in filenames, but this would confuse 'ls' */
-    if (iscntrl(ch))
-        return GCT_INVALID;
-    if ((ch == '*') || (ch=='?'))
-        return GCT_WILD;
-    if ((ch == '\\') || (ch=='/'))
-        return GCT_SEPARATOR;
-    flags = 0;
-    /* all normal characters, no lower case letters */
-    if ((ch > ' ') && (ch < 0x7f) && !islower(ch))
-        flags |= GCT_SHORTCHAR;
-    /* All other characters are valid in long filenames, even umlauts */
-    return flags | GCT_LFNCHAR;
-}
-
-/*************************************************************************
- *  PathGetCharTypeW   [SHLWAPI.@]
+        TRACE("%c\n", ch);
+
+        /* We could use them in filenames, but this would confuse 'ls' */
+        if (iscntrl(ch))
+            return GCT_INVALID;
+        if ((ch == '*') || (ch=='?'))
+            return GCT_WILD;
+        if ((ch == '\\') || (ch=='/'))
+            return GCT_SEPARATOR;
+        flags = 0;
+        /* all normal characters, no lower case letters */
+        if ((ch > ' ') && (ch < 0x7f) && !islower(ch))
+            flags |= GCT_SHORTCHAR;
+        /* All other characters are valid in long filenames, even umlauts */
+        return flags | GCT_LFNCHAR;
+}
+
+/*************************************************************************
+ *      PathGetCharTypeW   [SHLWAPI.@]
  */
 UINT WINAPI PathGetCharTypeW(WCHAR ch)
 {
-    FIXME("%c, using ascii version\n", ch);
-    return PathGetCharTypeA(ch);
-}
-
-/*************************************************************************
- *  PathMakeSystemFolderA   [SHLWAPI.@]
+        FIXME("%c, using ascii version\n", ch);
+        return PathGetCharTypeA(ch);
+}
+
+/*************************************************************************
+ *      PathMakeSystemFolderA   [SHLWAPI.@]
  */
 BOOL WINAPI PathMakeSystemFolderA(LPCSTR pszPath)
 {
-    FIXME("%s\n", pszPath);
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathMakeSystemFolderW   [SHLWAPI.@]
+        FIXME("%s\n", pszPath);
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathMakeSystemFolderW   [SHLWAPI.@]
  */
 BOOL WINAPI PathMakeSystemFolderW(LPCWSTR pszPath)
 {
-    FIXME("%s\n", debugstr_w(pszPath));
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathRenameExtensionA   [SHLWAPI.@]
+        FIXME("%s\n", debugstr_w(pszPath));
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathRenameExtensionA   [SHLWAPI.@]
  */
 BOOL WINAPI PathRenameExtensionA(LPSTR pszPath, LPCSTR pszExt)
 {
-    FIXME("%s %s\n", pszPath, pszExt);
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathRenameExtensionW   [SHLWAPI.@]
+        FIXME("%s %s\n", pszPath, pszExt);
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathRenameExtensionW   [SHLWAPI.@]
  */
 BOOL WINAPI PathRenameExtensionW(LPWSTR pszPath, LPCWSTR pszExt)
 {
-    FIXME("%s %s\n", debugstr_w(pszPath), debugstr_w(pszExt));
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathSearchAndQualifyA   [SHLWAPI.@]
+        FIXME("%s %s\n", debugstr_w(pszPath), debugstr_w(pszExt));
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathSearchAndQualifyA   [SHLWAPI.@]
  */
 BOOL WINAPI PathSearchAndQualifyA(
-    LPCSTR pszPath,
-    LPSTR pszBuf,
-    UINT cchBuf)
-{
-    FIXME("%s %s 0x%08x\n", pszPath, pszBuf, cchBuf);
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathSearchAndQualifyW   [SHLWAPI.@]
+        LPCSTR pszPath,
+        LPSTR pszBuf,
+        UINT cchBuf)
+{
+        FIXME("%s %s 0x%08x\n", pszPath, pszBuf, cchBuf);
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathSearchAndQualifyW   [SHLWAPI.@]
  */
 BOOL WINAPI PathSearchAndQualifyW(
-    LPCWSTR pszPath,
-    LPWSTR pszBuf,
-    UINT cchBuf)
-{
-    FIXME("%s %s 0x%08x\n", debugstr_w(pszPath), debugstr_w(pszBuf), cchBuf);
-    return FALSE;
+        LPCWSTR pszPath,
+        LPWSTR pszBuf,
+        UINT cchBuf)
+{
+        FIXME("%s %s 0x%08x\n", debugstr_w(pszPath), debugstr_w(pszBuf), cchBuf);
+        return FALSE;
 }
 
 #ifndef __WIN32OS2__
 /*************************************************************************
- *  PathSkipRootA   [SHLWAPI.@]
+ *      PathSkipRootA   [SHLWAPI.@]
  */
 LPSTR WINAPI PathSkipRootA(LPCSTR pszPath)
 {
-    FIXME("%s\n", pszPath);
-    return (LPSTR)pszPath;
-}
-
-/*************************************************************************
- *  PathSkipRootW   [SHLWAPI.@]
+        FIXME("%s\n", pszPath);
+        return (LPSTR)pszPath;
+}
+
+/*************************************************************************
+ *      PathSkipRootW   [SHLWAPI.@]
  */
 LPWSTR WINAPI PathSkipRootW(LPCWSTR pszPath)
 {
-    FIXME("%s\n", debugstr_w(pszPath));
-    return (LPWSTR)pszPath;
+        FIXME("%s\n", debugstr_w(pszPath));
+        return (LPWSTR)pszPath;
 }
 #endif
 
 /*************************************************************************
- *  PathCreateFromUrlA   [SHLWAPI.@]
+ *      PathCreateFromUrlA   [SHLWAPI.@]
  */
 HRESULT WINAPI PathCreateFromUrlA(
-    LPCSTR pszUrl,
-    LPSTR pszPath,
-    LPDWORD pcchPath,
-    DWORD dwFlags)
-{
-    FIXME("%s %p %p 0x%08lx\n",
-      pszUrl, pszPath, pcchPath, dwFlags);
-    return S_OK;
-}
-
-/*************************************************************************
- *  PathCreateFromUrlW   [SHLWAPI.@]
+        LPCSTR pszUrl,
+        LPSTR pszPath,
+        LPDWORD pcchPath,
+        DWORD dwFlags)
+{
+        FIXME("%s %p %p 0x%08lx\n",
+          pszUrl, pszPath, pcchPath, dwFlags);
+        return S_OK;
+}
+
+/*************************************************************************
+ *      PathCreateFromUrlW   [SHLWAPI.@]
  */
 HRESULT WINAPI PathCreateFromUrlW(
-    LPCWSTR pszUrl,
-    LPWSTR pszPath,
-    LPDWORD pcchPath,
-    DWORD dwFlags)
-{
-    FIXME("%s %p %p 0x%08lx\n",
-      debugstr_w(pszUrl), pszPath, pcchPath, dwFlags);
-    return S_OK;
-}
-
-/*************************************************************************
- *  PathRelativePathToA   [SHLWAPI.@]
+        LPCWSTR pszUrl,
+        LPWSTR pszPath,
+        LPDWORD pcchPath,
+        DWORD dwFlags)
+{
+        FIXME("%s %p %p 0x%08lx\n",
+          debugstr_w(pszUrl), pszPath, pcchPath, dwFlags);
+        return S_OK;
+}
+
+/*************************************************************************
+ *      PathRelativePathToA   [SHLWAPI.@]
  */
 BOOL WINAPI PathRelativePathToA(
-    LPSTR pszPath,
-    LPCSTR pszFrom,
-    DWORD dwAttrFrom,
-    LPCSTR pszTo,
-    DWORD dwAttrTo)
-{
-    FIXME("%s %s 0x%08lx %s 0x%08lx\n",
-      pszPath, pszFrom, dwAttrFrom, pszTo, dwAttrTo);
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathRelativePathToW   [SHLWAPI.@]
+        LPSTR pszPath,
+        LPCSTR pszFrom,
+        DWORD dwAttrFrom,
+        LPCSTR pszTo,
+        DWORD dwAttrTo)
+{
+        FIXME("%s %s 0x%08lx %s 0x%08lx\n",
+          pszPath, pszFrom, dwAttrFrom, pszTo, dwAttrTo);
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathRelativePathToW   [SHLWAPI.@]
  */
 BOOL WINAPI PathRelativePathToW(
-    LPWSTR pszPath,
-    LPCWSTR pszFrom,
-    DWORD dwAttrFrom,
-    LPCWSTR pszTo,
-    DWORD dwAttrTo)
-{
-    FIXME("%s %s 0x%08lx %s 0x%08lx\n",
-      debugstr_w(pszPath), debugstr_w(pszFrom), dwAttrFrom, debugstr_w(pszTo), dwAttrTo);
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathUnmakeSystemFolderA   [SHLWAPI.@]
+        LPWSTR pszPath,
+        LPCWSTR pszFrom,
+        DWORD dwAttrFrom,
+        LPCWSTR pszTo,
+        DWORD dwAttrTo)
+{
+        FIXME("%s %s 0x%08lx %s 0x%08lx\n",
+          debugstr_w(pszPath), debugstr_w(pszFrom), dwAttrFrom, debugstr_w(pszTo), dwAttrTo);
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathUnmakeSystemFolderA   [SHLWAPI.@]
  */
 BOOL WINAPI PathUnmakeSystemFolderA(LPCSTR pszPath)
 {
-    FIXME("%s\n", pszPath);
-    return FALSE;
-}
-
-/*************************************************************************
- *  PathUnmakeSystemFolderW   [SHLWAPI.@]
+        FIXME("%s\n", pszPath);
+        return FALSE;
+}
+
+/*************************************************************************
+ *      PathUnmakeSystemFolderW   [SHLWAPI.@]
  */
 BOOL WINAPI PathUnmakeSystemFolderW(LPCWSTR pszPath)
 {
-    FIXME("%s\n", debugstr_w(pszPath));
-    return FALSE;
+        FIXME("%s\n", debugstr_w(pszPath));
+        return FALSE;
 }
 
 /*
-    ########## special ##########
+        ########## special ##########
 */
 
@@ -1846 +1845 @@
  *  use PathCompactPath to make sure, the path fits into the control
  */
-BOOL WINAPI PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR pszPath)
-{   TRACE("%x %x %s\n",hDlg, id, pszPath);
-    return SetDlgItemTextA(hDlg, id, pszPath);
+BOOL WINAPI PathSetDlgItemPathA(HWND hDlg, int id, LPCSTR pszPath) 
+{       TRACE("%x %x %s\n",hDlg, id, pszPath);
+        return SetDlgItemTextA(hDlg, id, pszPath);
 }
 
@@ -1854 +1853 @@
  * PathSetDlgItemPathW   [SHLWAPI.@]
  */
-BOOL WINAPI PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR pszPath)
-{   TRACE("%x %x %s\n",hDlg, id, debugstr_w(pszPath));
-    return SetDlgItemTextW(hDlg, id, pszPath);
-}
+BOOL WINAPI PathSetDlgItemPathW(HWND hDlg, int id, LPCWSTR pszPath) 
+{       TRACE("%x %x %s\n",hDlg, id, debugstr_w(pszPath));
+        return SetDlgItemTextW(hDlg, id, pszPath);
+}

trunk/src/shlwapi/reg.c

@@ -1 @@
-/* $Id: reg.c,v 1.5 2001-09-05 13:48:38 bird Exp $ */
 /*
  * SHLWAPI registry functions
@@ -33 +32 @@
 
 /*************************************************************************
- * SHRegGetUSValueA [SHLWAPI.@]
+ * SHRegGetUSValueA     [SHLWAPI.@]
  *
  * Gets a user-specific registry value
  */
 LONG WINAPI SHRegGetUSValueA(
-    LPCSTR   pSubKey,
-    LPCSTR   pValue,
-    LPDWORD  pwType,
-    LPVOID   pvData,
-    LPDWORD  pbData,
-    BOOL     fIgnoreHKCU,
-    LPVOID   pDefaultData,
-    DWORD    wDefaultDataSize)
-{
-    FIXME("(%p),stub!\n", pSubKey);
-    return ERROR_SUCCESS;  /* return success */
-}
-
-/*************************************************************************
- * SHRegGetUSValueW [SHLWAPI.@]
+        LPCSTR   pSubKey,
+        LPCSTR   pValue,
+        LPDWORD  pwType,
+        LPVOID   pvData,
+        LPDWORD  pbData,
+        BOOL     fIgnoreHKCU,
+        LPVOID   pDefaultData,
+        DWORD    wDefaultDataSize)
+{
+        FIXME("(%p),stub!\n", pSubKey);
+        return ERROR_SUCCESS;  /* return success */
+}
+
+/*************************************************************************
+ * SHRegGetUSValueW     [SHLWAPI.@]
  *
  * Gets a user-specific registry value
  */
 LONG WINAPI SHRegGetUSValueW(
-    LPCWSTR  pSubKey,
-    LPCWSTR  pValue,
-    LPDWORD  pwType,
-    LPVOID   pvData,
-    LPDWORD  pbData,
-    BOOL     flagIgnoreHKCU,
-    LPVOID   pDefaultData,
-    DWORD    wDefaultDataSize)
-{
-    FIXME("(%p),stub!\n", pSubKey);
-    return ERROR_SUCCESS;  /* return success */
-}
-
-/*************************************************************************
- * SHRegOpenUSKeyA  [SHLWAPI.@]
+        LPCWSTR  pSubKey,
+        LPCWSTR  pValue,
+        LPDWORD  pwType,
+        LPVOID   pvData,
+        LPDWORD  pbData,
+        BOOL     flagIgnoreHKCU,
+        LPVOID   pDefaultData,
+        DWORD    wDefaultDataSize)
+{
+        FIXME("(%p),stub!\n", pSubKey);
+        return ERROR_SUCCESS;  /* return success */
+}
+
+/*************************************************************************
+ * SHRegOpenUSKeyA      [SHLWAPI.@]
  *
  * Openss a user-specific registry key
@@ -82 +81 @@
         BOOL fIgnoreHKCU)
 {
-    FIXME("stub!\n");
-    return ERROR_SUCCESS;  /* return success */
-}
-
-/*************************************************************************
- * SHRegOpenUSKeyW  [SHLWAPI.@]
+        FIXME("stub!\n");
+        return ERROR_SUCCESS;  /* return success */
+}
+
+/*************************************************************************
+ * SHRegOpenUSKeyW      [SHLWAPI.@]
  *
  * Openss a user-specific registry key
@@ -98 +97 @@
         BOOL fIgnoreHKCU)
 {
-    FIXME("stub!\n");
-    return ERROR_SUCCESS;  /* return success */
+        FIXME("stub!\n");
+        return ERROR_SUCCESS;  /* return success */
 }
 
@@ -107 +106 @@
  */
 BOOL WINAPI SHRegGetBoolUSValueA(
-    LPCSTR pszSubKey,
-    LPCSTR pszValue,
-    BOOL fIgnoreHKCU,
-    BOOL fDefault)
-{
-    FIXME("%s %s\n", pszSubKey,pszValue);
-    return fDefault;
-}
-
-/*************************************************************************
- * SHRegGetBoolUSValueW   [SHLWAPI.@]
+        LPCSTR pszSubKey,
+        LPCSTR pszValue,
+        BOOL fIgnoreHKCU,
+        BOOL fDefault)
+{
+        FIXME("%s %s\n", pszSubKey,pszValue);
+        return fDefault;
+}
+
+/*************************************************************************
+ * SHRegGetBoolUSValueW   [SHLWAPI.@]
  */
 BOOL WINAPI SHRegGetBoolUSValueW(
-    LPCWSTR pszSubKey,
-    LPCWSTR pszValue,
-    BOOL fIgnoreHKCU,
-    BOOL fDefault)
-{
-    FIXME("%s %s\n", debugstr_w(pszSubKey),debugstr_w(pszValue));
-    return fDefault;
+        LPCWSTR pszSubKey,
+        LPCWSTR pszValue,
+        BOOL fIgnoreHKCU,
+        BOOL fDefault)
+{
+        FIXME("%s %s\n", debugstr_w(pszSubKey),debugstr_w(pszValue));
+        return fDefault;
 }
 #endif
 
 /*************************************************************************
- *      SHRegQueryUSValueA  [SHLWAPI]
+ *      SHRegQueryUSValueA      [SHLWAPI]
  */
 LONG WINAPI SHRegQueryUSValueA(
-    HUSKEY hUSKey,             /* [in] FIXME: HUSKEY */
-    LPCSTR pszValue,
-    LPDWORD pdwType,
-    LPVOID pvData,
-    LPDWORD pcbData,
-    BOOL fIgnoreHKCU,
-    LPVOID pvDefaultData,
-    DWORD dwDefaultDataSize)
-{
-    FIXME("%s stub\n",pszValue);
-    return 1;
-}
-
-/*************************************************************************
- *      SHRegQueryUSValueA  [SHLWAPI]
+        HUSKEY hUSKey,             /* [in] FIXME: HUSKEY */
+        LPCSTR pszValue,
+        LPDWORD pdwType,
+        LPVOID pvData,
+        LPDWORD pcbData,
+        BOOL fIgnoreHKCU,
+        LPVOID pvDefaultData,
+        DWORD dwDefaultDataSize)
+{
+        FIXME("%s stub\n",pszValue);
+        return 1;
+}
+
+/*************************************************************************
+ *      SHRegQueryUSValueA      [SHLWAPI]
  */
 LONG WINAPI SHRegQueryUSValueW(
-    HUSKEY hUSKey,             /* [in] FIXME: HUSKEY */
-    LPCSTR pszValue,
-    LPDWORD pdwType,
-    void *pvData,
-    LPDWORD pcbData,
-    BOOL fIgnoreHKCU,
-    void *pvDefaultData,
-    DWORD dwDefaultDataSize)
-{
-    FIXME("%s stub\n",pszValue);
-    return 1;
+        HUSKEY hUSKey,             /* [in] FIXME: HUSKEY */
+        LPCSTR pszValue,
+        LPDWORD pdwType,
+        void *pvData,
+        LPDWORD pcbData,
+        BOOL fIgnoreHKCU,
+        void *pvDefaultData,
+        DWORD dwDefaultDataSize)
+{
+        FIXME("%s stub\n",pszValue);
+        return 1;
 }
 
@@ -168 +167 @@
  */
 DWORD WINAPI SHRegGetPathA(
-    HKEY hKey,
-    LPCSTR pcszSubKey,
-    LPCSTR pcszValue,
-    LPSTR pszPath,
-    DWORD dwFlags)
-{
-    FIXME("%s %s\n", pcszSubKey, pcszValue);
-    return 0;
+        HKEY hKey,
+        LPCSTR pcszSubKey,
+        LPCSTR pcszValue,
+        LPSTR pszPath,
+        DWORD dwFlags)
+{
+        FIXME("%s %s\n", pcszSubKey, pcszValue);
+        return 0;
 }
 
@@ -182 +181 @@
  */
 DWORD WINAPI SHRegGetPathW(
-    HKEY hKey,
-    LPCWSTR pcszSubKey,
-    LPCWSTR pcszValue,
-    LPWSTR pszPath,
-    DWORD dwFlags)
-{
-    FIXME("%s %s\n", debugstr_w(pcszSubKey), debugstr_w(pcszValue));
-    return 0;
+        HKEY hKey,
+        LPCWSTR pcszSubKey,
+        LPCWSTR pcszValue,
+        LPWSTR pszPath,
+        DWORD dwFlags)
+{
+        FIXME("%s %s\n", debugstr_w(pcszSubKey), debugstr_w(pcszValue));
+        return 0;
 }
 
@@ -198 +197 @@
  */
 DWORD WINAPI SHGetValueA(
-    HKEY     hkey,
-    LPCSTR   pSubKey,
-    LPCSTR   pValue,
-    LPDWORD  pwType,
-    LPVOID   pvData,
-    LPDWORD  pbData)
-{
-    HKEY hSubKey;
-    DWORD res;
-
-    TRACE("(%s %s)\n", pSubKey, pValue);
-
-    if((res = RegOpenKeyA(hkey, pSubKey, &hSubKey))) return res;
-    res = RegQueryValueExA(hSubKey, pValue, 0, pwType, pvData, pbData);
-    RegCloseKey( hSubKey );
-
-    return res;
+        HKEY     hkey,
+        LPCSTR   pSubKey,
+        LPCSTR   pValue,
+        LPDWORD  pwType,
+        LPVOID   pvData,
+        LPDWORD  pbData)
+{
+        HKEY hSubKey;
+        DWORD res;
+
+        TRACE("(%s %s)\n", pSubKey, pValue);
+
+        if((res = RegOpenKeyA(hkey, pSubKey, &hSubKey))) return res;
+        res = RegQueryValueExA(hSubKey, pValue, 0, pwType, pvData, pbData);
+        RegCloseKey( hSubKey );
+
+        return res;
 }
 
@@ -223 +222 @@
  */
 DWORD WINAPI SHGetValueW(
-    HKEY     hkey,
-    LPCWSTR  pSubKey,
-    LPCWSTR  pValue,
-    LPDWORD  pwType,
-    LPVOID   pvData,
-    LPDWORD  pbData)
-{
-    HKEY hSubKey;
-    DWORD res;
-
-    TRACE("(%s %s)\n", debugstr_w(pSubKey), debugstr_w(pValue));
-
-    if((res = RegOpenKeyW(hkey, pSubKey, &hSubKey))) return res;
-    res = RegQueryValueExW(hSubKey, pValue, 0, pwType, pvData, pbData);
-    RegCloseKey( hSubKey );
-
-    return res;
+        HKEY     hkey,
+        LPCWSTR  pSubKey,
+        LPCWSTR  pValue,
+        LPDWORD  pwType,
+        LPVOID   pvData,
+        LPDWORD  pbData)
+{
+        HKEY hSubKey;
+        DWORD res;
+
+        TRACE("(%s %s)\n", debugstr_w(pSubKey), debugstr_w(pValue));
+
+        if((res = RegOpenKeyW(hkey, pSubKey, &hSubKey))) return res;
+        res = RegQueryValueExW(hSubKey, pValue, 0, pwType, pvData, pbData);
+        RegCloseKey( hSubKey );
+
+        return res;
 }
 
@@ -246 +245 @@
  */
 HRESULT WINAPI SHSetValueA(
-    HKEY hkey,
-    LPCSTR pszSubKey,
-    LPCSTR pszValue,
-    DWORD dwType,
-    LPCVOID pvData,
-    DWORD cbData)
-{
-    HKEY    subkey;
-    HRESULT hres;
+        HKEY hkey,
+        LPCSTR pszSubKey,
+        LPCSTR pszValue,
+        DWORD dwType,
+        LPCVOID pvData,
+        DWORD cbData)
+{
+    HKEY        subkey;
+    HRESULT     hres;
 
     hres = RegCreateKeyA(hkey,pszSubKey,&subkey);
     if (!hres)
-    return hres;
+        return hres;
     hres = RegSetValueExA(subkey,pszValue,0,dwType,pvData,cbData);
     RegCloseKey(subkey);
@@ -268 +267 @@
  */
 HRESULT WINAPI SHSetValueW(
-    HKEY hkey,
-    LPCWSTR pszSubKey,
-    LPCWSTR pszValue,
-    DWORD dwType,
-    LPCVOID pvData,
-    DWORD cbData)
-{
-    HKEY    subkey;
-    HRESULT hres;
+        HKEY hkey,
+        LPCWSTR pszSubKey,
+        LPCWSTR pszValue,
+        DWORD dwType,
+        LPCVOID pvData,
+        DWORD cbData)
+{
+    HKEY        subkey;
+    HRESULT     hres;
 
     hres = RegCreateKeyW(hkey,pszSubKey,&subkey);
     if (!hres)
-    return hres;
+        return hres;
     hres = RegSetValueExW(subkey,pszValue,0,dwType,pvData,cbData);
     RegCloseKey(subkey);
@@ -287 +286 @@
 
 /*************************************************************************
- * SHQueryValueExA      [SHLWAPI.@]
+ * SHQueryValueExA              [SHLWAPI.@]
  *
  */
 HRESULT WINAPI SHQueryValueExA(
-    HKEY hkey,
-    LPSTR lpValueName,
-    LPDWORD lpReserved,
-    LPDWORD lpType,
-    LPBYTE lpData,
-    LPDWORD lpcbData)
-{
-    TRACE("0x%04x %s %p %p %p %p\n", hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
-    return RegQueryValueExA (hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
+        HKEY hkey,
+        LPSTR lpValueName,
+        LPDWORD lpReserved,
+        LPDWORD lpType,
+        LPBYTE lpData,
+        LPDWORD lpcbData)
+{
+        TRACE("0x%04x %s %p %p %p %p\n", hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
+        return RegQueryValueExA (hkey, lpValueName, lpReserved, lpType, lpData, lpcbData);
 }
 
@@ -306 +305 @@
  * SHQueryValueExW   [SHLWAPI.@]
  *
- * FIXME
+ * FIXME 
  *  if the datatype REG_EXPAND_SZ then expand the string and change
  *  *pdwType to REG_SZ.
  */
 HRESULT WINAPI SHQueryValueExW (
-    HKEY hkey,
-    LPWSTR pszValue,
-    LPDWORD pdwReserved,
-    LPDWORD pdwType,
-    LPVOID pvData,
-    LPDWORD pcbData)
-{
-    WARN("0x%04x %s %p %p %p %p semi-stub\n",
+        HKEY hkey,
+        LPWSTR pszValue,
+        LPDWORD pdwReserved,
+        LPDWORD pdwType,
+        LPVOID pvData,
+        LPDWORD pcbData)
+{
+        WARN("0x%04x %s %p %p %p %p semi-stub\n",
              hkey, debugstr_w(pszValue), pdwReserved, pdwType, pvData, pcbData);
-    return RegQueryValueExW ( hkey, pszValue, pdwReserved, pdwType, pvData, pcbData);
+        return RegQueryValueExW ( hkey, pszValue, pdwReserved, pdwType, pvData, pcbData);
 }
 
@@ -333 +332 @@
  */
 HRESULT WINAPI SHDeleteKeyA(
-    HKEY hKey,
-    LPCSTR lpszSubKey)
+        HKEY hKey,
+        LPCSTR lpszSubKey)
 {
     DWORD r, dwKeyCount, dwSize, i, dwMaxSubkeyLen;
@@ -399 +398 @@
  */
 HRESULT WINAPI SHDeleteKeyW(
-    HKEY hkey,
-    LPCWSTR pszSubKey)
-{
-    FIXME("hkey=0x%08x, %s\n", hkey, debugstr_w(pszSubKey));
-    return 0;
+        HKEY hkey,
+        LPCWSTR pszSubKey)
+{
+        FIXME("hkey=0x%08x, %s\n", hkey, debugstr_w(pszSubKey));
+        return 0;
 }
 
@@ -412 +411 @@
  */
 HRESULT WINAPI SHDeleteValueA(HKEY hkey, LPCSTR pszSubKey, LPCSTR pszValue) {
-    HKEY    subkey;
-    HRESULT hres;
+    HKEY        subkey;
+    HRESULT     hres;
 
     hres = RegOpenKeyA(hkey,pszSubKey,&subkey);
     if (hres)
-    return hres;
+        return hres;
     hres = RegDeleteValueA(subkey,pszValue);
     RegCloseKey(subkey);
@@ -429 +428 @@
  */
 HRESULT WINAPI SHDeleteValueW(HKEY hkey, LPCWSTR pszSubKey, LPCWSTR pszValue) {
-    HKEY    subkey;
-    HRESULT hres;
+    HKEY        subkey;
+    HRESULT     hres;
 
     hres = RegOpenKeyW(hkey,pszSubKey,&subkey);
     if (hres)
-    return hres;
+        return hres;
     hres = RegDeleteValueW(subkey,pszValue);
     RegCloseKey(subkey);

trunk/src/shlwapi/regstream.c

@@ -1 @@
-/* $Id: regstream.c,v 1.3 2001-09-05 13:48:38 bird Exp $ */
 /*
- *  SHRegOpenStream
+ *      SHRegOpenStream
  */
 #ifdef __WIN32OS2__
@@ -29 +28 @@
 DEFAULT_DEBUG_CHANNEL(shell);
 
-typedef struct
-{   ICOM_VFIELD(IStream);
-    DWORD       ref;
-    HKEY        hKey;
-    LPBYTE      pbBuffer;
-    DWORD       dwLength;
-    DWORD       dwPos;
+typedef struct 
+{       ICOM_VFIELD(IStream);
+        DWORD           ref;
+        HKEY            hKey;
+        LPBYTE          pbBuffer;
+        DWORD           dwLength;
+        DWORD           dwPos;
 } ISHRegStream;
 
@@ -41 +40 @@
 
 /**************************************************************************
-*   IStream_ConstructorA    [internal]
+*   IStream_ConstructorA        [internal]
 */
 static IStream *IStream_ConstructorA(HKEY hKey, LPCSTR pszSubKey, LPCSTR pszValue, DWORD grfMode)
 {
-    ISHRegStream*   rstr;
-    DWORD       dwType;
-
-    rstr = (ISHRegStream*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ISHRegStream));
-
-    ICOM_VTBL(rstr)=&rstvt;
-    rstr->ref = 1;
-
-    if (!(RegOpenKeyExA (hKey, pszSubKey, 0, KEY_READ, &(rstr->hKey))))
-    {
-      if (!(RegQueryValueExA(rstr->hKey, pszValue,0,0,0,&(rstr->dwLength))))
-      {
-        /* read the binary data into the buffer */
-        if((rstr->pbBuffer = HeapAlloc(GetProcessHeap(),0,rstr->dwLength)))
-        {
-          if (!(RegQueryValueExA(rstr->hKey, pszValue,0,&dwType,rstr->pbBuffer,&(rstr->dwLength))))
-          {
-            if (dwType == REG_BINARY )
-            {
-              TRACE ("%p\n", rstr);
-              return (IStream*)rstr;
-            }
-          }
-          HeapFree (GetProcessHeap(),0,rstr->pbBuffer);
-        }
-      }
-      RegCloseKey(rstr->hKey);
-    }
-    HeapFree (GetProcessHeap(),0,rstr);
-    return NULL;
-}
-
-/**************************************************************************
-*   IStream_ConstructorW    [internal]
+        ISHRegStream*   rstr;
+        DWORD           dwType;
+        
+        rstr = (ISHRegStream*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ISHRegStream));
+
+        ICOM_VTBL(rstr)=&rstvt;
+        rstr->ref = 1;
+
+        if (!(RegOpenKeyExA (hKey, pszSubKey, 0, KEY_READ, &(rstr->hKey))))
+        {
+          if (!(RegQueryValueExA(rstr->hKey, pszValue,0,0,0,&(rstr->dwLength))))
+          { 
+            /* read the binary data into the buffer */
+            if((rstr->pbBuffer = HeapAlloc(GetProcessHeap(),0,rstr->dwLength)))
+            {
+              if (!(RegQueryValueExA(rstr->hKey, pszValue,0,&dwType,rstr->pbBuffer,&(rstr->dwLength))))
+              {
+                if (dwType == REG_BINARY )
+                {
+                  TRACE ("%p\n", rstr);
+                  return (IStream*)rstr;
+                }
+              }
+              HeapFree (GetProcessHeap(),0,rstr->pbBuffer);
+            }
+          }
+          RegCloseKey(rstr->hKey);
+        }
+        HeapFree (GetProcessHeap(),0,rstr);
+        return NULL;
+}
+
+/**************************************************************************
+*   IStream_ConstructorW        [internal]
 */
 static IStream *IStream_ConstructorW(HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD grfMode)
 {
-    ISHRegStream*   rstr;
-    DWORD       dwType;
-
-    rstr = (ISHRegStream*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ISHRegStream));
-
-    ICOM_VTBL(rstr)=&rstvt;
-    rstr->ref = 1;
-
-    if (!(RegOpenKeyExW (hKey, pszSubKey, 0, KEY_READ, &(rstr->hKey))))
-    {
-      if (!(RegQueryValueExW(rstr->hKey, pszValue,0,0,0,&(rstr->dwLength))))
-      {
-        /* read the binary data into the buffer */
-        if((rstr->pbBuffer = HeapAlloc(GetProcessHeap(),0,rstr->dwLength)))
-        {
-          if (!(RegQueryValueExW(rstr->hKey, pszValue,0,&dwType,rstr->pbBuffer,&(rstr->dwLength))))
-          {
-            if (dwType == REG_BINARY )
-            {
-              TRACE ("%p\n", rstr);
-              return (IStream*)rstr;
-            }
-          }
-          HeapFree (GetProcessHeap(),0,rstr->pbBuffer);
-        }
-      }
-      RegCloseKey(rstr->hKey);
-    }
-    HeapFree (GetProcessHeap(),0,rstr);
-    return NULL;
+        ISHRegStream*   rstr;
+        DWORD           dwType;
+        
+        rstr = (ISHRegStream*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ISHRegStream));
+
+        ICOM_VTBL(rstr)=&rstvt;
+        rstr->ref = 1;
+
+        if (!(RegOpenKeyExW (hKey, pszSubKey, 0, KEY_READ, &(rstr->hKey))))
+        {
+          if (!(RegQueryValueExW(rstr->hKey, pszValue,0,0,0,&(rstr->dwLength))))
+          { 
+            /* read the binary data into the buffer */
+            if((rstr->pbBuffer = HeapAlloc(GetProcessHeap(),0,rstr->dwLength)))
+            {
+              if (!(RegQueryValueExW(rstr->hKey, pszValue,0,&dwType,rstr->pbBuffer,&(rstr->dwLength))))
+              {
+                if (dwType == REG_BINARY )
+                {
+                  TRACE ("%p\n", rstr);
+                  return (IStream*)rstr;
+                }
+              }
+              HeapFree (GetProcessHeap(),0,rstr->pbBuffer);
+            }
+          }
+          RegCloseKey(rstr->hKey);
+        }
+        HeapFree (GetProcessHeap(),0,rstr);
+        return NULL;
 }
 
@@ -119 +118 @@
 static HRESULT WINAPI IStream_fnQueryInterface(IStream *iface, REFIID riid, LPVOID *ppvObj)
 {
-    ICOM_THIS(ISHRegStream, iface);
-
-////    TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,debugstr_guid(riid),ppvObj);
-
-    *ppvObj = NULL;
-
-    if(IsEqualIID(riid, &IID_IUnknown)) /*IUnknown*/
-    { *ppvObj = This;
-    }
-    else if(IsEqualIID(riid, &IID_IStream)) /*IStream*/
-    { *ppvObj = This;
-    }
-
-    if(*ppvObj)
-    {
-      IStream_AddRef((IStream*)*ppvObj);
-      TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
-      return S_OK;
-    }
-    TRACE("-- Interface: E_NOINTERFACE\n");
-    return E_NOINTERFACE;
+        ICOM_THIS(ISHRegStream, iface);
+
+////    TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,debugstr_guid(riid),ppvObj);
+
+        *ppvObj = NULL;
+
+        if(IsEqualIID(riid, &IID_IUnknown))     /*IUnknown*/
+        { *ppvObj = This; 
+        }
+        else if(IsEqualIID(riid, &IID_IStream)) /*IStream*/
+        { *ppvObj = This;
+        }   
+
+        if(*ppvObj)
+        { 
+          IStream_AddRef((IStream*)*ppvObj);      
+          TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
+          return S_OK;
+        }
+        TRACE("-- Interface: E_NOINTERFACE\n");
+        return E_NOINTERFACE;
 }
 
@@ -147 +146 @@
 static ULONG WINAPI IStream_fnAddRef(IStream *iface)
 {
-    ICOM_THIS(ISHRegStream, iface);
-
-    TRACE("(%p)->(count=%lu)\n",This, This->ref);
-
-    return ++(This->ref);
+        ICOM_THIS(ISHRegStream, iface);
+
+        TRACE("(%p)->(count=%lu)\n",This, This->ref);
+
+        return ++(This->ref);
 }
 
@@ -159 +158 @@
 static ULONG WINAPI IStream_fnRelease(IStream *iface)
 {
-    ICOM_THIS(ISHRegStream, iface);
-
-    TRACE("(%p)->()\n",This);
-
-    if (!--(This->ref))
-    { TRACE(" destroying SHReg IStream (%p)\n",This);
-
-      if (This->pbBuffer)
-        HeapFree(GetProcessHeap(),0,This->pbBuffer);
-
-      if (This->hKey)
-        RegCloseKey(This->hKey);
-
-      HeapFree(GetProcessHeap(),0,This);
-      return 0;
-    }
-    return This->ref;
+        ICOM_THIS(ISHRegStream, iface);
+
+        TRACE("(%p)->()\n",This);
+
+        if (!--(This->ref)) 
+        { TRACE(" destroying SHReg IStream (%p)\n",This);
+
+          if (This->pbBuffer)
+            HeapFree(GetProcessHeap(),0,This->pbBuffer);
+
+          if (This->hKey)
+            RegCloseKey(This->hKey);
+
+          HeapFree(GetProcessHeap(),0,This);
+          return 0;
+        }
+        return This->ref;
 }
 
 static HRESULT WINAPI IStream_fnRead (IStream * iface, void* pv, ULONG cb, ULONG* pcbRead)
 {
-    ICOM_THIS(ISHRegStream, iface);
-
-    DWORD dwBytesToRead, dwBytesLeft;
-
-    TRACE("(%p)->(%p,0x%08lx,%p)\n",This, pv, cb, pcbRead);
-
-    if ( !pv )
-      return STG_E_INVALIDPOINTER;
-
-    dwBytesLeft = This->dwLength - This->dwPos;
-
-    if ( 0 >= dwBytesLeft )                     /* end of buffer */
-      return S_FALSE;
-
-    dwBytesToRead = ( cb > dwBytesLeft) ? dwBytesLeft : cb;
-
-    memmove ( pv, (This->pbBuffer) + (This->dwPos), dwBytesToRead);
-
-    This->dwPos += dwBytesToRead;                   /* adjust pointer */
-
-    if (pcbRead)
-      *pcbRead = dwBytesToRead;
-
-    return S_OK;
+        ICOM_THIS(ISHRegStream, iface);
+
+        DWORD dwBytesToRead, dwBytesLeft;
+        
+        TRACE("(%p)->(%p,0x%08lx,%p)\n",This, pv, cb, pcbRead);
+        
+        if ( !pv )
+          return STG_E_INVALIDPOINTER;
+          
+        dwBytesLeft = This->dwLength - This->dwPos;
+
+        if ( 0 >= dwBytesLeft )                                         /* end of buffer */
+          return S_FALSE;
+        
+        dwBytesToRead = ( cb > dwBytesLeft) ? dwBytesLeft : cb;
+
+        memmove ( pv, (This->pbBuffer) + (This->dwPos), dwBytesToRead);
+        
+        This->dwPos += dwBytesToRead;                                   /* adjust pointer */
+
+        if (pcbRead)
+          *pcbRead = dwBytesToRead;
+
+        return S_OK;
 }
 static HRESULT WINAPI IStream_fnWrite (IStream * iface, const void* pv, ULONG cb, ULONG* pcbWritten)
 {
-    ICOM_THIS(ISHRegStream, iface);
-
-    TRACE("(%p)\n",This);
-
-    return E_NOTIMPL;
+        ICOM_THIS(ISHRegStream, iface);
+
+        TRACE("(%p)\n",This);
+
+        return E_NOTIMPL;
 }
 static HRESULT WINAPI IStream_fnSeek (IStream * iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition)
 {
-    ICOM_THIS(ISHRegStream, iface);
-
-    TRACE("(%p)\n",This);
-
-    return E_NOTIMPL;
+        ICOM_THIS(ISHRegStream, iface);
+
+        TRACE("(%p)\n",This);
+
+        return E_NOTIMPL;
 }
 static HRESULT WINAPI IStream_fnSetSize (IStream * iface, ULARGE_INTEGER libNewSize)
 {
-    ICOM_THIS(ISHRegStream, iface);
-
-    TRACE("(%p)\n",This);
-
-    return E_NOTIMPL;
+        ICOM_THIS(ISHRegStream, iface);
+
+        TRACE("(%p)\n",This);
+
+        return E_NOTIMPL;
 }
 static HRESULT WINAPI IStream_fnCopyTo (IStream * iface, IStream* pstm, ULARGE_INTEGER cb, ULARGE_INTEGER* pcbRead, ULARGE_INTEGER* pcbWritten)
 {
-    ICOM_THIS(ISHRegStream, iface);
-
-    TRACE("(%p)\n",This);
-
-    return E_NOTIMPL;
+        ICOM_THIS(ISHRegStream, iface);
+
+        TRACE("(%p)\n",This);
+
+        return E_NOTIMPL;
 }
 static HRESULT WINAPI IStream_fnCommit (IStream * iface, DWORD grfCommitFlags)
 {
-    ICOM_THIS(ISHRegStream, iface);
-
-    TRACE("(%p)\n",This);
-
-    return E_NOTIMPL;
+        ICOM_THIS(ISHRegStream, iface);
+
+        TRACE("(%p)\n",This);
+
+        return E_NOTIMPL;
 }
 static HRESULT WINAPI IStream_fnRevert (IStream * iface)
 {
-    ICOM_THIS(ISHRegStream, iface);
-
-    TRACE("(%p)\n",This);
-
-    return E_NOTIMPL;
+        ICOM_THIS(ISHRegStream, iface);
+
+        TRACE("(%p)\n",This);
+
+        return E_NOTIMPL;
 }
 static HRESULT WINAPI IStream_fnLockRegion (IStream * iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
 {
-    ICOM_THIS(ISHRegStream, iface);
-
-    TRACE("(%p)\n",This);
-
-    return E_NOTIMPL;
+        ICOM_THIS(ISHRegStream, iface);
+
+        TRACE("(%p)\n",This);
+
+        return E_NOTIMPL;
 }
 static HRESULT WINAPI IStream_fnUnlockRegion (IStream * iface, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
 {
-    ICOM_THIS(ISHRegStream, iface);
-
-    TRACE("(%p)\n",This);
-
-    return E_NOTIMPL;
+        ICOM_THIS(ISHRegStream, iface);
+
+        TRACE("(%p)\n",This);
+
+        return E_NOTIMPL;
 }
 static HRESULT WINAPI IStream_fnStat (IStream * iface, STATSTG*   pstatstg, DWORD grfStatFlag)
 {
-    ICOM_THIS(ISHRegStream, iface);
-
-    TRACE("(%p)\n",This);
-
-    return E_NOTIMPL;
+        ICOM_THIS(ISHRegStream, iface);
+
+        TRACE("(%p)\n",This);
+
+        return E_NOTIMPL;
 }
 static HRESULT WINAPI IStream_fnClone (IStream * iface, IStream** ppstm)
 {
-    ICOM_THIS(ISHRegStream, iface);
-
-    TRACE("(%p)\n",This);
-
-    return E_NOTIMPL;
-}
-
-static struct ICOM_VTABLE(IStream) rstvt =
-{
-    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
-    IStream_fnQueryInterface,
-    IStream_fnAddRef,
-    IStream_fnRelease,
-    IStream_fnRead,
-    IStream_fnWrite,
-    IStream_fnSeek,
-    IStream_fnSetSize,
-    IStream_fnCopyTo,
-    IStream_fnCommit,
-    IStream_fnRevert,
-    IStream_fnLockRegion,
-    IStream_fnUnlockRegion,
-    IStream_fnStat,
-    IStream_fnClone
-
+        ICOM_THIS(ISHRegStream, iface);
+
+        TRACE("(%p)\n",This);
+
+        return E_NOTIMPL;
+}
+
+static struct ICOM_VTABLE(IStream) rstvt = 
+{       
+        ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+        IStream_fnQueryInterface,
+        IStream_fnAddRef,
+        IStream_fnRelease,
+        IStream_fnRead,
+        IStream_fnWrite,
+        IStream_fnSeek,
+        IStream_fnSetSize,
+        IStream_fnCopyTo,
+        IStream_fnCommit,
+        IStream_fnRevert,
+        IStream_fnLockRegion,
+        IStream_fnUnlockRegion,
+        IStream_fnStat,
+        IStream_fnClone
+        
 };
 
 /*************************************************************************
- * SHOpenRegStreamA             [SHLWAPI.@]
+ * SHOpenRegStreamA                             [SHLWAPI.@]
  */
 IStream * WINAPI SHOpenRegStreamA(
-    HKEY hkey,
-    LPCSTR pszSubkey,
-    LPCSTR pszValue,
-    DWORD grfMode)
-{
-    TRACE("(0x%08x,%s,%s,0x%08lx)\n",
-    hkey, pszSubkey, pszValue, grfMode);
-
-    return IStream_ConstructorA(hkey, pszSubkey, pszValue, grfMode);
+        HKEY hkey,
+        LPCSTR pszSubkey,
+        LPCSTR pszValue,
+        DWORD grfMode)
+{
+        TRACE("(0x%08x,%s,%s,0x%08lx)\n",
+        hkey, pszSubkey, pszValue, grfMode);
+
+        return IStream_ConstructorA(hkey, pszSubkey, pszValue, grfMode);
 }
 
 /*************************************************************************
- * SHOpenRegStreamW             [SHLWAPI.@]
+ * SHOpenRegStreamW                             [SHLWAPI.@]
  */
 IStream * WINAPI SHOpenRegStreamW(
-    HKEY hkey,
-    LPCWSTR pszSubkey,
-    LPCWSTR pszValue,
-    DWORD grfMode)
-{
-    TRACE("(0x%08x,%s,%s,0x%08lx)\n",
-    hkey, debugstr_w(pszSubkey), debugstr_w(pszValue), grfMode);
-
-    return IStream_ConstructorW(hkey, pszSubkey, pszValue, grfMode);
-}
+        HKEY hkey,
+        LPCWSTR pszSubkey,
+        LPCWSTR pszValue,
+        DWORD grfMode)
+{
+        TRACE("(0x%08x,%s,%s,0x%08lx)\n",
+        hkey, debugstr_w(pszSubkey), debugstr_w(pszValue), grfMode);
+
+        return IStream_ConstructorW(hkey, pszSubkey, pszValue, grfMode);
+}

trunk/src/shlwapi/shlwapiguid.c

@@ -1 @@
-/* $Id: shlwapiguid.c,v 1.2 2001-09-05 13:48:38 bird Exp $ */
 /*
- *  SHRegOpenStream
+ *      SHRegOpenStream
  */
 #ifdef __WIN32OS2__

trunk/src/shlwapi/string.c

@@ -1 @@
-/* $Id: string.c,v 1.5 2001-09-05 13:48:39 bird Exp $ */
 //Note: Odin changes marked by #ifdef __WIN32OS2__!
 #ifdef __WIN32OS2__
@@ -16 +15 @@
 #endif
 #include <ctype.h>
-#include <stdlib.h>
+#include <stdlib.h> 
 #include <stdio.h>
 #include <string.h>
@@ -42 +41 @@
 
 /*************************************************************************
- * StrChrA                  [SHLWAPI]
+ * StrChrA                                      [SHLWAPI]
  */
 LPSTR WINAPI StrChrA (LPCSTR str, WORD c)
 {
-    TRACE("%s %i\n", str,c);
-    return strchr(str, c);
-}
-
-/*************************************************************************
- * StrChrW                  [SHLWAPI]
+        TRACE("%s %i\n", str,c);
+        return strchr(str, c);
+}
+
+/*************************************************************************
+ * StrChrW                                      [SHLWAPI]
  *
  */
 LPWSTR WINAPI StrChrW (LPCWSTR str, WCHAR x )
 {
-    TRACE("%s 0x%04x\n",debugstr_w(str),x);
-    return strchrW(str, x);
+        TRACE("%s 0x%04x\n",debugstr_w(str),x);
+        return strchrW(str, x);
 }
 #ifndef __WIN32OS2__
 /*************************************************************************
- * StrCmpIW                 [SHLWAPI]
+ * StrCmpIW                                     [SHLWAPI]
  */
 int WINAPI StrCmpIW ( LPCWSTR wstr1, LPCWSTR wstr2 )
@@ -71 +70 @@
 
 /*************************************************************************
- * StrCmpNA                 [SHLWAPI]
+ * StrCmpNA                                     [SHLWAPI]
  */
 INT WINAPI StrCmpNA ( LPCSTR str1, LPCSTR str2, INT len)
 {
-    TRACE("%s %s %i stub\n", str1,str2,len);
-    return strncmp(str1, str2, len);
-}
-
-/*************************************************************************
- * StrCmpNW                 [SHLWAPI]
+        TRACE("%s %s %i stub\n", str1,str2,len);
+        return strncmp(str1, str2, len);
+}
+
+/*************************************************************************
+ * StrCmpNW                                     [SHLWAPI]
  */
 INT WINAPI StrCmpNW ( LPCWSTR wstr1, LPCWSTR wstr2, INT len)
 {
-    TRACE("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
-    return strncmpW(wstr1, wstr2, len);
-}
-
-/*************************************************************************
- * StrCmpNIA                    [SHLWAPI]
+        TRACE("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
+        return strncmpW(wstr1, wstr2, len);
+}
+
+/*************************************************************************
+ * StrCmpNIA                                    [SHLWAPI]
  */
 int WINAPI StrCmpNIA ( LPCSTR str1, LPCSTR str2, int len)
 {
-    TRACE("%s %s %i stub\n", str1,str2,len);
-    return strncasecmp(str1, str2, len);
-}
-
-/*************************************************************************
- * StrCmpNIW                    [SHLWAPI]
+        TRACE("%s %s %i stub\n", str1,str2,len);
+        return strncasecmp(str1, str2, len);
+}
+
+/*************************************************************************
+ * StrCmpNIW                                    [SHLWAPI]
  */
 int WINAPI StrCmpNIW ( LPCWSTR wstr1, LPCWSTR wstr2, int len)
 {
-    TRACE("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
-    return strncmpiW(wstr1, wstr2, len);
-}
-
-/*************************************************************************
- * StrCmpW                  [SHLWAPI]
+        TRACE("%s %s %i stub\n", debugstr_w(wstr1),debugstr_w(wstr2),len);
+        return strncmpiW(wstr1, wstr2, len);
+}
+
+/*************************************************************************
+ * StrCmpW                                      [SHLWAPI]
  */
 int WINAPI StrCmpW ( LPCWSTR wstr1, LPCWSTR wstr2 )
@@ -116 +115 @@
 
 /*************************************************************************
- * StrCatW                  [SHLWAPI]
+ * StrCatW                                      [SHLWAPI]
  */
 LPWSTR WINAPI StrCatW( LPWSTR wstr1, LPCWSTR wstr2 )
@@ -125 +124 @@
 
 /*************************************************************************
- * StrCpyW                  [SHLWAPI]
+ * StrCpyW                                      [SHLWAPI]
  */
 LPWSTR WINAPI StrCpyW( LPWSTR wstr1, LPCWSTR wstr2 )
@@ -134 +133 @@
 
 /*************************************************************************
- * StrCpyNW                 [SHLWAPI]
+ * StrCpyNW                                     [SHLWAPI]
  */
 LPWSTR WINAPI StrCpyNW( LPWSTR wstr1, LPCWSTR wstr2, int n )
@@ -143 +142 @@
 
 /*************************************************************************
- * StrStrA                  [SHLWAPI]
+ * StrStrA                                      [SHLWAPI]
  */
 LPSTR WINAPI StrStrA(LPCSTR lpFirst, LPCSTR lpSrch)
@@ -158 +157 @@
 
 /*************************************************************************
- * StrStrW                  [SHLWAPI]
+ * StrStrW                                      [SHLWAPI]
  */
 LPWSTR WINAPI StrStrW(LPCWSTR lpFirst, LPCWSTR lpSrch)
@@ -173 +172 @@
 
 /*************************************************************************
- * StrStrIA                 [SHLWAPI]
+ * StrStrIA                                     [SHLWAPI]
  */
 LPSTR WINAPI StrStrIA(LPCSTR lpFirst, LPCSTR lpSrch)
@@ -188 +187 @@
 
 /*************************************************************************
- * StrStrIW                 [SHLWAPI]
+ * StrStrIW                                     [SHLWAPI]
  */
 LPWSTR WINAPI StrStrIW(LPCWSTR lpFirst, LPCWSTR lpSrch)
@@ -203 +202 @@
 
 /*************************************************************************
- *  StrToIntA           [SHLWAPI]
+ *      StrToIntA                       [SHLWAPI]
  */
 int WINAPI StrToIntA(LPCSTR lpSrc)
 {
-    TRACE("%s\n", lpSrc);
-    return atol(lpSrc);
-}
-
-/*************************************************************************
- *  StrToIntW           [SHLWAPI]
+        TRACE("%s\n", lpSrc);
+        return atol(lpSrc);
+}
+
+/*************************************************************************
+ *      StrToIntW                       [SHLWAPI]
  */
 int WINAPI StrToIntW(LPCWSTR lpSrc)
@@ -225 +224 @@
 
 /*************************************************************************
- *  StrToIntExA         [SHLWAPI]
+ *      StrToIntExA                     [SHLWAPI]
  */
 BOOL WINAPI StrToIntExA( LPCSTR pszString, DWORD dwFlags, LPINT piRet)
 {
-    TRACE("%s %ld stub !\n", debugstr_a(pszString), dwFlags);
-    piRet = (LPINT) StrToIntA(pszString);
-    return TRUE;
-}
-
-/*************************************************************************
- *  StrToIntExW         [SHLWAPI]
+        TRACE("%s %ld stub !\n", debugstr_a(pszString), dwFlags);
+        piRet = (LPINT) StrToIntA(pszString);
+        return TRUE;
+}
+
+/*************************************************************************
+ *      StrToIntExW                     [SHLWAPI]
  */
 BOOL WINAPI StrToIntExW( LPCWSTR pszString, DWORD dwFlags, LPINT piRet)
 {
-    TRACE("%s %ld stub !\n", debugstr_w(pszString), dwFlags);
-    piRet = (LPINT) StrToIntW(pszString);
-    return TRUE;
-}
-
-/*************************************************************************
- *  StrDupA         [SHLWAPI]
+        TRACE("%s %ld stub !\n", debugstr_w(pszString), dwFlags);
+        piRet = (LPINT) StrToIntW(pszString);
+        return TRUE;
+}
+
+/*************************************************************************
+ *      StrDupA                 [SHLWAPI]
  */
 LPSTR WINAPI StrDupA (LPCSTR lpSrc)
 {
-    int len = strlen(lpSrc);
-    LPSTR lpDest = (LPSTR) LocalAlloc(LMEM_FIXED, len+1);
-
-    TRACE("%s\n", lpSrc);
-
-    if (lpDest) strcpy(lpDest, lpSrc);
-    return lpDest;
-}
-
-/*************************************************************************
- *  StrDupW         [SHLWAPI]
+        int len = strlen(lpSrc);
+        LPSTR lpDest = (LPSTR) LocalAlloc(LMEM_FIXED, len+1);
+        
+        TRACE("%s\n", lpSrc);
+
+        if (lpDest) strcpy(lpDest, lpSrc);
+        return lpDest;
+}
+
+/*************************************************************************
+ *      StrDupW                 [SHLWAPI]
  */
 LPWSTR WINAPI StrDupW (LPCWSTR lpSrc)
 {
-    int len = strlenW(lpSrc);
-    LPWSTR lpDest = (LPWSTR) LocalAlloc(LMEM_FIXED, sizeof(WCHAR) * (len+1));
-
-    TRACE("%s\n", debugstr_w(lpSrc));
-
-    if (lpDest) strcpyW(lpDest, lpSrc);
-    return lpDest;
-}
-
-/*************************************************************************
- *  StrCSpnA        [SHLWAPI]
+        int len = strlenW(lpSrc);
+        LPWSTR lpDest = (LPWSTR) LocalAlloc(LMEM_FIXED, sizeof(WCHAR) * (len+1));
+        
+        TRACE("%s\n", debugstr_w(lpSrc));
+
+        if (lpDest) strcpyW(lpDest, lpSrc);
+        return lpDest;
+}
+
+/*************************************************************************
+ *      StrCSpnA                [SHLWAPI]
  */
 int WINAPI StrCSpnA (LPCSTR lpStr, LPCSTR lpSet)
 {
-    int i,j, pos = strlen(lpStr);
-
-    TRACE("(%p %s  %p %s)\n",
-       lpStr, debugstr_a(lpStr), lpSet, debugstr_a(lpSet));
-
-    for (i=0; i < strlen(lpSet) ; i++ )
-    {
-      for (j = 0; j < pos;j++)
-      {
-        if (lpStr[j] == lpSet[i])
-        {
-          pos = j;
-        }
-      }
-    }
-    TRACE("-- %u\n", pos);
-    return pos;
-}
-
-/*************************************************************************
- *  StrCSpnW        [SHLWAPI]
+        int i,j, pos = strlen(lpStr);
+
+        TRACE("(%p %s  %p %s)\n",
+           lpStr, debugstr_a(lpStr), lpSet, debugstr_a(lpSet));
+
+        for (i=0; i < strlen(lpSet) ; i++ )
+        {
+          for (j = 0; j < pos;j++)
+          {
+            if (lpStr[j] == lpSet[i])
+            {
+              pos = j;
+            }
+          }
+        }      
+        TRACE("-- %u\n", pos);
+        return pos;     
+}
+
+/*************************************************************************
+ *      StrCSpnW                [SHLWAPI]
  */
 int WINAPI StrCSpnW (LPCWSTR lpStr, LPCWSTR lpSet)
 {
-    int i,j, pos = strlenW(lpStr);
-
-    TRACE("(%p %s %p %s)\n",
-       lpStr, debugstr_w(lpStr), lpSet, debugstr_w(lpSet));
-
-    for (i=0; i < strlenW(lpSet) ; i++ )
-    {
-      for (j = 0; j < pos;j++)
-      {
-        if (lpStr[j] == lpSet[i])
-        {
-          pos = j;
-        }
-      }
-    }
-    TRACE("-- %u\n", pos);
-    return pos;
+        int i,j, pos = strlenW(lpStr);
+
+        TRACE("(%p %s %p %s)\n",
+           lpStr, debugstr_w(lpStr), lpSet, debugstr_w(lpSet));
+
+        for (i=0; i < strlenW(lpSet) ; i++ )
+        {
+          for (j = 0; j < pos;j++)
+          {
+            if (lpStr[j] == lpSet[i])
+            {
+              pos = j;
+            }
+          }
+        }      
+        TRACE("-- %u\n", pos);
+        return pos;     
 }
 
@@ -338 +337 @@
         if (dbcs && lpStart[1] != HIBYTE(wMatch)) continue;
         lpGotIt = lpStart;
-    }
+    }    
     return (LPSTR)lpGotIt;
 }
@@ -362 +361 @@
 
 /*************************************************************************
- *  StrCatBuffA     [SHLWAPI]
+ *      StrCatBuffA             [SHLWAPI]
  *
  * Appends back onto front, stopping when front is size-1 characters long.
@@ -380 +379 @@
 
 /*************************************************************************
- *  StrCatBuffW     [SHLWAPI]
+ *      StrCatBuffW             [SHLWAPI]
  *
  * Appends back onto front, stopping when front is size-1 characters long.
@@ -398 +397 @@
 
 /*************************************************************************
- * StrRetToBufA                 [SHLWAPI.@]
- *
+ * StrRetToBufA                                 [SHLWAPI.@]
+ * 
  * converts a STRRET to a normal string
  *
@@ -407 +406 @@
 HRESULT WINAPI StrRetToBufA (LPSTRRET src, const ITEMIDLIST *pidl, LPSTR dest, DWORD len)
 {
-    TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
-
-    switch (src->uType)
-    {
-      case STRRET_WSTR:
-        WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
-/*      SHFree(src->u.pOleStr);  FIXME: is this right? */
-        break;
-
-      case STRRET_CSTRA:
-        lstrcpynA((LPSTR)dest, src->u.cStr, len);
-        break;
-
-      case STRRET_OFFSETA:
-        lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
-        break;
-
-      default:
-        FIXME("unknown type!\n");
-        if (len)
-        {
-          *(LPSTR)dest = '\0';
-        }
-        return(FALSE);
-    }
-    return S_OK;
-}
-
-/*************************************************************************
- * StrRetToBufW                 [SHLWAPI.@]
- *
+        TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
+
+        switch (src->uType)
+        {
+          case STRRET_WSTR:
+            WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
+/*          SHFree(src->u.pOleStr);  FIXME: is this right? */
+            break;
+
+          case STRRET_CSTRA:
+            lstrcpynA((LPSTR)dest, src->u.cStr, len);
+            break;
+
+          case STRRET_OFFSETA:
+            lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
+            break;
+
+          default:
+            FIXME("unknown type!\n");
+            if (len)
+            {
+              *(LPSTR)dest = '\0';
+            }
+            return(FALSE);
+        }
+        return S_OK;
+}
+
+/*************************************************************************
+ * StrRetToBufW                                 [SHLWAPI.@]
+ * 
  * converts a STRRET to a normal string
  *
@@ -445 +444 @@
 HRESULT WINAPI StrRetToBufW (LPSTRRET src, const ITEMIDLIST *pidl, LPWSTR dest, DWORD len)
 {
-    TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
-
-    switch (src->uType)
-    {
-      case STRRET_WSTR:
-        lstrcpynW((LPWSTR)dest, src->u.pOleStr, len);
-/*      SHFree(src->u.pOleStr);  FIXME: is this right? */
-        break;
-
-      case STRRET_CSTRA:
+        TRACE("dest=0x%p len=0x%lx strret=0x%p pidl=%p stub\n",dest,len,src,pidl);
+
+        switch (src->uType)
+        {
+          case STRRET_WSTR:
+            lstrcpynW((LPWSTR)dest, src->u.pOleStr, len);
+/*          SHFree(src->u.pOleStr);  FIXME: is this right? */
+            break;
+
+          case STRRET_CSTRA:
               if (!MultiByteToWideChar( CP_ACP, 0, src->u.cStr, -1, dest, len ) && len)
                   dest[len-1] = 0;
-        break;
-
-      case STRRET_OFFSETA:
-        if (pidl)
-        {
+            break;
+
+          case STRRET_OFFSETA:
+            if (pidl)
+            {
               if (!MultiByteToWideChar( CP_ACP, 0, ((LPCSTR)&pidl->mkid)+src->u.uOffset, -1,
                                         dest, len ) && len)
                   dest[len-1] = 0;
-        }
-        break;
-
-      default:
-        FIXME("unknown type!\n");
-        if (len)
-        { *(LPSTR)dest = '\0';
-        }
-        return(FALSE);
-    }
-    return S_OK;
-}
-
-/*************************************************************************
- * StrFormatByteSizeA               [SHLWAPI]
+            }
+            break;
+
+          default:
+            FIXME("unknown type!\n");
+            if (len)
+            { *(LPSTR)dest = '\0';
+            }
+            return(FALSE);
+        }
+        return S_OK;
+}
+
+/*************************************************************************
+ * StrFormatByteSizeA                           [SHLWAPI]
  */
 LPSTR WINAPI StrFormatByteSizeA ( DWORD dw, LPSTR pszBuf, UINT cchBuf )
-{   char buf[64];
-    TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
-    if ( dw<1024L )
-    { sprintf (buf,"%ld bytes", dw);
-    }
-    else if ( dw<1048576L)
-    { sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
-    }
-    else if ( dw < 1073741824L)
-    { sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
-    }
-    else
-    { sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
-    }
-    lstrcpynA (pszBuf, buf, cchBuf);
-    return pszBuf;
-}
-
-/*************************************************************************
- * StrFormatByteSizeW               [SHLWAPI]
+{       char buf[64];
+        TRACE("%lx %p %i\n", dw, pszBuf, cchBuf);
+        if ( dw<1024L )
+        { sprintf (buf,"%ld bytes", dw);
+        }
+        else if ( dw<1048576L)
+        { sprintf (buf,"%3.1f KB", (FLOAT)dw/1024);
+        }
+        else if ( dw < 1073741824L)
+        { sprintf (buf,"%3.1f MB", (FLOAT)dw/1048576L);
+        }
+        else
+        { sprintf (buf,"%3.1f GB", (FLOAT)dw/1073741824L);
+        }
+        lstrcpynA (pszBuf, buf, cchBuf);
+        return pszBuf;  
+}
+
+/*************************************************************************
+ * StrFormatByteSizeW                           [SHLWAPI]
  */
 LPWSTR WINAPI StrFormatByteSizeW ( DWORD dw, LPWSTR pszBuf, UINT cchBuf )
@@ -513 +512 @@
 
 /*************************************************************************
- *      StrNCatA    [SHLWAPI]
+ *      StrNCatA        [SHLWAPI]
  */
 LPSTR WINAPI StrNCatA(LPSTR front, LPCSTR back, INT cchMax)
 {
-    TRACE("%s %s %i stub\n", debugstr_a(front),debugstr_a(back),cchMax);
-    return (front);
-}
-
-/*************************************************************************
- *      StrNCatW    [SHLWAPI]
+        TRACE("%s %s %i stub\n", debugstr_a(front),debugstr_a(back),cchMax);
+        return (front);
+}
+
+/*************************************************************************
+ *      StrNCatW        [SHLWAPI]
  */
 LPWSTR WINAPI StrNCatW(LPWSTR front, LPCWSTR back, INT cchMax)
 {
-    TRACE("%s %s %i stub\n", debugstr_w(front),debugstr_w(back),cchMax);
-    return (front);
-}
-
-/*************************************************************************
- *      StrTrimA    [SHLWAPI.@]
+        TRACE("%s %s %i stub\n", debugstr_w(front),debugstr_w(back),cchMax);
+        return (front);
+}
+
+/*************************************************************************
+ *      StrTrimA        [SHLWAPI.@]
  */
 BOOL WINAPI StrTrimA(LPSTR pszSource, LPCSTR pszTrimChars)
@@ -542 +541 @@
     for (pTrim = pszTrimChars; *pTrim; pTrim++)
     {
-     for (pSrc = pszSource; *pSrc; pSrc++)
-         if (*pSrc == *pTrim)
-         {
-         /* match -> remove this char.
-          * strlen(pSrc) equiv. to the correct strlen(pSrc+1)+1 */
-         memmove(pSrc, pSrc+1, strlen(pSrc));
-         trimmed = TRUE;
-         }
+         for (pSrc = pszSource; *pSrc; pSrc++)
+             if (*pSrc == *pTrim)
+             {
+                 /* match -> remove this char.
+                  * strlen(pSrc) equiv. to the correct strlen(pSrc+1)+1 */
+                 memmove(pSrc, pSrc+1, strlen(pSrc));
+                 trimmed = TRUE;
+             }
     }
     TRACE("<- '%s'\n", pszSource);
@@ -556 +555 @@
 
 /*************************************************************************
- *      wnsprintfA  [SHLWAPI]
+ *      wnsprintfA      [SHLWAPI]
  */
 int WINAPIV wnsprintfA(LPSTR lpOut, int cchLimitIn, LPCSTR lpFmt, ...)
@@ -570 +569 @@
 
 /*************************************************************************
- *      wnsprintfW  [SHLWAPI]
+ *      wnsprintfW      [SHLWAPI]
  */
 int WINAPIV wnsprintfW(LPWSTR lpOut, int cchLimitIn, LPCWSTR lpFmt, ...)

trunk/src/shlwapi/url.c

@@ -1 @@
-/* $Id: url.c,v 1.4 2001-09-05 13:48:39 bird Exp $ */
 /*
  * Url functions
@@ -54 +53 @@
     if(dwFlags & URL_ESCAPE_SPACES_ONLY) {
         if(ch == ' ')
-        return TRUE;
-    else
-        return FALSE;
+            return TRUE;
+        else
+            return FALSE;
     }
 
     if (ch <= 31 || ch >= 127)
-    return TRUE;
+        return TRUE;
 
     else {
         switch (ch) {
-    case ' ':
-    case '<':
-    case '>':
-    case '\"':
-    case '{':
-    case '}':
-    case '|':
-    case '\\':
-    case '^':
-    case ']':
-    case '[':
-    case '`':
-    case '&':
-        return TRUE;
-
-    default:
-        return FALSE;
-    }
+        case ' ':
+        case '<':
+        case '>':
+        case '\"':
+        case '{':
+        case '}':
+        case '|':
+        case '\\':
+        case '^':
+        case ']':
+        case '[':
+        case '`':
+        case '&':
+            return TRUE;
+
+        default:
+            return FALSE;
+        }
     }
 }
@@ -89 +88 @@
  */
 HRESULT WINAPI UrlCanonicalizeA(LPCSTR pszUrl, LPSTR pszCanonicalized,
-    LPDWORD pcchCanonicalized, DWORD dwFlags)
+        LPDWORD pcchCanonicalized, DWORD dwFlags)
 {
     HRESULT hr = S_OK;
@@ -97 +96 @@
 
     TRACE("(%s %p %p 0x%08lx)\n", debugstr_a(pszUrl), pszCanonicalized,
-      pcchCanonicalized, dwFlags);
+          pcchCanonicalized, dwFlags);
 
     nLen = strlen(pszUrl);
@@ -114 +113 @@
     if(dwFlags & (URL_ESCAPE_UNSAFE | URL_ESCAPE_SPACES_ONLY)) {
         DWORD EscapeFlags = dwFlags & (URL_ESCAPE_SPACES_ONLY
-                       /* | URL_ESCAPE_PERCENT */);
-    hr = UrlEscapeA(lpszUrlCpy, pszCanonicalized, pcchCanonicalized,
-            EscapeFlags);
+                                       /* | URL_ESCAPE_PERCENT */);
+        hr = UrlEscapeA(lpszUrlCpy, pszCanonicalized, pcchCanonicalized,
+                        EscapeFlags);
     } else { /* No escapping needed, just copy the string */
         nLen = strlen(lpszUrlCpy);
-    if(nLen < *pcchCanonicalized)
-        memcpy(pszCanonicalized, lpszUrlCpy, nLen + 1);
-    else {
-        hr = E_POINTER;
-        nLen++;
-    }
-    *pcchCanonicalized = nLen;
+        if(nLen < *pcchCanonicalized)
+            memcpy(pszCanonicalized, lpszUrlCpy, nLen + 1);
+        else {
+            hr = E_POINTER;
+            nLen++;
+        }
+        *pcchCanonicalized = nLen;
     }
 
     HeapFree(GetProcessHeap(), 0, lpszUrlCpy);
-
+  
     return hr;
 }
@@ -136 +135 @@
  *        UrlCanonicalizeW     [SHLWAPI]
  */
-HRESULT WINAPI UrlCanonicalizeW(LPCWSTR pszUrl, LPWSTR pszCanonicalized,
-                LPDWORD pcchCanonicalized, DWORD dwFlags)
+HRESULT WINAPI UrlCanonicalizeW(LPCWSTR pszUrl, LPWSTR pszCanonicalized, 
+                                LPDWORD pcchCanonicalized, DWORD dwFlags)
 {
     FIXME("(%s %p %p 0x%08lx): stub\n",debugstr_w(pszUrl),
-      pszCanonicalized, pcchCanonicalized, dwFlags);
+          pszCanonicalized, pcchCanonicalized, dwFlags);
     return E_NOTIMPL;
 }
 
 /*************************************************************************
- *      UrlEscapeA  [SHLWAPI]
+ *      UrlEscapeA      [SHLWAPI]
  *
  * Converts unsafe characters into their escape sequences.
@@ -173 +172 @@
  */
 HRESULT WINAPI UrlEscapeA(
-    LPCSTR pszUrl,
-    LPSTR pszEscaped,
-    LPDWORD pcchEscaped,
-    DWORD dwFlags)
+        LPCSTR pszUrl,
+        LPSTR pszEscaped,
+        LPDWORD pcchEscaped,
+        DWORD dwFlags)
 {
     LPCSTR src;
@@ -186 +185 @@
 
     TRACE("(%s %p %p 0x%08lx)\n", debugstr_a(pszUrl), pszEscaped,
-      pcchEscaped, dwFlags);
+          pcchEscaped, dwFlags);
 
     if(dwFlags & ~URL_ESCAPE_SPACES_ONLY)
@@ -193 +192 @@
     for(src = pszUrl; *src; src++) {
         if(!(dwFlags & URL_ESCAPE_SPACES_ONLY) &&
-       (*src == '#' || *src == '?'))
-        stop_escapping = TRUE;
-
-    if(URL_NeedEscape(*src, dwFlags) && stop_escapping == FALSE) {
-        next[0] = '%';
-        next[1] = hex[(*src >> 4) & 0xf];
-        next[2] = hex[*src & 0xf];
-        len = 3;
-    } else {
-        next[0] = *src;
-        len = 1;
-    }
-
-    if(needed + len <= *pcchEscaped) {
-        memcpy(dst, next, len);
-        dst += len;
-    }
-    needed += len;
+           (*src == '#' || *src == '?'))
+            stop_escapping = TRUE;
+
+        if(URL_NeedEscape(*src, dwFlags) && stop_escapping == FALSE) {
+            next[0] = '%';
+            next[1] = hex[(*src >> 4) & 0xf];
+            next[2] = hex[*src & 0xf];
+            len = 3;
+        } else {
+            next[0] = *src;
+            len = 1;
+        }
+
+        if(needed + len <= *pcchEscaped) {
+            memcpy(dst, next, len);
+            dst += len;
+        }
+        needed += len;
     }
 
     if(needed < *pcchEscaped) {
         *dst = '\0';
-    ret = S_OK;
+        ret = S_OK;
     } else {
         needed++; /* add one for the '\0' */
-    ret = E_POINTER;
+        ret = E_POINTER;
     }
     *pcchEscaped = needed;
     return ret;
-}
-
-/*************************************************************************
- *      UrlEscapeW  [SHLWAPI]
+}       
+
+/*************************************************************************
+ *      UrlEscapeW      [SHLWAPI]
  */
 HRESULT WINAPI UrlEscapeW(
-    LPCWSTR pszUrl,
-    LPWSTR pszEscaped,
-    LPDWORD pcchEscaped,
-    DWORD dwFlags)
+        LPCWSTR pszUrl,
+        LPWSTR pszEscaped,
+        LPDWORD pcchEscaped,
+        DWORD dwFlags)
 {
     FIXME("(%s %p %p 0x%08lx): stub\n",debugstr_w(pszUrl),
-      pszEscaped, pcchEscaped, dwFlags);
+          pszEscaped, pcchEscaped, dwFlags);
     return E_NOTIMPL;
 }
@@ -240 +239 @@
 
 /*************************************************************************
- *      UrlUnescapeA    [SHLWAPI]
+ *      UrlUnescapeA    [SHLWAPI]
  *
  * Converts escape sequences back to ordinary characters.
- *
+ * 
  * If URL_ESCAPE_INPLACE is set in dwFlags then pszUnescaped and
  * pcchUnescaped are ignored and the converted string is returned in
@@ -257 +256 @@
  */
 HRESULT WINAPI UrlUnescapeA(
-    LPCSTR pszUrl,
-    LPSTR pszUnescaped,
-    LPDWORD pcchUnescaped,
-    DWORD dwFlags)
+        LPCSTR pszUrl,
+        LPSTR pszUnescaped,
+        LPDWORD pcchUnescaped,
+        DWORD dwFlags)
 {
     char *dst, next;
@@ -269 +268 @@
 
     TRACE("(%s, %p, %p, %08lx): stub\n", debugstr_a(pszUrl), pszUnescaped,
-      pcchUnescaped, dwFlags);
+          pcchUnescaped, dwFlags);
 
     if(dwFlags & URL_UNESCAPE_INPLACE)
@@ -278 +277 @@
     for(src = pszUrl, needed = 0; *src; src++, needed++) {
         if(dwFlags & URL_DONT_UNESCAPE_EXTRA_INFO &&
-       (*src == '#' || *src == '?')) {
-        stop_unescapping = TRUE;
-        next = *src;
-    } else if(*src == '%' && isxdigit(*(src + 1)) && isxdigit(*(src + 2))
-          && stop_unescapping == FALSE) {
-        INT ih;
-        char buf[3];
-        memcpy(buf, src + 1, 2);
-        buf[2] = '\0';
-        ih = strtol(buf, NULL, 16);
-        next = (CHAR) ih;
-        src += 2; /* Advance to end of escape */
-    } else
-        next = *src;
-
-    if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped)
-        *dst++ = next;
+           (*src == '#' || *src == '?')) {
+            stop_unescapping = TRUE;
+            next = *src;
+        } else if(*src == '%' && isxdigit(*(src + 1)) && isxdigit(*(src + 2))
+                  && stop_unescapping == FALSE) {
+            INT ih;
+            char buf[3];
+            memcpy(buf, src + 1, 2);
+            buf[2] = '\0';
+            ih = strtol(buf, NULL, 16);
+            next = (CHAR) ih;
+            src += 2; /* Advance to end of escape */
+        } else
+            next = *src;
+
+        if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped)
+            *dst++ = next;
     }
 
     if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped) {
         *dst = '\0';
-    ret = S_OK;
+        ret = S_OK;
     } else {
         needed++; /* add one for the '\0' */
-    ret = E_POINTER;
+        ret = E_POINTER;
     }
     if(!(dwFlags & URL_UNESCAPE_INPLACE))
@@ -311 +310 @@
 
 /*************************************************************************
- *      UrlUnescapeW    [SHLWAPI]
+ *      UrlUnescapeW    [SHLWAPI]
  */
 HRESULT WINAPI UrlUnescapeW(
-    LPCWSTR pszUrl,
-    LPWSTR pszUnescaped,
-    LPDWORD pcchUnescaped,
-    DWORD dwFlags)
+        LPCWSTR pszUrl,
+        LPWSTR pszUnescaped,
+        LPDWORD pcchUnescaped,
+        DWORD dwFlags)
 {
     FIXME("(%s, %p, %p, %08lx): stub\n", debugstr_w(pszUrl), pszUnescaped,
-      pcchUnescaped, dwFlags);
+          pcchUnescaped, dwFlags);
     return E_NOTIMPL;
 }
 
 /*************************************************************************
- *      HashData    [SHLWAPI]
+ *      HashData        [SHLWAPI]
  *
  * Hash an input block into a variable sized digest.
@@ -358 +357 @@
 
 /*************************************************************************
- *      UrlHashA    [SHLWAPI]
+ *      UrlHashA        [SHLWAPI]
  *
  * Hash an ASCII URL.
@@ -372 +371 @@
 
 /*************************************************************************
- *      UrlApplySchemeW [SHLWAPI.@]
+ *      UrlApplySchemeW [SHLWAPI.@]
  */
 HRESULT WINAPI UrlApplySchemeW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut, DWORD dwFlags)

trunk/src/wininet/http.c

@@ -1 @@
-/* $Id: http.c,v 1.3 2001-09-05 10:31:45 bird Exp $
- *
+/*
  * Wininet - Http Implementation
  *

trunk/src/wininet/wininet_main.c

@@ -1 @@
-/* $Id: wininet_main.c,v 1.2 2001-09-05 10:31:47 bird Exp $
- *
+/*
  * WinInet
  *
@@ -15 +14 @@
 
 /***********************************************************************
- *      WININET_DllInstall (WININET.@)
+ *              WININET_DllInstall (WININET.@)
  */
 HRESULT WINAPI WININET_DllInstall(BOOL bInstall, LPCWSTR cmdline)
 {
-  FIXME("(%s, %s): stub\n", bInstall?"TRUE":"FALSE",
-    debugstr_w(cmdline));
+  FIXME("(%s, %s): stub\n", bInstall?"TRUE":"FALSE", 
+        debugstr_w(cmdline));
 
   return S_OK;

trunk/src/winmm/driver.c

@@ -1 +1 @@
 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
 
-/* $Id: driver.c,v 1.2 2001-09-05 10:30:21 bird Exp $
- *
+/*
  * WINE Drivers functions
  *
@@ -33 +32 @@
 DEFAULT_DEBUG_CHANNEL(driver);
 
-static LPWINE_DRIVER    lpDrvItemList = NULL;
+static LPWINE_DRIVER    lpDrvItemList = NULL;
 
 /* TODO list :
- *  - LoadModule count and clean up is not handled correctly (it's not a
- *    problem as long as FreeLibrary is not working correctly)
- */
-
-/**************************************************************************
- *          DRIVER_GetNumberOfModuleRefs        [internal]
+ *      - LoadModule count and clean up is not handled correctly (it's not a 
+ *        problem as long as FreeLibrary is not working correctly)
+ */
+
+/**************************************************************************
+ *                      DRIVER_GetNumberOfModuleRefs            [internal]
  *
  * Returns the number of open drivers which share the same module.
  */
-static  WORD    DRIVER_GetNumberOfModuleRefs(LPWINE_DRIVER lpNewDrv)
-{
-    LPWINE_DRIVER   lpDrv;
-    WORD        count = 0;
+static  WORD    DRIVER_GetNumberOfModuleRefs(LPWINE_DRIVER lpNewDrv)
+{
+    LPWINE_DRIVER       lpDrv;
+    WORD                count = 0;
 
     if (lpNewDrv->dwFlags & WINE_GDF_16BIT) ERR("OOOch");
     for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem) {
-    if (!(lpDrv->dwFlags & WINE_GDF_16BIT) &&
-        lpDrv->d.d32.hModule == lpNewDrv->d.d32.hModule) {
-        count++;
-    }
+        if (!(lpDrv->dwFlags & WINE_GDF_16BIT) &&
+            lpDrv->d.d32.hModule == lpNewDrv->d.d32.hModule) {
+            count++;
+        }
     }
     return count;
@@ -61 +60 @@
 
 /**************************************************************************
- *              DRIVER_FindFromHDrvr        [internal]
- *
+ *                              DRIVER_FindFromHDrvr            [internal]
+ * 
  * From a hDrvr being 32 bits, returns the WINE internal structure.
  */
-LPWINE_DRIVER   DRIVER_FindFromHDrvr(HDRVR hDrvr)
-{
-    LPWINE_DRIVER   d = (LPWINE_DRIVER)hDrvr;
+LPWINE_DRIVER   DRIVER_FindFromHDrvr(HDRVR hDrvr)
+{    
+    LPWINE_DRIVER       d = (LPWINE_DRIVER)hDrvr;
 
     if (hDrvr && HeapValidate(GetProcessHeap(), 0, d) && d->dwMagic == WINE_DI_MAGIC) {
-    return d;
+        return d;
     }
     return NULL;
@@ -77 +76 @@
 #ifndef __WIN32OS2__
 /**************************************************************************
- *              DRIVER_MapMsg32To16     [internal]
+ *                              DRIVER_MapMsg32To16             [internal]
  *
  * Map a 32 bit driver message to a 16 bit driver message.
@@ -87 +86 @@
 static int DRIVER_MapMsg32To16(WORD wMsg, DWORD* lParam1, DWORD* lParam2)
 {
-    int ret = -1;
-
+    int ret = -1;
+    
     switch (wMsg) {
     case DRV_LOAD:
@@ -97 +96 @@
     case DRV_REMOVE:
     case DRV_EXITSESSION:
-    case DRV_EXITAPPLICATION:
+    case DRV_EXITAPPLICATION:   
     case DRV_POWER:
-    case DRV_CLOSE: /* should be 0/0 */
-    case DRV_OPEN:  /* pass thru */
-    /* lParam1 and lParam2 are not used */
-    ret = 0;
-    break;
-    break;
+    case DRV_CLOSE:     /* should be 0/0 */
+    case DRV_OPEN:      /* pass thru */
+        /* lParam1 and lParam2 are not used */
+        ret = 0;
+        break;
+        break;
     case DRV_CONFIGURE:
     case DRV_INSTALL:
-    /* lParam1 is a handle to a window (conf) or to a driver (inst) or not used,
-     * lParam2 is a pointer to DRVCONFIGINFO
-     */
-    if (*lParam2) {
-            LPDRVCONFIGINFO16   dci16 = (LPDRVCONFIGINFO16)SEGPTR_ALLOC(sizeof(DRVCONFIGINFO16));
-            LPDRVCONFIGINFO dci32 = (LPDRVCONFIGINFO)(*lParam2);
-
-        if (dci16) {
-        LPSTR   str1, str2;
-
-        dci16->dwDCISize = sizeof(DRVCONFIGINFO16);
-
-        if ((str1 = HEAP_strdupWtoA(GetProcessHeap(), 0, dci32->lpszDCISectionName)) != NULL &&
-            (str2 = SEGPTR_STRDUP(str1)) != NULL) {
-            dci16->lpszDCISectionName = SEGPTR_GET(str2);
-            if (!HeapFree(GetProcessHeap(), 0, str1))
-            FIXME("bad free line=%d\n", __LINE__);
-        } else {
-            return -2;
-        }
-        if ((str1 = HEAP_strdupWtoA(GetProcessHeap(), 0, dci32->lpszDCIAliasName)) != NULL &&
-            (str2 = SEGPTR_STRDUP(str1)) != NULL) {
-            dci16->lpszDCIAliasName = SEGPTR_GET(str2);
-            if (!HeapFree(GetProcessHeap(), 0, str1))
-            FIXME("bad free line=%d\n", __LINE__);
-        } else {
-            return -2;
-        }
-        } else {
-        return -2;
-        }
-        *lParam2 = (LPARAM)SEGPTR_GET(dci16);
-        ret = 1;
-    } else {
-        ret = 0;
-    }
-    break;
+        /* lParam1 is a handle to a window (conf) or to a driver (inst) or not used, 
+         * lParam2 is a pointer to DRVCONFIGINFO 
+         */
+        if (*lParam2) {
+            LPDRVCONFIGINFO16   dci16 = (LPDRVCONFIGINFO16)SEGPTR_ALLOC(sizeof(DRVCONFIGINFO16));
+            LPDRVCONFIGINFO     dci32 = (LPDRVCONFIGINFO)(*lParam2);
+            
+            if (dci16) {
+                LPSTR   str1, str2;
+                
+                dci16->dwDCISize = sizeof(DRVCONFIGINFO16);
+                
+                if ((str1 = HEAP_strdupWtoA(GetProcessHeap(), 0, dci32->lpszDCISectionName)) != NULL &&
+                    (str2 = SEGPTR_STRDUP(str1)) != NULL) {
+                    dci16->lpszDCISectionName = SEGPTR_GET(str2);
+                    if (!HeapFree(GetProcessHeap(), 0, str1))
+                        FIXME("bad free line=%d\n", __LINE__);
+                } else {
+                    return -2;
+                }
+                if ((str1 = HEAP_strdupWtoA(GetProcessHeap(), 0, dci32->lpszDCIAliasName)) != NULL &&
+                    (str2 = SEGPTR_STRDUP(str1)) != NULL) {
+                    dci16->lpszDCIAliasName = SEGPTR_GET(str2);
+                    if (!HeapFree(GetProcessHeap(), 0, str1))
+                        FIXME("bad free line=%d\n", __LINE__);
+                } else {
+                    return -2;
+                }
+            } else {
+                return -2;
+            }
+            *lParam2 = (LPARAM)SEGPTR_GET(dci16);
+            ret = 1;
+        } else {
+            ret = 0;
+        }
+        break;
     default:
-    if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
-       FIXME("Unknown message 0x%04x\n", wMsg);
-    }
-    ret = 0;
+        if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
+           FIXME("Unknown message 0x%04x\n", wMsg);
+        }
+        ret = 0;
     }
     return ret;
@@ -154 +153 @@
 
 /**************************************************************************
- *              DRIVER_UnMapMsg32To16       [internal]
+ *                              DRIVER_UnMapMsg32To16           [internal]
  *
  * UnMap a 32 bit driver message to a 16 bit driver message.
@@ -163 +162 @@
 static int DRIVER_UnMapMsg32To16(WORD wMsg, DWORD lParam1, DWORD lParam2)
 {
-    int ret = -1;
-
+    int ret = -1;
+    
     switch (wMsg) {
     case DRV_LOAD:
@@ -177 +176 @@
     case DRV_OPEN:
     case DRV_CLOSE:
-    /* lParam1 and lParam2 are not used */
-    break;
-    case DRV_CONFIGURE:
+        /* lParam1 and lParam2 are not used */
+        break;
+    case DRV_CONFIGURE: 
     case DRV_INSTALL:
-    /* lParam1 is a handle to a window (or not used), lParam2 is a pointer to DRVCONFIGINFO, lParam2 */
-    if (lParam2) {
-        LPDRVCONFIGINFO16   dci16 = MapSL(lParam2);
-
-        if (!SEGPTR_FREE(MapSL(dci16->lpszDCISectionName)))
-        FIXME("bad free line=%d\n", __LINE__);
-        if (!SEGPTR_FREE(MapSL(dci16->lpszDCIAliasName)))
-        FIXME("bad free line=%d\n", __LINE__);
-        if (!SEGPTR_FREE(dci16))
-        FIXME("bad free line=%d\n", __LINE__);
-    }
-    ret = 0;
-    break;
+        /* lParam1 is a handle to a window (or not used), lParam2 is a pointer to DRVCONFIGINFO, lParam2 */
+        if (lParam2) {
+            LPDRVCONFIGINFO16   dci16 = MapSL(lParam2);
+            
+            if (!SEGPTR_FREE(MapSL(dci16->lpszDCISectionName)))
+                FIXME("bad free line=%d\n", __LINE__);
+            if (!SEGPTR_FREE(MapSL(dci16->lpszDCIAliasName)))
+                FIXME("bad free line=%d\n", __LINE__);
+            if (!SEGPTR_FREE(dci16))
+                FIXME("bad free line=%d\n", __LINE__);
+        }
+        ret = 0;
+        break;
     default:
-    if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
-        FIXME("Unknown message 0x%04x\n", wMsg);
-    }
-    ret = 0;
+        if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
+            FIXME("Unknown message 0x%04x\n", wMsg);
+        }
+        ret = 0;
     }
     return ret;
@@ -205 +204 @@
 
 /**************************************************************************
- *              DRIVER_SendMessage      [internal]
- */
-static LRESULT inline DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg,
-                    LPARAM lParam1, LPARAM lParam2)
+ *                              DRIVER_SendMessage              [internal]
+ */
+static LRESULT inline DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg, 
+                                        LPARAM lParam1, LPARAM lParam2)
 {
 #ifndef __WIN32OS2__
     if (lpDrv->dwFlags & WINE_GDF_16BIT) {
-    LRESULT     ret;
-    int     map = 0;
-    TRACE("Before sdm16 call hDrv=%04x wMsg=%04x p1=%08lx p2=%08lx\n",
-          lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
-
-    if ((map = DRIVER_MapMsg32To16(msg, &lParam1, &lParam2)) >= 0) {
-        ret = SendDriverMessage16(lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
-        if (map == 1)
-        DRIVER_UnMapMsg32To16(msg, lParam1, lParam2);
+        LRESULT         ret;
+        int             map = 0;
+        TRACE("Before sdm16 call hDrv=%04x wMsg=%04x p1=%08lx p2=%08lx\n", 
+              lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
+
+        if ((map = DRIVER_MapMsg32To16(msg, &lParam1, &lParam2)) >= 0) {
+            ret = SendDriverMessage16(lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
+            if (map == 1)
+                DRIVER_UnMapMsg32To16(msg, lParam1, lParam2);
+        } else {
+            ret = 0;
+        }
+        return ret;
+    }
+#endif
+    TRACE("Before func32 call proc=%p driverID=%08lx hDrv=%08x wMsg=%04x p1=%08lx p2=%08lx\n", 
+          lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
+    return lpDrv->d.d32.lpDrvProc(lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
+}
+
+/**************************************************************************
+ *                              SendDriverMessage               [WINMM.19]
+ */
+LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1,
+                                 LPARAM lParam2)
+{
+    LPWINE_DRIVER       lpDrv;
+    LRESULT             retval = 0;
+    
+    TRACE("(%04x, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
+    
+    if ((lpDrv = DRIVER_FindFromHDrvr(hDriver)) != NULL) {
+        retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
     } else {
-        ret = 0;
-    }
-    return ret;
-    }
-#endif
-    TRACE("Before func32 call proc=%p driverID=%08lx hDrv=%08x wMsg=%04x p1=%08lx p2=%08lx\n",
-      lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
-    return lpDrv->d.d32.lpDrvProc(lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
-}
-
-/**************************************************************************
- *              SendDriverMessage       [WINMM.19]
- */
-LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1,
-                 LPARAM lParam2)
-{
-    LPWINE_DRIVER   lpDrv;
-    LRESULT         retval = 0;
-
-    TRACE("(%04x, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
-
-    if ((lpDrv = DRIVER_FindFromHDrvr(hDriver)) != NULL) {
-    retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
-    } else {
-    WARN("Bad driver handle %u\n", hDriver);
+        WARN("Bad driver handle %u\n", hDriver);
     }
     TRACE("retval = %ld\n", retval);
-
+    
     return retval;
 }
 
 /**************************************************************************
- *              DRIVER_RemoveFromList       [internal]
+ *                              DRIVER_RemoveFromList           [internal]
  *
  * Generates all the logic to handle driver closure / deletion
  * Removes a driver struct to the list of open drivers.
  */
-static  BOOL    DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
+static  BOOL    DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
 {
     if (!(lpDrv->dwFlags & WINE_GDF_16BIT)) {
-    if (DRIVER_GetNumberOfModuleRefs(lpDrv) == 1) {
-        DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
-        DRIVER_SendMessage(lpDrv, DRV_FREE,    0L, 0L);
-    }
-    }
-
+        if (DRIVER_GetNumberOfModuleRefs(lpDrv) == 1) {
+            DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
+            DRIVER_SendMessage(lpDrv, DRV_FREE,    0L, 0L);
+        }
+    }
+    
     if (lpDrv->lpPrevItem)
-    lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
+        lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
     else
-    lpDrvItemList = lpDrv->lpNextItem;
+        lpDrvItemList = lpDrv->lpNextItem;
     if (lpDrv->lpNextItem)
-    lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
+        lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
 
     return TRUE;
@@ -279 +278 @@
 
 /**************************************************************************
- *              DRIVER_AddToList        [internal]
+ *                              DRIVER_AddToList                [internal]
  *
  * Adds a driver struct to the list of open drivers.
  * Generates all the logic to handle driver creation / open.
  */
-static  BOOL    DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lParam2)
+static  BOOL    DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lParam2)
 {
     lpNewDrv->dwMagic = WINE_DI_MAGIC;
     /* First driver to be loaded for this module, need to load correctly the module */
     if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
-    if (DRIVER_GetNumberOfModuleRefs(lpNewDrv) == 0) {
-        if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
-        TRACE("DRV_LOAD failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
-        return FALSE;
-        }
-        /* returned value is not checked */
-        DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
-    }
+        if (DRIVER_GetNumberOfModuleRefs(lpNewDrv) == 0) {
+            if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
+                TRACE("DRV_LOAD failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
+                return FALSE;
+            }
+            /* returned value is not checked */
+            DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
+        }
     }
 
     lpNewDrv->lpNextItem = NULL;
     if (lpDrvItemList == NULL) {
-    lpDrvItemList = lpNewDrv;
-    lpNewDrv->lpPrevItem = NULL;
+        lpDrvItemList = lpNewDrv;
+        lpNewDrv->lpPrevItem = NULL;
     } else {
-    LPWINE_DRIVER   lpDrv = lpDrvItemList;  /* find end of list */
-    while (lpDrv->lpNextItem != NULL)
-        lpDrv = lpDrv->lpNextItem;
-
-    lpDrv->lpNextItem = lpNewDrv;
-    lpNewDrv->lpPrevItem = lpDrv;
+        LPWINE_DRIVER   lpDrv = lpDrvItemList;  /* find end of list */
+        while (lpDrv->lpNextItem != NULL)
+            lpDrv = lpDrv->lpNextItem;
+        
+        lpDrv->lpNextItem = lpNewDrv;
+        lpNewDrv->lpPrevItem = lpDrv;
     }
 
     if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
-    /* Now just open a new instance of a driver on this module */
-    lpNewDrv->d.d32.dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
-
-    if (lpNewDrv->d.d32.dwDriverID == 0) {
-        TRACE("DRV_OPEN failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
-        DRIVER_RemoveFromList(lpNewDrv);
-        return FALSE;
-    }
+        /* Now just open a new instance of a driver on this module */
+        lpNewDrv->d.d32.dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
+
+        if (lpNewDrv->d.d32.dwDriverID == 0) {
+            TRACE("DRV_OPEN failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
+            DRIVER_RemoveFromList(lpNewDrv);
+            return FALSE;
+        }
     }
     return TRUE;
@@ -326 +325 @@
 
 /**************************************************************************
- *              DRIVER_GetLibName       [internal]
- *
- */
-BOOL    DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz)
+ *                              DRIVER_GetLibName               [internal]
+ *
+ */
+BOOL    DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz)
 {
     /* should also do some registry diving */
@@ -336 +335 @@
 
 /**************************************************************************
- *              DRIVER_TryOpenDriver32      [internal]
+ *                              DRIVER_TryOpenDriver32          [internal]
  *
  * Tries to load a 32 bit driver whose DLL's (module) name is fn
  */
-LPWINE_DRIVER   DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2)
-{
-    LPWINE_DRIVER   lpDrv = NULL;
-    HMODULE     hModule = 0;
-    LPSTR       ptr;
-    LPCSTR      cause = 0;
+LPWINE_DRIVER   DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2)
+{
+    LPWINE_DRIVER       lpDrv = NULL;
+    HMODULE             hModule = 0;
+    LPSTR               ptr;
+    LPCSTR              cause = 0;
 
     TRACE("('%s', %08lX);\n", fn, lParam2);
-
+    
     if ((ptr = strchr(fn, ' ')) != NULL) {
-    *ptr++ = '\0';
-    while (*ptr == ' ') ptr++;
-    if (*ptr == '\0') ptr = NULL;
+        *ptr++ = '\0';
+        while (*ptr == ' ') ptr++;
+        if (*ptr == '\0') ptr = NULL;
     }
 
@@ -379 +378 @@
 #ifdef __WIN32OS2__
 /**************************************************************************
- *              DRIVER_OpenDriverA              [internal]
+ *                              DRIVER_OpenDriverA                      [internal]
  * (0,1,DRV_LOAD  ,0       ,0)
  * (0,1,DRV_ENABLE,0       ,0)
@@ -385 +384 @@
  *
  */
-static  LPWINE_DRIVER   DRIVER_TryOpenDriver16(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam)
+static  LPWINE_DRIVER   DRIVER_TryOpenDriver16(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam)
 {
   LPWINE_DRIVER lpDrv = NULL;
-  char      drvName[128];
+  char          drvName[128];
   LPCSTR        cause = 0;
-
+  
   TRACE("Entering DRIVER_OpenDriverA: lpDriverName: %s lpSectionName: %s\n",lpDriverName,lpSectionName);
 
@@ -397 +396 @@
 
   if (lpSectionName == NULL) {
-    lstrcpynA(drvName, lpDriverName, sizeof(drvName));
-    lpDrv = DRIVER_TryOpenDriver32(lpDriverName, lParam);
-    if (!lpDrv) {
+        lstrcpynA(drvName, lpDriverName, sizeof(drvName));
+        lpDrv = DRIVER_TryOpenDriver32(lpDriverName, lParam);
+        if (!lpDrv) {
       if (GetPrivateProfileStringA("Drivers32", lpDriverName, "", drvName,
                                    sizeof(drvName), "SYSTEM.INI")) {
 
-        lpDrv = DRIVER_TryOpenDriver32(drvName, lParam);
+                lpDrv = DRIVER_TryOpenDriver32(drvName, lParam);                
       }
-    }
+        }
   } else {/* of if (lpSectionName == NULL) */
     //dprintf(("driver name %x '%s'\n",drvName,drvName));
-    drvName[0]=0;
-
-    if (GetPrivateProfileStringA(lpSectionName, lpDriverName, "", drvName,
+    drvName[0]=0;    
+
+        if (GetPrivateProfileStringA(lpSectionName, lpDriverName, "", drvName,
                                  sizeof(drvName)-1, "SYSTEM.INI")) {
 #if 0
       dprintf(("driver name %x '%s'\n",drvName,drvName));
-#endif
+#endif      
       lpDrv = DRIVER_TryOpenDriver32(drvName, lParam);
-    }/* GetPrivate... */
+        }/* GetPrivate... */
   }
   if (!lpDrv)
-    TRACE("OpenDriverA: Failed to open driver %s from section %s\n", lpDriverName, lpSectionName);
-
-  else
-    TRACE("OpenDriverA success: Driver handle => %08x\n", lpDrv);
+        TRACE("OpenDriverA: Failed to open driver %s from section %s\n", lpDriverName, lpSectionName);
+
+  else 
+        TRACE("OpenDriverA success: Driver handle => %08x\n", lpDrv);
 
   return lpDrv;
@@ -433 +432 @@
 #else
 /**************************************************************************
- *              DRIVER_TryOpenDriver16      [internal]
+ *                              DRIVER_TryOpenDriver16          [internal]
  *
  * Tries to load a 16 bit driver whose DLL's (module) name is lpFileName.
  */
-static  LPWINE_DRIVER   DRIVER_TryOpenDriver16(LPCSTR fn, LPCSTR sn, LPARAM lParam2)
-{
-    LPWINE_DRIVER   lpDrv = NULL;
-    LPCSTR      cause = 0;
+static  LPWINE_DRIVER   DRIVER_TryOpenDriver16(LPCSTR fn, LPCSTR sn, LPARAM lParam2)
+{
+    LPWINE_DRIVER       lpDrv = NULL;
+    LPCSTR              cause = 0;
 
     TRACE("('%s', %08lX);\n", sn, lParam2);
-
+    
     lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
     if (lpDrv == NULL) {cause = "OOM"; goto exit;}
 
     /* FIXME: shall we do some black magic here on sn ?
-     *  drivers32 => drivers
-     *  mci32 => mci
+     *  drivers32 => drivers
+     *  mci32 => mci
      * ...
      */
@@ -468 +467 @@
 
 /**************************************************************************
- *              OpenDriverA             [WINMM.15]
+ *                              OpenDriverA                     [WINMM.15]
  * (0,1,DRV_LOAD  ,0       ,0)
  * (0,1,DRV_ENABLE,0       ,0)
  * (0,1,DRV_OPEN  ,buf[256],0)
  */
-HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2)
-{
-    LPWINE_DRIVER   lpDrv = NULL;
-    char        libName[128];
-    LPCSTR      lsn = lpSectionName;
+HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2) 
+{
+    LPWINE_DRIVER       lpDrv = NULL;
+    char                libName[128];
+    LPCSTR              lsn = lpSectionName;
 
     TRACE("(%s, %s, 0x%08lx);\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName), lParam2);
-
+    
     if (lsn == NULL) {
-    lstrcpynA(libName, lpDriverName, sizeof(libName));
-
-    if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
-        goto the_end;
-    lsn = "Drivers32";
+        lstrcpynA(libName, lpDriverName, sizeof(libName));
+
+        if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
+            goto the_end;
+        lsn = "Drivers32";
     }
     if (DRIVER_GetLibName(lpDriverName, lsn, libName, sizeof(libName)) &&
-    (lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
-    goto the_end;
+        (lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
+        goto the_end;
 
     if (!(lpDrv = DRIVER_TryOpenDriver16(lpDriverName, lpSectionName, lParam2)))
-    TRACE("Failed to open driver %s from system.ini file, section %s\n", lpDriverName, lpSectionName);
+        TRACE("Failed to open driver %s from system.ini file, section %s\n", lpDriverName, lpSectionName);
 
  the_end:
-    if (lpDrv)  TRACE("=> %08lx\n", (DWORD)lpDrv);
+    if (lpDrv)  TRACE("=> %08lx\n", (DWORD)lpDrv);
     return (DWORD)lpDrv;
 }
 
 /**************************************************************************
- *              OpenDriverW             [WINMM.15]
+ *                              OpenDriverW                     [WINMM.15]
  */
 HDRVR WINAPI OpenDriverW(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam)
 {
-    LPSTR       dn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpDriverName);
-    LPSTR       sn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpSectionName);
-    HDRVR       ret = OpenDriverA(dn, sn, lParam);
-
+    LPSTR               dn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpDriverName);
+    LPSTR               sn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpSectionName);
+    HDRVR               ret = OpenDriverA(dn, sn, lParam);
+    
     if (dn) HeapFree(GetProcessHeap(), 0, dn);
     if (sn) HeapFree(GetProcessHeap(), 0, sn);
@@ -515 +514 @@
 
 /**************************************************************************
- *          CloseDriver             [WINMM.4]
+ *                      CloseDriver                             [WINMM.4]
  */
 LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
 {
-    LPWINE_DRIVER   lpDrv;
+    LPWINE_DRIVER       lpDrv;
 
     TRACE("(%04x, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
-
+    
     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
 #ifndef __WIN32OS2__
-    if (lpDrv->dwFlags & WINE_GDF_16BIT)
-        CloseDriver16(lpDrv->d.d16.hDriver16, lParam1, lParam2);
-    else
+        if (lpDrv->dwFlags & WINE_GDF_16BIT)
+            CloseDriver16(lpDrv->d.d16.hDriver16, lParam1, lParam2);
+        else
 #endif
-        DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
-    if (DRIVER_RemoveFromList(lpDrv)) {
-        HeapFree(GetProcessHeap(), 0, lpDrv);
-        return TRUE;
-    }
+            DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
+        if (DRIVER_RemoveFromList(lpDrv)) {
+            HeapFree(GetProcessHeap(), 0, lpDrv);
+            return TRUE;
+        }
     }
     WARN("Failed to close driver\n");
@@ -540 +539 @@
 
 /**************************************************************************
- *              GetDriverFlags      [WINMM.13]
+ *                              GetDriverFlags          [WINMM.13]
  * [in] hDrvr handle to the driver
  *
  * Returns:
- *  0x00000000 if hDrvr is an invalid handle
- *  0x80000000 if hDrvr is a valid 32 bit driver
- *  0x90000000 if hDrvr is a valid 16 bit driver
+ *      0x00000000 if hDrvr is an invalid handle
+ *      0x80000000 if hDrvr is a valid 32 bit driver
+ *      0x90000000 if hDrvr is a valid 16 bit driver
  *
  * native WINMM doesn't return those flags
- *  0x80000000 for a valid 32 bit driver and that's it
- *  (I may have mixed up the two flags :-(
- */
-DWORD   WINAPI GetDriverFlags(HDRVR hDrvr)
-{
-    LPWINE_DRIVER   lpDrv;
-    DWORD       ret = 0;
+ *      0x80000000 for a valid 32 bit driver and that's it
+ *      (I may have mixed up the two flags :-(
+ */
+DWORD   WINAPI GetDriverFlags(HDRVR hDrvr)
+{
+    LPWINE_DRIVER       lpDrv;
+    DWORD               ret = 0;
 
     TRACE("(%04x)\n", hDrvr);
 
     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
-    ret = WINE_GDF_EXIST | lpDrv->dwFlags;
+        ret = WINE_GDF_EXIST | lpDrv->dwFlags;
     }
     return ret;
@@ -566 +565 @@
 
 /**************************************************************************
- *              GetDriverModuleHandle   [WINMM.14]
+ *                              GetDriverModuleHandle   [WINMM.14]
  */
 HMODULE WINAPI GetDriverModuleHandle(HDRVR hDrvr)
 {
-    LPWINE_DRIVER   lpDrv;
-    HMODULE     hModule = 0;
-
+    LPWINE_DRIVER       lpDrv;
+    HMODULE             hModule = 0;
+    
     TRACE("(%04x);\n", hDrvr);
-
+    
     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
-    if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
-        hModule = lpDrv->d.d32.hModule;
+        if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
+            hModule = lpDrv->d.d32.hModule;
     }
     TRACE("=> %04x\n", hModule);
@@ -585 +584 @@
 #ifndef __WIN32OS2__
 /**************************************************************************
- *              DrvOpen             [MMSYSTEM.1100]
+ *                              DrvOpen                 [MMSYSTEM.1100]
  */
 HDRVR16 WINAPI DrvOpen16(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
@@ -593 +592 @@
 
 /**************************************************************************
- *              DrvClose            [MMSYSTEM.1101]
+ *                              DrvClose                [MMSYSTEM.1101]
  */
 LRESULT WINAPI DrvClose16(HDRVR16 hDrv, LPARAM lParam1, LPARAM lParam2)
@@ -601 +600 @@
 
 /**************************************************************************
- *              DrvSendMessage      [MMSYSTEM.1102]
+ *                              DrvSendMessage          [MMSYSTEM.1102]
  */
 LRESULT WINAPI DrvSendMessage16(HDRVR16 hDrv, WORD msg, LPARAM lParam1,
-                LPARAM lParam2)
+                                LPARAM lParam2)
 {
     return SendDriverMessage16(hDrv, msg, lParam1, lParam2);
@@ -610 +609 @@
 
 /**************************************************************************
- *              DrvGetModuleHandle  [MMSYSTEM.1103]
+ *                              DrvGetModuleHandle      [MMSYSTEM.1103]
  */
 HANDLE16 WINAPI DrvGetModuleHandle16(HDRVR16 hDrv)
@@ -618 +617 @@
 
 /**************************************************************************
- *              DrvDefDriverProc    [MMSYSTEM.1104]
- */
-LRESULT WINAPI DrvDefDriverProc16(DWORD dwDriverID, HDRVR16 hDrv, WORD wMsg,
-                  DWORD dwParam1, DWORD dwParam2)
+ *                              DrvDefDriverProc        [MMSYSTEM.1104]
+ */
+LRESULT WINAPI DrvDefDriverProc16(DWORD dwDriverID, HDRVR16 hDrv, WORD wMsg, 
+                                  DWORD dwParam1, DWORD dwParam2)
 {
     return DefDriverProc16(dwDriverID, hDrv, wMsg, dwParam1, dwParam2);
@@ -628 +627 @@
 
 /**************************************************************************
- *              DefDriverProc             [WINMM.5]
+ *                              DefDriverProc                     [WINMM.5]
  */
 LRESULT WINAPI DefDriverProc(DWORD dwDriverIdentifier, HDRVR hDrv,
-                 UINT Msg, LPARAM lParam1, LPARAM lParam2)
+                             UINT Msg, LPARAM lParam1, LPARAM lParam2)
 {
     switch (Msg) {
@@ -649 +648 @@
 #ifndef __WIN32OS2__
 /**************************************************************************
- *              DriverProc          [MMSYSTEM.6]
- */
-LRESULT WINAPI DriverProc16(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg,
-                DWORD dwParam1, DWORD dwParam2)
+ *                              DriverProc                      [MMSYSTEM.6]
+ */
+LRESULT WINAPI DriverProc16(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg, 
+                            DWORD dwParam1, DWORD dwParam2)
 {
     TRACE("dwDevID=%08lx hDrv=%04x wMsg=%04x dwParam1=%08lx dwParam2=%08lx\n",
-      dwDevID, hDrv, wMsg, dwParam1, dwParam2);
+          dwDevID, hDrv, wMsg, dwParam1, dwParam2);
 
     return DrvDefDriverProc16(dwDevID, hDrv, wMsg, dwParam1, dwParam2);
@@ -663 +662 @@
 #ifdef __WIN32OS2__
 /**************************************************************************
- *              DriverCallback          [MMSYSTEM.31]
- */
-BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev,
-               UINT wMsg, DWORD dwUser, DWORD dwParam1,
-               DWORD dwParam2)
+ *                              DriverCallback                  [MMSYSTEM.31]
+ */
+BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev, 
+                           UINT wMsg, DWORD dwUser, DWORD dwParam1, 
+                           DWORD dwParam2)
 {
     TRACE("DriverCallback (%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n",
-      dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
+          dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
 
     switch (uFlags & DCB_TYPEMASK) {
     case DCB_NULL:
-    TRACE("Null !\n");
-    if (dwCallBack)
-        WARN("uFlags=%04X has null DCB value, but dwCallBack=%08lX is not null !\n", uFlags, dwCallBack);
-    break;
+        TRACE("Null !\n");
+        if (dwCallBack)
+            WARN("uFlags=%04X has null DCB value, but dwCallBack=%08lX is not null !\n", uFlags, dwCallBack);
+        break;
     case DCB_WINDOW:
-    TRACE("Window(%04lX) handle=%04X!\n", dwCallBack, hDev);
-    if (!IsWindow(dwCallBack))
-        return FALSE;
-    PostMessageA((HWND)dwCallBack, wMsg, hDev, dwParam1);
-    break;
+        TRACE("Window(%04lX) handle=%04X!\n", dwCallBack, hDev);
+        if (!IsWindow(dwCallBack))
+            return FALSE;
+        PostMessageA((HWND)dwCallBack, wMsg, hDev, dwParam1);
+        break;
     case DCB_TASK: /* aka DCB_THREAD */
-    TRACE("Task(%04lx) !\n", dwCallBack);
-    PostThreadMessageA(dwCallBack, wMsg, hDev, dwParam1);
-    break;
+        TRACE("Task(%04lx) !\n", dwCallBack);
+        PostThreadMessageA(dwCallBack, wMsg, hDev, dwParam1);
+        break;
     case DCB_FUNCTION:
-    TRACE("Function (32 bit) !\n");
-    ((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
-    break;
+        TRACE("Function (32 bit) !\n");
+        ((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
+        break;
     case DCB_EVENT:
-    TRACE("Event(%08lx) !\n", dwCallBack);
-    SetEvent((HANDLE)dwCallBack);
-    break;
+        TRACE("Event(%08lx) !\n", dwCallBack);
+        SetEvent((HANDLE)dwCallBack);
+        break;
     case 6: /* I would dub it DCB_MMTHREADSIGNAL */
-    /* this is an undocumented DCB_ value used for mmThreads
-     * loword of dwCallBack contains the handle of the lpMMThd block
-     * which dwSignalCount has to be incremented
-     */
-    {
+        /* this is an undocumented DCB_ value used for mmThreads
+         * loword of dwCallBack contains the handle of the lpMMThd block
+         * which dwSignalCount has to be incremented
+         */
+        {
 #ifdef __WIN32OS2__
-        WINE_MMTHREAD*  lpMMThd = (WINE_MMTHREAD*)dwCallBack;
+            WINE_MMTHREAD*      lpMMThd = (WINE_MMTHREAD*)dwCallBack;
 #else
-        WINE_MMTHREAD*  lpMMThd = MapSL( MAKESEGPTR(LOWORD(dwCallBack), 0) );
+            WINE_MMTHREAD*      lpMMThd = MapSL( MAKESEGPTR(LOWORD(dwCallBack), 0) );
 #endif
 
-        TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack), lpMMThd);
-        /* same as mmThreadSignal16 */
-        InterlockedIncrement(&lpMMThd->dwSignalCount);
-        SetEvent(lpMMThd->hEvent);
-        /* some other stuff on lpMMThd->hVxD */
-    }
-    break;
+            TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack), lpMMThd);
+            /* same as mmThreadSignal16 */
+            InterlockedIncrement(&lpMMThd->dwSignalCount);
+            SetEvent(lpMMThd->hEvent);
+            /* some other stuff on lpMMThd->hVxD */
+        }
+        break;  
 #if 0
     case 4:
-    /* this is an undocumented DCB_ value for... I don't know */
-    break;
+        /* this is an undocumented DCB_ value for... I don't know */
+        break;
 #endif
     default:
-    WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
-    return FALSE;
+        WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
+        return FALSE;
     }
     TRACE("Done\n");