*****************************************************************************/
struct aout_sys_t
{
- AudioObjectID i_default_dev; /* DeviceID of defaultOutputDevice */
AudioObjectID i_selected_dev; /* DeviceID of the selected device */
AudioObjectID i_new_selected_dev; /* DeviceID of device which will be selected on start */
bool b_selected_dev_is_digital;
AudioDeviceIOProcID i_procID; /* DeviceID of current device */
bool b_digital; /* Are we running in digital mode? */
- mtime_t clock_diff; /* Difference between VLC clock and Device clock */
uint8_t chans_to_reorder; /* do we need channel reordering */
uint8_t chan_table[AOUT_CHAN_MAX];
- UInt32 i_numberOfChannels;
TPCircularBuffer circular_buffer; /* circular buffer to swap the audio data */
/* AUHAL specific */
CFArrayRef device_list;
+ vlc_mutex_t var_lock; /* protects access to device_list and i_selected_dev */
+
+ float f_volume;
+ bool b_mute;
+
vlc_mutex_t lock;
vlc_cond_t cond;
};
static OSStatus RenderCallbackSPDIF (AudioDeviceID, const AudioTimeStamp *, const void *, const AudioTimeStamp *,
AudioBufferList *, const AudioTimeStamp *, void *);
-static OSStatus HardwareListener (AudioObjectID, UInt32, const AudioObjectPropertyAddress *, void *);
+static OSStatus DevicesListener (AudioObjectID, UInt32, const AudioObjectPropertyAddress *, void *);
+static OSStatus DeviceAliveListener (AudioObjectID, UInt32, const AudioObjectPropertyAddress *, void *);
+static OSStatus StreamsChangedListener (AudioObjectID, UInt32, const AudioObjectPropertyAddress *, void *);
+
static OSStatus StreamListener (AudioObjectID, UInt32, const AudioObjectPropertyAddress *, void *);
-static int RegisterAudioStreamsCallback(audio_output_t *, AudioDeviceID);
+static int ManageAudioStreamsCallback(audio_output_t *p_aout, AudioDeviceID i_dev_id, bool b_register);
static int AudioDeviceHasOutput (AudioDeviceID);
static int AudioDeviceSupportsDigital(audio_output_t *, AudioDeviceID);
static int AudioStreamSupportsDigital(audio_output_t *, AudioStreamID);
OSStatus err = noErr;
+ vlc_mutex_init(&p_sys->var_lock);
vlc_mutex_init(&p_sys->lock);
vlc_cond_init(&p_sys->cond);
p_sys->b_digital = false;
/* Attach a Listener so that we are notified of a change in the Device setup */
AudioObjectPropertyAddress audioDevicesAddress = { kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
- err = AudioObjectAddPropertyListener(kAudioObjectSystemObject, &audioDevicesAddress, HardwareListener, (void *)p_aout);
+ err = AudioObjectAddPropertyListener(kAudioObjectSystemObject, &audioDevicesAddress, DevicesListener, (void *)p_aout);
if (err != noErr)
- msg_Warn(p_aout, "failed to add listener for audio device configuration [%4.4s]", (char *)&err);
+ msg_Err(p_aout, "failed to add listener for audio device configuration [%4.4s]", (char *)&err);
RebuildDeviceList(p_aout);
/* remember the volume */
- aout_VolumeReport(p_aout, var_InheritInteger(p_aout, "auhal-volume") / (float)AOUT_VOLUME_DEFAULT);
- MuteSet(p_aout, var_InheritBool(p_aout, "mute"));
+ p_sys->f_volume = var_InheritInteger(p_aout, "auhal-volume") / (float)AOUT_VOLUME_DEFAULT;
+ aout_VolumeReport(p_aout, p_sys->f_volume);
+ p_sys->b_mute = var_InheritBool(p_aout, "mute");
+ aout_MuteReport(p_aout, p_sys->b_mute);
- SwitchAudioDevice(p_aout, config_GetPsz(p_aout, "auhal-audio-device"));
+ char *psz_audio_device = config_GetPsz(p_aout, "auhal-audio-device");
+ SwitchAudioDevice(p_aout, psz_audio_device);
+ free(psz_audio_device);
return VLC_SUCCESS;
}
/* remove audio devices callback */
AudioObjectPropertyAddress audioDevicesAddress = { kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
- err = AudioObjectRemovePropertyListener(kAudioObjectSystemObject, &audioDevicesAddress, HardwareListener, (void *)p_aout);
+ err = AudioObjectRemovePropertyListener(kAudioObjectSystemObject, &audioDevicesAddress, DevicesListener, (void *)p_aout);
if (err != noErr)
msg_Err(p_aout, "AudioHardwareRemovePropertyListener failed [%4.4s]", (char *)&err);
-
- /* remove audio device alive callback */
- AudioObjectPropertyAddress deviceAliveAddress = { kAudioDevicePropertyDeviceIsAlive, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
- err = AudioObjectRemovePropertyListener(p_sys->i_selected_dev, &deviceAliveAddress, HardwareListener, (void *)p_aout);
- if (err != noErr)
- msg_Err(p_aout, "failed to remove audio device life checker [%4.4s]", (char *)&err);
-
- /* remove audio streams callback */
- if (p_sys->i_stream_id > 0) {
- AudioObjectPropertyAddress physicalFormatsAddress = { kAudioStreamPropertyAvailablePhysicalFormats, kAudioObjectPropertyScopeGlobal, 0 };
- err = AudioObjectRemovePropertyListener(p_sys->i_stream_id, &physicalFormatsAddress, HardwareListener, (void *)p_aout);
- if (err != noErr)
- msg_Err(p_aout, "failed to remove audio device property streams callback [%4.4s]", (char *)&err);
+ vlc_mutex_lock(&p_sys->var_lock);
+ /* remove streams callbacks */
+ CFIndex count = CFArrayGetCount(p_sys->device_list);
+ if (count > 0) {
+ for (CFIndex x = 0; x < count; x++) {
+ AudioDeviceID deviceId = 0;
+ CFNumberRef cfn_device_id = CFArrayGetValueAtIndex(p_sys->device_list, x);
+ if (!cfn_device_id)
+ continue;
+
+ CFNumberGetValue(cfn_device_id, kCFNumberSInt32Type, &deviceId);
+ if (!(deviceId & AOUT_VAR_SPDIF_FLAG)) {
+ ManageAudioStreamsCallback(p_aout, deviceId, false);
+ }
+ }
}
- config_PutPsz(p_aout, "auhal-audio-device", aout_DeviceGet(p_aout));
-
CFRelease(p_sys->device_list);
+ vlc_mutex_unlock(&p_sys->var_lock);
+
+ char *psz_device = aout_DeviceGet(p_aout);
+ config_PutPsz(p_aout, "auhal-audio-device", psz_device);
+ free(psz_device);
+ vlc_mutex_destroy(&p_sys->var_lock);
vlc_mutex_destroy(&p_sys->lock);
vlc_cond_destroy(&p_sys->cond);
p_sys->b_digital = false;
p_sys->au_component = NULL;
p_sys->au_unit = NULL;
- p_sys->clock_diff = (mtime_t) 0;
p_sys->i_hog_pid = -1;
p_sys->i_stream_id = 0;
p_sys->i_stream_index = -1;
p_sys->b_changed_mixing = false;
p_sys->i_bytes_per_sample = 0;
+ vlc_mutex_lock(&p_sys->var_lock);
p_sys->i_selected_dev = p_sys->i_new_selected_dev;
aout_FormatPrint(p_aout, "VLC is looking for:", fmt);
msg_Dbg(p_aout, "attempting to use device %i", p_sys->i_selected_dev);
- /* Check if the desired device is alive and usable */
- i_param_size = sizeof(b_alive);
- AudioObjectPropertyAddress audioDeviceAliveAddress = { kAudioDevicePropertyDeviceIsAlive,
- kAudioObjectPropertyScopeGlobal,
- kAudioObjectPropertyElementMaster };
- err = AudioObjectGetPropertyData(p_sys->i_selected_dev, &audioDeviceAliveAddress, 0, NULL, &i_param_size, &b_alive);
+ AudioObjectPropertyAddress audioDeviceAliveAddress = { kAudioDevicePropertyDeviceIsAlive, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
+ if (p_sys->i_selected_dev > 0) {
+ /* Check if the desired device is alive and usable */
+ i_param_size = sizeof(b_alive);
+ err = AudioObjectGetPropertyData(p_sys->i_selected_dev, &audioDeviceAliveAddress, 0, NULL, &i_param_size, &b_alive);
+ if (err != noErr) {
+ /* Be tolerant, only give a warning here */
+ msg_Warn(p_aout, "could not check whether device [0x%x] is alive [%4.4s]",
+ (unsigned int)p_sys->i_selected_dev, (char *)&err);
+ b_alive = false;
+ }
- if (err != noErr) {
- /* Be tolerant, only give a warning here */
- msg_Warn(p_aout, "could not check whether device [0x%x] is alive [%4.4s]",
- (unsigned int)p_sys->i_selected_dev, (char *)&err);
- b_alive = false;
+ if (!b_alive)
+ msg_Warn(p_aout, "selected audio device is not alive, switching to default device");
}
if (!b_alive || p_sys->i_selected_dev == 0) {
- msg_Warn(p_aout, "selected audio device is not alive, switching to default device");
-
AudioObjectID defaultDeviceID = 0;
UInt32 propertySize = 0;
AudioObjectPropertyAddress defaultDeviceAddress = { kAudioHardwarePropertyDefaultOutputDevice, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
msg_Dbg(p_aout, "using default audio device %i", defaultDeviceID);
p_sys->i_selected_dev = defaultDeviceID;
+ p_sys->b_selected_dev_is_digital = var_InheritBool(p_aout, "spdif");
}
// recheck if device still supports digital
msg_Dbg(p_aout, "Audio device supports PCM mode only");
/* add a callback to see if the device dies later on */
- err = AudioObjectAddPropertyListener(p_sys->i_selected_dev, &audioDeviceAliveAddress, HardwareListener, (void *)p_aout);
+ err = AudioObjectAddPropertyListener(p_sys->i_selected_dev, &audioDeviceAliveAddress, DeviceAliveListener, (void *)p_aout);
if (err != noErr) {
/* Be tolerant, only give a warning here */
msg_Warn(p_aout, "could not set alive check callback on device [0x%x] [%4.4s]",
b_success = true;
}
}
+ vlc_mutex_unlock(&p_sys->var_lock);
if (b_success) {
p_aout->play = Play;
error:
/* If we reach this, this aout has failed */
+ vlc_mutex_unlock(&p_sys->var_lock);
msg_Err(p_aout, "opening auhal output failed");
return VLC_EGENERIC;
}
AURenderCallbackStruct input;
p_aout->sys->chans_to_reorder = 0;
+ SInt32 currentMinorSystemVersion;
+ if(Gestalt(gestaltSystemVersionMinor, ¤tMinorSystemVersion) != noErr)
+ msg_Err(p_aout, "failed to check OSX version");
+
/* Lets go find our Component */
desc.componentType = kAudioUnitType_Output;
desc.componentSubType = kAudioUnitSubType_HALOutput;
}
if (fmt->i_physical_channels == 0) {
fmt->i_physical_channels = AOUT_CHANS_STEREO;
- msg_Err(p_aout, "You should configure your speaker layout with Audio Midi Setup Utility in /Applications/Utilities. Now using Stereo mode.");
+ msg_Err(p_aout, "You should configure your speaker layout with Audio Midi Setup in /Applications/Utilities. VLC will output Stereo only.");
dialog_Fatal(p_aout, _("Audio device is not configured"), "%s",
_("You should configure your speaker layout with "
- "the \"Audio Midi Setup\" utility in /Applications/"
- "Utilities. Stereo mode is being used now."));
+ "\"Audio Midi Setup\" in /Applications/"
+ "Utilities. VLC will output Stereo only."));
}
}
free(layout);
msg_Dbg(p_aout, "selected %d physical channels for device output", aout_FormatNbChannels(fmt));
msg_Dbg(p_aout, "VLC will output: %s", aout_FormatPrintChannels(fmt));
- p_sys->i_numberOfChannels = aout_FormatNbChannels(fmt);
memset (&new_layout, 0, sizeof(new_layout));
uint32_t chans_out[AOUT_CHAN_MAX];
+ memset(&chans_out, 0, sizeof(chans_out));
+
+ /* Some channel abbreviations used below:
+ * L - left
+ * R - right
+ * C - center
+ * Ls - left surround
+ * Rs - right surround
+ * Cs - center surround
+ * Rls - rear left surround
+ * Rrs - rear right surround
+ * Lw - left wide
+ * Rw - right wide
+ * Lsd - left surround direct
+ * Rsd - right surround direct
+ * Lc - left center
+ * Rc - right center
+ * Ts - top surround
+ * Vhl - vertical height left
+ * Vhc - vertical height center
+ * Vhr - vertical height right
+ * Lt - left matrix total. for matrix encoded stereo.
+ * Rt - right matrix total. for matrix encoded stereo. */
switch(aout_FormatNbChannels(fmt)) {
case 1:
new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_DVD_18; // L R Ls Rs LFE
break;
case 6:
- if (fmt->i_physical_channels & (AOUT_CHAN_LFE))
- new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_DVD_20; // L R Ls Rs C LFE
- else
+ if (fmt->i_physical_channels & (AOUT_CHAN_LFE)) {
+ /* note: for some reason, kAudioChannelLayoutTag_DVD_20, which would not require channel reordering,
+ does not work anymore */
+ new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_AudioUnit_5_1; // L R C LFE Ls Rs
+
+ chans_out[0] = AOUT_CHAN_LEFT;
+ chans_out[1] = AOUT_CHAN_RIGHT;
+ chans_out[2] = AOUT_CHAN_CENTER;
+ chans_out[3] = AOUT_CHAN_LFE;
+ chans_out[4] = AOUT_CHAN_REARLEFT;
+ chans_out[5] = AOUT_CHAN_REARRIGHT;
+
+ p_aout->sys->chans_to_reorder = aout_CheckChannelReorder(NULL, chans_out, fmt->i_physical_channels, p_aout->sys->chan_table);
+ if (p_aout->sys->chans_to_reorder)
+ msg_Dbg(p_aout, "channel reordering needed for 5.1 output");
+ } else {
new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_AudioUnit_6_0; // L R Ls Rs C Cs
+
+ chans_out[0] = AOUT_CHAN_LEFT;
+ chans_out[1] = AOUT_CHAN_RIGHT;
+ chans_out[2] = AOUT_CHAN_REARLEFT;
+ chans_out[3] = AOUT_CHAN_REARRIGHT;
+ chans_out[4] = AOUT_CHAN_CENTER;
+ chans_out[5] = AOUT_CHAN_REARCENTER;
+
+ p_aout->sys->chans_to_reorder = aout_CheckChannelReorder(NULL, chans_out, fmt->i_physical_channels, p_aout->sys->chan_table);
+ if (p_aout->sys->chans_to_reorder)
+ msg_Dbg(p_aout, "channel reordering needed for 6.0 output");
+ }
break;
case 7:
- new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_MPEG_6_1_A;
+ new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_MPEG_6_1_A; // L R C LFE Ls Rs Cs
chans_out[0] = AOUT_CHAN_LEFT;
chans_out[1] = AOUT_CHAN_RIGHT;
break;
case 8:
- new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_MPEG_7_1_A;
+ if (fmt->i_physical_channels & (AOUT_CHAN_LFE) || currentMinorSystemVersion < 7) {
+ new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_MPEG_7_1_A; // L R C LFE Ls Rs Lc Rc
+
+ chans_out[0] = AOUT_CHAN_LEFT;
+ chans_out[1] = AOUT_CHAN_RIGHT;
+ chans_out[2] = AOUT_CHAN_CENTER;
+ chans_out[3] = AOUT_CHAN_LFE;
+ chans_out[4] = AOUT_CHAN_MIDDLELEFT;
+ chans_out[5] = AOUT_CHAN_MIDDLERIGHT;
+ chans_out[6] = AOUT_CHAN_REARLEFT;
+ chans_out[7] = AOUT_CHAN_REARRIGHT;
+
+ if (!(fmt->i_physical_channels & (AOUT_CHAN_LFE)))
+ msg_Warn(p_aout, "8.0 audio output not supported on OS X 10.%i, layout will be incorrect", currentMinorSystemVersion);
+ }
+#ifdef MAC_OS_X_VERSION_10_7
+ else {
+ new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_DTS_8_0_B; // Lc C Rc L R Ls Cs Rs
+
+ chans_out[0] = AOUT_CHAN_MIDDLELEFT;
+ chans_out[1] = AOUT_CHAN_CENTER;
+ chans_out[2] = AOUT_CHAN_MIDDLERIGHT;
+ chans_out[3] = AOUT_CHAN_LEFT;
+ chans_out[4] = AOUT_CHAN_RIGHT;
+ chans_out[5] = AOUT_CHAN_REARLEFT;
+ chans_out[6] = AOUT_CHAN_REARCENTER;
+ chans_out[7] = AOUT_CHAN_REARRIGHT;
+ }
+#endif
+ p_aout->sys->chans_to_reorder = aout_CheckChannelReorder(NULL, chans_out, fmt->i_physical_channels, p_aout->sys->chan_table);
+ if (p_aout->sys->chans_to_reorder)
+ msg_Dbg(p_aout, "channel reordering needed for 7.1 / 8.0 output");
- chans_out[0] = AOUT_CHAN_LEFT;
- chans_out[1] = AOUT_CHAN_RIGHT;
- chans_out[2] = AOUT_CHAN_CENTER;
- chans_out[3] = AOUT_CHAN_LFE;
- chans_out[4] = AOUT_CHAN_MIDDLELEFT;
- chans_out[5] = AOUT_CHAN_MIDDLERIGHT;
- chans_out[6] = AOUT_CHAN_REARLEFT;
+ break;
+ case 9:
+ if (currentMinorSystemVersion < 7) {
+ msg_Warn(p_aout, "8.1 audio output not supported on OS X 10.%i", currentMinorSystemVersion);
+ break;
+ }
+
+#ifdef MAC_OS_X_VERSION_10_7
+ new_layout.mChannelLayoutTag = kAudioChannelLayoutTag_DTS_8_1_B; // Lc C Rc L R Ls Cs Rs LFE
+ chans_out[0] = AOUT_CHAN_MIDDLELEFT;
+ chans_out[1] = AOUT_CHAN_CENTER;
+ chans_out[2] = AOUT_CHAN_MIDDLERIGHT;
+ chans_out[3] = AOUT_CHAN_LEFT;
+ chans_out[4] = AOUT_CHAN_RIGHT;
+ chans_out[5] = AOUT_CHAN_REARLEFT;
+ chans_out[6] = AOUT_CHAN_REARCENTER;
chans_out[7] = AOUT_CHAN_REARRIGHT;
+ chans_out[8] = AOUT_CHAN_LFE;
p_aout->sys->chans_to_reorder = aout_CheckChannelReorder(NULL, chans_out, fmt->i_physical_channels, p_aout->sys->chan_table);
if (p_aout->sys->chans_to_reorder)
- msg_Dbg(p_aout, "channel reordering needed for 7.1 output");
-
+ msg_Dbg(p_aout, "channel reordering needed for 8.1 output");
+#endif
break;
}
/* AU initiliaze */
verify_noerr(AudioUnitInitialize(p_sys->au_unit));
- /* Find the difference between device clock and mdate clock */
- p_sys->clock_diff = - (mtime_t)
- AudioConvertHostTimeToNanos(AudioGetCurrentHostTime()) / 1000;
- p_sys->clock_diff += mdate();
-
/* setup circular buffer */
TPCircularBufferInit(&p_sys->circular_buffer, AUDIO_BUFFER_SIZE_IN_SECONDS *
fmt->i_rate * fmt->i_bytes_per_frame);
p_sys->b_got_first_sample = false;
/* Set volume for output unit */
- float volume = var_InheritInteger(p_aout, "auhal-volume") / (float)AOUT_VOLUME_DEFAULT;
- volume = volume * volume * volume;
- verify_noerr(AudioUnitSetParameter(p_sys->au_unit,
- kHALOutputParam_Volume,
- kAudioUnitScope_Global,
- 0,
- volume,
- 0));
+ VolumeSet(p_aout, p_sys->f_volume);
+ MuteSet(p_aout, p_sys->b_mute);
return true;
}
return false;
}
- /* Check for the difference between the Device clock and mdate */
- p_sys->clock_diff = - (mtime_t)
- AudioConvertHostTimeToNanos(AudioGetCurrentHostTime()) / 1000;
- p_sys->clock_diff += mdate();
-
/* Start device */
err = AudioDeviceStart(p_sys->i_selected_dev, p_sys->i_procID);
if (err != noErr) {
verify_noerr(AudioComponentInstanceDispose(p_sys->au_unit));
}
+ vlc_mutex_lock(&p_sys->var_lock);
if (p_sys->b_digital) {
/* Stop device */
err = AudioDeviceStop(p_sys->i_selected_dev,
msg_Err(p_aout, "Failed to release hogmode [%4.4s]", (char *)&err);
}
+ /* remove audio device alive callback */
+ AudioObjectPropertyAddress deviceAliveAddress = { kAudioDevicePropertyDeviceIsAlive, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
+ err = AudioObjectRemovePropertyListener(p_sys->i_selected_dev, &deviceAliveAddress, DeviceAliveListener, (void *)p_aout);
+ if (err != noErr) {
+ /* Be tolerant, only give a warning here */
+ msg_Warn(p_aout, "failed to remove audio device life checker [%4.4s]", (char *)&err);
+ }
+
+ vlc_mutex_unlock(&p_sys->var_lock);
+
p_sys->i_bytes_per_sample = 0;
p_sys->b_digital = false;
struct aout_sys_t *p_sys = p_aout->sys;
+ ReportDevice(p_aout, 0, _("System Sound Output Device"));
+
/* setup local array */
currentListOfDevices = CFArrayCreateMutable(kCFAllocatorDefault, 0, NULL);
}
// TODO: only register once for each device
- RegisterAudioStreamsCallback(p_aout, deviceIDs[i]);
+ ManageAudioStreamsCallback(p_aout, deviceIDs[i], true);
CFRelease(device_name_ref);
free(psz_name);
}
+ vlc_mutex_lock(&p_sys->var_lock);
CFIndex count = 0;
if (p_sys->device_list)
count = CFArrayGetCount(p_sys->device_list);
CFRelease(p_sys->device_list);
p_sys->device_list = CFArrayCreateCopy(kCFAllocatorDefault, currentListOfDevices);
CFRelease(currentListOfDevices);
-
- ReportDevice(p_aout, 0, _("System Sound Output Device"));
+ vlc_mutex_unlock(&p_sys->var_lock);
free(deviceIDs);
}
struct aout_sys_t *p_sys = p_aout->sys;
OSStatus ostatus;
- if(p_sys->b_digital) {
+ if(p_sys->b_digital)
return VLC_EGENERIC;
- }
+ p_sys->f_volume = volume;
aout_VolumeReport(p_aout, volume);
/* Set volume for output unit */
struct aout_sys_t *p_sys = p_aout->sys;
OSStatus ostatus;
- if(p_sys->b_digital) {
+ if(p_sys->b_digital)
return VLC_EGENERIC;
- }
+ p_sys->b_mute = mute;
aout_MuteReport(p_aout, mute);
float volume = .0;
-
if (!mute)
- volume = var_InheritInteger(p_aout, "auhal-volume") / (float)AOUT_VOLUME_DEFAULT;
+ volume = p_sys->f_volume;
ostatus = AudioUnitSetParameter(p_sys->au_unit,
kHALOutputParam_Volume,
audio_output_t * p_aout = (audio_output_t *)p_obj;
struct aout_sys_t * p_sys = p_aout->sys;
- int bytesToCopy = ioData->mBuffers[0].mDataByteSize;
+ int bytesRequested = ioData->mBuffers[0].mDataByteSize;
Float32 *targetBuffer = (Float32*)ioData->mBuffers[0].mData;
vlc_mutex_lock(&p_sys->lock);
/* check if we have enough data */
if (!availableBytes) {
/* return an empty buffer so silence is played until we have data */
- for (UInt32 j = 0; j < inNumberFrames; j++)
- targetBuffer[j] = 0.;
+ memset(targetBuffer, 0, ioData->mBuffers[0].mDataByteSize);
} else {
- memcpy(targetBuffer, buffer, __MIN(bytesToCopy, availableBytes));
- TPCircularBufferConsume(&p_sys->circular_buffer, __MIN(bytesToCopy, availableBytes));
+ int32_t bytesToCopy = __MIN(bytesRequested, availableBytes);
+
+ memcpy(targetBuffer, buffer, bytesToCopy);
+ TPCircularBufferConsume(&p_sys->circular_buffer, bytesToCopy);
+ ioData->mBuffers[0].mDataByteSize = bytesToCopy;
}
vlc_cond_signal(&p_sys->cond);
audio_output_t * p_aout = (audio_output_t *)threadGlobals;
struct aout_sys_t * p_sys = p_aout->sys;
- int bytesToCopy = outOutputData->mBuffers[p_sys->i_stream_index].mDataByteSize;
+ int bytesRequested = outOutputData->mBuffers[p_sys->i_stream_index].mDataByteSize;
char *targetBuffer = outOutputData->mBuffers[p_sys->i_stream_index].mData;
vlc_mutex_lock(&p_sys->lock);
/* return an empty buffer so silence is played until we have data */
memset(targetBuffer, 0, outOutputData->mBuffers[p_sys->i_stream_index].mDataByteSize);
} else {
- memcpy(targetBuffer, buffer, __MIN(bytesToCopy, availableBytes));
- TPCircularBufferConsume(&p_sys->circular_buffer, __MIN(bytesToCopy, availableBytes));
+ int32_t bytesToCopy = __MIN(bytesRequested, availableBytes);
+
+ memcpy(targetBuffer, buffer, bytesToCopy);
+ TPCircularBufferConsume(&p_sys->circular_buffer, bytesToCopy);
+ outOutputData->mBuffers[p_sys->i_stream_index].mDataByteSize = bytesToCopy;
}
vlc_cond_signal(&p_sys->cond);
#pragma mark Stream / Hardware Listeners
/*
- * HardwareListener: Warns us of changes in the list of registered devices
+ * Callback when device list changed
*/
-static OSStatus HardwareListener(AudioObjectID inObjectID, UInt32 inNumberAddresses, const AudioObjectPropertyAddress inAddresses[], void*inClientData)
+static OSStatus DevicesListener(AudioObjectID inObjectID, UInt32 inNumberAddresses, const AudioObjectPropertyAddress inAddresses[], void*inClientData)
{
- OSStatus err = noErr;
- audio_output_t *p_aout = (audio_output_t *)inClientData;
VLC_UNUSED(inObjectID);
VLC_UNUSED(inNumberAddresses);
VLC_UNUSED(inAddresses);
+ audio_output_t *p_aout = (audio_output_t *)inClientData;
if (!p_aout)
return -1;
+ aout_sys_t *p_sys = p_aout->sys;
- for (unsigned int i = 0; i < inNumberAddresses; i++) {
- switch (inAddresses[i].mSelector) {
- case kAudioHardwarePropertyDevices:
- msg_Dbg(p_aout, "audio device configuration changed, resetting cache");
- break;
+ msg_Dbg(p_aout, "audio device configuration changed, resetting cache");
+ RebuildDeviceList(p_aout);
- case kAudioDevicePropertyDeviceIsAlive:
- msg_Warn(p_aout, "audio device died, resetting aout");
- break;
+ vlc_mutex_lock(&p_sys->var_lock);
+ if(!CFArrayContainsValue(p_sys->device_list, CFRangeMake(0, CFArrayGetCount(p_sys->device_list)),CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &p_sys->i_selected_dev)))
+ aout_RestartRequest(p_aout, AOUT_RESTART_OUTPUT);
+ vlc_mutex_unlock(&p_sys->var_lock);
- case kAudioStreamPropertyAvailablePhysicalFormats:
- msg_Dbg(p_aout, "available physical formats for audio device changed, resetting aout");
- break;
+ return noErr;
+}
- default:
- msg_Warn(p_aout, "device reset for unknown reason (%i)", inAddresses[i].mSelector);
- break;
- }
- }
+/*
+ * Callback when current device is not alive anymore
+ */
+static OSStatus DeviceAliveListener(AudioObjectID inObjectID, UInt32 inNumberAddresses, const AudioObjectPropertyAddress inAddresses[], void*inClientData)
+{
+ VLC_UNUSED(inObjectID);
+ VLC_UNUSED(inNumberAddresses);
+ VLC_UNUSED(inAddresses);
- RebuildDeviceList(p_aout);
+ audio_output_t *p_aout = (audio_output_t *)inClientData;
+ if (!p_aout)
+ return -1;
+
+ msg_Warn(p_aout, "audio device died, resetting aout");
aout_RestartRequest(p_aout, AOUT_RESTART_OUTPUT);
- return err;
+ return noErr;
+}
+
+/*
+ * Callback when streams of any audio device changed (e.g. SPDIF gets (un)available)
+ */
+static OSStatus StreamsChangedListener(AudioObjectID inObjectID, UInt32 inNumberAddresses, const AudioObjectPropertyAddress inAddresses[], void*inClientData)
+{
+ OSStatus err = noErr;
+ UInt32 i_param_size = 0;
+ AudioStreamID *p_streams = NULL;
+ int i_streams = 0;
+
+ VLC_UNUSED(inNumberAddresses);
+ VLC_UNUSED(inAddresses);
+
+ audio_output_t *p_aout = (audio_output_t *)inClientData;
+ if (!p_aout)
+ return -1;
+
+ aout_sys_t *p_sys = p_aout->sys;
+
+ msg_Dbg(p_aout, "available physical formats for audio device changed");
+ RebuildDeviceList(p_aout);
+
+ /*
+ * check if changed stream id belongs to current device
+ */
+ vlc_mutex_lock(&p_sys->var_lock);
+ AudioObjectPropertyAddress streamsAddress = { kAudioDevicePropertyStreams, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
+ err = AudioObjectGetPropertyDataSize(p_sys->i_selected_dev, &streamsAddress, 0, NULL, &i_param_size);
+ if (err != noErr) {
+ msg_Err(p_aout, "could not get number of streams [%4.4s]", (char *)&err);
+ return VLC_EGENERIC;
+ }
+
+ i_streams = i_param_size / sizeof(AudioStreamID);
+ p_streams = (AudioStreamID *)malloc(i_param_size);
+ if (p_streams == NULL)
+ return VLC_ENOMEM;
+
+ err = AudioObjectGetPropertyData(p_sys->i_selected_dev, &streamsAddress, 0, NULL, &i_param_size, p_streams);
+ if (err != noErr) {
+ msg_Err(p_aout, "could not get list of streams [%4.4s]", (char *)&err);
+ return VLC_EGENERIC;
+ }
+ vlc_mutex_unlock(&p_sys->var_lock);
+
+ for (int i = 0; i < i_streams; i++) {
+ if (p_streams[i] == inObjectID) {
+ msg_Dbg(p_aout, "Restart aout as this affects current device");
+ aout_RestartRequest(p_aout, AOUT_RESTART_OUTPUT);
+ break;
+ }
+ }
+ free(p_streams);
+
+ return noErr;
}
/*
#pragma mark -
#pragma mark helpers
-static int RegisterAudioStreamsCallback(audio_output_t *p_aout, AudioDeviceID i_dev_id)
+static int ManageAudioStreamsCallback(audio_output_t *p_aout, AudioDeviceID i_dev_id, bool b_register)
{
OSStatus err = noErr;
UInt32 i_param_size = 0;
AudioObjectPropertyAddress streamsAddress = { kAudioDevicePropertyStreams, kAudioDevicePropertyScopeOutput, kAudioObjectPropertyElementMaster };
err = AudioObjectGetPropertyDataSize(i_dev_id, &streamsAddress, 0, NULL, &i_param_size);
if (err != noErr) {
- msg_Err(p_aout, "could not get number of streams [%4.4s] (%i)", (char *)&err, (int32_t)err);
+ msg_Err(p_aout, "could not get number of streams for device id %i [%4.4s]", i_dev_id, (char *)&err);
return VLC_EGENERIC;
}
for (int i = 0; i < i_streams; i++) {
/* get notified when physical formats change */
AudioObjectPropertyAddress physicalFormatsAddress = { kAudioStreamPropertyAvailablePhysicalFormats, kAudioObjectPropertyScopeGlobal, 0 };
- err = AudioObjectAddPropertyListener(p_streams[i], &physicalFormatsAddress, HardwareListener, (void *)p_aout);
- if (err != noErr) {
- // nope just means that we already have a callback
- if (err == kAudioHardwareIllegalOperationError) {
- msg_Dbg(p_aout, "could not set audio stream formats property callback on stream id %i, callback already set? [%4.4s]", p_streams[i],
- (char *)&err);
- } else {
- msg_Warn(p_aout, "could not set audio stream formats property callback on stream id %i [%4.4s]", p_streams[i],
- (char *)&err);
+
+ if (b_register) {
+ err = AudioObjectAddPropertyListener(p_streams[i], &physicalFormatsAddress, StreamsChangedListener, (void *)p_aout);
+ if (err != noErr) {
+ // nope just means that we already have a callback
+ if (err == kAudioHardwareIllegalOperationError) {
+ msg_Warn(p_aout, "could not set audio stream formats property callback on stream id %i, callback already set? [%4.4s]", p_streams[i],
+ (char *)&err);
+ } else {
+ msg_Err(p_aout, "could not set audio stream formats property callback on stream id %i [%4.4s]", p_streams[i],
+ (char *)&err);
+ }
}
+
+ } else { /* unregister callback */
+ err = AudioObjectRemovePropertyListener(p_streams[i], &physicalFormatsAddress, StreamsChangedListener, (void *)p_aout);
+ if (err != noErr)
+ msg_Err(p_aout, "failed to remove audio device property streams callback [%4.4s]", (char *)&err);
}
+
}
free(p_streams);
projects / vlc / blobdiff