Ultima Input Devices Driver

12/10/2021by admin
  • Download drivers for Apple input device other devices (Windows 10 x64), or install DriverPack Solution software for automatic driver download and update. Are you tired of looking for the drivers for your devices? DriverPack Online will find and install the drivers you need automatically.
  • Workaround: To mitigate the safeguard, you might need to check with your device manufacturer (OEM) to see if an updated driver is available and install it. If updated drivers are not available for your device and you are offered Windows 10, version 2004 or Windows 10, version 20H2, a small number of devices might roll back to the previous version of Windows 10 when attempting to update.

/***************************************************************************/
/* */
/* ftmodapi.h */
/* */
/* FreeType modules public interface (specification). */
/* */
/* Copyright 1996-2015 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/

#ifndef __FTMODAPI_H__
#define __FTMODAPI_H__

The IOCTLHIDREADREPORT request transfers an input report from a HIDClass device into the HID class driver's buffer. IOCTLHIDSENDIDLENOTIFICATIONREQUEST The IOCTLHIDSENDIDLENOTIFICATIONREQUEST control code is the IOCTL of the idle notification request IRP that HIDClass sends to HID mini drivers, such as HIDUSB, to inform the bus.

#include
#include FT_FREETYPE_H

#ifdef FREETYPE_H
#error “freetype.h of FreeType 1 has been loaded!”
#error “Please fix the directory search order for header files”
#error “so that freetype.h of FreeType 2 is found first.”
#endif

FT_BEGIN_HEADER

/*************************************************************************/
/* */
/*

*/
/* module_management */
/* */
/* */<br> /* Module Management */<br> /* */<br> /* <Abstract> */<br> /* How to add, upgrade, remove, and control modules from FreeType. */<br> /* */<br> /* <Description> */<br> /* The definitions below are used to manage modules within FreeType. */<br> /* Modules can be added, upgraded, and removed at runtime. */<br> /* Additionally, some module properties can be controlled also. */<br> /* */<br> /* Here is a list of possible values of the `module_name’ field in */<br> /* the @FT_Module_Class structure. */<br> /* */<br> /* { */<br> /* autofitter */<br> /* bdf */<br> /* cff */<br> /* gxvalid */<br> /* otvalid */<br> /* pcf */<br> /* pfr */<br> /* psaux */<br> /* pshinter */<br> /* psnames */<br> /* raster1 */<br> /* sfnt */<br> /* smooth, smooth-lcd, smooth-lcdv */<br> /* truetype */<br> /* type1 */<br> /* type42 */<br> /* t1cid */<br> /* winfonts */<br> /* } */<br> /* */<br> /* Note that the FreeType Cache sub-system is not a FreeType module. */<br> /* */<br> /* <Order> */<br> /* FT_Module */<br> /* FT_Module_Constructor */<br> /* FT_Module_Destructor */<br> /* FT_Module_Requester */<br> /* FT_Module_Class */<br> /* */<br> /* FT_Add_Module */<br> /* FT_Get_Module */<br> /* FT_Remove_Module */<br> /* FT_Add_Default_Modules */<br> /* */<br> /* FT_Property_Set */<br> /* FT_Property_Get */<br> /* */<br> /* FT_New_Library */<br> /* FT_Done_Library */<br> /* FT_Reference_Library */<br> /* */<br> /* FT_Renderer */<br> /* FT_Renderer_Class */<br> /* */<br> /* FT_Get_Renderer */<br> /* FT_Set_Renderer */<br> /* */<br> /* FT_Set_Debug_Hook */<br> /* */<br> /*************************************************************************/</p><p> /* module bit flags */<br>#define FT_MODULE_FONT_DRIVER 1 /* this module is a font driver */<br>#define FT_MODULE_RENDERER 2 /* this module is a renderer */<br>#define FT_MODULE_HINTER 4 /* this module is a glyph hinter */<br>#define FT_MODULE_STYLER 8 /* this module is a styler */</p><p>#define FT_MODULE_DRIVER_SCALABLE 0x100 /* the driver supports */<br> /* scalable fonts */<br>#define FT_MODULE_DRIVER_NO_OUTLINES 0x200 /* the driver does not */<br> /* support vector outlines */<br>#define FT_MODULE_DRIVER_HAS_HINTER 0x400 /* the driver provides its */<br> /* own hinter */</p><p> /* deprecated values */<br>#define ft_module_font_driver FT_MODULE_FONT_DRIVER<br>#define ft_module_renderer FT_MODULE_RENDERER<br>#define ft_module_hinter FT_MODULE_HINTER<br>#define ft_module_styler FT_MODULE_STYLER</p><p>#define ft_module_driver_scalable FT_MODULE_DRIVER_SCALABLE<br>#define ft_module_driver_no_outlines FT_MODULE_DRIVER_NO_OUTLINES<br>#define ft_module_driver_has_hinter FT_MODULE_DRIVER_HAS_HINTER</p><p> typedef FT_Pointer FT_Module_Interface;</p><p> /*************************************************************************/<br> /* */<br> /* <FuncType> */<br> /* FT_Module_Constructor */<br> /* */<br> /* <Description> */<br> /* A function used to initialize (not create) a new module object. */<br> /* */<br> /* <Input> */<br> /* module :: The module to initialize. */<br> /* */<br> typedef FT_Error<br> (*FT_Module_Constructor)( FT_Module module );</p><p> /*************************************************************************/<br> /* */<br> /* <FuncType> */<br> /* FT_Module_Destructor */<br> /* */<br> /* <Description> */<br> /* A function used to finalize (not destroy) a given module object. */<br> /* */<br> /* <Input> */<br> /* module :: The module to finalize. */<br> /* */<br> typedef void<br> (*FT_Module_Destructor)( FT_Module module );</p><p> /*************************************************************************/<br> /* */<br> /* <FuncType> */<br> /* FT_Module_Requester */<br> /* */<br> /* <Description> */<br> /* A function used to query a given module for a specific interface. */<br> /* */<br> /* <Input> */<br> /* module :: The module to be searched. */<br> /* */<br> /* name :: The name of the interface in the module. */<br> /* */<br> typedef FT_Module_Interface<br> (*FT_Module_Requester)( FT_Module module,<br> const char* name );</p><p> /*************************************************************************/<br> /* */<br> /* <Struct> */<br> /* FT_Module_Class */<br> /* */<br> /* <Description> */<br> /* The module class descriptor. */<br> /* */<br> /* <Fields> */<br> /* module_flags :: Bit flags describing the module. */<br> /* */<br> /* module_size :: The size of one module object/instance in */<br> /* bytes. */<br> /* */<br> /* module_name :: The name of the module. */<br> /* */<br> /* module_version :: The version, as a 16.16 fixed number */<br> /* (major.minor). */<br> /* */<br> /* module_requires :: The version of FreeType this module requires, */<br> /* as a 16.16 fixed number (major.minor). Starts */<br> /* at version 2.0, i.e., 0x20000. */<br> /* */<br> /* module_init :: The initializing function. */<br> /* */<br> /* module_done :: The finalizing function. */<br> /* */<br> /* get_interface :: The interface requesting function. */<br> /* */<br> typedef struct FT_Module_Class_<br> {<br> FT_ULong module_flags;<br> FT_Long module_size;<br> const FT_String* module_name;<br> FT_Fixed module_version;<br> FT_Fixed module_requires;</p><p> const void* module_interface;</p><p> FT_Module_Constructor module_init;<br> FT_Module_Destructor module_done;<br> FT_Module_Requester get_interface;</p><p> } FT_Module_Class;</p><p> /*************************************************************************/<br> /* */<br> /* <Function> */<br> /* FT_Add_Module */<br> /* */<br> /* <Description> */<br> /* Add a new module to a given library instance. */<br> /* */<br> /* <InOut> */<br> /* library :: A handle to the library object. */<br> /* */<br> /* <Input> */<br> /* clazz :: A pointer to class descriptor for the module. */<br> /* */<br> /* <Return> */<br> /* FreeType error code. 0~means success. */<br> /* */<br> /* <Note> */<br> /* An error will be returned if a module already exists by that name, */<br> /* or if the module requires a version of FreeType that is too great. */<br> /* */<br> FT_EXPORT( FT_Error )<br> FT_Add_Module( FT_Library library,<br> const FT_Module_Class* clazz );</p><p> /*************************************************************************/<br> /* */<br> /* <Function> */<br> /* FT_Get_Module */<br> /* */<br> /* <Description> */<br> /* Find a module by its name. */<br> /* */<br> /* <Input> */<br> /* library :: A handle to the library object. */<br> /* */<br> /* module_name :: The module’s name (as an ASCII string). */<br> /* */<br> /* <Return> */<br> /* A module handle. 0~if none was found. */<br> /* */<br> /* <Note> */<br> /* FreeType’s internal modules aren’t documented very well, and you */<br> /* should look up the source code for details. */<br> /* */<br> FT_EXPORT( FT_Module )<br> FT_Get_Module( FT_Library library,<br> const char* module_name );</p><p> /*************************************************************************/<br> /* */<br> /* <Function> */<br> /* FT_Remove_Module */<br> /* */<br> /* <Description> */<br> /* Remove a given module from a library instance. */<br> /* */<br> /* <InOut> */<br> /* library :: A handle to a library object. */<br> /* */<br> /* <Input> */<br> /* module :: A handle to a module object. */<br> /* */<br> /* <Return> */<br> /* FreeType error code. 0~means success. */<br> /* */<br> /* <Note> */<br> /* The module object is destroyed by the function in case of success. */<br> /* */<br> FT_EXPORT( FT_Error )<br> FT_Remove_Module( FT_Library library,<br> FT_Module module );</p><p> /**********************************************************************<br> *<br> * @function:<br> * FT_Property_Set<br> *<br> * @description:<br> * Set a property for a given module.<br> *<br> * @input:<br> * library ::<br> * A handle to the library the module is part of.<br> *<br> * module_name ::<br> * The module name.<br> *<br> * property_name ::<br> * The property name. Properties are described in the `Synopsis’<br> * subsection of the module’s documentation.<br> *<br> * Note that only a few modules have properties.<br> *<br> * value ::<br> * A generic pointer to a variable or structure that gives the new<br> * value of the property. The exact definition of `value’ is<br> * dependent on the property; see the `Synopsis’ subsection of the<br> * module’s documentation.<br> *<br> * @return:<br> * FreeType error code. 0~means success.<br> *<br> * @note:<br> * If `module_name’ isn’t a valid module name, or `property_name’<br> * doesn’t specify a valid property, or if `value’ doesn’t represent a<br> * valid value for the given property, an error is returned.<br> *<br> * The following example sets property `bar’ (a simple integer) in<br> * module `foo’ to value~1.<br> *<br> * {<br> * FT_UInt bar;<br> *<br> *<br> * bar = 1;<br> * FT_Property_Set( library, “foo”, “bar”, &bar );<br> * }<br> *<br> * Note that the FreeType Cache sub-system doesn’t recognize module<br> * property changes. To avoid glyph lookup confusion within the cache<br> * you should call @FTC_Manager_Reset to completely flush the cache if<br> * a module property gets changed after @FTC_Manager_New has been<br> * called.<br> *<br> * It is not possible to set properties of the FreeType Cache<br> * sub-system itself with FT_Property_Set; use @FTC_Property_Set<br> * instead.<br> *<br> * @since:<br> * 2.4.11<br> *<br> */<br> FT_EXPORT( FT_Error )<br> FT_Property_Set( FT_Library library,<br> const FT_String* module_name,<br> const FT_String* property_name,<br> const void* value );</p><p> /**********************************************************************<br> *<br> * @function:<br> * FT_Property_Get<br> *<br> * @description:<br> * Get a module’s property value.<br> *<br> * @input:<br> * library ::<br> * A handle to the library the module is part of.<br> *<br> * module_name ::<br> * The module name.<br> *<br> * property_name ::<br> * The property name. Properties are described in the `Synopsis’<br> * subsection of the module’s documentation.<br> *<br> * @inout:<br> * value ::<br> * A generic pointer to a variable or structure that gives the<br> * value of the property. The exact definition of `value’ is<br> * dependent on the property; see the `Synopsis’ subsection of the<br> * module’s documentation.<br> *<br> * @return:<br> * FreeType error code. 0~means success.<br> *<br> * @note:<br> * If `module_name’ isn’t a valid module name, or `property_name’<br> * doesn’t specify a valid property, or if `value’ doesn’t represent a<br> * valid value for the given property, an error is returned.<br> *<br> * The following example gets property `baz’ (a range) in module `foo’.<br> *<br> * {<br> * typedef range_<br> * {<br> * FT_Int32 min;<br> * FT_Int32 max;<br> *<br> * } range;<br> *<br> * range baz;<br> *<br> *<br> * FT_Property_Get( library, “foo”, “baz”, &baz );<br> * }<br> *<br> * It is not possible to retrieve properties of the FreeType Cache<br> * sub-system with FT_Property_Get; use @FTC_Property_Get instead.<br> *<br> * @since:<br> * 2.4.11<br> *<br> */<br> FT_EXPORT( FT_Error )<br> FT_Property_Get( FT_Library library,<br> const FT_String* module_name,<br> const FT_String* property_name,<br> void* value );</p><p> /*************************************************************************/<br> /* */<br> /* <Function> */<br> /* FT_Reference_Library */<br> /* */<br> /* <Description> */<br> /* A counter gets initialized to~1 at the time an @FT_Library */<br> /* structure is created. This function increments the counter. */<br> /* @FT_Done_Library then only destroys a library if the counter is~1, */<br> /* otherwise it simply decrements the counter. */<br> /* */<br> /* This function helps in managing life-cycles of structures that */<br> /* reference @FT_Library objects. */<br> /* */<br> /* <Input> */<br> /* library :: A handle to a target library object. */<br> /* */<br> /* <Return> */<br> /* FreeType error code. 0~means success. */<br> /* */<br> /* <Since> */<br> /* 2.4.2 */<br> /* */<br> FT_EXPORT( FT_Error )<br> FT_Reference_Library( FT_Library library );</p><p> /*************************************************************************/<br> /* */<br> /* <Function> */<br> /* FT_New_Library */<br> /* */<br> /* <Description> */<br> /* This function is used to create a new FreeType library instance */<br> /* from a given memory object. It is thus possible to use libraries */<br> /* with distinct memory allocators within the same program. Note, */<br> /* however, that the used @FT_Memory structure is expected to remain */<br> /* valid for the life of the @FT_Library object. */<br> /* */<br> /* Normally, you would call this function (followed by a call to */<br> /* @FT_Add_Default_Modules or a series of calls to @FT_Add_Module) */<br> /* instead of @FT_Init_FreeType to initialize the FreeType library. */<br> /* */<br> /* Don’t use @FT_Done_FreeType but @FT_Done_Library to destroy a */<br> /* library instance. */<br> /* */<br> /* <Input> */<br> /* memory :: A handle to the original memory object. */<br> /* */<br> /* <Output> */<br> /* alibrary :: A pointer to handle of a new library object. */<br> /* */<br> /* <Return> */<br> /* FreeType error code. 0~means success. */<br> /* */<br> /* <Note> */<br> /* See the discussion of reference counters in the description of */<br> /* @FT_Reference_Library. */<br> /* */<br> FT_EXPORT( FT_Error )<br> FT_New_Library( FT_Memory memory,<br> FT_Library *alibrary );</p><p> /*************************************************************************/<br> /* */<br> /* <Function> */<br> /* FT_Done_Library */<br> /* */<br> /* <Description> */<br> /* Discard a given library object. This closes all drivers and */<br> /* discards all resource objects. */<br> /* */<br> /* <Input> */<br> /* library :: A handle to the target library. */<br> /* */<br> /* <Return> */<br> /* FreeType error code. 0~means success. */<br> /* */<br> /* <Note> */<br> /* See the discussion of reference counters in the description of */<br> /* @FT_Reference_Library. */<br> /* */<br> FT_EXPORT( FT_Error )<br> FT_Done_Library( FT_Library library );</p><p> /* */</p><p> typedef void<br> (*FT_DebugHook_Func)( void* arg );</p><p> /*************************************************************************/<br> /* */<br> /* <Function> */<br> /* FT_Set_Debug_Hook */<br> /* */<br> /* <Description> */<br> /* Set a debug hook function for debugging the interpreter of a font */<br> /* format. */<br> /* */<br> /* <InOut> */<br> /* library :: A handle to the library object. */<br> /* */<br> /* <Input> */<br> /* hook_index :: The index of the debug hook. You should use the */<br> /* values defined in `ftobjs.h’, e.g., */<br> /* `FT_DEBUG_HOOK_TRUETYPE’. */<br> /* */<br> /* debug_hook :: The function used to debug the interpreter. */<br> /* */<br> /* <Note> */<br> /* Currently, four debug hook slots are available, but only two (for */<br> /* the TrueType and the Type~1 interpreter) are defined. */<br> /* */<br> /* Since the internal headers of FreeType are no longer installed, */<br> /* the symbol `FT_DEBUG_HOOK_TRUETYPE’ isn’t available publicly. */<br> /* This is a bug and will be fixed in a forthcoming release. */<br> /* */<br> FT_EXPORT( void )<br> FT_Set_Debug_Hook( FT_Library library,<br> FT_UInt hook_index,<br> FT_DebugHook_Func debug_hook );</p><p> /*************************************************************************/<br> /* */<br> /* <Function> */<br> /* FT_Add_Default_Modules */<br> /* */<br> /* <Description> */<br> /* Add the set of default drivers to a given library object. */<br> /* This is only useful when you create a library object with */<br> /* @FT_New_Library (usually to plug a custom memory manager). */<br> /* */<br> /* <InOut> */<br> /* library :: A handle to a new library object. */<br> /* */<br> FT_EXPORT( void )<br> FT_Add_Default_Modules( FT_Library library );</p><p> /**************************************************************************<br> *<br> * @section:<br> * truetype_engine<br> *<br> * @title:<br> * The TrueType Engine<br> *<br> * @abstract:<br> * TrueType bytecode support.<br> *<br> * @description:<br> * This section contains a function used to query the level of TrueType<br> * bytecode support compiled in this version of the library.<br> *<br> */</p><p> /**************************************************************************<br> *<br> * @enum:<br> * FT_TrueTypeEngineType<br> *<br> * @description:<br> * A list of values describing which kind of TrueType bytecode<br> * engine is implemented in a given FT_Library instance. It is used<br> * by the @FT_Get_TrueType_Engine_Type function.<br> *<br> * @values:<br> * FT_TRUETYPE_ENGINE_TYPE_NONE ::<br> * The library doesn’t implement any kind of bytecode interpreter.<br> *<br> * FT_TRUETYPE_ENGINE_TYPE_UNPATENTED ::<br> * The library implements a bytecode interpreter that doesn’t<br> * support the patented operations of the TrueType virtual machine.<br> *<br> * Its main use is to load certain Asian fonts that position and<br> * scale glyph components with bytecode instructions. It produces<br> * bad output for most other fonts.<br> *<br> * FT_TRUETYPE_ENGINE_TYPE_PATENTED ::<br> * The library implements a bytecode interpreter that covers<br> * the full instruction set of the TrueType virtual machine (this<br> * was governed by patents until May 2010, hence the name).<br> *<br> * @since:<br> * 2.2<br> *<br> */<br> typedef enum FT_TrueTypeEngineType_<br> {<br> FT_TRUETYPE_ENGINE_TYPE_NONE = 0,<br> FT_TRUETYPE_ENGINE_TYPE_UNPATENTED,<br> FT_TRUETYPE_ENGINE_TYPE_PATENTED</p><p> } FT_TrueTypeEngineType;</p><p> /**************************************************************************<br> *<br> * @func:<br> * FT_Get_TrueType_Engine_Type<br> *<br> * @description:<br> * Return an @FT_TrueTypeEngineType value to indicate which level of<br> * the TrueType virtual machine a given library instance supports.<br> *<br> * @input:<br> * library ::<br> * A library instance.<br> *<br> * @return:<br> * A value indicating which level is supported.<br> *<br> * @since:<br> * 2.2<br> *<br> */<br> FT_EXPORT( FT_TrueTypeEngineType )<br> FT_Get_TrueType_Engine_Type( FT_Library library );</p><p> /* */</p><p>FT_END_HEADER</p><p>#endif /* __FTMODAPI_H__ */</p><p>/* END */</p><div><div><h3>Share this:</h3><div><ul><li><a href='https://powcoder.com/2021/02/13/cs%e4%bb%a3%e8%80%83%e8%ae%a1%e7%ae%97%e6%9c%ba%e4%bb%a3%e5%86%99-cache-interpreter/?share=twitter' target='_blank'><span></span><span>Click to share on Twitter (Opens in new window)</span></a></li><li><a href='https://powcoder.com/2021/02/13/cs%e4%bb%a3%e8%80%83%e8%ae%a1%e7%ae%97%e6%9c%ba%e4%bb%a3%e5%86%99-cache-interpreter/?share=facebook' target='_blank'><span></span><span>Click to share on Facebook (Opens in new window)</span></a></li><li></li></ul></div></div></div><div><h3>Like this:</h3><div><span><span>Like</span></span><span>Loading...</span></div><span></span><a></a></div><div ><h3><em>Related</em></h3></div></div><!-- .entry-content --><!-- .site-footer --></div><!-- #page --><div><div><span>%d</span> bloggers like this:</div><ul></ul></div> </body>
-->

