/*------------------------------------------------------------------------------*/
static void WaveInInit( void )
{
MMRESULT mmRes;
WaveInNum = waveInGetNumDevs();
if ( WaveInNum >= WAVEINMAX ){ WaveInNum = WAVEINMAX-1; }
for ( int i=0; i<WaveInNum; i++ ){
mmRes = waveInGetDevCaps( i, &WaveInCaps[i], sizeof(WAVEINCAPS) );
if ( mmRes != MMSYSERR_NOERROR ){ WaveInCaps[i].wChannels = 0; }
}
mmRes = waveInGetDevCaps( WAVE_MAPPER, &WaveInCaps[WAVEINMAX-1], sizeof(WAVEINCAPS) );
if ( mmRes != MMSYSERR_NOERROR ){ WaveInCaps[WAVEINMAX-1].wChannels = 0; }
}
void initAudioDevices(SIPX_INSTANCE_DATA& pInst)
{
#if defined(_WIN32)
WAVEOUTCAPS outcaps;
WAVEINCAPS incaps;
int numDevices;
MMRESULT result;
numDevices = waveInGetNumDevs();
for (int i = 0; i < numDevices && i < MAX_AUDIO_DEVICES; i++)
{
result = waveInGetDevCaps(i, &incaps, sizeof(WAVEINCAPS));
assert(result == MMSYSERR_NOERROR);
pInst.inputAudioDevices[i] = SAFE_STRDUP(incaps.szPname);
}
pInst.nInputAudioDevices = numDevices;
numDevices = waveOutGetNumDevs();
for (int i = 0; i < numDevices && i < MAX_AUDIO_DEVICES; i++)
{
result = waveOutGetDevCaps(i, &outcaps, sizeof(WAVEOUTCAPS));
assert(result == MMSYSERR_NOERROR);
pInst.outputAudioDevices[i] = SAFE_STRDUP(outcaps.szPname) ;
}
pInst.nOutputAudioDevices = numDevices;
#else
pInst.inputAudioDevices[0] = SAFE_STRDUP("Default");
pInst.outputAudioDevices[0] = SAFE_STRDUP("Default");
#endif
}
/* ////////////////////////// PUBLIC STATIC ///////////////////////////////// */
UtlString MpidWinMM::getDefaultDeviceName()
{
UtlString devName = "";
// Get windows default input device name
unsigned nDevs = waveInGetNumDevs();
if (nDevs == 0)
{
OsSysLog::add(FAC_AUDIO, PRI_ERR,
"MpidWinMM::getDefaultDeviceName: "
"No input audio devices present!");
}
assert(nDevs != 0);
MMRESULT wavResult = MMSYSERR_NOERROR;
WAVEINCAPS devCaps;
int defaultWinDeviceId = 0;
wavResult =
waveInGetDevCaps(defaultWinDeviceId, &devCaps, sizeof(devCaps));
if (wavResult != MMSYSERR_NOERROR)
{
OsSysLog::add(FAC_AUDIO, PRI_ERR,
"MpodWinMM::getDefaultDeviceName: "
"Couldn't get default input device capabilities!");
showWaveError("WINDOWS_DEFAULT_DEVICE_HACK",
wavResult, -1, __LINE__);
}
else
{
devName = devCaps.szPname;
}
assert(wavResult == MMSYSERR_NOERROR);
return devName;
}
//---------------------------------------------------------------------------
// サウンドカードの名前を得る
void __fastcall CWave::GetDeviceList(void)
{
m_InDevs = 0;
m_OutDevs = 0;
WAVEINCAPS incaps;
for( int i = 0; i < AN(m_tInDevName); i++ ){
if( !waveInGetDevCaps(i, &incaps, sizeof(incaps)) ){
m_tInDevName[i] = incaps.szPname;
m_InDevs = i + 1;
}
else {
m_tInDevName[i] = "";
}
}
WAVEOUTCAPS outcaps;
for( int i = 0; i < AN(m_tOutDevName); i++ ){
if( !waveOutGetDevCaps(i, &outcaps, sizeof(outcaps)) ){
m_tOutDevName[i] = outcaps.szPname;
m_OutDevs = i + 1;
}
else {
m_tOutDevName[i] = "";
}
}
}
void CSettingsDlg::OnButtonAudioinput()
{
std::vector<CString> deviceList;
//Obtain the number of input devices on the system
DWORD numWaveInputDevices = waveInGetNumDevs();
//Scan through each input device to see if we can find the FM Radio
for (DWORD i = 0; i < numWaveInputDevices; i++)
{
WAVEINCAPS waveInputCapabilities;
//Get the device capabilities of the currently indexed device
if (waveInGetDevCaps(i, &waveInputCapabilities, sizeof(waveInputCapabilities)) == MMSYSERR_NOERROR)
{
deviceList.push_back(waveInputCapabilities.szPname);
}
}
CDeviceSelectDlg deviceSelectDlg(&deviceList, m_RadioIndex);
if (deviceSelectDlg.DoModal() == IDOK)
{
m_RadioIndex = deviceSelectDlg.GetIndex();
}
}
UINT CSoundRecDlg::FillDevices()
{
CComboBox *pBox=(CComboBox*)GetDlgItem(IDC_DEVICES);
UINT nDevices,nC1;
WAVEINCAPS stWIC={0};
MMRESULT mRes;
pBox->ResetContent();
nDevices=waveInGetNumDevs();
for(nC1=0;nC1<nDevices;++nC1)
{
ZeroMemory(&stWIC,sizeof(WAVEINCAPS));
mRes=waveInGetDevCaps(nC1,&stWIC,sizeof(WAVEINCAPS));
if(mRes==0)
pBox->AddString(stWIC.szPname);
else
StoreError(mRes,TRUE,"File: %s ,Line Number:%d",__FILE__,__LINE__);
}
if(pBox->GetCount())
{
pBox->SetCurSel(0);
OnCbnSelchangeDevices();
}
return nDevices;
}
QList<QByteArray> QAudioDeviceInfoInternal::availableDevices(QAudio::Mode mode)
{
Q_UNUSED(mode)
QList<QByteArray> devices;
if(mode == QAudio::AudioOutput) {
WAVEOUTCAPS woc;
unsigned long iNumDevs,i;
iNumDevs = waveOutGetNumDevs();
for(i=0;i<iNumDevs;i++) {
if(waveOutGetDevCaps(i, &woc, sizeof(WAVEOUTCAPS))
== MMSYSERR_NOERROR) {
devices.append(QString((const QChar *)woc.szPname).toLocal8Bit().constData());
}
}
} else {
WAVEINCAPS woc;
unsigned long iNumDevs,i;
iNumDevs = waveInGetNumDevs();
for(i=0;i<iNumDevs;i++) {
if(waveInGetDevCaps(i, &woc, sizeof(WAVEINCAPS))
== MMSYSERR_NOERROR) {
devices.append(QString((const QChar *)woc.szPname).toLocal8Bit().constData());
}
}
}
if(devices.count() > 0)
devices.append("default");
return devices;
}
// Determine if this computer has a sound card capable of recording
JNIEXPORT jboolean
JNICALL Java_craigl_winrecorder_WinRecorder_nativeHasSoundCard(
JNIEnv *env, jobject o) {
WAVEINCAPS waveInCaps;
BOOL success;
if (waveInGetNumDevs() == 0)
return FALSE;
// We have a recording device, grab its specs
success = (waveInGetDevCaps(0, &waveInCaps, sizeof(WAVEINCAPS)) == MMSYSERR_NOERROR);
if (success) {
#ifdef DEBUG
// Display info
printf("Manufacturer ID: %d\n", waveInCaps.wMid);
printf("Product ID: %d\n", waveInCaps.wPid);
printf("Maj Version: %d\n", waveInCaps.vDriverVersion >> 8);
printf("Min Version: %d\n", waveInCaps.vDriverVersion & 255);
printf("Product Name: %s\n", waveInCaps.szPname);
printf("Formats: %x\n", waveInCaps.dwFormats);
printf("Channels: %d\n", waveInCaps.wChannels);
#endif
return TRUE;
} else
return FALSE;
void mmio_getdevs(char *indevlist, int *nindevs,
char *outdevlist, int *noutdevs, int *canmulti,
int maxndev, int devdescsize)
{
int wRtn, ndev, i;
*canmulti = 2; /* supports multiple devices */
ndev = waveInGetNumDevs();
if (ndev > maxndev)
ndev = maxndev;
*nindevs = ndev;
for (i = 0; i < ndev; i++)
{
WAVEINCAPS wicap;
wRtn = waveInGetDevCaps(i, (LPWAVEINCAPS) &wicap, sizeof(wicap));
sprintf(indevlist + i * devdescsize, (wRtn ? "???" : wicap.szPname));
}
ndev = waveOutGetNumDevs();
if (ndev > maxndev)
ndev = maxndev;
*noutdevs = ndev;
for (i = 0; i < ndev; i++)
{
WAVEOUTCAPS wocap;
wRtn = waveOutGetDevCaps(i, (LPWAVEOUTCAPS) &wocap, sizeof(wocap));
sprintf(outdevlist + i * devdescsize, (wRtn ? "???" : wocap.szPname));
}
}
/* list the audio and MIDI device names */
void mmio_listdevs(void)
{
UINT wRtn, ndevices;
unsigned int i;
ndevices = waveInGetNumDevs();
for (i = 0; i < ndevices; i++)
{
WAVEINCAPS wicap;
wRtn = waveInGetDevCaps(i, (LPWAVEINCAPS) &wicap,
sizeof(wicap));
if (wRtn) nt_waveinerror("waveInGetDevCaps: %s\n", wRtn);
else fprintf(stderr,
"audio input device #%d: %s\n", i+1, wicap.szPname);
}
ndevices = waveOutGetNumDevs();
for (i = 0; i < ndevices; i++)
{
WAVEOUTCAPS wocap;
wRtn = waveOutGetDevCaps(i, (LPWAVEOUTCAPS) &wocap,
sizeof(wocap));
if (wRtn) nt_waveouterror("waveOutGetDevCaps: %s\n", wRtn);
else fprintf(stderr,
"audio output device #%d: %s\n", i+1, wocap.szPname);
}
}
void Mixer::open(unsigned numChannels, unsigned samplingFrequency, unsigned granularityInMS) {
HMIXER newHMixer = NULL;
do {
MIXERCAPS mc;
if (mixerGetDevCaps(index, &mc, sizeof mc) != MMSYSERR_NOERROR) break;
#ifdef UNICODE
// Copy the mixer name:
wcstombs(name, mc.szPname, MAXPNAMELEN);
#else
strncpy(name, mc.szPname, MAXPNAMELEN);
#endif
// Find the correct line for this mixer:
unsigned i, uWavIn;
unsigned nWavIn = waveInGetNumDevs();
for (i = 0; i < nWavIn; ++i) {
WAVEINCAPS wic;
if (waveInGetDevCaps(i, &wic, sizeof wic) != MMSYSERR_NOERROR) continue;
MIXERLINE ml;
ml.cbStruct = sizeof ml;
ml.Target.dwType = MIXERLINE_TARGETTYPE_WAVEIN;
#ifdef UNICODE
wcsncpy(ml.Target.szPname, wic.szPname, MAXPNAMELEN);
#else
strncpy(ml.Target.szPname, wic.szPname, MAXPNAMELEN);
#endif
ml.Target.vDriverVersion = wic.vDriverVersion;
ml.Target.wMid = wic.wMid;
ml.Target.wPid = wic.wPid;
if (mixerGetLineInfo((HMIXEROBJ)index, &ml, MIXER_GETLINEINFOF_TARGETTYPE/*|MIXER_OBJECTF_MIXER*/) == MMSYSERR_NOERROR) {
// this is the right line
uWavIn = i;
dwRecLineID = ml.dwLineID;
break;
}
}
if (i >= nWavIn) break; // error: we couldn't find the right line
if (mixerOpen(&newHMixer, index, (unsigned long)NULL, (unsigned long)NULL, MIXER_OBJECTF_MIXER) != MMSYSERR_NOERROR) break;
if (newHMixer == NULL) break;
// Sanity check: re-call "mixerGetDevCaps()" using the mixer device handle:
if (mixerGetDevCaps((UINT)newHMixer, &mc, sizeof mc) != MMSYSERR_NOERROR) break;
if (mc.cDestinations < 1) break; // error: this mixer has no destinations
if (!WindowsAudioInputDevice_common::openWavInPort(uWavIn, numChannels, samplingFrequency, granularityInMS)) break;
hMixer = newHMixer;
return;
} while (0);
// An error occurred:
close();
}
void CSoundRecDlg::OnCbnSelchangeDevices()
{
CComboBox *pDevices=(CComboBox*)GetDlgItem(IDC_DEVICES);
CComboBox *pFormats=(CComboBox*)GetDlgItem(IDC_FORMATS);
int nSel;
WAVEINCAPS stWIC={0};
MMRESULT mRes;
SetStatus("Querying device informations...");
pFormats->ResetContent();
nSel=pDevices->GetCurSel();
if(nSel!=-1)
{
ZeroMemory(&stWIC,sizeof(WAVEINCAPS));
mRes=waveInGetDevCaps(nSel,&stWIC,sizeof(WAVEINCAPS));
if(mRes==0)
{
if(WAVE_FORMAT_1M08==(stWIC.dwFormats&WAVE_FORMAT_1M08))
pFormats->SetItemData(pFormats->AddString("11.025 kHz, mono, 8-bit"),WAVE_FORMAT_1M08);
if(WAVE_FORMAT_1M16==(stWIC.dwFormats&WAVE_FORMAT_1M16))
pFormats->SetItemData(pFormats->AddString("11.025 kHz, mono, 16-bit"),WAVE_FORMAT_1M16);
if(WAVE_FORMAT_1S08==(stWIC.dwFormats&WAVE_FORMAT_1S08))
pFormats->SetItemData(pFormats->AddString("11.025 kHz, stereo, 8-bit"),WAVE_FORMAT_1S08);
if(WAVE_FORMAT_1S16==(stWIC.dwFormats&WAVE_FORMAT_1S16))
pFormats->SetItemData(pFormats->AddString("11.025 kHz, stereo, 16-bit"),WAVE_FORMAT_1S16);
if(WAVE_FORMAT_2M08==(stWIC.dwFormats&WAVE_FORMAT_2M08))
pFormats->SetItemData(pFormats->AddString("22.05 kHz, mono, 8-bit"),WAVE_FORMAT_2M08);
if(WAVE_FORMAT_2M16==(stWIC.dwFormats&WAVE_FORMAT_2M16))
pFormats->SetItemData(pFormats->AddString("22.05 kHz, mono, 16-bit"),WAVE_FORMAT_2M16);
if(WAVE_FORMAT_2S08==(stWIC.dwFormats&WAVE_FORMAT_2S08))
pFormats->SetItemData(pFormats->AddString("22.05 kHz, stereo, 8-bit"),WAVE_FORMAT_2S08);
if(WAVE_FORMAT_2S16==(stWIC.dwFormats&WAVE_FORMAT_2S16))
pFormats->SetItemData(pFormats->AddString("22.05 kHz, stereo, 16-bit"),WAVE_FORMAT_2S16);
if(WAVE_FORMAT_4M08==(stWIC.dwFormats&WAVE_FORMAT_4M08))
pFormats->SetItemData(pFormats->AddString("44.1 kHz, mono, 8-bit"),WAVE_FORMAT_4M08);
if(WAVE_FORMAT_4M16==(stWIC.dwFormats&WAVE_FORMAT_4M16))
pFormats->SetItemData(pFormats->AddString("44.1 kHz, mono, 16-bit"),WAVE_FORMAT_4M16);
if(WAVE_FORMAT_4S08==(stWIC.dwFormats&WAVE_FORMAT_4S08))
pFormats->SetItemData(pFormats->AddString("44.1 kHz, stereo, 8-bit"),WAVE_FORMAT_4S08);
if(WAVE_FORMAT_4S16==(stWIC.dwFormats&WAVE_FORMAT_4S16))
pFormats->SetItemData(pFormats->AddString("44.1 kHz, stereo, 16-bit"),WAVE_FORMAT_4S16);
if(WAVE_FORMAT_96M08==(stWIC.dwFormats&WAVE_FORMAT_96M08))
pFormats->SetItemData(pFormats->AddString("96 kHz, mono, 8-bit"),WAVE_FORMAT_96M08);
if(WAVE_FORMAT_96S08==(stWIC.dwFormats&WAVE_FORMAT_96S08))
pFormats->SetItemData(pFormats->AddString("96 kHz, stereo, 8-bit"),WAVE_FORMAT_96S08);
if(WAVE_FORMAT_96M16==(stWIC.dwFormats&WAVE_FORMAT_96M16))
pFormats->SetItemData(pFormats->AddString("96 kHz, mono, 16-bit"),WAVE_FORMAT_96M16);
if(WAVE_FORMAT_96S16==(stWIC.dwFormats&WAVE_FORMAT_96S16))
pFormats->SetItemData(pFormats->AddString("96 kHz, stereo, 16-bit"),WAVE_FORMAT_96S16);
if(pFormats->GetCount())
pFormats->SetCurSel(0);
}
else
StoreError(mRes,TRUE,"File: %s ,Line Number:%d",__FILE__,__LINE__);
}
SetStatus("Waiting to start...");
}
tbool CDeviceWaveIO::LoadDriver(tint iIndex, tbool bEnableInput, tbool bEnableOutput)
{
AbortCloseAndRelease();
mbDriverPseudoLoaded = FALSE;
mbInput = false;
if (iIndex == -1) {
tuint32 uiDev = WAVE_MAPPER;
// Can only be either output or input
mbInput = (bEnableInput && !bEnableOutput);
if (mbInput) {
WAVEINCAPS caps;
MMRESULT mmres = waveInGetDevCaps(WAVE_MAPPER, &caps, sizeof(caps));
if (mmres != MMSYSERR_NOERROR)
return false;
miChannelsIn = caps.wChannels;
}
else {
// We must query for default wave-out device
if (!TestWaveOutCaps(&uiDev, 44100))
return FALSE;
iIndex = (tint32)uiDev;
}
}
else {
if (iIndex < 0)
return false;
if (iIndex >= (tint32)waveOutGetNumDevs()) {
// Load input device
tbool bSuccess = LoadDriverInput(iIndex - waveOutGetNumDevs());
if (!bSuccess)
return false;
WAVEINCAPS caps;
MMRESULT mmres = waveInGetDevCaps(WAVE_MAPPER, &caps, sizeof(caps));
if (mmres != MMSYSERR_NOERROR)
return false;
miChannelsIn = caps.wChannels;
mbInput = (bEnableInput && (miChannelsIn > 0));
}
}
muiDevIndex = (tuint32)iIndex;
mbDriverPseudoLoaded = TRUE;
mbOutput = bEnableOutput;
return (mbInput || mbOutput);
} // LoadDriver
// Define: getWaveInDevNumChannels(DWORD deviceID)
WORD waveCapture::getWaveInDevNumChannels(const WORD uDev)
{
if ( waveInGetDevCaps(uDev, &wcaps, sizeof(wcaps)) == MMSYSERR_NOERROR )
{
return wcaps.wChannels;
} else {
return NULL;
}
}
char *sound_devicename(int card)
/* card between 0 and sound_maxdevice() */
{
static char no_such_soundcard[] = "Undefined Soundcard";
if (MMSYSERR_NOERROR != waveInGetDevCaps(card, &wic,sizeof(WAVEINCAPS)))
return no_such_soundcard;
else
return wic.szPname;
}
char* CAudioCtrl::GetWaveInName(UINT uiDevID)
{
WAVEINCAPS tagCaps;
if (waveInGetDevCaps(uiDevID, &tagCaps, sizeof(tagCaps)) == MMSYSERR_NOERROR)
{
return tagCaps.szPname;
}
return NULL;
}
// Define: getWaveInDevName(DWORD deviceID)
LPSTR waveCapture::getWaveInDevName(const WORD uDev)
{
if ( waveInGetDevCaps(uDev, &wcaps, sizeof(wcaps)) == MMSYSERR_NOERROR )
{
return wcaps.szPname;
} else {
return NULL;
}
}
// Define: getWaveInDevProductId(DWORD deviceID)
WORD waveCapture::getWaveInDevProductId(const WORD uDev)
{
if ( waveInGetDevCaps(uDev, &wcaps, sizeof(wcaps)) == MMSYSERR_NOERROR )
{
return wcaps.wPid;
} else {
return NULL;
}
}
// Aquire and enabled audio card
// return 0 if ok, -1 if failed
int BAE_AquireAudioCapture(void *threadContext, unsigned long sampleRate, unsigned long channels, unsigned long bits,
unsigned long *pCaptureHandle)
{
MMRESULT theErr;
WAVEINCAPS caps;
WAVEFORMATEX format;
UINT deviceID;
g_bitSize = bits;
g_channels = channels;
g_sampleRate = sampleRate;
if (pCaptureHandle)
{
*pCaptureHandle = 0L;
}
deviceID = WAVE_MAPPER;
if (g_soundDeviceIndex)
{
deviceID = g_soundDeviceIndex - 1;
}
theErr = waveInGetDevCaps(deviceID, &caps, sizeof(WAVEINCAPS));
if (theErr == MMSYSERR_NOERROR)
{
format.wFormatTag = WAVE_FORMAT_PCM;
format.nSamplesPerSec = sampleRate;
format.wBitsPerSample = (WORD)bits;
format.nChannels = (WORD)channels;
format.nBlockAlign = (WORD)((format.wBitsPerSample * format.nChannels) / 8);
format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign;
format.cbSize = 0;
theErr = waveInOpen(&g_captureSound, deviceID, &format,
0L/*(DWORD)PV_AudioCaptureCallback*/, (DWORD)threadContext, CALLBACK_NULL /*CALLBACK_FUNCTION*/);
if (theErr == MMSYSERR_NOERROR)
{
g_captureShutdown = FALSE;
if (pCaptureHandle)
{
*pCaptureHandle = (unsigned long)g_captureSound;
}
}
else
{
BAE_ReleaseAudioCapture(threadContext);
}
}
return (theErr == MMSYSERR_NOERROR) ? 0 : -1;
}
void CWaveRecord::GetProductNames(CStringArray& strArrProductNames)
{
WAVEINCAPS caps;
strArrProductNames.RemoveAll();
for(int i = 0; i < waveInGetNumDevs(); i++)
{
waveInGetDevCaps(i, &caps, sizeof(WAVEINCAPS));
strArrProductNames.Add(caps.szPname);
}
}
void Recorder::EnumDevs(EnumDevsProc lpProc)
{
WAVEINCAPS waveInCap;
UINT count = waveInGetNumDevs();
for (int i = 0; i < count; i++)
{
UINT result = waveInGetDevCaps(i, &waveInCap, sizeof(waveInCap));
if (result == 0)
{
lpProc(i, waveInCap.szPname);
}
}
}
void printInDevices() {
unsigned int count = waveInGetNumDevs();
WAVEINCAPS caps;
unsigned int i = 0;
for (i = 0; i < count; i++) {
if (waveInGetDevCaps(i, &caps, sizeof(caps)) == MMSYSERR_NOERROR) {
fprintf(stderr, "%u: %s\r\n", i, caps.szPname);
} else {
fprintf(stderr, "Can't read devices\r\n");
exit(EXIT_FAILURE);
}
}
}
//===========================================================================
void __fastcall Tform_Main::Setup_lb_WaveFormDevice()
{
combobox_SoundCard->Items->Clear();
combobox_SoundFreq->Items->Clear();
// ----- Количество ВАйфФОрм Устройств ------
for ( unsigned int i = 0; i < waveInGetNumDevs(); i++)
{
WAVEINCAPS wic;
ZeroMemory(&wic, sizeof(wic));
waveInGetDevCaps(i, &wic, sizeof(wic));
combobox_SoundCard->Items->Add(wic.szPname);
}
}
//===========================================================================
void __fastcall Tform_Main::combobox_SoundCardChange(TObject *Sender)
{
//if ( wic.dwFormats & WAVE_FORMAT_4M16 ) ListBox1->Items->Add(wic.szPname);
if ( combobox_SoundCard->ItemIndex == -1 ) return;
WAVEINCAPS wic;
ZeroMemory(&wic, sizeof(wic));
waveInGetDevCaps(combobox_SoundCard->ItemIndex, &wic, sizeof(wic));
combobox_SoundFreq->Items->Clear();
for ( DWORD k = 1; k < 0xFFFFFFF; k = k * 2)// (k << 1)
{
//2channels, 16bit, 96kHz => size is 0x5DC0
//if ( (wic.dwFormats & WAVE_INVALIDFORMAT) && k == WAVE_INVALIDFORMAT ) combobox_SoundFreq->Items->Add("invalid format"); else // 0x00000000 // invalid format
//if ( (wic.dwFormats & WAVE_FORMAT_1M08 ) && k == WAVE_FORMAT_1M08 ) combobox_SoundFreq->Items->Add("11.025 kHz, Mono, 8-bit"); else // 0x00000001 //
//if ( (wic.dwFormats & WAVE_FORMAT_1S08 ) && k == WAVE_FORMAT_1S08 ) combobox_SoundFreq->Items->Add("11.025 kHz, Stereo, 8-bit"); else // 0x00000002 //
//if ( (wic.dwFormats & WAVE_FORMAT_1M16 ) && k == WAVE_FORMAT_1M16 ) combobox_SoundFreq->Items->Add("11.025 kHz, Mono, 16-bit"); else // 0x00000004 //
//if ( (wic.dwFormats & WAVE_FORMAT_1S16 ) && k == WAVE_FORMAT_1S16 ) combobox_SoundFreq->Items->Add("11.025 kHz, Stereo, 16-bit"); else // 0x00000008 //
//if ( (wic.dwFormats & WAVE_FORMAT_2M08 ) && k == WAVE_FORMAT_2M08 ) combobox_SoundFreq->Items->Add("22.05 kHz, Mono, 8-bit"); else // 0x00000010 //
//if ( (wic.dwFormats & WAVE_FORMAT_2S08 ) && k == WAVE_FORMAT_2S08 ) combobox_SoundFreq->Items->Add("22.05 kHz, Stereo, 8-bit"); else // 0x00000020 //
//if ( (wic.dwFormats & WAVE_FORMAT_2M16 ) && k == WAVE_FORMAT_2M16 ) combobox_SoundFreq->Items->Add("22.05 kHz, Mono, 16-bit"); else // 0x00000040 //
//if ( (wic.dwFormats & WAVE_FORMAT_2S16 ) && k == WAVE_FORMAT_2S16 ) combobox_SoundFreq->Items->Add("22.05 kHz, Stereo, 16-bit"); else // 0x00000080 //
//if ( (wic.dwFormats & WAVE_FORMAT_4M08 ) && k == WAVE_FORMAT_4M08 ) combobox_SoundFreq->Items->Add("44.1 kHz, Mono, 8-bit"); else // 0x00000100 //
//if ( (wic.dwFormats & WAVE_FORMAT_4S08 ) && k == WAVE_FORMAT_4S08 ) combobox_SoundFreq->Items->Add("44.1 kHz, Stereo, 8-bit"); else // 0x00000200 //
//if ( (wic.dwFormats & WAVE_FORMAT_4M16 ) && k == WAVE_FORMAT_4M16 ) combobox_SoundFreq->Items->Add("44.1 kHz, Mono, 16-bit"); else // 0x00000400 //
//if ( (wic.dwFormats & WAVE_FORMAT_4S16 ) && k == WAVE_FORMAT_4S16 ) combobox_SoundFreq->Items->Add("44.1 kHz, Stereo, 16-bit"); else // 0x00000800 //
//if ( (wic.dwFormats & WAVE_FORMAT_48M08 ) && k == WAVE_FORMAT_48M08 ) combobox_SoundFreq->Items->Add("48 kHz, Mono, 8-bit"); else // 0x00001000 //
//if ( (wic.dwFormats & WAVE_FORMAT_48S08 ) && k == WAVE_FORMAT_48S08 ) combobox_SoundFreq->Items->Add("48 kHz, Stereo, 8-bit"); else // 0x00002000 //
//if ( (wic.dwFormats & WAVE_FORMAT_48M16 ) && k == WAVE_FORMAT_48M16 ) combobox_SoundFreq->Items->Add("48 kHz, Mono, 16-bit"); else // 0x00004000 //
//if ( (wic.dwFormats & WAVE_FORMAT_48S16 ) && k == WAVE_FORMAT_48S16 ) combobox_SoundFreq->Items->Add("48 kHz, Stereo, 16-bit"); else // 0x00008000 //
//if ( (wic.dwFormats & WAVE_FORMAT_96M08 ) && k == WAVE_FORMAT_96M08 ) combobox_SoundFreq->Items->Add("96 kHz, Mono, 8-bit"); else // 0x00010000 //
//if ( (wic.dwFormats & WAVE_FORMAT_96S08 ) && k == WAVE_FORMAT_96S08 ) combobox_SoundFreq->Items->Add("96 kHz, Stereo, 8-bit"); else // 0x00020000 //
//if ( (wic.dwFormats & WAVE_FORMAT_96M16 ) && k == WAVE_FORMAT_96M16 ) combobox_SoundFreq->Items->Add("96 kHz, Mono, 16-bit");// else // 0x00040000 //
//if ( (wic.dwFormats & WAVE_FORMAT_96S16 ) && k == WAVE_FORMAT_96S16 ) combobox_SoundFreq->Items->Add("96 kHz, Stereo, 16-bit"); // 0x00080000 //
if ( (wic.dwFormats & WAVE_FORMAT_48M16 ) && k == WAVE_FORMAT_48M16 ) combobox_SoundFreq->Items->Add("48 kHz, Mono, 16-bit"); else // 0x00004000 //
if ( (wic.dwFormats & WAVE_FORMAT_96M16 ) && k == WAVE_FORMAT_96M16 ) combobox_SoundFreq->Items->Add("96 kHz, Mono, 16-bit");// else // 0x00040000 //
}
SoundCardIndex = combobox_SoundCard->ItemIndex;
if ( combobox_SoundFreq->Items->Count > 0 ){
combobox_SoundFreq->ItemIndex = FreqSoundCardIndex;
combobox_SoundFreqChange(NULL);
}
combobox_SoundFreqChange(Sender);
}
static int winwave_get_dev_name(unsigned int i, char name[32])
{
WAVEINCAPS wic;
int err = 0;
if (waveInGetDevCaps(i, &wic,
sizeof(WAVEINCAPS)) == MMSYSERR_NOERROR) {
str_ncpy(name, wic.szPname, 32);
}
else {
err = ENODEV;
}
return err;
}
void FillDevices()
{
WAVEINCAPS stWIC={0};
UINT nDevices=waveInGetNumDevs();
for(UINT nC1=0;nC1<nDevices;++nC1)
{
ZeroMemory(&stWIC,sizeof(WAVEINCAPS));
MMRESULT mRes=waveInGetDevCaps(nC1,&stWIC,sizeof(WAVEINCAPS));
if(mRes==0)
LOG->Trace( stWIC.szPname );
else
FAIL_M("bad");
}
}
CDeviceManagerWaveIO::CDeviceManagerWaveIO()
{
muiNbOfDrivers_Outputs = waveOutGetNumDevs();
tuint32 ui;
for (ui = 0; ui<muiNbOfDrivers_Outputs; ui++) {
UINT uiDevID = ui;
SMyWaveOutCaps* p = new SMyWaveOutCaps();
MMRESULT mmres = waveOutGetDevCaps((UINT_PTR)uiDevID, &(p->wocaps), sizeof(WAVEOUTCAPS));
if (mmres == MMSYSERR_NOERROR) {
if (p->wocaps.dwFormats & WAVE_FORMAT_4S16)
p->b44100 = TRUE;
p->b48000 = CDeviceWaveIO::TestWaveOutCaps(&uiDevID, 48000);
p->b88200 = CDeviceWaveIO::TestWaveOutCaps(&uiDevID, 88200);
if (p->wocaps.dwFormats & WAVE_FORMAT_96S16)
p->b96000 = TRUE;
#ifdef _DEBUG
tchar pszDevName[1024];
strcpy(pszDevName, p->wocaps.szPname);
WORD wChannels = p->wocaps.wChannels;
std::cout << "CDeviceManagerWaveIO::CDeviceManagerWaveIO() - Add device " << uiDevID << " = '" << pszDevName << "', " << wChannels << " channels.\n";
#endif _DEBUG
}
else {
std::cerr << "CDeviceManagerWaveIO::CDeviceManagerWaveIO() - Unable to add device " << uiDevID << ".\n";
}
mlistpMyWaveOutCaps.insert(mlistpMyWaveOutCaps.end(), p);
}
muiNbOfDrivers_Total = muiNbOfDrivers_Outputs + waveInGetNumDevs();
for (ui = muiNbOfDrivers_Outputs; ui < muiNbOfDrivers_Total; ui++) {
UINT uiDevID = ui - muiNbOfDrivers_Outputs;
SWaveInCaps* p = new SWaveInCaps();
MMRESULT mmres = waveInGetDevCaps((UINT_PTR)uiDevID, &(p->wicaps), sizeof(WAVEINCAPS));
if (mmres == MMSYSERR_NOERROR) {
#ifdef _DEBUG
tchar pszDevName[1024];
strcpy(pszDevName, p->wicaps.szPname);
WORD wChannels = p->wicaps.wChannels;
std::cout << "CDeviceManagerWaveIO::CDeviceManagerWaveIO() - Add device " << uiDevID << " = '" << pszDevName << "', " << wChannels << " channels.\n";
#endif _DEBUG
}
else {
std::cerr << "CDeviceManagerWaveIO::CDeviceManagerWaveIO() - Unable to add device " << uiDevID << ".\n";
}
mWaveInCaps.push_back(p);
}
} // constructor
PLUGIN_FUNCTION_ARG3(GetDeviceName,unsigned,index, char *,buffer, unsigned,bufsize)
{
if (buffer == NULL || bufsize == 0)
return PluginLID_InvalidParameter;
if (m_hDLL== NULL)
return PluginLID_InternalError;
if (index > 0)
return PluginLID_NoMoreNames;
const char * searchName;
switch (m_eProductID)
{
case TJIP_NONE :
return PluginLID_NoSuchDevice;
case TJIP_TJ560BPPG :
case TJIP_TJ560BPPG_NO_EC :
case TJIP_TJ560CPPG_NO_EC :
case TJIP_TJ560BPPGPROSLIC :
case TJIP_TJ560BPPGPROSLIC_NO_EC :
searchName = "Personal PhoneGateway-USB";
break;
case TJIP_TJ320PHONE :
searchName = "PCI Internet Phone";
break;
default :
searchName = "USB Audio";
}
for (UINT id = 0; id < waveInGetNumDevs(); id++) {
WAVEINCAPS caps;
if (waveInGetDevCaps(id, &caps, sizeof(caps)) == 0 && _strnicmp(caps.szPname, searchName, strlen(searchName)) == 0) {
if (bufsize <= strlen(caps.szPname))
return PluginLID_BufferTooSmall;
strcpy(buffer, caps.szPname);
return PluginLID_NoError;
}
}
return PluginLID_InternalError;
}
// Default constructor
MpidWinMM::MpidWinMM(const UtlString& name,
MpInputDeviceManager& deviceManager,
unsigned nInputBuffers)
: MpInputDeviceDriver(name, deviceManager)
, mWinMMDeviceId(-1)
, mDevHandle(NULL)
, mNumInBuffers(nInputBuffers)
, mWaveBufSize(0) // Unknown until enableDevice()
, mIsOpen(FALSE)
, mnAddBufferFailures(0)
{
WAVEINCAPS devCaps;
// Grab the number of input devices that are available.
UINT nInputDevs = waveInGetNumDevs();
// Search through the input devices looking for the input device specified.
MMRESULT wavResult = MMSYSERR_NOERROR;
unsigned i;
for (i = 0; i < nInputDevs; i++)
{
MMRESULT res = waveInGetDevCaps(i, &devCaps, sizeof(devCaps));
if (res != MMSYSERR_NOERROR)
{
wavResult = res;
}
else if (strncmp(name, devCaps.szPname, MAXPNAMELEN) == 0)
{
mWinMMDeviceId = i;
break;
}
}
// Allocate the wave headers and buffer pointers for use with
// windows audio routines.
//(This does *not* include allocation of the buffers themselves -
// that is handled in enableDevice, as we don't know the
// buffer size (#samplesPerFrame) until then.
mpWaveHeaders = new WAVEHDR[mNumInBuffers];
mpWaveBuffers = new LPSTR[mNumInBuffers];
for (i = 0; i < mNumInBuffers; i++)
{
mpWaveBuffers[i] = NULL;
}
}
string CSoundChannel::m_sGetDefaultDevice(EDIRECTIONS eDir)
{
string strDevName;
if(eDir == e_Player)
{
WAVEOUTCAPS capTmp;
if(waveOutGetDevCaps(0, &capTmp, sizeof(capTmp)) == 0)
strDevName = capTmp.szPname;
}
else
{
WAVEINCAPS capTmp;
if(waveInGetDevCaps(0, &capTmp, sizeof(capTmp)) == 0)
strDevName = capTmp.szPname;
}
return strDevName;
}
