ReactOS 0.4.15-dev-8348-gc1b9bb5
msacm.c File Reference
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "wine/test.h"
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "mmsystem.h"
#include "mmreg.h"
#include "msacm.h"
#include "wine/msacmdrv.h"
Include dependency graph for msacm.c:

Go to the source code of this file.

Classes

struct  stream_output
 

Macros

#define NOBITMAP
 

Functions

static BOOL CALLBACK FormatTagEnumProc (HACMDRIVERID hadid, PACMFORMATTAGDETAILSA paftd, DWORD_PTR dwInstance, DWORD fdwSupport)
 
static BOOL CALLBACK FormatEnumProc (HACMDRIVERID hadid, LPACMFORMATDETAILSA pafd, DWORD_PTR dwInstance, DWORD fd)
 
static BOOL CALLBACK DriverEnumProc (HACMDRIVERID hadid, DWORD_PTR dwInstance, DWORD fdwSupport)
 
static const charget_metric (UINT uMetric)
 
static void check_count (UINT uMetric)
 
static void driver_tests (void)
 
static void test_prepareheader (void)
 
static void test_convert (void)
 
static void test_acmFormatSuggest (void)
 
static void test_acmFormatTagDetails (void)
 
static void test_acmFormatChoose (void)
 
static void test_mp3 (void)
 
static LRESULT CALLBACK acm_driver_func (DWORD_PTR id, HDRVR handle, UINT msg, LPARAM param1, LPARAM param2)
 
static void test_acmDriverAdd (void)
 
 START_TEST (msacm)
 

Variables

static const BYTE input [64] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63}
 
static const struct stream_output expected_output []
 
struct {
   struct {
      int   load
 
      int   free
 
      int   open
 
      int   close
 
      int   enable
 
      int   disable
 
      int   install
 
      int   remove
 
      int   details
 
      int   notify
 
      int   querycfg
 
      int   about
 
   }   driver
 
   struct {
      int   tag_details
 
      int   details
 
      int   suggest
 
   }   format
 
   struct {
      int   open
 
      int   close
 
      int   size
 
      int   convert
 
      int   prepare
 
      int   unprepare
 
      int   reset
 
   }   stream
 
   int   other
 
driver_calls
 

Macro Definition Documentation

◆ NOBITMAP

#define NOBITMAP

Definition at line 31 of file msacm.c.

Function Documentation

◆ acm_driver_func()

static LRESULT CALLBACK acm_driver_func ( DWORD_PTR  id,
HDRVR  handle,
UINT  msg,
LPARAM  param1,
LPARAM  param2 
)
static

Definition at line 1379 of file msacm.c.

1380{
1381 switch (msg)
1382 {
1383 /* Driver messages */
1384 case DRV_LOAD:
1385 driver_calls.driver.load++;
1386 return 1;
1387 case DRV_FREE:
1388 driver_calls.driver.free++;
1389 return 1;
1390 case DRV_OPEN:
1391 driver_calls.driver.open++;
1392 return 1;
1393 case DRV_CLOSE:
1394 driver_calls.driver.close++;
1395 return 1;
1396 case DRV_ENABLE:
1397 driver_calls.driver.enable++;
1398 return 1;
1399 case DRV_DISABLE:
1400 driver_calls.driver.disable++;
1401 return 1;
1402 case DRV_QUERYCONFIGURE:
1403 driver_calls.driver.querycfg++;
1404 return 1;
1405 case DRV_INSTALL:
1406 driver_calls.driver.install++;
1407 return DRVCNF_RESTART;
1408 case DRV_REMOVE:
1409 driver_calls.driver.remove++;
1410 return DRVCNF_RESTART;
1411 case ACMDM_DRIVER_ABOUT:
1412 driver_calls.driver.about++;
1413 return MMSYSERR_NOTSUPPORTED;
1415 {
1417
1418 /* copied from pcmconverter.c */
1421 ptr->wMid = MM_MICROSOFT;
1422 ptr->wPid = MM_MSFT_ACM_PCM;
1423 ptr->vdwACM = 0x01000000;
1424 ptr->vdwDriver = 0x01000000;
1426 ptr->cFormatTags = 1;
1427 ptr->cFilterTags = 0;
1428 ptr->hicon = NULL;
1429 strcpy(ptr->szShortName, "TEST-CODEC");
1430 strcpy(ptr->szLongName, "Wine Test Codec");
1431 strcpy(ptr->szCopyright, "Brought to you by the Wine team...");
1432 strcpy(ptr->szLicensing, "Refer to LICENSE file");
1433 ptr->szFeatures[0] = 0;
1434
1435 driver_calls.driver.details++;
1436 break;
1437 }
1439 driver_calls.driver.notify++;
1440 return MMSYSERR_NOTSUPPORTED;
1441
1442 /* Format messages */
1444 driver_calls.format.tag_details++;
1445 break;
1447 driver_calls.format.details++;
1448 break;
1450 driver_calls.format.suggest++;
1451 break;
1452
1453 /* Stream messages */
1454 case ACMDM_STREAM_OPEN:
1455 driver_calls.stream.open++;
1456 break;
1457 case ACMDM_STREAM_CLOSE:
1458 driver_calls.stream.close++;
1459 break;
1460 case ACMDM_STREAM_SIZE:
1461 driver_calls.stream.size++;
1462 break;
1464 driver_calls.stream.convert++;
1465 break;
1466 case ACMDM_STREAM_RESET:
1467 driver_calls.stream.reset++;
1468 return MMSYSERR_NOTSUPPORTED;
1470 driver_calls.stream.prepare++;
1471 break;
1473 driver_calls.stream.unprepare++;
1474 break;
1475
1476 default:
1477 driver_calls.other++;
1478 return DefDriverProc(id, handle, msg, param1, param2);
1479 }
1480 return MMSYSERR_NOERROR;
1481}
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
#define msg(x)
Definition: auth_time.c:54
#define NULL
Definition: types.h:112
LRESULT WINAPI DefDriverProc(DWORD_PTR dwDriverIdentifier, HDRVR hDrv, UINT Msg, LPARAM lParam1, LPARAM lParam2)
Definition: driver.c:554
#define DRV_LOAD(x)
#define MM_MSFT_ACM_PCM
Definition: mmreg.h:150
#define MM_MICROSOFT
Definition: mmreg.h:144
#define DRV_CLOSE
Definition: mmsystem.h:122
#define DRV_QUERYCONFIGURE
Definition: mmsystem.h:126
#define MMSYSERR_NOTSUPPORTED
Definition: mmsystem.h:104
#define DRVCNF_RESTART
Definition: mmsystem.h:135
#define DRV_REMOVE
Definition: mmsystem.h:128
#define DRV_ENABLE
Definition: mmsystem.h:120
#define DRV_OPEN
Definition: mmsystem.h:121
#define DRV_INSTALL
Definition: mmsystem.h:127
#define MMSYSERR_NOERROR
Definition: mmsystem.h:96
#define DRV_FREE
Definition: mmsystem.h:124
#define DRV_DISABLE
Definition: mmsystem.h:123
static PVOID ptr
Definition: dispmode.c:27
static struct @1663 driver_calls
#define ACMDRIVERDETAILS_SUPPORTF_CONVERTER
Definition: msacm.h:62
#define ACMDM_DRIVER_ABOUT
Definition: msacm.h:227
#define ACMDRIVERDETAILS_FCCCOMP_UNDEFINED
Definition: msacm.h:59
#define ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC
Definition: msacm.h:58
#define ACMDM_STREAM_PREPARE
Definition: msacmdrv.h:63
#define ACMDM_STREAM_CLOSE
Definition: msacmdrv.h:59
#define ACMDM_STREAM_CONVERT
Definition: msacmdrv.h:61
#define ACMDM_FORMAT_SUGGEST
Definition: msacmdrv.h:53
#define ACMDM_DRIVER_NOTIFY
Definition: msacmdrv.h:45
#define ACMDM_FORMAT_DETAILS
Definition: msacmdrv.h:52
#define ACMDM_STREAM_SIZE
Definition: msacmdrv.h:60
#define ACMDM_FORMATTAG_DETAILS
Definition: msacmdrv.h:51
#define ACMDM_STREAM_UNPREPARE
Definition: msacmdrv.h:64
#define ACMDM_STREAM_OPEN
Definition: msacmdrv.h:58
#define ACMDM_DRIVER_DETAILS
Definition: msacmdrv.h:46
#define ACMDM_STREAM_RESET
Definition: msacmdrv.h:62

Referenced by test_acmDriverAdd().

◆ check_count()

static void check_count ( UINT  uMetric)
static

Definition at line 777 of file msacm.c.

778{
779 DWORD dwMetric;
780 MMRESULT rc;
781
782 /* try invalid result pointer */
783 rc = acmMetrics(NULL, uMetric, 0);
785 "acmMetrics(NULL, %s, 0): rc = 0x%08x, should be 0x%08x\n",
786 get_metric(uMetric), rc, MMSYSERR_INVALPARAM);
787
788 /* try invalid handle */
789 rc = acmMetrics((HACMOBJ)1, uMetric, &dwMetric);
791 "acmMetrics(1, %s, %p): rc = 0x%08x, should be 0x%08x\n",
792 get_metric(uMetric), &dwMetric, rc, MMSYSERR_INVALHANDLE);
793
794 /* try invalid result pointer and handle */
795 rc = acmMetrics((HACMOBJ)1, uMetric, 0);
797 "acmMetrics(1, %s, 0): rc = 0x%08x, should be 0x%08x\n",
798 get_metric(uMetric), rc, MMSYSERR_INVALHANDLE);
799
800 /* try valid parameters */
801 rc = acmMetrics(NULL, uMetric, &dwMetric);
802 ok(rc == MMSYSERR_NOERROR, "acmMetrics() failed: rc = 0x%08x\n", rc);
803
805 trace("%s: %u\n", get_metric(uMetric), dwMetric);
806}
#define trace
Definition: atltest.h:70
#define ok(value,...)
Definition: atltest.h:57
unsigned long DWORD
Definition: ntddk_ex.h:95
UINT MMRESULT
Definition: mmsystem.h:962
#define MMSYSERR_INVALHANDLE
Definition: mmsystem.h:101
#define MMSYSERR_INVALPARAM
Definition: mmsystem.h:107
MMRESULT WINAPI acmMetrics(HACMOBJ hao, UINT uMetric, LPVOID pMetric)
Definition: msacm32_main.c:106
static const char * get_metric(UINT uMetric)
Definition: msacm.c:735
int winetest_interactive

Referenced by driver_tests().

◆ driver_tests()

static void driver_tests ( void  )
static

Definition at line 808 of file msacm.c.

