dll/win32/msacm32/filter.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  *      MSACM32 library
   5  *
   6  *      Copyright 1998  Patrik Stridvall
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "wineacm.h"
  24
  25 /***********************************************************************
  26  *           acmFilterChooseA (MSACM32.@)
  27  */
  28 MMRESULT WINAPI acmFilterChooseA(PACMFILTERCHOOSEA pafltrc)
  29 {
  30     FIXME("(%p): stub\n", pafltrc);
  31     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  32     return MMSYSERR_ERROR;
  33 }
  34
  35 /***********************************************************************
  36  *           acmFilterChooseW (MSACM32.@)
  37  */
  38 MMRESULT WINAPI acmFilterChooseW(PACMFILTERCHOOSEW pafltrc)
  39 {
  40     FIXME("(%p): stub\n", pafltrc);
  41     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  42     return MMSYSERR_ERROR;
  43 }
  44
  45 /***********************************************************************
  46  *           acmFilterDetailsA (MSACM32.@)
  47  */
  48 MMRESULT WINAPI acmFilterDetailsA(HACMDRIVER had, PACMFILTERDETAILSA pafd,
  49                                   DWORD fdwDetails)
  50 {
  51     ACMFILTERDETAILSW   afdw;
  52     MMRESULT            mmr;
  53
  54     memset(&afdw, 0, sizeof(afdw));
  55     afdw.cbStruct = sizeof(afdw);
  56     afdw.dwFilterIndex = pafd->dwFilterIndex;
  57     afdw.dwFilterTag = pafd->dwFilterTag;
  58     afdw.pwfltr = pafd->pwfltr;
  59     afdw.cbwfltr = pafd->cbwfltr;
  60
  61     mmr = acmFilterDetailsW(had, &afdw, fdwDetails);
  62     if (mmr == MMSYSERR_NOERROR) {
  63         pafd->dwFilterTag = afdw.dwFilterTag;
  64         pafd->fdwSupport = afdw.fdwSupport;
  65         WideCharToMultiByte( CP_ACP, 0, afdw.szFilter, -1, pafd->szFilter,
  66                              sizeof(pafd->szFilter), NULL, NULL );
  67     }
  68     return mmr;
  69 }
  70
  71 /***********************************************************************
  72  *           acmFilterDetailsW (MSACM32.@)
  73  */
  74 MMRESULT WINAPI acmFilterDetailsW(HACMDRIVER had, PACMFILTERDETAILSW pafd,
  75                                   DWORD fdwDetails)
  76 {
  77     MMRESULT                    mmr;
  78     ACMFILTERTAGDETAILSA        aftd;
  79
  80     TRACE("(%p, %p, %d)\n", had, pafd, fdwDetails);
  81
  82     memset(&aftd, 0, sizeof(aftd));
  83     aftd.cbStruct = sizeof(aftd);
  84
  85     if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
  86
  87     switch (fdwDetails) {
  88     case ACM_FILTERDETAILSF_FILTER:
  89         if (pafd->dwFilterTag != pafd->pwfltr->dwFilterTag) {
  90             mmr = MMSYSERR_INVALPARAM;
  91             break;
  92         }
  93         if (had == NULL) {
  94             PWINE_ACMDRIVERID           padid;
  95
  96             mmr = ACMERR_NOTPOSSIBLE;
  97             for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
  98                 /* should check for codec only */
  99                 if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
 100                     acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
 101                     mmr = MSACM_Message(had, ACMDM_FILTER_DETAILS,
 102                                         (LPARAM)pafd, (LPARAM)fdwDetails);
 103                     acmDriverClose(had, 0);
 104                     if (mmr == MMSYSERR_NOERROR) break;
 105                 }
 106             }
 107         } else {
 108             mmr = MSACM_Message(had, ACMDM_FILTER_DETAILS, (LPARAM)pafd, fdwDetails);
 109         }
 110         break;
 111     case ACM_FILTERDETAILSF_INDEX:
 112         /* should check pafd->dwFilterIndex < aftd->cStandardFilters */
 113         mmr = MSACM_Message(had, ACMDM_FILTER_DETAILS, (LPARAM)pafd, fdwDetails);
 114         break;
 115     default:
 116         WARN("Unknown fdwDetails %08x\n", fdwDetails);
 117         mmr = MMSYSERR_INVALFLAG;
 118         break;
 119     }
 120
 121     TRACE("=> %d\n", mmr);
 122     return mmr;
 123 }
 124
 125 struct MSACM_FilterEnumWtoA_Instance {
 126     PACMFILTERDETAILSA pafda;
 127     DWORD_PTR          dwInstance;
 128     ACMFILTERENUMCBA   fnCallback;
 129 };
 130
 131 static BOOL CALLBACK MSACM_FilterEnumCallbackWtoA(HACMDRIVERID hadid,
 132                                                   PACMFILTERDETAILSW pafdw,
 133                                                   DWORD_PTR dwInstance,
 134                                                   DWORD fdwSupport)
 135 {
 136     struct MSACM_FilterEnumWtoA_Instance* pafei;
 137
 138     pafei = (struct MSACM_FilterEnumWtoA_Instance*)dwInstance;
 139
 140     pafei->pafda->dwFilterIndex = pafdw->dwFilterIndex;
 141     pafei->pafda->dwFilterTag = pafdw->dwFilterTag;
 142     pafei->pafda->fdwSupport = pafdw->fdwSupport;
 143     WideCharToMultiByte( CP_ACP, 0, pafdw->szFilter, -1, pafei->pafda->szFilter,
 144                          sizeof(pafei->pafda->szFilter), NULL, NULL );
 145
 146     return (pafei->fnCallback)(hadid, pafei->pafda,
 147                                pafei->dwInstance, fdwSupport);
 148 }
 149
 150 /***********************************************************************
 151  *           acmFilterEnumA (MSACM32.@)
 152  */
 153 MMRESULT WINAPI acmFilterEnumA(HACMDRIVER had, PACMFILTERDETAILSA pafda,
 154                                ACMFILTERENUMCBA fnCallback,
 155                                DWORD_PTR dwInstance, DWORD fdwEnum)
 156 {
 157     ACMFILTERDETAILSW           afdw;
 158     struct MSACM_FilterEnumWtoA_Instance afei;
 159
 160     memset(&afdw, 0, sizeof(afdw));
 161     afdw.cbStruct = sizeof(afdw);
 162     afdw.dwFilterIndex = pafda->dwFilterIndex;
 163     afdw.dwFilterTag = pafda->dwFilterTag;
 164     afdw.pwfltr = pafda->pwfltr;
 165     afdw.cbwfltr = pafda->cbwfltr;
 166
 167     afei.pafda = pafda;
 168     afei.dwInstance = dwInstance;
 169     afei.fnCallback = fnCallback;
 170
 171     return acmFilterEnumW(had, &afdw, MSACM_FilterEnumCallbackWtoA,
 172                           (DWORD_PTR)&afei, fdwEnum);
 173 }
 174
 175 static BOOL MSACM_FilterEnumHelper(PWINE_ACMDRIVERID padid, HACMDRIVER had,
 176                                    PACMFILTERDETAILSW pafd,
 177                                    ACMFILTERENUMCBW fnCallback,
 178                                    DWORD_PTR dwInstance, DWORD fdwEnum)
 179 {
 180     ACMFILTERTAGDETAILSW        aftd;
 181     unsigned int i, j;
 182
 183     for (i = 0; i < padid->cFilterTags; i++) {
 184         memset(&aftd, 0, sizeof(aftd));
 185         aftd.cbStruct = sizeof(aftd);
 186         aftd.dwFilterTagIndex = i;
 187         if (acmFilterTagDetailsW(had, &aftd, ACM_FILTERTAGDETAILSF_INDEX) != MMSYSERR_NOERROR)
 188             continue;
 189
 190         if ((fdwEnum & ACM_FILTERENUMF_DWFILTERTAG) &&
 191             aftd.dwFilterTag != pafd->pwfltr->dwFilterTag)
 192             continue;
 193
 194         for (j = 0; j < aftd.cStandardFilters; j++) {
 195             pafd->dwFilterIndex = j;
 196             pafd->dwFilterTag = aftd.dwFilterTag;
 197             if (acmFilterDetailsW(had, pafd, ACM_FILTERDETAILSF_INDEX) != MMSYSERR_NOERROR)
 198                 continue;
 199
 200             if (!(fnCallback)((HACMDRIVERID)padid, pafd, dwInstance, padid->fdwSupport))
 201                 return FALSE;
 202         }
 203     }
 204     return TRUE;
 205 }
 206
 207 /***********************************************************************
 208  *           acmFilterEnumW (MSACM32.@)
 209  */
 210 MMRESULT WINAPI acmFilterEnumW(HACMDRIVER had, PACMFILTERDETAILSW pafd,
 211                                ACMFILTERENUMCBW fnCallback,
 212                                DWORD_PTR dwInstance, DWORD fdwEnum)
 213 {
 214     PWINE_ACMDRIVERID           padid;
 215     BOOL                        ret;
 216
 217     TRACE("(%p, %p, %p, %ld, %d)\n",
 218           had, pafd, fnCallback, dwInstance, fdwEnum);
 219
 220     if (pafd->cbStruct < sizeof(*pafd)) return MMSYSERR_INVALPARAM;
 221
 222     if (fdwEnum & ~(ACM_FILTERENUMF_DWFILTERTAG))
 223         FIXME("Unsupported fdwEnum values\n");
 224
 225     if (had) {
 226         HACMDRIVERID    hadid;
 227
 228         if (acmDriverID((HACMOBJ)had, &hadid, 0) != MMSYSERR_NOERROR)
 229             return MMSYSERR_INVALHANDLE;
 230         MSACM_FilterEnumHelper(MSACM_GetDriverID(hadid), had, pafd,
 231                                fnCallback, dwInstance, fdwEnum);
 232         return MMSYSERR_NOERROR;
 233     }
 234     for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
 235             /* should check for codec only */
 236             if ((padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) ||
 237                 acmDriverOpen(&had, (HACMDRIVERID)padid, 0) != MMSYSERR_NOERROR)
 238                 continue;
 239             ret = MSACM_FilterEnumHelper(padid, had, pafd,
 240                                          fnCallback, dwInstance, fdwEnum);
 241             acmDriverClose(had, 0);
 242             if (!ret) break;
 243     }
 244     return MMSYSERR_NOERROR;
 245 }
 246
 247 /***********************************************************************
 248  *           acmFilterTagDetailsA (MSACM32.@)
 249  */
 250 MMRESULT WINAPI acmFilterTagDetailsA(HACMDRIVER had, PACMFILTERTAGDETAILSA paftda,
 251                                      DWORD fdwDetails)
 252 {
 253     ACMFILTERTAGDETAILSW        aftdw;
 254     MMRESULT                    mmr;
 255
 256     memset(&aftdw, 0, sizeof(aftdw));
 257     aftdw.cbStruct = sizeof(aftdw);
 258     aftdw.dwFilterTagIndex = paftda->dwFilterTagIndex;
 259     aftdw.dwFilterTag = paftda->dwFilterTag;
 260
 261     mmr = acmFilterTagDetailsW(had, &aftdw, fdwDetails);
 262     if (mmr == MMSYSERR_NOERROR) {
 263         paftda->dwFilterTag = aftdw.dwFilterTag;
 264         paftda->dwFilterTagIndex = aftdw.dwFilterTagIndex;
 265         paftda->cbFilterSize = aftdw.cbFilterSize;
 266         paftda->fdwSupport = aftdw.fdwSupport;
 267         paftda->cStandardFilters = aftdw.cStandardFilters;
 268         WideCharToMultiByte( CP_ACP, 0, aftdw.szFilterTag, -1, paftda->szFilterTag,
 269                              sizeof(paftda->szFilterTag), NULL, NULL );
 270     }
 271     return mmr;
 272 }
 273
 274 /***********************************************************************
 275  *           acmFilterTagDetailsW (MSACM32.@)
 276  */
 277 MMRESULT WINAPI acmFilterTagDetailsW(HACMDRIVER had, PACMFILTERTAGDETAILSW paftd,
 278                                      DWORD fdwDetails)
 279 {
 280     PWINE_ACMDRIVERID   padid;
 281     MMRESULT            mmr;
 282
 283     TRACE("(%p, %p, %d)\n", had, paftd, fdwDetails);
 284
 285     if (fdwDetails & ~(ACM_FILTERTAGDETAILSF_FILTERTAG|ACM_FILTERTAGDETAILSF_INDEX|
 286                        ACM_FILTERTAGDETAILSF_LARGESTSIZE))
 287         return MMSYSERR_INVALFLAG;
 288
 289     switch (fdwDetails) {
 290     case ACM_FILTERTAGDETAILSF_FILTERTAG:
 291         if (had == NULL) {
 292             mmr = ACMERR_NOTPOSSIBLE;
 293             for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
 294                 /* should check for codec only */
 295                 if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
 296                       acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
 297                     mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS, (LPARAM)paftd, fdwDetails);
 298                     acmDriverClose(had, 0);
 299                     if (mmr == MMSYSERR_NOERROR) break;
 300                 }
 301             }
 302         } else {
 303             mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS, (LPARAM)paftd, fdwDetails);
 304         }
 305         break;
 306
 307     case ACM_FILTERTAGDETAILSF_INDEX:
 308         /* FIXME should check paftd->dwFilterTagIndex < add.cFilterTags */
 309         mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS, (LPARAM)paftd, fdwDetails);
 310         break;
 311
 312     case ACM_FILTERTAGDETAILSF_LARGESTSIZE:
 313         if (had == NULL) {
 314             ACMFILTERTAGDETAILSW        tmp;
 315             DWORD                       ft = paftd->dwFilterTag;
 316
 317             mmr = ACMERR_NOTPOSSIBLE;
 318             for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
 319                 /* should check for codec only */
 320                 if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
 321                     acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == 0) {
 322
 323                     memset(&tmp, 0, sizeof(tmp));
 324                     tmp.cbStruct = sizeof(tmp);
 325                     tmp.dwFilterTag = ft;
 326
 327                     if (MSACM_Message(had, ACMDM_FILTERTAG_DETAILS,
 328                                       (LPARAM)&tmp, fdwDetails) == MMSYSERR_NOERROR) {
 329                         if (mmr == ACMERR_NOTPOSSIBLE ||
 330                             paftd->cbFilterSize < tmp.cbFilterSize) {
 331                             *paftd = tmp;
 332                             mmr = MMSYSERR_NOERROR;
 333                         }
 334                     }
 335                     acmDriverClose(had, 0);
 336                 }
 337             }
 338         } else {
 339             mmr = MSACM_Message(had, ACMDM_FILTERTAG_DETAILS, (LPARAM)paftd, fdwDetails);
 340         }
 341         break;
 342
 343     default:
 344         WARN("Unsupported fdwDetails=%08x\n", fdwDetails);
 345         mmr = MMSYSERR_ERROR;
 346     }
 347
 348     if (mmr == MMSYSERR_NOERROR &&
 349         paftd->dwFilterTag == WAVE_FORMAT_PCM && paftd->szFilterTag[0] == 0)
 350         MultiByteToWideChar( CP_ACP, 0, "PCM", -1, paftd->szFilterTag,
 351                              sizeof(paftd->szFilterTag)/sizeof(WCHAR) );
 352
 353     return mmr;
 354 }
 355
 356 struct MSACM_FilterTagEnumWtoA_Instance {
 357     PACMFILTERTAGDETAILSA paftda;
 358     DWORD_PTR             dwInstance;
 359     ACMFILTERTAGENUMCBA   fnCallback;
 360 };
 361
 362 static BOOL CALLBACK MSACM_FilterTagEnumCallbackWtoA(HACMDRIVERID hadid,
 363                                                      PACMFILTERTAGDETAILSW paftdw,
 364                                                      DWORD_PTR dwInstance,
 365                                                      DWORD fdwSupport)
 366 {
 367     struct MSACM_FilterTagEnumWtoA_Instance* paftei;
 368
 369     paftei = (struct MSACM_FilterTagEnumWtoA_Instance*)dwInstance;
 370
 371     paftei->paftda->dwFilterTagIndex = paftdw->dwFilterTagIndex;
 372     paftei->paftda->dwFilterTag = paftdw->dwFilterTag;
 373     paftei->paftda->cbFilterSize = paftdw->cbFilterSize;
 374     paftei->paftda->fdwSupport = paftdw->fdwSupport;
 375     paftei->paftda->cStandardFilters = paftdw->cStandardFilters;
 376     WideCharToMultiByte( CP_ACP, 0, paftdw->szFilterTag, -1, paftei->paftda->szFilterTag,
 377                          sizeof(paftei->paftda->szFilterTag), NULL, NULL );
 378
 379     return (paftei->fnCallback)(hadid, paftei->paftda,
 380                                 paftei->dwInstance, fdwSupport);
 381 }
 382
 383 /***********************************************************************
 384  *           acmFilterTagEnumA (MSACM32.@)
 385  */
 386 MMRESULT WINAPI acmFilterTagEnumA(HACMDRIVER had, PACMFILTERTAGDETAILSA paftda,
 387                                   ACMFILTERTAGENUMCBA fnCallback,
 388                                   DWORD_PTR dwInstance, DWORD fdwEnum)
 389 {
 390     ACMFILTERTAGDETAILSW        aftdw;
 391     struct MSACM_FilterTagEnumWtoA_Instance aftei;
 392
 393     memset(&aftdw, 0, sizeof(aftdw));
 394     aftdw.cbStruct = sizeof(aftdw);
 395     aftdw.dwFilterTagIndex = paftda->dwFilterTagIndex;
 396     aftdw.dwFilterTag = paftda->dwFilterTag;
 397
 398     aftei.paftda = paftda;
 399     aftei.dwInstance = dwInstance;
 400     aftei.fnCallback = fnCallback;
 401
 402     return acmFilterTagEnumW(had, &aftdw, MSACM_FilterTagEnumCallbackWtoA,
 403                              (DWORD_PTR)&aftei, fdwEnum);
 404 }
 405
 406 /***********************************************************************
 407  *           acmFilterTagEnumW (MSACM32.@)
 408  */
 409 MMRESULT WINAPI acmFilterTagEnumW(HACMDRIVER had, PACMFILTERTAGDETAILSW paftd,
 410                                   ACMFILTERTAGENUMCBW fnCallback,
 411                                   DWORD_PTR dwInstance, DWORD fdwEnum)
 412 {
 413     PWINE_ACMDRIVERID           padid;
 414     unsigned int                        i;
 415
 416     TRACE("(%p, %p, %p, %ld, %d)\n",
 417           had, paftd, fnCallback, dwInstance, fdwEnum);
 418
 419     if (paftd->cbStruct < sizeof(*paftd)) return MMSYSERR_INVALPARAM;
 420
 421     if (had) FIXME("had != NULL, not supported\n");
 422
 423     for (padid = MSACM_pFirstACMDriverID; padid; padid = padid->pNextACMDriverID) {
 424         /* should check for codec only */
 425         if (!(padid->fdwSupport & ACMDRIVERDETAILS_SUPPORTF_DISABLED) &&
 426             acmDriverOpen(&had, (HACMDRIVERID)padid, 0) == MMSYSERR_NOERROR) {
 427
 428             for (i = 0; i < padid->cFilterTags; i++) {
 429                 paftd->dwFilterTagIndex = i;
 430                 if (acmFilterTagDetailsW(had, paftd, ACM_FILTERTAGDETAILSF_INDEX) == MMSYSERR_NOERROR) {
 431                     if (!(fnCallback)((HACMDRIVERID)padid, paftd, dwInstance, padid->fdwSupport)) {
 432                         padid = NULL;
 433                         break;
 434                     }
 435                 }
 436             }
 437             acmDriverClose(had, 0);
 438         }
 439     }
 440     return MMSYSERR_NOERROR;
 441 }