Application programs rely on a combination of user-mode and kernel-mode components to capture (input) and render (output) wave streams. A wave stream is a digital-audio stream whose data format is described by a WAVEFORMATEX or WAVEFORMATEXTENSIBLE structure.

An application can use either of the following software interfaces for wave rendering and capture:

  • Microsoft Windows Multimedia waveOutXxx and waveInXxx functions

  • DirectSound and DirectSoundCapture APIs

The behavior of the waveOutXxx and waveInXxx functions is based on the capabilities of legacy wave drivers and devices. Beginning with Windows 98, the WDMAud system driver translates calls to these functions into commands to WDM audio drivers. However, by emulating the behavior of older software and hardware, the waveOutXxx functions sacrifice the 3-D sound effects and hardware acceleration that are now available through the DirectSound API. For more information about DirectSound and the Windows Multimedia wave functions, see the Microsoft Windows SDK documentation.

DirectSound and the Windows Multimedia wave functions are clients of the SysAudio system driver, which builds the audio filter graphs that process the wave and DirectSound streams. Graph building is transparent to the applications that use these software interfaces.

Wave Components

The following figure shows the user-mode and kernel-mode components that a wave application uses to render or capture a digital audio stream consisting of wave PCM data.

The rendering components appear on the left side of the preceding figure, and the capture components appear on the right. The boxes representing the wave miniport driver are darkened to indicate that these are vendor-supplied components. The other components in the figure are system-supplied.