809{
810 MMRESULT rc;
811 DWORD dwACMVersion = acmGetVersion();
812
814 trace("ACM version = %u.%02u build %u%s\n",
815 HIWORD(dwACMVersion) >> 8,
816 HIWORD(dwACMVersion) & 0xff,
817 LOWORD(dwACMVersion),
818 LOWORD(dwACMVersion) == 0 ? " (Retail)" : "");
819 }
820
832
834 trace("enabled drivers:\n");
835
836 rc = acmDriverEnum(DriverEnumProc, 0, 0);
837 ok(rc == MMSYSERR_NOERROR,
838 "acmDriverEnum() failed, rc=%08x, should be 0x%08x\n",
839 rc, MMSYSERR_NOERROR);
840}
MMRESULT WINAPI acmDriverEnum(ACMDRIVERENUMCB fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum)
Definition: driver.c:315
DWORD WINAPI acmGetVersion(void)
Definition: msacm32_main.c:76
static void check_count(UINT uMetric)
Definition: msacm.c:777
static BOOL CALLBACK DriverEnumProc(HACMDRIVERID hadid, DWORD_PTR dwInstance, DWORD fdwSupport)
Definition: msacm.c:317
#define ACM_METRIC_COUNT_DISABLED
Definition: msacm.h:191
#define ACM_METRIC_COUNT_FILTERS
Definition: msacm.h:190
#define ACM_METRIC_COUNT_LOCAL_CODECS
Definition: msacm.h:194
#define ACM_METRIC_COUNT_LOCAL_DISABLED
Definition: msacm.h:197
#define ACM_METRIC_COUNT_LOCAL_FILTERS
Definition: msacm.h:196
#define ACM_METRIC_COUNT_HARDWARE
Definition: msacm.h:192
#define ACM_METRIC_COUNT_CODECS
Definition: msacm.h:188
#define ACM_METRIC_COUNT_CONVERTERS
Definition: msacm.h:189
#define ACM_METRIC_COUNT_LOCAL_CONVERTERS
Definition: msacm.h:195
#define ACM_METRIC_COUNT_LOCAL_DRIVERS
Definition: msacm.h:193
#define ACM_METRIC_COUNT_DRIVERS
Definition: msacm.h:187
#define LOWORD(l)
Definition: pedump.c:82
#define HIWORD(l)
Definition: typedefs.h:247

Referenced by START_TEST().

◆ DriverEnumProc()

static BOOL CALLBACK DriverEnumProc ( HACMDRIVERID  hadid,
DWORD_PTR  dwInstance,
DWORD  fdwSupport 
)
static

Definition at line 317 of file msacm.c.

