mmacm.pas

一套及时通讯的原码

        hInstance  : THandle;      { app instance containing dlg template}
        pszTemplateName: PChar;    { custom template name                }
        lCustData  : LPARAM;       { data passed to hook fn.             }
        pfnHook    : TACMFILTERCHOOSEHOOKPROC; { ptr to hook function    }
    end;

{-----------------------------------------------------------------------}
{ ACMFILTERCHOOSE.fdwStyle                                              }
{-----------------------------------------------------------------------}
const
     ACMFILTERCHOOSE_STYLEF_SHOWHELP             = $00000004;
     ACMFILTERCHOOSE_STYLEF_ENABLEHOOK           = $00000008;
     ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATE       = $00000010;
     ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATEHANDLE = $00000020;
     ACMFILTERCHOOSE_STYLEF_INITTOFILTERSTRUCT   = $00000040;
     ACMFILTERCHOOSE_STYLEF_CONTEXTHELP          = $00000080;

var
   acmFilterChoose: function(pafltrc: PACMFILTERCHOOSE): MMRESULT;
                             {$IFDEF WIN32}stdcall;{$ENDIF}

{=======================================================================}
{ ACM Stream API's                                                      }
{=======================================================================}

{-----------------------------------------------------------------------}
{ acmStreamOpen                                                         }
{-----------------------------------------------------------------------}
type
    PACMSTREAMHEADER = ^TACMSTREAMHEADER;
    TACMSTREAMHEADER = record
        cbStruct       : DWORD;    { sizeof(ACMSTREAMHEADER)    }
        fdwStatus      : DWORD;    { ACMSTREAMHEADER_STATUSF_*  }
        dwUser         : DWORD;    { user instance data for hdr }
        pbSrc          : PChar;
        cbSrcLength    : DWORD;
        cbSrcLengthUsed: DWORD;
        dwSrcUser      : DWORD;    { user instance data for src }
        pbDst          : PChar;
        cbDstLength    : DWORD;
        cbDstLengthUsed: DWORD;
        dwDstUser      : DWORD;    { user instance data for dst }
        dwReservedDriver: array[0..9] of Longint;{ driver reserved work space }
    end;

{-----------------------------------------------------------------------}
{ ACMSTREAMHEADER.fdwStatus                                             }
{-----------------------------------------------------------------------}
{ ACMSTREAMHEADER_STATUSF_DONE: done bit for async conversions.         }
{-----------------------------------------------------------------------}
const
     ACMSTREAMHEADER_STATUSF_DONE     = $00010000;
     ACMSTREAMHEADER_STATUSF_PREPARED = $00020000;
     ACMSTREAMHEADER_STATUSF_INQUEUE  = $00100000;

var
   acmStreamOpen: function(phas: PHACMSTREAM;     { pointer to stream handle        }
                           had:  THACMDRIVER;     { optional driver handle          }
                           pwfxSrc: PWAVEFORMATEX;{ source format to convert        }
                           pwfxDst: PWAVEFORMATEX;{ required destination format     }
                           pwfltr: PWAVEFILTER;   { optional filter                 }
                           dwCallback: DWORD;     { callback                        }
                           dwInstance: DWORD;     { callback instance data          }
                           fdwOpen: DWORD         { ACM_STREAMOPENF_* and CALLBACK_*}
                           ): MMRESULT;
                           {$IFDEF WIN32}stdcall;{$ENDIF}
const
     ACM_STREAMOPENF_QUERY       = $00000001;
     ACM_STREAMOPENF_ASYNC       = $00000002;
     ACM_STREAMOPENF_NONREALTIME = $00000004;

{-----------------------------------------------------------------------}
{ acmStreamClose                                                        }
{-----------------------------------------------------------------------}
var
   acmStreamClose: function(has: THACMSTREAM; fdwClose: DWORD): MMRESULT;
                            {$IFDEF WIN32}stdcall;{$ENDIF}

{-----------------------------------------------------------------------}
{ acmStreamSize                                                         }
{-----------------------------------------------------------------------}
var
   acmStreamSize: function(has: THACMSTREAM; cbInput: DWORD;
                           var dwOutputBytes: Longint; fdwSize: DWORD): MMRESULT;
                           {$IFDEF WIN32}stdcall;{$ENDIF}

const
     ACM_STREAMSIZEF_SOURCE      = $00000000;
     ACM_STREAMSIZEF_DESTINATION = $00000001;
     ACM_STREAMSIZEF_QUERYMASK   = $0000000F;

{-----------------------------------------------------------------------}
{ acmStreamReset                                                        }
{-----------------------------------------------------------------------}
var
   acmStreamReset: function(has: THACMSTREAM; fdwReset: DWORD): MMRESULT;
                            {$IFDEF WIN32}stdcall;{$ENDIF}

{-----------------------------------------------------------------------}
{ acmStreamMessage                                                      }
{-----------------------------------------------------------------------}
var
   acmStreamMessage: function(has: THACMSTREAM; uMsg: UINT;
                              lParam1, lParam2: LPARAM): MMRESULT;
                              {$IFDEF WIN32}stdcall;{$ENDIF}

{-----------------------------------------------------------------------}
{ acmStreamConvert                                                      }
{-----------------------------------------------------------------------}
var
   acmStreamConvert: function(has: THACMSTREAM; pash: PACMSTREAMHEADER;
                              fdwConvert: DWORD): MMRESULT;
                              {$IFDEF WIN32}stdcall;{$ENDIF}
const
     ACM_STREAMCONVERTF_BLOCKALIGN = $00000004;
     ACM_STREAMCONVERTF_START      = $00000010;
     ACM_STREAMCONVERTF_END        = $00000020;

{-----------------------------------------------------------------------}
{ acmStreamPrepareHeader                                                }
{-----------------------------------------------------------------------}
var
   acmStreamPrepareHeader: function(has: THACMSTREAM; pash: PACMSTREAMHEADER;
                                    fdwPrepare: DWORD): MMRESULT;
                                    {$IFDEF WIN32}stdcall;{$ENDIF}

{-----------------------------------------------------------------------}
{ acmStreamUnprepareHeader                                              }
{-----------------------------------------------------------------------}
var
   acmStreamUnprepareHeader: function(has: THACMSTREAM; pash: PACMSTREAMHEADER;
                                      fdwUnprepare: DWORD): MMRESULT;
                                      {$IFDEF WIN32}stdcall;{$ENDIF}

implementation

var
   ErrorMode: Cardinal;

procedure NewExitProc; Far;
begin
     if ACMDLLHandle >= HINSTANCE_ERROR then FreeLibrary(ACMDLLHandle);
end;

Initialization
     ErrorMode := SetErrorMode(SEM_NoOpenFileErrorBox);
     {$IFDEF WIN32}
     acmDLLHandle := LoadLibrary('MSACM32.DLL');
     {$ELSE}
     acmDLLHandle := LoadLibrary('MSACM.DLL');
     {$ENDIF}
     SetErrorMode(ErrorMode);
     if abs(acmDLLHandle) >= HINSTANCE_ERROR then
     begin
        @acmGetVersion := GetProcAddress(acmDLLHandle,'acmGetVersion');

        if (@acmGetVersion = nil) then
        begin
           FreeLibrary(acmDLLHandle);
           acmDLLHandle := 0;
           exit;
        end;

        acmDLLLoaded := True;
        {$IFNDEF WIN32}
        AddExitProc(NewExitProc);
        {$ENDIF}

        { if the version of the ACM is *NOT* V2.00 or greater, then     }
        { all other API's are unavailable--so don't waste time trying   }
        { to link to them.                                              }
        if HiWord(acmGetVersion) < $0200 then exit;

        { yipee! the ACM V2.00 or greater appears to be installed and   }
        { happy with us--so link to the rest of the nifty cool API's.   }

        @acmMetrics         := GetProcAddress(acmDLLHandle,'acmMetrics');

        @acmDriverEnum      := GetProcAddress(acmDLLHandle,'acmDriverEnum');
        {$IFDEF WIN32}
        @acmDriverDetails   := GetProcAddress(acmDLLHandle,'acmDriverDetailsA');
        @acmDriverAdd       := GetProcAddress(acmDLLHandle,'acmDriverAddA');
        {$ELSE}
        @acmDriverDetails   := GetProcAddress(acmDLLHandle,'acmDriverDetails');
        @acmDriverAdd       := GetProcAddress(acmDLLHandle,'acmDriverAdd');
        {$ENDIF}
        @acmDriverRemove    := GetProcAddress(acmDLLHandle,'acmDriverRemove');
        @acmDriverOpen      := GetProcAddress(acmDLLHandle,'acmDriverOpen');
        @acmDriverClose     := GetProcAddress(acmDLLHandle,'acmDriverClose');
        @acmDriverMessage   := GetProcAddress(acmDLLHandle,'acmDriverMessage');
        @acmDriverID        := GetProcAddress(acmDLLHandle,'acmDriverID');
        @acmDriverPriority  := GetProcAddress(acmDLLHandle,'acmDriverPriority');

        {$IFDEF WIN32}
        @acmFormatTagDetails:= GetProcAddress(acmDLLHandle,'acmFormatTagDetailsA');
        @acmFormatTagEnum   := GetProcAddress(acmDLLHandle,'acmFormatTagEnumA');
        @acmFormatChoose    := GetProcAddress(acmDLLHandle,'acmFormatChooseA');
        @acmFormatDetails   := GetProcAddress(acmDLLHandle,'acmFormatDetailsA');
        @acmFormatEnum      := GetProcAddress(acmDLLHandle,'acmFormatEnumA');
        {$ELSE}
        @acmFormatTagDetails:= GetProcAddress(acmDLLHandle,'acmFormatTagDetails');
        @acmFormatTagEnum   := GetProcAddress(acmDLLHandle,'acmFormatTagEnum');
        @acmFormatChoose    := GetProcAddress(acmDLLHandle,'acmFormatChoose');
        @acmFormatDetails   := GetProcAddress(acmDLLHandle,'acmFormatDetails');
        @acmFormatEnum      := GetProcAddress(acmDLLHandle,'acmFormatEnum');
        {$ENDIF}
        @acmFormatSuggest   := GetProcAddress(acmDLLHandle,'acmFormatSuggest');

        {$IFDEF WIN32}
        @acmFilterTagDetails:= GetProcAddress(acmDLLHandle,'acmFilterTagDetailsA');
        @acmFilterTagEnum   := GetProcAddress(acmDLLHandle,'acmFilterTagEnumA');
        @acmFilterChoose    := GetProcAddress(acmDLLHandle,'acmFilterChooseA');
        @acmFilterDetails   := GetProcAddress(acmDLLHandle,'acmFilterDetailsA');
        @acmFilterEnum      := GetProcAddress(acmDLLHandle,'acmFilterEnumA');
        {$ELSE}
        @acmFilterTagDetails:= GetProcAddress(acmDLLHandle,'acmFilterTagDetails');
        @acmFilterTagEnum   := GetProcAddress(acmDLLHandle,'acmFilterTagEnum');
        @acmFilterChoose    := GetProcAddress(acmDLLHandle,'acmFilterChoose');
        @acmFilterDetails   := GetProcAddress(acmDLLHandle,'acmFilterDetails');
        @acmFilterEnum      := GetProcAddress(acmDLLHandle,'acmFilterEnum');
        {$ENDIF}

        @acmStreamOpen      := GetProcAddress(acmDLLHandle,'acmStreamOpen');
        @acmStreamClose     := GetProcAddress(acmDLLHandle,'acmStreamClose');
        @acmStreamSize      := GetProcAddress(acmDLLHandle,'acmStreamSize');
        @acmStreamConvert   := GetProcAddress(acmDLLHandle,'acmStreamConvert');
        @acmStreamReset     := GetProcAddress(acmDLLHandle,'acmStreamReset');
        @acmStreamPrepareHeader  := GetProcAddress(acmDLLHandle,'acmStreamPrepareHeader');
        @acmStreamUnprepareHeader:= GetProcAddress(acmDLLHandle,'acmStreamUnprepareHeader');
     end;
{$IFDEF WIN32}
Finalization
     NewExitProc;
{$ENDIF}
end.