开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Delphi控件源码 > 查看源码
Mmacm.pas
资源名称：qqdelphiprog.rar　[点击查看]
上传用户：hylc_2004
上传日期：2014-01-23
资源大小：46800k
文件大小：46k
源码类别：

Delphi控件源码

开发平台：

Delphi

Mmacm.pas：源码内容
  1. {========================================================================}
  2. {=                (c) 1995-98 SwiftSoft Ronald Dittrich                 =}
  3. {========================================================================}
  4. {=                          All Rights Reserved                         =}
  5. {========================================================================}
  6. {=  D 01099 Dresden             = Fax.: +49 (0)351-8037944              =}
  7. {=  Loewenstr.7a                = info@swiftsoft.de                     =}
  8. {========================================================================}
  9. {=  Actual versions on http://www.swiftsoft.de/mmtools.html             =}
  10. {========================================================================}
  11. {=  This code is for reference purposes only and may not be copied or   =}
  12. {=  distributed in any format electronic or otherwise except one copy   =}
  13. {=  for backup purposes.                                                =}
  14. {=                                                                      =}
  15. {=  No Delphi Component Kit or Component individually or in a collection=}
  16. {=  subclassed or otherwise from the code in this unit, or associated   =}
  17. {=  .pas, .dfm, .dcu, .asm or .obj files may be sold or distributed     =}
  18. {=  without express permission from SwiftSoft.                          =}
  19. {=                                                                      =}
  20. {=  For more licence informations please refer to the associated        =}
  21. {=  HelpFile.                                                           =}
  22. {========================================================================}
  23. {=  $Date: 06.09.98 - 12:42:51 $                                        =}
  24. {========================================================================}
  25. unit MMACM;
  27. {$I COMPILER.INC}
  29. interface
  31. uses
  32. {$IFDEF WIN32}
  33.     Windows,
  34. {$ELSE}
  35.     WinProcs,   
  36.     WinTypes,
  37. {$ENDIF}
  38.     SysUtils,
  39.     MMSystem,
  40.     MMRegs;
  42. const
  43.      acmDLLLoaded: Boolean = False;
  44.      acmDLLHandle: THandle = 0;
  46. const
  47.      DRV_MAPPER_PREFERRED_INPUT_GET  = (DRV_USER + 0);
  48.      DRV_MAPPER_PREFERRED_OUTPUT_GET = (DRV_USER + 2);
  50.      DRVM_MAPPER_STATUS              = ($2000);
  52.      WIDM_MAPPER_STATUS              = (DRVM_MAPPER_STATUS + 0);
  53.      WAVEIN_MAPPER_STATUS_DEVICE     = 0;
  54.      WAVEIN_MAPPER_STATUS_MAPPED     = 1;
  55.      WAVEIN_MAPPER_STATUS_FORMAT     = 2;
  57.      WODM_MAPPER_STATUS              = (DRVM_MAPPER_STATUS + 0);
  58.      WAVEOUT_MAPPER_STATUS_DEVICE    = 0;
  59.      WAVEOUT_MAPPER_STATUS_MAPPED    = 1;
  60.      WAVEOUT_MAPPER_STATUS_FORMAT    = 2;
  62. {========================================================================}
  63. { ACM General API's and Defines                                          }
  64. {========================================================================}
  66. {------------------------------------------------------------------------}
  67. { there are four types of 'handles' used by the ACM. the first three     }
  68. { are unique types that define specific objects:                         }
  69. {                                                                        }
  70. { HACMDRIVERID:                                                          }
  71. { used to _identify_ an ACM driver. this identifier can be used to _open_}
  72. { the driver for querying details, etc about the driver.                 }
  73. {                                                                        }
  74. { HACMDRIVER:                                                            }
  75. { used to manage a driver (codec, filter, etc). this handle is much like }
  76. { a handle to other media drivers--you use it to send messages to the    }
  77. { converter, query for capabilities, etc.                                }
  78. {                                                                        }
  79. { HACMSTREAM:                                                            }
  80. { used to manage a 'stream' (conversion channel) with the ACM. you use a }
  81. { stream handle to convert data from one format/type to another--much    }
  82. { like dealing with a file handle.                                       }
  83. {                                                                        }
  84. { the fourth handle type is a generic type used on ACM functions that    }
  85. { can accept two or more of the above handle types (for example the      }
  86. { acmMetrics and acmDriverID functions).                                 }
  87. {                                                                        }
  88. { HACMOBJ:                                                               }
  89. { used to identify ACM objects. this handle is used on functions that can}
  90. { accept two or more ACM handle types.                                   }
  91. {------------------------------------------------------------------------}
  92. type
  93.     PHACMDRIVERID = ^THACMDRIVERID;
  94.     THACMDRIVERID = THandle;
  96.     PHACMDRIVER   = ^THACMDRIVER;
  97.     THACMDRIVER   = THandle;
  99.     PHACMSTREAM   = ^THACMSTREAM;
  100.     THACMSTREAM   = THandle;
  102.     PHACMOBJ      = ^THACMOBJ;
  103.     THACMOBJ      = THandle;
  105. {-----------------------------------------------------------------------}
  106. { ACM Error Codes                                                       }
  107. {                                                                       }
  108. { Note that these error codes are specific errors that apply to the ACM }
  109. { directly--general errors are defined as MMSYSTEM.                     }
  110. {-----------------------------------------------------------------------}
  111. const
  112.      ACMERR_BASE        = (512);
  113.      ACMERR_NOTPOSSIBLE = (ACMERR_BASE + 0);
  114.      ACMERR_BUSY        = (ACMERR_BASE + 1);
  115.      ACMERR_UNPREPARED  = (ACMERR_BASE + 2);
  116.      ACMERR_CANCELED    = (ACMERR_BASE + 3);
  118. {-----------------------------------------------------------------------}
  119. { ACM Window Messages                                                   }
  120. {                                                                       }
  121. { These window messages are sent by the ACM or ACM drivers to notify    }
  122. { applications of events.                                               }
  123. {                                                                       }
  124. { Note that these window message numbers will also be defined in        }
  125. { MMSYSTEM.                                                             }
  126. {-----------------------------------------------------------------------}
  127. const   { BUGBUG: ev. 16 bit others ? }
  128.      MM_ACM_OPEN  = $03D4;               { conversion callback messages }
  129.      MM_ACM_CLOSE = $03D5;
  130.      MM_ACM_DONE  = $03D6;
  132. {-----------------------------------------------------------------------}
  133. {  function acmGetVersion: Longint;                                     }
  134. {                                                                       }
  135. { the ACM version is a 32 bit number that is broken into three parts as }
  136. {  follows:                                                             }
  137. {                                                                       }
  138. {     bits 24 - 31:   8 bit _major_ version number                      }
  139. {     bits 16 - 23:   8 bit _minor_ version number                      }
  140. {     bits  0 - 15:   16 bit build number                               }
  141. {                                                                       }
  142. {  this is then displayed as follows:                                   }
  143. {                                                                       }
  144. {     bMajor = (BYTE)(dwVersion >> 24)                                  }
  145. {     bMinor = (BYTE)(dwVersion >> 16) &                                }
  146. {     wBuild = LOWORD(dwVersion)                                        }
  147. {                                                                       }
  148. {-----------------------------------------------------------------------}
  149. var
  150.    acmGetVersion: function: DWORD; {$IFDEF WIN32}stdcall;{$ENDIF}
  152. {-----------------------------------------------------------------------}
  153. { acmMetrics                                                            }
  154. {-----------------------------------------------------------------------}
  155. var
  156.    acmMetrics: function(hao: THACMOBJ; uMetric: UINT; pMetric: Pointer): MMRESULT;
  157.                         {$IFDEF WIN32}stdcall;{$ENDIF}
  159. const
  160.      ACM_METRIC_COUNT_DRIVERS          = 1;
  161.      ACM_METRIC_COUNT_CODECS           = 2;
  162.      ACM_METRIC_COUNT_CONVERTERS       = 3;
  163.      ACM_METRIC_COUNT_FILTERS          = 4;
  164.      ACM_METRIC_COUNT_DISABLED         = 5;
  165.      ACM_METRIC_COUNT_HARDWARE         = 6;
  166.      ACM_METRIC_COUNT_LOCAL_DRIVERS    = 20;
  167.      ACM_METRIC_COUNT_LOCAL_CODECS     = 21;
  168.      ACM_METRIC_COUNT_LOCAL_CONVERTERS = 22;
  169.      ACM_METRIC_COUNT_LOCAL_FILTERS    = 23;
  170.      ACM_METRIC_COUNT_LOCAL_DISABLED   = 24;
  171.      ACM_METRIC_HARDWARE_WAVE_INPUT    = 30;
  172.      ACM_METRIC_HARDWARE_WAVE_OUTPUT   = 31;
  173.      ACM_METRIC_MAX_SIZE_FORMAT        = 50;
  174.      ACM_METRIC_MAX_SIZE_FILTER        = 51;
  175.      ACM_METRIC_DRIVER_SUPPORT         = 100;
  176.      ACM_METRIC_DRIVER_PRIORITY        = 101;
  178. {=======================================================================}
  179. { ACM Drivers                                                           }
  180. {=======================================================================}
  182. {=======================================================================}
  183. { acmDriverEnum                                                         }
  184. {=======================================================================}
  185. type
  186.     TACMDRIVERENUMCB = function(hadid: THACMDRIVERID;
  187.                                 dwInstance, fdwSupport: DWORD): Boolean;
  188.                                 {$IFDEF WIN32} stdcall; {$ENDIF}
  190. var
  191.    acmDriverEnum: function(fnCallback: TACMDRIVERENUMCB;
  192.                            dwInstance, fdwEnum: DWORD): MMRESULT;
  193.                            {$IFDEF WIN32} stdcall; {$ENDIF}
  195. const
  196.      ACM_DRIVERENUMF_NOLOCAL  = $40000000;
  197.      ACM_DRIVERENUMF_DISABLED = $80000000;
  199. {-----------------------------------------------------------------------}
  200. { acmDriverID                                                           }
  201. {-----------------------------------------------------------------------}
  202. var
  203.    acmDriverID: function(hao: THACMOBJ; phadid: PHACMDRIVERID;
  204.                          fdwDriverID: DWORD): MMRESULT;
  205.                          {$IFDEF WIN32} stdcall; {$ENDIF}
  208. {-----------------------------------------------------------------------}
  209. { acmDriverAdd                                                          }
  210. {-----------------------------------------------------------------------}
  211. var
  212.    acmDriverAdd: function(phadid: PHACMDRIVERID; hinstModule: THandle;
  213.                           lParam: LPARAM; dwPriority: DWORD; fdwAdd: DWORD): MMRESULT;
  214.                           {$IFDEF WIN32} stdcall; {$ENDIF}
  216. const
  217.      ACM_DRIVERADDF_FUNCTION   = $00000003;  { lParam is a procedure    }
  218.      ACM_DRIVERADDF_NOTIFYHWND = $00000004;  { lParam is notify hwnd    }
  219.      ACM_DRIVERADDF_TYPEMASK   = $00000007;  { driver type mask         }
  220.      ACM_DRIVERADDF_LOCAL      = $00000000;  { is local to current task }
  221.      ACM_DRIVERADDF_GLOBAL     = $00000008;  { is global                }
  223. {-----------------------------------------------------------------------}
  224. { prototype for ACM driver procedures that are installed as _functions_ }
  225. { or _notifations_ instead of as a standalone installable driver.       }
  226. {-----------------------------------------------------------------------}
  227. (*type
  228.     PACMDRIVERPROC = ^TACMDRIVERPROC;
  229.     TACMDRIVERPROC = function(DWORD; THACMDRIVERID; UINT; LPARAM;
  230.                               LPARAM): LRESULT;
  231.                               {$IFDEF WIN32} stdcall; {$ENDIF}
  232. *)
  234. {-----------------------------------------------------------------------}
  235. { acmDriverRemove                                                       }
  236. {-----------------------------------------------------------------------}
  237. var
  238.    acmDriverRemove: function(hadid: THACMDRIVERID; fdwRemove: DWORD): MMRESULT;
  239.                              {$IFDEF WIN32} stdcall; {$ENDIF}
  241. {-----------------------------------------------------------------------}
  242. { acmDriverOpen                                                         }
  243. {-----------------------------------------------------------------------}
  244. var
  245.    acmDriverOpen: function(phad: PHACMDRIVER; hadid: THACMDRIVERID; fdwOpen: DWORD): MMRESULT;
  246.                            {$IFDEF WIN32} stdcall; {$ENDIF}
  248. {-----------------------------------------------------------------------}
  249. { acmDriverClose                                                        }
  250. {-----------------------------------------------------------------------}
  251. var
  252.    acmDriverClose: function(had: THACMDRIVER; fdwClose: DWORD): MMRESULT;
  253.                             {$IFDEF WIN32} stdcall; {$ENDIF}
  255. {-----------------------------------------------------------------------}
  256. { acmDriverMessage                                                      }
  257. {-----------------------------------------------------------------------}
  258. var
  259.    acmDriverMessage: function(had: THACMDRIVER; uMsg: UINT;
  260.                               lParam1, lParam2: LPARAM): LRESULT;
  261.                               {$IFDEF WIN32} stdcall; {$ENDIF}
  263. const
  264.      ACMDM_USER          = (DRV_USER + $0000);
  265.      ACMDM_RESERVED_LOW  = (DRV_USER + $2000);
  266.      ACMDM_RESERVED_HIGH = (DRV_USER + $2FFF);
  267.      ACMDM_BASE          = ACMDM_RESERVED_LOW;
  268.      ACMDM_DRIVER_ABOUT  = (ACMDM_BASE + 11);
  270. {-----------------------------------------------------------------------}
  271. { acmDriverPriority                                                     }
  272. {-----------------------------------------------------------------------}
  273. var
  274.    acmDriverPriority: function(hadid: THACMDRIVERID;
  275.                                dwPriority, fdwPriority: DWORD): MMRESULT;
  276.                                {$IFDEF WIN32} stdcall; {$ENDIF}
  278. const
  279.      ACM_DRIVERPRIORITYF_ENABLE    = $00000001;
  280.      ACM_DRIVERPRIORITYF_DISABLE   = $00000002;
  281.      ACM_DRIVERPRIORITYF_ABLEMASK  = $00000003;
  282.      ACM_DRIVERPRIORITYF_BEGIN     = $00010000;
  283.      ACM_DRIVERPRIORITYF_END       = $00020000;
  284.      ACM_DRIVERPRIORITYF_DEFERMASK = $00030000;
  286. {-----------------------------------------------------------------------}
  287. { acmDriverDetails                                                      }
  288. {-----------------------------------------------------------------------}
  289. {                                                                       }
  290. {  ACMDRIVERDETAILS                                                     }
  291. {                                                                       }
  292. {  the ACMDRIVERDETAILS structure is used to get various capabilities   }
  293. {  from an ACM driver (codec, converter, filter).                       }
  294. {-----------------------------------------------------------------------}
  295. const
  296.      ACMDRIVERDETAILS_SHORTNAME_CHARS = 32;
  297.      ACMDRIVERDETAILS_LONGNAME_CHARS  = 128;
  298.      ACMDRIVERDETAILS_COPYRIGHT_CHARS = 80;
  299.      ACMDRIVERDETAILS_LICENSING_CHARS = 128;
  300.      ACMDRIVERDETAILS_FEATURES_CHARS  = 512;
  302. type
  303.     PACMDRIVERDETAILS = ^TACMDRIVERDETAILS;
  304.     TACMDRIVERDETAILS = record
  305.         cbStruct   : DWORD;        { number of valid bytes in structure }
  306.         fccType    : FOURCC;       { compressor type 'audc'             }
  307.         fccComp    : FOURCC;       { sub-type (not used; reserved)      }
  309.         wMid       : WORD;         { manufacturer id                    }
  310.         wPid       : WORD;         { product id                         }
  312.         vdwACM     : DWORD;        { version of the ACM *compiled* for  }
  313.         vdwDriver  : DWORD;        { version of the driver              }
  315.         fdwSupport : DWORD;        { misc. support flags                }
  316.         cFormatTags: DWORD;        { total unique format tags supported }
  317.         cFilterTags: DWORD;        { total unique filter tags supported }
  319.         hicon      : HICON;        { handle to custom icon              }
  321.         szShortName: array[0..ACMDRIVERDETAILS_SHORTNAME_CHARS-1]of Char;
  322.         szLongName : array[0..ACMDRIVERDETAILS_LONGNAME_CHARS-1] of Char;
  323.         szCopyright: array[0..ACMDRIVERDETAILS_COPYRIGHT_CHARS-1]of Char;
  324.         szLicensing: array[0..ACMDRIVERDETAILS_LICENSING_CHARS-1]of Char;
  325.         szFeatures : array[0..ACMDRIVERDETAILS_FEATURES_CHARS-1] of Char;
  326.     end;
  328. {-----------------------------------------------------------------------}
  329. {                                                                       }
  330. {  ACMDRIVERDETAILS.fccType                                             }
  331. {                                                                       }
  332. {  ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC: the FOURCC used in the fccType  }
  333. {  field of the ACMDRIVERDETAILS structure to specify that this is an   }
  334. {  ACM codec designed for audio.                                        }
  335. {                                                                       }
  336. {                                                                       }
  337. {  ACMDRIVERDETAILS.fccComp                                             }
  338. {                                                                       }
  339. {  ACMDRIVERDETAILS_FCCCOMP_UNDEFINED: the FOURCC used in the fccComp   }
  340. {  field of the ACMDRIVERDETAILS structure. this is currently an unused }
  341. {  field.                                                               }
  342. {-----------------------------------------------------------------------}
  343. const
  344.      ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC = $63647561; {'audc'}
  345.      ACMDRIVERDETAILS_FCCCOMP_UNDEFINED  = $0;
  347. {  the following flags are used to specify the type of conversion(s) that     }
  348. {  the converter/codec/filter supports. these are placed in the fdwSupport    }
  349. {  field of the ACMDRIVERDETAILS structure. note that a converter can         }
  350. {  support one or more of these flags in any combination.                     }
  351. {                                                                             }
  352. {  ACMDRIVERDETAILS_SUPPORTF_CODEC: this flag is set if the driver supports   }
  353. {  conversions from one format tag to another format tag. for example, if a   }
  354. {  converter compresses WAVE_FORMAT_PCM to WAVE_FORMAT_ADPCM, then this bit   }
  355. {  should be set.                                                             }
  356. {                                                                             }
  357. {  ACMDRIVERDETAILS_SUPPORTF_CONVERTER: this flags is set if the driver       }
  358. {  supports conversions on the same format tag. as an example, the PCM        }
  359. {  converter that is built into the ACM sets this bit (and only this bit)     }
  360. {  because it converts only PCM formats (bits, sample rate).                  }
  361. {                                                                             }
  362. {  ACMDRIVERDETAILS_SUPPORTF_FILTER: this flag is set if the driver supports  }
  363. {  transformations on a single format. for example, a converter that changed  }
  364. {  the 'volume' of PCM data would set this bit. 'echo' and 'reverb' are       }
  365. {  also filter types.                                                         }
  366. {                                                                             }
  367. {  ACMDRIVERDETAILS_SUPPORTF_HARDWARE: this flag is set if the driver supports}
  368. {  hardware input and/or output through a waveform device.                    }
  369. {                                                                             }
  370. {  ACMDRIVERDETAILS_SUPPORTF_ASYNC: this flag is set if the driver supports   }
  371. {  async conversions.                                                         }
  372. {                                                                             }
  373. {  ACMDRIVERDETAILS_SUPPORTF_LOCAL: this flag is set _by the ACM_ if a        }
  374. {  driver has been installed local to the current task. this flag is also     }
  375. {  set in the fdwSupport argument to the enumeration callback function        }
  376. {  for drivers.                                                               }
  377. {                                                                             }
  378. {  ACMDRIVERDETAILS_SUPPORTF_DISABLED: this flag is set _by the ACM_ if a     }
  379. {  driver has been disabled. this flag is also passed set in the fdwSupport   }
  380. {  argument to the enumeration callback function for drivers.                 }
  381. {                                                                             }
  382. {-----------------------------------------------------------------------------}
  383. const
  384.      ACMDRIVERDETAILS_SUPPORTF_CODEC     = $00000001;
  385.      ACMDRIVERDETAILS_SUPPORTF_CONVERTER = $00000002;
  386.      ACMDRIVERDETAILS_SUPPORTF_FILTER    = $00000004;
  387.      ACMDRIVERDETAILS_SUPPORTF_HARDWARE  = $00000008;
  388.      ACMDRIVERDETAILS_SUPPORTF_ASYNC     = $00000010;
  389.      ACMDRIVERDETAILS_SUPPORTF_LOCAL     = $40000000;
  390.      ACMDRIVERDETAILS_SUPPORTF_DISABLED  = $80000000;
  392. var
  393.    acmDriverDetails: function(hadid: THACMDRIVERID; padd: PACMDRIVERDETAILS;
  394.                               fdwDetails: DWORD): MMRESULT;
  395.                               {$IFDEF WIN32} stdcall; {$ENDIF}
  397. {=======================================================================}
  398. { ACM Format Tags                                                       }
  399. {=======================================================================}
  401. {-----------------------------------------------------------------------}
  402. { acmFormatTagDetails                                                   }
  403. {-----------------------------------------------------------------------}
  404. const
  405.      ACMFORMATTAGDETAILS_FORMATTAG_CHARS = 48;
  407. type
  408.     PACMFORMATTAGDETAILS = ^TACMFORMATTAGDETAILS;
  409.     TACMFORMATTAGDETAILS = record
  410.        cbStruct        : DWORD;
  411.        dwFormatTagIndex: DWORD;
  412.        dwFormatTag     : DWORD;
  413.        cbFormatSize    : DWORD;
  414.        fdwSupport      : DWORD;
  415.        cStandardFormats: DWORD;
  416.        szFormatTag: array[0..ACMFORMATTAGDETAILS_FORMATTAG_CHARS-1] of Char;
  417.     end;
  419. var
  420.    acmFormatTagDetails: function(had: THACMDRIVER; paftd: PACMFORMATTAGDETAILS;
  421.                                  fdwDetails: DWORD): MMRESULT;
  422.                                  {$IFDEF WIN32}stdcall; {$ENDIF}
  424. const
  425.      ACM_FORMATTAGDETAILSF_INDEX       = $00000000;
  426.      ACM_FORMATTAGDETAILSF_FORMATTAG   = $00000001;
  427.      ACM_FORMATTAGDETAILSF_LARGESTSIZE = $00000002;
  428.      ACM_FORMATTAGDETAILSF_QUERYMASK   = $0000000F;
  430. {-----------------------------------------------------------------------}
  431. { acmFormatTagEnum                                                      }
  432. {-----------------------------------------------------------------------}
  433. type
  434.     TACMFORMATTAGENUMCB = function(hadid: THACMDRIVERID;
  435.                                    paftd: PACMFORMATTAGDETAILS;
  436.                                    dwInstance, fdwSupport: DWORD): Boolean; 
  437.                                    {$IFDEF WIN32}stdcall;{$ENDIF}
  439. var
  440.    acmFormatTagEnum: function(had: THACMDRIVER; paftd: PACMFORMATTAGDETAILS;
  441.                               fnCallBack: TACMFORMATTAGENUMCB;
  442.                               dwInstance, fdwEnum: DWORD): MMRESULT;
  443.                               {$IFDEF WIN32}stdcall;{$ENDIF}
  445. {=======================================================================}
  446. { ACM Formats                                                           }
  447. {=======================================================================}
  449. {-----------------------------------------------------------------------}
  450. { acmFormatDetails                                                      }
  451. {-----------------------------------------------------------------------}
  452. const
  453.      ACMFORMATDETAILS_FORMAT_CHARS = 128;
  455. type
  456.     PACMFORMATDETAILS = ^TACMFORMATDETAILS;
  457.     TACMFORMATDETAILS = record
  458.         cbStruct     : DWORD;
  459.         dwFormatIndex: DWORD;
  460.         dwFormatTag  : DWORD;
  461.         fdwSupport   : DWORD;
  462.         pwfx         : PWAVEFORMATEX;
  463.         cbwfx        : DWORD;
  464.         szFormat: array[0..ACMFORMATDETAILS_FORMAT_CHARS-1] of Char;
  465.     end;
  467. var
  468.    acmFormatDetails: function(had: THACMDRIVER; pafd: PACMFORMATDETAILS;
  469.                               fdwDetails: DWORD): MMRESULT;
  470.                               {$IFDEF WIN32} stdcall; {$ENDIF}
  472. const
  473.      ACM_FORMATDETAILSF_INDEX     = $00000000;
  474.      ACM_FORMATDETAILSF_FORMAT    = $00000001;
  475.      ACM_FORMATDETAILSF_QUERYMASK = $0000000F;
  477. {-----------------------------------------------------------------------}
  478. { acmFormatEnum                                                         }
  479. {-----------------------------------------------------------------------}
  480. type
  481.     TACMFORMATENUMCB = function(hadid: THACMDRIVERID; pafd: PACMFORMATDETAILS;
  482.                                 dwInstance, fdwSupport: DWORD): Boolean; 
  483.                                 {$IFDEF WIN32}stdcall;{$ENDIF}
  484. var
  485.    acmFormatEnum: function(had: THACMDRIVER; pafd: PACMFORMATDETAILS;
  486.                            fnCallBack: TACMFORMATENUMCB;
  487.                            dwInstance, fdwEnum: DWORD): MMRESULT;
  488.                            {$IFDEF WIN32}stdcall;{$ENDIF}
  490. const
  491.      ACM_FORMATENUMF_WFORMATTAG     = $00010000;
  492.      ACM_FORMATENUMF_NCHANNELS      = $00020000;
  493.      ACM_FORMATENUMF_NSAMPLESPERSEC = $00040000;
  494.      ACM_FORMATENUMF_WBITSPERSAMPLE = $00080000;
  495.      ACM_FORMATENUMF_CONVERT        = $00100000;
  496.      ACM_FORMATENUMF_SUGGEST        = $00200000;
  497.      ACM_FORMATENUMF_HARDWARE       = $00400000;
  498.      ACM_FORMATENUMF_INPUT          = $00800000;
  499.      ACM_FORMATENUMF_OUTPUT         = $01000000;
  501. {-----------------------------------------------------------------------}
  502. { acmFormatSuggest                                                      }
  503. {-----------------------------------------------------------------------}
  504. var
  505.    acmFormatSuggest: function(had: THACMDRIVER; pwfxSrc, pwfxDst: PWAVEFORMATEX;
  506.                               cbwfxDst, fdwSuggest: DWORD): MMRESULT;
  507.                               {$IFDEF WIN32}stdcall;{$ENDIF}
  508. const
  509.      ACM_FORMATSUGGESTF_WFORMATTAG     = $00010000;
  510.      ACM_FORMATSUGGESTF_NCHANNELS      = $00020000;
  511.      ACM_FORMATSUGGESTF_NSAMPLESPERSEC = $00040000;
  512.      ACM_FORMATSUGGESTF_WBITSPERSAMPLE = $00080000;
  514.      ACM_FORMATSUGGESTF_TYPEMASK       = $00FF0000;
  516. {-----------------------------------------------------------------------}
  517. { acmFormatChoose                                                       }
  518. {-----------------------------------------------------------------------}
  519. const
  520.      ACMHELPMSGSTRING       = 'acmchoose_help';
  521.      ACMHELPMSGCONTEXTMENU  = 'acmchoose_contextmenu';
  522.      ACMHELPMSGCONTEXTHELP  = 'acmchoose_contexthelp';
  524. { MM_ACM_FORMATCHOOSE is sent to hook callbacks by the Format Chooser   }
  525. {  Dialog...                                                            }
  527.      MM_ACM_FORMATCHOOSE           = ($8000);
  529.      FORMATCHOOSE_MESSAGE          = 0;
  530.      FORMATCHOOSE_FORMATTAG_VERIFY = (FORMATCHOOSE_MESSAGE+0);
  531.      FORMATCHOOSE_FORMAT_VERIFY    = (FORMATCHOOSE_MESSAGE+1);
  532.      FORMATCHOOSE_CUSTOM_VERIFY    = (FORMATCHOOSE_MESSAGE+2);
  534. type
  535.     TACMFORMATCHOOSEHOOKPROC = function(hwnd: HWND; uMsg: UINT;
  536.                                         wParam: WPARAM; lParam: LPARAM): UINT;
  537.                                         {$IFDEF WIN32}stdcall;{$ENDIF}
  539.     PACMFORMATCHOOSE = ^TACMFORMATCHOOSE;
  540.     TACMFORMATCHOOSE = record
  541.         cbStruct       : DWORD;           { sizeof(ACMFORMATCHOOSE)      }
  542.         fdwStyle       : DWORD;           { chooser style flags          }
  544.         hwndOwner      : HWND;            { caller's window handle       }
  546.         pwfx           : PWAVEFORMATEX;   { ptr to wfx buf to receive choice }
  547.         cbwfx          : DWORD;           { size of mem buf for pwfx     }
  548.         pszTitle       : PCHAR;           { dialog box title bar         }
  550.         szFormatTag    : array[0..ACMFORMATTAGDETAILS_FORMATTAG_CHARS-1] of Char;
  551.         szFormat       : array[0..ACMFORMATDETAILS_FORMAT_CHARS-1] of Char;
  553.         pszName        : PCHAR;            { custom name selection       }
  554.         cchName        : DWORD;            { size in chars of mem buf for pszName }
  556.         fdwEnum        : DWORD;            { format enumeration restrictions }
  557.         pwfxEnum       : PWAVEFORMATEX;    { format describing restrictions }
  559.         hInstance      : THandle;          { app instance containing dlg template }
  560.         pszTemplateName: PChar;            { custom template name           }
  561.         lCustData      : LPARAM;           { data passed to hook fn.        }
  562.         pfnHook        : TACMFORMATCHOOSEHOOKPROC;{ ptr to hook function }
  563.     end;
  565. {-----------------------------------------------------------------------}
  566. { ACMFORMATCHOOSE.fdwStyle                                              }
  567. {-----------------------------------------------------------------------}
  568. const
  569.      ACMFORMATCHOOSE_STYLEF_SHOWHELP             = $00000004;
  570.      ACMFORMATCHOOSE_STYLEF_ENABLEHOOK           = $00000008;
  571.      ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE       = $00000010;
  572.      ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE = $00000020;
  573.      ACMFORMATCHOOSE_STYLEF_INITTOWFXSTRUCT      = $00000040;
  574.      ACMFORMATCHOOSE_STYLEF_CONTEXTHELP          = $00000080;
  576. var
  577.    acmFormatChoose: function(pafmtc: PACMFORMATCHOOSE): MMRESULT;
  578.                              {$IFDEF WIN32}stdcall;{$ENDIF}
  580. {=======================================================================}
  581. { ACM Filter Tags                                                       }
  582. {=======================================================================}
  584. {-----------------------------------------------------------------------}
  585. { acmFilterTagDetails                                                   }
  586. {-----------------------------------------------------------------------}
  587. const
  588.      ACMFILTERTAGDETAILS_FILTERTAG_CHARS = 48;
  590. type
  591.     PACMFILTERTAGDETAILS = ^TACMFILTERTAGDETAILS;
  592.     TACMFILTERTAGDETAILS = record
  593.         cbStruct        : DWORD;
  594.         dwFilterTagIndex: DWORD;
  595.         dwFilterTag     : DWORD;
  596.         cbFilterSize    : DWORD;
  597.         fdwSupport      : DWORD;
  598.         cStandardFilters: DWORD;
  599.         szFilterTag: array[0..ACMFILTERTAGDETAILS_FILTERTAG_CHARS-1] of Char;
  600.     end;
  602. var
  603.    acmFilterTagDetails: function(had: THACMDRIVER; paftd: PACMFILTERTAGDETAILS;
  604.                                  fdwDetails: DWORD): MMRESULT;
  605.                                  {$IFDEF WIN32}stdcall;{$ENDIF}
  606. const
  607.      ACM_FILTERTAGDETAILSF_INDEX       = $00000000;
  608.      ACM_FILTERTAGDETAILSF_FILTERTAG   = $00000001;
  609.      ACM_FILTERTAGDETAILSF_LARGESTSIZE = $00000002;
  610.      ACM_FILTERTAGDETAILSF_QUERYMASK   = $0000000F;
  612. {-----------------------------------------------------------------------}
  613. { acmFilterTagEnum                                                      }
  614. {-----------------------------------------------------------------------}
  615. type
  616.     TACMFILTERTAGENUMCB = function(hadid: THACMDRIVERID;
  617.                                    paftd: PACMFILTERTAGDETAILS;
  618.                                    dwInstance, fdwSupport: DWORD): Boolean; 
  619.                                    {$IFDEF WIN32}stdcall;{$ENDIF}
  621. var
  622.    acmFilterTagEnum: function(had: THACMDRIVER;paftd: PACMFILTERTAGDETAILS;
  623.                               fnCallBack: TACMFILTERTAGENUMCB;
  624.                               dwInstance, fdwEnum: DWORD): MMRESULT;
  625.                               {$IFDEF WIN32}stdcall;{$ENDIF}
  627. {=======================================================================}
  628. { ACM Filters                                                           }
  629. {=======================================================================}
  631. {-----------------------------------------------------------------------}
  632. { acmFilterDetails                                                      }
  633. {-----------------------------------------------------------------------}
  634. const
  635.      ACMFILTERDETAILS_FILTER_CHARS = 128;
  637. type
  638.     PACMFILTERDETAILS = ^TACMFILTERDETAILS;
  639.     TACMFILTERDETAILS = record
  640.         cbStruct     : DWORD;
  641.         dwFilterIndex: DWORD;
  642.         dwFilterTag  : DWORD;
  643.         fdwSupport   : DWORD;
  644.         pwfltr       : PWAVEFILTER;
  645.         cbwfltr      : DWORD;
  646.         szFilter: array[0..ACMFILTERDETAILS_FILTER_CHARS-1] of char;
  647.     end;
  649. var
  650.    acmFilterDetails: function(had: THACMDRIVER;
  651.                               pafd: PACMFILTERDETAILS;
  652.                               fdwDetails: DWORD): MMRESULT;
  653.                               {$IFDEF WIN32}stdcall;{$ENDIF}
  655. const
  656.      ACM_FILTERDETAILSF_INDEX     = $00000000;
  657.      ACM_FILTERDETAILSF_FILTER    = $00000001;
  658.      ACM_FILTERDETAILSF_QUERYMASK = $0000000F;
  660. {-----------------------------------------------------------------------}
  661. { acmFilterEnum                                                         }
  662. {-----------------------------------------------------------------------}
  663. type
  664.     TACMFILTERENUMCB = function(hadid: THACMDRIVERID;
  665.                                 pafd: PACMFILTERDETAILS;
  666.                                 dwInstance, fdwSupport: DWORD): Boolean;
  667.                                 {$IFDEF WIN32}stdcall;{$ENDIF}
  669. var
  670.    acmFilterEnum: function(had: THACMDRIVER; pafd: PACMFILTERDETAILS;
  671.                            fnCallBack: TACMFILTERENUMCB;
  672.                            dwInstance, fdwEnum: DWORD): MMRESULT;
  673.                            {$IFDEF WIN32}stdcall;{$ENDIF}
  674. const
  675.      ACM_FILTERENUMF_DWFILTERTAG = $00010000;
  677. {-----------------------------------------------------------------------}
  678. { acmFilterChoose                                                       }
  679. {-----------------------------------------------------------------------}
  680. { MM_ACM_FILTERCHOOSE is sent to hook callbacks by the Filter Chooser   }
  681. { Dialog...                                                             }
  682. const
  683.      MM_ACM_FILTERCHOOSE           = ($8000);
  685.      FILTERCHOOSE_MESSAGE          = 0;
  686.      FILTERCHOOSE_FILTERTAG_VERIFY = (FILTERCHOOSE_MESSAGE+0);
  687.      FILTERCHOOSE_FILTER_VERIFY    = (FILTERCHOOSE_MESSAGE+1);
  688.      FILTERCHOOSE_CUSTOM_VERIFY    = (FILTERCHOOSE_MESSAGE+2);
  690. type
  691.     TACMFILTERCHOOSEHOOKPROC = function(hwnd: HWND; uMsg: UINT;
  692.                                         wParam: WPARAM; lParam: LPARAM): UINT;
  693.                                         {$IFDEF WIN32}stdcall;{$ENDIF}
  695.     PACMFILTERCHOOSE = ^TACMFILTERCHOOSE;
  696.     TACMFILTERCHOOSE = record
  697.         cbStruct   : DWORD;        { sizeof(ACMFILTERCHOOSE)             }
  698.         fdwStyle   : DWORD;        { chooser style flags                 }
  700.         hwndOwner  : HWND;         { caller's window handle              }
  702.         pwfltr     : PWAVEFILTER;  { ptr to wfltr buf to receive choice  }
  703.         cbwfltr    : DWORD;        { size of mem buf for pwfltr          }
  705.         pszTitle   : PChar;
  707.         szFilterTag: array[0..ACMFILTERTAGDETAILS_FILTERTAG_CHARS-1] of Char;
  708.         szFilter   : array[0..ACMFILTERDETAILS_FILTER_CHARS-1] of Char;
  709.         pszName    : PChar;        { custom name selection               }
  710.         cchName    : DWORD;        { size in chars of mem buf for pszName}
  712.         fdwEnum    : DWORD;        { filter enumeration restrictions     }
  713.         pwfltrEnum : PWAVEFILTER;  { filter describing restrictions      }
  715.         hInstance  : THandle;      { app instance containing dlg template}
  716.         pszTemplateName: PChar;    { custom template name                }
  717.         lCustData  : LPARAM;       { data passed to hook fn.             }
  718.         pfnHook    : TACMFILTERCHOOSEHOOKPROC; { ptr to hook function    }
  719.     end;
  721. {-----------------------------------------------------------------------}
  722. { ACMFILTERCHOOSE.fdwStyle                                              }
  723. {-----------------------------------------------------------------------}
  724. const
  725.      ACMFILTERCHOOSE_STYLEF_SHOWHELP             = $00000004;
  726.      ACMFILTERCHOOSE_STYLEF_ENABLEHOOK           = $00000008;
  727.      ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATE       = $00000010;
  728.      ACMFILTERCHOOSE_STYLEF_ENABLETEMPLATEHANDLE = $00000020;
  729.      ACMFILTERCHOOSE_STYLEF_INITTOFILTERSTRUCT   = $00000040;
  730.      ACMFILTERCHOOSE_STYLEF_CONTEXTHELP          = $00000080;
  732. var
  733.    acmFilterChoose: function(pafltrc: PACMFILTERCHOOSE): MMRESULT;
  734.                              {$IFDEF WIN32}stdcall;{$ENDIF}
  736. {=======================================================================}
  737. { ACM Stream API's                                                      }
  738. {=======================================================================}
  740. {-----------------------------------------------------------------------}
  741. { acmStreamOpen                                                         }
  742. {-----------------------------------------------------------------------}
  743. type
  744.     PACMSTREAMHEADER = ^TACMSTREAMHEADER;
  745.     TACMSTREAMHEADER = record
  746.         cbStruct       : DWORD;    { sizeof(ACMSTREAMHEADER)    }
  747.         fdwStatus      : DWORD;    { ACMSTREAMHEADER_STATUSF_*  }
  748.         dwUser         : DWORD;    { user instance data for hdr }
  749.         pbSrc          : PChar;
  750.         cbSrcLength    : DWORD;
  751.         cbSrcLengthUsed: DWORD;
  752.         dwSrcUser      : DWORD;    { user instance data for src }
  753.         pbDst          : PChar;
  754.         cbDstLength    : DWORD;
  755.         cbDstLengthUsed: DWORD;
  756.         dwDstUser      : DWORD;    { user instance data for dst }
  757.         dwReservedDriver: array[0..9] of Longint;{ driver reserved work space }
  758.     end;
  760. {-----------------------------------------------------------------------}
  761. { ACMSTREAMHEADER.fdwStatus                                             }
  762. {-----------------------------------------------------------------------}
  763. { ACMSTREAMHEADER_STATUSF_DONE: done bit for async conversions.         }
  764. {-----------------------------------------------------------------------}
  765. const
  766.      ACMSTREAMHEADER_STATUSF_DONE     = $00010000;
  767.      ACMSTREAMHEADER_STATUSF_PREPARED = $00020000;
  768.      ACMSTREAMHEADER_STATUSF_INQUEUE  = $00100000;
  770. var
  771.    acmStreamOpen: function(phas: PHACMSTREAM;     { pointer to stream handle        }
  772.                            had:  THACMDRIVER;     { optional driver handle          }
  773.                            pwfxSrc: PWAVEFORMATEX;{ source format to convert        }
  774.                            pwfxDst: PWAVEFORMATEX;{ required destination format     }
  775.                            pwfltr: PWAVEFILTER;   { optional filter                 }
  776.                            dwCallback: DWORD;     { callback                        }
  777.                            dwInstance: DWORD;     { callback instance data          }
  778.                            fdwOpen: DWORD         { ACM_STREAMOPENF_* and CALLBACK_*}
  779.                            ): MMRESULT;
  780.                            {$IFDEF WIN32}stdcall;{$ENDIF}
  781. const
  782.      ACM_STREAMOPENF_QUERY       = $00000001;
  783.      ACM_STREAMOPENF_ASYNC       = $00000002;
  784.      ACM_STREAMOPENF_NONREALTIME = $00000004;
  786. {-----------------------------------------------------------------------}
  787. { acmStreamClose                                                        }
  788. {-----------------------------------------------------------------------}
  789. var
  790.    acmStreamClose: function(has: THACMSTREAM; fdwClose: DWORD): MMRESULT;
  791.                             {$IFDEF WIN32}stdcall;{$ENDIF}
  793. {-----------------------------------------------------------------------}
  794. { acmStreamSize                                                         }
  795. {-----------------------------------------------------------------------}
  796. var
  797.    acmStreamSize: function(has: THACMSTREAM; cbInput: DWORD;
  798.                            var dwOutputBytes: Longint; fdwSize: DWORD): MMRESULT;
  799.                            {$IFDEF WIN32}stdcall;{$ENDIF}
  801. const
  802.      ACM_STREAMSIZEF_SOURCE      = $00000000;
  803.      ACM_STREAMSIZEF_DESTINATION = $00000001;
  804.      ACM_STREAMSIZEF_QUERYMASK   = $0000000F;
  806. {-----------------------------------------------------------------------}
  807. { acmStreamReset                                                        }
  808. {-----------------------------------------------------------------------}
  809. var
  810.    acmStreamReset: function(has: THACMSTREAM; fdwReset: DWORD): MMRESULT;
  811.                             {$IFDEF WIN32}stdcall;{$ENDIF}
  813. {-----------------------------------------------------------------------}
  814. { acmStreamMessage                                                      }
  815. {-----------------------------------------------------------------------}
  816. var
  817.    acmStreamMessage: function(has: THACMSTREAM; uMsg: UINT;
  818.                               lParam1, lParam2: LPARAM): MMRESULT;
  819.                               {$IFDEF WIN32}stdcall;{$ENDIF}
  821. {-----------------------------------------------------------------------}
  822. { acmStreamConvert                                                      }
  823. {-----------------------------------------------------------------------}
  824. var
  825.    acmStreamConvert: function(has: THACMSTREAM; pash: PACMSTREAMHEADER;
  826.                               fdwConvert: DWORD): MMRESULT;
  827.                               {$IFDEF WIN32}stdcall;{$ENDIF}
  828. const
  829.      ACM_STREAMCONVERTF_BLOCKALIGN = $00000004;
  830.      ACM_STREAMCONVERTF_START      = $00000010;
  831.      ACM_STREAMCONVERTF_END        = $00000020;
  833. {-----------------------------------------------------------------------}
  834. { acmStreamPrepareHeader                                                }
  835. {-----------------------------------------------------------------------}
  836. var
  837.    acmStreamPrepareHeader: function(has: THACMSTREAM; pash: PACMSTREAMHEADER;
  838.                                     fdwPrepare: DWORD): MMRESULT;
  839.                                     {$IFDEF WIN32}stdcall;{$ENDIF}
  841. {-----------------------------------------------------------------------}
  842. { acmStreamUnprepareHeader                                              }
  843. {-----------------------------------------------------------------------}
  844. var
  845.    acmStreamUnprepareHeader: function(has: THACMSTREAM; pash: PACMSTREAMHEADER;
  846.                                       fdwUnprepare: DWORD): MMRESULT;
  847.                                       {$IFDEF WIN32}stdcall;{$ENDIF}
  849. implementation
  851. var
  852.    ErrorMode: Cardinal;
  854. procedure NewExitProc; Far;
  855. begin
  856.      if ACMDLLHandle >= HINSTANCE_ERROR then FreeLibrary(ACMDLLHandle);
  857. end;
  859. Initialization
  860.      ErrorMode := SetErrorMode(SEM_NoOpenFileErrorBox);
  861.      {$IFDEF WIN32}
  862.      acmDLLHandle := LoadLibrary('MSACM32.DLL');
  863.      {$ELSE}
  864.      acmDLLHandle := LoadLibrary('MSACM.DLL');
  865.      {$ENDIF}
  866.      SetErrorMode(ErrorMode);
  867.      if abs(acmDLLHandle) >= HINSTANCE_ERROR then
  868.      begin
  869.         @acmGetVersion := GetProcAddress(acmDLLHandle,'acmGetVersion');
  871.         if (@acmGetVersion = nil) then
  872.         begin
  873.            FreeLibrary(acmDLLHandle);
  874.            acmDLLHandle := 0;
  875.            exit;
  876.         end;
  878.         acmDLLLoaded := True;
  879.         {$IFNDEF WIN32}
  880.         AddExitProc(NewExitProc);
  881.         {$ENDIF}
  883.         { if the version of the ACM is *NOT* V2.00 or greater, then     }
  884.         { all other API's are unavailable--so don't waste time trying   }
  885.         { to link to them.                                              }
  886.         if HiWord(acmGetVersion) < $0200 then exit;
  888.         { yipee! the ACM V2.00 or greater appears to be installed and   }
  889.         { happy with us--so link to the rest of the nifty cool API's.   }
  891.         @acmMetrics         := GetProcAddress(acmDLLHandle,'acmMetrics');
  893.         @acmDriverEnum      := GetProcAddress(acmDLLHandle,'acmDriverEnum');
  894.         {$IFDEF WIN32}
  895.         @acmDriverDetails   := GetProcAddress(acmDLLHandle,'acmDriverDetailsA');
  896.         @acmDriverAdd       := GetProcAddress(acmDLLHandle,'acmDriverAddA');
  897.         {$ELSE}
  898.         @acmDriverDetails   := GetProcAddress(acmDLLHandle,'acmDriverDetails');
  899.         @acmDriverAdd       := GetProcAddress(acmDLLHandle,'acmDriverAdd');
  900.         {$ENDIF}
  901.         @acmDriverRemove    := GetProcAddress(acmDLLHandle,'acmDriverRemove');
  902.         @acmDriverOpen      := GetProcAddress(acmDLLHandle,'acmDriverOpen');
  903.         @acmDriverClose     := GetProcAddress(acmDLLHandle,'acmDriverClose');
  904.         @acmDriverMessage   := GetProcAddress(acmDLLHandle,'acmDriverMessage');
  905.         @acmDriverID        := GetProcAddress(acmDLLHandle,'acmDriverID');
  906.         @acmDriverPriority  := GetProcAddress(acmDLLHandle,'acmDriverPriority');
  908.         {$IFDEF WIN32}
  909.         @acmFormatTagDetails:= GetProcAddress(acmDLLHandle,'acmFormatTagDetailsA');
  910.         @acmFormatTagEnum   := GetProcAddress(acmDLLHandle,'acmFormatTagEnumA');
  911.         @acmFormatChoose    := GetProcAddress(acmDLLHandle,'acmFormatChooseA');
  912.         @acmFormatDetails   := GetProcAddress(acmDLLHandle,'acmFormatDetailsA');
  913.         @acmFormatEnum      := GetProcAddress(acmDLLHandle,'acmFormatEnumA');
  914.         {$ELSE}
  915.         @acmFormatTagDetails:= GetProcAddress(acmDLLHandle,'acmFormatTagDetails');
  916.         @acmFormatTagEnum   := GetProcAddress(acmDLLHandle,'acmFormatTagEnum');
  917.         @acmFormatChoose    := GetProcAddress(acmDLLHandle,'acmFormatChoose');
  918.         @acmFormatDetails   := GetProcAddress(acmDLLHandle,'acmFormatDetails');
  919.         @acmFormatEnum      := GetProcAddress(acmDLLHandle,'acmFormatEnum');
  920.         {$ENDIF}
  921.         @acmFormatSuggest   := GetProcAddress(acmDLLHandle,'acmFormatSuggest');
  923.         {$IFDEF WIN32}
  924.         @acmFilterTagDetails:= GetProcAddress(acmDLLHandle,'acmFilterTagDetailsA');
  925.         @acmFilterTagEnum   := GetProcAddress(acmDLLHandle,'acmFilterTagEnumA');
  926.         @acmFilterChoose    := GetProcAddress(acmDLLHandle,'acmFilterChooseA');
  927.         @acmFilterDetails   := GetProcAddress(acmDLLHandle,'acmFilterDetailsA');
  928.         @acmFilterEnum      := GetProcAddress(acmDLLHandle,'acmFilterEnumA');
  929.         {$ELSE}
  930.         @acmFilterTagDetails:= GetProcAddress(acmDLLHandle,'acmFilterTagDetails');
  931.         @acmFilterTagEnum   := GetProcAddress(acmDLLHandle,'acmFilterTagEnum');
  932.         @acmFilterChoose    := GetProcAddress(acmDLLHandle,'acmFilterChoose');
  933.         @acmFilterDetails   := GetProcAddress(acmDLLHandle,'acmFilterDetails');
  934.         @acmFilterEnum      := GetProcAddress(acmDLLHandle,'acmFilterEnum');
  935.         {$ENDIF}
  937.         @acmStreamOpen      := GetProcAddress(acmDLLHandle,'acmStreamOpen');
  938.         @acmStreamClose     := GetProcAddress(acmDLLHandle,'acmStreamClose');
  939.         @acmStreamSize      := GetProcAddress(acmDLLHandle,'acmStreamSize');
  940.         @acmStreamConvert   := GetProcAddress(acmDLLHandle,'acmStreamConvert');
  941.         @acmStreamReset     := GetProcAddress(acmDLLHandle,'acmStreamReset');
  942.         @acmStreamPrepareHeader  := GetProcAddress(acmDLLHandle,'acmStreamPrepareHeader');
  943.         @acmStreamUnprepareHeader:= GetProcAddress(acmDLLHandle,'acmStreamUnprepareHeader');
  944.      end;
  945. {$IFDEF WIN32}
  946. Finalization
  947.      NewExitProc;
  948. {$ENDIF}
  949. end.