mirror of
https://github.com/saitohirga/WSJT-X.git
synced 2024-11-09 02:26:06 -05:00
260 lines
7.9 KiB
C++
260 lines
7.9 KiB
C++
#include <stdio.h>
|
|
#define MAXDEVICES 100
|
|
#include <string.h>
|
|
#include <portaudio.h>
|
|
#include <QDebug>
|
|
|
|
//------------------------------------------------------- pa_get_device_info
|
|
int pa_get_device_info (int n,
|
|
void *pa_device_name,
|
|
void *pa_device_hostapi,
|
|
double *pa_device_max_speed,
|
|
double *pa_device_min_speed,
|
|
int *pa_device_max_bytes,
|
|
int *pa_device_min_bytes,
|
|
int *pa_device_max_channels,
|
|
int *pa_device_min_channels )
|
|
{
|
|
|
|
(void) n ;
|
|
(void) pa_device_name;
|
|
(void) pa_device_hostapi;
|
|
(void) pa_device_max_speed;
|
|
(void) pa_device_min_speed;
|
|
(void) pa_device_max_bytes;
|
|
(void) pa_device_min_bytes;
|
|
(void) pa_device_max_channels;
|
|
(void) pa_device_min_channels;
|
|
const PaDeviceInfo *deviceInfo;
|
|
PaError pa_err;
|
|
PaStreamParameters inputParameters;
|
|
int i,j, speed_warning;
|
|
int minBytes, maxBytes;
|
|
double maxStandardSampleRate;
|
|
double minStandardSampleRate;
|
|
int minInputChannels;
|
|
int maxInputChannels;
|
|
|
|
// negative terminated list
|
|
static double standardSampleRates[] = {8000.0, 9600.0,
|
|
11025.0, 12000.0, 16000.0, 22050.0, 24000.0, 32000.0,
|
|
44100.0, 48000.0, 88200.0, 96000.0, 192000.0, -1};
|
|
// *******************************************************
|
|
|
|
|
|
*pa_device_max_speed=0;
|
|
*pa_device_min_speed=0;
|
|
*pa_device_max_bytes=0;
|
|
*pa_device_min_bytes=0;
|
|
*pa_device_max_channels=0;
|
|
*pa_device_min_channels=0;
|
|
minInputChannels=0;
|
|
if(n >= Pa_GetDeviceCount() ) return -1;
|
|
deviceInfo = Pa_GetDeviceInfo(n);
|
|
if (deviceInfo->maxInputChannels==0) return -1;
|
|
sprintf((char*)(pa_device_name),"%s",deviceInfo->name);
|
|
sprintf((char*)(pa_device_hostapi),"%s",
|
|
Pa_GetHostApiInfo( deviceInfo->hostApi )->name);
|
|
speed_warning=0;
|
|
|
|
// bypass bug in Juli@ ASIO driver:
|
|
// this driver hangs after a Pa_IsFormatSupported call
|
|
i = strncmp(deviceInfo->name, "ASIO 2.0 - ESI Juli@", 19);
|
|
if (i == 0) {
|
|
minStandardSampleRate=44100;
|
|
maxStandardSampleRate=192000;
|
|
minBytes=1;
|
|
maxBytes=4;
|
|
maxInputChannels= deviceInfo->maxInputChannels;
|
|
minInputChannels= 1;
|
|
goto end_pa_get_device_info;
|
|
}
|
|
|
|
// Investigate device capabilities.
|
|
// Check min and max samplerates with 16 bit data.
|
|
maxStandardSampleRate=0;
|
|
minStandardSampleRate=0;
|
|
inputParameters.device = n;
|
|
inputParameters.channelCount = deviceInfo->maxInputChannels;
|
|
inputParameters.sampleFormat = paInt16;
|
|
inputParameters.suggestedLatency = 0;
|
|
inputParameters.hostApiSpecificStreamInfo = NULL;
|
|
|
|
// ************************************************************************
|
|
//filter for portaudio Windows hostapi's with non experts.
|
|
//only allow ASIO or WASAPI or WDM-KS
|
|
i = strncmp(Pa_GetHostApiInfo(deviceInfo->hostApi)->name, "ASIO", 4);
|
|
if (i==0 ) goto end_filter_hostapi;
|
|
i = strncmp(Pa_GetHostApiInfo(deviceInfo->hostApi)->name,
|
|
"Windows WASAPI", 14);
|
|
if (i==0 ) goto end_filter_hostapi;
|
|
i = strncmp(Pa_GetHostApiInfo(deviceInfo->hostApi)->name,
|
|
"Windows WDM-KS", 14);
|
|
if (i==0 ) goto end_filter_hostapi;
|
|
speed_warning=1;
|
|
end_filter_hostapi:;
|
|
|
|
// ************************************************************************
|
|
i=0;
|
|
while(standardSampleRates[i] > 0 && minStandardSampleRate==0) {
|
|
pa_err=Pa_IsFormatSupported(&inputParameters, NULL,
|
|
standardSampleRates[i] );
|
|
if(pa_err == paDeviceUnavailable) return -1;
|
|
if(pa_err == paInvalidDevice) return -1;
|
|
if(pa_err == paFormatIsSupported ) {
|
|
minStandardSampleRate=standardSampleRates[i];
|
|
}
|
|
i++;
|
|
}
|
|
if(minStandardSampleRate == 0) return -1;
|
|
j=i;
|
|
while(standardSampleRates[i] > 0 ) i++;
|
|
i--;
|
|
|
|
while(i >= j && maxStandardSampleRate==0) {
|
|
pa_err=Pa_IsFormatSupported(&inputParameters, NULL,
|
|
standardSampleRates[i] );
|
|
if(pa_err == paDeviceUnavailable) return -1;
|
|
if(pa_err == paInvalidDevice) return -1;
|
|
if( pa_err == paFormatIsSupported ) {
|
|
maxStandardSampleRate=standardSampleRates[i];
|
|
}
|
|
i--;
|
|
}
|
|
|
|
// check if min SampleRate = max SampleRate
|
|
if(maxStandardSampleRate==0 && (minStandardSampleRate != 0)) {
|
|
maxStandardSampleRate= minStandardSampleRate;
|
|
}
|
|
|
|
// check min and max bytes
|
|
minBytes=2;
|
|
maxBytes=2;
|
|
inputParameters.sampleFormat = paUInt8;
|
|
pa_err=Pa_IsFormatSupported(&inputParameters, NULL,
|
|
maxStandardSampleRate );
|
|
if( pa_err == paFormatIsSupported ) {
|
|
minBytes=1;
|
|
}
|
|
inputParameters.sampleFormat = paInt32;
|
|
pa_err=Pa_IsFormatSupported(&inputParameters, NULL,
|
|
maxStandardSampleRate );
|
|
if( pa_err == paFormatIsSupported ) {
|
|
maxBytes=4;
|
|
}
|
|
|
|
// check min channel count
|
|
maxInputChannels= deviceInfo->maxInputChannels;
|
|
inputParameters.channelCount = 1;
|
|
inputParameters.sampleFormat = paInt16;
|
|
pa_err=paFormatIsSupported+32000;
|
|
while(pa_err != paFormatIsSupported &&
|
|
( inputParameters.channelCount < (maxInputChannels+1)) ) {
|
|
pa_err=Pa_IsFormatSupported(&inputParameters, NULL,
|
|
maxStandardSampleRate );
|
|
inputParameters.channelCount++;
|
|
}
|
|
if( pa_err == paFormatIsSupported ) {
|
|
minInputChannels=inputParameters.channelCount-1;
|
|
} else {
|
|
return -1;
|
|
}
|
|
|
|
end_pa_get_device_info:;
|
|
|
|
*pa_device_max_speed=maxStandardSampleRate;
|
|
*pa_device_min_speed=minStandardSampleRate;
|
|
*pa_device_max_bytes=maxBytes;
|
|
*pa_device_min_bytes=minBytes;
|
|
*pa_device_max_channels= maxInputChannels;
|
|
*pa_device_min_channels= minInputChannels;
|
|
|
|
return speed_warning;
|
|
}
|
|
|
|
|
|
void paInputDevice(int id, char* hostAPI_DeviceName, int* minChan,
|
|
int* maxChan, int* minSpeed, int* maxSpeed)
|
|
{
|
|
int i;
|
|
char pa_device_name[128];
|
|
char pa_device_hostapi[128];
|
|
double pa_device_max_speed;
|
|
double pa_device_min_speed;
|
|
int pa_device_max_bytes;
|
|
int pa_device_min_bytes;
|
|
int pa_device_max_channels;
|
|
int pa_device_min_channels;
|
|
char p2[256];
|
|
char *p,*p1;
|
|
static int iret, valid_dev_cnt;
|
|
|
|
iret=pa_get_device_info (id,
|
|
&pa_device_name,
|
|
&pa_device_hostapi,
|
|
&pa_device_max_speed,
|
|
&pa_device_min_speed,
|
|
&pa_device_max_bytes,
|
|
&pa_device_min_bytes,
|
|
&pa_device_max_channels,
|
|
&pa_device_min_channels);
|
|
|
|
if (iret >= 0 ) {
|
|
valid_dev_cnt++;
|
|
|
|
p1=(char*)"";
|
|
p=strstr(pa_device_hostapi,"MME");
|
|
if(p!=NULL) p1=(char*)"MME";
|
|
p=strstr(pa_device_hostapi,"Direct");
|
|
if(p!=NULL) p1=(char*)"DirectX";
|
|
p=strstr(pa_device_hostapi,"WASAPI");
|
|
if(p!=NULL) p1=(char*)"WASAPI";
|
|
p=strstr(pa_device_hostapi,"ASIO");
|
|
if(p!=NULL) p1=(char*)"ASIO";
|
|
p=strstr(pa_device_hostapi,"WDM-KS");
|
|
if(p!=NULL) p1=(char*)"WDM-KS";
|
|
|
|
sprintf(p2,"%-8s %-39s",p1,pa_device_name);
|
|
for(i=0; i<50; i++) {
|
|
hostAPI_DeviceName[i]=p2[i];
|
|
if(p2[i]==0) break;
|
|
}
|
|
*minChan=pa_device_min_channels;
|
|
*maxChan=pa_device_max_channels;
|
|
*minSpeed=(int)pa_device_min_speed;
|
|
*maxSpeed=(int)pa_device_max_speed;
|
|
} else {
|
|
for(i=0; i<50; i++) {
|
|
hostAPI_DeviceName[i]=0;
|
|
}
|
|
*minChan=0;
|
|
*maxChan=0;
|
|
*minSpeed=0;
|
|
*maxSpeed=0;
|
|
}
|
|
}
|
|
|
|
void getDev(int* numDevices0, char hostAPI_DeviceName[][50],
|
|
int minChan[], int maxChan[],
|
|
int minSpeed[], int maxSpeed[])
|
|
{
|
|
int i,id,numDevices;
|
|
int minch,maxch,minsp,maxsp;
|
|
char apidev[256];
|
|
|
|
numDevices=Pa_GetDeviceCount();
|
|
*numDevices0=numDevices;
|
|
|
|
for(id=0; id<numDevices; id++) {
|
|
paInputDevice(id,apidev,&minch,&maxch,&minsp,&maxsp);
|
|
for(i=0; i<50; i++) {
|
|
hostAPI_DeviceName[id][i]=apidev[i];
|
|
}
|
|
hostAPI_DeviceName[id][49]=0;
|
|
minChan[id]=minch;
|
|
maxChan[id]=maxch;
|
|
minSpeed[id]=minsp;
|
|
maxSpeed[id]=maxsp;
|
|
}
|
|
}
|