At the top left of the figure, the wave-rendering (or 'wave-out') application interfaces to the WDM audio drivers through the waveOutXxx functions, which are implemented in the user-mode WinMM system component, Winmm.dll. The application reads blocks of wave audio samples from a file and calls the waveOutWrite function to render them.

WDMAud, which consists of both user-mode and kernel-mode components (Wdmaud.drv and Wdmaud.sys), buffers the wave data from the waveOutWrite call and outputs the wave stream to the KMixer system driver, which appears below WDMAud in the figure.

Ultima Input Devices Drivers

Ultima Input Devices Driver

KMixer is a system component that receives wave PCM streams from one or more sources and mixes them together to form a single output stream, which is also in wave PCM format.

KMixer outputs a wave stream to a WaveCyclic or WavePci device, whose port and miniport drivers appear below KMixer on the left side of the preceding figure. The miniport driver binds itself to the port driver to form the wave filter that represents the underlying audio rendering device. A typical rendering device outputs an analog signal that drives a set of speakers or an external audio unit. A rendering device might also output digital audio through an S/PDIF connector. For more information about WaveCyclic and WavePci, see Wave Filters.

Alternatively, KMixer can pass its output stream to a USB audio device, which is controlled by the USBAudio class system driver (not shown in figure), instead of a WaveCyclic or WavePci device.

