Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-04 09:46:18 +00:00
Code Issues Projects Releases Packages Wiki Activity

Preliminary implementation of mmdrv.dll. This is fixed to using MidiOut0 (provided by the mpu401 driver) and is *very* basic. It's only possible to open the MIDI device and play a note, with this.

Browse source 
Eventually, a list of devices will need to be obtained from the registry.

svn path=/trunk/; revision=7927
This commit is contained in:
Andrew Greenwood 2004-01-30 18:32:58 +00:00
parent 0b9faf4625
commit 26584f6d6a
9 changed files with 1520 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

9
reactos/lib/mmdrv/.cvsignore Normal file
View file

@ -0,0 +1,9 @@
temp.exp
*.a
*.dll
*.lib
*.sym
*.coff
*.map
*.tmp
*.o

33
reactos/lib/mmdrv/Makefile Normal file
View file

@ -0,0 +1,33 @@
PATH_TO_TOP = ../..
TARGET_TYPE = dynlink
TARGET_NORC = yes
TARGET_NAME = mmdrv
# -fno-builtin
TARGET_CFLAGS = -D__USE_W32API
# require os code to explicitly request A/W version of structs/functions
TARGET_CFLAGS += -DUNICODE -D_UNICODE -Wall -Werror
TARGET_LFLAGS =
TARGET_SDKLIBS = winmm.a
TARGET_OBJECTS = \
entry.o \
midi.o \
utils.o \
wave.o
DEP_OBJECTS = $(TARGET_OBJECTS)
include $(PATH_TO_TOP)/rules.mak
include $(TOOLS_PATH)/helper.mk
include $(TOOLS_PATH)/depend.mk
# EOF

195
reactos/lib/mmdrv/entry.c Normal file
View file

@ -0,0 +1,195 @@
/*
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: lib/mmdrv/entry.c
* PURPOSE: Multimedia User Mode Driver
* PROGRAMMER: Andrew Greenwood
* UPDATE HISTORY:
* Jan 30, 2004: Imported into ReactOS tree
*/
#include "mmdrv.h"
#define EXPORT __declspec(dllexport)
CRITICAL_SECTION DriverSection;
APIENTRY LONG DriverProc(DWORD DriverID, HANDLE DriverHandle, UINT Message,
LONG Param1, LONG Param2)
{
printf("DriverProc\n");
// HINSTANCE Module;
switch(Message)
{
case DRV_LOAD :
printf("DRV_LOAD\n");
return TRUE; // dont need to do any more
/*
Module = GetDriverModuleHandle(DriverHandle);
// Create our process heap
Heap = GetProcessHeap();
if (Heap == NULL)
return FALSE;
DisableThreadLibraryCalls(Module);
InitializeCriticalSection(&CS);
//
// Load our device list
//
// if (sndFindDevices() != MMSYSERR_NOERROR) {
// DeleteCriticalSection(&mmDrvCritSec);
// return FALSE;
// }
return TRUE;
*/
// return 1L;
case DRV_FREE :
printf("DRV_FREE\n");
// TerminateMidi();
// TerminateWave();
// DeleteCriticalSection(&CS);
return 1L;
case DRV_OPEN :
printf("DRV_OPEN\n");
return 1L;
case DRV_CLOSE :
printf("DRV_CLOSE\n");
return 1L;
case DRV_ENABLE :
printf("DRV_ENABLE\n");
return 1L;
case DRV_DISABLE :
printf("DRV_DISABLE\n");
return 1L;
case DRV_QUERYCONFIGURE :
printf("DRV_QUERYCONFIGURE\n");
return 0L;
case DRV_CONFIGURE :
printf("DRV_CONFIGURE\n");
return 0L;
case DRV_INSTALL :
printf("DRV_INSTALL\n");
return DRVCNF_RESTART;
default :
printf("?\n");
return DefDriverProc(DriverID, DriverHandle, Message, Param1, Param2);
};
}
BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD Reason, LPVOID Reserved)
{
printf("DllMain called!\n");
if (Reason == DLL_PROCESS_ATTACH)
{
DisableThreadLibraryCalls(hInstance);
// Create our heap
Heap = HeapCreate(0, 800, 0);
if (Heap == NULL)
return FALSE;
InitializeCriticalSection(&CS);
// OK to do this now??
FindDevices();
}
else if (Reason == DLL_PROCESS_DETACH)
{
// We need to do cleanup here...
// TerminateMidi();
// TerminateWave();
DeleteCriticalSection(&CS);
HeapDestroy(Heap);
}
return TRUE;
}
/*
EXPORT DWORD midMessage(DWORD id, DWORD msg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
{
printf("midMessage\n");
switch (msg) {
case MIDM_GETNUMDEVS:
printf("MIDM_GETNUMDEVS");
return GetNumDevs(MidiInDevice);
case MIDM_GETDEVCAPS:
printf("MIDM_GETDEVCAPS");
return MMSYSERR_NOERROR;
case MIDM_OPEN:
printf("MIDM_OPEN");
return MMSYSERR_NOERROR;
case MIDM_CLOSE:
printf("MIDM_CLOSE");
return MMSYSERR_NOERROR;
case MIDM_ADDBUFFER:
printf("MIDM_ADDBUFFER");
return MMSYSERR_NOERROR;
case MIDM_STOP:
printf("MIDM_PAUSE");
return MMSYSERR_NOERROR;
case MIDM_START:
printf("MIDM_RESTART");
return MMSYSERR_NOERROR;
case MIDM_RESET:
printf("MIDM_RESET");
return MMSYSERR_NOERROR;
default:
return MMSYSERR_NOTSUPPORTED;
}
//
// Should not get here
//
return MMSYSERR_NOTSUPPORTED;
}
*/
APIENTRY DWORD auxMessage(UINT uDevice,
UINT uMsg,
DWORD dwUser,
DWORD dwParam1,
DWORD dwParam2)
{
printf("auxMessage\n");
return MMSYSERR_NOERROR;
}

239
reactos/lib/mmdrv/midi.c Normal file
View file