320{
321 MMRESULT rc;
323 HACMDRIVER had;
324
325 DWORD dwDriverPriority;
326 DWORD dwDriverSupport;
327
329 trace("id: %p\n", hadid);
330 trace(" Supports:\n");
331 if (fdwSupport & ACMDRIVERDETAILS_SUPPORTF_ASYNC)
332 trace(" async conversions\n");
333 if (fdwSupport & ACMDRIVERDETAILS_SUPPORTF_CODEC)
334 trace(" different format conversions\n");
336 trace(" same format conversions\n");
337 if (fdwSupport & ACMDRIVERDETAILS_SUPPORTF_FILTER)
338 trace(" filtering\n");
339 }
340
341 /* try an invalid pointer */
342 rc = acmDriverDetailsA(hadid, 0, 0);
344 "acmDriverDetailsA(): rc = %08x, should be %08x\n",
346
347 /* try an invalid structure size */
348 ZeroMemory(&dd, sizeof(dd));
349 rc = acmDriverDetailsA(hadid, &dd, 0);
351 "acmDriverDetailsA(): rc = %08x, should be %08x\n",
353
354 /* MSDN says this should fail but it doesn't in practice */
355 dd.cbStruct = 4;
356 rc = acmDriverDetailsA(hadid, &dd, 0);
358 "acmDriverDetailsA(): rc = %08x, should be %08x\n",
359 rc, MMSYSERR_NOERROR);
360
361 /* try an invalid handle */
362 dd.cbStruct = sizeof(dd);
363 rc = acmDriverDetailsA((HACMDRIVERID)1, &dd, 0);
365 "acmDriverDetailsA(): rc = %08x, should be %08x\n",
367
368 /* try an invalid handle and pointer */
369 rc = acmDriverDetailsA((HACMDRIVERID)1, 0, 0);
371 "acmDriverDetailsA(): rc = %08x, should be %08x\n",
373
374 /* try invalid details */
375 rc = acmDriverDetailsA(hadid, &dd, -1);
377 "acmDriverDetailsA(): rc = %08x, should be %08x\n",
379
380 /* try valid parameters */
381 rc = acmDriverDetailsA(hadid, &dd, 0);
383 "acmDriverDetailsA(): rc = %08x, should be %08x\n",
384 rc, MMSYSERR_NOERROR);
385
386 /* cbStruct should contain size of returned data (at most sizeof(dd))
387 TODO: should it be *exactly* sizeof(dd), as tested here?
388 */
389 if (rc == MMSYSERR_NOERROR) {
390 static const struct {
391 const char *shortname;
392 WORD mid;
393 WORD pid;
394 WORD pid_alt;
395 } *iter, expected_ids[] = {
396 { "Microsoft IMA ADPCM", MM_MICROSOFT, MM_MSFT_ACM_IMAADPCM },
397 { "MS-ADPCM", MM_MICROSOFT, MM_MSFT_ACM_MSADPCM },
398 { "Microsoft CCITT G.711", MM_MICROSOFT, MM_MSFT_ACM_G711},
400 { "MS-PCM", MM_MICROSOFT, MM_MSFT_ACM_PCM },
401 { 0 }
402 };
403
404 ok(dd.cbStruct == sizeof(dd),
405 "acmDriverDetailsA(): cbStruct = %08x\n", dd.cbStruct);
406
407 for (iter = expected_ids; iter->shortname; ++iter) {
408 if (!strcmp(iter->shortname, dd.szShortName)) {
409 /* try alternative product id on mismatch */
410 if (iter->pid_alt && iter->pid != dd.wPid)
411 ok(iter->mid == dd.wMid && iter->pid_alt == dd.wPid,
412 "Got wrong manufacturer (0x%x vs 0x%x) or product (0x%x vs 0x%x)\n",
413 dd.wMid, iter->mid,
414 dd.wPid, iter->pid_alt);
415 else
416 ok(iter->mid == dd.wMid && iter->pid == dd.wPid,
417 "Got wrong manufacturer (0x%x vs 0x%x) or product (0x%x vs 0x%x)\n",
418 dd.wMid, iter->mid,
419 dd.wPid, iter->pid);
420 }
421 }
422 }
423
425 trace(" Short name: %s\n", dd.szShortName);
426 trace(" Long name: %s\n", dd.szLongName);
427 trace(" Copyright: %s\n", dd.szCopyright);
428 trace(" Licensing: %s\n", dd.szLicensing);
429 trace(" Features: %s\n", dd.szFeatures);
430 trace(" Supports %u formats\n", dd.cFormatTags);
431 trace(" Supports %u filter formats\n", dd.cFilterTags);
432 trace(" Mid: 0x%x\n", dd.wMid);
433 trace(" Pid: 0x%x\n", dd.wPid);
434 }
435
436 /* try bad pointer */
437 rc = acmMetrics((HACMOBJ)hadid, ACM_METRIC_DRIVER_PRIORITY, 0);
439 "acmMetrics(): rc = %08x, should be %08x\n",
441
442 /* try bad handle */
443 rc = acmMetrics((HACMOBJ)1, ACM_METRIC_DRIVER_PRIORITY, &dwDriverPriority);
445 "acmMetrics(): rc = %08x, should be %08x\n",
447
448 /* try bad pointer and handle */
449 rc = acmMetrics((HACMOBJ)1, ACM_METRIC_DRIVER_PRIORITY, 0);
451 "acmMetrics(): rc = %08x, should be %08x\n",
453
454 /* try valid parameters */
455 rc = acmMetrics((HACMOBJ)hadid, ACM_METRIC_DRIVER_PRIORITY, &dwDriverSupport);
456 ok(rc == MMSYSERR_NOERROR,
457 "acmMetrics(): rc = %08x, should be %08x\n",
458 rc, MMSYSERR_NOERROR);
459
460 /* try bad pointer */
461 rc = acmMetrics((HACMOBJ)hadid, ACM_METRIC_DRIVER_SUPPORT, 0);
463 "acmMetrics(): rc = %08x, should be %08x\n",
465
466 /* try bad handle */
467 rc = acmMetrics((HACMOBJ)1, ACM_METRIC_DRIVER_SUPPORT, &dwDriverSupport);
469 "acmMetrics(): rc = %08x, should be %08x\n",
471
472 /* try bad pointer and handle */
473 rc = acmMetrics((HACMOBJ)1, ACM_METRIC_DRIVER_SUPPORT, 0);
475 "acmMetrics(): rc = %08x, should be %08x\n",
477
478 /* try valid parameters */
479 rc = acmMetrics((HACMOBJ)hadid, ACM_METRIC_DRIVER_SUPPORT, &dwDriverSupport);
480 ok(rc == MMSYSERR_NOERROR,
481 "acmMetrics(): rc = %08x, should be %08x\n",
482 rc, MMSYSERR_NOERROR);
483
484 /* try invalid pointer */
485 rc = acmDriverOpen(0, hadid, 0);
487 "acmDriverOpen(): rc = %08x, should be %08x\n",
489
490 /* try invalid handle */
491 rc = acmDriverOpen(&had, (HACMDRIVERID)1, 0);
493 "acmDriverOpen(): rc = %08x, should be %08x\n",
495
496 /* try invalid open */
497 rc = acmDriverOpen(&had, hadid, -1);
499 "acmDriverOpen(): rc = %08x, should be %08x\n",
501
502 /* try valid parameters */
503 rc = acmDriverOpen(&had, hadid, 0);
505 "acmDriverOpen(): rc = %08x, should be %08x\n",
506 rc, MMSYSERR_NOERROR);
507
508 if (rc == MMSYSERR_NOERROR) {
510 HACMDRIVERID hid;
511
512 /* try bad pointer */
513 rc = acmDriverID((HACMOBJ)had, 0, 0);
515 "acmDriverID(): rc = %08x, should be %08x\n",
517
518 /* try bad handle */
519 rc = acmDriverID((HACMOBJ)1, &hid, 0);
521 "acmDriverID(): rc = %08x, should be %08x\n",
523
524 /* try bad handle and pointer */
525 rc = acmDriverID((HACMOBJ)1, 0, 0);
527 "acmDriverID(): rc = %08x, should be %08x\n",
529
530 /* try bad flag */
531 rc = acmDriverID((HACMOBJ)had, &hid, 1);
533 "acmDriverID(): rc = %08x, should be %08x\n",
535
536 /* try valid parameters */
537 rc = acmDriverID((HACMOBJ)had, &hid, 0);
538 ok(rc == MMSYSERR_NOERROR,
539 "acmDriverID(): rc = %08x, should be %08x\n",
540 rc, MMSYSERR_NOERROR);
541 ok(hid == hadid,
542 "acmDriverID() returned ID %p doesn't equal %p\n",
543 hid, hadid);
544
545 /* try bad pointer */
546 rc = acmMetrics((HACMOBJ)had, ACM_METRIC_MAX_SIZE_FORMAT, 0);
548 "acmMetrics(): rc = %08x, should be %08x\n",
550
551 /* try bad handle */
552 rc = acmMetrics((HACMOBJ)1, ACM_METRIC_MAX_SIZE_FORMAT, &dwSize);
554 "acmMetrics(): rc = %08x, should be %08x\n",
556
557 /* try bad pointer and handle */
558 rc = acmMetrics((HACMOBJ)1, ACM_METRIC_MAX_SIZE_FORMAT, 0);
560 "acmMetrics(): rc = %08x, should be %08x\n",
562
563 /* try valid parameters */
564 rc = acmMetrics((HACMOBJ)had, ACM_METRIC_MAX_SIZE_FORMAT, &dwSize);
565 ok(rc == MMSYSERR_NOERROR,
566 "acmMetrics(): rc = %08x, should be %08x\n",
567 rc, MMSYSERR_NOERROR);
568 if (rc == MMSYSERR_NOERROR) {
570 WAVEFORMATEX * pwfx;
572
573 /* try bad pointer */
574 rc = acmFormatEnumA(had, 0, FormatEnumProc, 0, 0);
576 "acmFormatEnumA(): rc = %08x, should be %08x\n",
578
579 /* try bad structure size */
580 ZeroMemory(&fd, sizeof(fd));
581 rc = acmFormatEnumA(had, &fd, FormatEnumProc, 0, 0);
583 "acmFormatEnumA(): rc = %08x, should be %08x\n",
585
586 fd.cbStruct = sizeof(fd) - 1;
587 rc = acmFormatEnumA(had, &fd, FormatEnumProc, 0, 0);
589 "acmFormatEnumA(): rc = %08x, should be %08x\n",
591
593
594 if (dwSize >= sizeof(WAVEFORMATEX))
595 pwfx->cbSize = LOWORD(dwSize) - sizeof(WAVEFORMATEX);
597
598 fd.cbStruct = sizeof(fd);
599 fd.pwfx = pwfx;
600 fd.cbwfx = dwSize;
601 fd.dwFormatTag = WAVE_FORMAT_UNKNOWN;
602
603 /* try bad callback */
604 rc = acmFormatEnumA(had, &fd, NULL, 0, 0);
606 "acmFormatEnumA(): rc = %08x, should be %08x\n",
608
609 /* try bad pwfx */
610 fd.pwfx = NULL;
611 rc = acmFormatEnumA(had, &fd, FormatEnumProc, 0, 0);
613 "acmFormatEnumA(): rc = %08x, should be %08x\n",
615 fd.pwfx = pwfx;
616
617 /* fdwSupport must be zero */
618 fd.fdwSupport = 0xdeadbeef;
619 rc = acmFormatEnumA(had, &fd, FormatEnumProc, 0, 0);
621 "acmFormatEnumA(): rc = %08x, should be %08x\n",
623 fd.fdwSupport = 0;
624
625 /* try bad pwfx structure size */
626 fd.cbwfx = dwSize-1;
627 rc = acmFormatEnumA(had, &fd, FormatEnumProc, 0, 0);
629 "acmFormatEnumA(): rc = %08x, should be %08x\n",
631 fd.cbwfx = dwSize;
632
633 /* try valid parameters */
634 rc = acmFormatEnumA(had, &fd, FormatEnumProc, 0, 0);
635 ok(rc == MMSYSERR_NOERROR,
636 "acmFormatEnumA(): rc = %08x, should be %08x\n",
637 rc, MMSYSERR_NOERROR);
638
639 /* try bad pointer */
640 rc = acmFormatTagEnumA(had, 0, FormatTagEnumProc, 0, 0);
642 "acmFormatTagEnumA(): rc = %08x, should be %08x\n",
644
645 /* try bad structure size */
646 ZeroMemory(&aftd, sizeof(aftd));
647 rc = acmFormatTagEnumA(had, &aftd, FormatTagEnumProc, 0, 0);
649 "acmFormatTagEnumA(): rc = %08x, should be %08x\n",
651
652 aftd.cbStruct = sizeof(aftd) - 1;
653 rc = acmFormatTagEnumA(had, &aftd, FormatTagEnumProc, 0, 0);
655 "acmFormatTagEnumA(): rc = %08x, should be %08x\n",
657
658 aftd.cbStruct = sizeof(aftd);
660
661 /* try bad flag */
662 rc = acmFormatTagEnumA(had, &aftd, FormatTagEnumProc, 0, 1);
664 "acmFormatTagEnumA(): rc = %08x, should be %08x\n",
666
667 /* try valid parameters */
668 rc = acmFormatTagEnumA(had, &aftd, FormatTagEnumProc, 0, 0);
669 ok(rc == MMSYSERR_NOERROR,
670 "acmFormatTagEnumA(): rc = %08x, should be %08x\n",
671 rc, MMSYSERR_NOERROR);
672
673 /* try bad pointer */
676 "acmFormatDetailsA(): rc = %08x, should be %08x\n",
678
679 /* try bad structure size */
680 ZeroMemory(&fd, sizeof(fd));
683 "acmFormatDetailsA(): rc = %08x, should be %08x\n",
685
686 fd.cbStruct = sizeof(fd) - 1;
689 "acmFormatDetailsA(): rc = %08x, should be %08x\n",
691
692 fd.cbStruct = sizeof(fd);
693 fd.pwfx = pwfx;
694 ZeroMemory(fd.pwfx, dwSize);
695 fd.cbwfx = dwSize;
696 fd.dwFormatTag = WAVE_FORMAT_UNKNOWN;
697
698 /* try WAVE_FORMAT_UNKNOWN */
701 "acmFormatDetailsA(): rc = %08x, should be %08x\n",
703
704 HeapFree(GetProcessHeap(), 0, pwfx);
705
706 /* try invalid handle */
707 rc = acmDriverClose((HACMDRIVER)1, 0);
709 "acmDriverClose(): rc = %08x, should be %08x\n",
711
712 /* try invalid flag */
713 rc = acmDriverClose(had, 1);
715 "acmDriverClose(): rc = %08x, should be %08x\n",
717
718 /* try valid parameters */
719 rc = acmDriverClose(had, 0);
720 ok(rc == MMSYSERR_NOERROR,
721 "acmDriverClose(): rc = %08x, should be %08x\n",
722 rc, MMSYSERR_NOERROR);
723
724 /* try closing again */
725 rc = acmDriverClose(had, 0);
727 "acmDriverClose(): rc = %08x, should be %08x\n",
729 }
730 }
731
732 return TRUE;
733}
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define TRUE
Definition: types.h:120
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
MMRESULT WINAPI acmDriverOpen(PHACMDRIVER phad, HACMDRIVERID hadid, DWORD fdwOpen)
Definition: driver.c:491
MMRESULT WINAPI acmDriverClose(HACMDRIVER had, DWORD fdwClose)
Definition: driver.c:179
MMRESULT WINAPI acmDriverID(HACMOBJ hao, PHACMDRIVERID phadid, DWORD fdwDriverID)
Definition: driver.c:352
MMRESULT WINAPI acmDriverDetailsA(HACMDRIVERID hadid, PACMDRIVERDETAILSA padd, DWORD fdwDetails)
Definition: driver.c:223
MMRESULT WINAPI acmFormatDetailsA(HACMDRIVER had, PACMFORMATDETAILSA pafd, DWORD fdwDetails)
Definition: format.c:401
MMRESULT WINAPI acmFormatEnumA(HACMDRIVER had, PACMFORMATDETAILSA pafda, ACMFORMATENUMCBA fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum)
Definition: format.c:542
MMRESULT WINAPI acmFormatTagEnumA(HACMDRIVER had, PACMFORMATTAGDETAILSA paftda, ACMFORMATTAGENUMCBA fnCallback, DWORD_PTR dwInstance, DWORD fdwEnum)
Definition: format.c:967
unsigned short WORD
Definition: ntddk_ex.h:93
#define MM_FRAUNHOFER_IIS
Definition: mmreg.h:152
#define WAVE_FORMAT_UNKNOWN
Definition: mmreg.h:95
#define MM_FHGIIS_MPEGLAYER3_PROFESSIONAL
Definition: mmreg.h:154
#define MM_MSFT_ACM_G711
Definition: mmreg.h:149
#define MM_MSFT_ACM_MSADPCM
Definition: mmreg.h:146
#define MM_MSFT_ACM_IMAADPCM
Definition: mmreg.h:147
#define MM_FHGIIS_MPEGLAYER3_DECODE
Definition: mmreg.h:153
#define MMSYSERR_NODRIVER
Definition: mmsystem.h:102
#define MMSYSERR_INVALFLAG
Definition: mmsystem.h:106
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
static BOOL CALLBACK FormatEnumProc(HACMDRIVERID hadid, LPACMFORMATDETAILSA pafd, DWORD_PTR dwInstance, DWORD fd)
Definition: msacm.c:232
static BOOL CALLBACK FormatTagEnumProc(HACMDRIVERID hadid, PACMFORMATTAGDETAILSA paftd, DWORD_PTR dwInstance, DWORD fdwSupport)
Definition: msacm.c:36
#define ACM_METRIC_MAX_SIZE_FORMAT
Definition: msacm.h:200
#define ACMDRIVERDETAILS_SUPPORTF_FILTER
Definition: msacm.h:63
#define ACMDRIVERDETAILS_SUPPORTF_ASYNC
Definition: msacm.h:65
#define ACM_METRIC_DRIVER_PRIORITY
Definition: msacm.h:203
#define ACM_METRIC_DRIVER_SUPPORT
Definition: msacm.h:202
#define ACM_FORMATDETAILSF_INDEX
Definition: msacm.h:160
#define ACMDRIVERDETAILS_SUPPORTF_CODEC
Definition: msacm.h:61
static int fd
Definition: io.c:51
CHAR szFeatures[ACMDRIVERDETAILS_FEATURES_CHARS]
Definition: msacm.h:293
DWORD cbStruct
Definition: msacm.h:272
CHAR szCopyright[ACMDRIVERDETAILS_COPYRIGHT_CHARS]
Definition: msacm.h:291
CHAR szLicensing[ACMDRIVERDETAILS_LICENSING_CHARS]
Definition: msacm.h:292
CHAR szShortName[ACMDRIVERDETAILS_SHORTNAME_CHARS]
Definition: msacm.h:289
DWORD cFilterTags
Definition: msacm.h:285
CHAR szLongName[ACMDRIVERDETAILS_LONGNAME_CHARS]
Definition: msacm.h:290
DWORD cFormatTags
Definition: msacm.h:284
#define ZeroMemory
Definition: winbase.h:1712
_In_ ULONG_PTR _In_ ULONG _Out_ ULONG_PTR * pid
Definition: winddi.h:3837

Referenced by driver_tests().

◆ FormatEnumProc()

static BOOL CALLBACK FormatEnumProc ( HACMDRIVERID  hadid,
LPACMFORMATDETAILSA  pafd,
DWORD_PTR  dwInstance,
DWORD  fd 
)
static