An adapter driver creates an instance of a WaveCyclic or WavePci port driver by calling PcNewPort with a GUID value of CLSID_PortWaveCyclic or CLSID_PortWavePci, respectively.

Ultima Input Devices Driver

Ultima Input Devices Driver

The right side of the preceding figure shows the components that are needed to support an application that captures wave data to a file. The wave-capture (or 'wave-in') application communicates with the WDM audio drivers through the waveInXxx functions, which are implemented in the WinMM system component.

At the lower right corner of the figure, the wave-capture device is controlled by wave miniport and port drivers. The port and miniport drivers, which can be of type WaveCyclic or WavePci, bind together to form a wave filter that represents the capture device. This device typically captures an analog signal from a microphone or other audio source and converts it to a wave PCM stream. The device might also input a digital audio stream through an S/PDIF connector.

The wave port driver outputs its wave stream either to KMixer or to WDMAud directly. The stream must pass through KMixer if it needs to be sample-rate converted before WDMAud receives it. A system that performs simultaneous rendering and capture of audio streams might require two instances of KMixer, as shown in the figure. Note that SysAudio automatically creates these instances as they are needed.

Alternatively, the source of the captured wave stream can be a USB audio device instead of a WaveCyclic or WavePci device. In this case, the USBAudio driver (not shown in figure) passes the stream to KMixer.