@ -0,0 +1,239 @@
/*
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: lib/mmdrv/midi.c
* PURPOSE: Multimedia User Mode Driver
* PROGRAMMER: Andrew Greenwood
* UPDATE HISTORY:
* Jan 30, 2004: Imported into ReactOS tree
*/
#include "mmdrv.h"
// MIDI device instance information
//
typedef struct tag_MIDIALLOC {
struct tag_MIDIALLOC *Next; // Chain of devices
UINT DeviceNumber; // Number of device
UINT DeviceType; // MidiInput or MidiOutput
DWORD dwCallback; // client's callback
DWORD dwInstance; // client's instance data
HMIDI hMidi; // handle for stream
HANDLE DeviceHandle; // Midi device handle
LPMIDIHDR lpMIQueue; // Buffers sent to device
// This is only required so that
// CLOSE knows when things have
// really finished.
// notify. This is only accessed
// on the device thread and its
// apcs so does not need any
// synchronized access.
HANDLE Event; // Event for driver syncrhonization
// and notification of auxiliary
// task operation completion.
// MIDITHREADFUNCTION AuxFunction; // Function for thread to perform
union {
LPMIDIHDR pHdr; // Buffer to pass in aux task
ULONG State; // State to set
struct {
ULONG Function; // IOCTL to use
PBYTE pData; // Data to set or get
ULONG DataLen; // Length of data
} GetSetData;
} AuxParam;
// 0 means terminate task.
HANDLE ThreadHandle; // Handle for termination ONLY
HANDLE AuxEvent1; // Aux thread waits on this
HANDLE AuxEvent2; // Aux thread caller waits on this
DWORD AuxReturnCode; // Return code from Aux task
DWORD dwFlags; // Open flags
// PLOCALMIDIDATA Mid; // Extra midi input structures
int l; // Helper global for modMidiLength
} MIDIALLOC, *PMIDIALLOC;
PMIDIALLOC MidiHandleList; // Our chain of wave handles
static DWORD OpenMidiDevice(UINT DeviceType, DWORD ID, DWORD User, DWORD Param1, DWORD Param2)
{
PMIDIALLOC pClient = NULL;
MMRESULT Result = MMSYSERR_NOERROR;
// Check ID?
printf("OpenMidiDevice()\n");
switch(DeviceType)
{
case MidiOutDevice :
pClient = (PMIDIALLOC) HeapAlloc(Heap, 0, sizeof(MIDIALLOC));
if ( pClient ) memset(pClient, 0, sizeof(MIDIALLOC));
break;
case MidiInDevice :
// TODO
break;
};
if ( !pClient )
return MMSYSERR_NOMEM;
pClient->DeviceType = DeviceType;
pClient->dwCallback = ((LPMIDIOPENDESC)Param1)->dwCallback;
pClient->dwInstance = ((LPMIDIOPENDESC)Param1)->dwInstance;
pClient->hMidi = ((LPMIDIOPENDESC)Param1)->hMidi;
pClient->dwFlags = Param2;
Result = OpenDevice(DeviceType, ID, &pClient->DeviceHandle, (GENERIC_READ | GENERIC_WRITE));
if ( Result != MMSYSERR_NOERROR )
{
// cleanup
return Result;
}
pClient->Event = CreateEvent(NULL, FALSE, FALSE, NULL);
if ( !pClient->Event )
{
// cleanup
return MMSYSERR_NOMEM;
}
PMIDIALLOC *pUserHandle;
pUserHandle = (PMIDIALLOC*) User;
*pUserHandle = pClient;
// callback
return MMSYSERR_NOERROR;
}
static DWORD WriteMidi(PBYTE pData, ULONG Length, PMIDIALLOC pClient)
{
DWORD BytesReturned;
if ( !DeviceIoControl(pClient->DeviceHandle, IOCTL_MIDI_PLAY, (PVOID)pData,
Length, NULL, 0, &BytesReturned, NULL))
return TranslateStatus();
return MMSYSERR_NOERROR;
}
static int GetMidiLength(PMIDIALLOC pClient, BYTE b)
{
if (b >= 0xF8)
{
// Realtime message - leave running status
return 1; // Write one byte
}
switch (b)
{
case 0xF0: case 0xF4: case 0xF5: case 0xF6: case 0xF7:
pClient->l = 1;
return pClient->l;
case 0xF1: case 0xF3:
pClient->l = 2;
return pClient->l;
case 0xF2:
pClient->l = 3;
return pClient->l;
}
switch (b & 0xF0)
{
case 0x80: case 0x90: case 0xA0: case 0xB0: case 0xE0:
pClient->l = 3;
return pClient->l;
case 0xC0: case 0xD0:
pClient->l = 2;
return pClient->l;
}
return (pClient->l - 1); // uses previous value if data byte (running status)
}
/* ----------------------------------------------------------------------------
Exported functions
----------------------------------------------------------------------------- */
APIENTRY DWORD midMessage(DWORD ID, DWORD Message, DWORD User, DWORD Param1, DWORD Param2)
{
printf("midMessage\n");
return MMSYSERR_NOERROR;
}
APIENTRY DWORD modMessage(DWORD ID, DWORD Message, DWORD User, DWORD Param1, DWORD Param2)
{
printf("modMessage\n");
switch(Message)
{
case MODM_GETNUMDEVS:
printf("MODM_GETNUMDEVS == %d\n", (int)GetDeviceCount(MidiOutDevice));
return GetDeviceCount(MidiOutDevice);
case MODM_GETDEVCAPS:
printf("MODM_GETDEVCAPS");
return MMSYSERR_NOTSUPPORTED;
case MODM_OPEN :
return OpenMidiDevice(MidiOutDevice, ID, User, Param1, Param2);
case MODM_CLOSE:
printf("MODM_CLOSE");
return MMSYSERR_NOTSUPPORTED;
case MODM_DATA:
printf("MODM_DATA");
int i;
BYTE b[4];
for (i = 0; i < 4; i ++) {
b[i] = (BYTE)(Param1 % 256);
Param1 /= 256;
}
return WriteMidi(b, GetMidiLength((PMIDIALLOC)User, b[0]),
(PMIDIALLOC)User);
case MODM_LONGDATA:
printf("MODM_LONGDATA");
return MMSYSERR_NOTSUPPORTED;
case MODM_RESET:
printf("MODM_RESET");
return MMSYSERR_NOTSUPPORTED;
case MODM_SETVOLUME:
printf("MODM_SETVOLUME");
return MMSYSERR_NOTSUPPORTED;
case MODM_GETVOLUME:
printf("MODM_GETVOLUME");
return MMSYSERR_NOTSUPPORTED;
case MODM_CACHEPATCHES:
printf("MODM_CACHEPATCHES");
return MMSYSERR_NOTSUPPORTED;
case MODM_CACHEDRUMPATCHES:
printf("MODM_CACHEDRUMPATCHES");
return MMSYSERR_NOTSUPPORTED;
};
return MMSYSERR_NOTSUPPORTED;
}

460
reactos/lib/mmdrv/mmddk.h Normal file
View file