Definition at line 232 of file msacm.c.

236{
237 MMRESULT rc;
238 HACMDRIVER had;
239 WAVEFORMATEX *dst, *dstMax;
240 DWORD dwSize, dwSizeMax;
241 DWORD fdwSupport;
242
243 acmMetrics((HACMOBJ)hadid, ACM_METRIC_DRIVER_SUPPORT, &fdwSupport);
244
246 trace(" 0x%04x, %s\n", pafd->dwFormatTag, pafd->szFormat);
247
248 acmDriverOpen(&had, hadid, 0);
249 dwSize = pafd->cbwfx;
251
252 /* test acmFormatSuggest with valid src format */
253 if (pafd->dwFormatTag == WAVE_FORMAT_PCM)
254 {
255 rc = acmFormatSuggest(had, pafd->pwfx, dst, dwSize, 0);
256 /* this fails on some decode-only drivers */
258 "acmFormatSuggest(): rc = %08x, should be %08x\n",
259 rc, MMSYSERR_NOERROR);
260 if (rc == MMSYSERR_NOERROR)
261 {
262 if (fdwSupport & ACMDRIVERDETAILS_SUPPORTF_CODEC) /* supports different conversions */
263 ok(dst->wFormatTag != WAVE_FORMAT_PCM, "expected different format\n");
264 else
265 ok(dst->wFormatTag == WAVE_FORMAT_PCM,
266 "expected %d, got %d\n", WAVE_FORMAT_PCM, dst->wFormatTag);
267 }
268 }
269 else
270 {
271 rc = acmFormatSuggest(had, pafd->pwfx, dst, dwSize, 0);
272 ok(rc == MMSYSERR_NOERROR,
273 "acmFormatSuggest(): rc = %08x, should be %08x\n",
274 rc, MMSYSERR_NOERROR);
275 ok(dst->wFormatTag == WAVE_FORMAT_PCM,
276 "expected %d, got %d\n", WAVE_FORMAT_PCM, dst->wFormatTag);
277 ok(dst->nChannels == pafd->pwfx->nChannels,
278 "expected %d, got %d\n", pafd->pwfx->nChannels, dst->nChannels);
279 if (pafd->dwFormatTag != 0x42) /* codec 0x0042 returns a different sample rate */
280 ok(dst->nSamplesPerSec == pafd->pwfx->nSamplesPerSec,
281 "expected %d, got %d\n", pafd->pwfx->nSamplesPerSec, dst->nSamplesPerSec);
282 ok(dst->wBitsPerSample == 16,
283 "expected %d, got %d\n", 16, dst->wBitsPerSample);
284 ok(dst->nBlockAlign == 2*pafd->pwfx->nChannels,
285 "expected %d, got %d\n", 2*pafd->pwfx->nChannels, dst->nBlockAlign);
286
287 /* test with NULL driver */
289 dstMax = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSizeMax);
290 rc = acmFormatSuggest(NULL, pafd->pwfx, dstMax, dwSizeMax, 0);
291 ok(rc == MMSYSERR_NOERROR,
292 "acmFormatSuggest(): rc = %08x, should be %08x\n",
293 rc, MMSYSERR_NOERROR);
294
295 HeapFree(GetProcessHeap(), 0, dstMax);
296 }
297
299 dst->wFormatTag = pafd->pwfx->wFormatTag;
301 if (fdwSupport & ACMDRIVERDETAILS_SUPPORTF_CONVERTER) /* supports same conversions */
302 ok(rc == MMSYSERR_NOERROR,
303 "acmFormatSuggest(): rc = %08x, should be %08x\n",
304 rc, MMSYSERR_NOERROR);
305 else
308 "acmFormatSuggest(): rc = %08x, should be %08x\n",
310
312 acmDriverClose(had, 0);
313
314 return TRUE;
315}
#define WAVE_FORMAT_PCM
Definition: constants.h:425
MMRESULT WINAPI acmFormatSuggest(HACMDRIVER had, PWAVEFORMATEX pwfxSrc, PWAVEFORMATEX pwfxDst, DWORD cbwfxDst, DWORD fdwSuggest)
Definition: format.c:746
GLenum GLenum dst
Definition: glext.h:6340
#define todo_wine_if(is_todo)
Definition: custom.c:76
#define ACM_FORMATSUGGESTF_WFORMATTAG
Definition: msacm.h:174
#define ACMERR_NOTPOSSIBLE
Definition: msacm.h:36
CHAR szFormat[ACMFORMATDETAILS_FORMAT_CHARS]
Definition: msacm.h:498
PWAVEFORMATEX pwfx
Definition: msacm.h:496
DWORD dwFormatTag
Definition: msacm.h:494
DWORD nSamplesPerSec
Definition: mmreg.h:80
WORD nChannels
Definition: mmreg.h:79
WORD wFormatTag
Definition: mmreg.h:78

Referenced by DriverEnumProc().

◆ FormatTagEnumProc()

static BOOL CALLBACK FormatTagEnumProc ( HACMDRIVERID  hadid,
PACMFORMATTAGDETAILSA  paftd,
DWORD_PTR  dwInstance,
DWORD  fdwSupport 
)
static

Definition at line 36 of file msacm.c.

