系统音频信息

最新推荐文章于 2023-09-14 16:34:52 发布

Pregunta

最新推荐文章于 2023-09-14 16:34:52 发布

阅读量1.2k

点赞数

分类专栏： Win32 System 文章标签： vector struct list string 产品

本文链接：https://blog.csdn.net/Pregunta/article/details/1113111

版权

Win32 System 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

在VC中如何获得音频的详细信息呢 ? 这里做个简单的介绍,并附关键代码

author : 辟邪马甲

首先我们需要头文件

#include "MMSystem.h"

LIB库

#pragma comment(lib,"Winmm.lib")

要保持一个好的习惯,就是保证你的SDK是最新的,并且保留老的版本这样才能避免版本导致的编译错误

http://blog.csdn.net/Pregunta/

在这里用了点别的东西

#include vector

using namespace std;

    vector < WAVEOUTCAPS > vcWaveItemsOut;     // WAVE设备音频输出
    vector < MIDIOUTCAPS > vcMidiItemsOut;           // MIDI设备输出

    vector < WAVEINCAPS > vcWaveItemsIn;           // WAVE设备输入
    vector < MIDIINCAPS > vcMidiItemsIn;                 // MIDI设备输入

    vector < AUXCAPS >     vcAuxItems;             // 音频辅助设备信息
    vector < MIXERCAPS >     vcMixerItems;           // 混音设备信息

// 从这些信息里你可以获得各类音频设备的厂家ID,产品ID,
// 设备详细名称.设备版本号,通道数,以及支持的格式,设备性能,采样频率等...

结构原型如下

typedef struct waveoutcaps_tag {
    WORD    wMid;                   /**//* manufacturer ID */
    WORD    wPid;                   /**//* product ID */
    VERSION vDriverVersion;         /**//* version of the driver */
     char     szPname[MAXPNAMELEN];   /**//* product name (NULL terminated string) */
    DWORD   dwFormats;              /**//* formats supported */
    WORD    wChannels;              /**//* number of sources supported */
    DWORD   dwSupport;              /**//* functionality supported by driver */
} WAVEOUTCAPS, * PWAVEOUTCAPS, NEAR * NPWAVEOUTCAPS, FAR * LPWAVEOUTCAPS;

typedef struct midioutcaps_tag {
    WORD    wMid;                   /**//* manufacturer ID */
    WORD    wPid;                   /**//* product ID */
    VERSION vDriverVersion;         /**//* version of the driver */
     char     szPname[MAXPNAMELEN];   /**//* product name (NULL terminated string) */
    WORD    wTechnology;            /**//* type of device */
    WORD    wVoices;                /**//* # of voices (internal synth only) */
    WORD    wNotes;                 /**//* max # of notes (internal synth only) */
    WORD    wChannelMask;           /**//* channels used (internal synth only) */
    DWORD   dwSupport;              /**//* functionality supported by driver */
} MIDIOUTCAPS, * PMIDIOUTCAPS, NEAR * NPMIDIOUTCAPS, FAR * LPMIDIOUTCAPS;

typedef struct waveincaps_tag {
    WORD    wMid;                     /**//* manufacturer ID */
    WORD    wPid;                     /**//* product ID */
    VERSION vDriverVersion;           /**//* version of the driver */
     char     szPname[MAXPNAMELEN];     /**//* product name (NULL terminated string) */
    DWORD   dwFormats;                /**//* formats supported */
    WORD    wChannels;                /**//* number of channels supported */
} WAVEINCAPS, * PWAVEINCAPS, NEAR * NPWAVEINCAPS, FAR * LPWAVEINCAPS;

typedef struct midiincaps_tag {
    WORD    wMid;                   /**//* manufacturer ID */
    WORD    wPid;                   /**//* product ID */
    VERSION vDriverVersion;         /**//* version of the driver */
     char     szPname[MAXPNAMELEN];   /**//* product name (NULL terminated string) */
#if (WINVER >= 0x0400)
    DWORD   dwSupport;              /**//* functionality supported by driver */
#endif
} MIDIINCAPS, * PMIDIINCAPS, NEAR * NPMIDIINCAPS, FAR * LPMIDIINCAPS;

