unamsacmapi.pas

Voice Commnucation Components for Delphi

(*
	----------------------------------------------
	Microsoft Audio Compression Manager (ACM) interface

	Original Delphi conversion by Armin Sander,
		Digital SimpleX / [e-mail]

	Additional programming:

	  Copyright (c) 2001, 2003 Lake of Soft, Ltd
			All Rights Reserved

	----------------------------------------------
	  modified by:
		Lake, Jan-Dec 2002
		Lake, Feb 2003
	----------------------------------------------
*)

{$I unaDef.inc}

unit
  unaMsAcmAPI;

interface

{DP:UNIT
  This unit contains Object Pascal version of MSAcm.h originally done by Armin Sander, Digital SimpleX / [e-mail]
  <BR />Most of the functions in this unit are documented in Microsoft Platform SDK.
}

uses
   Windows, unaTypes, MMSystem
{$IFDEF __SYSUTILS_H_ }
   , Math
{$ENDIF}   
   ;

   // C++Builders stuff

{$HPPEMIT '#include "MMREG.H"' }
{$HPPEMIT '#include "msacm.h"' }

type
  {$EXTERNALSYM WAVEFORMATEX }
  WAVEFORMATEX = tWAVEFORMATEX;

// some MMREG.H and MMSYSTEM.H includes missed from MMSystem.pas

const
  {$EXTERNALSYM WAVE_FILTER_UNKNOWN }
  WAVE_FILTER_UNKNOWN        	= $0000;
  {$EXTERNALSYM WAVE_FILTER_DEVELOPMENT }
  WAVE_FILTER_DEVELOPMENT	= $FFFF;

  {$EXTERNALSYM WAVE_FORMAT_DIRECT}
  WAVE_FORMAT_DIRECT        	= $0008;

type
  pWAVEFILTER = ^WAVEFILTER;
  {$EXTERNALSYM WAVEFILTER}
  WAVEFILTER = packed record
    cbStruct   : DWORD;        // Size of the filter in bytes
    dwFilterTag: DWORD;        // filter type
    fdwFilter  : DWORD;        // Flags for the filter (Universal Dfns)
    dwReserved : array[0..5] of DWORD;      // Reserved for system use
  end;

const
  {$EXTERNALSYM DRV_MAPPER_PREFERRED_INPUT_GET }
  DRV_MAPPER_PREFERRED_INPUT_GET = (DRV_USER + 0);
  {$EXTERNALSYM DRV_MAPPER_PREFERRED_OUTPUT_GET }
  DRV_MAPPER_PREFERRED_OUTPUT_GET = (DRV_USER + 2);

  {$EXTERNALSYM DRVM_MAPPER_STATUS }
  DRVM_MAPPER_STATUS = $2000;

  {$EXTERNALSYM WIDM_MAPPER_STATUS }
  WIDM_MAPPER_STATUS = (DRVM_MAPPER_STATUS + 0);

  {$EXTERNALSYM WAVEIN_MAPPER_STATUS_DEVICE }
  WAVEIN_MAPPER_STATUS_DEVICE = 0;
  {$EXTERNALSYM WAVEIN_MAPPER_STATUS_MAPPED }
  WAVEIN_MAPPER_STATUS_MAPPED = 1;
  {$EXTERNALSYM WAVEIN_MAPPER_STATUS_FORMAT }
  WAVEIN_MAPPER_STATUS_FORMAT = 2;

  {$EXTERNALSYM WODM_MAPPER_STATUS }
  WODM_MAPPER_STATUS = (DRVM_MAPPER_STATUS + 0);

  {$EXTERNALSYM WAVEOUT_MAPPER_STATUS_DEVICE }
  WAVEOUT_MAPPER_STATUS_DEVICE = 0;
  {$EXTERNALSYM WAVEOUT_MAPPER_STATUS_MAPPED }
  WAVEOUT_MAPPER_STATUS_MAPPED = 1;
  {$EXTERNALSYM WAVEOUT_MAPPER_STATUS_FORMAT }
  WAVEOUT_MAPPER_STATUS_FORMAT = 2;

// MSACM.H

//--------------------------------------------------------------------------;
//
//  ACM General API's and Defines
//
//

