videolan
/
vlc
mirror of https://code.videolan.org/videolan/vlc
1
Fork 0
Code Releases Activity
vlc/modules/audio_output/waveout.c

1038 lines
32 KiB
C
Raw Blame History

/*****************************************************************************
* waveout.c : Windows waveOut plugin for vlc
*****************************************************************************
* Copyright (C) 2001-2009 VLC authors and VideoLAN
*
* Authors: Gildas Bazin <gbazin@videolan.org>
* André Weber
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This program 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
/*****************************************************************************
* Preamble
*****************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <math.h>
#ifndef UNICODE
# define UNICODE
#endif
#include <vlc_common.h>
#include <vlc_plugin.h>
#include <vlc_aout.h>
#include <vlc_charset.h> /* FromWide() */
#include "audio_output/windows_audio_common.h"
#define FRAME_SIZE 4096 /* The size is in samples, not in bytes */
/*****************************************************************************
* Local prototypes
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close ( vlc_object_t * );
static void Play ( audio_output_t *, block_t *, vlc_tick_t );
/*****************************************************************************
* notification_thread_t: waveOut event thread
*****************************************************************************/
typedef struct aout_sys_t aout_sys_t;
struct lkwavehdr
{
WAVEHDR hdr;
struct lkwavehdr * p_next;
};
/* local functions */
static int OpenWaveOut ( audio_output_t *, uint32_t,
int, int, int, int, bool );
static int OpenWaveOutPCM( audio_output_t *, uint32_t,
vlc_fourcc_t*, int, int, int, bool );
static int PlayWaveOut ( audio_output_t *, HWAVEOUT, struct lkwavehdr *,
block_t *, bool );
static void CALLBACK WaveOutCallback ( HWAVEOUT, UINT, DWORD_PTR, DWORD_PTR, DWORD_PTR );
static void WaveOutClean( aout_sys_t * p_sys );
static void WaveOutClearBuffer( HWAVEOUT, WAVEHDR *);
static uint32_t findDeviceID(char *);
static int WaveOutTimeGet(audio_output_t * , vlc_tick_t *);
static void WaveOutFlush( audio_output_t *);
static void WaveOutDrain( audio_output_t *);
static void WaveOutDrainAsync( audio_output_t *);
static void WaveOutPause( audio_output_t *, bool, vlc_tick_t);
static int WaveoutVolumeSet(audio_output_t * p_aout, float volume);
static int WaveoutMuteSet(audio_output_t * p_aout, bool mute);
static void WaveoutPollVolume( void * );
static const wchar_t device_name_fmt[] = L"%ls ($%x,$%x)";
/*****************************************************************************
* aout_sys_t: waveOut audio output method descriptor
*****************************************************************************
* This structure is part of the audio output thread descriptor.
* It describes the waveOut specific properties of an audio device.
*****************************************************************************/
struct aout_sys_t
{
HWAVEOUT h_waveout; /* handle to waveout instance */
WAVEFORMATEXTENSIBLE waveformat; /* audio format */
size_t i_frames;
int i_repeat_counter;
int i_buffer_size;
int i_rate;
uint8_t *p_silence_buffer; /* buffer we use to play silence */
float f_volume;
bool b_spdif;
bool b_mute;
bool b_soft; /* Use software gain */
uint8_t chans_to_reorder; /* do we need channel reordering */
uint8_t chan_table[AOUT_CHAN_MAX];
vlc_fourcc_t format;
vlc_tick_t i_played_length;
struct lkwavehdr * p_free_list;
vlc_mutex_t lock;
vlc_cond_t cond;
vlc_timer_t volume_poll_timer;
bool draining;
};
/*****************************************************************************
* Module descriptor
*****************************************************************************/
#define DEVICE_TEXT N_("Select Audio Device")
#define DEVICE_LONG N_("Select special Audio device, or let windows "\
"decide (default), change needs VLC restart "\
"to apply.")
#define AUDIO_CHAN_TEXT N_("Audio output channels")
#define AUDIO_CHAN_LONGTEXT N_("Channels available for audio output. " \
"If the input has more channels than the output, it will be down-mixed. " \
"This parameter is ignored when digital pass-through is active.")
#define VOLUME_TEXT N_("Audio volume")
vlc_module_begin ()
set_shortname( "WaveOut" )
set_description( N_("WaveOut audio output") )
set_capability( "audio output", 50 )
set_subcategory( SUBCAT_AUDIO_AOUT )
add_string( "waveout-audio-device", "wavemapper",
DEVICE_TEXT, DEVICE_LONG )
add_float( "waveout-volume", 1.0f, VOLUME_TEXT, NULL )
change_float_range(0.0f, 2.0f)
add_bool( "waveout-float32", true, FLOAT_TEXT, FLOAT_LONGTEXT )
add_integer ("waveout-audio-channels", 9, AUDIO_CHAN_TEXT,
AUDIO_CHAN_LONGTEXT)
change_integer_range(1,9)
set_callbacks( Open, Close )
vlc_module_end ()
/*****************************************************************************
* Opens the audio device
*****************************************************************************
* This function opens and setups Win32 waveOut
*****************************************************************************/
static int Start( audio_output_t *p_aout, audio_sample_format_t *restrict fmt )
{
if( aout_FormatNbChannels( fmt ) == 0 )
return VLC_EGENERIC;
p_aout->time_get = WaveOutTimeGet;
p_aout->play = Play;
p_aout->pause = WaveOutPause;
p_aout->flush = WaveOutFlush;
p_aout->drain = WaveOutDrainAsync;
aout_sys_t *sys = p_aout->sys;
sys->draining = false;
/* Default behaviour is to use software gain */
sys->b_soft = true;
char *dev = var_GetNonEmptyString( p_aout, "waveout-audio-device");
uint32_t devid = findDeviceID( dev );
if(devid == WAVE_MAPPER && dev != NULL && stricmp(dev,"wavemapper"))
msg_Warn( p_aout, "configured audio device '%s' not available, "
"using default instead", dev );
free( dev );
WAVEOUTCAPS waveoutcaps;
if(waveOutGetDevCaps( devid, &waveoutcaps,
sizeof(WAVEOUTCAPS)) == MMSYSERR_NOERROR)
{
/* log debug some infos about driver, to know who to blame
if it doesn't work */
msg_Dbg( p_aout, "Drivername: %ls", waveoutcaps.szPname);
msg_Dbg( p_aout, "Driver Version: %d.%d",
(waveoutcaps.vDriverVersion>>8)&255,
waveoutcaps.vDriverVersion & 255);
msg_Dbg( p_aout, "Manufacturer identifier: 0x%x", waveoutcaps.wMid );
msg_Dbg( p_aout, "Product identifier: 0x%x", waveoutcaps.wPid );
}
/* Open the device */
if( AOUT_FMT_SPDIF(fmt) && var_InheritBool (p_aout, "spdif") )
{
if( OpenWaveOut( p_aout, devid, VLC_CODEC_SPDIFL,
fmt->i_physical_channels,
aout_FormatNbChannels( fmt ), fmt->i_rate, false )
== VLC_SUCCESS )
{
fmt->i_format = VLC_CODEC_SPDIFL;
/* Calculate the frame size in bytes */
fmt->i_bytes_per_frame = AOUT_SPDIF_SIZE;
fmt->i_frame_length = A52_FRAME_NB;
sys->i_buffer_size = fmt->i_bytes_per_frame;
sys->b_spdif = true;
}
else
msg_Err( p_aout,
"cannot open waveout audio device for spdif fallback to PCM" );
}
if( fmt->i_format != VLC_CODEC_SPDIFL )
{
/*
check for configured audio device!
*/
fmt->i_format = var_InheritBool( p_aout, "waveout-float32" )?
VLC_CODEC_FL32: VLC_CODEC_S16N;
int max_chan = var_InheritInteger( p_aout, "waveout-audio-channels");
int i_channels = aout_FormatNbChannels(fmt);
i_channels = ( i_channels < max_chan )? i_channels: max_chan;
do
{
switch(i_channels)
{
case 9:
fmt->i_physical_channels = AOUT_CHANS_8_1;
break;
case 8:
fmt->i_physical_channels = AOUT_CHANS_7_1;
break;
case 7:
fmt->i_physical_channels = AOUT_CHANS_7_0;
break;
case 6:
fmt->i_physical_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
| AOUT_CHAN_CENTER | AOUT_CHAN_REARLEFT
| AOUT_CHAN_REARRIGHT | AOUT_CHAN_LFE;
break;
case 5:
fmt->i_physical_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
| AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
| AOUT_CHAN_LFE;
break;
case 4:
fmt->i_physical_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
| AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
break;
case 3:
fmt->i_physical_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
| AOUT_CHAN_LFE;
break;
case 2:
fmt->i_physical_channels = AOUT_CHANS_STEREO;
break;
case 1:
default:
fmt->i_physical_channels = AOUT_CHAN_CENTER;
}
msg_Dbg( p_aout, "Trying %d channels", i_channels );
}
while( ( OpenWaveOutPCM( p_aout, devid, &fmt->i_format,
fmt->i_physical_channels, i_channels,
fmt->i_rate, false ) != VLC_SUCCESS ) &&
--i_channels );
if( !i_channels )
{
msg_Err(p_aout, "Waveout couldn't find appropriate channel mapping");
return VLC_EGENERIC;
}
/* Calculate the frame size in bytes */
aout_FormatPrepare( fmt );
sys->i_buffer_size = FRAME_SIZE * fmt->i_bytes_per_frame;
if( waveoutcaps.dwSupport & WAVECAPS_VOLUME )
{
aout_GainRequest( p_aout, 1.0f );
sys->b_soft = false;
}
WaveoutMuteSet( p_aout, sys->b_mute );
sys->b_spdif = false;
}
sys->i_rate = fmt->i_rate;
waveOutReset( sys->h_waveout );
/* Allocate silence buffer */
sys->p_silence_buffer =
malloc( sys->i_buffer_size );
if( sys->p_silence_buffer == NULL )
{
return VLC_ENOMEM;
}
sys->i_repeat_counter = 0;
/* Zero the buffer. WinCE doesn't have calloc(). */
memset( sys->p_silence_buffer, 0,
sys->i_buffer_size );
/* Now we need to setup our waveOut play notification structure */
sys->i_frames = 0;
sys->i_played_length = 0;
sys->p_free_list = NULL;
fmt->channel_type = AUDIO_CHANNEL_TYPE_BITMAP;
return VLC_SUCCESS;
}
/*****************************************************************************
* Play: play a sound buffer
*****************************************************************************
* This doesn't actually play the buffer. This just stores the buffer so it
* can be played by the callback thread.
*****************************************************************************/
static void Play( audio_output_t *p_aout, block_t *block, vlc_tick_t date )
{
aout_sys_t *sys = p_aout->sys;
struct lkwavehdr * p_waveheader =
(struct lkwavehdr *) malloc(sizeof(struct lkwavehdr));
if(!p_waveheader)
{
if( block )
block_Release( block );
return;
}
p_waveheader->p_next = NULL;
if( block && sys->chans_to_reorder )
{
aout_ChannelReorder( block->p_buffer, block->i_buffer,
sys->waveformat.Format.nChannels,
sys->chan_table, sys->format );
}
while( PlayWaveOut( p_aout, sys->h_waveout, p_waveheader, block,
sys->b_spdif ) != VLC_SUCCESS )
{
msg_Warn( p_aout, "Couldn't write frame... sleeping");
vlc_tick_sleep( block->i_length );
}
WaveOutClean( sys );
WaveoutPollVolume( p_aout );
vlc_mutex_lock( &sys->lock );
sys->i_frames++;
sys->i_played_length += block->i_length;
vlc_mutex_unlock( &sys->lock );
(void) date;
}
/*****************************************************************************
* Close: close the audio device
*****************************************************************************/
static void Stop( audio_output_t *p_aout )
{
aout_sys_t *p_sys = p_aout->sys;
/* Before calling waveOutClose we must reset the device */
waveOutReset( p_sys->h_waveout );
/* wait for the frames to be queued in cleaning list */
WaveOutDrain( p_aout );
WaveOutClean( p_sys );
/* now we can Close the device */
if( waveOutClose( p_sys->h_waveout ) != MMSYSERR_NOERROR )
{
msg_Err( p_aout, "waveOutClose failed" );
}
free( p_sys->p_silence_buffer );
p_sys->i_played_length = 0;
p_sys->b_soft = true;
}
/*****************************************************************************
* OpenWaveOut: open the waveout sound device
****************************************************************************/
static int OpenWaveOut( audio_output_t *p_aout, uint32_t i_device_id, int i_format,
int i_channels, int i_nb_channels, int i_rate,
bool b_probe )
{
MMRESULT result;
aout_sys_t *sys = p_aout->sys;
/* Set sound format */
#define waveformat sys->waveformat
waveformat.dwChannelMask = 0;
for( unsigned i = 0; pi_vlc_chan_order_wg4[i]; i++ )
if( i_channels & pi_vlc_chan_order_wg4[i] )
waveformat.dwChannelMask |= pi_channels_in[i];
switch( i_format )
{
case VLC_CODEC_SPDIFL:
i_nb_channels = 2;
/* To prevent channel re-ordering */
waveformat.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT;
waveformat.Format.wBitsPerSample = 16;
waveformat.Samples.wValidBitsPerSample =
waveformat.Format.wBitsPerSample;
waveformat.Format.wFormatTag = WAVE_FORMAT_DOLBY_AC3_SPDIF;
waveformat.SubFormat = __KSDATAFORMAT_SUBTYPE_DOLBY_AC3_SPDIF;
break;
case VLC_CODEC_FL32:
waveformat.Format.wBitsPerSample = sizeof(float) * 8;
waveformat.Samples.wValidBitsPerSample =
waveformat.Format.wBitsPerSample;
waveformat.Format.wFormatTag = WAVE_FORMAT_IEEE_FLOAT;
waveformat.SubFormat = __KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
break;
case VLC_CODEC_S16N:
waveformat.Format.wBitsPerSample = 16;
waveformat.Samples.wValidBitsPerSample =
waveformat.Format.wBitsPerSample;
waveformat.Format.wFormatTag = WAVE_FORMAT_PCM;
waveformat.SubFormat = __KSDATAFORMAT_SUBTYPE_PCM;
break;
}
waveformat.Format.nChannels = i_nb_channels;
waveformat.Format.nSamplesPerSec = i_rate;
waveformat.Format.nBlockAlign =
waveformat.Format.wBitsPerSample / 8 * i_nb_channels;
waveformat.Format.nAvgBytesPerSec =
waveformat.Format.nSamplesPerSec * waveformat.Format.nBlockAlign;
/* Only use the new WAVE_FORMAT_EXTENSIBLE format for multichannel audio */
if( i_nb_channels <= 2 )
{
waveformat.Format.cbSize = 0;
}
else
{
waveformat.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
waveformat.Format.cbSize =
sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
}
if(!b_probe) {
msg_Dbg( p_aout, "OpenWaveDevice-ID: %u", i_device_id);
msg_Dbg( p_aout,"waveformat.Format.cbSize = %d",
waveformat.Format.cbSize);
msg_Dbg( p_aout,"waveformat.Format.wFormatTag = %u",
waveformat.Format.wFormatTag);
msg_Dbg( p_aout,"waveformat.Format.nChannels = %u",
waveformat.Format.nChannels);
msg_Dbg( p_aout,"waveformat.Format.nSamplesPerSec = %d",
(int)waveformat.Format.nSamplesPerSec);
msg_Dbg( p_aout,"waveformat.Format.nAvgBytesPerSec = %u",
(int)waveformat.Format.nAvgBytesPerSec);
msg_Dbg( p_aout,"waveformat.Format.nBlockAlign = %d",
waveformat.Format.nBlockAlign);
msg_Dbg( p_aout,"waveformat.Format.wBitsPerSample = %d",
waveformat.Format.wBitsPerSample);
msg_Dbg( p_aout,"waveformat.Samples.wValidBitsPerSample = %d",
waveformat.Samples.wValidBitsPerSample);
msg_Dbg( p_aout,"waveformat.Samples.wSamplesPerBlock = %d",
waveformat.Samples.wSamplesPerBlock);
msg_Dbg( p_aout,"waveformat.dwChannelMask = %u",
waveformat.dwChannelMask);
}
/* Open the device */
result = waveOutOpen( &sys->h_waveout, i_device_id,
(WAVEFORMATEX *)&waveformat,
(DWORD_PTR)WaveOutCallback, (DWORD_PTR)p_aout,
CALLBACK_FUNCTION | (b_probe?WAVE_FORMAT_QUERY:0) );
if( result == WAVERR_BADFORMAT )
{
msg_Warn( p_aout, "waveOutOpen failed WAVERR_BADFORMAT" );
return VLC_EGENERIC;
}
if( result == MMSYSERR_ALLOCATED )
{
msg_Warn( p_aout, "waveOutOpen failed WAVERR_ALLOCATED" );
return VLC_EGENERIC;
}
if( result != MMSYSERR_NOERROR )
{
msg_Warn( p_aout, "waveOutOpen failed" );
return VLC_EGENERIC;
}
sys->chans_to_reorder =
aout_CheckChannelReorder( pi_channels_in, pi_channels_out,
waveformat.dwChannelMask,
sys->chan_table );
if( sys->chans_to_reorder )
msg_Dbg( p_aout, "channel reordering needed" );
sys->format = i_format;
return VLC_SUCCESS;
#undef waveformat
}
/*****************************************************************************
* OpenWaveOutPCM: open a PCM waveout sound device
****************************************************************************/
static int OpenWaveOutPCM( audio_output_t *p_aout, uint32_t i_device_id,
vlc_fourcc_t *i_format,
int i_channels, int i_nb_channels, int i_rate,
bool b_probe )
{
bool b_use_float32 = var_CreateGetBool( p_aout, "waveout-float32");
if( !b_use_float32 || OpenWaveOut( p_aout, i_device_id, VLC_CODEC_FL32,
i_channels, i_nb_channels, i_rate, b_probe )
!= VLC_SUCCESS )
{
if ( OpenWaveOut( p_aout, i_device_id, VLC_CODEC_S16N,
i_channels, i_nb_channels, i_rate, b_probe )
!= VLC_SUCCESS )
{
return VLC_EGENERIC;
}
else
{
*i_format = VLC_CODEC_S16N;
return VLC_SUCCESS;
}
}
else
{
*i_format = VLC_CODEC_FL32;
return VLC_SUCCESS;
}
}
/*****************************************************************************
* PlayWaveOut: play a buffer through the WaveOut device
*****************************************************************************/
static int PlayWaveOut( audio_output_t *p_aout, HWAVEOUT h_waveout,
struct lkwavehdr *p_waveheader, block_t *p_buffer, bool b_spdif)
{
MMRESULT result;
aout_sys_t *sys = p_aout->sys;
/* Prepare the buffer */
if( p_buffer != NULL )
{
p_waveheader->hdr.lpData = (LPSTR)p_buffer->p_buffer;
p_waveheader->hdr.dwBufferLength = p_buffer->i_buffer;
/*
copy the buffer to the silence buffer :) so in case we don't
get the next buffer fast enough (I will repeat this one a time
for AC3 / DTS and SPDIF this will sound better instead of
a hickup)
*/
if(b_spdif)
{
memcpy( sys->p_silence_buffer,
p_buffer->p_buffer,
sys->i_buffer_size );
sys->i_repeat_counter = 2;
}
} else {
/* Use silence buffer instead */
if(sys->i_repeat_counter)
{
sys->i_repeat_counter--;
if(!sys->i_repeat_counter)
{
memset( sys->p_silence_buffer,
0x00, sys->i_buffer_size );
}
}
p_waveheader->hdr.lpData = (LPSTR)sys->p_silence_buffer;
p_waveheader->hdr.dwBufferLength = sys->i_buffer_size;
}
p_waveheader->hdr.dwUser = p_buffer ? (DWORD_PTR)p_buffer : (DWORD_PTR)1;
p_waveheader->hdr.dwFlags = 0;
result = waveOutPrepareHeader( h_waveout, &p_waveheader->hdr, sizeof(WAVEHDR) );
if( result != MMSYSERR_NOERROR )
{
msg_Err( p_aout, "waveOutPrepareHeader failed" );
return VLC_EGENERIC;
}
/* Send the buffer to the waveOut queue */
result = waveOutWrite( h_waveout, &p_waveheader->hdr, sizeof(WAVEHDR) );
if( result != MMSYSERR_NOERROR )
{
msg_Err( p_aout, "waveOutWrite failed" );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/*****************************************************************************
* WaveOutCallback: what to do once WaveOut has played its sound samples
*****************************************************************************/
static void CALLBACK WaveOutCallback( HWAVEOUT h_waveout, UINT uMsg,
DWORD_PTR _p_aout,
DWORD_PTR dwParam1, DWORD_PTR dwParam2 )
{
(void) h_waveout;
(void) dwParam2;
audio_output_t *p_aout = (audio_output_t *)_p_aout;
aout_sys_t *sys = p_aout->sys;
struct lkwavehdr * p_waveheader = (struct lkwavehdr *) dwParam1;
if( uMsg != WOM_DONE ) return;
vlc_mutex_lock( &sys->lock );
p_waveheader->p_next = sys->p_free_list;
sys->p_free_list = p_waveheader;
sys->i_frames--;
if( sys->i_frames == 0 && sys->draining )
{
aout_DrainedReport( p_aout );
sys->draining = false;
}
vlc_cond_broadcast( &sys->cond );
vlc_mutex_unlock( &sys->lock );
}
static void WaveOutClean( aout_sys_t * p_sys )
{
struct lkwavehdr *p_whdr, *p_list;
vlc_mutex_lock(&p_sys->lock);
p_list = p_sys->p_free_list;
p_sys->p_free_list = NULL;
vlc_mutex_unlock(&p_sys->lock);
while( p_list )
{
p_whdr = p_list;
p_list = p_list->p_next;
WaveOutClearBuffer( p_sys->h_waveout, &p_whdr->hdr );
free(p_whdr);
}
}
static void WaveOutClearBuffer( HWAVEOUT h_waveout, WAVEHDR *p_waveheader )
{
block_t *p_buffer = (block_t *)(p_waveheader->dwUser);
/* Unprepare and free the buffers which has just been played */
waveOutUnprepareHeader( h_waveout, p_waveheader, sizeof(WAVEHDR) );
if( p_waveheader->dwUser != 1 )
block_Release( p_buffer );
}
/*
reload the configuration drop down list, of the Audio Devices
*/
static int ReloadWaveoutDevices( char const *psz_name,
char ***values, char ***descs )
{
int n = 0, nb_devices = waveOutGetNumDevs();
VLC_UNUSED( psz_name );
*values = xmalloc( (nb_devices + 1) * sizeof(char *) );
*descs = xmalloc( (nb_devices + 1) * sizeof(char *) );
(*values)[n] = strdup( "wavemapper" );
(*descs)[n] = strdup( _("Microsoft Soundmapper") );
n++;
for(int i = 0; i < nb_devices; i++)
{
WAVEOUTCAPS caps;
wchar_t dev_name[MAXPNAMELEN+32];
if(waveOutGetDevCaps(i, &caps, sizeof(WAVEOUTCAPS))
!= MMSYSERR_NOERROR)
continue;
_snwprintf(dev_name, MAXPNAMELEN + 32, device_name_fmt,
caps.szPname, caps.wMid, caps.wPid);
(*values)[n] = FromWide( dev_name );
(*descs)[n] = strdup( (*values)[n] );
n++;
}
return n;
}
VLC_CONFIG_STRING_ENUM(ReloadWaveoutDevices)
/*
convert devicename to device ID for output
if device not found return WAVE_MAPPER, so let
windows decide which preferred audio device
should be used.
*/
static uint32_t findDeviceID(char *psz_device_name)
{
if( !psz_device_name )
return WAVE_MAPPER;
uint32_t wave_devices = waveOutGetNumDevs();
for( uint32_t i = 0; i < wave_devices; i++ )
{
WAVEOUTCAPS caps;
wchar_t dev_name[MAXPNAMELEN+32];
if( waveOutGetDevCaps( i, &caps, sizeof(WAVEOUTCAPS) )
!= MMSYSERR_NOERROR )
continue;
_snwprintf( dev_name, MAXPNAMELEN + 32, device_name_fmt,
caps.szPname, caps.wMid, caps.wPid );
char *u8 = FromWide(dev_name);
if( !_stricmp(u8, psz_device_name) )
{
free( u8 );
return i;
}
free( u8 );
}
return WAVE_MAPPER;
}
static int DeviceSelect (audio_output_t *aout, const char *id)
{
var_SetString(aout, "waveout-audio-device", (id != NULL) ? id : "");
aout_DeviceReport (aout, id);
aout_RestartRequest (aout, AOUT_RESTART_OUTPUT);
return 0;
}
static int Open(vlc_object_t *obj)
{
audio_output_t *aout = (audio_output_t *)obj;
aout_sys_t *sys = malloc(sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
aout->sys = sys;
aout->start = Start;
aout->stop = Stop;
aout->volume_set = WaveoutVolumeSet;
aout->mute_set = WaveoutMuteSet;
aout->device_select = DeviceSelect;
sys->f_volume = var_InheritFloat(aout, "waveout-volume");
sys->b_mute = var_InheritBool(aout, "mute");
aout_MuteReport(aout, sys->b_mute);
aout_VolumeReport(aout, sys->f_volume );
if( vlc_timer_create( &sys->volume_poll_timer,
WaveoutPollVolume, aout ) )
{
msg_Err( aout, "Couldn't create volume polling timer" );
free( sys );
return VLC_ENOMEM;
}
vlc_mutex_init( &sys->lock );
vlc_cond_init( &sys->cond );
/* WaveOut does not support hot-plug events so list devices at startup */
char **ids, **names;
int count = ReloadWaveoutDevices(NULL, &ids, &names);
if (count >= 0)
{
for (int i = 0; i < count; i++)
{
aout_HotplugReport(aout, ids[i], names[i]);
free(names[i]);
free(ids[i]);
}
free(names);
free(ids);
}
char *dev = var_CreateGetNonEmptyString(aout, "waveout-audio-device");
aout_DeviceReport(aout, dev);
free(dev);
return VLC_SUCCESS;
}
static void Close(vlc_object_t *obj)
{
audio_output_t *aout = (audio_output_t *)obj;
aout_sys_t *sys = aout->sys;
var_Destroy(aout, "waveout-audio-device");
vlc_timer_destroy( sys->volume_poll_timer );
free(sys);
}
static int WaveOutTimeGet(audio_output_t * p_aout, vlc_tick_t *delay)
{
MMTIME mmtime;
mmtime.wType = TIME_SAMPLES;
aout_sys_t *sys = p_aout->sys;
if( !sys->i_frames )
return -1;
if( waveOutGetPosition( sys->h_waveout, &mmtime, sizeof(MMTIME) )
!= MMSYSERR_NOERROR )
{
msg_Err( p_aout, "waveOutGetPosition failed");
return -1;
}
vlc_tick_t i_pos = vlc_tick_from_samples(mmtime.u.sample, sys->i_rate);
*delay = sys->i_played_length - i_pos;
return 0;
}
static void WaveOutFlush( audio_output_t *p_aout)
{
MMRESULT res;
aout_sys_t *sys = p_aout->sys;
vlc_mutex_lock( &sys->lock );
sys->draining = false;
vlc_mutex_unlock( &sys->lock );
res = waveOutReset( sys->h_waveout );
sys->i_played_length = 0;
if( res != MMSYSERR_NOERROR )
msg_Err( p_aout, "waveOutReset failed");
}
static void WaveOutDrain( audio_output_t *p_aout)
{
aout_sys_t *sys = p_aout->sys;
vlc_mutex_lock( &sys->lock );
while( sys->i_frames )
{
vlc_cond_wait( &sys->cond, &sys->lock );
}
vlc_mutex_unlock( &sys->lock );
}
static void WaveOutDrainAsync( audio_output_t *p_aout)
{
aout_sys_t *sys = p_aout->sys;
vlc_mutex_lock( &sys->lock );
if( sys->i_frames == 0 )
aout_DrainedReport( p_aout );
else
sys->draining = true;
vlc_mutex_unlock( &sys->lock );
}
static void WaveOutPause( audio_output_t * p_aout, bool pause, vlc_tick_t date)
{
MMRESULT res;
(void) date;
aout_sys_t *sys = p_aout->sys;
if(pause)
{
vlc_timer_schedule_asap( sys->volume_poll_timer, VLC_TICK_FROM_MS(200) );
res = waveOutPause( sys->h_waveout );
if( res != MMSYSERR_NOERROR )
{
msg_Err( p_aout, "waveOutPause failed (0x%x)", res);
return;
}
}
else
{
vlc_timer_disarm( sys->volume_poll_timer );
res = waveOutRestart( sys->h_waveout );
if( res != MMSYSERR_NOERROR )
{
msg_Err( p_aout, "waveOutRestart failed (0x%x)", res);
return;
}
}
}
static int WaveoutVolumeSet( audio_output_t *p_aout, float volume )
{
aout_sys_t *sys = p_aout->sys;
if( sys->b_soft )
{
float gain = volume * volume * volume;
if ( !sys->b_mute && aout_GainRequest( p_aout, gain ) )
return -1;
}
else
{
const HWAVEOUT hwo = sys->h_waveout;
uint32_t vol = lroundf( volume * 0x7fff.fp0 );
if( !sys->b_mute )
{
if( vol > 0xffff )
{
vol = 0xffff;
volume = 2.0f;
}
MMRESULT r = waveOutSetVolume( hwo, vol | ( vol << 16 ) );
if( r != MMSYSERR_NOERROR )
{
msg_Err( p_aout, "waveOutSetVolume failed (%u)", r );
return -1;
}
}
}
vlc_mutex_lock(&sys->lock);
sys->f_volume = volume;
if( var_InheritBool( p_aout, "volume-save" ) )
config_PutFloat( "waveout-volume", volume );
aout_VolumeReport( p_aout, volume );
vlc_mutex_unlock(&sys->lock);
return 0;
}
static int WaveoutMuteSet( audio_output_t * p_aout, bool mute )
{
aout_sys_t *sys = p_aout->sys;
if( sys->b_soft )
{
float gain = sys->f_volume * sys->f_volume * sys->f_volume;
if ( aout_GainRequest( p_aout, mute ? 0.f : gain ) )
return -1;
}
else
{
const HWAVEOUT hwo = sys->h_waveout;
uint32_t vol = mute ? 0 : lroundf( sys->f_volume * 0x7fff.fp0 );
if( vol > 0xffff )
vol = 0xffff;
MMRESULT r = waveOutSetVolume( hwo, vol | ( vol << 16 ) );
if( r != MMSYSERR_NOERROR )
{
msg_Err( p_aout, "waveOutSetVolume failed (%u)", r );
return -1;
}
}
vlc_mutex_lock(&sys->lock);
sys->b_mute = mute;
aout_MuteReport( p_aout, mute );
vlc_mutex_unlock(&sys->lock);
return 0;
}
static void WaveoutPollVolume( void * _aout )
{
audio_output_t * aout = (audio_output_t *) _aout;
aout_sys_t *sys = aout->sys;
uint32_t vol;
MMRESULT r = waveOutGetVolume( sys->h_waveout, (LPDWORD) &vol );
if( r != MMSYSERR_NOERROR )
{
msg_Err( aout, "waveOutGetVolume failed (%u)", r );
return;
}
float volume = (float) ( vol & UINT32_C( 0xffff ) );
volume /= 0x7fff.fp0;
vlc_mutex_lock(&sys->lock);
if( !sys->b_mute && volume != sys->f_volume )
{
sys->f_volume = volume;
if( var_InheritBool( aout, "volume-save" ) )
config_PutFloat( "waveout-volume", volume );
aout_VolumeReport( aout, volume );
}
vlc_mutex_unlock(&sys->lock);
return;
}
View Git Blame Copy Permalink