typedef struct auxcaps_tag {
    WORD    wMid;                   /**//* manufacturer ID */
    WORD    wPid;                   /**//* product ID */
    VERSION vDriverVersion;         /**//* version of the driver */
     char     szPname[MAXPNAMELEN];   /**//* product name (NULL terminated string) */
    WORD    wTechnology;            /**//* type of device */
    DWORD   dwSupport;              /**//* functionality supported by driver */
} AUXCAPS, * PAUXCAPS, NEAR * NPAUXCAPS, FAR * LPAUXCAPS;

typedef struct tMIXERCAPS {
    WORD            wMid;                    /**//* manufacturer id */
    WORD            wPid;                    /**//* product id */
    VERSION         vDriverVersion;          /**//* version of the driver */
     char             szPname[MAXPNAMELEN];    /**//* product name */
    DWORD           fdwSupport;              /**//* misc. support bits */
    DWORD           cDestinations;           /**//* count of destinations */
} MIXERCAPS, * PMIXERCAPS, FAR * LPMIXERCAPS;

     int iwaveDeviceOut = 0 ,imidiDeviceOut = 0 ;
     int iwaveDeviceIn = 0 ,imidiDeviceIn = 0 ;
     int iAuxDevice = 0 , iMixerDevice = 0 ;

    WAVEOUTCAPS wavecapOut;
    WAVEINCAPS wavacapIn;
    MIDIOUTCAPS midicapOut;
    MIDIINCAPS midicapIn;
    AUXCAPS    auxcap;
    MIXERCAPS mixercap;

    ZeroMemory( & wavecapOut, sizeof ( WAVEOUTCAPS ) );
    ZeroMemory( & midicapOut, sizeof ( MIDIOUTCAPS ) );
    ZeroMemory( & wavacapIn, sizeof ( WAVEINCAPS ) );
    ZeroMemory( & midicapIn, sizeof ( MIDIINCAPS ) );
    ZeroMemory( & auxcap, sizeof ( AUXCAPS ) );
    ZeroMemory( & mixercap, sizeof ( MIDIINCAPS ) );

    iwaveDeviceOut = ( int )waveOutGetNumDevs();
    imidiDeviceOut = ( int )midiOutGetNumDevs();
    iwaveDeviceIn   = ( int )waveInGetNumDevs();
    imidiDeviceIn   = ( int )midiInGetNumDevs();
    iAuxDevice        = ( int )auxGetNumDevs();
    iMixerDevice    = ( int )mixerGetNumDevs();
     // WAVE caps out
     if ( iwaveDeviceOut != 0 )
     {
         for ( int i = 0 ; i < iwaveDeviceOut; i ++ )
         {
            waveOutGetDevCaps( i, & wavecapOut, sizeof ( WAVEOUTCAPS ) );
            vcWaveItemsOut.push_back( wavecapOut );
        }
    }
     else
     {

    }
     // MIDI caps out
     if ( imidiDeviceOut != 0 )
     {
         for ( int j = 0 ; j < imidiDeviceOut; j ++ )
         {
            midiOutGetDevCaps( j, & midicapOut, sizeof ( MIDIOUTCAPS ) );
            vcMidiItemsOut.push_back( midicapOut );
        }
    }
     else
     {

    }
     // WAVE caps in
     if ( iwaveDeviceIn != 0 )
     {
         for ( int m = 0 ; m < iwaveDeviceIn; m ++ )
         {
            waveInGetDevCaps( m, & wavacapIn, sizeof (WAVEINCAPS) );
            vcWaveItemsIn.push_back( wavacapIn );
        }
    }
     else
     {

    }
     // MIDI caps in
     if ( imidiDeviceIn != 0 )
     {
         for ( int n = 0 ; n < imidiDeviceIn; n ++ )
         {
            midiInGetDevCaps( n, & midicapIn, sizeof (MIDIINCAPS) );
            vcMidiItemsIn.push_back( midicapIn );
        }

    }
     else
     {

    }

     // AUX caps
     if ( iAuxDevice != 0 )
     {
         for ( int x = 0 ; x < iAuxDevice; x ++ )
          {
            auxGetDevCaps( x, & auxcap, sizeof ( AUXCAPS ) );
            vcAuxItems.push_back( auxcap );
        }
    }
     else
     {

    }

     // MIXER caps
     if ( iMixerDevice != 0 )
     {
         for ( int y = 0 ; y < iMixerDevice; y ++ )
         {
            mixerGetDevCaps( y, & mixercap, sizeof ( MIXERCAPS ) );
            vcMixerItems.push_back( mixercap );
        }
    }
     else
     {

    }

http://blog.csdn.net/Pregunta/

