188 lines
7.3 KiB
C++
188 lines
7.3 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
|
|
|
|
Doom 3 Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
#ifndef ID_SND_BACKENDS
|
|
#define ID_SND_BACKENDS
|
|
|
|
class idAudioHardwareOSS : public idAudioHardware {
|
|
// if you can't write MIXBUFFER_SAMPLES all at once to the audio device, split in MIXBUFFER_CHUNKS
|
|
static const int MIXBUFFER_CHUNKS = 4;
|
|
|
|
int m_audio_fd;
|
|
int m_sample_format;
|
|
unsigned int m_channels;
|
|
unsigned int m_speed;
|
|
void *m_buffer;
|
|
int m_buffer_size;
|
|
|
|
// counting the loops through the dma buffer
|
|
int m_loops;
|
|
|
|
// how many chunks we have left to write in cases where we need to split
|
|
int m_writeChunks;
|
|
// how many chunks we can write to the audio device without blocking
|
|
int m_freeWriteChunks;
|
|
|
|
public:
|
|
idAudioHardwareOSS() {
|
|
m_audio_fd = 0;
|
|
m_sample_format = 0;
|
|
m_channels = 0;
|
|
m_speed = 0;
|
|
m_buffer = NULL;
|
|
m_buffer_size = 0;
|
|
m_loops = 0;
|
|
m_writeChunks = 0;
|
|
m_freeWriteChunks = 0;
|
|
}
|
|
virtual ~idAudioHardwareOSS();
|
|
|
|
bool Initialize( void );
|
|
|
|
// Linux driver doesn't support memory map API
|
|
bool Lock( void **pDSLockedBuffer, ulong *dwDSLockedBufferSize ) { return false; }
|
|
bool Unlock( void *pDSLockedBuffer, dword dwDSLockedBufferSize ) { return false; }
|
|
bool GetCurrentPosition( ulong *pdwCurrentWriteCursor ) { return false; }
|
|
|
|
bool Flush();
|
|
void Write( bool flushing );
|
|
|
|
int GetNumberOfSpeakers() { return m_channels; }
|
|
int GetMixBufferSize();
|
|
short* GetMixBuffer();
|
|
|
|
private:
|
|
void Release( bool bSilent = false );
|
|
void InitFailed();
|
|
void ExtractOSSVersion( int version, idStr &str ) const;
|
|
};
|
|
|
|
#ifndef NO_ALSA
|
|
|
|
// libasound2-dev
|
|
// the new/old API may be a problem if we are going to dynamically load the asound lib?
|
|
#define ALSA_PCM_NEW_HW_PARAMS_API
|
|
#define ALSA_PCM_NEW_SW_PARAMS_API
|
|
#include <alsa/asoundlib.h>
|
|
|
|
#define id_snd_pcm_hw_params_alloca(ptr) do { assert(ptr); *ptr = (snd_pcm_hw_params_t *) alloca(id_snd_pcm_hw_params_sizeof()); memset(*ptr, 0, id_snd_pcm_hw_params_sizeof()); } while (0)
|
|
|
|
typedef const char * ( *pfn_snd_asoundlib_version )( void );
|
|
typedef snd_pcm_sframes_t ( *pfn_snd_pcm_avail_update )( snd_pcm_t *pcm );
|
|
typedef int ( *pfn_snd_pcm_close )( snd_pcm_t *pcm );
|
|
typedef const char * ( *pfn_snd_strerror )( int errnum );
|
|
typedef int ( *pfn_snd_pcm_hw_params )( snd_pcm_t *pcm, snd_pcm_hw_params_t *params );
|
|
typedef int ( *pfn_snd_pcm_hw_params_any )( snd_pcm_t *pcm, snd_pcm_hw_params_t *params );
|
|
typedef int ( *pfn_snd_pcm_hw_params_get_buffer_size )( const snd_pcm_hw_params_t *params, snd_pcm_uframes_t *val );
|
|
typedef int ( *pfn_snd_pcm_hw_params_set_access )( snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_access_t access );
|
|
typedef int ( *pfn_snd_pcm_hw_params_set_buffer_size_min )( snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_uframes_t *val );
|
|
typedef int ( *pfn_snd_pcm_hw_params_set_channels )( snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val );
|
|
typedef int ( *pfn_snd_pcm_hw_params_set_format )( snd_pcm_t *pcm, snd_pcm_hw_params_t *params, snd_pcm_format_t format );
|
|
typedef int ( *pfn_snd_pcm_hw_params_set_rate )( snd_pcm_t *pcm, snd_pcm_hw_params_t *params, unsigned int val, int dir );
|
|
typedef size_t ( *pfn_snd_pcm_hw_params_sizeof )( void );
|
|
typedef int ( *pfn_snd_pcm_open )( snd_pcm_t **pcmp, const char *name, snd_pcm_stream_t stream, int mode );
|
|
typedef int ( *pfn_snd_pcm_prepare )( snd_pcm_t *pcm );
|
|
typedef snd_pcm_state_t ( *pfn_snd_pcm_state )( snd_pcm_t *pcm );
|
|
typedef snd_pcm_sframes_t ( *pfn_snd_pcm_writei )( snd_pcm_t *pcm, const void *buffer, snd_pcm_uframes_t size );
|
|
|
|
#define ALSA_DLSYM(SYM) id_##SYM = ( pfn_##SYM )dlvsym( m_handle, #SYM, "ALSA_0.9" ); if ( !id_##SYM ) { common->Printf( "dlsym "#SYM" failed: %s\n", dlerror() ); Release(); return false; }
|
|
|
|
class idAudioHardwareALSA : public idAudioHardware {
|
|
private:
|
|
// if you can't write MIXBUFFER_SAMPLES all at once to the audio device, split in MIXBUFFER_CHUNKS
|
|
static const int MIXBUFFER_CHUNKS = 4;
|
|
|
|
snd_pcm_t *m_pcm_handle;
|
|
unsigned int m_channels;
|
|
void *m_buffer;
|
|
int m_buffer_size;
|
|
|
|
// how many frames remaining to be written to the device
|
|
int m_remainingFrames;
|
|
|
|
void *m_handle;
|
|
|
|
public:
|
|
idAudioHardwareALSA() {
|
|
m_pcm_handle = NULL;
|
|
m_channels = 0;
|
|
m_buffer = NULL;
|
|
m_buffer_size = 0;
|
|
m_remainingFrames = 0;
|
|
m_handle = NULL;
|
|
}
|
|
virtual ~idAudioHardwareALSA();
|
|
|
|
// dlopen the lib ( check minimum version )
|
|
bool DLOpen();
|
|
|
|
bool Initialize( void );
|
|
|
|
|
|
// Linux driver doesn't support memory map API
|
|
bool Lock( void **pDSLockedBuffer, ulong *dwDSLockedBufferSize ) { return false; }
|
|
bool Unlock( void *pDSLockedBuffer, dword dwDSLockedBufferSize ) { return false; }
|
|
bool GetCurrentPosition( ulong *pdwCurrentWriteCursor ) { return false; }
|
|
|
|
bool Flush();
|
|
void Write( bool flushing );
|
|
|
|
int GetNumberOfSpeakers( void ) { return m_channels; }
|
|
int GetMixBufferSize( void );
|
|
short* GetMixBuffer( void );
|
|
|
|
private:
|
|
void Release();
|
|
void InitFailed();
|
|
void PlayTestPattern();
|
|
|
|
// may be NULL, outdated alsa versions are missing it and we just ignore
|
|
pfn_snd_asoundlib_version id_snd_asoundlib_version;
|
|
|
|
pfn_snd_pcm_avail_update id_snd_pcm_avail_update;
|
|
pfn_snd_pcm_close id_snd_pcm_close;
|
|
pfn_snd_strerror id_snd_strerror;
|
|
pfn_snd_pcm_hw_params id_snd_pcm_hw_params;
|
|
pfn_snd_pcm_hw_params_any id_snd_pcm_hw_params_any;
|
|
pfn_snd_pcm_hw_params_get_buffer_size id_snd_pcm_hw_params_get_buffer_size;
|
|
pfn_snd_pcm_hw_params_set_access id_snd_pcm_hw_params_set_access;
|
|
pfn_snd_pcm_hw_params_set_buffer_size_min id_snd_pcm_hw_params_set_buffer_size_min;
|
|
pfn_snd_pcm_hw_params_set_channels id_snd_pcm_hw_params_set_channels;
|
|
pfn_snd_pcm_hw_params_set_format id_snd_pcm_hw_params_set_format;
|
|
pfn_snd_pcm_hw_params_set_rate id_snd_pcm_hw_params_set_rate;
|
|
pfn_snd_pcm_hw_params_sizeof id_snd_pcm_hw_params_sizeof;
|
|
pfn_snd_pcm_open id_snd_pcm_open;
|
|
pfn_snd_pcm_prepare id_snd_pcm_prepare;
|
|
pfn_snd_pcm_state id_snd_pcm_state;
|
|
pfn_snd_pcm_writei id_snd_pcm_writei;
|
|
|
|
};
|
|
|
|
#endif // NO_ALSA
|
|
|
|
#endif
|