Ignore:
Timestamp:
Nov 5, 1999, 10:19:27 AM (26 years ago)
Author:
sandervl
Message:

Jens Weissner's update

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/msacm32/msacm32.cpp

    r1118 r1607  
    1 /* $Id: msacm32.cpp,v 1.3 1999-10-04 09:55:58 sandervl Exp $ */
     1/* -*- tab-width: 8; c-basic-offset: 4 -*- */
     2
    23/*
    34 *      MSACM32 library
    45 *
    56 *      Copyright 1998  Patrik Stridvall
    6  *      Copyright 1999  Jens Wiessner
     7 *                1999  Eric Pouech
    78 */
    89
    910#include <os2win.h>
    10 #include <winerror.h>
    11 #include <windef.h>
    12 #include <winuser.h>
    13 #include <misc.h>
    14 #include <odinwrap.h>
     11#include "winbase.h"
     12#include "winerror.h"
     13#include "windef.h"
     14#include "debugtools.h"
    1515#include "msacm.h"
    1616#include "msacmdrv.h"
     17#include "wineacm.h"
    1718#include "winversion.h"
    18 #include "winreg.h"
    19 #include "debugtools.h"
    20 #include <debugdefs.h>
    21 
    2219
    2320DEFAULT_DEBUG_CHANNEL(msacm)
    24 
     21       
    2522/**********************************************************************/
    26 
     23       
    2724static DWORD MSACM_dwProcessesAttached = 0;
    2825
    … …  
    3027 *           MSACM_LibMain32 (MSACM32.init)
    3128 */
    32 BOOL WINAPI MSACM32_LibMain(
    33   HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
     29BOOL WINAPI MSACM32_LibMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved)
    3430{
    35   switch(fdwReason)
    36     {
     31    dprintf(("0x%x 0x%lx %p\n", hInstDLL, fdwReason, lpvReserved));
     32
     33    switch (fdwReason) {
    3734    case DLL_PROCESS_ATTACH:
    38       if(MSACM_dwProcessesAttached == 0)
    39         {
    40           MSACM_hHeap = HeapCreate(0, 0x10000, 0);
    41           MSACM_RegisterAllDrivers();
     35        if (MSACM_dwProcessesAttached == 0) {
     36            MSACM_hHeap = HeapCreate(0, 0x10000, 0);
     37            MSACM_RegisterAllDrivers();
    4238        }
    43       MSACM_dwProcessesAttached++;
    44       break;
     39        MSACM_dwProcessesAttached++;
     40        break;
    4541    case DLL_PROCESS_DETACH:
    46       MSACM_dwProcessesAttached--;
    47       if(MSACM_dwProcessesAttached == 0)
    48         {
    49           MSACM_UnregisterAllDrivers();
    50           HeapDestroy(MSACM_hHeap);
    51           MSACM_hHeap = (HANDLE) NULL;
     42        MSACM_dwProcessesAttached--;
     43        if (MSACM_dwProcessesAttached == 0) {
     44            MSACM_UnregisterAllDrivers();
     45            HeapDestroy(MSACM_hHeap);
     46            MSACM_hHeap = (HANDLE) NULL;
    5247        }
    53       break;
     48        break;
    5449    case DLL_THREAD_ATTACH:
    55       break;
     50        break;
    5651    case DLL_THREAD_DETACH:
    57       break;
     52        break;
    5853    default:
    59       break;
     54        break;
    6055    }
    61   return TRUE;
     56    return TRUE;
    6257}
    6358
    … …  
    6964
    7065/***********************************************************************
    71  *           acmDriverAddA (MSACM32.2)
     66 *           acmGetVersion32 (MSACM32.34)
    7267 */
    73 MMRESULT WINAPI acmDriverAddA(
    74   PHACMDRIVERID phadid, HINSTANCE hinstModule,
    75   LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
     68DWORD WINAPI acmGetVersion(void)
    7669{
    77 #ifdef DEBUG
    78   dprintf(("MSACM32: acmDriverAddA\n"));
    79 #endif
    80   PWINE_ACMLOCALDRIVER pld;
    81   if(!phadid)
    82     return MMSYSERR_INVALPARAM;
    83 
    84   /* Check if any unknown flags */
    85   if(fdwAdd &
    86      ~(ACM_DRIVERADDF_FUNCTION|ACM_DRIVERADDF_NOTIFYHWND|
    87        ACM_DRIVERADDF_GLOBAL))
    88     return MMSYSERR_INVALFLAG;
    89 
    90   /* Check if any incompatible flags */
    91   if((fdwAdd & ACM_DRIVERADDF_FUNCTION) &&
    92      (fdwAdd & ACM_DRIVERADDF_NOTIFYHWND))
    93     return MMSYSERR_INVALFLAG;
    94 
    95   pld = (PWINE_ACMLOCALDRIVER) HeapAlloc(MSACM_hHeap, 0, sizeof(WINE_ACMLOCALDRIVER));
    96   pld->pfnDriverProc = (DRIVERPROC)
    97     GetProcAddress(hinstModule, "DriverProc");
    98   *phadid = (HACMDRIVERID) MSACM_RegisterDriver(NULL, NULL, pld);
    99 
    100   /* FIXME: lParam, dwPriority and fdwAdd ignored */
    101 
    102   return MMSYSERR_NOERROR;
    103 }
    104 
    105 /***********************************************************************
    106  *           acmDriverAddW (MSACM32.3)
    107  * FIXME
    108  *   Not implemented
    109  */
    110 MMRESULT WINAPI acmDriverAddW(
    111   PHACMDRIVERID phadid, HINSTANCE hinstModule,
    112   LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
    113 {
    114 #ifdef DEBUG
    115   dprintf(("MSACM32: acmDriverAddW not implemented\n"));
    116 #endif
    117   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    118   return MMSYSERR_ERROR;
    119 }
    120 
    121 /***********************************************************************
    122  *           acmDriverClose (MSACM32.4)
    123  */
    124 MMRESULT WINAPI acmDriverClose(
    125   HACMDRIVER had, DWORD fdwClose)
    126 {
    127 #ifdef DEBUG
    128   dprintf(("MSACM32: acmDriverClose\n"));
    129 #endif
    130   PWINE_ACMDRIVER p;
    131 
    132   if(fdwClose)
    133     return MMSYSERR_INVALFLAG;
    134 
    135   p = MSACM_GetDriver(had);
    136   if(!p)
    137     return MMSYSERR_INVALHANDLE;
    138 
    139   p->obj.pACMDriverID->pACMDriver = NULL;
    140 
    141   if(p->hDrvr)
    142     CloseDriver(p->hDrvr, 0, 0);
    143 
    144   HeapFree(MSACM_hHeap, 0, p);
    145 
    146   return MMSYSERR_NOERROR;
    147 }
    148 
    149 /***********************************************************************
    150  *           acmDriverDetailsA (MSACM32.5)
    151  */
    152 MMRESULT WINAPI acmDriverDetailsA(
    153   HACMDRIVERID hadid, PACMDRIVERDETAILSA padd, DWORD fdwDetails)
    154 {
    155 #ifdef DEBUG
    156   dprintf(("MSACM32: acmDriverDetailsA\n"));
    157 #endif
    158   PWINE_ACMDRIVERID p;
    159   MMRESULT mmr;
    160   BOOL bOpenTemporary;
    161 
    162   p = MSACM_GetDriverID(hadid);
    163   if(!p)
    164     return MMSYSERR_INVALHANDLE;
    165  
    166   if(fdwDetails)
    167     return MMSYSERR_INVALFLAG;
    168 
    169   bOpenTemporary = !p->pACMDriver;
    170   if(bOpenTemporary) {
    171     bOpenTemporary = TRUE;
    172     acmDriverOpen((PHACMDRIVER) &p->pACMDriver, hadid, 0);
    173   }
    174  
    175   /* FIXME
    176    *   How does the driver know if the ANSI or
    177    *   the UNICODE variant of PACMDRIVERDETAILS is used?
    178    *   It might check cbStruct or does it only accept ANSI.
    179    */
    180   mmr = (MMRESULT) acmDriverMessage(
    181     (HACMDRIVER) p->pACMDriver, ACMDM_DRIVER_DETAILS,
    182     (LPARAM) padd,  0
    183   );
    184 
    185   if(bOpenTemporary) {
    186     acmDriverClose((HACMDRIVER) p->pACMDriver, 0);
    187     p->pACMDriver = NULL;
    188   }
    189 
    190   return mmr;
    191 }
    192 
    193 /***********************************************************************
    194  *           acmDriverDetailsW (MSACM32.6)
    195  * FIXME
    196  *   Not implemented
    197  */
    198 MMRESULT WINAPI acmDriverDetailsW(
    199   HACMDRIVERID hadid, PACMDRIVERDETAILSW padd, DWORD fdwDetails)
    200 {
    201 #ifdef DEBUG
    202   dprintf(("MSACM32: acmDriverDetailsW not implemented\n"));
    203 #endif
    204   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    205   return MMSYSERR_ERROR;
    206 }
    207 
    208 /***********************************************************************
    209  *           acmDriverEnum (MSACM32.7)
    210  */
    211 MMRESULT WINAPI acmDriverEnum(
    212   ACMDRIVERENUMCB fnCallback, DWORD dwInstance, DWORD fdwEnum)
    213 {
    214 #ifdef DEBUG
    215   dprintf(("MSACM32: acmDriverEnum\n"));
    216 #endif
    217   PWINE_ACMDRIVERID p;
    218 
    219   if(!fnCallback)
    220     {
    221       return MMSYSERR_INVALPARAM;
    222     }
    223 
    224   if(fdwEnum && ~(ACM_DRIVERENUMF_NOLOCAL|ACM_DRIVERENUMF_DISABLED))
    225     {
    226       return MMSYSERR_INVALFLAG;
    227     }
    228 
    229   p = MSACM_pFirstACMDriverID;
    230   while(p)
    231     {
    232       (*fnCallback)((HACMDRIVERID) p, dwInstance, ACMDRIVERDETAILS_SUPPORTF_CODEC);
    233       p = p->pNextACMDriverID;
    234     }
    235 
    236   return MMSYSERR_NOERROR;
    237 }
    238 
    239 /***********************************************************************
    240  *           acmDriverID (MSACM32.8)
    241  */
    242 MMRESULT WINAPI acmDriverID(
    243   HACMOBJ hao, PHACMDRIVERID phadid, DWORD fdwDriverID)
    244 {
    245 #ifdef DEBUG
    246   dprintf(("MSACM32: acmDriverID\n"));
    247 #endif
    248   PWINE_ACMOBJ pao;
    249 
    250   pao = MSACM_GetObj(hao);
    251   if(!pao)
    252     return MMSYSERR_INVALHANDLE;
    253 
    254   if(!phadid)
    255     return MMSYSERR_INVALPARAM;
    256 
    257   if(fdwDriverID)
    258     return MMSYSERR_INVALFLAG;
    259 
    260   *phadid = (HACMDRIVERID) pao->pACMDriverID;
    261 
    262   return MMSYSERR_NOERROR;
    263 }
    264 
    265 /***********************************************************************
    266  *           acmDriverMessage (MSACM32.9)
    267  * FIXME
    268  *   Not implemented
    269  */
    270 LRESULT WINAPI acmDriverMessage(
    271   HACMDRIVER had, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
    272 {
    273 #ifdef DEBUG
    274   dprintf(("MSACM32: acmDriverMessage not implemented\n"));
    275 #endif
    276   PWINE_ACMDRIVER pad = MSACM_GetDriver(had);
    277   if(!pad)
    278     return MMSYSERR_INVALPARAM;
    279 
    280   /* FIXME: Check if uMsg legal */
    281 
    282   if(!SendDriverMessage(pad->hDrvr, uMsg, lParam1, lParam2))
    283     return MMSYSERR_NOTSUPPORTED;
    284 
    285   return MMSYSERR_NOERROR;
    286 }
    287 
    288 
    289 /***********************************************************************
    290  *           acmDriverOpen (MSACM32.10)
    291  */
    292 MMRESULT WINAPI acmDriverOpen(
    293   PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
    294 {
    295 #ifdef DEBUG
    296   dprintf(("MSACM32: acmDriverOpen\n"));
    297 #endif
    298   PWINE_ACMDRIVERID padid;
    299 
    300   if(!phad)
    301     return MMSYSERR_INVALPARAM;
    302 
    303   padid = MSACM_GetDriverID(hadid);
    304   if(!padid)
    305     return MMSYSERR_INVALHANDLE;
    306 
    307   if(fdwOpen)
    308     return MMSYSERR_INVALFLAG;
    309 
    310   if(padid->pACMDriver)
    311     {
    312       /* FIXME: Is it allowed? */
    313       return MMSYSERR_ERROR;
    314     }
    315 
    316   padid->pACMDriver = (PWINE_ACMDRIVER) HeapAlloc(
    317     MSACM_hHeap, 0, sizeof(WINE_ACMDRIVER)
    318   );
    319   padid->pACMDriver->obj.pACMDriverID = padid;
    320  
    321   if(!padid->pACMLocalDriver)
    322       padid->pACMDriver->hDrvr =
    323         OpenDriverA(padid->pszDriverAlias, "drivers32", 0);
    324   else
    325     {
    326       padid->pACMDriver->hDrvr = MSACM_OpenDriverProc(
    327         padid->pACMLocalDriver->pfnDriverProc
    328       );
    329     }
    330 
    331   if(!padid->pACMDriver->hDrvr)
    332     return MMSYSERR_ERROR;
    333  
    334   /* FIXME: Create a WINE_ACMDRIVER32 */
    335   *phad = (HACMDRIVER) NULL;
    336 
    337   return MMSYSERR_ERROR;
    338 }
    339 
    340 /***********************************************************************
    341  *           acmDriverPriority (MSACM32.11)
    342  */
    343 MMRESULT WINAPI acmDriverPriority(
    344   HACMDRIVERID hadid, DWORD dwPriority, DWORD fdwPriority)
    345 {
    346 #ifdef DEBUG
    347   dprintf(("MSACM32: acmDriverPriority\n"));
    348 #endif
    349   PWINE_ACMDRIVERID padid;
    350   CHAR szSubKey[17];
    351   CHAR szBuffer[256];
    352   LONG lBufferLength = sizeof(szBuffer);
    353   LONG lError;
    354   HKEY hPriorityKey;
    355   DWORD dwPriorityCounter;
    356 
    357   padid = MSACM_GetDriverID(hadid);
    358   if(!padid)
    359     return MMSYSERR_INVALHANDLE;
    360 
    361   /* Check for unknown flags */
    362   if(fdwPriority &
    363      ~(ACM_DRIVERPRIORITYF_ENABLE|ACM_DRIVERPRIORITYF_DISABLE|
    364        ACM_DRIVERPRIORITYF_BEGIN|ACM_DRIVERPRIORITYF_END))
    365     return MMSYSERR_INVALFLAG;
    366 
    367   /* Check for incompatible flags */
    368   if((fdwPriority & ACM_DRIVERPRIORITYF_ENABLE) &&
    369     (fdwPriority & ACM_DRIVERPRIORITYF_DISABLE))
    370     return MMSYSERR_INVALFLAG;
    371 
    372   /* Check for incompatible flags */
    373   if((fdwPriority & ACM_DRIVERPRIORITYF_BEGIN) &&
    374     (fdwPriority & ACM_DRIVERPRIORITYF_END))
    375     return MMSYSERR_INVALFLAG;
    376 
    377   lError = RegOpenKeyA(HKEY_CURRENT_USER,
    378     "Software\\Microsoft\\Multimedia\\"
    379       "Audio Compression Manager\\Priority v4.00",
    380     &hPriorityKey
    381   );
    382   /* FIXME: Create key */
    383   if(lError != ERROR_SUCCESS)
    384     return MMSYSERR_ERROR;
    385 
    386   for(dwPriorityCounter = 1; ; dwPriorityCounter++)
    387   {
    388 //
    389 // FIXME ODIN   wsnprintfA(szSubKey, 17, "Priorty%ld", dwPriorityCounter);
    390 //
    391     lError = RegQueryValueA(hPriorityKey, szSubKey, szBuffer, &lBufferLength);
    392     if(lError != ERROR_SUCCESS)
    393       break;
    394 
    395     break;
    396   }
    397 
    398   RegCloseKey(hPriorityKey);
    399 
    400   return MMSYSERR_ERROR;
    401 }
    402 
    403 /***********************************************************************
    404  *           acmDriverRemove (MSACM32.12)
    405  */
    406 MMRESULT WINAPI acmDriverRemove(
    407   HACMDRIVERID hadid, DWORD fdwRemove)
    408 {
    409 #ifdef DEBUG
    410   dprintf(("MSACM32: acmDriverRemove\n"));
    411 #endif
    412   PWINE_ACMDRIVERID padid;
    413 
    414   padid = MSACM_GetDriverID(hadid);
    415   if(!padid)
    416     return MMSYSERR_INVALHANDLE;
    417 
    418   if(fdwRemove)
    419     return MMSYSERR_INVALFLAG;
    420 
    421   MSACM_UnregisterDriver(padid);
    422 
    423   return MMSYSERR_NOERROR;
    424 }
    425 
    426 /***********************************************************************
    427  *           acmFilterChooseA (MSACM32.13)
    428  */
    429 MMRESULT WINAPI acmFilterChooseA(
    430   PACMFILTERCHOOSEA pafltrc)
    431 {
    432 #ifdef DEBUG
    433   dprintf(("MSACM32: acmDriverChooseA not implemented\n"));
    434 #endif
    435   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    436   return MMSYSERR_ERROR;
    437 }
    438 
    439 /***********************************************************************
    440  *           acmFilterChooseW (MSACM32.14)
    441  */
    442 MMRESULT WINAPI acmFilterChooseW(
    443   PACMFILTERCHOOSEW pafltrc)
    444 {
    445 #ifdef DEBUG
    446   dprintf(("MSACM32: acmDriverChooseW not implemented\n"));
    447 #endif
    448   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    449   return MMSYSERR_ERROR;
    450 }
    451 
    452 /***********************************************************************
    453  *           acmFilterDetailsA (MSACM32.15)
    454  */
    455 MMRESULT WINAPI acmFilterDetailsA(
    456   HACMDRIVER had, PACMFILTERDETAILSA pafd, DWORD fdwDetails)
    457 {
    458 #ifdef DEBUG
    459   dprintf(("MSACM32: acmFilterDetailsA\n"));
    460 #endif
    461   if(fdwDetails & ~(ACM_FILTERDETAILSF_FILTER))
    462     return MMSYSERR_INVALFLAG;
    463 
    464   /* FIXME
    465    *   How does the driver know if the ANSI or
    466    *   the UNICODE variant of PACMFILTERDETAILS is used?
    467    *   It might check cbStruct or does it only accept ANSI.
    468    */
    469   return (MMRESULT) acmDriverMessage(
    470     had, ACMDM_FILTER_DETAILS,
    471     (LPARAM) pafd,  (LPARAM) fdwDetails
    472   );
    473 }
    474 
    475 /***********************************************************************
    476  *           acmFilterDetailsW (MSACM32.16)
    477  */
    478 MMRESULT WINAPI acmFilterDetailsW(
    479   HACMDRIVER had, PACMFILTERDETAILSW pafd, DWORD fdwDetails)
    480 {
    481 #ifdef DEBUG
    482   dprintf(("MSACM32: acmFilterDetailsW not implemented\n"));
    483 #endif
    484   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    485   return MMSYSERR_ERROR;
    486 }
    487 
    488 /***********************************************************************
    489  *           acmFilterEnumA (MSACM32.17)
    490  */
    491 MMRESULT WINAPI acmFilterEnumA(
    492   HACMDRIVER had, PACMFILTERDETAILSA pafd,
    493   ACMFILTERENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
    494 {
    495 #ifdef DEBUG
    496   dprintf(("MSACM32: acmFilterEnumA not implemented\n"));
    497 #endif
    498   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    499   return MMSYSERR_ERROR;
    500 }
    501 
    502 /***********************************************************************
    503  *           acmFilterEnumW (MSACM32.18)
    504  */
    505 MMRESULT WINAPI acmFilterEnumW(
    506   HACMDRIVER had, PACMFILTERDETAILSW pafd,
    507   ACMFILTERENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
    508 {
    509 #ifdef DEBUG
    510   dprintf(("MSACM32: acmFilterEnumW not implemented\n"));
    511 #endif
    512   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    513   return MMSYSERR_ERROR;
    514 }
    515 
    516 /***********************************************************************
    517  *           acmFilterTagDetailsA (MSACM32.19)
    518  */
    519 MMRESULT WINAPI acmFilterTagDetailsA(
    520   HACMDRIVER had, PACMFILTERTAGDETAILSA paftd, DWORD fdwDetails)
    521 {
    522 #ifdef DEBUG
    523   dprintf(("MSACM32: acmFilterTagDetailsA\n"));
    524 #endif
    525   if(fdwDetails &
    526      ~(ACM_FILTERTAGDETAILSF_FILTERTAG|
    527        ACM_FILTERTAGDETAILSF_LARGESTSIZE))
    528     return MMSYSERR_INVALFLAG;
    529 
    530   /* FIXME
    531    *   How does the driver know if the ANSI or
    532    *   the UNICODE variant of PACMFILTERTAGDETAILS is used?
    533    *   It might check cbStruct or does it only accept ANSI.
    534    */
    535   return (MMRESULT) acmDriverMessage(
    536     had, ACMDM_FILTERTAG_DETAILS,
    537     (LPARAM) paftd,  (LPARAM) fdwDetails
    538   );
    539 }
    540 
    541 /***********************************************************************
    542  *           acmFilterTagDetailsW (MSACM32.20)
    543  */
    544 MMRESULT WINAPI acmFilterTagDetailsW(
    545   HACMDRIVER had, PACMFILTERTAGDETAILSW paftd, DWORD fdwDetails)
    546 {
    547 #ifdef DEBUG
    548   dprintf(("MSACM32: acmFilterTagDetailsW not implemented\n"));
    549 #endif
    550   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    551   return MMSYSERR_ERROR;
    552 }
    553 
    554 /***********************************************************************
    555  *           acmFilterTagEnumA (MSACM32.21)
    556  */
    557 MMRESULT WINAPI acmFilterTagEnumA(
    558   HACMDRIVER had, PACMFILTERTAGDETAILSA  paftd,
    559   ACMFILTERTAGENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
    560 {
    561 #ifdef DEBUG
    562   dprintf(("MSACM32: acmFilterTagEnumA not implemented\n"));
    563 #endif
    564   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    565   return MMSYSERR_ERROR;
    566 }
    567 
    568 /***********************************************************************
    569  *           acmFilterTagEnumW (MSACM32.22)
    570  */
    571 MMRESULT WINAPI acmFilterTagEnumW(
    572   HACMDRIVER had, PACMFILTERTAGDETAILSW paftd,
    573   ACMFILTERTAGENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
    574 {
    575 #ifdef DEBUG
    576   dprintf(("MSACM32: acmFilterTagEnumW not implemented\n"));
    577 #endif
    578   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    579   return MMSYSERR_ERROR;
    580 }
    581 
    582 /***********************************************************************
    583  *           acmFormatChooseA (MSACM32.23)
    584  */
    585 MMRESULT WINAPI acmFormatChooseA(
    586   PACMFORMATCHOOSEA pafmtc)
    587 {
    588 #ifdef DEBUG
    589   dprintf(("MSACM32: acmFormatChooseA not implemented\n"));
    590 #endif
    591   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    592   return MMSYSERR_ERROR;
    593 }
    594 
    595 /***********************************************************************
    596  *           acmFormatChooseW (MSACM32.24)
    597  */
    598 MMRESULT WINAPI acmFormatChooseW(
    599   PACMFORMATCHOOSEW pafmtc)
    600 {
    601 #ifdef DEBUG
    602   dprintf(("MSACM32: acmFormatChooseW not implemented\n"));
    603 #endif
    604   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    605   return MMSYSERR_ERROR;
    606 }
    607 
    608 /***********************************************************************
    609  *           acmFormatDetailsA (MSACM32.25)
    610  */
    611 MMRESULT WINAPI acmFormatDetailsA(
    612   HACMDRIVER had, PACMFORMATDETAILSA pafd, DWORD fdwDetails)
    613 {
    614 #ifdef DEBUG
    615   dprintf(("MSACM32: acmFormatDetailsA\n"));
    616 #endif
    617   if(fdwDetails & ~(ACM_FORMATDETAILSF_FORMAT))
    618     return MMSYSERR_INVALFLAG;
    619 
    620   /* FIXME
    621    *   How does the driver know if the ANSI or
    622    *   the UNICODE variant of PACMFORMATDETAILS is used?
    623    *   It might check cbStruct or does it only accept ANSI.
    624    */
    625   return (MMRESULT) acmDriverMessage(
    626     had, ACMDM_FORMAT_DETAILS,
    627     (LPARAM) pafd,  (LPARAM) fdwDetails
    628   );
    629 }
    630 
    631 /***********************************************************************
    632  *           acmFormatDetailsW (MSACM32.26)
    633  */
    634 MMRESULT WINAPI acmFormatDetailsW(
    635   HACMDRIVER had, PACMFORMATDETAILSW pafd, DWORD fdwDetails)
    636 {
    637 #ifdef DEBUG
    638   dprintf(("MSACM32: acmFormatDetailsW not implemented\n"));
    639 #endif
    640   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    641   return MMSYSERR_ERROR;
    642 }
    643 
    644 /***********************************************************************
    645  *           acmFormatEnumA (MSACM32.27)
    646  */
    647 MMRESULT WINAPI acmFormatEnumA(
    648   HACMDRIVER had, PACMFORMATDETAILSA pafd,
    649   ACMFORMATENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
    650 {
    651 #ifdef DEBUG
    652   dprintf(("MSACM32: acmFormatEnumA not implemented\n"));
    653 #endif
    654   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    655   return MMSYSERR_ERROR;
    656 }
    657 
    658 /***********************************************************************
    659  *           acmFormatEnumW (MSACM32.28)
    660  */
    661 MMRESULT WINAPI acmFormatEnumW(
    662   HACMDRIVER had, PACMFORMATDETAILSW pafd,
    663   ACMFORMATENUMCBW fnCallback, DWORD dwInstance,  DWORD fdwEnum)
    664 {
    665 #ifdef DEBUG
    666   dprintf(("MSACM32: acmFormatEnumW not implemented\n"));
    667 #endif
    668   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    669   return MMSYSERR_ERROR;
    670 }
    671 
    672 /***********************************************************************
    673  *           acmFormatSuggest (MSACM32.29)
    674  */
    675 MMRESULT WINAPI acmFormatSuggest(
    676   HACMDRIVER had, PWAVEFORMATEX pwfxSrc, PWAVEFORMATEX pwfxDst,
    677   DWORD cbwfxDst, DWORD fdwSuggest)
    678 {
    679 #ifdef DEBUG
    680   dprintf(("MSACM32: acmFormatSuggest not implemented\n"));
    681 #endif
    682   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    683   return MMSYSERR_ERROR;
    684 }
    685 
    686 /***********************************************************************
    687  *           acmFormatTagDetailsA (MSACM32.30)
    688  */
    689 MMRESULT WINAPI acmFormatTagDetailsA(
    690   HACMDRIVER had, PACMFORMATTAGDETAILSA paftd, DWORD fdwDetails)
    691 {
    692 #ifdef DEBUG
    693   dprintf(("MSACM32: acmFormatTagDetailsA\n"));
    694 #endif
    695   if(fdwDetails &
    696      ~(ACM_FORMATTAGDETAILSF_FORMATTAG|ACM_FORMATTAGDETAILSF_LARGESTSIZE))
    697     return MMSYSERR_INVALFLAG;
    698 
    699   /* FIXME
    700    *   How does the driver know if the ANSI or
    701    *   the UNICODE variant of PACMFORMATTAGDETAILS is used?
    702    *   It might check cbStruct or does it only accept ANSI.
    703    */
    704   return (MMRESULT) acmDriverMessage(
    705     had, ACMDM_FORMATTAG_DETAILS,
    706     (LPARAM) paftd,  (LPARAM) fdwDetails
    707   );
    708 }
    709 
    710 /***********************************************************************
    711  *           acmFormatTagDetailsW (MSACM32.31)
    712  */
    713 MMRESULT WINAPI acmFormatTagDetailsW(
    714   HACMDRIVER had, PACMFORMATTAGDETAILSW paftd, DWORD fdwDetails)
    715 {
    716 #ifdef DEBUG
    717   dprintf(("MSACM32: acmFormatTagDetailsW not implemented\n"));
    718 #endif
    719   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    720   return MMSYSERR_ERROR;
    721 }
    722 
    723 /***********************************************************************
    724  *           acmFormatTagEnumA (MSACM32.32)
    725  */
    726 MMRESULT WINAPI acmFormatTagEnumA(
    727   HACMDRIVER had, PACMFORMATTAGDETAILSA paftd,
    728   ACMFORMATTAGENUMCBA fnCallback, DWORD dwInstance, DWORD fdwEnum)
    729 {
    730 #ifdef DEBUG
    731   dprintf(("MSACM32: acmFormatTagEnumA not implemented\n"));
    732 #endif
    733   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    734   return MMSYSERR_ERROR;
    735 }
    736 
    737 /***********************************************************************
    738  *           acmFormatTagEnumW (MSACM32.33)
    739  */
    740 MMRESULT WINAPI acmFormatTagEnumW(
    741   HACMDRIVER had, PACMFORMATTAGDETAILSW paftd,
    742   ACMFORMATTAGENUMCBW fnCallback, DWORD dwInstance, DWORD fdwEnum)
    743 {
    744 #ifdef DEBUG
    745   dprintf(("MSACM32: acmFormatTagEnumW not implemented\n"));
    746 #endif
    747   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    748   return MMSYSERR_ERROR;
    749 }
    750 
    751 /***********************************************************************
    752  *           acmGetVersion (MSACM32.34)
    753  */
    754 DWORD WINAPI acmGetVersion()
    755 {
    756 #ifdef DEBUG
    757   dprintf(("MSACM32: acmGetVersion\n"));
    758 #endif
    759   switch(GetVersion())
    760     {
     70    switch (GetVersion()) {
    76171    default:
    762 //
     72        dprintf(("OS not supported\n"));
    76373    case WIN95:
    764       return 0x04000000; /* 4.0.0 */
     74        return 0x04000000; /* 4.0.0 */
    76575    case NT40:
    766       return 0x04000565; /* 4.0.1381 */
     76        return 0x04000565; /* 4.0.1381 */
    76777    }
    76878}
    76979
    77080/***********************************************************************
    771  *           acmMessage (MSACM32.35)
     81 *           acmMessage32 (MSACM32.35)
    77282 * FIXME
    77383 *   No documentation found.
    … …  
    77787 *           acmMetrics (MSACM32.36)
    77888 */
    779 MMRESULT WINAPI acmMetrics(
    780   HACMOBJ hao, UINT uMetric, LPVOID  pMetric)
     89MMRESULT WINAPI acmMetrics(HACMOBJ hao, UINT uMetric, LPVOID  pMetric)
    78190{
    782 #ifdef DEBUG
    783   dprintf(("MSACM32: acmMetrics\n"));
    784 #endif
    785   PWINE_ACMOBJ pao = MSACM_GetObj(hao);
    786   BOOL bLocal = TRUE;
    787 
    788   switch(uMetric)
    789     {
     91    PWINE_ACMOBJ pao = MSACM_GetObj(hao);
     92    BOOL bLocal = TRUE;
     93   
     94    dprintf(("(0x%08x, %d, %p): stub\n", hao, uMetric, pMetric));
     95   
     96    switch (uMetric) {
    79097    case ACM_METRIC_COUNT_DRIVERS:
    791       bLocal = FALSE;
     98        bLocal = FALSE;
    79299    case ACM_METRIC_COUNT_LOCAL_DRIVERS:
    793       if(!pao)
    794         return MMSYSERR_INVALHANDLE; 
    795       return MMSYSERR_NOTSUPPORTED;
     100        if (!pao)
     101            return MMSYSERR_INVALHANDLE; 
     102        return MMSYSERR_NOTSUPPORTED;
    796103    case ACM_METRIC_COUNT_CODECS:
    797       bLocal = FALSE;
     104        bLocal = FALSE;
    798105    case ACM_METRIC_COUNT_LOCAL_CODECS:
    799       return MMSYSERR_NOTSUPPORTED;
     106        return MMSYSERR_NOTSUPPORTED;
    800107    case ACM_METRIC_COUNT_CONVERTERS:
    801       bLocal = FALSE;
     108        bLocal = FALSE;
    802109    case ACM_METRIC_COUNT_LOCAL_CONVERTERS:
    803       return MMSYSERR_NOTSUPPORTED;
     110        return MMSYSERR_NOTSUPPORTED;
    804111    case ACM_METRIC_COUNT_FILTERS:
    805       bLocal = FALSE;
     112        bLocal = FALSE;
    806113    case ACM_METRIC_COUNT_LOCAL_FILTERS:
    807       return MMSYSERR_NOTSUPPORTED;
     114        return MMSYSERR_NOTSUPPORTED;
    808115    case ACM_METRIC_COUNT_DISABLED:
    809       bLocal = FALSE;
     116        bLocal = FALSE;
    810117    case ACM_METRIC_COUNT_LOCAL_DISABLED:
    811       if(!pao)
    812         return MMSYSERR_INVALHANDLE; 
    813       return MMSYSERR_NOTSUPPORTED;
     118        if (!pao)
     119            return MMSYSERR_INVALHANDLE; 
     120        return MMSYSERR_NOTSUPPORTED;
    814121    case ACM_METRIC_COUNT_HARDWARE:
    815122    case ACM_METRIC_HARDWARE_WAVE_INPUT:
    … …  
    820127    case ACM_METRIC_DRIVER_PRIORITY:
    821128    default:
    822       return MMSYSERR_NOTSUPPORTED;
     129        return MMSYSERR_NOTSUPPORTED;
    823130    }
    824   return MMSYSERR_NOERROR;
     131    return MMSYSERR_NOERROR;
    825132}
    826 
    827 /***********************************************************************
    828  *           acmStreamClose (MSACM32.37)
    829  */
    830 MMRESULT WINAPI acmStreamClose(
    831   HACMSTREAM has, DWORD fdwClose)
    832 {
    833 #ifdef DEBUG
    834   dprintf(("MSACM32: acmStreamClose not implemented\n"));
    835 #endif
    836   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    837   return MMSYSERR_ERROR;
    838 }
    839 
    840 /***********************************************************************
    841  *           acmStreamConvert (MSACM32.38)
    842  */
    843 MMRESULT WINAPI acmStreamConvert(
    844   HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwConvert)
    845 {
    846 #ifdef DEBUG
    847   dprintf(("MSACM32: acmStreamConvert not implemented\n"));
    848 #endif
    849   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    850   return MMSYSERR_ERROR;
    851 }
    852 
    853 /***********************************************************************
    854  *           acmStreamMessage (MSACM32.39)
    855  */
    856 MMRESULT WINAPI acmStreamMessage(
    857   HACMSTREAM has, UINT uMsg, LPARAM lParam1, LPARAM lParam2)
    858 {
    859 #ifdef DEBUG
    860   dprintf(("MSACM32: acmStreamMessage not implemented\n"));
    861 #endif
    862   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    863   return MMSYSERR_ERROR;
    864 }
    865 
    866 /***********************************************************************
    867  *           acmStreamOpen (MSACM32.40)
    868  */
    869 MMRESULT WINAPI acmStreamOpen(
    870   PHACMSTREAM phas, HACMDRIVER had, PWAVEFORMATEX pwfxSrc,
    871   PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD dwCallback,
    872   DWORD dwInstance, DWORD fdwOpen)
    873 {
    874 #ifdef DEBUG
    875   dprintf(("MSACM32: acmStreamOpen not implemented\n"));
    876 #endif
    877   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    878   return MMSYSERR_ERROR;
    879 }
    880 
    881 
    882 /***********************************************************************
    883  *           acmStreamPrepareHeader (MSACM32.41)
    884  */
    885 MMRESULT WINAPI acmStreamPrepareHeader(
    886   HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwPrepare)
    887 {
    888 #ifdef DEBUG
    889   dprintf(("MSACM32: acmStreamPrepareHeader not implemented\n"));
    890 #endif
    891   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    892   return MMSYSERR_ERROR;
    893 }
    894 
    895 /***********************************************************************
    896  *           acmStreamReset (MSACM32.42)
    897  */
    898 MMRESULT WINAPI acmStreamReset(
    899   HACMSTREAM has, DWORD fdwReset)
    900 {
    901 #ifdef DEBUG
    902   dprintf(("MSACM32: acmStreamReset not implemented\n"));
    903 #endif
    904   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    905   return MMSYSERR_ERROR;
    906 }
    907 
    908 /***********************************************************************
    909  *           acmStreamSize (MSACM32.43)
    910  */
    911 MMRESULT WINAPI acmStreamSize(
    912   HACMSTREAM has, DWORD cbInput,
    913   LPDWORD pdwOutputBytes, DWORD fdwSize)
    914 {
    915 #ifdef DEBUG
    916   dprintf(("MSACM32: acmStreamSize not implemented\n"));
    917 #endif
    918   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    919   return MMSYSERR_ERROR;
    920 }
    921 
    922 /***********************************************************************
    923  *           acmStreamUnprepareHeader (MSACM32.44)
    924  */
    925 MMRESULT WINAPI acmStreamUnprepareHeader(
    926   HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwUnprepare)
    927 {
    928 #ifdef DEBUG
    929   dprintf(("MSACM32: acmStreamUnprepareHeader not implemented\n"));
    930 #endif
    931   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    932   return MMSYSERR_ERROR;
    933 }
Note: See TracChangeset for help on using the changeset viewer.