40{
41 MMRESULT rc;
42 HACMDRIVER had;
43
45 trace(" Format 0x%04x: %s\n", paftd->dwFormatTag, paftd->szFormatTag);
46
47 rc = acmDriverOpen(&had, hadid, 0);
49 "acmDriverOpen(): rc = %08x, should be %08x\n",
51
52 if (rc == MMSYSERR_NOERROR)
53 {
55 WAVEFORMATEX *pwfx, dst;
56 ACMFORMATTAGDETAILSA aftd_pcm = {0};
57 DWORD dwSize, dwSizeMax;
58 DWORD i;
59
60 fd.cbStruct = sizeof(fd);
61 if (paftd->cbFormatSize < sizeof(WAVEFORMATEX))
63 else
65 fd.pwfx = pwfx;
66 fd.cbwfx = paftd->cbFormatSize;
67 fd.dwFormatTag = paftd->dwFormatTag;
68
69 /* try bad pwfx */
70 fd.pwfx = NULL;
73 "acmFormatDetailsA(): rc = %08x, should be %08x\n",
75 fd.pwfx = pwfx;
76
77 /* try bad wFormatTag */
78 fd.pwfx->wFormatTag = WAVE_FORMAT_UNKNOWN;
81 "acmFormatDetailsA(): rc = %08x, should be %08x\n",
83 fd.pwfx->wFormatTag = paftd->dwFormatTag;
84
85 /* try bad fdwSupport */
86 fd.fdwSupport = 0xdeadbeef;
89 "acmFormatDetailsA(): rc = %08x, should be %08x\n",
91 fd.fdwSupport = 0;
92
93 /* try bad pwfx structure size */
94 fd.cbwfx = sizeof(PCMWAVEFORMAT)-1;
97 "acmFormatDetailsA(): rc = %08x, should be %08x\n",
99 fd.cbwfx = paftd->cbFormatSize;
100
101 /* test bad parameters (all zero) */
104 "acmFormatDetailsA(): rc = %08x, should be %08x\n",
106
107 /* test acmFormatSuggest */
108
109 /* if we don't specify a format, we must give at least the driver's maximum size for any format */
111 rc = acmFormatSuggest(had, pwfx, &dst, dwSize-1, 0);
113 "acmFormatSuggest(): rc = %08x, should be %08x\n",
115
116 rc = acmFormatSuggest(had, pwfx, &dst, dwSize, 0);
118 "acmFormatSuggest(): rc = %08x, should be %08x\n",
120
121 /* if we do specify a format, we must give at least the driver's maximum size for that format */
122 aftd_pcm.cbStruct = sizeof(aftd_pcm);
123 aftd_pcm.dwFormatTag = WAVE_FORMAT_PCM;
125 ok(rc == MMSYSERR_NOERROR, "returned %08x\n", rc);
126
127 dst.wFormatTag = WAVE_FORMAT_PCM;
128 rc = acmFormatSuggest(had, pwfx, &dst, aftd_pcm.cbFormatSize-1, ACM_FORMATSUGGESTF_WFORMATTAG);
130 "acmFormatSuggest(): rc = %08x, should be %08x\n",
132
135 "acmFormatSuggest(): rc = %08x, should be %08x\n",
137
138 /* test nonexistent format */
139 dst.wFormatTag = 0xbeef;
142 "acmFormatSuggest(): rc = %08x, should be %08x\n",
144
145 /* if the driver is NULL, we must give at least the maximum size for any driver */
147 rc = acmFormatSuggest(NULL, pwfx, &dst, dwSizeMax-1, 0);
149 "acmFormatSuggest(): rc = %08x, should be %08x\n",
151
152 if (paftd->dwFormatTag != WAVE_FORMAT_PCM)
153 {
154 rc = acmFormatSuggest(NULL, pwfx, &dst, dwSizeMax, 0);
156 "acmFormatSuggest(): rc = %08x, should be %08x\n",
158 }
159
160 /* if we specify a dst format, we must give the maximum size for that format */
161 dst.wFormatTag = WAVE_FORMAT_PCM;
163 ok(rc == MMSYSERR_INVALPARAM || broken (rc == ACMERR_NOTPOSSIBLE), /* WinXP */
164 "acmFormatSuggest(): rc = %08x, should be %08x\n",
166
169 "acmFormatSuggest(): rc = %08x, should be %08x\n",
171
172 dst.wFormatTag = paftd->dwFormatTag;
174 ok(rc == MMSYSERR_INVALPARAM || broken (rc == ACMERR_NOTPOSSIBLE), /* WinXP */
175 "acmFormatSuggest(): rc = %08x, should be %08x\n",
177
180 "acmFormatSuggest(): rc = %08x, should be %08x\n",
182
183 /* test nonexistent format */
184 dst.wFormatTag = 0xbeef;
187 "acmFormatSuggest(): rc = %08x, should be %08x\n",
189
190 /* test index */
191 for (i = 0; i < paftd->cStandardFormats; i++)
192 {
193 fd.dwFormatIndex = i;
194
195 fd.fdwSupport = 0;
196 fd.cbwfx = paftd->cbFormatSize;
197 fd.pwfx->cbSize = 0xbeef;
199 ok(rc == MMSYSERR_NOERROR,
200 "acmFormatDetailsA(): rc = %08x, should be %08x\n",
201 rc, MMSYSERR_NOERROR);
202
203 /* Windows will write cbSize (and other data) even if the
204 * given cbwfx is not large enough */
205 fd.fdwSupport = 0;
206 fd.cbwfx = sizeof(PCMWAVEFORMAT);
207 fd.pwfx->cbSize = 0xbeef;
209 todo_wine_if(rc != MMSYSERR_NOERROR) /* remove when fixed */
210 ok(rc == MMSYSERR_NOERROR,
211 "acmFormatDetailsA(): rc = %08x, should be %08x\n",
212 rc, MMSYSERR_NOERROR);
213 if (paftd->dwFormatTag != WAVE_FORMAT_PCM)
214 todo_wine_if(fd.pwfx->cbSize != paftd->cbFormatSize - sizeof(WAVEFORMATEX)) /* remove when fixed */
215 ok(fd.pwfx->cbSize == paftd->cbFormatSize - sizeof(WAVEFORMATEX),
216 "got %d\n", fd.pwfx->cbSize);
217 }
218
219 /* one more */
220 fd.dwFormatIndex = paftd->cStandardFormats;
221 fd.fdwSupport = 0;
224 "acmFormatDetailsA(): rc = %08x, should be %08x\n",
226
227 HeapFree(GetProcessHeap(), 0, pwfx);
228 }
229 return TRUE;
230}
#define broken(x)
Definition: _sntprintf.h:21
MMRESULT WINAPI acmFormatTagDetailsA(HACMDRIVER had, PACMFORMATTAGDETAILSA paftda, DWORD fdwDetails)
Definition: format.c:825
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
struct pcmwaveformat_tag PCMWAVEFORMAT
#define ACM_FORMATDETAILSF_FORMAT
Definition: msacm.h:161
#define ACM_FORMATTAGDETAILSF_LARGESTSIZE
Definition: msacm.h:184
CHAR szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS]
Definition: msacm.h:524
DWORD cStandardFormats
Definition: msacm.h:523

Referenced by DriverEnumProc().

◆ get_metric()

static const char * get_metric ( UINT  uMetric)
static

Definition at line 735 of file msacm.c.

736{
737 switch (uMetric) {
739 return "ACM_METRIC_COUNT_CODECS";
741 return "ACM_METRIC_COUNT_CONVERTERS";
743 return "ACM_METRIC_COUNT_DISABLED";
745 return "ACM_METRIC_COUNT_DRIVERS";
747 return "ACM_METRIC_COUNT_FILTERS";
749 return "ACM_METRIC_COUNT_HARDWARE";
751 return "ACM_METRIC_COUNT_LOCAL_CODECS";
753 return "ACM_METRIC_COUNT_LOCAL_CONVERTERS";
755 return "ACM_METRIC_COUNT_LOCAL_DISABLED";
757 return "ACM_METRIC_COUNT_LOCAL_DRIVERS";
759 return "ACM_METRIC_COUNT_LOCAL_FILTERS";
761 return "ACM_METRIC_DRIVER_PRIORITY";
763 return "ACM_METRIC_DRIVER_SUPPORT";
765 return "ACM_METRIC_HARDWARE_WAVE_INPUT";
767 return "ACM_METRIC_HARDWARE_WAVE_OUTPUT";
769 return "ACM_METRIC_MAX_SIZE_FILTER";
771 return "ACM_METRIC_MAX_SIZE_FORMAT";
772 }
773
774 return "UNKNOWN";
775}
#define ACM_METRIC_HARDWARE_WAVE_INPUT
Definition: msacm.h:198
#define ACM_METRIC_MAX_SIZE_FILTER
Definition: msacm.h:201
#define ACM_METRIC_HARDWARE_WAVE_OUTPUT
Definition: msacm.h:199

Referenced by check_count().

◆ START_TEST()

START_TEST ( msacm  )

Definition at line 1523 of file msacm.c.

1524{
1525 driver_tests();
1527 test_convert();
1531 test_mp3();
1532 /* Test acmDriverAdd in the end as it may conflict
1533 * with other tests due to codec lookup order */
1535}
static void test_mp3(void)
Definition: msacm.c:1279
static void test_acmDriverAdd(void)
Definition: msacm.c:1483
static void test_convert(void)
Definition: msacm.c:1101
static void test_acmFormatTagDetails(void)
Definition: msacm.c:1240
static void test_prepareheader(void)
Definition: msacm.c:842
static void test_acmFormatSuggest(void)
Definition: msacm.c:1143
static void driver_tests(void)
Definition: msacm.c:808
static void test_acmFormatChoose(void)
Definition: msacm.c:1252

◆ test_acmDriverAdd()

static void test_acmDriverAdd ( void  )
static

Definition at line 1483 of file msacm.c.

1484{
1485 MMRESULT res;
1486 HACMDRIVERID drvid;
1487 union
1488 {
1489 ACMDRIVERDETAILSA drv_details;
1490 } acm;
1491
1492 /* Driver load steps:
1493 * - acmDriverAdd checks the passed parameters
1494 * - DRV_LOAD message is sent - required
1495 * - DRV_ENABLE message is sent - required
1496 * - DRV_OPEN message is sent - required
1497 * - DRV_DETAILS message is sent - required
1498 * - ACMDM_FORMATTAG_DETAILS message is sent - optional
1499 * - DRV_QUERYCONFIGURE message is sent - optional
1500 * - ACMDM_DRIVER_ABOUT message is sent - optional
1501 */
1502
1504 ok(res == MMSYSERR_NOERROR, "Expected 0, got %d\n", res);
1506 ok(driver_calls.driver.open == 1, "Expected 1, got %d\n", driver_calls.driver.open);
1507 ok(driver_calls.driver.details == 1, "Expected 1, got %d\n", driver_calls.driver.details);
1508
1509 memset(&acm, 0, sizeof(acm));
1510 res = acmDriverDetailsA(drvid, &acm.drv_details, 0);
1511 ok(res == MMSYSERR_INVALPARAM, "Expected 11, got %d\n", res);
1512
1513 acm.drv_details.cbStruct = sizeof(acm.drv_details);
1514 res = acmDriverDetailsA(drvid, &acm.drv_details, 0);
1515 ok(res == MMSYSERR_NOERROR, "Expected 0, got %d\n", res);
1517 ok(driver_calls.driver.open == 1, "Expected 1, got %d\n", driver_calls.driver.open);
1518 ok(driver_calls.driver.details == 2, "Expected 2, got %d\n", driver_calls.driver.details);
1520 ok(driver_calls.driver.close == 0, "Expected 0, got %d\n", driver_calls.driver.close);
1521}
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
MMRESULT WINAPI acmDriverAddA(PHACMDRIVERID phadid, HINSTANCE hinstModule, LPARAM lParam, DWORD dwPriority, DWORD fdwAdd)
Definition: driver.c:45
GLuint res
Definition: glext.h:9613
#define todo_wine
Definition: custom.c:79
static LRESULT CALLBACK acm_driver_func(DWORD_PTR id, HDRVR handle, UINT msg, LPARAM param1, LPARAM param2)
Definition: msacm.c:1379
#define ACM_DRIVERADDF_FUNCTION
Definition: msacm.h:46
#define memset(x, y, z)
Definition: compat.h:39
LONG_PTR LPARAM
Definition: windef.h:208

Referenced by START_TEST().

◆ test_acmFormatChoose()

static void test_acmFormatChoose ( void  )
static

Definition at line 1252 of file msacm.c.

1253{
1254 ACMFORMATCHOOSEW afc = {0};
1255 WAVEFORMATEX *pwfx;
1256 DWORD sizeMax;
1257 MMRESULT rc;
1258
1260 pwfx = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeMax);
1261
1262 afc.cbStruct = sizeof(afc);
1263 afc.pwfx = pwfx;
1264
1265 /* test invalid struct size */
1266 afc.cbStruct = sizeof(afc)-1;
1267 rc = acmFormatChooseW(&afc);
1268 ok(rc == MMSYSERR_INVALPARAM, "expected 0xb, got 0x%x\n", rc);
1269 afc.cbStruct = sizeof(afc);
1270
1271 afc.pwfx = NULL;
1272 rc = acmFormatChooseW(&afc);
1273 ok(rc == MMSYSERR_INVALPARAM, "expected 0xb, got 0x%x\n", rc);
1274 afc.pwfx = pwfx;
1275
1276 HeapFree(GetProcessHeap(), 0, pwfx);
1277}
MMRESULT WINAPI acmFormatChooseW(PACMFORMATCHOOSEW pafmtc)
Definition: format.c:378
DWORD cbStruct
Definition: msacm.h:462
PWAVEFORMATEX pwfx
Definition: msacm.h:467

Referenced by START_TEST().

◆ test_acmFormatSuggest()

static void test_acmFormatSuggest ( void  )
static

Definition at line 1143 of file msacm.c.