Regardless of whether the wave stream is captured by a USB device or by a WaveCyclic or WavePci device, KMixer performs sample-rate conversion on the stream, if needed, but does no mixing with other streams. KMixer outputs the resulting stream to Wdmaud.sys, the kernel-mode half of the WDMAud system driver. The user-mode half, Wdmaud.drv, outputs the wave stream to the application program through the waveInXxx functions, which are implemented in Winmm.dll. Finally, at the top of the figure, the wave-capture application writes the wave data to a file.

At the time that the wave-capture application calls the waveInOpen function to open the capture stream, it passes in a pointer to its callback routine. When a wave-capture event occurs, the operating system calls the callback routine with a buffer containing the next block of wave samples from the capture device. In response to the callback, the application writes the next block of wave data to the file.

Devices

Ultima Input Devices Driver Device

DirectSound Components

The following figure shows the user-mode and kernel-mode components that are used by a DirectSound application program to render or capture wave data.

Ultima Input Devices Driver Touchpad

The rendering components are shown in the left half of the preceding figure, and the capture components appear on the right. The wave miniport drivers are shown as darkened boxes to indicate that they are vendor-supplied components. The other components in the figure are system-supplied.

At the top left of the figure, a DirectSound application loads wave data from a file to a sound buffer that the user-mode DirectSound system component (Dsound.dll) manages. This component sends a wave stream to a WaveCyclic or WavePci device, whose port and miniport drivers appear at the lower left in the figure. If a hardware mixer pin is available on the device, the stream passes directly to the wave port driver, bypassing KMixer. Otherwise, the stream first passes through KMixer, which mixes it with any other simultaneously playing streams. KMixer outputs the mixed stream to the port driver.