type
  {
	there are four types of 'handles' used by the ACM. the first three
	are unique types that define specific objects:

	HACMDRIVERID: used to _identify_ an ACM driver. this identifier can be
	used to _open_ the driver for querying details, etc about the driver.
  }
  pHACMDRIVERID = ^HACMDRIVERID;
  {$EXTERNALSYM HACMDRIVERID }
  HACMDRIVERID  = tHandle;

  {
	HACMDRIVER: used to manage a driver (codec, filter, etc). this handle
	is much like a handle to other media drivers -- you use it to send
	messages to the converter, query for capabilities, etc.
  }
  pHACMDRIVER = ^HACMDRIVER;
  {$EXTERNALSYM HACMDRIVER }
  HACMDRIVER  = tHandle;

  {
	HACMSTREAM: used to manage a 'stream' (conversion channel) with the
	ACM. you use a stream handle to convert data from one format/type
	to another -- much like dealing with a file handle.
  }
  pHACMSTREAM = ^HACMSTREAM;
  {$EXTERNALSYM HACMSTREAM }
  HACMSTREAM  = tHandle;

  {
	the fourth handle type is a generic type used on ACM functions that
	can accept two or more of the above handle types (for example the
	acmMetrics and acmDriverID functions).

	HACMOBJ: used to identify ACM objects. this handle is used on functions
	that can accept two or more ACM handle types.
  }
  pHACMOBJ = ^HACMOBJ;
  {$EXTERNALSYM HACMOBJ }
  HACMOBJ  = tHandle;

const
  {
	ACM Error Codes

	Note that these error codes are specific errors that apply to the ACM
	directly--general errors are defined as MMSYSERR_*.
  }
  {$EXTERNALSYM ACMERR_BASE }
  ACMERR_BASE         	= (512);
  {$EXTERNALSYM ACMERR_NOTPOSSIBLE }
  ACMERR_NOTPOSSIBLE	= (ACMERR_BASE + 0);
  {$EXTERNALSYM ACMERR_BUSY }
  ACMERR_BUSY         	= (ACMERR_BASE + 1);
  {$EXTERNALSYM ACMERR_UNPREPARED }
  ACMERR_UNPREPARED   	= (ACMERR_BASE + 2);
  {$EXTERNALSYM ACMERR_CANCELED }
  ACMERR_CANCELED     	= (ACMERR_BASE + 3);

  {
	ACM Window Messages

	These window messages are sent by the ACM or ACM drivers to notify
	applications of events.

	Note that these window message numbers will also be defined in
	mmsystem.
  }
  {$EXTERNALSYM MM_ACM_OPEN }
  MM_ACM_OPEN        	= (MM_STREAM_OPEN);  // conversion callback messages
  {$EXTERNALSYM MM_ACM_CLOSE }
  MM_ACM_CLOSE       	= (MM_STREAM_CLOSE);
  {$EXTERNALSYM MM_ACM_DONE }
  MM_ACM_DONE		= (MM_STREAM_DONE);

  {
	the ACM version is a 32 bit number that is broken into three parts as
	follows:

		bits 24 - 31:   8 bit _major_ version number
		bits 16 - 23:   8 bit _minor_ version number
		bits  0 - 15:   16 bit build number

	this is then displayed as follows:

		bMajor = (BYTE)(dwVersion >> 24)
		bMinor = (BYTE)(dwVersion >> 16) &
		wBuild = LOWORD(dwVersion)
  }
{$EXTERNALSYM acm_GetVersion}
function acm_getVersion: DWORD; stdcall;

{$EXTERNALSYM acm_Metrics }
function acm_metrics(hao: HACMOBJ; uMetric: UINT; var pMetric): MMRESULT; stdcall;