1144{
1146 DWORD suggest;
1147 MMRESULT rc;
1148 DWORD sizeMax;
1149
1151
1152 /* Test a valid PCM format */
1153 src.wFormatTag = WAVE_FORMAT_PCM;
1154 src.nChannels = 1;
1155 src.nSamplesPerSec = 8000;
1156 src.nAvgBytesPerSec = 16000;
1157 src.nBlockAlign = 2;
1158 src.wBitsPerSample = 16;
1159 src.cbSize = 0;
1160 suggest = 0;
1161 memset(&dst, 0, sizeof(dst));
1162 rc = acmFormatSuggest(NULL, &src, &dst, sizeof(PCMWAVEFORMAT), suggest);
1163 ok(rc == MMSYSERR_NOERROR, "failed with error 0x%x\n", rc);
1164 ok(src.wFormatTag == dst.wFormatTag, "expected %d, got %d\n", src.wFormatTag, dst.wFormatTag);
1165 ok(src.nChannels == dst.nChannels, "expected %d, got %d\n", src.nChannels, dst.nChannels);
1166 ok(src.nSamplesPerSec == dst.nSamplesPerSec, "expected %d, got %d\n", src.nSamplesPerSec, dst.nSamplesPerSec);
1167 ok(src.nAvgBytesPerSec == dst.nAvgBytesPerSec, "expected %d, got %d\n", src.nAvgBytesPerSec, dst.nAvgBytesPerSec);
1168 ok(src.nBlockAlign == dst.nBlockAlign, "expected %d, got %d\n", src.nBlockAlign, dst.nBlockAlign);
1169 ok(src.wBitsPerSample == dst.wBitsPerSample, "expected %d, got %d\n", src.wBitsPerSample, dst.wBitsPerSample);
1170
1171 /* All parameters from destination are valid */
1176 dst = src;
1177 rc = acmFormatSuggest(NULL, &src, &dst, sizeof(PCMWAVEFORMAT), suggest);
1178 ok(rc == MMSYSERR_NOERROR, "failed with error 0x%x\n", rc);
1179 ok(src.wFormatTag == dst.wFormatTag, "expected %d, got %d\n", src.wFormatTag, dst.wFormatTag);
1180 ok(src.nChannels == dst.nChannels, "expected %d, got %d\n", src.nChannels, dst.nChannels);
1181 ok(src.nSamplesPerSec == dst.nSamplesPerSec, "expected %d, got %d\n", src.nSamplesPerSec, dst.nSamplesPerSec);
1182 ok(src.nAvgBytesPerSec == dst.nAvgBytesPerSec, "expected %d, got %d\n", src.nAvgBytesPerSec, dst.nAvgBytesPerSec);
1183 ok(src.nBlockAlign == dst.nBlockAlign, "expected %d, got %d\n", src.nBlockAlign, dst.nBlockAlign);
1184 ok(src.wBitsPerSample == dst.wBitsPerSample, "expected %d, got %d\n", src.wBitsPerSample, dst.wBitsPerSample);
1185
1186 /* Test an invalid PCM format */
1187 ZeroMemory(&dst, sizeof(dst));
1188 src.nSamplesPerSec = 0xdeadbeef;
1189 suggest = 0;
1190 rc = acmFormatSuggest(NULL, &src, &dst, sizeMax, suggest);
1191 todo_wine {
1192 ok(rc == MMSYSERR_NOERROR, "failed with error 0x%x\n", rc);
1193 ok(dst.wFormatTag == WAVE_FORMAT_PCM, "expected %d, got %d\n", WAVE_FORMAT_PCM, dst.wFormatTag);
1194 ok(dst.nSamplesPerSec == 0xdeadbeef, "expected %d, got %d\n", 0xdeadbeef, dst.nSamplesPerSec);
1195 }
1196 src.nSamplesPerSec = 8000;
1197
1198 /* Test a nonexistent format */
1199 src.wFormatTag = 0xbeef;
1200 rc = acmFormatSuggest(NULL, &src, &dst, sizeMax-1, suggest);
1201 ok(rc == MMSYSERR_INVALPARAM, "failed with error 0x%x\n", rc);
1202
1203 rc = acmFormatSuggest(NULL, &src, &dst, sizeMax, suggest);
1204 todo_wine
1205 ok(rc == MMSYSERR_NODRIVER, "failed with error 0x%x\n", rc);
1206
1207 /* Test converting between two known but incompatible formats */
1208 src.wFormatTag = WAVE_FORMAT_ALAW;
1209 src.nChannels = 1;
1210 src.nSamplesPerSec = 8000;
1211 src.nAvgBytesPerSec = 8000;
1212 src.nBlockAlign = 1;
1213 src.wBitsPerSample = 8;
1214 src.cbSize = 0;
1216 dst.wFormatTag = WAVE_FORMAT_IMA_ADPCM;
1217 rc = acmFormatSuggest(NULL, &src, &dst, sizeof(IMAADPCMWAVEFORMAT)-1, suggest);
1218 ok(rc == MMSYSERR_INVALPARAM, "failed with error 0x%x\n", rc);
1219
1221 todo_wine
1222 ok(rc == MMSYSERR_NODRIVER, "failed with error 0x%x\n", rc);
1223
1224 /* Invalid suggest flags */
1225 src.wFormatTag = WAVE_FORMAT_PCM;
1226 suggest = 0xFFFFFFFF;
1227 rc = acmFormatSuggest(NULL, &src, &dst, sizeof(dst), suggest);
1228 ok(rc == MMSYSERR_INVALFLAG, "failed with error 0x%x\n", rc);
1229
1230 /* Invalid source and destination */
1231 suggest = 0;
1232 rc = acmFormatSuggest(NULL, NULL, &dst, sizeof(dst), suggest);
1233 ok(rc == MMSYSERR_INVALPARAM, "failed with error 0x%x\n", rc);
1234 rc = acmFormatSuggest(NULL, &src, NULL, sizeof(dst), suggest);
1235 ok(rc == MMSYSERR_INVALPARAM, "failed with error 0x%x\n", rc);
1236 rc = acmFormatSuggest(NULL, NULL, NULL, sizeof(dst), suggest);
1237 ok(rc == MMSYSERR_INVALPARAM, "failed with error 0x%x\n", rc);
1238}
#define WAVE_FORMAT_ALAW
Definition: constants.h:427
GLenum src
Definition: glext.h:6340
#define WAVE_FORMAT_IMA_ADPCM
Definition: mmreg.h:103
int suggest
Definition: msacm.c:1370
#define ACM_FORMATSUGGESTF_NCHANNELS
Definition: msacm.h:175
#define ACM_FORMATSUGGESTF_WBITSPERSAMPLE
Definition: msacm.h:177
#define ACM_FORMATSUGGESTF_NSAMPLESPERSEC
Definition: msacm.h:176

Referenced by START_TEST().

◆ test_acmFormatTagDetails()

static void test_acmFormatTagDetails ( void  )
static

Definition at line 1240 of file msacm.c.

1241{
1242 ACMFORMATTAGDETAILSW aftd = {0};
1243 MMRESULT rc;
1244
1245 aftd.cbStruct = sizeof(aftd);
1248 if (rc == MMSYSERR_NOERROR)
1249 ok(aftd.cbFormatSize == sizeof(MPEGLAYER3WAVEFORMAT), "got %d\n", aftd.cbFormatSize);
1250}
MMRESULT WINAPI acmFormatTagDetailsW(HACMDRIVER had, PACMFORMATTAGDETAILSW paftd, DWORD fdwDetails)
Definition: format.c:852
#define WAVE_FORMAT_MPEGLAYER3
Definition: mmreg.h:127
#define ACM_FORMATTAGDETAILSF_FORMATTAG
Definition: msacm.h:183

Referenced by START_TEST().

◆ test_convert()

static void test_convert ( void  )
static

Definition at line 1101 of file msacm.c.

1102{
1103 HACMSTREAM has;
1104 ACMSTREAMHEADER hdr = {0};
1105 BYTE output[256];
1106 MMRESULT mmr;
1107 unsigned i;
1108
1109 for (i = 0; i < ARRAY_SIZE(expected_output); i++)
1110 {
1112 ok(mmr == MMSYSERR_NOERROR, "#%d: open failed: 0x%x\n", i, mmr);
1113
1114 memset(&hdr, 0, sizeof(hdr));
1115 hdr.cbStruct = sizeof(hdr);
1116 hdr.pbSrc = (BYTE *)input;
1117 hdr.cbSrcLength = sizeof(input);
1118 hdr.pbDst = output;
1119 hdr.cbDstLength = sizeof(output);
1120
1121 mmr = acmStreamPrepareHeader(has, &hdr, 0);
1122 ok(mmr == MMSYSERR_NOERROR, "#%d: prepare failed: 0x%x\n", i, mmr);
1123 ok(hdr.fdwStatus == ACMSTREAMHEADER_STATUSF_PREPARED, "#%d: header wasn't prepared: 0x%x\n", i, hdr.fdwStatus);
1124
1125 memset(&output, 0, sizeof(output));
1127 ok(mmr == MMSYSERR_NOERROR, "#%d: convert failed: 0x%x\n", i, mmr);
1128 ok(hdr.fdwStatus & ACMSTREAMHEADER_STATUSF_DONE, "#%d: conversion was not done: 0x%x\n", i, hdr.fdwStatus);
1129 ok(hdr.cbSrcLengthUsed == hdr.cbSrcLength, "#%d: expected %d, got %d\n", i, hdr.cbSrcLength, hdr.cbSrcLengthUsed);
1130 ok(hdr.cbDstLengthUsed == expected_output[i].dst_used, "#%d: expected %d, got %d\n", i, expected_output[i].dst_used, hdr.cbDstLengthUsed);
1132 ok(!memcmp(expected_output[i].output, output, hdr.cbDstLengthUsed), "#%d: output does not match\n", i);
1133
1134 mmr = acmStreamUnprepareHeader(has, &hdr, 0);
1135 ok(mmr == MMSYSERR_NOERROR, "#%d: unprepare failed: 0x%x\n", i, mmr);
1136 ok(hdr.fdwStatus == ACMSTREAMHEADER_STATUSF_DONE, "#%d: header wasn't unprepared: 0x%x\n", i, hdr.fdwStatus);
1137
1138 mmr = acmStreamClose(has, 0);
1139 ok(mmr == MMSYSERR_NOERROR, "#%d: close failed: 0x%x\n", i, mmr);
1140 }
1141}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define ARRAY_SIZE(A)
Definition: main.h:33
MMRESULT WINAPI acmStreamClose(HACMSTREAM has, DWORD fdwClose)
Definition: stream.c:65
MMRESULT WINAPI acmStreamPrepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwPrepare)
Definition: stream.c:299
MMRESULT WINAPI acmStreamConvert(HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwConvert)
Definition: stream.c:89
MMRESULT WINAPI acmStreamUnprepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwUnprepare)
Definition: stream.c:449
MMRESULT WINAPI acmStreamOpen(PHACMSTREAM phas, HACMDRIVER had, PWAVEFORMATEX pwfxSrc, PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen)
Definition: stream.c:149
GLenum GLenum GLenum input
Definition: glext.h:9031
char hdr[14]
Definition: iptest.cpp:33
BOOL todo
Definition: filedlg.c:313
static const BYTE input[64]
Definition: msacm.c:1045
static const struct stream_output expected_output[]
Definition: msacm.c:1056
#define ACM_STREAMCONVERTF_BLOCKALIGN
Definition: msacm.h:205
#define ACMSTREAMHEADER_STATUSF_PREPARED
Definition: msacm.h:210
#define ACMSTREAMHEADER_STATUSF_DONE
Definition: msacm.h:209
unsigned char BYTE
Definition: xxhash.c:193

Referenced by START_TEST().

◆ test_mp3()

static void test_mp3 ( void  )
static

Definition at line 1279 of file msacm.c.

