// Aquire and enabled audio card
// return 0 if ok, -1 if failed
int HAE_AquireAudioCapture(void *context, UINT32 encoding, UINT32 sampleRate, UINT32 channels, UINT32 bits,
UINT32 audioFramesPerBuffer, UINT_PTR *pCaptureHandle)
{
MMRESULT theErr;
WAVEINCAPS caps;
WAVEFORMATEX format;
INT32 deviceID;
ULONG minFramesPerBuffer;
if (encoding != PCM) {
// fprintf(stderr, "HAE_AquireAudioCapture: unsupported encoding: %d\n", g_encoding);
return -1;
}
g_encoding = encoding;
g_bitSize = bits;
g_channels = channels;
g_sampleRate = sampleRate;
minFramesPerBuffer = sampleRate * HAE_WAVEIN_MIN_BUFFERSIZE_IN_MS / 1000;
if( audioFramesPerBuffer == 0 ) {
audioFramesPerBuffer = sampleRate * HAE_WAVEIN_DEFAULT_BUFFERSIZE_IN_MS / 1000;
}
g_audioFramesPerBuffer = audioFramesPerBuffer;
if (pCaptureHandle) {
/* what about multi-thread ? */
*pCaptureHandle = 0L;
}
/* $$fb 2002-04-10: fix for 4514334: JavaSoundDemo Capture not works on Windows2000 with USB Port */
if (g_soundDeviceIndex == 0) {
deviceID = WAVE_MAPPER;
} else {
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;
// $$fb 2002-02-01: itanium port: use UINT_PTR for casting a pointer to UINT
theErr = waveInOpen(&g_captureSound, deviceID, &format,
0L, (UINT_PTR)context, CALLBACK_NULL);
if (theErr == MMSYSERR_NOERROR) {
g_captureShutdown = FALSE;
g_waveInStarted = FALSE;
if (pCaptureHandle) {
*pCaptureHandle = (UINT_PTR)g_captureSound;
}
} else {
HAE_ReleaseAudioCapture(context);
}
}
return (theErr == MMSYSERR_NOERROR) ? 0 : -1;
}
// Aquire and enabled audio card
// return 0 if ok, -1 if failed
int HAE_AquireAudioCapture(void *context, UINT32 encoding, UINT32 sampleRate, UINT32 channels, UINT32 bits,
UINT32 audioFramesPerBuffer, UINT_PTR *pCaptureHandle) {
audio_info_t sunAudioHeader;
INT32 error = -1;
char* pAudioDev = HAE_GetAudioDevRec(g_soundDeviceIndex, 0);
INT32 minFramesPerBuffer;
//fprintf(stderr, "Entering HAE_AquireAudioCapture(encoding=%d, samplerate=%d, channels=%d, bits=%d, framesPerBuffer=%d)\n",
// encoding, sampleRate, channels, bits, audioFramesPerBuffer);
g_encoding = encoding;
g_bitSize = bits;
g_channels = channels;
g_sampleRate = sampleRate;
if( audioFramesPerBuffer == 0 ) {
audioFramesPerBuffer = sampleRate * HAE_SOLARIS_DEFAULT_BUFFERSIZE_IN_MS / 1000;
}
g_audioFramesToRead = audioFramesPerBuffer / g_audioCaptureBufferSizeDivisor;
if (pCaptureHandle) {
*pCaptureHandle = 0L;
}
// try to open wave device for recording
// $$kk: 12.17.97: need O_NONBLOCK flag to be compatible with windows
// $$kk: 10.13.98: we want O_NONBLOCK so that we return failure immediately if the
// device is busy (or absent or whatever) rather than blocking. however, i think that
// this same O_NONBLOCK flag dictates whether the read() calls should block. even
// without the O_NONBLOCK flag set, read() does *not* block for me, so i'm keeping
// the flag for now....
g_captureSound = open(pAudioDev,O_RDONLY|O_NONBLOCK);
if (g_captureSound > 0) {
/* set to multiple open */
if (ioctl(g_captureSound, AUDIO_MIXER_MULTIPLE_OPEN, NULL) >= 0) {
TRACE1("HAE_AquireAudioCapture: %s set to multiple open\n", pAudioDev);
} else {
ERROR1("HAE_AquireAudioCapture: ioctl AUDIO_MIXER_MULTIPLE_OPEN failed on %s!\n", pAudioDev);
}
AUDIO_INITINFO(&sunAudioHeader);
// Set capture format of the sun device.
sunAudioHeader.record.sample_rate = sampleRate;
sunAudioHeader.record.precision = bits;
sunAudioHeader.record.channels = channels;
sunAudioHeader.record.buffer_size = g_audioFramesToRead * channels * bits / 8;
sunAudioHeader.record.encoding = AUDIO_ENCODING_LINEAR;
if (g_encoding == ULAW) {
sunAudioHeader.record.encoding = AUDIO_ENCODING_ULAW;
}
else if (g_encoding == ALAW) {
sunAudioHeader.record.encoding = AUDIO_ENCODING_ALAW;
}
// start out paused so we don't overflow the device driver buffers
sunAudioHeader.record.pause = 1;
error = ioctl(g_captureSound, AUDIO_SETINFO, &sunAudioHeader);
if (error != -1) {
// flush anything we might have accumulated in the capture queue before pausing
error = ioctl(g_captureSound, I_FLUSH, FLUSHR);
error = ioctl(g_captureSound, AUDIO_GETINFO, &sunAudioHeader);
g_audioFramesToRead = sunAudioHeader.record.buffer_size / (channels * bits / 8);
if (error != -1) {
if (pCaptureHandle) {
*pCaptureHandle = (UINT_PTR)g_captureSound;
}
}
}
}
if (error == -1) { // something failed
HAE_ReleaseAudioCapture(context);
}
//fprintf(stderr, "<< HAE_API_SolarisOS_Capture: HAE_AquireAudioCapture() returning %d\n", error);
return error;
}
// Aquire and enabled audio card
// return 0 if ok, -1 if failed
// $$fb 2002-02-01: itanium port
int HAE_AquireAudioCapture(void *context, UINT32 encoding, UINT32 sampleRate,
UINT32 channels, UINT32 bits,
UINT32 audioFramesPerBuffer, UINT_PTR *pCaptureHandle)
{
long error = -1;
//long minFramesPerBuffer;
g_encoding = encoding;
g_bitSize = bits;
g_channels = channels;
g_sampleRate = sampleRate;
// $$jb: 05.19.99: Setting the buffer size
// $$kk: 08.06.99: i got rid of the fixed minimum value for buffersize
// minFramesPerBuffer = sampleRate * HAE_LINUX_MIN_BUFFERSIZE_IN_MS / 1000;
if ( audioFramesPerBuffer == 0 ) {
audioFramesPerBuffer = sampleRate * HAE_LINUX_DEFAULT_BUFFERSIZE_IN_MS / 1000;
}
// $$kk: 08.06.99: got rid of fixed minimum buffer size
/*
if ( audioFramesPerBuffer >= minFramesPerBuffer ) {
g_audioFramesToRead = audioFramesPerBuffer;
} else {
g_audioFramesToRead = minFramesPerBuffer;
}
*/
g_audioFramesToRead = audioFramesPerBuffer / g_audioCaptureBufferSizeDivisor;
if (pCaptureHandle) {
*pCaptureHandle = 0L;
}
// try to open wave device for recording
// $$kk: 12.17.97: need O_NONBLOCK flag to be compatible with windows
// $$kk: 10.13.98: we want O_NONBLOCK so that we return failure immediately if the
// device is busy (or absent or whatever) rather than blocking. however, i think that
// this same O_NONBLOCK flag dictates whether the read() calls should block. even
// without the O_NONBLOCK flag set, read() does *not* block for me, so i'm keeping
// the flag for now....
HAE_OpenSoundCard(1); // Open for capture
if (g_waveDevice > 0) {
int format = AFMT_MU_LAW;
int stereo = (channels == 2);
int speed = sampleRate;
switch (bits) {
case 8:
format = AFMT_MU_LAW; /* [sbb fix] don't know if this is right or not -- maybe should be s8? */
break;
case 16:
format = AFMT_S16_LE; /* [sbb fix] needs to be conditional? */
break;
//default:
// fprintf(stderr, "Warning: unhandled number of data bits %d\n", (int) bits);
}
error = ioctl(g_waveDevice, SNDCTL_DSP_SETFMT, &format);
if (error < 0) {
//perror("SNDCTL_DSP_SETFMT");
//exit(1);
}
error = ioctl(g_waveDevice, SNDCTL_DSP_STEREO, &stereo);
if (error < 0) {
/* [sbb fix] issue some kind of error message */
//perror("SNDCTL_DSP_STEREO");
//exit(1);
}
if (ioctl(g_waveDevice, SNDCTL_DSP_SPEED, &speed) < 0) { /* Fatal error */
/* [sbb fix] handle this better */
//perror("SNDCTL_DSP_SPEED");
// $$ay: dont exit !
// exit(1);
}
if (speed != (INT32) sampleRate) {
/* [sbb fix] need to issue a message */
}
if (error == 0) {
// flush anything we might have accumulated in the capture queue before pausing
HAE_FlushAudioCapture();
error = ioctl(g_waveDevice, SNDCTL_DSP_GETBLKSIZE, &g_audioFramesToRead);
g_audioFramesToRead = g_audioFramesToRead / (channels * bits / 8);
if (error == 0) {
if (pCaptureHandle) {
*pCaptureHandle = (UINT_PTR)g_waveDevice;
}
}
}
}
if (error != 0) { // something failed
HAE_ReleaseAudioCapture(context);
}
return (error == 0 ? 0 : -1);
}