@ -0,0 +1,460 @@
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
/*****************************************************************************
* Copyright 1998, Luiz Otavio L. Zorzella
* 1999, Eric Pouech
*
* Purpose: multimedia declarations (external to WINMM & MMSYSTEM DLLs
* for other DLLs (MCI, drivers...))
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*****************************************************************************
*/
#ifndef __MMDDK_H
#define __MMDDK_H
#include <mmsystem.h>
#include <winbase.h>
#define MAX_MIDIINDRV (16)
/* For now I'm making 16 the maximum number of midi devices one can
* have. This should be more than enough for everybody. But as a purist,
* I intend to make it unbounded in the future, as soon as I figure
* a good way to do so.
*/
#define MAX_MIDIOUTDRV (16)
/* ==================================
* Multimedia DDK compatible part
* ================================== */
#include <pshpack1.h>
#define DRVM_INIT 100
#define DRVM_EXIT 101
#define DRVM_DISABLE 102
#define DRVM_ENABLE 103
/* messages that have IOCTL format
* dw1 = NULL or handle
* dw2 = NULL or ptr to DRVM_IOCTL_DATA
* return is MMRESULT
*/
#define DRVM_IOCTL 0x100
#define DRVM_ADD_THRU (DRVM_IOCTL+1)
#define DRVM_REMOVE_THRU (DRVM_IOCTL+2)
#define DRVM_IOCTL_LAST (DRVM_IOCTL+5)
typedef struct {
DWORD dwSize; /* size of this structure */
DWORD dwCmd; /* IOCTL command code, 0x80000000 and above reserved for system */
} DRVM_IOCTL_DATA, *LPDRVM_IOCTL_DATA;
/* command code ranges for dwCmd field of DRVM_IOCTL message
* - codes from 0 to 0x7FFFFFFF are user defined
* - codes from 0x80000000 to 0xFFFFFFFF are reserved for future definition by microsoft
*/
#define DRVM_IOCTL_CMD_USER 0x00000000L
#define DRVM_IOCTL_CMD_SYSTEM 0x80000000L
#define DRVM_MAPPER 0x2000
#define DRVM_USER 0x4000
#define DRVM_MAPPER_STATUS (DRVM_MAPPER+0)
#define DRVM_MAPPER_RECONFIGURE (DRVM_MAPPER+1)
#define DRVM_MAPPER_PREFERRED_GET (DRVM_MAPPER+21)
#define DRVM_MAPPER_CONSOLEVOICECOM_GET (DRVM_MAPPER+23)
#define DRV_QUERYDRVENTRY (DRV_RESERVED + 1)
#define DRV_QUERYDEVNODE (DRV_RESERVED + 2)
#define DRV_QUERYNAME (DRV_RESERVED + 3)
#define DRV_QUERYDRIVERIDS (DRV_RESERVED + 4)
#define DRV_QUERYMAPPABLE (DRV_RESERVED + 5)
#define DRV_QUERYMODULE (DRV_RESERVED + 9)
#define DRV_PNPINSTALL (DRV_RESERVED + 11)
#define DRV_QUERYDEVICEINTERFACE (DRV_RESERVED + 12)
#define DRV_QUERYDEVICEINTERFACESIZE (DRV_RESERVED + 13)
#define DRV_QUERYSTRINGID (DRV_RESERVED + 14)
#define DRV_QUERYSTRINGIDSIZE (DRV_RESERVED + 15)
#define DRV_QUERYIDFROMSTRINGID (DRV_RESERVED + 16)
#ifdef __WINESRC__
#define DRV_QUERYDSOUNDIFACE (DRV_RESERVED + 20)
#define DRV_QUERYDSOUNDDESC (DRV_RESERVED + 21)
#define DRV_QUERYDSOUNDGUID (DRV_RESERVED + 22)
#endif
#define WODM_INIT DRVM_INIT
#define WODM_GETNUMDEVS 3
#define WODM_GETDEVCAPS 4
#define WODM_OPEN 5
#define WODM_CLOSE 6
#define WODM_PREPARE 7
#define WODM_UNPREPARE 8
#define WODM_WRITE 9
#define WODM_PAUSE 10
#define WODM_RESTART 11
#define WODM_RESET 12
#define WODM_GETPOS 13
#define WODM_GETPITCH 14
#define WODM_SETPITCH 15
#define WODM_GETVOLUME 16
#define WODM_SETVOLUME 17
#define WODM_GETPLAYBACKRATE 18
#define WODM_SETPLAYBACKRATE 19
#define WODM_BREAKLOOP 20
#define WODM_PREFERRED 21
#define WODM_MAPPER_STATUS (DRVM_MAPPER_STATUS + 0)
#define WAVEOUT_MAPPER_STATUS_DEVICE 0
#define WAVEOUT_MAPPER_STATUS_MAPPED 1
#define WAVEOUT_MAPPER_STATUS_FORMAT 2
#define WODM_BUSY 21
#define WIDM_INIT DRVM_INIT
#define WIDM_GETNUMDEVS 50
#define WIDM_GETDEVCAPS 51
#define WIDM_OPEN 52
#define WIDM_CLOSE 53
#define WIDM_PREPARE 54
#define WIDM_UNPREPARE 55
#define WIDM_ADDBUFFER 56
#define WIDM_START 57
#define WIDM_STOP 58
#define WIDM_RESET 59
#define WIDM_GETPOS 60
#define WIDM_PREFERRED 61
#define WIDM_MAPPER_STATUS (DRVM_MAPPER_STATUS + 0)
#define WAVEIN_MAPPER_STATUS_DEVICE 0
#define WAVEIN_MAPPER_STATUS_MAPPED 1
#define WAVEIN_MAPPER_STATUS_FORMAT 2
#define MODM_INIT DRVM_INIT
#define MODM_GETNUMDEVS 1
#define MODM_GETDEVCAPS 2
#define MODM_OPEN 3
#define MODM_CLOSE 4
#define MODM_PREPARE 5
#define MODM_UNPREPARE 6
#define MODM_DATA 7
#define MODM_LONGDATA 8
#define MODM_RESET 9
#define MODM_GETVOLUME 10
#define MODM_SETVOLUME 11
#define MODM_CACHEPATCHES 12
#define MODM_CACHEDRUMPATCHES 13
#define MIDM_INIT DRVM_INIT
#define MIDM_GETNUMDEVS 53
#define MIDM_GETDEVCAPS 54
#define MIDM_OPEN 55
#define MIDM_CLOSE 56
#define MIDM_PREPARE 57
#define MIDM_UNPREPARE 58
#define MIDM_ADDBUFFER 59
#define MIDM_START 60
#define MIDM_STOP 61
#define MIDM_RESET 62
#define AUXM_INIT DRVM_INIT
#define AUXDM_GETNUMDEVS 3
#define AUXDM_GETDEVCAPS 4
#define AUXDM_GETVOLUME 5
#define AUXDM_SETVOLUME 6
#define MXDM_INIT DRVM_INIT
#define MXDM_USER DRVM_USER
#define MXDM_MAPPER DRVM_MAPPER
#define MXDM_GETNUMDEVS 1
#define MXDM_GETDEVCAPS 2
#define MXDM_OPEN 3
#define MXDM_CLOSE 4
#define MXDM_GETLINEINFO 5
#define MXDM_GETLINECONTROLS 6
#define MXDM_GETCONTROLDETAILS 7
#define MXDM_SETCONTROLDETAILS 8
/* pre-defined joystick types */
#define JOY_HW_NONE 0
#define JOY_HW_CUSTOM 1
#define JOY_HW_2A_2B_GENERIC 2
#define JOY_HW_2A_4B_GENERIC 3
#define JOY_HW_2B_GAMEPAD 4
#define JOY_HW_2B_FLIGHTYOKE 5
#define JOY_HW_2B_FLIGHTYOKETHROTTLE 6
#define JOY_HW_3A_2B_GENERIC 7
#define JOY_HW_3A_4B_GENERIC 8
#define JOY_HW_4B_GAMEPAD 9
#define JOY_HW_4B_FLIGHTYOKE 10
#define JOY_HW_4B_FLIGHTYOKETHROTTLE 11
#define JOY_HW_LASTENTRY 12
/* calibration flags */
#define JOY_ISCAL_XY 0x00000001l /* XY are calibrated */
#define JOY_ISCAL_Z 0x00000002l /* Z is calibrated */
#define JOY_ISCAL_R 0x00000004l /* R is calibrated */
#define JOY_ISCAL_U 0x00000008l /* U is calibrated */
#define JOY_ISCAL_V 0x00000010l /* V is calibrated */
#define JOY_ISCAL_POV 0x00000020l /* POV is calibrated */
/* point of view constants */
#define JOY_POV_NUMDIRS 4
#define JOY_POVVAL_FORWARD 0
#define JOY_POVVAL_BACKWARD 1
#define JOY_POVVAL_LEFT 2
#define JOY_POVVAL_RIGHT 3
/* Specific settings for joystick hardware */
#define JOY_HWS_HASZ 0x00000001l /* has Z info? */
#define JOY_HWS_HASPOV 0x00000002l /* point of view hat present */
#define JOY_HWS_POVISBUTTONCOMBOS 0x00000004l /* pov done through combo of buttons */
#define JOY_HWS_POVISPOLL 0x00000008l /* pov done through polling */
#define JOY_HWS_ISYOKE 0x00000010l /* joystick is a flight yoke */
#define JOY_HWS_ISGAMEPAD 0x00000020l /* joystick is a game pad */
#define JOY_HWS_ISCARCTRL 0x00000040l /* joystick is a car controller */
/* X defaults to J1 X axis */
#define JOY_HWS_XISJ1Y 0x00000080l /* X is on J1 Y axis */
#define JOY_HWS_XISJ2X 0x00000100l /* X is on J2 X axis */
#define JOY_HWS_XISJ2Y 0x00000200l /* X is on J2 Y axis */
/* Y defaults to J1 Y axis */
#define JOY_HWS_YISJ1X 0x00000400l /* Y is on J1 X axis */
#define JOY_HWS_YISJ2X 0x00000800l /* Y is on J2 X axis */
#define JOY_HWS_YISJ2Y 0x00001000l /* Y is on J2 Y axis */
/* Z defaults to J2 Y axis */
#define JOY_HWS_ZISJ1X 0x00002000l /* Z is on J1 X axis */
#define JOY_HWS_ZISJ1Y 0x00004000l /* Z is on J1 Y axis */
#define JOY_HWS_ZISJ2X 0x00008000l /* Z is on J2 X axis */
/* POV defaults to J2 Y axis, if it is not button based */
#define JOY_HWS_POVISJ1X 0x00010000l /* pov done through J1 X axis */
#define JOY_HWS_POVISJ1Y 0x00020000l /* pov done through J1 Y axis */
#define JOY_HWS_POVISJ2X 0x00040000l /* pov done through J2 X axis */
/* R defaults to J2 X axis */
#define JOY_HWS_HASR 0x00080000l /* has R (4th axis) info */
#define JOY_HWS_RISJ1X 0x00100000l /* R done through J1 X axis */
#define JOY_HWS_RISJ1Y 0x00200000l /* R done through J1 Y axis */
#define JOY_HWS_RISJ2Y 0x00400000l /* R done through J2 X axis */
/* U & V for future hardware */
#define JOY_HWS_HASU 0x00800000l /* has U (5th axis) info */
#define JOY_HWS_HASV 0x01000000l /* has V (6th axis) info */
/* Usage settings */
#define JOY_US_HASRUDDER 0x00000001l /* joystick configured with rudder */
#define JOY_US_PRESENT 0x00000002l /* is joystick actually present? */
#define JOY_US_ISOEM 0x00000004l /* joystick is an OEM defined type */
/* struct for storing x,y, z, and rudder values */
typedef struct joypos_tag {
DWORD dwX;
DWORD dwY;
DWORD dwZ;
DWORD dwR;
DWORD dwU;
DWORD dwV;
} JOYPOS, *LPJOYPOS;
/* struct for storing ranges */
typedef struct joyrange_tag {
JOYPOS jpMin;
JOYPOS jpMax;
JOYPOS jpCenter;
} JOYRANGE,*LPJOYRANGE;
typedef struct joyreguservalues_tag {
DWORD dwTimeOut; /* value at which to timeout joystick polling */
JOYRANGE jrvRanges; /* range of values app wants returned for axes */
JOYPOS jpDeadZone; /* area around center to be considered
as "dead". specified as a percentage
(0-100). Only X & Y handled by system driver */
} JOYREGUSERVALUES, *LPJOYREGUSERVALUES;
typedef struct joyreghwsettings_tag {
DWORD dwFlags;
DWORD dwNumButtons; /* number of buttons */
} JOYREGHWSETTINGS, *LPJOYHWSETTINGS;
/* range of values returned by the hardware (filled in by calibration) */
typedef struct joyreghwvalues_tag {
JOYRANGE jrvHardware; /* values returned by hardware */
DWORD dwPOVValues[JOY_POV_NUMDIRS];/* POV values returned by hardware */
DWORD dwCalFlags; /* what has been calibrated */
} JOYREGHWVALUES, *LPJOYREGHWVALUES;
/* hardware configuration */
typedef struct joyreghwconfig_tag {
JOYREGHWSETTINGS hws; /* hardware settings */
DWORD dwUsageSettings;/* usage settings */
JOYREGHWVALUES hwv; /* values returned by hardware */
DWORD dwType; /* type of joystick */
DWORD dwReserved; /* reserved for OEM drivers */
} JOYREGHWCONFIG, *LPJOYREGHWCONFIG;
/* joystick calibration info structure */
typedef struct joycalibrate_tag {
UINT wXbase;
UINT wXdelta;
UINT wYbase;
UINT wYdelta;
UINT wZbase;
UINT wZdelta;
} JOYCALIBRATE;
typedef JOYCALIBRATE *LPJOYCALIBRATE;
/* prototype for joystick message function */
typedef UINT (CALLBACK * JOYDEVMSGPROC)(DWORD dwID, UINT uMessage, LPARAM lParam1, LPARAM lParam2);
typedef JOYDEVMSGPROC *LPJOYDEVMSGPROC;
/* messages sent to joystick driver's DriverProc() function */
#define JDD_GETNUMDEVS (DRV_RESERVED + 0x0001)
#define JDD_GETDEVCAPS (DRV_RESERVED + 0x0002)
#define JDD_GETPOS (DRV_RESERVED + 0x0101)
#define JDD_SETCALIBRATION (DRV_RESERVED + 0x0102)
#define JDD_CONFIGCHANGED (DRV_RESERVED + 0x0103)
#define JDD_GETPOSEX (DRV_RESERVED + 0x0104)
#define MCI_MAX_DEVICE_TYPE_LENGTH 80
#define MCI_FALSE (MCI_STRING_OFFSET + 19)
#define MCI_TRUE (MCI_STRING_OFFSET + 20)
#define MCI_FORMAT_RETURN_BASE MCI_FORMAT_MILLISECONDS_S
#define MCI_FORMAT_MILLISECONDS_S (MCI_STRING_OFFSET + 21)
#define MCI_FORMAT_HMS_S (MCI_STRING_OFFSET + 22)
#define MCI_FORMAT_MSF_S (MCI_STRING_OFFSET + 23)
#define MCI_FORMAT_FRAMES_S (MCI_STRING_OFFSET + 24)
#define MCI_FORMAT_SMPTE_24_S (MCI_STRING_OFFSET + 25)
#define MCI_FORMAT_SMPTE_25_S (MCI_STRING_OFFSET + 26)
#define MCI_FORMAT_SMPTE_30_S (MCI_STRING_OFFSET + 27)
#define MCI_FORMAT_SMPTE_30DROP_S (MCI_STRING_OFFSET + 28)
#define MCI_FORMAT_BYTES_S (MCI_STRING_OFFSET + 29)
#define MCI_FORMAT_SAMPLES_S (MCI_STRING_OFFSET + 30)
#define MCI_FORMAT_TMSF_S (MCI_STRING_OFFSET + 31)
#define MCI_VD_FORMAT_TRACK_S (MCI_VD_OFFSET + 5)
#define WAVE_FORMAT_PCM_S (MCI_WAVE_OFFSET + 0)
#define WAVE_MAPPER_S (MCI_WAVE_OFFSET + 1)
#define MCI_SEQ_MAPPER_S (MCI_SEQ_OFFSET + 5)
#define MCI_SEQ_FILE_S (MCI_SEQ_OFFSET + 6)
#define MCI_SEQ_MIDI_S (MCI_SEQ_OFFSET + 7)
#define MCI_SEQ_SMPTE_S (MCI_SEQ_OFFSET + 8)
#define MCI_SEQ_FORMAT_SONGPTR_S (MCI_SEQ_OFFSET + 9)
#define MCI_SEQ_NONE_S (MCI_SEQ_OFFSET + 10)
#define MIDIMAPPER_S (MCI_SEQ_OFFSET + 11)
#define MCI_RESOURCE_RETURNED 0x00010000 /* resource ID */
#define MCI_COLONIZED3_RETURN 0x00020000 /* colonized ID, 3 bytes data */
#define MCI_COLONIZED4_RETURN 0x00040000 /* colonized ID, 4 bytes data */
#define MCI_INTEGER_RETURNED 0x00080000 /* integer conversion needed */
#define MCI_RESOURCE_DRIVER 0x00100000 /* driver owns returned resource */
#define MCI_NO_COMMAND_TABLE 0xFFFF
#define MCI_COMMAND_HEAD 0
#define MCI_STRING 1
#define MCI_INTEGER 2
#define MCI_END_COMMAND 3
#define MCI_RETURN 4
#define MCI_FLAG 5
#define MCI_END_COMMAND_LIST 6
#define MCI_RECT 7
#define MCI_CONSTANT 8
#define MCI_END_CONSTANT 9
#define MAKEMCIRESOURCE(wRet, wRes) MAKELRESULT((wRet), (wRes))
typedef struct {
DWORD dwCallback;
DWORD dwInstance;
HMIDIOUT hMidi;
DWORD dwFlags;
} PORTALLOC, *LPPORTALLOC;
typedef struct {
HWAVE hWave;
LPWAVEFORMATEX lpFormat;
DWORD dwCallback;
DWORD dwInstance;
UINT uMappedDeviceID;
DWORD dnDevNode;
} WAVEOPENDESC, *LPWAVEOPENDESC;
typedef struct {
DWORD dwStreamID;
WORD wDeviceID;
} MIDIOPENSTRMID;
typedef struct {
HMIDI hMidi;
DWORD dwCallback;
DWORD dwInstance;
DWORD dnDevNode;
DWORD cIds;
MIDIOPENSTRMID rgIds;
} MIDIOPENDESC, *LPMIDIOPENDESC;
typedef struct tMIXEROPENDESC
{
HMIXEROBJ hmx;
LPVOID pReserved0;
DWORD dwCallback;
DWORD dwInstance;
} MIXEROPENDESC, *LPMIXEROPENDESC;
typedef struct {
UINT wDeviceID; /* device ID */
LPSTR lpstrParams; /* parameter string for entry in SYSTEM.INI */
UINT wCustomCommandTable; /* custom command table (0xFFFF if none) * filled in by the driver */
UINT wType; /* driver type (filled in by the driver) */
} MCI_OPEN_DRIVER_PARMSA, *LPMCI_OPEN_DRIVER_PARMSA;
typedef struct {
UINT wDeviceID; /* device ID */
LPWSTR lpstrParams; /* parameter string for entry in SYSTEM.INI */
UINT wCustomCommandTable; /* custom command table (0xFFFF if none) * filled in by the driver */
UINT wType; /* driver type (filled in by the driver) */
} MCI_OPEN_DRIVER_PARMSW, *LPMCI_OPEN_DRIVER_PARMSW;
//DECL_WINELIB_TYPE_AW(MCI_OPEN_DRIVER_PARMS)
//DECL_WINELIB_TYPE_AW(LPMCI_OPEN_DRIVER_PARMS)
DWORD WINAPI mciGetDriverData(UINT uDeviceID);
BOOL WINAPI mciSetDriverData(UINT uDeviceID, DWORD dwData);
UINT WINAPI mciDriverYield(UINT uDeviceID);
BOOL WINAPI mciDriverNotify(HWND hwndCallback, UINT uDeviceID,
UINT uStatus);
UINT WINAPI mciLoadCommandResource(HINSTANCE hInstance,
LPCWSTR lpResName, UINT uType);
BOOL WINAPI mciFreeCommandResource(UINT uTable);
#define DCB_NULL 0x0000
#define DCB_WINDOW 0x0001 /* dwCallback is a HWND */
#define DCB_TASK 0x0002 /* dwCallback is a HTASK */
#define DCB_FUNCTION 0x0003 /* dwCallback is a FARPROC */
#define DCB_EVENT 0x0005 /* dwCallback is an EVENT Handler */
#define DCB_TYPEMASK 0x0007
#define DCB_NOSWITCH 0x0008 /* don't switch stacks for callback */
BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev,
UINT wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2);
#ifdef __WINESRC__
#define WAVE_DIRECTSOUND 0x0080
#endif
#include <poppack.h>
#endif /* __MMDDK_H */