1280{
1283 HACMSTREAM has;
1284 DWORD output;
1285 MMRESULT mr;
1286
1287 src.wfx.wFormatTag = WAVE_FORMAT_MPEGLAYER3;
1288 src.wfx.nSamplesPerSec = 11025;
1289 src.wfx.wBitsPerSample = 0;
1290 src.wfx.nChannels = 1;
1291 src.wfx.nBlockAlign = 576;
1292 src.wfx.nAvgBytesPerSec = 2000;
1293
1294 src.wID = MPEGLAYER3_ID_MPEG;
1295 src.fdwFlags = 0;
1296 src.nBlockSize = 576;
1297 src.nFramesPerBlock = 1;
1298 src.nCodecDelay = 0;
1299
1300 dst.cbSize = 0;
1301 dst.wFormatTag = WAVE_FORMAT_PCM;
1302 dst.nSamplesPerSec = 11025;
1303 dst.wBitsPerSample = 16;
1304 dst.nChannels = 1;
1305 dst.nBlockAlign = dst.wBitsPerSample * dst.nChannels / 8;
1306 dst.nAvgBytesPerSec = dst.nSamplesPerSec * dst.nBlockAlign;
1307
1308 src.wfx.cbSize = 0;
1309
1310 mr = acmStreamOpen(&has, NULL, (WAVEFORMATEX*)&src, &dst, NULL, 0, 0, 0);
1311 ok(mr == ACMERR_NOTPOSSIBLE, "expected error ACMERR_NOTPOSSIBLE, got 0x%x\n", mr);
1312 if (mr == MMSYSERR_NOERROR) acmStreamClose(has, 0);
1313
1314 src.wfx.cbSize = MPEGLAYER3_WFX_EXTRA_BYTES;
1315 src.wID = 0;
1316
1317 mr = acmStreamOpen(&has, NULL, (WAVEFORMATEX*)&src, &dst, NULL, 0, 0, 0);
1318 ok(mr == ACMERR_NOTPOSSIBLE, "expected error ACMERR_NOTPOSSIBLE, got 0x%x\n", mr);
1319 if (mr == MMSYSERR_NOERROR) acmStreamClose(has, 0);
1320
1321 src.wID = MPEGLAYER3_ID_MPEG;
1322 src.nBlockSize = 0;
1323
1324 mr = acmStreamOpen(&has, NULL, (WAVEFORMATEX*)&src, &dst, NULL, 0, 0, 0);
1325 ok(mr == MMSYSERR_NOERROR || broken(mr == ACMERR_NOTPOSSIBLE) /* Win 2008 */,
1326 "failed with error 0x%x\n", mr);
1327 if (mr == MMSYSERR_NOERROR)
1328 {
1329 mr = acmStreamClose(has, 0);
1330 ok(mr == MMSYSERR_NOERROR, "failed with error 0x%x\n", mr);
1331 }
1332 src.nBlockSize = 576;
1333 src.wfx.nAvgBytesPerSec = 0;
1334
1335 mr = acmStreamOpen(&has, NULL, (WAVEFORMATEX*)&src, &dst, NULL, 0, 0, 0);
1336 ok(mr == MMSYSERR_NOERROR || broken(mr == ACMERR_NOTPOSSIBLE) /* Win 2008 */,
1337 "failed with error 0x%x\n", mr);
1338 if (mr == MMSYSERR_NOERROR)
1339 {
1340 /* causes a division by zero exception in XP, Vista,
1341 but throws ACMERR_NOTPOSSIBLE on others */
1342 if (0) acmStreamSize(has, 4000, &output, ACM_STREAMSIZEF_SOURCE);
1343 mr = acmStreamClose(has, 0);
1344 ok(mr == MMSYSERR_NOERROR, "failed with error 0x%x\n", mr);
1345 }
1346
1347 src.wfx.nAvgBytesPerSec = 2000;
1348
1349 mr = acmStreamOpen(&has, NULL, (WAVEFORMATEX*)&src, &dst, NULL, 0, 0, 0);
1350 ok(mr == MMSYSERR_NOERROR || broken(mr == ACMERR_NOTPOSSIBLE) /* Win 2008 */,
1351 "failed with error 0x%x\n", mr);
1352 if (mr == MMSYSERR_NOERROR)
1353 {
1354 mr = acmStreamSize(has, 4000, &output, ACM_STREAMSIZEF_SOURCE);
1355 ok(mr == MMSYSERR_NOERROR, "failed with error 0x%x\n", mr);
1356 mr = acmStreamClose(has, 0);
1357 ok(mr == MMSYSERR_NOERROR, "failed with error 0x%x\n", mr);
1358 }
1359}
MMRESULT WINAPI acmStreamSize(HACMSTREAM has, DWORD cbInput, LPDWORD pdwOutputBytes, DWORD fdwSize)
Definition: stream.c:394
#define MPEGLAYER3_ID_MPEG
Definition: mmreg.h:442
#define MPEGLAYER3_WFX_EXTRA_BYTES
Definition: mmreg.h:439
#define ACM_STREAMSIZEF_SOURCE
Definition: msacm.h:217

Referenced by START_TEST().

◆ test_prepareheader()

static void test_prepareheader ( void  )
static

Definition at line 842 of file msacm.c.

843{
844 HACMSTREAM has;
847 MMRESULT mr;
849 BYTE buf[sizeof(WAVEFORMATEX) + 32], pcm[2048], input[512];
850 ADPCMCOEFSET *coef;
851
853 coef = src->aCoef;
854 src->wfx.cbSize = 32;
855 src->wfx.wFormatTag = WAVE_FORMAT_ADPCM;
856 src->wfx.nSamplesPerSec = 22050;
857 src->wfx.wBitsPerSample = 4;
858 src->wfx.nChannels = 1;
859 src->wfx.nBlockAlign = 512;
860 src->wfx.nAvgBytesPerSec = 11025;
861 src->wSamplesPerBlock = 0x3f4;
862 src->wNumCoef = 7;
863 coef[0].iCoef1 = 0x0100;
864 coef[0].iCoef2 = 0x0000;
865 coef[1].iCoef1 = 0x0200;
866 coef[1].iCoef2 = 0xff00;
867 coef[2].iCoef1 = 0x0000;
868 coef[2].iCoef2 = 0x0000;
869 coef[3].iCoef1 = 0x00c0;
870 coef[3].iCoef2 = 0x0040;
871 coef[4].iCoef1 = 0x00f0;
872 coef[4].iCoef2 = 0x0000;
873 coef[5].iCoef1 = 0x01cc;
874 coef[5].iCoef2 = 0xff30;
875 coef[6].iCoef1 = 0x0188;
876 coef[6].iCoef2 = 0xff18;
877
878 dst.cbSize = 0;
879 dst.wFormatTag = WAVE_FORMAT_PCM;
880 dst.nSamplesPerSec = 22050;
881 dst.wBitsPerSample = 8;
882 dst.nChannels = 1;
883 dst.nBlockAlign = dst.wBitsPerSample * dst.nChannels / 8;
884 dst.nAvgBytesPerSec = dst.nSamplesPerSec * dst.nBlockAlign;
885
886 mr = acmStreamOpen(&has, NULL, (WAVEFORMATEX*)src, &dst, NULL, 0, 0, 0);
887 ok(mr == MMSYSERR_NOERROR, "open failed: 0x%x\n", mr);
888
889 memset(input, 0, sizeof(input));
890 memset(&hdr, 0, sizeof(hdr));
891 hdr.cbStruct = sizeof(hdr);
892 hdr.pbSrc = input;
893 hdr.cbSrcLength = sizeof(input);
894 hdr.pbDst = pcm;
895 hdr.cbDstLength = sizeof(pcm);
896
897 mr = acmStreamPrepareHeader(has, &hdr, 0);
898 ok(mr == MMSYSERR_NOERROR, "prepare failed: 0x%x\n", mr);
899 ok(hdr.fdwStatus == ACMSTREAMHEADER_STATUSF_PREPARED, "header wasn't prepared: 0x%x\n", hdr.fdwStatus);
900
901 mr = acmStreamUnprepareHeader(has, &hdr, 0);
902 ok(mr == MMSYSERR_NOERROR, "unprepare failed: 0x%x\n", mr);
903 ok(hdr.fdwStatus == 0, "header wasn't unprepared: 0x%x\n", hdr.fdwStatus);
904
905 memset(&hdr, 0, sizeof(hdr));
906 hdr.cbStruct = sizeof(hdr);
907 hdr.pbSrc = input;
908 hdr.cbSrcLength = 0; /* invalid source length */
909 hdr.pbDst = pcm;
910 hdr.cbDstLength = sizeof(pcm);
911
912 mr = acmStreamPrepareHeader(has, &hdr, 0);
913 ok(mr == MMSYSERR_INVALPARAM, "expected 0x0b, got 0x%x\n", mr);
914
915 hdr.cbSrcLength = src->wfx.nBlockAlign - 1; /* less than block align */
916 mr = acmStreamPrepareHeader(has, &hdr, 0);
917 ok(mr == ACMERR_NOTPOSSIBLE, "expected 0x200, got 0x%x\n", mr);
918
919 hdr.cbSrcLength = src->wfx.nBlockAlign + 1; /* more than block align */
920 mr = acmStreamPrepareHeader(has, &hdr, 0);
921 ok(mr == MMSYSERR_NOERROR, "prepare failed: 0x%x\n", mr);
922
923 mr = acmStreamUnprepareHeader(has, &hdr, 0);
924 ok(mr == MMSYSERR_NOERROR, "unprepare failed: 0x%x\n", mr);
925
926 hdr.cbSrcLength = src->wfx.nBlockAlign;
927 mr = acmStreamPrepareHeader(has, &hdr, 1); /* invalid use of reserved parameter */
928 ok(mr == MMSYSERR_INVALFLAG, "expected 0x0a, got 0x%x\n", mr);
929
930 mr = acmStreamPrepareHeader(has, &hdr, 0);
931 ok(mr == MMSYSERR_NOERROR, "prepare failed: 0x%x\n", mr);
932
933 mr = acmStreamUnprepareHeader(has, &hdr, 0);
934 ok(mr == MMSYSERR_NOERROR, "unprepare failed: 0x%x\n", mr);
935
936 memset(&hdr, 0, sizeof(hdr));
937 hdr.cbStruct = sizeof(hdr);
938 hdr.pbSrc = input;
939 hdr.cbSrcLength = sizeof(input);
940 hdr.pbDst = pcm;
941 hdr.cbDstLength = sizeof(pcm);
943
944 mr = acmStreamPrepareHeader(has, &hdr, 0);
945 ok(mr == MMSYSERR_NOERROR, "prepare failed: 0x%x\n", mr);
946 ok(hdr.fdwStatus == (ACMSTREAMHEADER_STATUSF_PREPARED | ACMSTREAMHEADER_STATUSF_DONE), "header wasn't prepared: 0x%x\n", hdr.fdwStatus);
947
948 hdr.cbSrcLengthUsed = 12345;
949 hdr.cbDstLengthUsed = 12345;
950 hdr.fdwStatus &= ~ACMSTREAMHEADER_STATUSF_DONE;
952 ok(mr == MMSYSERR_NOERROR, "convert failed: 0x%x\n", mr);
953 ok(hdr.fdwStatus & ACMSTREAMHEADER_STATUSF_DONE, "conversion was not done: 0x%x\n", hdr.fdwStatus);
954 ok(hdr.cbSrcLengthUsed == hdr.cbSrcLength, "expected %d, got %d\n", hdr.cbSrcLength, hdr.cbSrcLengthUsed);
956 ok(hdr.cbDstLengthUsed == 1010, "expected 1010, got %d\n", hdr.cbDstLengthUsed);
957
958 mr = acmStreamUnprepareHeader(has, &hdr, 0);
959 ok(mr == MMSYSERR_NOERROR, "unprepare failed: 0x%x\n", mr);
960 ok(hdr.fdwStatus == ACMSTREAMHEADER_STATUSF_DONE, "header wasn't unprepared: 0x%x\n", hdr.fdwStatus);
961
962 /* The 2 next tests are related to Lost Horizon (bug 24723) */
963 memset(&hdr, 0, sizeof(hdr));
964 hdr.cbStruct = sizeof(hdr);
965 hdr.pbSrc = input;
966 hdr.cbSrcLength = sizeof(input);
967 hdr.pbDst = pcm;
968 hdr.cbDstLength = -4;
969
970 mr = acmStreamPrepareHeader(has, &hdr, 0);
971 if (sizeof(void *) == 4) /* 64 bit fails on this test */
972 {
973 ok(mr == MMSYSERR_NOERROR, "prepare failed: 0x%x\n", mr);
974 ok(hdr.fdwStatus == ACMSTREAMHEADER_STATUSF_PREPARED, "header wasn't prepared: 0x%x\n", hdr.fdwStatus);
975
976 hdr.cbSrcLengthUsed = 12345;
977 hdr.cbDstLengthUsed = 12345;
978 hdr.fdwStatus &= ~ACMSTREAMHEADER_STATUSF_DONE;
980 ok(mr == MMSYSERR_NOERROR, "convert failed: 0x%x\n", mr);
981 ok(hdr.fdwStatus & ACMSTREAMHEADER_STATUSF_DONE, "conversion was not done: 0x%x\n", hdr.fdwStatus);
982 ok(hdr.cbSrcLengthUsed == hdr.cbSrcLength, "expected %d, got %d\n", hdr.cbSrcLength, hdr.cbSrcLengthUsed);
984 ok(hdr.cbDstLengthUsed == 1010, "expected 1010, got %d\n", hdr.cbDstLengthUsed);
985
986 mr = acmStreamUnprepareHeader(has, &hdr, 0);
987 ok(mr == MMSYSERR_NOERROR, "unprepare failed: 0x%x\n", mr);
988 ok(hdr.fdwStatus == ACMSTREAMHEADER_STATUSF_DONE, "header wasn't unprepared: 0x%x\n", hdr.fdwStatus);
989 }
990 else
992 ok(mr == MMSYSERR_INVALPARAM, "expected 0x0b, got 0x%x\n", mr);
993
994 memset(&hdr, 0, sizeof(hdr));
995 hdr.cbStruct = sizeof(hdr);
996 hdr.pbSrc = input;
997 hdr.cbSrcLength = 24;
998 hdr.pbDst = pcm;
999 hdr.cbDstLength = -4;
1000 mr = acmStreamPrepareHeader(has, &hdr, 0);
1001 ok(mr == ACMERR_NOTPOSSIBLE, "expected 0x200, got 0x%x\n", mr);
1002 ok(hdr.fdwStatus == 0, "expected 0, got 0x%x\n", hdr.fdwStatus);
1003
1004 hdr.cbSrcLengthUsed = 12345;
1005 hdr.cbDstLengthUsed = 12345;
1007 ok(mr == ACMERR_UNPREPARED, "expected 0x202, got 0x%x\n", mr);
1008 ok(hdr.cbSrcLengthUsed == 12345, "expected 12345, got %d\n", hdr.cbSrcLengthUsed);
1009 ok(hdr.cbDstLengthUsed == 12345, "expected 12345, got %d\n", hdr.cbDstLengthUsed);
1010
1011 mr = acmStreamUnprepareHeader(has, &hdr, 0);
1012 ok(mr == ACMERR_UNPREPARED, "expected 0x202, got 0x%x\n", mr);
1013
1014 /* Less output space than required */
1015 memset(&hdr, 0, sizeof(hdr));
1016 hdr.cbStruct = sizeof(hdr);
1017 hdr.pbSrc = input;
1018 hdr.cbSrcLength = sizeof(input);
1019 hdr.pbDst = pcm;
1020 hdr.cbDstLength = 32;
1021
1022 mr = acmStreamPrepareHeader(has, &hdr, 0);
1023 ok(mr == MMSYSERR_NOERROR, "prepare failed: 0x%x\n", mr);
1024 ok(hdr.fdwStatus == ACMSTREAMHEADER_STATUSF_PREPARED, "header wasn't prepared: 0x%x\n", hdr.fdwStatus);
1025
1026 hdr.cbSrcLengthUsed = 12345;
1027 hdr.cbDstLengthUsed = 12345;
1028 hdr.fdwStatus &= ~ACMSTREAMHEADER_STATUSF_DONE;
1030 ok(mr == MMSYSERR_NOERROR, "convert failed: 0x%x\n", mr);
1031 ok(hdr.fdwStatus & ACMSTREAMHEADER_STATUSF_DONE, "conversion was not done: 0x%x\n", hdr.fdwStatus);
1033 ok(hdr.cbSrcLengthUsed == hdr.cbSrcLength, "expected %d, got %d\n", hdr.cbSrcLength, hdr.cbSrcLengthUsed);
1035 ok(hdr.cbDstLengthUsed == hdr.cbDstLength, "expected %d, got %d\n", hdr.cbDstLength, hdr.cbDstLengthUsed);
1036
1037 mr = acmStreamUnprepareHeader(has, &hdr, 0);
1038 ok(mr == MMSYSERR_NOERROR, "unprepare failed: 0x%x\n", mr);
1039 ok(hdr.fdwStatus == ACMSTREAMHEADER_STATUSF_DONE, "header wasn't unprepared: 0x%x\n", hdr.fdwStatus);
1040
1041 mr = acmStreamClose(has, 0);
1042 ok(mr == MMSYSERR_NOERROR, "close failed: 0x%x\n", mr);
1043}
#define WAVE_FORMAT_ADPCM
Definition: constants.h:426
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define ACMERR_UNPREPARED
Definition: msacm.h:38

