Changeset 3925 for trunk/src/msacm32


Ignore:
Timestamp:
Aug 2, 2000, 5:51:35 PM (25 years ago)
Author:
bird
Message:

Added the CVS keyword Id.

Location:
trunk/src/msacm32
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/msacm32/driver.cpp

    r2103 r3925  
     1/* $Id: driver.cpp,v 1.3 2000-08-02 15:49:31 bird Exp $ */
    12/*
    23 *      MSACM32 library
    … …  
    2122
    2223DEFAULT_DEBUG_CHANNEL(msacm)
    23        
     24
    2425/***********************************************************************
    2526 *           acmDriverAddA (MSACM32.2)
    … …  
    3031    if (!phadid)
    3132        return MMSYSERR_INVALPARAM;
    32    
     33
    3334    /* Check if any unknown flags */
    34     if (fdwAdd & 
     35    if (fdwAdd &
    3536        ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
    3637          ACM_DRIVERADDF_GLOBAL))
    3738        return MMSYSERR_INVALFLAG;
    38    
     39
    3940    /* Check if any incompatible flags */
    40     if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) && 
     41    if ((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
    4142        (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND))
    4243        return MMSYSERR_INVALFLAG;
    43    
    44     /* FIXME: in fact, should GetModuleFileName(hinstModule) and do a 
     44
     45    /* FIXME: in fact, should GetModuleFileName(hinstModule) and do a
    4546     * LoadDriver on it, to be sure we can call SendDriverMessage on the
    4647     * hDrvr handle.
    4748     */
    4849    *phadid = (HACMDRIVERID) MSACM_RegisterDriver(NULL, NULL, hinstModule);
    49    
     50
    5051    /* FIXME: lParam, dwPriority and fdwAdd ignored */
    51    
     52
    5253    return MMSYSERR_NOERROR;
    5354}
    … …  
    6364    dprintf(("(%p, 0x%08x, %ld, %ld, %ld): stub\n",
    6465          phadid, hinstModule, lParam, dwPriority, fdwAdd));
    65    
     66
    6667    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    6768    return MMSYSERR_ERROR;
    … …  
    7576    PWINE_ACMDRIVER  p;
    7677    PWINE_ACMDRIVER* tp;
    77    
     78
    7879    if (fdwClose)
    7980        return MMSYSERR_INVALFLAG;
    80    
     81
    8182    p = MSACM_GetDriver(had);
    8283    if (!p)
    … …  
    8990        }
    9091    }
    91    
     92
    9293    if (p->hDrvr && !p->obj.pACMDriverID->pACMDriverList)
    9394        CloseDriver(p->hDrvr, 0, 0);
    94    
     95
    9596    HeapFree(MSACM_hHeap, 0, p);
    96    
     97
    9798    return MMSYSERR_NOERROR;
    9899}
    … …  
    105106    MMRESULT mmr;
    106107    ACMDRIVERDETAILSW   addw;
    107    
     108
    108109    addw.cbStruct = sizeof(addw);
    109110    mmr = acmDriverDetailsW(hadid, &addw, fdwDetails);
    110111    if (mmr == 0) {
    111         padd->fccType = addw.fccType; 
    112         padd->fccComp = addw.fccComp; 
    113         padd->wMid = addw.wMid; 
    114         padd->wPid = addw.wPid; 
    115         padd->vdwACM = addw.vdwACM; 
    116         padd->vdwDriver = addw.vdwDriver; 
    117         padd->fdwSupport = addw.fdwSupport; 
    118         padd->cFormatTags = addw.cFormatTags; 
    119         padd->cFilterTags = addw.cFilterTags; 
    120         padd->hicon = addw.hicon; 
     112        padd->fccType = addw.fccType;
     113        padd->fccComp = addw.fccComp;
     114        padd->wMid = addw.wMid;
     115        padd->wPid = addw.wPid;
     116        padd->vdwACM = addw.vdwACM;
     117        padd->vdwDriver = addw.vdwDriver;
     118        padd->fdwSupport = addw.fdwSupport;
     119        padd->cFormatTags = addw.cFormatTags;
     120        padd->cFilterTags = addw.cFilterTags;
     121        padd->hicon = addw.hicon;
    121122        lstrcpyWtoA(padd->szShortName, addw.szShortName);
    122123        lstrcpyWtoA(padd->szLongName, addw.szLongName);
    … …  
    135136    HACMDRIVER acmDrvr;
    136137    MMRESULT mmr;
    137    
     138
    138139    if (fdwDetails)
    139140        return MMSYSERR_INVALFLAG;
    140    
     141
    141142    mmr = acmDriverOpen(&acmDrvr, hadid, 0);
    142143    if (mmr == 0) {
    143144        mmr = (MMRESULT)acmDriverMessage(acmDrvr, ACMDM_DRIVER_DETAILS, (LPARAM) padd,  0);
    144    
     145
    145146        acmDriverClose(acmDrvr, 0);
    146147    }
    147    
     148
    148149    return mmr;
    149150}
    … …  
    160161        return MMSYSERR_INVALPARAM;
    161162    }
    162    
     163
    163164    if (fdwEnum && ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED)) {
    164165        return MMSYSERR_INVALFLAG;
    165166    }
    166    
     167
    167168    for (p = MSACM_pFirstACMDriverID; p; p = p->pNextACMDriverID) {
    168169        fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
    … …  
    175176        (*fnCallback)((HACMDRIVERID) p, dwInstance, fdwSupport);
    176177    }
    177    
     178
    178179    return MMSYSERR_NOERROR;
    179180}
    … …  
    185186{
    186187    PWINE_ACMOBJ pao;
    187    
     188
    188189    pao = MSACM_GetObj(hao);
    189190    if (!pao)
    190191        return MMSYSERR_INVALHANDLE;
    191    
     192
    192193    if (!phadid)
    193194        return MMSYSERR_INVALPARAM;
    194    
     195
    195196    if (fdwDriverID)
    196197        return MMSYSERR_INVALFLAG;
    197    
     198
    198199    *phadid = (HACMDRIVERID) pao->pACMDriverID;
    199    
     200
    200201    return MMSYSERR_NOERROR;
    201202}
    … …  
    211212    if (!pad)
    212213        return MMSYSERR_INVALPARAM;
    213    
     214
    214215    /* FIXME: Check if uMsg legal */
    215    
     216
    216217    if (!SendDriverMessage(pad->hDrvr, uMsg, lParam1, lParam2))
    217218        return MMSYSERR_NOTSUPPORTED;
    218    
     219
    219220    return MMSYSERR_NOERROR;
    220221}
    … …  
    233234    if (!phad)
    234235        return MMSYSERR_INVALPARAM;
    235    
    236     padid = MSACM_GetDriverID(hadid); 
     236
     237    padid = MSACM_GetDriverID(hadid);
    237238    if (!padid)
    238239        return MMSYSERR_INVALHANDLE;
    239    
     240
    240241    if (fdwOpen)
    241242        return MMSYSERR_INVALFLAG;
    242    
     243
    243244    pad = PWINE_ACMDRIVER(HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER)));
    244245    if (!pad) return MMSYSERR_NOMEM;
    245246
    246247    pad->obj.pACMDriverID = padid;
    247    
     248
    248249    if (!padid->hInstModule)
    249250        pad->hDrvr = OpenDriverA(padid->pszDriverAlias, "drivers32", 0);
    250251    else
    251252        pad->hDrvr = padid->hInstModule;
    252    
     253
    253254    if (!pad->hDrvr) {
    254255        HeapFree(MSACM_hHeap, 0, pad);
    255256        return MMSYSERR_ERROR;
    256257    }
    257    
     258
    258259//    pad->pfnDriverProc = GetProcAddress(pad->hDrvr, "DriverProc");
    259260
    … …  
    264265    /* FIXME: Create a WINE_ACMDRIVER32 */
    265266    *phad = (HACMDRIVER)pad;
    266    
     267
    267268//    return MMSYSERR_NOERROR;
    268269    return MMSYSERR_ERROR;
    … …  
    281282    HKEY hPriorityKey;
    282283    DWORD dwPriorityCounter;
    283    
     284
    284285    padid = MSACM_GetDriverID(hadid);
    285286    if (!padid)
    286287        return MMSYSERR_INVALHANDLE;
    287    
     288
    288289    /* Check for unknown flags */
    289     if (fdwPriority & 
     290    if (fdwPriority &
    290291        ~(ACM_DRIVERPRIORITYF_ENABLE|ACM_DRIVERPRIORITYF_DISABLE|
    291292          ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END))
    292293        return MMSYSERR_INVALFLAG;
    293    
     294
    294295    /* Check for incompatible flags */
    295296    if ((fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) &&
    296297        (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE))
    297298        return MMSYSERR_INVALFLAG;
    298    
     299
    299300    /* Check for incompatible flags */
    300301    if ((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) &&
    301302        (fdwPriority & ACM_DRIVERPRIORITYF_END))
    302303        return MMSYSERR_INVALFLAG;
    303    
    304     lError = RegOpenKeyA(HKEY_CURRENT_USER, 
     304
     305    lError = RegOpenKeyA(HKEY_CURRENT_USER,
    305306                         "Software\\Microsoft\\Multimedia\\"
    306307                         "Audio Compression Manager\\Priority v4.00",
    … …  
    310311    if (lError != ERROR_SUCCESS)
    311312        return MMSYSERR_ERROR;
    312    
     313
    313314    for (dwPriorityCounter = 1; ; dwPriorityCounter++)  {
    314315        wsnprintfA(szSubKey, 17, "Priorty%ld", dwPriorityCounter);
    … …  
    316317        if (lError != ERROR_SUCCESS)
    317318            break;
    318        
    319         dprintf(("(0x%08x, %ld, %ld): stub (partial)\n", 
     319
     320        dprintf(("(0x%08x, %ld, %ld): stub (partial)\n",
    320321              hadid, dwPriority, fdwPriority));
    321322        break;
    322323    }
    323    
     324
    324325    RegCloseKey(hPriorityKey);
    325    
     326
    326327    return MMSYSERR_ERROR;
    327328}
    … …  
    333334{
    334335    PWINE_ACMDRIVERID padid;
    335    
     336
    336337    padid = MSACM_GetDriverID(hadid);
    337338    if (!padid)
    338339        return MMSYSERR_INVALHANDLE;
    339    
     340
    340341    if (fdwRemove)
    341342        return MMSYSERR_INVALFLAG;
    342    
     343
    343344    MSACM_UnregisterDriver(padid);
    344    
    345     return MMSYSERR_NOERROR;
    346 }
    347 
     345
     346    return MMSYSERR_NOERROR;
     347}
     348

  • trunk/src/msacm32/filter.cpp

    r1607 r3925  
     1/* $Id: filter.cpp,v 1.2 2000-08-02 15:49:31 bird Exp $ */
    12/*
    23 *      MSACM32 library
    … …  
    7273 */
    7374MMRESULT WINAPI acmFilterEnumA(
    74   HACMDRIVER had, PACMFILTERDETAILSA pafd, 
     75  HACMDRIVER had, PACMFILTERDETAILSA pafd,
    7576  ACMFILTERENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
    7677{
    … …  
    8687 */
    8788MMRESULT WINAPI acmFilterEnumW(
    88   HACMDRIVER had, PACMFILTERDETAILSW pafd, 
     89  HACMDRIVER had, PACMFILTERDETAILSW pafd,
    8990  ACMFILTERENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
    9091{
    … …  
    102103  HACMDRIVER had, PACMFILTERTAGDETAILSA paftd, DWORD fdwDetails)
    103104{
    104   if(fdwDetails & 
     105  if(fdwDetails &
    105106     ~(ACM_FILTERTAGDETAILSF_FILTERTAG|
    106107       ACM_FILTERTAGDETAILSF_LARGESTSIZE))

  • trunk/src/msacm32/format.cpp

    r1607 r3925  
     1/* $Id: format.cpp,v 1.2 2000-08-02 15:49:32 bird Exp $ */
    12/*
    23 *      MSACM32 library
    … …  
    117118  HACMDRIVER had, PACMFORMATTAGDETAILSA paftd, DWORD fdwDetails)
    118119{
    119   if(fdwDetails & 
     120  if(fdwDetails &
    120121     ~(ACM_FORMATTAGDETAILSF_FORMATTAG|ACM_FORMATTAGDETAILSF_LARGESTSIZE))
    121122    return MMSYSERR_INVALFLAG;
    … …  
    152153  dprintf(("(0x%08x, %p, %p, %ld, %ld): stub\n",
    153154    had, paftd, fnCallback, dwInstance, fdwEnum
    154   )); 
     155  ));
    155156  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    156157  return MMSYSERR_ERROR;
    … …  
    166167  dprintf(("(0x%08x, %p, %p, %ld, %ld): stub\n",
    167168    had, paftd, fnCallback, dwInstance, fdwEnum
    168   )); 
     169  ));
    169170  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    170171  return MMSYSERR_ERROR;

  • trunk/src/msacm32/internal.cpp

    r2105 r3925  
     1/* $Id: internal.cpp,v 1.5 2000-08-02 15:49:32 bird Exp $ */
    12/* -*- tab-width: 8; c-basic-offset: 4 -*- */
    23
    … …  
    2223#include "debugtools.h"
    2324
    24 DEFAULT_DEBUG_CHANNEL(msacm)   
     25DEFAULT_DEBUG_CHANNEL(msacm)
    2526
    2627/**********************************************************************/
    … …  
    3132
    3233/***********************************************************************
    33  *           MSACM_RegisterDriver32() 
     34 *           MSACM_RegisterDriver32()
    3435 */
    3536PWINE_ACMDRIVERID MSACM_RegisterDriver(LPSTR pszDriverAlias, LPSTR pszFileName,
    3637                                       HINSTANCE hinstModule)
    37 { 
     38{
    3839    PWINE_ACMDRIVERID padid;
    3940
    … …  
    5354    if (!MSACM_pFirstACMDriverID)
    5455        MSACM_pFirstACMDriverID = padid;
    55    
     56
    5657    return padid;
    5758}
    5859
    5960/***********************************************************************
    60  *           MSACM_RegisterAllDrivers32() 
     61 *           MSACM_RegisterAllDrivers32()
    6162 */
    6263void MSACM_RegisterAllDrivers(void)
    … …  
    6465    LPSTR pszBuffer;
    6566    DWORD dwBufferLength;
    66    
    67     /* FIXME 
     67
     68    /* FIXME
    6869     *  What if the user edits system.ini while the program is running?
    6970     *  Does Windows handle that?
    … …  
    7172    if (MSACM_pFirstACMDriverID)
    7273        return;
    73    
     74
    7475    /* FIXME: Do not work! How do I determine the section length? */
    7576    dwBufferLength = 1024;
    7677/* EPP  GetPrivateProfileSectionA("drivers32", NULL, 0, "system.ini"); */
    77    
     78
    7879    pszBuffer = (LPSTR) HeapAlloc(MSACM_hHeap, 0, dwBufferLength);
    7980    if (GetPrivateProfileSectionA("drivers32", pszBuffer, dwBufferLength, "system.ini")) {
    … …  
    8788                    MSACM_RegisterDriver(s, s2, 0);
    8889                }
    89             } 
     90            }
    9091            s += lstrlenA(s) + 1; /* Either next char or \0 */
    9192        }
    9293    }
    93    
     94
    9495    HeapFree(MSACM_hHeap, 0, pszBuffer);
    9596}
    … …  
    101102{
    102103    PWINE_ACMDRIVERID pNextACMDriverID;
    103    
     104
    104105    if (p->pACMDriverList)
    105106        acmDriverClose((HACMDRIVER) p->pACMDriverList, 0);
    106    
     107
    107108    if (p->pszDriverAlias)
    108109        HeapFree(MSACM_hHeap, 0, p->pszDriverAlias);
    109110    if (p->pszFileName)
    110111        HeapFree(MSACM_hHeap, 0, p->pszFileName);
    111    
     112
    112113    if (p == MSACM_pFirstACMDriverID)
    113114        MSACM_pFirstACMDriverID = p->pNextACMDriverID;
    … …  
    119120    if (p->pNextACMDriverID)
    120121        p->pNextACMDriverID->pPrevACMDriverID = p->pPrevACMDriverID;
    121    
     122
    122123    pNextACMDriverID = p->pNextACMDriverID;
    123    
     124
    124125    HeapFree(MSACM_hHeap, 0, p);
    125    
     126
    126127    return pNextACMDriverID;
    127128}
    … …  
    140141
    141142/***********************************************************************
    142  *           MSACM_GetDriverID32() 
     143 *           MSACM_GetDriverID32()
    143144 */
    144145PWINE_ACMDRIVERID MSACM_GetDriverID(HACMDRIVERID hDriverID)

  • trunk/src/msacm32/msacm32.cpp

    r2103 r3925  
     1/* $Id: msacm32.cpp,v 1.6 2000-08-02 15:49:32 bird Exp $ */
    12/* -*- tab-width: 8; c-basic-offset: 4 -*- */
    23
    … …  
    1920
    2021DEFAULT_DEBUG_CHANNEL(msacm)
    21        
     22
    2223/**********************************************************************/
    23        
     24
    2425static DWORD MSACM_dwProcessesAttached = 0;
    2526
    2627/***********************************************************************
    27  *           MSACM_LibMain32 (MSACM32.init) 
     28 *           MSACM_LibMain32 (MSACM32.init)
    2829 */
    2930BOOL WINAPI MSACM32_LibMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved)
    … …  
    6970{
    7071    switch (GetVersion()) {
    71     default: 
     72    default:
    7273        dprintf(("Current OS not supported\n"));
    7374    case WIN95:
    … …  
    9596
    9697    dprintf(("(0x%08x, %d, %p): stub\n", hao, uMetric, pMetric));
    97    
     98
    9899    switch (uMetric) {
    99100    case ACM_METRIC_COUNT_DRIVERS:
    … …  
    149150    case ACM_METRIC_COUNT_LOCAL_DISABLED:
    150151        if (!pao)
    151             return MMSYSERR_INVALHANDLE; 
     152            return MMSYSERR_INVALHANDLE;
    152153        for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID)
    153154            if (!padid->bEnabled /* && (local(padid) || !bLocal) */)

  • trunk/src/msacm32/stream.cpp

    r2103 r3925  
     1/* $Id: stream.cpp,v 1.3 2000-08-02 15:49:32 bird Exp $ */
    12/* -*- tab-width: 8; c-basic-offset: 4 -*- */
    23
    … …  
    2728
    2829DEFAULT_DEBUG_CHANNEL(msacm)
    29    
     30
    3031static PWINE_ACMSTREAM  ACM_GetStream(HACMSTREAM has)
    3132{
    … …  
    4041    PWINE_ACMSTREAM     was;
    4142    MMRESULT            ret;
    42                
     43
    4344    dprintf(("(0x%08x, %ld)\n", has, fdwClose));
    44    
     45
    4546    if ((was = ACM_GetStream(has)) == NULL) {
    4647        return MMSYSERR_INVALHANDLE;
    … …  
    4950    if (ret == MMSYSERR_NOERROR) {
    5051        if (was->hAcmDriver)
    51             acmDriverClose(was->hAcmDriver, 0L);       
     52            acmDriverClose(was->hAcmDriver, 0L);
    5253        HeapFree(MSACM_hHeap, 0, was);
    5354    }
    … …  
    5960 *           acmStreamConvert (MSACM32.38)
    6061 */
    61 MMRESULT WINAPI acmStreamConvert(HACMSTREAM has, PACMSTREAMHEADER pash, 
     62MMRESULT WINAPI acmStreamConvert(HACMSTREAM has, PACMSTREAMHEADER pash,
    6263                                 DWORD fdwConvert)
    6364{
    … …  
    6768
    6869    dprintf(("(0x%08x, %p, %ld)\n", has, pash, fdwConvert));
    69    
     70
    7071    if ((was = ACM_GetStream(has)) == NULL)
    7172        return MMSYSERR_INVALHANDLE;
    … …  
    8889        padsh->cbPreparedDstLength < padsh->cbDstLength) {
    8990        return MMSYSERR_INVALPARAM;
    90     }   
     91    }
    9192
    9293    padsh->fdwConvert = fdwConvert;
    … …  
    103104 *           acmStreamMessage (MSACM32.39)
    104105 */
    105 MMRESULT WINAPI acmStreamMessage(HACMSTREAM has, UINT uMsg, LPARAM lParam1, 
     106MMRESULT WINAPI acmStreamMessage(HACMSTREAM has, UINT uMsg, LPARAM lParam1,
    106107                                 LPARAM lParam2)
    107108{
    … …  
    123124    int                 wfxSrcSize;
    124125    int                 wfxDstSize;
    125    
     126
    126127    dprintf(("(%p, 0x%08x, %p, %p, %p, %ld, %ld, %ld)\n",
    127128          phas, had, pwfxSrc, pwfxDst, pwfltr, dwCallback, dwInstance, fdwOpen));
    128129
    129     dprintf(("src [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n", 
    130           pwfxSrc->wFormatTag, pwfxSrc->nChannels, pwfxSrc->nSamplesPerSec, pwfxSrc->nAvgBytesPerSec, 
     130    dprintf(("src [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
     131          pwfxSrc->wFormatTag, pwfxSrc->nChannels, pwfxSrc->nSamplesPerSec, pwfxSrc->nAvgBytesPerSec,
    131132          pwfxSrc->nBlockAlign, pwfxSrc->wBitsPerSample, pwfxSrc->cbSize));
    132133
    133     dprintf(("dst [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n", 
    134           pwfxDst->wFormatTag, pwfxDst->nChannels, pwfxDst->nSamplesPerSec, pwfxDst->nAvgBytesPerSec, 
     134    dprintf(("dst [wFormatTag=%u, nChannels=%u, nSamplesPerSec=%lu, nAvgBytesPerSec=%lu, nBlockAlign=%u, wBitsPerSample=%u, cbSize=%u]\n",
     135          pwfxDst->wFormatTag, pwfxDst->nChannels, pwfxDst->nSamplesPerSec, pwfxDst->nAvgBytesPerSec,
    135136          pwfxDst->nBlockAlign, pwfxDst->wBitsPerSample, pwfxDst->cbSize));
    136137
    … …  
    143144    if (was == NULL)
    144145        return MMSYSERR_NOMEM;
    145    
     146
    146147    was->drvInst.cbStruct = sizeof(was->drvInst);
    147148    was->drvInst.pwfxSrc = (PWAVEFORMATEX)((LPSTR)was + sizeof(*was));
    … …  
    155156        was->drvInst.pwfltr = NULL;
    156157    }
    157     was->drvInst.dwCallback = dwCallback;   
     158    was->drvInst.dwCallback = dwCallback;
    158159    was->drvInst.dwInstance = dwInstance;
    159160    was->drvInst.fdwOpen = fdwOpen;
    160     was->drvInst.fdwDriver = 0L; 
    161     was->drvInst.dwDriver = 0L;     
     161    was->drvInst.fdwDriver = 0L;
     162    was->drvInst.dwDriver = 0L;
    162163    was->drvInst.has = (HACMSTREAM)was;
    163    
     164
    164165    if (had) {
    165166        if (!(wad = MSACM_GetDriver(had))) {
    … …  
    167168            goto errCleanUp;
    168169        }
    169        
     170
    170171        was->obj.pACMDriverID = wad->obj.pACMDriverID;
    171172        was->pDrv = wad;
    … …  
    177178    } else {
    178179        PWINE_ACMDRIVERID wadi;
    179        
     180
    180181        ret = ACMERR_NOTPOSSIBLE;
    181182        for (wadi = MSACM_pFirstACMDriverID; wadi; wadi = wadi->pNextACMDriverID) {
    … …  
    186187                    was->pDrv = wad;
    187188                    was->hAcmDriver = had;
    188                    
     189
    189190                    ret = SendDriverMessage(wad->hDrvr, ACMDM_STREAM_OPEN, (DWORD)&was->drvInst, 0L);
    190191                    if (ret == MMSYSERR_NOERROR) {
    … …  
    211212        return ret;
    212213    }
    213 errCleanUp:             
     214errCleanUp:
    214215    if (phas)
    215216        *phas = (HACMSTREAM)0;
    … …  
    223224 *           acmStreamPrepareHeader (MSACM32.41)
    224225 */
    225 MMRESULT WINAPI acmStreamPrepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash, 
     226MMRESULT WINAPI acmStreamPrepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
    226227                                       DWORD fdwPrepare)
    227228{
    … …  
    231232
    232233    dprintf(("(0x%08x, %p, %ld)\n", has, pash, fdwPrepare));
    233    
     234
    234235    if ((was = ACM_GetStream(has)) == NULL)
    235236        return MMSYSERR_INVALHANDLE;
    … …  
    306307 *           acmStreamSize (MSACM32.43)
    307308 */
    308 MMRESULT WINAPI acmStreamSize(HACMSTREAM has, DWORD cbInput, 
     309MMRESULT WINAPI acmStreamSize(HACMSTREAM has, DWORD cbInput,
    309310                              LPDWORD pdwOutputBytes, DWORD fdwSize)
    310311{
    … …  
    312313    ACMDRVSTREAMSIZE    adss;
    313314    MMRESULT            ret;
    314    
     315
    315316    dprintf(("(0x%08x, %ld, %p, %ld)\n", has, cbInput, pdwOutputBytes, fdwSize));
    316    
     317
    317318    if ((was = ACM_GetStream(has)) == NULL) {
    318319        return MMSYSERR_INVALHANDLE;
    … …  
    323324
    324325    *pdwOutputBytes = 0L;
    325    
     326
    326327    switch (fdwSize & ACM_STREAMSIZEF_QUERYMASK) {
    327328    case ACM_STREAMSIZEF_DESTINATION:
    … …  
    333334        adss.cbDstLength = 0;
    334335        break;
    335     default:   
     336    default:
    336337        return MMSYSERR_INVALFLAG;
    337338    }
    338    
     339
    339340    adss.cbStruct = sizeof(adss);
    340341    adss.fdwSize = fdwSize;
    341     ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_SIZE, 
     342    ret = SendDriverMessage(was->pDrv->hDrvr, ACMDM_STREAM_SIZE,
    342343                            (DWORD)&was->drvInst, (DWORD)&adss);
    343344    if (ret == MMSYSERR_NOERROR) {
    … …  
    358359 *           acmStreamUnprepareHeader (MSACM32.44)
    359360 */
    360 MMRESULT WINAPI acmStreamUnprepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash, 
     361MMRESULT WINAPI acmStreamUnprepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash,
    361362                                         DWORD fdwUnprepare)
    362363{
    … …  
    366367
    367368    dprintf(("(0x%08x, %p, %ld)\n", has, pash, fdwUnprepare));
    368    
     369
    369370    if ((was = ACM_GetStream(has)) == NULL)
    370371        return MMSYSERR_INVALHANDLE;
    … …  
    387388        padsh->cbPreparedDstLength < padsh->cbDstLength) {
    388389        return MMSYSERR_INVALPARAM;
    389     }   
     390    }
    390391
    391392    padsh->fdwConvert = fdwUnprepare;
Note: See TracChangeset for help on using the changeset viewer.