/// <summary>
/// Copies another AudioItem.
/// </summary>
/// <param name="reference"> The AudioItem to copy. </param>
public void Copy(AudioItemBase reference)
{
identifier = reference.identifier;
itemManager = reference.itemManager;
state = reference.state;
spatializer = reference.spatializer;
parent = reference.parent;
scheduledTime = reference.scheduledTime;
scheduleStarted = reference.scheduleStarted;
volumeModifier.Copy(reference.volumeModifier);
pitchModifier.Copy(reference.pitchModifier);
rampVolumeTweener.Copy(reference.rampVolumeTweener);
rampParentVolumeTweener.Copy(reference.rampParentVolumeTweener);
rampPitchTweener.Copy(reference.rampPitchTweener);
rampParentPitchTweener.Copy(reference.rampParentPitchTweener);
fadeTweener.Copy(reference.fadeTweener);
pausedState = reference.pausedState;
hasFaded = reference.hasFaded;
hasBreak = reference.hasBreak;
Copier <AudioDelayedOption> .Default.CopyTo(reference.delayedOptions, delayedOptions);
OnPlay = reference.OnPlay;
OnPause = reference.OnPause;
OnResume = reference.OnResume;
OnStopping = reference.OnStopping;
OnStop = reference.OnStop;
OnUpdate = reference.OnUpdate;
OnStateChanged = reference.OnStateChanged;
}
public AudioDynamicItem CreateDynamicItem(DynamicGetter getNextSettings, AudioSpatializer spatializer, IAudioItem parent)
{
var item = TypePoolManager.Create<AudioDynamicItem>();
item.Initialize(getNextSettings, this, spatializer, parent);
return item;
}
static void StopPreview()
{
if (audioManager == null)
{
return;
}
if (previewItem != null)
{
previewItem.StopImmediate();
previewItem = null;
}
if (previewSettings != null)
{
EditorUtility.SetDirty(previewSettings);
EditorApplication.RepaintProjectWindow();
previewSettings = null;
}
if (!Application.isPlaying)
{
PrefabPoolManager.ClearPool(audioManager.Reference);
}
stopPreview = false;
}
public IAudioProvider GetAudioProvider(IAudioItem AudioItem)
{
if (AudioItem is BassItem item)
{
return(new BassAudioProvider(item));
}
return(null);
}
static void PlayPreview(AudioSettingsBase settings)
{
StopPreview();
EditorUtility.SetDirty(settings);
previewSettings = settings;
previewItem = audioManager.CreateItem(previewSettings);
previewItem.OnStop += item => { stopPreview = true; previewItem = null; };
previewItem.Play();
}
protected virtual IAudioItem AddSource(AudioContainerSourceData data)
{
IAudioItem item = null;
if (data != null)
{
item = AddSource(data.Settings, data.Options);
}
return(item);
}
public void Initialize(DynamicGetter getNextSettings, AudioItemManager itemManager, AudioSpatializer spatializer, IAudioItem parent)
{
settings = TypePoolManager.Create<AudioDynamicSettings>();
base.Initialize(settings.Identifier, itemManager, spatializer, parent);
this.getNextSettings = getNextSettings ?? delegate { return null; };
InitializeModifiers(settings);
InitializeSources();
}
public void Refresh()
{
AvailableRecordingSources.Clear();
AvailableLoopbackSources.Clear();
AvailableRecordingSources.Add(NoSoundItem.Instance);
AvailableLoopbackSources.Add(NoSoundItem.Instance);
OnRefresh();
SelectedRecordingSource = SelectedLoopbackSource = NoSoundItem.Instance;
}
public IAudioProvider GetAudioProvider(IAudioItem AudioItem)
{
if (AudioItem is NAudioItem item)
{
if (item.IsLoopback)
{
return(new WasapiLoopbackCaptureProvider(item.Device));
}
return(new WasapiCaptureProvider(item.Device));
}
return(null);
}
protected void Initialize(int identifier, AudioItemManager itemManager, AudioSpatializer spatializer, IAudioItem parent)
{
this.identifier = identifier;
this.itemManager = itemManager;
this.spatializer = spatializer;
this.parent = parent;
if (this.parent == null)
{
itemManager.Activate(this);
}
SetState(AudioStates.Waiting);
}
public override void Break()
{
for (int i = 0; i < sources.Count; i++)
{
IAudioItem source = sources[i];
if (source.State != AudioStates.Waiting && source.GetScheduledTime() <= AudioSettings.dspTime)
{
source.Break();
}
}
hasBreak = true;
}
protected void AddSource(AudioSettingsBase settings, AudioDynamicData data)
{
IAudioItem item = base.AddSource(settings, null);
if (item == null)
{
return;
}
if (data.OnInitialize != null)
{
data.OnInitialize(item);
data.OnInitialize = null;
}
dynamicData.Add(data);
}
protected void UpdateScheduledTime()
{
if (state == AudioStates.Stopped)
{
return;
}
UpdateDelays();
// Schedule sources
int delayIndex = sourcesIndex - sources.Count;
double remainingTime = 0d;
for (int i = 0; i < sources.Count; i++)
{
IAudioItem item = sources[i];
double time;
if (i == 0)
{
time = Math.Max(AudioSettings.dspTime, scheduledTime) + delay;
}
else
{
time = AudioSettings.dspTime + remainingTime;
}
if (state == AudioStates.Playing && item.State == AudioStates.Waiting)
{
item.PlayScheduled(time);
}
else
{
item.SetScheduledTime(time);
}
if (delayIndex < settings.Delays.Count)
{
remainingTime = item.RemainingTime() + settings.Delays[delayIndex++];
}
else
{
remainingTime = item.RemainingTime();
}
}
}
/// <summary>
/// Called when a stream has been created. This actually starts the playback of the stream.
/// </summary>
/// <param name="track">The track that is to be played.</param>
/// <param name="stream">The BASS.NET stream pointer to play.</param>
protected virtual void StreamCreated(IAudioItem track, int stream)
{
// Init mixer
if (_mixer == -1)
{
_mixer = BassMix.BASS_Mixer_StreamCreate(44100, 6, BASSFlag.BASS_MIXER_END);
// Set playback done callback on mixer
_channelEndCallback = new SYNCPROC(ChannelEnd);
Bass.BASS_ChannelSetSync(_mixer, BASSSync.BASS_SYNC_END | BASSSync.BASS_SYNC_MIXTIME, 0, _channelEndCallback, IntPtr.Zero);
}
// Load streamin mixer
bool ok = BassMix.BASS_Mixer_StreamAddChannel(_mixer, stream, BASSFlag.BASS_STREAM_AUTOFREE | BASSFlag.BASS_MIXER_MATRIX);
if (!ok)
{
Log(Bass.BASS_ErrorGetCode().ToString(), Logger.LogLevel.Error);
}
// Set matrix
SetMatrix(stream);
// Remove current channel from mixer
if (_currentStream != -1)
{
BassMix.BASS_Mixer_ChannelRemove(_currentStream);
Bass.BASS_StreamFree(_currentStream);
}
//
if (track is IWebcast)
{
SYNCPROC _mySync = new SYNCPROC(MetaSync);
Bass.BASS_ChannelSetSync(_currentStream, BASSSync.BASS_SYNC_META, 0, _mySync, IntPtr.Zero);
}
// Play it!
Bass.BASS_ChannelSetPosition(_mixer, 0);
Bass.BASS_Start();
Bass.BASS_ChannelPlay(_mixer, false);
// Set current stuff
_currentStream = stream;
}
public IAudioProvider GetAudioProvider(IAudioItem Microphone, IAudioItem Speaker)
{
switch ((Microphone, Speaker))
{
case (null, NAudioItem speaker):
return(new MixedAudioProvider(new WasapiLoopbackCaptureProvider(speaker.Device)));
case (NAudioItem mic, null):
return(new MixedAudioProvider(new WasapiCaptureProvider(mic.Device)));
case (NAudioItem mic, NAudioItem speaker):
return(new MixedAudioProvider(
new WasapiCaptureProvider(mic.Device),
new WasapiLoopbackCaptureProvider(speaker.Device)));
default:
return(null);
}
}
/// <summary>
/// Creates a stream for the given track.
/// If the stream is created successfully, the track is automatically played. Thus,
/// this implementation is synchronous.
/// </summary>
/// <param name="track">The track to create the stream for and play.</param>
protected virtual void CreateStream(IAudioItem track)
{
int stream = 0;
// If we have a webcast, create a stream for one of the available URIs
if (track is IWebcast)
{
var streams = ((IWebcast)track).Streams;
foreach (var si in streams)
{
var url = si.Uri.ToString();
stream = Bass.BASS_StreamCreateURL(url, 0, BASSFlag.BASS_STREAM_STATUS | BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT, null, IntPtr.Zero);
Log(Bass.BASS_ErrorGetCode().ToString());
if (stream != 0)
{
Un4seen.Bass.AddOn.Tags.TAG_INFO tagInfo = new TAG_INFO(url);
if (BassTags.BASS_TAG_GetFromURL(stream, tagInfo))
{
// display the tags...
}
break;
}
}
}
// Else, just load the track
else if (track is IFileTrack)
{
var path = Path.GetFullPath(((ITrack)track).Uri.GetComponents(UriComponents.Path, UriFormat.SafeUnescaped));
stream = Bass.BASS_StreamCreateFile(path, 0, 0, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_PRESCAN);
}
// Start the stream if successfull
if (stream != 0)
{
this.StreamCreated(track, stream);
}
else
{
throw new NotImplementedException("Unhandled: no valid stream created");
}
}
protected void UpdateScheduledTime()
{
if (state == AudioStates.Stopped)
{
return;
}
// Update delta time
double dspTime = Math.Max(AudioSettings.dspTime, scheduledTime);
deltaTime = dspTime - lastTime;
lastTime = dspTime;
// Decrease delay counters
for (int i = 0; i < delays.Count; i++)
{
if (state != AudioStates.Paused)
{
delays[i] = Math.Max(delays[i] - deltaTime, 0d);
}
}
// Schedule sources
for (int i = 0; i < sources.Count; i++)
{
IAudioItem item = sources[i];
double time = Math.Max(AudioSettings.dspTime, scheduledTime) + delays[i];
if (state == AudioStates.Playing && item.State == AudioStates.Waiting)
{
item.PlayScheduled(time);
}
else
{
item.SetScheduledTime(time);
}
}
}
void HandleAudioSource(StartCmdOptions StartOptions, out IAudioItem Microphone, out IAudioItem Speaker)
{
Microphone = Speaker = null;
var mics = _audioSource
.Microphones
.ToArray();
var speakers = _audioSource
.Speakers
.ToArray();
if (StartOptions.Microphone != -1 && StartOptions.Microphone < mics.Length)
{
_settings.Audio.RecordMicrophone = true;
Microphone = mics[StartOptions.Microphone];
}
if (StartOptions.Speaker != -1 && StartOptions.Speaker < speakers.Length)
{
_settings.Audio.RecordSpeaker = true;
Speaker = speakers[StartOptions.Speaker];
}
}
public void Initialize(DynamicGetter getNextSettings, AudioItemManager itemManager, AudioSpatializer spatializer, IAudioItem parent)
{
settings = TypePoolManager.Create <AudioDynamicSettings>();
base.Initialize(settings.Identifier, itemManager, spatializer, parent);
this.getNextSettings = getNextSettings ?? delegate { return(null); };
InitializeModifiers(settings);
InitializeSources();
}
static void StopPreview()
{
if (audioManager == null)
return;
if (previewItem != null)
{
previewItem.StopImmediate();
previewItem = null;
}
if (previewSettings != null)
{
EditorUtility.SetDirty(previewSettings);
EditorApplication.RepaintProjectWindow();
previewSettings = null;
}
if (!Application.isPlaying)
PrefabPoolManager.ClearPool(audioManager.Reference);
stopPreview = false;
}
static void PlayPreview(AudioSettingsBase settings)
{
StopPreview();
EditorUtility.SetDirty(settings);
previewSettings = settings;
previewItem = audioManager.CreateItem(previewSettings);
previewItem.OnStop += item => { stopPreview = true; previewItem = null; };
previewItem.Play();
}
protected void UpdateScheduledTime()
{
if (state == AudioStates.Stopped)
{
return;
}
UpdateDeltaTime();
double remainingTime = 0d;
requestNextSettings = state != AudioStates.Paused;
for (int i = 0; i < sources.Count; i++)
{
IAudioItem source = sources[i];
AudioDynamicData data = dynamicData[i];
// Decrease delay
if (state != AudioStates.Paused)
{
switch (data.PlayMode)
{
case AudioDynamicData.PlayModes.Now:
data.Delay = Math.Max(data.Delay - deltaTime, 0d);
break;
case AudioDynamicData.PlayModes.After:
if (i == 0)
{
data.Delay = Math.Max(data.Delay - deltaTime, 0d);
}
else
{
requestNextSettings = false;
}
break;
}
if (data.Delay > 0d)
{
requestNextSettings = false;
}
}
// Schedule source
double time = Math.Max(AudioSettings.dspTime, scheduledTime) + remainingTime + data.Delay;
if (state == AudioStates.Playing && source.State == AudioStates.Waiting)
{
source.PlayScheduled(time);
}
else
{
source.SetScheduledTime(time);
}
// Set remaining time
switch (data.PlayMode)
{
case AudioDynamicData.PlayModes.Now:
remainingTime = data.Delay;
break;
case AudioDynamicData.PlayModes.After:
remainingTime = source.RemainingTime();
break;
}
}
}
public void Initialize(AudioMixContainerSettings settings, AudioItemManager itemManager, AudioSpatializer spatializer, IAudioItem parent)
{
base.Initialize(settings.Identifier, itemManager, spatializer, parent);
originalSettings = settings;
this.settings = PrefabPoolManager.Create(settings);
InitializeModifiers(originalSettings);
InitializeSources();
for (int i = 0; i < originalSettings.Options.Count; i++)
{
ApplyOption(originalSettings.Options[i], false);
}
}
/// <summary>
/// Creates a stream for the given track.
/// If the stream is created successfully, the track is automatically played. Thus,
/// this implementation is synchronous.
/// </summary>
/// <param name="track">The track to create the stream for and play.</param>
protected virtual void CreateStream(IAudioItem track)
{
int stream = 0;
// If we have a webcast, create a stream for one of the available URIs
if (track is IWebcast) {
var streams = ((IWebcast)track).Streams;
foreach (var si in streams) {
var url = si.Uri.ToString();
stream = Bass.BASS_StreamCreateURL(url, 0, BASSFlag.BASS_STREAM_STATUS | BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT, null, IntPtr.Zero);
Log(Bass.BASS_ErrorGetCode().ToString());
if (stream != 0) {
Un4seen.Bass.AddOn.Tags.TAG_INFO tagInfo = new TAG_INFO(url);
if (BassTags.BASS_TAG_GetFromURL(stream, tagInfo)) {
// display the tags...
}
break;
}
}
}
// Else, just load the track
else if (track is IFileTrack) {
var path = Path.GetFullPath(((ITrack)track).Uri.GetComponents(UriComponents.Path, UriFormat.SafeUnescaped));
stream = Bass.BASS_StreamCreateFile(path, 0, 0, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_PRESCAN);
}
// Start the stream if successfull
if (stream != 0)
this.StreamCreated(track, stream);
else
throw new NotImplementedException("Unhandled: no valid stream created");
}
/// <summary>
/// Called when a stream has been created. This actually starts the playback of the stream.
/// </summary>
/// <param name="track">The track that is to be played.</param>
/// <param name="stream">The BASS.NET stream pointer to play.</param>
protected virtual void StreamCreated(IAudioItem track, int stream)
{
// Init mixer
if (_mixer == -1) {
_mixer = BassMix.BASS_Mixer_StreamCreate(44100, 6, BASSFlag.BASS_MIXER_END);
// Set playback done callback on mixer
_channelEndCallback = new SYNCPROC(ChannelEnd);
Bass.BASS_ChannelSetSync(_mixer, BASSSync.BASS_SYNC_END | BASSSync.BASS_SYNC_MIXTIME, 0, _channelEndCallback, IntPtr.Zero);
}
// Load streamin mixer
bool ok = BassMix.BASS_Mixer_StreamAddChannel(_mixer, stream, BASSFlag.BASS_STREAM_AUTOFREE | BASSFlag.BASS_MIXER_MATRIX);
if (!ok) Log(Bass.BASS_ErrorGetCode().ToString(), Logger.LogLevel.Error);
// Set matrix
SetMatrix(stream);
// Remove current channel from mixer
if (_currentStream != -1) {
BassMix.BASS_Mixer_ChannelRemove(_currentStream);
Bass.BASS_StreamFree(_currentStream);
}
//
if (track is IWebcast) {
SYNCPROC _mySync = new SYNCPROC(MetaSync);
Bass.BASS_ChannelSetSync(_currentStream, BASSSync.BASS_SYNC_META, 0, _mySync, IntPtr.Zero);
}
// Play it!
Bass.BASS_ChannelSetPosition(_mixer, 0);
Bass.BASS_Start();
Bass.BASS_ChannelPlay(_mixer, false);
// Set current stuff
_currentStream = stream;
}
public void Initialize(AudioSourceSettings settings, AudioItemManager itemManager, AudioSource audioSource, AudioSpatializer spatializer, IAudioItem parent)
{
base.Initialize(settings.Identifier, itemManager, spatializer, parent);
// General Setup
originalSettings = settings;
this.settings = PrefabPoolManager.Create(settings);
source = audioSource;
source.transform.parent = itemManager.AudioManager.Reference.transform.parent;
base.spatializer.AddSource(source.transform);
// Setup the AudioSource
source.Stop();
source.clip = this.settings.Clip;
source.name = settings.Name;
source.outputAudioMixerGroup = this.settings.Output;
source.loop = this.settings.Loop;
source.spatialBlend = base.spatializer.SpatializeMode == AudioSpatializer.SpatializeModes.None ? 0f : source.spatialBlend;
InitializeModifiers(originalSettings);
for (int i = 0; i < originalSettings.Options.Count; i++)
{
ApplyOption(originalSettings.Options[i], false);
}
if (this.settings.MaxInstances > 0)
{
itemManager.TrimInstances(this, this.settings.MaxInstances);
}
}
public AudioServiceConnection(IAudioItem dependancy)
{
_dependancy = dependancy;
}
public AudioItemBase CreateItem(AudioSettingsBase settings, AudioSpatializer spatializer, IAudioItem parent)
{
if (settings == null)
return null;
switch (settings.Type)
{
default:
var sourceItem = TypePoolManager.Create<AudioSourceItem>();
var source = PrefabPoolManager.Create(audioManager.Reference);
source.Copy(audioManager.Reference, audioManager.UseCustomCurves);
sourceItem.Initialize((AudioSourceSettings)settings, this, source, spatializer, parent);
return sourceItem;
case AudioTypes.MixContainer:
var mixContainerItem = TypePoolManager.Create<AudioMixContainerItem>();
mixContainerItem.Initialize((AudioMixContainerSettings)settings, this, spatializer, parent);
return mixContainerItem;
case AudioTypes.RandomContainer:
var randomContainerItem = TypePoolManager.Create<AudioRandomContainerItem>();
randomContainerItem.Initialize((AudioRandomContainerSettings)settings, this, spatializer, parent);
return randomContainerItem;
case AudioTypes.EnumeratorContainer:
var enumeratorContainerItem = TypePoolManager.Create<AudioEnumeratorContainerItem>();
enumeratorContainerItem.Initialize((AudioEnumeratorContainerSettings)settings, this, spatializer, parent);
return enumeratorContainerItem;
case AudioTypes.SwitchContainer:
var switchContainerItem = TypePoolManager.Create<AudioSwitchContainerItem>();
switchContainerItem.Initialize((AudioSwitchContainerSettings)settings, this, spatializer, parent);
return switchContainerItem;
case AudioTypes.SequenceContainer:
var sequenceContainerItem = TypePoolManager.Create<AudioSequenceContainerItem>();
sequenceContainerItem.Initialize((AudioSequenceContainerSettings)settings, this, spatializer, parent);
return sequenceContainerItem;
}
}
public AudioDynamicItem CreateDynamicItem(DynamicGetter getNextSettings, AudioSpatializer spatializer, IAudioItem parent)
{
var item = TypePoolManager.Create <AudioDynamicItem>();
item.Initialize(getNextSettings, this, spatializer, parent);
return(item);
}
public AudioItemBase CreateItem(AudioSettingsBase settings, AudioSpatializer spatializer, IAudioItem parent)
{
if (settings == null)
{
return(null);
}
switch (settings.Type)
{
default:
var sourceItem = TypePoolManager.Create <AudioSourceItem>();
var source = PrefabPoolManager.Create(audioManager.Reference);
source.Copy(audioManager.Reference, audioManager.UseCustomCurves);
sourceItem.Initialize((AudioSourceSettings)settings, this, source, spatializer, parent);
return(sourceItem);
case AudioTypes.MixContainer:
var mixContainerItem = TypePoolManager.Create <AudioMixContainerItem>();
mixContainerItem.Initialize((AudioMixContainerSettings)settings, this, spatializer, parent);
return(mixContainerItem);
case AudioTypes.RandomContainer:
var randomContainerItem = TypePoolManager.Create <AudioRandomContainerItem>();
randomContainerItem.Initialize((AudioRandomContainerSettings)settings, this, spatializer, parent);
return(randomContainerItem);
case AudioTypes.EnumeratorContainer:
var enumeratorContainerItem = TypePoolManager.Create <AudioEnumeratorContainerItem>();
enumeratorContainerItem.Initialize((AudioEnumeratorContainerSettings)settings, this, spatializer, parent);
return(enumeratorContainerItem);
case AudioTypes.SwitchContainer:
var switchContainerItem = TypePoolManager.Create <AudioSwitchContainerItem>();
switchContainerItem.Initialize((AudioSwitchContainerSettings)settings, this, spatializer, parent);
return(switchContainerItem);
case AudioTypes.SequenceContainer:
var sequenceContainerItem = TypePoolManager.Create <AudioSequenceContainerItem>();
sequenceContainerItem.Initialize((AudioSequenceContainerSettings)settings, this, spatializer, parent);
return(sequenceContainerItem);
}
}