Referenced by START_TEST().

Variable Documentation

◆ about

int about

Definition at line 1366 of file msacm.c.

◆ close

int close

Definition at line 1365 of file msacm.c.

◆ convert

◆ details

◆ disable

int disable

Definition at line 1365 of file msacm.c.

Referenced by request_set_option(), and test_WinHttpSendRequest().

◆ 

struct { ... } driver

Referenced by acpi_bus_attach(), acpi_bus_driver_init(), acpi_bus_find_driver(), acpi_bus_match(), acpi_bus_notify(), acpi_bus_register_driver(), acpi_bus_unattach(), acpi_bus_unregister_driver(), AtlCreateTargetDC(), cf2_decoder_parse_charstrings(), cff_builder_add_point(), cff_driver_init(), cff_get_interface(), cff_slot_load(), cff_subfont_load(), cid_driver_done(), cid_driver_init(), compute_glyph_metrics(), Destroy_Driver(), destroy_face(), destroy_size(), DriverEvtCleanup(), FT_Add_Module(), FT_Attach_Stream(), FT_Done_Face(), FT_Done_GlyphSlot(), FT_Done_Size(), FT_Get_Kerning(), ft_glyphslot_done(), ft_glyphslot_init(), FT_Load_Glyph(), FT_New_GlyphSlot(), FT_New_Size(), ft_open_face_internal(), gdf_driver_proc(), get_driver_version_info(), ICInfo(), ICInstall(), ICOpen(), ICRemove(), if(), init_driver(), init_driver_info(), ITERATE_InstallODBCDataSource(), ITERATE_InstallODBCDriver(), ITERATE_RemoveODBCDataSource(), load_config_driver(), load_driver(), open_face(), pcf_driver_init(), pcf_load_font(), pcf_property_get(), pcf_property_set(), printercache_process(), ps_builder_add_point(), ps_property_get(), ps_property_set(), SQLConfigDriver(), SQLConfigDriverW(), SQLInstallDriverEx(), SQLRemoveDriver(), T1_Driver_Done(), T1_Driver_Init(), T1_Parse_Glyph_And_Get_Char_String(), T42_Driver_Init(), test_create_device_from_clipper1(), test_create_device_from_clipper2(), test_create_device_from_clipper3(), test_create_device_from_surface1(), test_create_device_from_surface2(), test_create_device_from_surface3(), test_Device(), test_device_qi(), test_DeviceCapabilities(), test_driver_install(), test_PrintDlgA(), test_Viewport(), test_viewport_clear1(), test_viewport_clear2(), test_viewport_qi(), tt_driver_init(), tt_get_interface(), tt_get_metrics(), TT_Hint_Glyph(), tt_loader_init(), tt_loader_set_pp(), TT_Process_Composite_Component(), TT_Process_Simple_Glyph(), tt_property_get(), tt_property_set(), VerifyWdfDeviceWdmDispatchIrp(), write_config_value(), and write_registry_values().

◆ 

struct { ... } driver_calls

◆ enable

Definition at line 1365 of file msacm.c.

◆ expected_output

const struct stream_output expected_output[]
static

Definition at line 1056 of file msacm.c.

Referenced by test_convert(), and test_shader_semantics().

◆ 

struct { ... } format

◆ free

int free

Definition at line 1365 of file msacm.c.

◆ input

const BYTE input[64] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63}
static

Definition at line 1045 of file msacm.c.

Referenced by test_convert(), and test_prepareheader().

◆ install

int install

Definition at line 1365 of file msacm.c.

Referenced by calc_sizes(), FGetComponentPath(), and InstallEngineTiming_GetRates().

◆ load

◆ notify

◆ open

int open

Definition at line 1365 of file msacm.c.

◆ other

int other

Definition at line 1376 of file msacm.c.

Referenced by __rb_erase_color(), LocaleTest::_time_put_get(), XMLStorage::XMLNode::Children::assign(), BookmarkNode::BookmarkNode(), ATL::CComBSTR::CComBSTR(), ATL::CComVariant::CComVariant(), XMLStorage::XMLNode::Children::Children(), convert_old_args(), XMLStorage::XMLNode::Children::copy(), ATL::CComBSTR::CopyTo(), Entry::Entry(), MainProc(), monoTriangulationOpt(), monoTriangulationRecGenOpt(), XMLStorage::XMLNode::Children::move(), nsURI_Equals(), nsURI_EqualsExceptRef(), XMLStorage::XMLChildrenFilter::iterator::operator!=(), XMLStorage::const_XMLChildrenFilter::const_iterator::operator!=(), XMLStorage::XMLPropertyReader::const_iterator::operator!=(), StackAllocator< _Tp >::operator!=(), Data::operator<(), XMLStorage::XMLNode::Children::operator=(), BookmarkNode::operator=(), ATL::CComBSTR::operator=(), CCreature::operator=(), XMLStorage::XMLNode::operator=(), Data::operator==(), MyIntComparable::operator==(), XMLStorage::XMLChildrenFilter::iterator::operator==(), XMLStorage::const_XMLChildrenFilter::const_iterator::operator==(), XMLStorage::XMLPropertyReader::const_iterator::operator==(), StackAllocator< _Tp >::operator==(), RECTL_Intersect(), sampleMonoPoly(), tinyxml2::XMLElement::ShallowEqual(), StackAllocator< _Tp >::swap(), test_dialog_parent(), test_GetCharsetInfo_other(), TLB_get_size_from_hreftype(), tinyxml2::StrPair::TransferTo(), TRIO_ARGS1(), TRIO_ARGS2(), TRIO_ARGS3(), Uri_IsEqual(), wined3d_clip_blit(), XMLStorage::XMLNode::XMLNode(), xmlParseNameAndCompare(), xsltMergeAttrSets(), xsltResolveAttrSet(), and xsltResolveUseAttrSets().

◆ prepare

int prepare

Definition at line 1374 of file msacm.c.

◆ querycfg

int querycfg

Definition at line 1366 of file msacm.c.

◆ remove

◆ reset

Definition at line 1374 of file msacm.c.

◆ size

Definition at line 1374 of file msacm.c.

◆ 

struct { ... } stream

◆ suggest

int suggest

Definition at line 1370 of file msacm.c.

Referenced by test_acmFormatSuggest().

◆ tag_details

int tag_details

Definition at line 1370 of file msacm.c.

◆ unprepare

int unprepare

Definition at line 1374 of file msacm.c.