mmdsound.pas

一套及时通讯的原码

    flDistanceFactor    : D3DVALUE;
    flRolloffFactor     : D3DVALUE;
    flDopplerFactor     : D3DVALUE;
  end;

  PDSDRIVERDESC = ^TDSDRIVERDESC;
  TDSDRIVERDESC = record
    lpGUID     : PGUID;
    Description: String;
    Module     : String;
  end;

  PDSBPOSITIONNOTIFY = ^TDSBPOSITIONNOTIFY;
  TDSBPOSITIONNOTIFY = record
    dwOffset: DWORD;
    hEventNotify: THandle;
  end;

  {-- IDirectSound ------------------------------------------------------------}
  IDirectSound = class(IUnknown)
  public
    function CreateSoundBuffer(const DSBufferDesc: TDSBUFFERDESC;
                               var lpDSB: IDirectSoundBuffer;
                               pUnkOuter: IUnknown): HRESULT; virtual; stdcall; abstract;
    function GetCaps(var DSCaps: TDSCAPS): HRESULT; virtual; stdcall; abstract;
    function DuplicateSoundBuffer(lpDSBOriginal: IDirectSoundBuffer;
                                  var lpDSBDuplicate: IDirectSoundBuffer): HRESULT; virtual; stdcall; abstract;
    function SetCooperativeLevel(hwnd: HWND; dwLevel: DWORD): HRESULT; virtual; stdcall; abstract;
    function Compact: HRESULT; virtual; stdcall; abstract;
    function GetSpeakerConfig(var dwSpeakerConfig: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetSpeakerConfig(dwSpeakerConfig: DWORD): HRESULT; virtual; stdcall; abstract;
    function Initialize(lpGuid: PGUID): HRESULT; virtual; stdcall; abstract;
  end;

  {-- IDirectSoundBuffer ------------------------------------------------------}
  IDirectSoundBuffer = class(IUnknown)
  public
    function GetCaps(var DSBCaps: TDSBCAPS): HRESULT; virtual; stdcall; abstract;
    function GetCurrentPosition(var dwCurrentPlayCursor: DWORD;
                                var dwCurrentWriteCursor: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetFormat(lpwfxFormat: PWaveFormatEx; dwSizeAllocated: DWORD;
                       lpdwSizeWritten: PDWORD): HRESULT; virtual; stdcall; abstract;
    function GetVolume(var lVolume: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetPan(var lPan: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetFrequency(var dwFrequency: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetStatus(var dwStatus: DWORD): HRESULT; virtual; stdcall; abstract;
    function Initialize(lpDirectSound: IDirectSound;
                        const DSBDesc: TDSBUFFERDESC): HRESULT; virtual; stdcall; abstract;
    function Lock(dwWriteCursor: DWORD; dwWriteBytes: DWORD;
                  var lpvAudioPtr1: PChar; var dwAudioBytes1: DWORD;
                  var lpvAudioPtr2: PChar; var dwAudioBytes2: DWORD;
                  dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function Play(dwReserved1: DWORD; dwReserved2: DWORD; dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetCurrentPosition(dwNewPosition: DWORD): HRESULT; virtual; stdcall; abstract;
    function SetFormat(pwfx: PWaveFormatEx): HRESULT; virtual; stdcall; abstract;
    function SetVolume(lVolume: LONGINT): HRESULT; virtual; stdcall; abstract;
    function SetPan(lPan: LONGINT): HRESULT; virtual; stdcall; abstract;
    function SetFrequency(dwFrequency: DWORD): HRESULT; virtual; stdcall; abstract;
    function Stop: HRESULT; virtual; stdcall; abstract;
    function Unlock(lpvAudioPtr1: PChar; dwAudioBytes1: DWORD;
                    lpvAudioPtr2: PChar; dwAudioBytes2: DWORD): HRESULT; virtual; stdcall; abstract;
    function Restore: HRESULT; virtual; stdcall; abstract;
  end;

  {-- IDirectSound3DListener --------------------------------------------------}
  IDirectSound3DListener = class(IUnknown)
  public
    function GetAllParameters(lpListener: PDS3DLISTENER): HResult; virtual; stdcall; abstract;
    function GetDistanceFactor(lpflDistanceFactor: PD3DVALUE): HResult; virtual; stdcall; abstract;
    function GetDopplerFactor(lpflDopplerFactor: PD3DVALUE): HResult; virtual; stdcall; abstract;
    function GetOrientation(lpvOrientFront, lpvOrientTop: PD3DVECTOR): HResult; virtual; stdcall; abstract;
    function GetPosition(lpvPosition: PD3DVECTOR): HResult; virtual; stdcall; abstract;
    function GetRolloffFactor(lpflRolloffFactor: PD3DVALUE ): HResult; virtual; stdcall; abstract;
    function GetVelocity(lpvVelocity: PD3DVECTOR): HResult; virtual; stdcall; abstract;
    function SetAllParameters(lpListener: PDS3DLISTENER; dwApply: DWORD): HResult; virtual; stdcall; abstract;
    function SetDistanceFactor(flDistanceFactor: D3DVALUE; dwApply: DWORD): HResult; virtual; stdcall; abstract;
    function SetDopplerFactor(flDopplerFactor: D3DVALUE; dwApply: DWORD): HResult; virtual; stdcall; abstract;
    function SetOrientation(xFront, yFront, zFront, xTop, yTop, zTop: D3DVALUE; dwApply: DWORD): HResult; virtual; stdcall; abstract;
    function SetPosition(x, y, z: D3DVALUE; dwApply: DWORD): HResult; virtual; stdcall; abstract;
    function SetRolloffFactor(flRolloffFactor: D3DVALUE; dwApply: DWORD): HResult; virtual; stdcall; abstract;
    function SetVelocity(x, y, z: D3DVALUE; dwApply: DWORD): HResult; virtual; stdcall; abstract;
    function CommitDeferredSettings: HResult; virtual; stdcall; abstract;
  end;

  {-- IDirectSound3DBuffer ----------------------------------------------------}
  IDirectSound3DBuffer = class(IUnknown)
  public
    function GetAllParameters(lpDS3DBuffer: PDS3DBUFFER): HResult; virtual; stdcall; abstract;
    function GetConeAngles(lpdwInsideConeAngle, lpdwOutsideConeAngle: PDWORD): HResult; virtual; stdcall; abstract;
    function GetConeOrientation(lpvOrientation: PD3DVECTOR): HResult; virtual; stdcall; abstract;
    function GetConeOutsideVolume(lplConeOutsideVolume: PLONG): HResult; virtual; stdcall; abstract;
    function GetMaxDistance(lpflMaxDistance: PD3DVALUE): HResult; virtual; stdcall; abstract;
    function GetMinDistance(lpflMinDistance: PD3DVALUE): HResult; virtual; stdcall; abstract;
    function GetMode(lpdwMode: PDWORD): HResult; virtual; stdcall; abstract;
    function GetPosition(lpvPosition: PD3DVECTOR): HResult; virtual; stdcall; abstract;
    function GetVelocity(lpvVelocity: PD3DVECTOR): HResult; virtual; stdcall; abstract;
    function SetAllParameters(lpDS3DBuffer: PDS3DBUFFER; dwApply: DWORD): HResult; virtual; stdcall; abstract;
    function SetConeAngles(dwInsideConeAngle, dwOutsideConeAngle: DWORD; dwApply: DWORD): HResult; virtual; stdcall; abstract;
    function SetConeOrientation(x, y, z: D3DVALUE; dwApply: DWORD): HResult; virtual; stdcall; abstract;
    function SetConeOutsideVolume(lConeOutsideVolume: LONG; dwApply: DWORD): HResult; virtual; stdcall; abstract;
    function SetMaxDistance(flMaxDistance: D3DVALUE; dwApply: DWORD): HResult; virtual; stdcall; abstract;
    function SetMinDistance(flMinDistance: D3DVALUE; dwApply: DWORD): HResult; virtual; stdcall; abstract;
    function SetMode(dwMode: DWORD; dwApply: DWORD): HResult; virtual; stdcall; abstract;
    function SetPosition(x, y, z: D3DVALUE; dwApply: DWORD): HResult; virtual; stdcall; abstract;
    function SetVelocity(x, y, z: D3DVALUE; dwApply: DWORD): HResult; virtual; stdcall; abstract;
  end;

  {-- IDirectSoundNotify ------------------------------------------------------}
  IDirectSoundNotify = class(IUnknown)
  public
    function SetNotificationPositions(cPositionNotifies: DWORD;
                                      lpcPositionNotifies: PDSBPOSITIONNOTIFY): HRESULT; virtual; stdcall; abstract;
  end;

  {-- Capturing ---------------------------------------------------------------}
  PDSCCAPS = ^TDSCCAPS;
  TDSCCAPS = record
    dwSize: DWORD;
    dwFlags: DWORD;
    dwFormats: DWORD;
    dwChannels: DWORD;
  end;

  PDSCBUFFERDESC = ^TDSCBUFFERDESC;
  TDSCBUFFERDESC = record
    dwSize: DWORD;
    dwFlags: DWORD;
    dwBufferBytes: DWORD;
    dwReserved: DWORD;
    lpwfxFormat: PWaveFormatEx;
  end;

  PDSCBCAPS = ^TDSCBCAPS;
  TDSCBCAPS = record
    dwSize: DWORD;
    dwFlags: DWORD;
    dwBufferBytes: DWORD;
    dwReserved: DWORD;
  end;

  IDirectSoundCapture = class;
  IDirectSoundCaptureBuffer = class;

  {-- IDirectSoundCapture -----------------------------------------------------}
  IDirectSoundCapture = class(IUnknown)
  public
    function CreateCaptureBuffer(const lpDSCBufferDesc: TDSCBUFFERDESC;
                                 var lplpDirectSoundCaptureBuffer: IDirectSoundCaptureBuffer;
                                 pUnkOuter: IUnknown): HRESULT; virtual; stdcall; abstract;
    function GetCaps(var lpDSCCaps: TDSCCAPS): HRESULT; virtual; stdcall; abstract;
    function Initialize(lpGuid: PGUID): HRESULT; virtual; stdcall; abstract;
  end;

  {-- IDirectSoundCaptureBuffer -----------------------------------------------}
  IDirectSoundCaptureBuffer = class(IUnknown)
  public
    function GetCaps(var lpDSCBCaps: TDSCBCAPS): HRESULT; virtual; stdcall; abstract;
    function GetCurrentPosition(var lpdwCapturePosition,
                                lpdwReadPosition: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetFormat(lpwfxFormat: PWaveFormatEx; dwSizeAllocated: DWORD;
                       var lpdwSizeWritten: DWORD): HRESULT; virtual; stdcall; abstract;
    function GetStatus(var dwStatus: DWORD): HRESULT; virtual; stdcall; abstract;
    function Initialize(lpDirectSoundCapture: IDirectSoundCapture;
                        const lpcDSBufferDesc: TDSCBUFFERDESC): HRESULT; virtual; stdcall; abstract;
    function Lock(dwReadCursor: DWORD; dwReadBytes: DWORD;
                  var lplpvAudioPtr1: Pointer; var lpdwAudioBytes1: DWORD;
                  var lplpvAudioPtr2: Pointer; var lpdwAudioBytes2: DWORD;
                  dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function Start(dwFlags: DWORD): HRESULT; virtual; stdcall; abstract;
    function Stop: HRESULT; virtual; stdcall; abstract;
    function Unlock(lpvAudioPtr1: Pointer; dwAudioBytes1: DWORD;
                    lpvAudioPtr2: Pointer; dwAudioBytes2: DWORD): HRESULT; virtual; stdcall; abstract;
  end;


  PDSENUMCALLBACKA = function(lpGUID: PGUID; lpDescription: PChar;
                              lpModule: PChar; lpContext: Pointer): BOOL; stdcall;
  PDSENUMCALLBACKW = function(lpGUID: PGUID; lpDescription: PWideChar;
                              lpModule: PWideChar; lpContext: Pointer): BOOL; stdcall;

  PDSENUMCALLBACK  = PDSENUMCALLBACKA;

  { Obtaining interface }

var
   DirectSoundCreate: function (lpGUID: PGUID; var lpDS: IDirectSound;
                                pUnkOuter: IUnknown): HRESULT; stdcall;
   DirectSoundEnumerateA: function (lpCallback: PDSENUMCALLBACKA;
                                    lpContext: Pointer): HRESULT; stdcall;
   DirectSoundEnumerateW: function (lpCallback: PDSENUMCALLBACKW;
                                    lpContext: Pointer): HRESULT; stdcall;
   DirectSoundEnumerate: function (lpCallback: PDSENUMCALLBACK;
                                   lpContext: Pointer): HRESULT; stdcall;

   DirectSoundCaptureCreate: function(lpGUID: PGUID;
                                      var lplpDSC: IDirectSoundCapture;
                                      pUnkOuter: IUnknown): HRESULT; stdcall;
   DirectSoundCaptureEnumerateA: function(lpDSEnumCallback: PDSENUMCALLBACKA;
                                          lpContext: Pointer): HRESULT; stdcall;
   DirectSoundCaptureEnumerateW: function(lpDSEnumCallback: PDSENUMCALLBACKW;
                                          lpContext: Pointer): HRESULT; stdcall;
   DirectSoundCaptureEnumerate: function(lpDSEnumCallback: PDSENUMCALLBACKA;
                                         lpContext: Pointer): HRESULT; stdcall;

function DriverEnumerate(lpGUID: PGUID; lpDescription: PChar;
                         lpModule: PChar; lpContext: Pointer): BOOL; stdcall;
procedure FreeDriverList(lpContext: Pointer);

const
   DSoundDLLLoaded : Boolean = False;
   DSoundDLLHandle : THandle = 0;

function LoadDSoundDLL: Boolean;

implementation

var
   ErrorMode: DWORD;

{-- DriverEnumerate -----------------------------------------------------------}
function DriverEnumerate(lpGUID: PGUID; lpDescription: PChar;
                         lpModule: PChar; lpContext: Pointer): BOOL; stdcall;
var
   lpDriverDesc: PDSDRIVERDESC;

begin
   if (lpContext <> nil) then
   begin
      lpDriverDesc := GlobalAllocPtr(GHND,sizeOf(TDSDRIVERDESC));
      if (lpDriverDesc = nil) then OutOfMemoryError;
      lpDriverDesc^.lpGUID := nil;
      if (lpGUID <> nil) then
      begin
         lpDriverDesc^.lpGUID := GlobalAllocPtr(GHND,sizeOf(TGUID));
         if (lpDriverDesc^.lpGUID = nil) then OutOfMemoryError;
         Move(lpGUID^, lpDriverDesc^.lpGUID^, sizeof(TGUID));
      end;
      lpDriverDesc^.Description := lpDescription;
      lpDriverDesc^.Module := lpModule;
      TList(lpContext).Add(lpDriverDesc);
   end;
   Result := True;
end;

{------------------------------------------------------------------------------}
procedure FreeDriverList(lpContext: Pointer);
var
   Index: Integer;
   Driver: PDSDRIVERDESC;
begin
   if (lpContext <> nil) then
   with TList(lpContext) do
   begin
      for Index := Count-1 downto 0 do
      begin
         Driver := PDSDRIVERDESC(Items[Index]);
         if Driver <> nil then
         begin
            if Driver^.lpGuid <> nil then
               GlobalFreePtr(Driver^.lpGuid);
            Driver^.Description := '';
            Driver^.Module      := '';
            GlobalFreePtr(Driver);
         end;
      end;
      Clear;
   end;
end;

{------------------------------------------------------------------------------}
function LoadDSoundDLL: Boolean;
begin
   if not DSoundDLLLoaded then
   begin
      ErrorMode := SetErrorMode(SEM_NoOpenFileErrorBox);
      try
         DSoundDLLHandle := LoadLibrary('DSOUND.DLL');

         if (DSoundDLLHandle <> 0) then
         begin
            DSoundDLLLoaded := True;
            @DirectSoundCreate       := GetProcAddress(DSoundDLLHandle,'DirectSoundCreate');
            @DirectSoundEnumerateA := GetProcAddress(DSoundDLLHandle,'DirectSoundEnumerateA');
            @DirectSoundEnumerateW := GetProcAddress(DSoundDLLHandle,'DirectSoundEnumerateW');
            @DirectSoundEnumerate  := @DirectSoundEnumerateA;

            @DirectSoundCaptureCreate := GetProcAddress(DSoundDLLHandle, 'DirectSoundCaptureCreate');
            @DirectSoundCaptureEnumerateA := GetProcAddress(DSoundDLLHandle, 'DirectSoundCaptureEnumerateA');
            @DirectSoundCaptureEnumerateW := GetProcAddress(DSoundDLLHandle, 'DirectSoundCaptureEnumerateW');
            @DirectSoundCaptureEnumerate := @DirectSoundCaptureEnumerateA;
         end;

      finally
         SetErrorMode(ErrorMode);
      end;
   end;
   Result := DSoundDLLLoaded;
end;

Initialization

Finalization
     if DSoundDLLHandle <> 0 then
        FreeLibrary(DSoundDLLHandle);
end.