16
reactos/lib/mmdrv/mmdrv.edf Normal file
View file

@ -0,0 +1,16 @@
; $Id: mmdrv.edf,v 1.1 2004/01/30 18:32:58 silverblade Exp $
;
; advapi32.edf
;
; ReactOS Operating System
;
; Some stack sizes are taken from Ander Norlander's .DEFs.
;
LIBRARY mmdrv.dll
EXPORTS
DriverProc=DriverProc@20
widMessage=widMessage@20
wodMessage=wodMessage@20
midMessage=midMessage@20
modMessage=modMessage@20
auxMessage=auxMessage@20

114
reactos/lib/mmdrv/mmdrv.h Normal file
View file

@ -0,0 +1,114 @@
/*
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: lib/mmdrv/mmdrv.h
* PURPOSE: Multimedia User Mode Driver (header)
* PROGRAMMER: Andrew Greenwood
* UPDATE HISTORY:
* Jan 30, 2004: Imported into ReactOS tree
*/
#ifndef __INCLUDES_MMDRV_H__
#define __INCLUDES_MMDRV_H__
//#define UNICODE
#define EXPORT __declspec(dllexport)
#include <stdio.h>
#include <windows.h>
#include <mmsystem.h>
#include <mmddk.h>
// This needs to be done to get winioctl.h to work:
typedef unsigned __int64 DWORD64, *PDWORD64;
#include <winioctl.h>
//#include "mmddk.h"
#define SOUND_MAX_DEVICE_NAME 1024 // GUESSWORK
#define SOUND_MAX_DEVICES 256 // GUESSWORK
// If the root is \Device and the Device type is
// WaveIn and the device number is 2, the full name is \Device\WaveIn2
#define WAVE_IN_DEVICE_NAME "\\Device\\WaveIn"
#define WAVE_IN_DEVICE_NAME_U L"\\Device\\WaveIn"
#define WAVE_OUT_DEVICE_NAME "\\Device\\WaveOut"
#define WAVE_OUT_DEVICE_NAME_U L"\\Device\\WaveOut"
#define MIDI_IN_DEVICE_NAME "\\Device\\MidiIn"
#define MIDI_IN_DEVICE_NAME_U L"\\Device\\MidiIn"
#define MIDI_OUT_DEVICE_NAME "\\Device\\MidiOut"
#define MIDI_OUT_DEVICE_NAME_U L"\\Device\\MidiOut"
#define AUX_DEVICE_NAME "\\Device\\MMAux"
#define AUX_DEVICE_NAME_U L"\\Device\\MMAux"
#define IOCTL_SOUND_BASE FILE_DEVICE_SOUND
#define IOCTL_WAVE_BASE 0x0000
#define IOCTL_MIDI_BASE 0x0080
// Wave device driver IOCTLs
#define IOCTL_WAVE_QUERY_FORMAT CTL_CODE(IOCTL_SOUND_BASE, IOCTL_WAVE_BASE + 0x0001, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_WAVE_SET_FORMAT CTL_CODE(IOCTL_SOUND_BASE, IOCTL_WAVE_BASE + 0x0002, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_WAVE_GET_CAPABILITIES CTL_CODE(IOCTL_SOUND_BASE, IOCTL_WAVE_BASE + 0x0003, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_WAVE_SET_STATE CTL_CODE(IOCTL_SOUND_BASE, IOCTL_WAVE_BASE + 0x0004, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_WAVE_GET_STATE CTL_CODE(IOCTL_SOUND_BASE, IOCTL_WAVE_BASE + 0x0005, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_WAVE_GET_POSITION CTL_CODE(IOCTL_SOUND_BASE, IOCTL_WAVE_BASE + 0x0006, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_WAVE_SET_VOLUME CTL_CODE(IOCTL_SOUND_BASE, IOCTL_WAVE_BASE + 0x0007, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_WAVE_GET_VOLUME CTL_CODE(IOCTL_SOUND_BASE, IOCTL_WAVE_BASE + 0x0008, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_WAVE_SET_PITCH CTL_CODE(IOCTL_SOUND_BASE, IOCTL_WAVE_BASE + 0x0009, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_WAVE_GET_PITCH CTL_CODE(IOCTL_SOUND_BASE, IOCTL_WAVE_BASE + 0x000A, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_WAVE_SET_PLAYBACK_RATE CTL_CODE(IOCTL_SOUND_BASE, IOCTL_WAVE_BASE + 0x000B, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_WAVE_GET_PLAYBACK_RATE CTL_CODE(IOCTL_SOUND_BASE, IOCTL_WAVE_BASE + 0x000C, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_WAVE_PLAY CTL_CODE(IOCTL_SOUND_BASE, IOCTL_WAVE_BASE + 0x000D, METHOD_IN_DIRECT, FILE_WRITE_ACCESS)
#define IOCTL_WAVE_RECORD CTL_CODE(IOCTL_SOUND_BASE, IOCTL_WAVE_BASE + 0x000E, METHOD_OUT_DIRECT, FILE_WRITE_ACCESS)
#define IOCTL_WAVE_BREAK_LOOP CTL_CODE(IOCTL_SOUND_BASE, IOCTL_WAVE_BASE + 0x000F, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_WAVE_SET_LOW_PRIORITY CTL_CODE(IOCTL_SOUND_BASE, IOCTL_WAVE_BASE + 0x0010, METHOD_BUFFERED, FILE_WRITE_ACCESS)
// MIDI device driver IOCTLs
#define IOCTL_MIDI_GET_CAPABILITIES CTL_CODE(IOCTL_SOUND_BASE, IOCTL_MIDI_BASE + 0x0001, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_MIDI_SET_STATE CTL_CODE(IOCTL_SOUND_BASE, IOCTL_MIDI_BASE + 0x0002, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_MIDI_GET_STATE CTL_CODE(IOCTL_SOUND_BASE, IOCTL_MIDI_BASE + 0x0003, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_MIDI_SET_VOLUME CTL_CODE(IOCTL_SOUND_BASE, IOCTL_MIDI_BASE + 0x0004, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_MIDI_GET_VOLUME CTL_CODE(IOCTL_SOUND_BASE, IOCTL_MIDI_BASE + 0x0005, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_MIDI_PLAY CTL_CODE(IOCTL_SOUND_BASE, IOCTL_MIDI_BASE + 0x0006, METHOD_NEITHER, FILE_WRITE_ACCESS)
#define IOCTL_MIDI_RECORD CTL_CODE(IOCTL_SOUND_BASE, IOCTL_MIDI_BASE + 0x0007, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_MIDI_CACHE_PATCHES CTL_CODE(IOCTL_SOUND_BASE, IOCTL_MIDI_BASE + 0x0008, METHOD_BUFFERED, FILE_WRITE_ACCESS)
#define IOCTL_MIDI_CACHE_DRUM_PATCHES CTL_CODE(IOCTL_SOUND_BASE, IOCTL_MIDI_BASE + 0x0009, METHOD_BUFFERED, FILE_WRITE_ACCESS)
CRITICAL_SECTION CS; // Serialize access to device lists
HANDLE Heap;
enum {
InvalidDevice,
WaveInDevice,
WaveOutDevice,
MidiInDevice,
MidiOutDevice,
AuxDevice
};
MMRESULT OpenDevice(UINT DeviceType, DWORD ID, PHANDLE pDeviceHandle,
DWORD Access);
MMRESULT FindDevices();
DWORD GetDeviceCount(UINT DeviceType);
DWORD TranslateStatus(void);
#endif