const
  {$EXTERNALSYM ACM_METRIC_COUNT_DRIVERS }
  ACM_METRIC_COUNT_DRIVERS            = 1;
  {$EXTERNALSYM ACM_METRIC_COUNT_CODECS }
  ACM_METRIC_COUNT_CODECS             = 2;
  {$EXTERNALSYM ACM_METRIC_COUNT_CONVERTERS }
  ACM_METRIC_COUNT_CONVERTERS         = 3;
  {$EXTERNALSYM ACM_METRIC_COUNT_FILTERS }
  ACM_METRIC_COUNT_FILTERS            = 4;
  {$EXTERNALSYM ACM_METRIC_COUNT_DISABLED }
  ACM_METRIC_COUNT_DISABLED           = 5;
  {$EXTERNALSYM ACM_METRIC_COUNT_HARDWARE }
  ACM_METRIC_COUNT_HARDWARE           = 6;
  {$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_DRIVERS }
  ACM_METRIC_COUNT_LOCAL_DRIVERS      = 20;
  {$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_CODECS }
  ACM_METRIC_COUNT_LOCAL_CODECS       = 21;
  {$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_CONVERTERS }
  ACM_METRIC_COUNT_LOCAL_CONVERTERS   = 22;
  {$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_FILTERS }
  ACM_METRIC_COUNT_LOCAL_FILTERS      = 23;
  {$EXTERNALSYM ACM_METRIC_COUNT_LOCAL_DISABLED }
  ACM_METRIC_COUNT_LOCAL_DISABLED     = 24;

  {$EXTERNALSYM ACM_METRIC_HARDWARE_WAVE_INPUT }
  ACM_METRIC_HARDWARE_WAVE_INPUT      = 30;
  {$EXTERNALSYM ACM_METRIC_HARDWARE_WAVE_OUTPUT }
  ACM_METRIC_HARDWARE_WAVE_OUTPUT     = 31;
  {$EXTERNALSYM ACM_METRIC_MAX_SIZE_FORMAT }
  ACM_METRIC_MAX_SIZE_FORMAT          = 50;
  {$EXTERNALSYM ACM_METRIC_MAX_SIZE_FILTER }
  ACM_METRIC_MAX_SIZE_FILTER          = 51;
  {$EXTERNALSYM ACM_METRIC_DRIVER_SUPPORT }
  ACM_METRIC_DRIVER_SUPPORT           = 100;
  {$EXTERNALSYM ACM_METRIC_DRIVER_PRIORITY }
  ACM_METRIC_DRIVER_PRIORITY          = 101;

//--------------------------------------------------------------------------
//
//  ACM Drivers
//

type
  {$EXTERNALSYM ACMDRIVERENUMCB }
  ACMDRIVERENUMCB = function(hadid: HACMDRIVERID; dwInstance: DWORD; fdwSupport: DWORD): Windows.BOOL; stdcall;

{$EXTERNALSYM acm_DriverEnum }
function acm_driverEnum(fnCallback: ACMDRIVERENUMCB; dwInstance: DWORD; fdwEnum: DWORD): MMRESULT; stdcall;

const
  {$EXTERNALSYM ACM_DRIVERENUMF_NOLOCAL }
  ACM_DRIVERENUMF_NOLOCAL  = $40000000;
  {$EXTERNALSYM ACM_DRIVERENUMF_DISABLED }
  ACM_DRIVERENUMF_DISABLED = $80000000;

{$EXTERNALSYM acm_DriverID }
function acm_driverID(hao: HACMOBJ; var phadid: HACMDRIVERID; fdwDriverID: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_DriverAddA }
function acm_driverAddA(var phadid: HACMDRIVERID; hinstModule: HINST; lParam: LPARAM; dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_DriverAddW }
function acm_driverAddW(var phadid: HACMDRIVERID; hinstModule: HINST; lParam: LPARAM; dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_DriverAdd }
function acm_driverAdd (var phadid: HACMDRIVERID; hinstModule: HINST; lParam: LPARAM; dwPriority: DWORD; fdwAdd: DWORD): MMRESULT; stdcall;

const
  {$EXTERNALSYM ACM_DRIVERADDF_FUNCTION }
  ACM_DRIVERADDF_FUNCTION   = $00000003;  // lParam is a procedure
  {$EXTERNALSYM ACM_DRIVERADDF_NOTIFYHWND }
  ACM_DRIVERADDF_NOTIFYHWND = $00000004;  // lParam is notify hwnd
  {$EXTERNALSYM ACM_DRIVERADDF_TYPEMASK }
  ACM_DRIVERADDF_TYPEMASK   = $00000007;  // driver type mask
  {$EXTERNALSYM ACM_DRIVERADDF_LOCAL }
  ACM_DRIVERADDF_LOCAL      = $00000000;  // is local to current task
  {$EXTERNALSYM ACM_DRIVERADDF_GLOBAL }
  ACM_DRIVERADDF_GLOBAL     = $00000008;  // is global

type
  {
	prototype for ACM driver procedures that are installed as _functions_
	or _notifations_ instead of as a standalone installable driver.
  }
  {$EXTERNALSYM ACMDRIVERPROC }
  ACMDRIVERPROC = function(a_0: DWORD; a_1: HACMDRIVERID; a_2: UINT; a_3: LPARAM; a_4: LPARAM): LRESULT; stdcall;
  {$EXTERNALSYM LPACMDRIVERPROC }
  LPACMDRIVERPROC = ^ACMDRIVERPROC;

{$EXTERNALSYM acm_DriverRemove }
function acm_driverRemove(hadid: HACMDRIVERID; fdwRemove: DWORD): MMRESULT; stdcall;
{$EXTERNALSYM acm_DriverOpen }