/**
* Gets the list of available audio output modules.
*
* \return list of available audio outputs. It must be freed it with
*
* \see AudioOutputDescription::audioOutputListRelease()
*
* \see AudioOutputDescription . In case of error, NULL is returned.
*/
std::vector<AudioOutputDescription> audioOutputList()
{
libvlc_audio_output_t* result = libvlc_audio_output_list_get(*this);
std::vector<AudioOutputDescription> res;
if ( result == NULL )
return res;
libvlc_audio_output_t* p = result;
while ( p != NULL )
{
res.emplace_back( p );
p = p->p_next;
}
libvlc_audio_output_list_release(result);
return res;
}
/*****************************************
* Get the list of available audio outputs
*****************************************/
libvlc_audio_output_t *
libvlc_audio_output_list_get( libvlc_instance_t *p_instance,
libvlc_exception_t *p_e )
{
VLC_UNUSED( p_instance );
libvlc_audio_output_t *p_list = NULL,
*p_actual = NULL,
*p_previous = NULL;
module_t **module_list = module_list_get( NULL );
for (size_t i = 0; module_list[i]; i++)
{
module_t *p_module = module_list[i];
if( module_provides( p_module, "audio output" ) )
{
if( p_actual == NULL)
{
p_actual = ( libvlc_audio_output_t * )
malloc( sizeof( libvlc_audio_output_t ) );
if( p_actual == NULL )
{
libvlc_exception_raise( p_e );
libvlc_printerr( "Not enough memory" );
libvlc_audio_output_list_release( p_list );
module_list_free( module_list );
return NULL;
}
if( p_list == NULL )
{
p_list = p_actual;
p_previous = p_actual;
}
}
p_actual->psz_name = strdup( module_get_object( p_module ) );
p_actual->psz_description = strdup( module_get_name( p_module, true ) );
p_actual->p_next = NULL;
if( p_previous != p_actual ) /* not first item */
p_previous->p_next = p_actual;
p_previous = p_actual;
p_actual = p_actual->p_next;
}
}
module_list_free( module_list );
return p_list;
}
/*****************************************
* Get the list of available audio outputs
*****************************************/
libvlc_audio_output_t *
libvlc_audio_output_list_get( libvlc_instance_t *p_instance )
{
size_t count;
module_t **module_list = module_list_get( &count );
libvlc_audio_output_t *list = NULL;
for (size_t i = 0; i < count; i++)
{
module_t *module = module_list[i];
if( !module_provides( module, "audio output" ) )
continue;
libvlc_audio_output_t *item = malloc( sizeof( *item ) );
if( unlikely(item == NULL) )
{
error:
libvlc_printerr( "Not enough memory" );
libvlc_audio_output_list_release( list );
list = NULL;
break;
}
item->psz_name = strdup( module_get_object( module ) );
item->psz_description = strdup( module_get_name( module, true ) );
if( unlikely(item->psz_name == NULL || item->psz_description == NULL) )
{
free( item->psz_name );
free( item->psz_description );
free( item );
goto error;
}
item->p_next = list;
list = item;
}
module_list_free( module_list );
VLC_UNUSED( p_instance );
return list;
}
vector<VLC::deviceoutput> VLC::getDeviceOutputs(vector<string> &outputNames) {
// Get all attached audio devices
libvlc_audio_output_t *audioOutputs, *curAudioOutput;
audioOutputs = libvlc_audio_output_list_get(libvlcInstance);
curAudioOutput = audioOutputs;
vector<deviceoutput> outputs;
while (curAudioOutput) {
libvlc_audio_output_device_t *audioDevices, *curAudioDevice;
audioDevices = libvlc_audio_output_device_list_get(libvlcInstance, curAudioOutput->psz_name);
curAudioDevice = audioDevices;
while (curAudioDevice) {
outputNames.push_back(string(curAudioDevice->psz_device));
outputs.push_back({string(curAudioOutput->psz_name), string(curAudioDevice->psz_device), string(curAudioDevice->psz_description)});
curAudioDevice = curAudioDevice->p_next;
}
libvlc_audio_output_device_list_release(audioDevices);
audioDevices = NULL;
curAudioOutput = curAudioOutput->p_next;
}
libvlc_audio_output_list_release(audioOutputs);
audioOutputs = NULL;
return outputs;
}