171
reactos/lib/mmdrv/utils.c Normal file
View file

@ -0,0 +1,171 @@
/*
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: lib/mmdrv/utils.c
* PURPOSE: Multimedia User Mode Driver (utility functions)
* PROGRAMMER: Andrew Greenwood
* UPDATE HISTORY:
* Jan 30, 2004: Imported into ReactOS tree
*/
#include "mmdrv.h"
typedef struct _DEVICE_LIST
{
struct _DEVICE_LIST *Next;
DWORD DeviceType;
ULONG CardIndex;
PVOID DeviceInstanceData;
ULONG DeviceInstanceDataSize;
WCHAR Name[1];
} DEVICE_LIST, *PDEVICE_LIST;
PDEVICE_LIST DeviceList;
DWORD TranslateStatus(void)
{
switch(GetLastError())
{
case NO_ERROR :
case ERROR_IO_PENDING :
return MMSYSERR_NOERROR;
case ERROR_BUSY :
return MMSYSERR_ALLOCATED;
case ERROR_NOT_SUPPORTED :
case ERROR_INVALID_FUNCTION :
return MMSYSERR_NOTSUPPORTED;
case ERROR_NOT_ENOUGH_MEMORY :
return MMSYSERR_NOMEM;
case ERROR_ACCESS_DENIED :
return MMSYSERR_BADDEVICEID;
case ERROR_INSUFFICIENT_BUFFER :
return MMSYSERR_INVALPARAM;
default :
return MMSYSERR_ERROR;
};
}
MMRESULT OpenDevice(UINT DeviceType, DWORD ID, PHANDLE pDeviceHandle,
DWORD Access)
{
printf("OpenDevice()\n");
WCHAR Name[SOUND_MAX_DEVICE_NAME];
*pDeviceHandle = INVALID_HANDLE_VALUE;
if (ID > SOUND_MAX_DEVICES)
return MMSYSERR_BADDEVICEID;
wsprintf(Name, L"\\\\.%ls%d",
(DeviceType == WaveOutDevice ? WAVE_OUT_DEVICE_NAME_U :
DeviceType == WaveInDevice ? WAVE_IN_DEVICE_NAME_U :
DeviceType == MidiOutDevice ? MIDI_OUT_DEVICE_NAME_U :
DeviceType == MidiInDevice ? MIDI_IN_DEVICE_NAME_U :
AUX_DEVICE_NAME_U) + strlen("\\Device"), ID);
printf("Attempting to open %S\n", Name);
*pDeviceHandle = CreateFile(Name, Access, FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, Access != GENERIC_READ ? FILE_FLAG_OVERLAPPED : 0,
NULL);
printf("DeviceHandle == 0x%x\n", (int)*pDeviceHandle);
return *pDeviceHandle != INVALID_HANDLE_VALUE ? MMSYSERR_NOERROR : TranslateStatus();
}
// DEVICE LIST MANAGEMENT
BOOL AddDeviceToList(PDEVICE_LIST* pList, DWORD DeviceType, DWORD CardIndex,
LPWSTR Name)
{
PDEVICE_LIST pNewDevice;
printf("AddDeviceToList()\n");
pNewDevice = (PDEVICE_LIST) HeapAlloc(Heap, 0,
sizeof(DEVICE_LIST) + lstrlen(Name) * sizeof(WCHAR));
if ( !pNewDevice )
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
}
pNewDevice->DeviceType = DeviceType;
pNewDevice->CardIndex = CardIndex;
lstrcpy(pNewDevice->Name, Name);
pNewDevice->DeviceInstanceData = NULL;
pNewDevice->Next = *pList;
*pList = pNewDevice;
printf("Success!\n");
return TRUE;
}
VOID FreeDeviceList()
{
PDEVICE_LIST pDevice;
printf("FreeDeviceList()\n");
while (DeviceList)
{
pDevice = DeviceList;
DeviceList = pDevice->Next;
if (pDevice->DeviceInstanceData)
HeapFree(Heap, 0, (LPVOID)pDevice->DeviceInstanceData);
HeapFree(Heap, 0, (LPSTR)pDevice);
}
}
MMRESULT FindDevices()
{
// DWORD Index;
// HKEY DriverKey;
printf("Finding devices\n");
// DriverKey = OpenParametersKey();
// see drvutil.c of MS DDK for how this SHOULD be done...
// FIXME: This is hard-coded for now, to use the hardware emulated by Bochs...
// MIDI Out 0: MPU-401 UART
AddDeviceToList(&DeviceList, MidiOutDevice, 0, L"MidiOut0");
// Wave Out 0: Sound Blaster 16 (ok?)
AddDeviceToList(&DeviceList, WaveOutDevice, 0, L"WaveOut0");
return MMSYSERR_NOERROR; // ok?
}
DWORD GetDeviceCount(UINT DeviceType)
{
int i;
PDEVICE_LIST List;
for (List = DeviceList, i = 0; List != NULL; List = List->Next)
if (List->DeviceType == DeviceType)
i ++;
return i;
}