Ultima Input Devices Driver Updater

As before, the miniport driver binds itself to the port driver to form the wave filter that represents the underlying audio rendering device. This device might play the stream through a set of speakers, for example.

Alternatively, the wave stream can be rendered by a USB audio device instead of a WaveCyclic or WavePci device. In this case, the stream cannot bypass KMixer; the USBAudio class system driver (not shown in figure) always passes the stream to KMixer.

The right side of the preceding figure shows the components that support a DirectSoundCapture application. The application records wave data that is receives from a WaveCyclic or WavePci capture device. This device converts an analog signal from a microphone, for example, to a wave stream. The device's wave port and miniport drivers appear at the lower-right corner of the figure. As shown in the figure, the port driver receives as input the stream from the miniport driver and outputs it either directly to the user-mode DirectSound component, Dsound.dll, or indirectly through KMixer. This depends on whether a hardware capture pin is available from the capture device.

Ultima Input Devices Driver

Alternatively, the source of the captured wave stream can be a USB audio device. In this case, the stream cannot bypass KMixer; the USBAudio driver (not shown in figure) always passes the stream to KMixer.

If KMixer is inserted into the path of the capture stream, it performs sample-rate conversion on the stream, if needed, but does no mixing with other streams.

At the top-right corner of the preceding figure, the application reads the wave data from the DirectSoundCapture buffer and writes it to the file.

Comments are closed.