上面的代码可以让我们获得自己的机器上的详细音频设备信息那么如何应用呢

我们可以设计一个LIST列表来存放获得的信息数据用来显示

typedef struct tagListNode

{

string strName;

string strValue;

} LIST_NODE,LPLIST_NODE;

上面的程序告诉我们机器上总的音频设备类型各自的设备数量,因此我们也需要这些参数

int iwaveDeviceOut = vcWaveItemsOut.size();

int iwaveDeviceIn = vcWaveItemsIn.size();

int imidiDeviceOut = vcMidiItemsOut.size();

int imidiDeviceIn = vcMidiItemsIn.size();

int iAuxDevice = vcAuxItems.size();

int iMixerDevice = vcMixerItems.size();

拿 Wave输出设备(回放) 做例子

http://blog.csdn.net/Pregunta/

#define SUPPORT            _T("支持")
#define NONSUPPORT            _T("不支持")

LIST_NODE node;
CString strVersion = "" ;
DWORD dwVersionItems = 0 ;
BYTE btHight = 0 ,btLow = 0 ;
DWORD dwSampleFrequency = 0 ;         // 采样频率
DWORD dwFunctionalitySupport = 0 ;    // 功能性支持
WORD wMidiTechnology = 0 ;            // MIDI 支持设备类型
WORD wAuxTechnology = 0 ;             // AUX  支持设备类型
CString strVersion = "" ;             // 音频设备版本
CString strproNum = "" ;              // 产品标示
CString strChannelNum = "" ;          // 音频设备通道数量
CString strMidiVoiceNum = "" ;        // MIDI 合成声音数量
CString strMidiNotesNum = "" ;        // MIDI 合成音符数量

if ( iwaveDeviceOut != 0 )
{
     for ( int i = 0 ; i < iwaveDeviceOut; i ++ )
   {

        node.strName = _T( " 设备名称 " );
        node.strValue = vcWaveItemsOut[i].szPname;

        strVersion.Format( " %d.%d " ,HIBYTE(LOWORD(vcWaveItemsOut[i].vDriverVersion)),
            LOBYTE(LOWORD(vcWaveItemsOut[i].vDriverVersion)));

        node.strName = _T( " 版本 " );
        node.strValue = strVersion;


        node.strName = _T( " 11.025 kHz, 单声道,  8位 " ); // 采样频率举例
         if ( ( dwSampleFrequency & WAVE_FORMAT_1M08 ) == WAVE_FORMAT_1M08 )
        {
            node.strValue = SUPPORT;
        }
         else
            node.strValue = NONSUPPORT;

        node.strName = _T( " 44.1 kHz, 立体声,  16位 " );
         if ( ( dwSampleFrequency & WAVE_FORMAT_4S16 ) == WAVE_FORMAT_4S16 )
        {
            node.strValue = SUPPORT;
        }
         else
            node.strValue = NONSUPPORT;

        node.strName = _T( " 96 kHz, 立体声,  8位 " );
         if ( ( dwSampleFrequency & WAVE_FORMAT_96S08 ) == WAVE_FORMAT_96S08 )
        {
            node.strValue = SUPPORT;
        }
         else
            node.strValue = NONSUPPORT;



        node.strName = _T( " 回放率控制 " ); // 功能性支持举例
         if ( ( dwFunctionalitySupport & WAVECAPS_PLAYBACKRATE ) == WAVECAPS_PLAYBACKRATE )
        {
            node.strValue = SUPPORT;
        }
         else
            node.strValue = NONSUPPORT;

        node.strName = _T( " 左右声道音量平衡控制 " );
         if ( ( dwFunctionalitySupport & WAVECAPS_LRVOLUME ) == WAVECAPS_LRVOLUME )
       {
            node.strValue = SUPPORT;
        }
         else
            node.strValue = NONSUPPORT;

        node.strName = _T( " 精确采样位置信息返回 " );
         if ( ( dwFunctionalitySupport & WAVECAPS_SAMPLEACCURATE ) == WAVECAPS_SAMPLEACCURATE )
        {
            node.strValue = SUPPORT;
        }
         else
            node.strValue = NONSUPPORT;
    }
}
else
{
    node.strName = _T( " 没有安装或没有配置 " );
    node.strValue = _T( "" );
}

vcWaveItemsOut.clear();
// 以上是关于音频设备中的WAVE设备输出信息的获取,只是很少的其中一部分,其他信息类似

基本上我们已经获得了系统所有音频设备的详细信息了