283
reactos/lib/mmdrv/wave.c Normal file
View file

@ -0,0 +1,283 @@
/*
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: lib/mmdrv/wave.c
* PURPOSE: Multimedia User Mode Driver
* PROGRAMMER: Andrew Greenwood
* UPDATE HISTORY:
* Jan 30, 2004: Imported into ReactOS tree
*/
#include "mmdrv.h"
static MMRESULT GetDeviceCapabilities(DWORD ID, UINT DeviceType,
LPBYTE pCaps, DWORD Size)
{
// FIXME: Implement :)
// return sndGetData(DeviceType, id, dwSize, lpCaps,
// IOCTL_WAVE_GET_CAPABILITIES);
HANDLE DeviceHandle = NULL;
MMRESULT Result = MMSYSERR_NOERROR;
DWORD BytesReturned = 0;
// Open the wave device
Result = OpenDevice(DeviceType, ID, &DeviceHandle, GENERIC_READ);
if (Result != MMSYSERR_NOERROR)
return Result;
//
// Set our data.
//
// Setting the overlapped parameter (last) to null means we
// wait until the operation completes.
//
Result = DeviceIoControl(DeviceHandle, IOCTL_WAVE_GET_CAPABILITIES,
NULL, 0, (LPVOID)pCaps, Size,
&BytesReturned, NULL) ? MMSYSERR_NOERROR : TranslateStatus();
// Close the handle and return the result code
// CloseHandle(DeviceHandle);
return Result;
}
APIENTRY DWORD wodMessage(DWORD ID, DWORD Message, DWORD User, DWORD Param1, DWORD Param2)
{
// PWAVEALLOC pOutClient;
MMRESULT Result;
switch (Message) {
case WODM_GETNUMDEVS:
printf(("WODM_GETNUMDEVS"));
return GetDeviceCount(WaveOutDevice);
case WODM_GETDEVCAPS:
printf(("WODM_GETDEVCAPS"));
return GetDeviceCapabilities(ID, WaveOutDevice, (LPBYTE)Param1,
(DWORD)Param2);
case WODM_OPEN:
printf(("WODM_OPEN"));
// return waveOpen(WaveOutDevice, id, dwUser, dwParam1, dwParam2);
case WODM_CLOSE:
printf(("WODM_CLOSE"));
// pOutClient = (PWAVEALLOC)dwUser;
//
// Call our task to see if it's ready to complete
//
// Result = waveThreadCall(WaveThreadClose, pOutClient);
if (Result != MMSYSERR_NOERROR) {
return Result;
}
// waveCallback(pOutClient, WOM_CLOSE, 0L);
//
// Close our device
//
// if (pOutClient->hDev != INVALID_HANDLE_VALUE) {
// CloseHandle(pOutClient->hDev);
EnterCriticalSection(&CS);
// pOutClient->hDev = INVALID_HANDLE_VALUE;
LeaveCriticalSection(&CS);
// }
return MMSYSERR_NOERROR;
case WODM_WRITE:
printf(("WODM_WRITE"));
/* WinAssert(dwParam1 != 0);
WinAssert(!(((LPWAVEHDR)dwParam1)->dwFlags &
~(WHDR_INQUEUE|WHDR_DONE|WHDR_PREPARED|
WHDR_BEGINLOOP|WHDR_ENDLOOP)));
((LPWAVEHDR)dwParam1)->dwFlags &=
(WHDR_INQUEUE|WHDR_DONE|WHDR_PREPARED|
WHDR_BEGINLOOP|WHDR_ENDLOOP);
WinAssert(((LPWAVEHDR)dwParam1)->dwFlags & WHDR_PREPARED);
// check if it's been prepared
if (!(((LPWAVEHDR)dwParam1)->dwFlags & WHDR_PREPARED))
return WAVERR_UNPREPARED;
WinAssert(!(((LPWAVEHDR)dwParam1)->dwFlags & WHDR_INQUEUE));
// if it is already in our Q, then we cannot do this
if ( ((LPWAVEHDR)dwParam1)->dwFlags & WHDR_INQUEUE )
return ( WAVERR_STILLPLAYING );
// store the pointer to my WAVEALLOC structure in the wavehdr
pOutClient = (PWAVEALLOC)dwUser;
((LPWAVEHDR)dwParam1)->reserved = (DWORD)(LPSTR)pOutClient;
return waveWrite((LPWAVEHDR)dwParam1, pOutClient);
*/
case WODM_PAUSE:
printf(("WODM_PAUSE"));
/*
pOutClient = (PWAVEALLOC)dwUser;
pOutClient->AuxParam.State = WAVE_DD_STOP;
return waveThreadCall(WaveThreadSetState, pOutClient);
*/
case WODM_RESTART:
printf(("WODM_RESTART"));
/*
pOutClient = (PWAVEALLOC)dwUser;
pOutClient->AuxParam.State = WAVE_DD_PLAY;
return waveThreadCall(WaveThreadSetState, pOutClient);
*/
case WODM_RESET:
printf(("WODM_RESET"));
/*
pOutClient = (PWAVEALLOC)dwUser;
pOutClient->AuxParam.State = WAVE_DD_RESET;
return waveThreadCall(WaveThreadSetState, pOutClient);
*/
case WODM_BREAKLOOP:
/*
pOutClient = (PWAVEALLOC)dwUser;
printf(("WODM_BREAKLOOP"));
return waveThreadCall(WaveThreadBreakLoop, pOutClient);
*/
case WODM_GETPOS:
printf(("WODM_GETPOS"));
/*
pOutClient = (PWAVEALLOC)dwUser;
return waveGetPos(pOutClient, (LPMMTIME)dwParam1, dwParam2);
*/
case WODM_SETPITCH:
printf(("WODM_SETPITCH"));
/*
pOutClient = (PWAVEALLOC)dwUser;
pOutClient->AuxParam.GetSetData.pData = (PBYTE)&dwParam1;
pOutClient->AuxParam.GetSetData.DataLen = sizeof(DWORD);
pOutClient->AuxParam.GetSetData.Function = IOCTL_WAVE_SET_PITCH;
return waveThreadCall(WaveThreadSetData, pOutClient);
*/
case WODM_SETVOLUME:
printf(("WODM_SETVOLUME"));// i didnt do this - AG
//pOutClient = (PWAVEALLOC)dwUser;
//pOutClient->AuxParam.GetSetData.pData = *(PBYTE *)&dwParam1;
//pOutClient->AuxParam.GetSetData.DataLen = sizeof(DWORD);
//pOutClient->AuxParam.GetSetData.Function = IOCTL_WAVE_SET_VOLUME;
//return waveThreadCall(WaveThreadSetData, pOutClient);
{
//
// Translate to device volume structure
//
// WAVE_DD_VOLUME Volume;
// Volume.Left = LOWORD(dwParam1) << 16;
// Volume.Right = HIWORD(dwParam1) << 16;
// return sndSetData(WaveOutDevice, id, sizeof(Volume),
// (PBYTE)&Volume, IOCTL_WAVE_SET_VOLUME);
}
case WODM_SETPLAYBACKRATE:
/*
printf(("WODM_SETPLAYBACKRATE"));
pOutClient = (PWAVEALLOC)dwUser;
pOutClient->AuxParam.GetSetData.pData = (PBYTE)&dwParam1;
pOutClient->AuxParam.GetSetData.DataLen = sizeof(DWORD);
pOutClient->AuxParam.GetSetData.Function =
IOCTL_WAVE_SET_PLAYBACK_RATE;
return waveThreadCall(WaveThreadSetData, pOutClient);
*/
case WODM_GETPITCH:
/*
printf(("WODM_GETPITCH"));
pOutClient = (PWAVEALLOC)dwUser;
pOutClient->AuxParam.GetSetData.pData = (PBYTE)dwParam1;
pOutClient->AuxParam.GetSetData.DataLen = sizeof(DWORD);
pOutClient->AuxParam.GetSetData.Function = IOCTL_WAVE_GET_PITCH;
return waveThreadCall(WaveThreadGetData, pOutClient);
*/
case WODM_GETVOLUME:
printf(("WODM_GETVOLUME"));
//pOutClient = (PWAVEALLOC)dwUser;
//pOutClient->AuxParam.GetSetData.pData = *(PBYTE *)&dwParam1;
//pOutClient->AuxParam.GetSetData.DataLen = sizeof(DWORD);
//pOutClient->AuxParam.GetSetData.Function = IOCTL_WAVE_GET_VOLUME;
//return waveThreadCall(WaveThreadGetData, pOutClient);
{
//
// Translate to device volume structure
//
/*
WAVE_DD_VOLUME Volume;
DWORD rc;
rc = sndGetData(WaveOutDevice, id, sizeof(Volume),
(PBYTE)&Volume, IOCTL_WAVE_GET_VOLUME);
if (rc == MMSYSERR_NOERROR) {
*(LPDWORD)dwParam1 =
(DWORD)MAKELONG(HIWORD(Volume.Left),
HIWORD(Volume.Right));
}
return rc;
*/
}
case WODM_GETPLAYBACKRATE:
printf(("WODM_GETPLAYBACKRATE"));
/*
pOutClient = (PWAVEALLOC)dwUser;
pOutClient->AuxParam.GetSetData.pData = (PBYTE)dwParam1;
pOutClient->AuxParam.GetSetData.DataLen = sizeof(DWORD);
pOutClient->AuxParam.GetSetData.Function =
IOCTL_WAVE_GET_PLAYBACK_RATE;
return waveThreadCall(WaveThreadGetData, pOutClient);
*/
default:
return MMSYSERR_NOTSUPPORTED;
}
//
// Should not get here
//
return MMSYSERR_NOTSUPPORTED;
}
APIENTRY DWORD widMessage(DWORD id, DWORD msg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
{
printf("widMessage\n");
switch (msg) {
case WIDM_GETNUMDEVS:
return GetDeviceCount(WaveInDevice);
default :
return MMSYSERR_NOERROR;
}
}