syn keyword cType audio_format_t video_format_t subs_format_t
syn keyword cType es_format_t video_palette_t
" Aout
- syn keyword cType aout_instance_t aout_sys_t
+ syn keyword cType audio_output_t aout_sys_t
syn keyword cType aout_fifo_t aout_input_t aout_buffer_t audio_sample_format_t
syn keyword cType aout_mixer_sys_t aout_filter_sys_t audio_volume_t
syn keyword cType aout_mixer_t aout_output_t audio_date_t
struct aout_mixer_t;
/** Audio output object */
-struct aout_instance_t
+struct audio_output
{
VLC_COMMON_MEMBERS
struct module_t *module; /**< Output plugin */
struct aout_sys_t *sys; /**< Output plugin private data */
- void (*pf_play)( aout_instance_t * ); /**< Audio buffer callback */
- void (* pf_pause)( aout_instance_t *, bool, mtime_t ); /**< Pause/resume
+ void (*pf_play)( audio_output_t * ); /**< Audio buffer callback */
+ void (* pf_pause)( audio_output_t *, bool, mtime_t ); /**< Pause/resume
callback (optional, may be NULL) */
- int (* pf_volume_set )(aout_instance_t *, float, bool); /**< Volume setter
+ int (* pf_volume_set )(audio_output_t *, float, bool); /**< Volume setter
(optional, may be NULL) */
int i_nb_samples;
};
* Prototypes
*****************************************************************************/
-VLC_API aout_buffer_t * aout_OutputNextBuffer( aout_instance_t *, mtime_t, bool ) VLC_USED;
+VLC_API aout_buffer_t * aout_OutputNextBuffer( audio_output_t *, mtime_t, bool ) VLC_USED;
/**
* This function computes the reordering needed to go from pi_chan_order_in to
VLC_API unsigned int aout_BitsPerSample( vlc_fourcc_t i_format ) VLC_USED;
VLC_API void aout_FormatPrepare( audio_sample_format_t * p_format );
-VLC_API void aout_FormatPrint( aout_instance_t * p_aout, const char * psz_text, const audio_sample_format_t * p_format );
+VLC_API void aout_FormatPrint( audio_output_t * p_aout, const char * psz_text, const audio_sample_format_t * p_format );
VLC_API const char * aout_FormatPrintChannels( const audio_sample_format_t * ) VLC_USED;
VLC_API mtime_t aout_FifoFirstDate( const aout_fifo_t * ) VLC_USED;
VLC_API aout_buffer_t *aout_FifoPop( aout_fifo_t * p_fifo ) VLC_USED;
/* From intf.c : */
-VLC_API void aout_VolumeSoftInit( aout_instance_t * );
-VLC_API void aout_VolumeNoneInit( aout_instance_t * );
+VLC_API void aout_VolumeSoftInit( audio_output_t * );
+VLC_API void aout_VolumeNoneInit( audio_output_t * );
VLC_API int aout_ChannelsRestart( vlc_object_t *, const char *, vlc_value_t, vlc_value_t, void * );
/* */
typedef struct video_palette_t video_palette_t;
/* Audio */
-typedef struct aout_instance_t aout_instance_t;
+typedef struct audio_output audio_output_t;
typedef struct aout_sys_t aout_sys_t;
typedef struct aout_fifo_t aout_fifo_t;
typedef struct aout_input_t aout_input_t;
/* cache" has changed */
INPUT_EVENT_CACHE,
- /* A aout_instance_t object has been created/deleted by *the input* */
+ /* A audio_output_t object has been created/deleted by *the input* */
INPUT_EVENT_AOUT,
/* A vout_thread_t object has been created/deleted by *the input* */
INPUT_EVENT_VOUT,
/* Input ressources
* XXX You must call vlc_object_release as soon as possible */
- INPUT_GET_AOUT, /* arg1=aout_instance_t ** res=can fail */
+ INPUT_GET_AOUT, /* arg1=audio_output_t ** res=can fail */
INPUT_GET_VOUTS, /* arg1=vout_thread_t ***, size_t * res=can fail */
- INPUT_GET_ES_OBJECTS, /* arg1=int id, vlc_object_t **dec, vout_thread_t **, aout_instance_t ** */
+ INPUT_GET_ES_OBJECTS, /* arg1=int id, vlc_object_t **dec, vout_thread_t **, audio_output_t ** */
/* External clock managments */
INPUT_GET_PCR_SYSTEM, /* arg1=mtime_t *, arg2=mtime_t * res=can fail */
* @return NULL on error, or the audio output (which needs to be
* released with vlc_object_release()).
*/
-static inline aout_instance_t *input_GetAout( input_thread_t *p_input )
+static inline audio_output_t *input_GetAout( input_thread_t *p_input )
{
- aout_instance_t *p_aout;
+ audio_output_t *p_aout;
return input_Control( p_input, INPUT_GET_AOUT, &p_aout ) ? NULL : p_aout;
}
*/
static inline int input_GetEsObjects( input_thread_t *p_input, int i_id,
vlc_object_t **pp_decoder,
- vout_thread_t **pp_vout, aout_instance_t **pp_aout )
+ vout_thread_t **pp_vout, audio_output_t **pp_aout )
{
return input_Control( p_input, INPUT_GET_ES_OBJECTS, i_id,
pp_decoder, pp_vout, pp_aout );
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close ( vlc_object_t * );
-static void Play ( aout_instance_t * );
+static void Play ( audio_output_t * );
static void* ALSAThread ( void * );
-static void ALSAFill ( aout_instance_t * );
+static void ALSAFill ( audio_output_t * );
static int FindDevicesCallback( vlc_object_t *p_this, char const *psz_name,
vlc_value_t newval, vlc_value_t oldval, void *p_unused );
static void GetDevices( vlc_object_t *, module_config_t * );
*****************************************************************************/
static int Open (vlc_object_t *obj)
{
- aout_instance_t * p_aout = (aout_instance_t *)obj;
+ audio_output_t * p_aout = (audio_output_t *)obj;
/* Get device name */
char *psz_device;
return VLC_EGENERIC;
}
-static void PlayIgnore( aout_instance_t *p_aout )
+static void PlayIgnore( audio_output_t *p_aout )
{ /* Already playing - nothing to do */
(void) p_aout;
}
/*****************************************************************************
* Play: start playback
*****************************************************************************/
-static void Play( aout_instance_t *p_aout )
+static void Play( audio_output_t *p_aout )
{
p_aout->pf_play = PlayIgnore;
*****************************************************************************/
static void Close (vlc_object_t *obj)
{
- aout_instance_t *p_aout = (aout_instance_t *)obj;
+ audio_output_t *p_aout = (audio_output_t *)obj;
struct aout_sys_t * p_sys = p_aout->sys;
/* Make sure that the thread will stop once it is waken up */
*****************************************************************************/
static void* ALSAThread( void *data )
{
- aout_instance_t * p_aout = data;
+ audio_output_t * p_aout = data;
struct aout_sys_t * p_sys = p_aout->sys;
/* Wait for the exact time to start playing (avoids resampling) */
/*****************************************************************************
* ALSAFill: function used to fill the ALSA buffer as much as possible
*****************************************************************************/
-static void ALSAFill( aout_instance_t * p_aout )
+static void ALSAFill( audio_output_t * p_aout )
{
struct aout_sys_t * p_sys = p_aout->sys;
snd_pcm_t *p_pcm = p_sys->p_snd_pcm;
void (*cleanup) (void *opaque);
};
-static void Play (aout_instance_t *aout)
+static void Play (audio_output_t *aout)
{
aout_sys_t *sys = aout->sys;
block_t *block;
}
}
-static int VolumeSet (aout_instance_t *aout, float vol, bool mute)
+static int VolumeSet (audio_output_t *aout, float vol, bool mute)
{
aout_sys_t *sys = aout->sys;
static int Open (vlc_object_t *obj)
{
- aout_instance_t *aout = (aout_instance_t *)obj;
+ audio_output_t *aout = (audio_output_t *)obj;
aout_sys_t *sys = malloc (sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
static void Close (vlc_object_t *obj)
{
- aout_instance_t *aout = (aout_instance_t *)obj;
+ audio_output_t *aout = (audio_output_t *)obj;
aout_sys_t *sys = aout->sys;
if (sys->cleanup != NULL)
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close ( vlc_object_t * );
-static void Play ( aout_instance_t * );
+static void Play ( audio_output_t * );
static void AudioQueueCallback (void *, AudioQueueRef, AudioQueueBufferRef);
/*****************************************************************************
static int Open ( vlc_object_t *p_this )
{
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
struct aout_sys_t *p_sys = malloc(sizeof(aout_sys_t));
p_aout->sys = p_sys;
/*****************************************************************************
* Play: play a sound samples buffer
*****************************************************************************/
-static void Play( aout_instance_t * p_aout )
+static void Play( audio_output_t * p_aout )
{
VLC_UNUSED(p_aout);
}
*****************************************************************************/
static void Close ( vlc_object_t *p_this )
{
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
struct aout_sys_t * p_sys = p_aout->sys;
msg_Dbg(p_aout, "Stopping AudioQueue");
}
void AudioQueueCallback(void * inUserData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffer) {
- aout_instance_t * p_aout = (aout_instance_t *)inUserData;
+ audio_output_t * p_aout = (audio_output_t *)inUserData;
aout_buffer_t * p_buffer = NULL;
if (p_aout) {
* Local prototypes.
*****************************************************************************/
static int Open ( vlc_object_t * );
-static int OpenAnalog ( aout_instance_t * );
-static int OpenSPDIF ( aout_instance_t * );
+static int OpenAnalog ( audio_output_t * );
+static int OpenSPDIF ( audio_output_t * );
static void Close ( vlc_object_t * );
-static void Play ( aout_instance_t * );
-static void Probe ( aout_instance_t * );
+static void Play ( audio_output_t * );
+static void Probe ( audio_output_t * );
static int AudioDeviceHasOutput ( AudioDeviceID );
-static int AudioDeviceSupportsDigital( aout_instance_t *, AudioDeviceID );
-static int AudioStreamSupportsDigital( aout_instance_t *, AudioStreamID );
-static int AudioStreamChangeFormat ( aout_instance_t *, AudioStreamID, AudioStreamBasicDescription );
+static int AudioDeviceSupportsDigital( audio_output_t *, AudioDeviceID );
+static int AudioStreamSupportsDigital( audio_output_t *, AudioStreamID );
+static int AudioStreamChangeFormat ( audio_output_t *, AudioStreamID, AudioStreamBasicDescription );
static OSStatus RenderCallbackAnalog ( vlc_object_t *, AudioUnitRenderActionFlags *, const AudioTimeStamp *,
unsigned int, unsigned int, AudioBufferList *);
UInt32 i_param_size = 0;
struct aout_sys_t *p_sys = NULL;
vlc_value_t val;
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
/* Use int here, to match kAudioDevicePropertyDeviceIsAlive
* property size */
/*****************************************************************************
* Open: open and setup a HAL AudioUnit to do analog (multichannel) audio output
*****************************************************************************/
-static int OpenAnalog( aout_instance_t *p_aout )
+static int OpenAnalog( audio_output_t *p_aout )
{
struct aout_sys_t *p_sys = p_aout->sys;
OSStatus err = noErr;
/*****************************************************************************
* Setup a encoded digital stream (SPDIF)
*****************************************************************************/
-static int OpenSPDIF( aout_instance_t * p_aout )
+static int OpenSPDIF( audio_output_t * p_aout )
{
struct aout_sys_t *p_sys = p_aout->sys;
OSStatus err = noErr;
*****************************************************************************/
static void Close( vlc_object_t * p_this )
{
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
struct aout_sys_t *p_sys = p_aout->sys;
OSStatus err = noErr;
UInt32 i_param_size = 0;
/*****************************************************************************
* Play: nothing to do
*****************************************************************************/
-static void Play( aout_instance_t * p_aout )
+static void Play( audio_output_t * p_aout )
{
VLC_UNUSED(p_aout);
}
/*****************************************************************************
* Probe: Check which devices the OS has, and add them to our audio-device menu
*****************************************************************************/
-static void Probe( aout_instance_t * p_aout )
+static void Probe( audio_output_t * p_aout )
{
OSStatus err = noErr;
UInt32 i_param_size = 0;
/*****************************************************************************
* AudioDeviceSupportsDigital: Check i_dev_id for digital stream support.
*****************************************************************************/
-static int AudioDeviceSupportsDigital( aout_instance_t *p_aout, AudioDeviceID i_dev_id )
+static int AudioDeviceSupportsDigital( audio_output_t *p_aout, AudioDeviceID i_dev_id )
{
OSStatus err = noErr;
UInt32 i_param_size = 0;
/*****************************************************************************
* AudioStreamSupportsDigital: Check i_stream_id for digital stream support.
*****************************************************************************/
-static int AudioStreamSupportsDigital( aout_instance_t *p_aout, AudioStreamID i_stream_id )
+static int AudioStreamSupportsDigital( audio_output_t *p_aout, AudioStreamID i_stream_id )
{
OSStatus err = noErr;
UInt32 i_param_size = 0;
/*****************************************************************************
* AudioStreamChangeFormat: Change i_stream_id to change_format
*****************************************************************************/
-static int AudioStreamChangeFormat( aout_instance_t *p_aout, AudioStreamID i_stream_id, AudioStreamBasicDescription change_format )
+static int AudioStreamChangeFormat( audio_output_t *p_aout, AudioStreamID i_stream_id, AudioStreamBasicDescription change_format )
{
OSStatus err = noErr;
UInt32 i_param_size = 0;
mtime_t current_date = 0;
uint32_t i_mData_bytes = 0;
- aout_instance_t * p_aout = (aout_instance_t *)_p_aout;
+ audio_output_t * p_aout = (audio_output_t *)_p_aout;
struct aout_sys_t * p_sys = p_aout->sys;
VLC_UNUSED(ioActionFlags);
aout_buffer_t * p_buffer;
mtime_t current_date;
- aout_instance_t * p_aout = (aout_instance_t *)threadGlobals;
+ audio_output_t * p_aout = (audio_output_t *)threadGlobals;
struct aout_sys_t * p_sys = p_aout->sys;
VLC_UNUSED(inDevice);
static OSStatus HardwareListener( AudioObjectID inObjectID, UInt32 inNumberAddresses, const AudioObjectPropertyAddress inAddresses[], void*inClientData)
{
OSStatus err = noErr;
- aout_instance_t *p_aout = (aout_instance_t *)inClientData;
+ audio_output_t *p_aout = (audio_output_t *)inClientData;
VLC_UNUSED(inObjectID);
for ( unsigned int i = 0; i < inNumberAddresses; i++ )
static int AudioDeviceCallback( vlc_object_t *p_this, const char *psz_variable,
vlc_value_t old_val, vlc_value_t new_val, void *param )
{
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
var_Set( p_aout->p_libvlc, "macosx-audio-device", new_val );
msg_Dbg( p_aout, "Set Device: %#"PRIx64, new_val.i_int );
return aout_ChannelsRestart( p_this, psz_variable, old_val, new_val, param );
*****************************************************************************/
typedef struct notification_thread_t
{
- aout_instance_t *p_aout;
+ audio_output_t *p_aout;
int i_frame_size; /* size in bytes of one frame */
int i_write_slot; /* current write position in our circular buffer */
*****************************************************************************/
static int OpenAudio ( vlc_object_t * );
static void CloseAudio ( vlc_object_t * );
-static void Play ( aout_instance_t * );
+static void Play ( audio_output_t * );
/* local functions */
-static void Probe ( aout_instance_t * );
-static int InitDirectSound ( aout_instance_t * );
-static int CreateDSBuffer ( aout_instance_t *, int, int, int, int, int, bool );
-static int CreateDSBufferPCM ( aout_instance_t *, vlc_fourcc_t*, int, int, int, bool );
-static void DestroyDSBuffer ( aout_instance_t * );
+static void Probe ( audio_output_t * );
+static int InitDirectSound ( audio_output_t * );
+static int CreateDSBuffer ( audio_output_t *, int, int, int, int, int, bool );
+static int CreateDSBufferPCM ( audio_output_t *, vlc_fourcc_t*, int, int, int, bool );
+static void DestroyDSBuffer ( audio_output_t * );
static void* DirectSoundThread( void * );
-static int FillBuffer ( aout_instance_t *, int, aout_buffer_t * );
+static int FillBuffer ( audio_output_t *, int, aout_buffer_t * );
static int ReloadDirectXDevices( vlc_object_t *, char const *,
vlc_value_t, vlc_value_t, void * );
*****************************************************************************/
static int OpenAudio( vlc_object_t *p_this )
{
- aout_instance_t * p_aout = (aout_instance_t *)p_this;
+ audio_output_t * p_aout = (audio_output_t *)p_this;
vlc_value_t val;
char * psz_speaker;
int i = 0;
/*****************************************************************************
* Probe: probe the audio device for available formats and channels
*****************************************************************************/
-static void Probe( aout_instance_t * p_aout )
+static void Probe( audio_output_t * p_aout )
{
vlc_value_t val, text;
vlc_fourcc_t i_format;
* we know the first buffer has been put in the aout fifo and we also
* know its date.
*****************************************************************************/
-static void Play( aout_instance_t *p_aout )
+static void Play( audio_output_t *p_aout )
{
if( !p_aout->sys->b_playing )
{
*****************************************************************************/
static void CloseAudio( vlc_object_t *p_this )
{
- aout_instance_t * p_aout = (aout_instance_t *)p_this;
+ audio_output_t * p_aout = (audio_output_t *)p_this;
aout_sys_t *p_sys = p_aout->sys;
msg_Dbg( p_aout, "closing audio device" );
{
VLC_UNUSED( psz_mod );
- aout_instance_t *p_aout = (aout_instance_t *)_p_aout;
+ audio_output_t *p_aout = (audio_output_t *)_p_aout;
char *psz_device = FromWide( psz_desc );
msg_Dbg( p_aout, "found device: %s", psz_device );
/*****************************************************************************
* InitDirectSound: handle all the gory details of DirectSound initialisation
*****************************************************************************/
-static int InitDirectSound( aout_instance_t *p_aout )
+static int InitDirectSound( audio_output_t *p_aout )
{
HRESULT (WINAPI *OurDirectSoundCreate)(LPGUID, LPDIRECTSOUND *, LPUNKNOWN);
HRESULT (WINAPI *OurDirectSoundEnumerate)(LPDSENUMCALLBACKW, LPVOID);
* Once you create a secondary buffer, you cannot change its format anymore so
* you have to release the current one and create another.
*****************************************************************************/
-static int CreateDSBuffer( aout_instance_t *p_aout, int i_format,
+static int CreateDSBuffer( audio_output_t *p_aout, int i_format,
int i_channels, int i_nb_channels, int i_rate,
int i_bytes_per_frame, bool b_probe )
{
* We first try to create a WAVE_FORMAT_IEEE_FLOAT buffer if supported by
* the hardware, otherwise we create a WAVE_FORMAT_PCM buffer.
****************************************************************************/
-static int CreateDSBufferPCM( aout_instance_t *p_aout, vlc_fourcc_t *i_format,
+static int CreateDSBufferPCM( audio_output_t *p_aout, vlc_fourcc_t *i_format,
int i_channels, int i_nb_channels, int i_rate,
bool b_probe )
{
*****************************************************************************
* This function destroys the secondary buffer.
*****************************************************************************/
-static void DestroyDSBuffer( aout_instance_t *p_aout )
+static void DestroyDSBuffer( audio_output_t *p_aout )
{
if( p_aout->sys->p_dsbuffer )
{
*****************************************************************************
* Returns VLC_SUCCESS on success.
*****************************************************************************/
-static int FillBuffer( aout_instance_t *p_aout, int i_frame,
+static int FillBuffer( audio_output_t *p_aout, int i_frame,
aout_buffer_t *p_buffer )
{
notification_thread_t *p_notif = p_aout->sys->p_notif;
static void* DirectSoundThread( void *data )
{
notification_thread_t *p_notif = (notification_thread_t*)data;
- aout_instance_t *p_aout = p_notif->p_aout;
+ audio_output_t *p_aout = p_notif->p_aout;
mtime_t last_time;
int canc = vlc_savecancel ();
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close ( vlc_object_t * );
-static void Play ( aout_instance_t * );
+static void Play ( audio_output_t * );
/*****************************************************************************
* Module descriptor
*****************************************************************************/
static int Open( vlc_object_t * p_this )
{
- aout_instance_t * p_aout = (aout_instance_t *)p_this;
+ audio_output_t * p_aout = (audio_output_t *)p_this;
char * psz_name, * psz_format;
const char * const * ppsz_compare = format_list;
int i_channels, i = 0;
*****************************************************************************/
static void Close( vlc_object_t * p_this )
{
- aout_instance_t * p_aout = (aout_instance_t *)p_this;
+ audio_output_t * p_aout = (audio_output_t *)p_this;
msg_Dbg( p_aout, "closing audio file" );
/*****************************************************************************
* Play: pretend to play a sound
*****************************************************************************/
-static void Play( aout_instance_t * p_aout )
+static void Play( audio_output_t * p_aout )
{
aout_buffer_t * p_buffer;
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close ( vlc_object_t * );
-static void Play ( aout_instance_t * );
+static void Play ( audio_output_t * );
static int Process ( jack_nframes_t i_frames, void *p_arg );
static int GraphChange ( void *p_arg );
static int Open( vlc_object_t *p_this )
{
char psz_name[32];
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
struct aout_sys_t *p_sys = NULL;
int status = VLC_SUCCESS;
unsigned int i;
int Process( jack_nframes_t i_frames, void *p_arg )
{
unsigned int i, j, i_nb_samples = 0;
- aout_instance_t *p_aout = (aout_instance_t*) p_arg;
+ audio_output_t *p_aout = (audio_output_t*) p_arg;
struct aout_sys_t *p_sys = p_aout->sys;
jack_sample_t *p_src = NULL;
static int GraphChange( void *p_arg )
{
- aout_instance_t *p_aout = (aout_instance_t*) p_arg;
+ audio_output_t *p_aout = (audio_output_t*) p_arg;
struct aout_sys_t *p_sys = p_aout->sys;
unsigned int i;
jack_nframes_t port_latency;
/*****************************************************************************
* Play: nothing to do
*****************************************************************************/
-static void Play( aout_instance_t *p_aout )
+static void Play( audio_output_t *p_aout )
{
VLC_UNUSED( p_aout );
}
static void Close( vlc_object_t *p_this )
{
int i_error;
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
struct aout_sys_t *p_sys = p_aout->sys;
i_error = jack_deactivate( p_sys->p_jack_client );
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close ( vlc_object_t * );
-static void Play ( aout_instance_t * );
+static void Play ( audio_output_t * );
static void PlayedCallback ( SLAndroidSimpleBufferQueueItf caller, void *pContext);
/*****************************************************************************
*****************************************************************************/
static int Open( vlc_object_t * p_this )
{
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
SLresult result;
/* Allocate structure */
*****************************************************************************/
static void Close( vlc_object_t * p_this )
{
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
aout_sys_t *p_sys = p_aout->sys;
msg_Dbg( p_aout, "Closing OpenSLES" );
/*****************************************************************************
* Play: play a sound
*****************************************************************************/
-static void Play( aout_instance_t * p_aout )
+static void Play( audio_output_t * p_aout )
{
aout_sys_t * p_sys = p_aout->sys;
aout_buffer_t *p_buffer;
static int Open ( vlc_object_t * );
static void Close ( vlc_object_t * );
-static void Play ( aout_instance_t * );
+static void Play ( audio_output_t * );
static void* OSSThread ( void * );
-static mtime_t BufferDuration( aout_instance_t * p_aout );
+static mtime_t BufferDuration( audio_output_t * p_aout );
/*****************************************************************************
* Module descriptor
/*****************************************************************************
* Probe: probe the audio device for available formats and channels
*****************************************************************************/
-static void Probe( aout_instance_t * p_aout )
+static void Probe( audio_output_t * p_aout )
{
struct aout_sys_t * p_sys = p_aout->sys;
vlc_value_t val, text;
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
- aout_instance_t * p_aout = (aout_instance_t *)p_this;
+ audio_output_t * p_aout = (audio_output_t *)p_this;
struct aout_sys_t * p_sys;
char * psz_device;
vlc_value_t val;
/*****************************************************************************
* Play: nothing to do
*****************************************************************************/
-static void Play( aout_instance_t *p_aout )
+static void Play( audio_output_t *p_aout )
{
VLC_UNUSED(p_aout);
}
*****************************************************************************/
static void Close( vlc_object_t * p_this )
{
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
struct aout_sys_t * p_sys = p_aout->sys;
vlc_cancel( p_sys->thread );
*****************************************************************************
* This function returns the duration in microseconds of the current buffer.
*****************************************************************************/
-static mtime_t BufferDuration( aout_instance_t * p_aout )
+static mtime_t BufferDuration( audio_output_t * p_aout )
{
struct aout_sys_t * p_sys = p_aout->sys;
audio_buf_info audio_buf;
*****************************************************************************/
static void* OSSThread( void *obj )
{
- aout_instance_t * p_aout = (aout_instance_t*)obj;
+ audio_output_t * p_aout = (audio_output_t*)obj;
struct aout_sys_t * p_sys = p_aout->sys;
mtime_t next_date = 0;
*****************************************************************************/
typedef struct
{
- aout_instance_t *p_aout;
+ audio_output_t *p_aout;
vlc_thread_t thread;
vlc_cond_t wait;
struct aout_sys_t
{
- aout_instance_t *p_aout;
+ audio_output_t *p_aout;
PaStream *p_stream;
PaDeviceIndex i_devices;
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close ( vlc_object_t * );
-static void Play ( aout_instance_t * );
+static void Play ( audio_output_t * );
-static int PAOpenDevice( aout_instance_t * );
-static int PAOpenStream( aout_instance_t * );
+static int PAOpenDevice( audio_output_t * );
+static int PAOpenStream( audio_output_t * );
/*****************************************************************************
* Module descriptor
VLC_UNUSED( inputBuffer ); VLC_UNUSED( statusFlags );
struct aout_sys_t *p_sys = (struct aout_sys_t*) p_cookie;
- aout_instance_t *p_aout = p_sys->p_aout;
+ audio_output_t *p_aout = p_sys->p_aout;
aout_buffer_t *p_buffer;
mtime_t out_date;
*****************************************************************************/
static int Open( vlc_object_t * p_this )
{
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
struct aout_sys_t * p_sys;
msg_Dbg( p_aout, "entering Open()");
*****************************************************************************/
static void Close ( vlc_object_t *p_this )
{
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
aout_sys_t *p_sys = p_aout->sys;
msg_Dbg( p_aout, "closing portaudio");
free( p_sys );
}
-static int PAOpenDevice( aout_instance_t *p_aout )
+static int PAOpenDevice( audio_output_t *p_aout )
{
aout_sys_t *p_sys = p_aout->sys;
const PaDeviceInfo *p_pdi;
return VLC_EGENERIC;
}
-static int PAOpenStream( aout_instance_t *p_aout )
+static int PAOpenStream( audio_output_t *p_aout )
{
aout_sys_t *p_sys = p_aout->sys;
const PaHostErrorInfo* paLastHostErrorInfo = Pa_GetLastHostErrorInfo();
/*****************************************************************************
* Play: play sound
*****************************************************************************/
-static void Play( aout_instance_t * p_aout )
+static void Play( audio_output_t * p_aout )
{
VLC_UNUSED( p_aout );
}
static void* PORTAUDIOThread( void *data )
{
pa_thread_t *pa_thread = (pa_thread_t*)data;
- aout_instance_t *p_aout;
+ audio_output_t *p_aout;
aout_sys_t *p_sys;
int i_err;
int canc = vlc_savecancel ();
static void sink_list_cb(pa_context *c, const pa_sink_info *i, int eol,
void *userdata)
{
- aout_instance_t *aout = userdata;
+ audio_output_t *aout = userdata;
vlc_value_t val, text;
if (eol)
static void sink_info_cb(pa_context *c, const pa_sink_info *i, int eol,
void *userdata)
{
- aout_instance_t *aout = userdata;
+ audio_output_t *aout = userdata;
aout_sys_t *sys = aout->sys;
if (eol)
}
/*** Stream helpers ***/
-static void stream_reset_sync(pa_stream *s, aout_instance_t *aout)
+static void stream_reset_sync(pa_stream *s, audio_output_t *aout)
{
aout_sys_t *sys = aout->sys;
const unsigned rate = aout->format.i_rate;
/* Latency management and lip synchronization */
static void stream_latency_cb(pa_stream *s, void *userdata)
{
- aout_instance_t *aout = userdata;
+ audio_output_t *aout = userdata;
aout_sys_t *sys = aout->sys;
mtime_t delta, change;
static void stream_moved_cb(pa_stream *s, void *userdata)
{
- aout_instance_t *aout = userdata;
+ audio_output_t *aout = userdata;
aout_sys_t *sys = aout->sys;
pa_operation *op;
uint32_t idx = pa_stream_get_device_index(s);
static void stream_overflow_cb(pa_stream *s, void *userdata)
{
- aout_instance_t *aout = userdata;
+ audio_output_t *aout = userdata;
msg_Err(aout, "overflow");
(void) s;
static void stream_started_cb(pa_stream *s, void *userdata)
{
- aout_instance_t *aout = userdata;
+ audio_output_t *aout = userdata;
msg_Dbg(aout, "started");
(void) s;
static void stream_suspended_cb(pa_stream *s, void *userdata)
{
- aout_instance_t *aout = userdata;
+ audio_output_t *aout = userdata;
msg_Dbg(aout, "suspended");
stream_reset_sync(s, aout);
static void stream_underflow_cb(pa_stream *s, void *userdata)
{
- aout_instance_t *aout = userdata;
+ audio_output_t *aout = userdata;
pa_operation *op;
msg_Warn(aout, "underflow");
/**
* Queue one audio frame to the playabck stream
*/
-static void Play(aout_instance_t *aout)
+static void Play(audio_output_t *aout)
{
aout_sys_t *sys = aout->sys;
pa_stream *s = sys->stream;
/**
* Cork or uncork the playback stream
*/
-static void Pause(aout_instance_t *aout, bool b_paused, mtime_t i_date)
+static void Pause(audio_output_t *aout, bool b_paused, mtime_t i_date)
{
aout_sys_t *sys = aout->sys;
pa_stream *s = sys->stream;
(void) i_date;
}
-static int VolumeSet(aout_instance_t *aout, float vol, bool mute)
+static int VolumeSet(audio_output_t *aout, float vol, bool mute)
{
aout_sys_t *sys = aout->sys;
pa_operation *op;
static int StreamMove(vlc_object_t *obj, const char *varname, vlc_value_t old,
vlc_value_t val, void *userdata)
{
- aout_instance_t *aout = (aout_instance_t *)obj;
+ audio_output_t *aout = (audio_output_t *)obj;
aout_sys_t *sys = aout->sys;
pa_stream *s = userdata;
pa_operation *op;
*/
static int Open(vlc_object_t *obj)
{
- aout_instance_t *aout = (aout_instance_t *)obj;
+ audio_output_t *aout = (audio_output_t *)obj;
pa_operation *op;
/* Sample format specification */
*/
static void Close (vlc_object_t *obj)
{
- aout_instance_t *aout = (aout_instance_t *)obj;
+ audio_output_t *aout = (audio_output_t *)obj;
aout_sys_t *sys = aout->sys;
pa_context *ctx = sys->context;
pa_stream *s = sys->stream;
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close ( vlc_object_t * );
-static void Play ( aout_instance_t * );
+static void Play ( audio_output_t * );
static void SDLCallback ( void *, uint8_t *, int );
/*****************************************************************************
*****************************************************************************/
static int Open ( vlc_object_t *p_this )
{
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
SDL_AudioSpec desired, obtained;
int i_nb_channels;
vlc_value_t val, text;
/*****************************************************************************
* Play: play a sound samples buffer
*****************************************************************************/
-static void Play( aout_instance_t * p_aout )
+static void Play( audio_output_t * p_aout )
{
VLC_UNUSED(p_aout);
}
*****************************************************************************/
static void SDLCallback( void * _p_aout, uint8_t * p_stream, int i_len )
{
- aout_instance_t * p_aout = (aout_instance_t *)_p_aout;
+ audio_output_t * p_aout = (audio_output_t *)_p_aout;
aout_buffer_t * p_buffer;
/* SDL is unable to call us at regular times, or tell us its current
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close ( vlc_object_t * );
-static void Play ( aout_instance_t * );
+static void Play ( audio_output_t * );
/*****************************************************************************
* notification_thread_t: waveOut event thread
*****************************************************************************/
/* local functions */
-static void Probe ( aout_instance_t * );
-static int OpenWaveOut ( aout_instance_t *, uint32_t,
+static void Probe ( audio_output_t * );
+static int OpenWaveOut ( audio_output_t *, uint32_t,
int, int, int, int, bool );
-static int OpenWaveOutPCM( aout_instance_t *, uint32_t,
+static int OpenWaveOutPCM( audio_output_t *, uint32_t,
vlc_fourcc_t*, int, int, int, bool );
-static int PlayWaveOut ( aout_instance_t *, HWAVEOUT, WAVEHDR *,
+static int PlayWaveOut ( audio_output_t *, HWAVEOUT, WAVEHDR *,
aout_buffer_t *, bool );
static void CALLBACK WaveOutCallback ( HWAVEOUT, UINT, DWORD, DWORD, DWORD );
static void* WaveOutThread( void * );
-static int VolumeSet( aout_instance_t *, float, bool );
+static int VolumeSet( audio_output_t *, float, bool );
static int WaveOutClearDoneBuffers(aout_sys_t *p_sys);
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
vlc_value_t val;
/* Allocate structure */
/*****************************************************************************
* Probe: probe the audio device for available formats and channels
*****************************************************************************/
-static void Probe( aout_instance_t * p_aout )
+static void Probe( audio_output_t * p_aout )
{
vlc_value_t val, text;
vlc_fourcc_t i_format;
* This doesn't actually play the buffer. This just stores the buffer so it
* can be played by the callback thread.
*****************************************************************************/
-static void Play( aout_instance_t *_p_aout )
+static void Play( audio_output_t *_p_aout )
{
if( !_p_aout->sys->b_playing )
{
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
aout_sys_t *p_sys = p_aout->sys;
/* Before calling waveOutClose we must reset the device */
/*****************************************************************************
* OpenWaveOut: open the waveout sound device
****************************************************************************/
-static int OpenWaveOut( aout_instance_t *p_aout, uint32_t i_device_id, int i_format,
+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 )
{
/*****************************************************************************
* OpenWaveOutPCM: open a PCM waveout sound device
****************************************************************************/
-static int OpenWaveOutPCM( aout_instance_t *p_aout, uint32_t i_device_id,
+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 )
/*****************************************************************************
* PlayWaveOut: play a buffer through the WaveOut device
*****************************************************************************/
-static int PlayWaveOut( aout_instance_t *p_aout, HWAVEOUT h_waveout,
+static int PlayWaveOut( audio_output_t *p_aout, HWAVEOUT h_waveout,
WAVEHDR *p_waveheader, aout_buffer_t *p_buffer,
bool b_spdif)
{
DWORD dwParam1, DWORD dwParam2 )
{
(void)h_waveout; (void)dwParam1; (void)dwParam2;
- aout_instance_t *p_aout = (aout_instance_t *)_p_aout;
+ audio_output_t *p_aout = (audio_output_t *)_p_aout;
int i_queued_frames = 0;
if( uMsg != WOM_DONE ) return;
*****************************************************************************/
static void* WaveOutThread( void *data )
{
- aout_instance_t *p_aout = data;
+ audio_output_t *p_aout = data;
aout_sys_t *p_sys = p_aout->sys;
aout_buffer_t *p_buffer = NULL;
WAVEHDR *p_waveheader = p_sys->waveheader;
return NULL;
}
-static int VolumeSet( aout_instance_t * p_aout, float volume, bool mute )
+static int VolumeSet( audio_output_t * p_aout, float volume, bool mute )
{
if( mute )
volume = 0.;
- (void)setAudioFilter: (char *)psz_name on:(BOOL)b_on
{
char *psz_tmp;
- aout_instance_t * p_aout = getAout();
+ audio_output_t * p_aout = getAout();
if( p_aout )
psz_tmp = var_GetNonEmptyString( p_aout, "audio-filter" );
else
- (IBAction)eq_twopass:(id)sender
{
bool b_2p = [sender state] ? true : false;
- aout_instance_t *p_aout = getAout();
+ audio_output_t *p_aout = getAout();
vlc_object_t *p_object= VLC_OBJECT(p_aout);
if( p_object == NULL )
p_object = vlc_object_hold(pl_Get( p_intf ));
config_PutFloat( p_intf, "compressor-knee", 2.500000 );
config_PutFloat( p_intf, "compressor-makeup-gain", 7.000000 );
- aout_instance_t * p_aout = getAout();
+ audio_output_t * p_aout = getAout();
if (p_aout) {
var_SetFloat( p_aout, "compressor-rms-peak", 0.000000 );
var_SetFloat( p_aout, "compressor-attack", 25.000000 );
- (IBAction)comp_sliderUpdated:(id)sender
{
- aout_instance_t * p_aout = getAout();
+ audio_output_t * p_aout = getAout();
char * value;
if( sender == o_comp_band1_sld )
value = "compressor-rms-peak";
config_PutFloat( p_intf, "spatializer-dry", 2.000000 );
config_PutFloat( p_intf, "spatializer-damp", 1.000000 );
- aout_instance_t * p_aout = getAout();
+ audio_output_t * p_aout = getAout();
if (p_aout) {
var_SetFloat( p_aout, "spatializer-roomsize", 1.050000 );
var_SetFloat( p_aout, "spatializer-width", 10.000000 );
- (IBAction)spat_sliderUpdated:(id)sender
{
- aout_instance_t * p_aout = getAout();
+ audio_output_t * p_aout = getAout();
char * value;
if( sender == o_spat_band1_sld )
value = "spatializer-roomsize";
- (IBAction)filter_volNormSliderUpdated:(id)sender
{
- aout_instance_t * p_aout= getAout();
+ audio_output_t * p_aout= getAout();
if( p_aout )
{
if( [o_mi_videotrack isEnabled] == YES )
[o_mi_subtitle setEnabled: YES];
- aout_instance_t * p_aout = input_GetAout( p_input );
+ audio_output_t * p_aout = input_GetAout( p_input );
if( p_aout != NULL )
{
[self setupVarMenuItem: o_mi_channels target: (vlc_object_t *)p_aout
// You need to release those objects after use
input_thread_t *getInput(void);
vout_thread_t *getVout(void);
-aout_instance_t *getAout(void);
+audio_output_t *getAout(void);
/*****************************************************************************
* intf_sys_t: description and status of the interface
return p_vout;
}
-aout_instance_t *getAout(void)
+audio_output_t *getAout(void)
{
input_thread_t *p_input = getInput();
if (!p_input)
return NULL;
- aout_instance_t *p_aout = input_GetAout(p_input);
+ audio_output_t *p_aout = input_GetAout(p_input);
vlc_object_release(p_input);
return p_aout;
}
if( !p_input )
return false;
- aout_instance_t *aout = input_GetAout( p_input );
+ audio_output_t *aout = input_GetAout( p_input );
if( !aout )
return false;
return p_input ? input_GetVout( p_input ) : NULL;
}
-aout_instance_t * MainInputManager::getAout()
+audio_output_t * MainInputManager::getAout()
{
return p_input ? input_GetAout( p_input ) : NULL;
}
}
vout_thread_t* getVout();
- aout_instance_t *getAout();
+ audio_output_t *getAout();
bool getPlayExitState();
private:
return VLC_SUCCESS;
}
-static int AudioAutoMenuBuilder( aout_instance_t *p_object,
+static int AudioAutoMenuBuilder( audio_output_t *p_object,
input_thread_t *p_input,
vector<vlc_object_t *> &objects,
vector<const char *> &varnames )
{
vector<vlc_object_t *> objects;
vector<const char *> varnames;
- aout_instance_t *p_aout;
+ audio_output_t *p_aout;
input_thread_t *p_input;
if( current->isEmpty() )
POPUP_BOILERPLATE
if( p_input )
{
- aout_instance_t *p_aout = THEMIM->getAout();
+ audio_output_t *p_aout = THEMIM->getAout();
AudioAutoMenuBuilder( p_aout, p_input, objects, varnames );
if( p_aout )
vlc_object_release( p_aout );
case INPUT_EVENT_AOUT:
{
- aout_instance_t* pAout = input_GetAout( pInput );
+ audio_output_t* pAout = input_GetAout( pInput );
// end of input or aout reuse (nothing to do)
if( !pAout || pAout == m_pAout )
void VlcProc::on_audio_filter_changed( vlc_object_t* p_obj, vlc_value_t newVal )
{
(void)newVal;
- aout_instance_t* pAout = (aout_instance_t*) p_obj;
+ audio_output_t* pAout = (audio_output_t*) p_obj;
char *pFilters = newVal.psz_string;
class OSTimer;
class VarBool;
-struct aout_instance_t;
+struct audio_output_t;
struct vout_window_t;
/// Vout thread
vout_thread_t *m_pVout;
/// Audio output
- aout_instance_t *m_pAout;
+ audio_output_t *m_pAout;
bool m_bEqualizer_started;
/**
void EqualizerBands::onUpdate( Subject<VarPercent> &rBand, void *arg )
{
(void)rBand; (void)arg;
- aout_instance_t *pAout = NULL;
+ audio_output_t *pAout = NULL;
playlist_t *pPlaylist = getIntf()->p_sys->p_playlist;
input_thread_t *pInput = playlist_CurrentInput( pPlaylist );
void EqualizerPreamp::set( float percentage, bool updateVLC )
{
- aout_instance_t *pAout = NULL;
+ audio_output_t *pAout = NULL;
playlist_t *pPlaylist = getIntf()->p_sys->p_playlist;
input_thread_t *pInput = playlist_CurrentInput( pPlaylist );
if( !p_input )
return 0;
- aout_instance_t *p_aout = input_GetAout( p_input );
+ audio_output_t *p_aout = input_GetAout( p_input );
vlc_object_release( p_input );
char *psz_af = var_GetNonEmptyString( p_aout, "audio-filter" );
if( !p_input )
return 0;
- aout_instance_t *p_aout = input_GetAout( p_input );
+ audio_output_t *p_aout = input_GetAout( p_input );
vlc_object_release( p_input );
if( !p_aout )
return 0;
if( !p_input )
return 0;
- aout_instance_t *p_aout = input_GetAout( p_input );
+ audio_output_t *p_aout = input_GetAout( p_input );
vlc_object_release( p_input );
if( !p_aout )
return 0;
return 0;
int i_pos = 0 , j = 0;
- aout_instance_t *p_aout = input_GetAout( p_input );
+ audio_output_t *p_aout = input_GetAout( p_input );
vlc_object_release( p_input );
if( !p_aout )
return 0;
/*****************************************************************************
* Local prototypes.
*****************************************************************************/
-static void Play ( aout_instance_t * );
+static void Play ( audio_output_t * );
/*****************************************************************************
* OpenAudio: open a dummy audio device
*****************************************************************************/
int OpenAudio ( vlc_object_t * p_this )
{
- aout_instance_t * p_aout = (aout_instance_t *)p_this;
+ audio_output_t * p_aout = (audio_output_t *)p_this;
p_aout->pf_play = Play;
p_aout->pf_pause = NULL;
/*****************************************************************************
* Play: pretend to play a sound
*****************************************************************************/
-static void Play( aout_instance_t * p_aout )
+static void Play( audio_output_t * p_aout )
{
aout_buffer_t * p_buffer = aout_FifoPop( &p_aout->fifo );
aout_BufferFree( p_buffer );
struct filter_owner_sys_t
{
- aout_instance_t *p_aout;
+ audio_output_t *p_aout;
aout_input_t *p_input;
};
*****************************************************************************/
/* From input.c : */
-int aout_InputNew( aout_instance_t * p_aout, aout_input_t * p_input, const aout_request_vout_t * );
-int aout_InputDelete( aout_instance_t * p_aout, aout_input_t * p_input );
-void aout_InputPlay( aout_instance_t * p_aout, aout_input_t * p_input,
+int aout_InputNew( audio_output_t * p_aout, aout_input_t * p_input, const aout_request_vout_t * );
+int aout_InputDelete( audio_output_t * p_aout, aout_input_t * p_input );
+void aout_InputPlay( audio_output_t * p_aout, aout_input_t * p_input,
aout_buffer_t * p_buffer, int i_input_rate );
-void aout_InputCheckAndRestart( aout_instance_t * p_aout, aout_input_t * p_input );
+void aout_InputCheckAndRestart( audio_output_t * p_aout, aout_input_t * p_input );
/* From filters.c : */
-int aout_FiltersCreatePipeline( aout_instance_t *, filter_t **, int *,
+int aout_FiltersCreatePipeline( audio_output_t *, filter_t **, int *,
const audio_sample_format_t *, const audio_sample_format_t * );
void aout_FiltersDestroyPipeline( filter_t *const *, unsigned );
void aout_FiltersPlay( filter_t *const *, unsigned, aout_buffer_t ** );
/* From mixer.c : */
-int aout_MixerNew( aout_instance_t * p_aout );
-void aout_MixerDelete( aout_instance_t * p_aout );
-void aout_MixerRun( aout_instance_t * p_aout, float );
+int aout_MixerNew( audio_output_t * p_aout );
+void aout_MixerDelete( audio_output_t * p_aout );
+void aout_MixerRun( audio_output_t * p_aout, float );
/* From output.c : */
-int aout_OutputNew( aout_instance_t * p_aout,
+int aout_OutputNew( audio_output_t * p_aout,
const audio_sample_format_t * p_format );
-void aout_OutputPlay( aout_instance_t * p_aout, aout_buffer_t * p_buffer );
-void aout_OutputPause( aout_instance_t * p_aout, bool, mtime_t );
-void aout_OutputDelete( aout_instance_t * p_aout );
+void aout_OutputPlay( audio_output_t * p_aout, aout_buffer_t * p_buffer );
+void aout_OutputPause( audio_output_t * p_aout, bool, mtime_t );
+void aout_OutputDelete( audio_output_t * p_aout );
/* From common.c : */
/* Release with vlc_object_release() */
-aout_instance_t *aout_New ( vlc_object_t * );
+audio_output_t *aout_New ( vlc_object_t * );
#define aout_New(a) aout_New(VLC_OBJECT(a))
void aout_FifoInit( vlc_object_t *, aout_fifo_t *, uint32_t );
void aout_FifoSet( aout_fifo_t *, mtime_t );
void aout_FifoMoveDates( aout_fifo_t *, mtime_t );
void aout_FifoDestroy( aout_fifo_t * p_fifo );
-void aout_FormatsPrint( aout_instance_t * p_aout, const char * psz_text, const audio_sample_format_t * p_format1, const audio_sample_format_t * p_format2 );
-bool aout_ChangeFilterString( vlc_object_t *, aout_instance_t *, const char *psz_variable, const char *psz_name, bool b_add );
+void aout_FormatsPrint( audio_output_t * p_aout, const char * psz_text, const audio_sample_format_t * p_format1, const audio_sample_format_t * p_format2 );
+bool aout_ChangeFilterString( vlc_object_t *, audio_output_t *, const char *psz_variable, const char *psz_name, bool b_add );
/* From dec.c */
-aout_input_t *aout_DecNew( aout_instance_t *, audio_sample_format_t *,
+aout_input_t *aout_DecNew( audio_output_t *, audio_sample_format_t *,
const audio_replay_gain_t *, const aout_request_vout_t * );
-void aout_DecDelete ( aout_instance_t *, aout_input_t * );
+void aout_DecDelete ( audio_output_t *, aout_input_t * );
aout_buffer_t * aout_DecNewBuffer( aout_input_t *, size_t );
-void aout_DecDeleteBuffer( aout_instance_t *, aout_input_t *, aout_buffer_t * );
-int aout_DecPlay( aout_instance_t *, aout_input_t *, aout_buffer_t *, int i_input_rate );
-int aout_DecGetResetLost( aout_instance_t *, aout_input_t * );
-void aout_DecChangePause( aout_instance_t *, aout_input_t *, bool b_paused, mtime_t i_date );
-void aout_DecFlush( aout_instance_t *, aout_input_t * );
-bool aout_DecIsEmpty( aout_instance_t * p_aout, aout_input_t * p_input );
+void aout_DecDeleteBuffer( audio_output_t *, aout_input_t *, aout_buffer_t * );
+int aout_DecPlay( audio_output_t *, aout_input_t *, aout_buffer_t *, int i_input_rate );
+int aout_DecGetResetLost( audio_output_t *, aout_input_t * );
+void aout_DecChangePause( audio_output_t *, aout_input_t *, bool b_paused, mtime_t i_date );
+void aout_DecFlush( audio_output_t *, aout_input_t * );
+bool aout_DecIsEmpty( audio_output_t * p_aout, aout_input_t * p_input );
/* Audio output locking */
# define aout_unlock_check( i ) (void)0
#endif
-static inline void aout_lock( aout_instance_t *p_aout )
+static inline void aout_lock( audio_output_t *p_aout )
{
aout_lock_check( OUTPUT_LOCK );
vlc_mutex_lock( &p_aout->lock );
}
-static inline void aout_unlock( aout_instance_t *p_aout )
+static inline void aout_unlock( audio_output_t *p_aout )
{
aout_unlock_check( OUTPUT_LOCK );
vlc_mutex_unlock( &p_aout->lock );
}
-static inline void aout_lock_volume( aout_instance_t *p_aout )
+static inline void aout_lock_volume( audio_output_t *p_aout )
{
aout_lock_check( VOLUME_LOCK );
vlc_mutex_lock( &p_aout->volume_lock );
}
-static inline void aout_unlock_volume( aout_instance_t *p_aout )
+static inline void aout_unlock_volume( audio_output_t *p_aout )
{
aout_unlock_check( VOLUME_LOCK );
vlc_mutex_unlock( &p_aout->volume_lock );
/**
* This function will safely mark aout input to be restarted as soon as
* possible to take configuration changes into account */
-static inline void AoutInputsMarkToRestart( aout_instance_t *p_aout )
+static inline void AoutInputsMarkToRestart( audio_output_t *p_aout )
{
aout_lock( p_aout );
if( p_aout->p_input != NULL )
/*****************************************************************************
* aout_New: initialize aout structure
*****************************************************************************/
-aout_instance_t *aout_New( vlc_object_t * p_parent )
+audio_output_t *aout_New( vlc_object_t * p_parent )
{
- aout_instance_t * p_aout;
+ audio_output_t * p_aout;
/* Allocate descriptor. */
p_aout = vlc_custom_create( p_parent, sizeof( *p_aout ), "audio output" );
*****************************************************************************/
static void aout_Destructor( vlc_object_t * p_this )
{
- aout_instance_t * p_aout = (aout_instance_t *)p_this;
+ audio_output_t * p_aout = (audio_output_t *)p_this;
vlc_mutex_destroy( &p_aout->volume_lock );
vlc_mutex_destroy( &p_aout->lock );
}
/*****************************************************************************
* aout_FormatPrint : print a format in a human-readable form
*****************************************************************************/
-void aout_FormatPrint( aout_instance_t * p_aout, const char * psz_text,
+void aout_FormatPrint( audio_output_t * p_aout, const char * psz_text,
const audio_sample_format_t * p_format )
{
msg_Dbg( p_aout, "%s '%4.4s' %d Hz %s frame=%d samples/%d bytes", psz_text,
/*****************************************************************************
* aout_FormatsPrint : print two formats in a human-readable form
*****************************************************************************/
-void aout_FormatsPrint( aout_instance_t * p_aout, const char * psz_text,
+void aout_FormatsPrint( audio_output_t * p_aout, const char * psz_text,
const audio_sample_format_t * p_format1,
const audio_sample_format_t * p_format2 )
{
/* This function will add or remove a a module from a string list (colon
* separated). It will return true if there is a modification
* In case p_aout is NULL, we will use configuration instead of variable */
-bool aout_ChangeFilterString( vlc_object_t *p_obj, aout_instance_t *p_aout,
+bool aout_ChangeFilterString( vlc_object_t *p_obj, audio_output_t *p_aout,
const char *psz_variable,
const char *psz_name, bool b_add )
{
/**
* Creates an audio output
*/
-aout_input_t *aout_DecNew( aout_instance_t *p_aout,
+aout_input_t *aout_DecNew( audio_output_t *p_aout,
audio_sample_format_t *p_format,
const audio_replay_gain_t *p_replay_gain,
const aout_request_vout_t *p_request_vout )
/*****************************************************************************
* aout_DecDelete : delete a decoder
*****************************************************************************/
-void aout_DecDelete( aout_instance_t * p_aout, aout_input_t * p_input )
+void aout_DecDelete( audio_output_t * p_aout, aout_input_t * p_input )
{
aout_lock( p_aout );
/* Remove the input. */
/*****************************************************************************
* aout_DecDeleteBuffer : destroy an undecoded buffer
*****************************************************************************/
-void aout_DecDeleteBuffer( aout_instance_t * p_aout, aout_input_t * p_input,
+void aout_DecDeleteBuffer( audio_output_t * p_aout, aout_input_t * p_input,
aout_buffer_t * p_buffer )
{
(void)p_aout; (void)p_input;
/*****************************************************************************
* aout_DecPlay : filter & mix the decoded buffer
*****************************************************************************/
-int aout_DecPlay( aout_instance_t * p_aout, aout_input_t * p_input,
+int aout_DecPlay( audio_output_t * p_aout, aout_input_t * p_input,
aout_buffer_t * p_buffer, int i_input_rate )
{
assert( i_input_rate >= INPUT_RATE_DEFAULT / AOUT_MAX_INPUT_RATE &&
return 0;
}
-int aout_DecGetResetLost( aout_instance_t *p_aout, aout_input_t *p_input )
+int aout_DecGetResetLost( audio_output_t *p_aout, aout_input_t *p_input )
{
int val;
return val;
}
-void aout_DecChangePause( aout_instance_t *p_aout, aout_input_t *p_input, bool b_paused, mtime_t i_date )
+void aout_DecChangePause( audio_output_t *p_aout, aout_input_t *p_input, bool b_paused, mtime_t i_date )
{
mtime_t i_duration = 0;
aout_unlock( p_aout );
}
-void aout_DecFlush( aout_instance_t *p_aout, aout_input_t *p_input )
+void aout_DecFlush( audio_output_t *p_aout, aout_input_t *p_input )
{
aout_lock( p_aout );
aout_FifoSet( &p_input->mixer.fifo, 0 );
aout_unlock( p_aout );
}
-bool aout_DecIsEmpty( aout_instance_t * p_aout, aout_input_t * p_input )
+bool aout_DecIsEmpty( audio_output_t * p_aout, aout_input_t * p_input )
{
mtime_t end_date;
/*****************************************************************************
* FindFilter: find an audio filter for a specific transformation
*****************************************************************************/
-static filter_t * FindFilter( aout_instance_t * p_aout,
+static filter_t * FindFilter( audio_output_t * p_aout,
const audio_sample_format_t * p_input_format,
const audio_sample_format_t * p_output_format )
{
* @param outfmt output audio format
* @return 0 on success, -1 on failure
*/
-int aout_FiltersCreatePipeline( aout_instance_t *obj,
+int aout_FiltersCreatePipeline( audio_output_t *obj,
filter_t **filters,
int *nb_filters,
const audio_sample_format_t *restrict infmt,
#define AOUT_ASSERT_LOCKED vlc_assert_locked( &p_aout->lock )
-static void inputFailure( aout_instance_t *, aout_input_t *, const char * );
+static void inputFailure( audio_output_t *, aout_input_t *, const char * );
static void inputDrop( aout_input_t *, aout_buffer_t * );
static void inputResamplingStop( aout_input_t *p_input );
vlc_value_t, vlc_value_t, void * );
static int ReplayGainCallback( vlc_object_t *, char const *,
vlc_value_t, vlc_value_t, void * );
-static void ReplayGainSelect( aout_instance_t *, aout_input_t * );
+static void ReplayGainSelect( audio_output_t *, aout_input_t * );
static vout_thread_t *RequestVout( void *,
vout_thread_t *, video_format_t *, bool );
/*****************************************************************************
* aout_InputNew : allocate a new input and rework the filter pipeline
*****************************************************************************/
-int aout_InputNew( aout_instance_t * p_aout, aout_input_t * p_input, const aout_request_vout_t *p_request_vout )
+int aout_InputNew( audio_output_t * p_aout, aout_input_t * p_input, const aout_request_vout_t *p_request_vout )
{
audio_sample_format_t chain_input_format;
audio_sample_format_t chain_output_format;
*****************************************************************************
* This function must be entered with the mixer lock.
*****************************************************************************/
-int aout_InputDelete( aout_instance_t * p_aout, aout_input_t * p_input )
+int aout_InputDelete( audio_output_t * p_aout, aout_input_t * p_input )
{
AOUT_ASSERT_LOCKED;
if ( p_input->b_error )
*****************************************************************************
* This function must be entered with the input and mixer lock.
*****************************************************************************/
-void aout_InputCheckAndRestart( aout_instance_t * p_aout, aout_input_t * p_input )
+void aout_InputCheckAndRestart( audio_output_t * p_aout, aout_input_t * p_input )
{
AOUT_ASSERT_LOCKED;
*****************************************************************************/
/* XXX Do not activate it !! */
//#define AOUT_PROCESS_BEFORE_CHEKS
-void aout_InputPlay( aout_instance_t * p_aout, aout_input_t * p_input,
+void aout_InputPlay( audio_output_t * p_aout, aout_input_t * p_input,
aout_buffer_t * p_buffer, int i_input_rate )
{
mtime_t start_date;
* static functions
*****************************************************************************/
-static void inputFailure( aout_instance_t * p_aout, aout_input_t * p_input,
+static void inputFailure( audio_output_t * p_aout, aout_input_t * p_input,
const char * psz_error_message )
{
/* error message */
static vout_thread_t *RequestVout( void *p_private,
vout_thread_t *p_vout, video_format_t *p_fmt, bool b_recycle )
{
- aout_instance_t *p_aout = p_private;
+ audio_output_t *p_aout = p_private;
VLC_UNUSED(b_recycle);
vout_configuration_t cfg = {
.vout = p_vout,
p_vout, p_fmt, p_input->b_recycle_vout );
}
-static int ChangeFiltersString( aout_instance_t * p_aout, const char* psz_variable,
+static int ChangeFiltersString( audio_output_t * p_aout, const char* psz_variable,
const char *psz_name, bool b_add )
{
return aout_ChangeFilterString( VLC_OBJECT(p_aout), p_aout,
static int VisualizationCallback( vlc_object_t *p_this, char const *psz_cmd,
vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
char *psz_mode = newval.psz_string;
(void)psz_cmd; (void)oldval; (void)p_data;
static int EqualizerCallback( vlc_object_t *p_this, char const *psz_cmd,
vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
char *psz_mode = newval.psz_string;
int i_ret;
(void)psz_cmd; (void)oldval; (void)p_data;
{
VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval);
VLC_UNUSED(newval); VLC_UNUSED(p_data);
- aout_instance_t *p_aout = (aout_instance_t *)p_this;
+ audio_output_t *p_aout = (audio_output_t *)p_this;
aout_lock( p_aout );
if( p_aout->p_input != NULL )
return VLC_SUCCESS;
}
-static void ReplayGainSelect( aout_instance_t *p_aout, aout_input_t *p_input )
+static void ReplayGainSelect( audio_output_t *p_aout, aout_input_t *p_input )
{
char *psz_replay_gain = var_GetNonEmptyString( p_aout,
"audio-replay-gain-mode" );
#include <vlc_playlist.h>
-static aout_instance_t *findAout (vlc_object_t *obj)
+static audio_output_t *findAout (vlc_object_t *obj)
{
input_thread_t *(*pf_find_input) (vlc_object_t *);
if (p_input == NULL)
return NULL;
- aout_instance_t *p_aout = input_GetAout (p_input);
+ audio_output_t *p_aout = input_GetAout (p_input);
vlc_object_release (p_input);
return p_aout;
}
#define findAout(o) findAout(VLC_OBJECT(o))
/** Start a volume change transaction. */
-static void prepareVolume (vlc_object_t *obj, aout_instance_t **aoutp,
+static void prepareVolume (vlc_object_t *obj, audio_output_t **aoutp,
audio_volume_t *volp, bool *mutep)
{
- aout_instance_t *aout = findAout (obj);
+ audio_output_t *aout = findAout (obj);
/* FIXME: we need interlocking even if aout does not exist! */
*aoutp = aout;
}
/** Commit a volume change transaction. */
-static int commitVolume (vlc_object_t *obj, aout_instance_t *aout,
+static int commitVolume (vlc_object_t *obj, audio_output_t *aout,
audio_volume_t volume, bool mute)
{
int ret = 0;
#if 0
/** Cancel a volume change transaction. */
-static void cancelVolume (vlc_object_t *obj, aout_instance_t *aout)
+static void cancelVolume (vlc_object_t *obj, audio_output_t *aout)
{
(void) obj;
if (aout != NULL)
audio_volume_t aout_VolumeGet (vlc_object_t *obj)
{
#if 0
- aout_instance_t *aout;
+ audio_output_t *aout;
audio_volume_t volume;
prepareVolume (obj, &aout, &volume, NULL);
*/
int aout_VolumeSet (vlc_object_t *obj, audio_volume_t volume)
{
- aout_instance_t *aout;
+ audio_output_t *aout;
bool mute;
prepareVolume (obj, &aout, NULL, &mute);
*/
int aout_VolumeUp (vlc_object_t *obj, int value, audio_volume_t *volp)
{
- aout_instance_t *aout;
+ audio_output_t *aout;
int ret;
audio_volume_t volume;
bool mute;
*/
int aout_ToggleMute (vlc_object_t *obj, audio_volume_t *volp)
{
- aout_instance_t *aout;
+ audio_output_t *aout;
int ret;
audio_volume_t volume;
bool mute;
bool aout_IsMuted (vlc_object_t *obj)
{
#if 0
- aout_instance_t *aout;
+ audio_output_t *aout;
bool mute;
prepareVolume (obj, &aout, NULL, &mute);
*/
int aout_SetMute (vlc_object_t *obj, audio_volume_t *volp, bool mute)
{
- aout_instance_t *aout;
+ audio_output_t *aout;
int ret;
audio_volume_t volume;
* The next functions are not supposed to be called by the interface, but
* are placeholders for software-only scaling.
*/
-static int aout_VolumeSoftSet (aout_instance_t *aout, float volume, bool mute)
+static int aout_VolumeSoftSet (audio_output_t *aout, float volume, bool mute)
{
aout->mixer_multiplier = mute ? 0. : volume;
return 0;
}
/* Meant to be called by the output plug-in's Open(). */
-void aout_VolumeSoftInit (aout_instance_t *aout)
+void aout_VolumeSoftInit (audio_output_t *aout)
{
audio_volume_t volume = var_InheritInteger (aout, "volume");
bool mute = var_InheritBool (aout, "mute");
* The next functions are not supposed to be called by the interface, but
* are placeholders for unsupported scaling.
*/
-static int aout_VolumeNoneSet (aout_instance_t *aout, float volume, bool mute)
+static int aout_VolumeNoneSet (audio_output_t *aout, float volume, bool mute)
{
(void)aout; (void)volume; (void)mute;
return -1;
}
/* Meant to be called by the output plug-in's Open(). */
-void aout_VolumeNoneInit( aout_instance_t * p_aout )
+void aout_VolumeNoneInit( audio_output_t * p_aout )
{
p_aout->pf_volume_set = aout_VolumeNoneSet;
}
* This function is used whenever the parameters of the output plug-in are
* changed (eg. selecting S/PDIF or PCM).
*****************************************************************************/
-static int aout_Restart( aout_instance_t * p_aout )
+static int aout_Restart( audio_output_t * p_aout )
{
aout_input_t *p_input;
vlc_value_t oldval, vlc_value_t newval,
void *p_data )
{
- aout_instance_t * p_aout = (aout_instance_t *)p_this;
+ audio_output_t * p_aout = (audio_output_t *)p_this;
(void)oldval; (void)newval; (void)p_data;
if ( !strcmp( psz_variable, "audio-device" ) )
void aout_EnableFilter( vlc_object_t *p_this, const char *psz_name,
bool b_add )
{
- aout_instance_t *p_aout = findAout( p_this );
+ audio_output_t *p_aout = findAout( p_this );
if( aout_ChangeFilterString( p_this, p_aout, "audio-filter", psz_name, b_add ) )
{
*****************************************************************************
* Please note that you must hold the mixer lock.
*****************************************************************************/
-int aout_MixerNew( aout_instance_t * p_aout )
+int aout_MixerNew( audio_output_t * p_aout )
{
assert( !p_aout->p_mixer );
vlc_assert_locked( &p_aout->lock );
*****************************************************************************
* Please note that you must hold the mixer lock.
*****************************************************************************/
-void aout_MixerDelete( aout_instance_t * p_aout )
+void aout_MixerDelete( audio_output_t * p_aout )
{
vlc_assert_locked( &p_aout->lock );
*****************************************************************************
* Please note that you must hold the mixer lock.
*****************************************************************************/
-static int MixBuffer( aout_instance_t * p_aout, float volume )
+static int MixBuffer( audio_output_t * p_aout, float volume )
{
aout_mixer_t *p_mixer = p_aout->p_mixer;
aout_mixer_input_t *p_input = p_mixer->input;
*****************************************************************************
* Please note that you must hold the mixer lock.
*****************************************************************************/
-void aout_MixerRun( aout_instance_t * p_aout, float volume )
+void aout_MixerRun( audio_output_t * p_aout, float volume )
{
while( MixBuffer( p_aout, volume ) != -1 );
}
*****************************************************************************
* This function is entered with the mixer lock.
*****************************************************************************/
-int aout_OutputNew( aout_instance_t * p_aout,
+int aout_OutputNew( audio_output_t * p_aout,
const audio_sample_format_t * p_format )
{
vlc_assert_locked( &p_aout->lock );
*****************************************************************************
* This function is entered with the mixer lock.
*****************************************************************************/
-void aout_OutputDelete( aout_instance_t * p_aout )
+void aout_OutputDelete( audio_output_t * p_aout )
{
vlc_assert_locked( &p_aout->lock );
*****************************************************************************
* This function is entered with the mixer lock.
*****************************************************************************/
-void aout_OutputPlay( aout_instance_t * p_aout, aout_buffer_t * p_buffer )
+void aout_OutputPlay( audio_output_t * p_aout, aout_buffer_t * p_buffer )
{
vlc_assert_locked( &p_aout->lock );
* This enables the output to expedite pause, instead of waiting for its
* buffers to drain.
*/
-void aout_OutputPause( aout_instance_t *aout, bool pause, mtime_t date )
+void aout_OutputPause( audio_output_t *aout, bool pause, mtime_t date )
{
vlc_assert_locked( &aout->lock );
* compensate it by itself. S/PDIF outputs should always set b_can_sleek = 1.
* This function is entered with no lock at all :-).
*****************************************************************************/
-aout_buffer_t * aout_OutputNextBuffer( aout_instance_t * p_aout,
+aout_buffer_t * aout_OutputNextBuffer( audio_output_t * p_aout,
mtime_t start_date,
bool b_can_sleek )
{
#include "media_player_internal.h"
/*
- * Remember to release the returned aout_instance_t since it is locked at
+ * Remember to release the returned audio_output_t since it is locked at
* the end of this function.
*/
-static aout_instance_t *GetAOut( libvlc_media_player_t *mp )
+static audio_output_t *GetAOut( libvlc_media_player_t *mp )
{
assert( mp != NULL );
if( p_input == NULL )
return NULL;
- aout_instance_t * p_aout = input_GetAout( p_input );
+ audio_output_t * p_aout = input_GetAout( p_input );
vlc_object_release( p_input );
if( p_aout == NULL )
libvlc_printerr( "No active audio output" );
*****************************************************************************/
int libvlc_audio_output_get_device_type( libvlc_media_player_t *mp )
{
- aout_instance_t *p_aout = GetAOut( mp );
+ audio_output_t *p_aout = GetAOut( mp );
if( p_aout )
{
int i_device_type = var_GetInteger( p_aout, "audio-device" );
void libvlc_audio_output_set_device_type( libvlc_media_player_t *mp,
int device_type )
{
- aout_instance_t *p_aout = GetAOut( mp );
+ audio_output_t *p_aout = GetAOut( mp );
if( !p_aout )
return;
if( var_SetInteger( p_aout, "audio-device", device_type ) < 0 )
*****************************************************************************/
int libvlc_audio_get_channel( libvlc_media_player_t *mp )
{
- aout_instance_t *p_aout = GetAOut( mp );
+ audio_output_t *p_aout = GetAOut( mp );
if( !p_aout )
return 0;
*****************************************************************************/
int libvlc_audio_set_channel( libvlc_media_player_t *mp, int channel )
{
- aout_instance_t *p_aout = GetAOut( mp );
+ audio_output_t *p_aout = GetAOut( mp );
int ret = 0;
if( !p_aout )
case INPUT_GET_AOUT:
{
- aout_instance_t *p_aout = input_resource_HoldAout( p_input->p->p_resource );
+ audio_output_t *p_aout = input_resource_HoldAout( p_input->p->p_resource );
if( !p_aout )
return VLC_EGENERIC;
- aout_instance_t **pp_aout = (aout_instance_t**)va_arg( args, aout_instance_t** );
+ audio_output_t **pp_aout = (audio_output_t**)va_arg( args, audio_output_t** );
*pp_aout = p_aout;
return VLC_SUCCESS;
}
const int i_id = va_arg( args, int );
vlc_object_t **pp_decoder = va_arg( args, vlc_object_t ** );
vout_thread_t **pp_vout = va_arg( args, vout_thread_t ** );
- aout_instance_t **pp_aout = va_arg( args, aout_instance_t ** );
+ audio_output_t **pp_aout = va_arg( args, audio_output_t ** );
return es_out_Control( p_input->p->p_es_out_display, ES_OUT_GET_ES_OBJECTS_BY_ID, i_id,
pp_decoder, pp_vout, pp_aout );
vlc_cond_t wait_acknowledge;
/* -- These variables need locking on write(only) -- */
- aout_instance_t *p_aout;
+ audio_output_t *p_aout;
aout_input_t *p_aout_input;
vout_thread_t *p_vout;
}
void input_DecoderGetObjects( decoder_t *p_dec,
- vout_thread_t **pp_vout, aout_instance_t **pp_aout )
+ vout_thread_t **pp_vout, audio_output_t **pp_aout )
{
decoder_owner_sys_t *p_owner = p_dec->p_owner;
int *pi_played_sum, int *pi_lost_sum )
{
decoder_owner_sys_t *p_owner = p_dec->p_owner;
- aout_instance_t *p_aout = p_owner->p_aout;
+ audio_output_t *p_aout = p_owner->p_aout;
aout_input_t *p_aout_input = p_owner->p_aout_input;
/* */
while( (p_aout_buf = p_dec->pf_decode_audio( p_dec, &p_block )) )
{
- aout_instance_t *p_aout = p_owner->p_aout;
+ audio_output_t *p_aout = p_owner->p_aout;
aout_input_t *p_aout_input = p_owner->p_aout_input;
if( DecoderIsExitRequested( p_dec ) )
p_owner->audio.i_bytes_per_frame ) )
{
aout_input_t *p_aout_input = p_owner->p_aout_input;
- aout_instance_t *p_aout = p_owner->p_aout;
+ audio_output_t *p_aout = p_owner->p_aout;
/* Parameters changed, restart the aout */
vlc_mutex_lock( &p_owner->lock );
const int i_force_dolby = var_InheritInteger( p_dec, "force-dolby-surround" );
audio_sample_format_t format;
aout_input_t *p_aout_input;
- aout_instance_t *p_aout;
+ audio_output_t *p_aout;
aout_request_vout_t request_vout;
p_dec->fmt_out.audio.i_format = p_dec->fmt_out.i_codec;
*
* They must be released using vlc_object_release().
*/
-void input_DecoderGetObjects( decoder_t *, vout_thread_t **, aout_instance_t ** );
+void input_DecoderGetObjects( decoder_t *, vout_thread_t **, audio_output_t ** );
#endif
vlc_object_t **pp_decoder = va_arg( args, vlc_object_t ** );
vout_thread_t **pp_vout = va_arg( args, vout_thread_t ** );
- aout_instance_t **pp_aout = va_arg( args, aout_instance_t ** );
+ audio_output_t **pp_aout = va_arg( args, audio_output_t ** );
if( p_es->p_dec )
{
if( pp_decoder )
ES_OUT_SET_ES_BY_ID,
ES_OUT_RESTART_ES_BY_ID,
ES_OUT_SET_ES_DEFAULT_BY_ID,
- ES_OUT_GET_ES_OBJECTS_BY_ID, /* arg1=int id, vlc_object_t **dec, vout_thread_t **, aout_instance_t ** res=can fail*/
+ ES_OUT_GET_ES_OBJECTS_BY_ID, /* arg1=int id, vlc_object_t **dec, vout_thread_t **, audio_output_t ** res=can fail*/
/* Get buffering state */
ES_OUT_GET_BUFFERING, /* arg1=bool* res=cannot fail */
assert( !i_ret );
}
static inline int es_out_GetEsObjects( es_out_t *p_out, int i_id,
- vlc_object_t **pp_decoder, vout_thread_t **pp_vout, aout_instance_t **pp_aout )
+ vlc_object_t **pp_decoder, vout_thread_t **pp_vout, audio_output_t **pp_aout )
{
return es_out_Control( p_out, ES_OUT_GET_ES_OBJECTS_BY_ID, i_id, pp_decoder, pp_vout, pp_aout );
}
/* TODO? track more than one audio output (like video outputs) */
bool b_aout_busy;
- aout_instance_t *p_aout;
+ audio_output_t *p_aout;
};
/* */
}
static void ReleaseAout( input_resource_t *p_resource,
- aout_instance_t *p_aout )
+ audio_output_t *p_aout )
{
msg_Dbg( p_resource->p_parent, "releasing audio output" );
if( likely(p_aout == p_resource->p_aout) )
vlc_object_release( p_aout );
}
-static aout_instance_t *AllocateAout( input_resource_t *p_resource )
+static audio_output_t *AllocateAout( input_resource_t *p_resource )
{
- aout_instance_t *p_aout;
+ audio_output_t *p_aout;
if( unlikely(p_resource->b_aout_busy) )
{
return p_aout;
}
-static aout_instance_t *RequestAout( input_resource_t *p_resource, aout_instance_t *p_aout )
+static audio_output_t *RequestAout( input_resource_t *p_resource, audio_output_t *p_aout )
{
vlc_assert_locked( &p_resource->lock );
return AllocateAout( p_resource );
}
-static aout_instance_t *HoldAout( input_resource_t *p_resource )
+static audio_output_t *HoldAout( input_resource_t *p_resource )
{
vlc_mutex_lock( &p_resource->lock_hold );
- aout_instance_t *p_aout = p_resource->p_aout;
+ audio_output_t *p_aout = p_resource->p_aout;
if( p_aout )
vlc_object_hold( p_aout );
{
vlc_mutex_lock( &p_resource->lock_hold );
- aout_instance_t *p_aout = p_resource->p_aout;
+ audio_output_t *p_aout = p_resource->p_aout;
p_resource->p_aout = NULL;
vlc_mutex_unlock( &p_resource->lock_hold );
}
/* */
-aout_instance_t *input_resource_RequestAout( input_resource_t *p_resource, aout_instance_t *p_aout )
+audio_output_t *input_resource_RequestAout( input_resource_t *p_resource, audio_output_t *p_aout )
{
vlc_mutex_lock( &p_resource->lock );
- aout_instance_t *p_ret = RequestAout( p_resource, p_aout );
+ audio_output_t *p_ret = RequestAout( p_resource, p_aout );
vlc_mutex_unlock( &p_resource->lock );
return p_ret;
}
-aout_instance_t *input_resource_HoldAout( input_resource_t *p_resource )
+audio_output_t *input_resource_HoldAout( input_resource_t *p_resource )
{
return HoldAout( p_resource );
}
/**
* This function handles aout request.
*/
-aout_instance_t *input_resource_RequestAout( input_resource_t *, aout_instance_t * );
+audio_output_t *input_resource_RequestAout( input_resource_t *, audio_output_t * );
/**
* This function returns the current aout if any.
*
* You must call vlc_object_release on the value returned (if non NULL).
*/
-aout_instance_t *input_resource_HoldAout( input_resource_t *p_resource );
+audio_output_t *input_resource_HoldAout( input_resource_t *p_resource );
/**
* This function handles vout request.
projects / vlc / commitdiff