public RESULT createStream(IntPtr data, MODE mode, ref CREATESOUNDEXINFO exinfo, ref Sound sound)
{
RESULT result = RESULT.OK;
IntPtr soundraw = new IntPtr();
Sound soundnew = null;
try
{
result = FMOD_System_CreateStream(systemraw, data, mode, ref exinfo, ref soundraw);
}
catch
{
result = RESULT.ERR_INVALID_PARAM;
}
if (result != RESULT.OK)
{
return(result);
}
if (sound == null)
{
soundnew = new Sound();
soundnew.setRaw(soundraw);
sound = soundnew;
}
else
{
sound.setRaw(soundraw);
}
return(result);
}
private static Sound CreateSoundFromAudioClip(AudioClip audioClip, MODE mode)
{
var samplesSize = audioClip.samples * audioClip.channels;
var samples = new float[samplesSize];
audioClip.GetData(samples, 0);
var bytesLength = (uint)(samplesSize * sizeof(float));
var soundInfo = new CREATESOUNDEXINFO
{
cbsize = Marshal.SizeOf(typeof(CREATESOUNDEXINFO)),
length = bytesLength,
format = SOUND_FORMAT.PCMFLOAT,
defaultfrequency = audioClip.frequency,
numchannels = audioClip.channels
};
FMOD_System.createSound("", MODE.OPENUSER, ref soundInfo, out var sound);
sound.@lock(0, bytesLength, out var ptr1, out var ptr2, out var len1, out var len2);
var samplesLength = (int)(len1 / sizeof(float));
Marshal.Copy(samples, 0, ptr1, samplesLength);
if (len2 > 0)
{
Marshal.Copy(samples, samplesLength, ptr2, (int)(len2 / sizeof(float)));
}
sound.unlock(ptr1, ptr2, len1, len2);
sound.setMode(mode);
return(sound);
}
private static void PlayInThread(byte[] file, bool isBGM)
{//子线程中的处理
if (isBGM)
{
if (_channelBGM != null)
{
bool isPlaying;
_channelBGM.isPlaying(out isPlaying);
if (isPlaying)
{
_channelBGM.stop();
}
}
}
var info = new CREATESOUNDEXINFO();
info.length = (uint)file.Length;
Sound s;
if (isBGM)
{
var result2 = _fmod.createSound(file, MODE.OPENMEMORY | MODE.LOOP_NORMAL, ref info, out s);
if (result2 != RESULT.OK)
{
NLog.Error("fmod createSound " + result2);
}
}
else
{
var result2 = _fmod.createSound(file, MODE.OPENMEMORY, ref info, out s);
if (result2 != RESULT.OK)
{
NLog.Error("fmod createSound " + result2);
}
}
Channel channel;
var result = _fmod.playSound(s, null, false, out channel);
_fmod.update();
int index;
channel.getIndex(out index);
if (result != RESULT.OK)
{
NLog.Error("fmod playSound " + result);
}
if (isBGM)
{
channel.setVolume(BGMVolume * WorldInfoManager.BGVolumn);
_channelBGM = channel;
}
else
{
channel.setVolume(EffectVolume * WorldInfoManager.SoundVolumn);
}
}
public static void PlaySong(string name)
{
if (player == null)
{
return;
}
if (Mix.FileExists(name))
{
var sound = new Sound();
var data = Mix.GetBytes(name);
var exInfo = new CREATESOUNDEXINFO()
{
cbsize = 112,
length = (uint)data.Length,
};
if (System.IO.File.Exists("kafe.dls"))
{
exInfo.dlsname = "kafe.dls";
}
var ret = player.CreateSound(data, Mode.Loop | Mode.OpenMemory, ref exInfo, ref sound);
if (ret != Result.OK)
{
return;
}
ret = player.PlaySound(CHANNELINDEX.REUSE, sound, true, ref musicChannel);
if (ret != Result.OK)
{
return;
}
if (name.EndsWith(".ogg"))
{
var tag = new TAG();
uint loopStart = 0;
uint loopEnd = 0;
ret = sound.GetTag("LOOP_START", 0, ref tag);
if (ret != Result.ERR_TOOMANYCHANNELS)
{
if (ret != Result.ERR_TAGNOTFOUND)
{
loopStart = uint.Parse(tag.StringData);
}
ret = sound.GetTag("LOOP_END", 0, ref tag);
if (ret != Result.ERR_TAGNOTFOUND)
{
loopEnd = uint.Parse(tag.StringData);
}
if (loopEnd > 0)
{
sound.SetLoopPoints(loopStart, TIMEUNIT.PCM, loopEnd, TIMEUNIT.PCM);
}
}
}
musicChannel.SetPaused(false);
}
}
/// <summary>
/// Record what is coming in from the given driver
/// </summary>
/// <returns>The record.</returns>
/// <param name="driver">Driver.</param>
public static RecordingSound StartRecording(RecordDriver driver, ChannelGroup channelgroup = new ChannelGroup())
{
if (driver.id == -1)
{
return(new RecordingSound());
}
RESULT result = RESULT.OK;
CREATESOUNDEXINFO exInfo = new CREATESOUNDEXINFO();
exInfo.cbsize = Marshal.SizeOf(exInfo);
exInfo.numchannels = driver.speakerModeChannels;
exInfo.format = SOUND_FORMAT.PCM16;
exInfo.defaultfrequency = driver.systemRate;
exInfo.length = (uint)driver.systemRate * (uint)driver.speakerModeChannels * 16; // (FROM FMOD EXAMPLES): nativeRate * sizeof(short) * nativeChannels
// I'm just saying 16 as that's the size of a short
Sound sound;
result = Instance.LowLevelSystem.createSound(IntPtr.Zero, MODE.LOOP_NORMAL | MODE.OPENUSER, ref exInfo, out sound);
Instance.CheckResult(result, "FMOD.CreateSound");
result = Instance.LowLevelSystem.recordStart(driver.id, sound, true);
Instance.CheckResult(result, "FMOD.RecordStart");
uint soundLength = 0;
result = sound.getLength(out soundLength, TIMEUNIT.PCM);
Instance.CheckResult(result, "Sound.GetLength");
// Add our currently recording sound to our dictionary so we can check its record position and do stuff to it in update
RecordingSound recordingSound = new RecordingSound
{
driver = driver,
sound = sound
};
if (channelgroup.hasHandle())
{
recordingSound.channelGroup = channelgroup;
}
RecordingSound temp = new RecordingSound();
if (Instance.recordingSounds.TryGetValue(driver.id, out temp))
{
return(temp);
}
Instance.recordingSounds.Add(driver.id, recordingSound);
return(recordingSound);
}
public byte[] ConvertToWav()
{
var m_AudioData = m_AudioClip.m_AudioData.GetData();
if (m_AudioData == null || m_AudioData.Length == 0)
{
return(null);
}
var exinfo = new CREATESOUNDEXINFO();
var result = Factory.System_Create(out var system);
if (result != RESULT.OK)
{
return(null);
}
result = system.init(1, INITFLAGS.NORMAL, IntPtr.Zero);
if (result != RESULT.OK)
{
return(null);
}
exinfo.cbsize = Marshal.SizeOf(exinfo);
exinfo.length = (uint)m_AudioClip.m_Size;
result = system.createSound(m_AudioData, MODE.OPENMEMORY, ref exinfo, out var sound);
if (result != RESULT.OK)
{
return(null);
}
result = sound.getNumSubSounds(out var numsubsounds);
if (result != RESULT.OK)
{
return(null);
}
byte[] buff;
if (numsubsounds > 0)
{
result = sound.getSubSound(0, out var subsound);
if (result != RESULT.OK)
{
return(null);
}
buff = SoundToWav(subsound);
subsound.release();
}
else
{
buff = SoundToWav(sound);
}
sound.release();
system.release();
return(buff);
}
public static Sound CreateSoundFromAudioClip(AudioClip audioClip)
{
var samplesSize = audioClip.samples * audioClip.channels;
var samples = new float[samplesSize];
audioClip.GetData(samples, 0);
var bytesLength = (uint)(samplesSize * sizeof(float));
var soundInfo = new CREATESOUNDEXINFO();
soundInfo.length = bytesLength;
soundInfo.format = SOUND_FORMAT.PCMFLOAT;
soundInfo.defaultfrequency = audioClip.frequency;
soundInfo.numchannels = audioClip.channels;
soundInfo.cbsize = Marshal.SizeOf(soundInfo);
Sound sound;
var result = RuntimeManager.CoreSystem.createSound("", MODE.OPENUSER, ref soundInfo, out sound);
if (result == RESULT.OK)
{
IntPtr ptr1, ptr2;
uint len1, len2;
result = sound.@lock(0, bytesLength, out ptr1, out ptr2, out len1, out len2);
if (result == FMOD.RESULT.OK)
{
var samplesLength = (int)(len1 / sizeof(float));
Marshal.Copy(samples, 0, ptr1, samplesLength);
if (len2 > 0)
{
Marshal.Copy(samples, samplesLength, ptr2, (int)(len2 / sizeof(float)));
}
result = sound.unlock(ptr1, ptr2, len1, len2);
if (result == RESULT.OK)
{
result = sound.setMode(MODE.LOOP_NORMAL);
if (result == RESULT.OK)
{
return(sound);
}
}
}
}
throw new InvalidDataException("There was an error processing this audioclip");
}
private static void PlayInThread(byte[] file, bool isBGM)
{//子线程中的处理
if (isBGM)
{
if (_channelBGM != null)
{
bool isPlaying;
_channelBGM.isPlaying(out isPlaying);
if (isPlaying)
{
_channelBGM.stop();
}
}
}
var info = new CREATESOUNDEXINFO();
info.length = (uint)file.Length;
Sound s;
var result = _fmod.createSound(file, MODE.OPENMEMORY, ref info, out s);
if (result != RESULT.OK)
{
NLog.Error("fmod createSound " + result);
}
Channel channel;
result = _fmod.playSound(s, null, false, out channel);
_fmod.update();
int index;
channel.getIndex(out index);
if (result != RESULT.OK)
{
NLog.Error("fmod playSound " + result);
}
if (isBGM)
{
_channelBGM = channel;
}
}
public Sound(SoundSystem soundSystem, byte[] data)
{
soundSystem.ThrowIfNull("soundSystem");
data.ThrowIfNull("data");
var createsoundexinfo = new CREATESOUNDEXINFO
{
cbsize = Marshal.SizeOf(typeof(CREATESOUNDEXINFO)),
length = (uint)data.Length
};
// ReSharper disable BitwiseOperatorOnEnumWihtoutFlags
RESULT result = soundSystem.System.createSound(data, MODE.HARDWARE | MODE.OPENMEMORY, ref createsoundexinfo, ref _sound);
// ReSharper restore BitwiseOperatorOnEnumWihtoutFlags
if (result != RESULT.OK)
{
throw new Exception(GetExceptionMessage("Failed to create FMOD sound.", result));
}
_soundSystem = soundSystem;
}
public static SoundTrack LoadSoundTrack(string filePath)
{
if (IsActive)
{
var buffer = LoadBuffer(filePath, ".ogg");
if (buffer != null)
{
var mode = MODE.OPENMEMORY | MODE.CREATESTREAM;
var handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
var info = new CREATESOUNDEXINFO {
length = (uint)buffer.Length
};
info.cbsize = Marshal.SizeOf(info);
Sound sound;
System.createSound(buffer, mode, ref info, out sound);
return(new SoundTrack(filePath.CleanPath(), sound, handle, buffer));
}
}
return(null);
}
public static SoundEffect LoadSoundEffect(string filePath)
{
if (IsActive)
{
var buffer = LoadBuffer(filePath, ".ogg");
if (buffer != null)
{
var mode = MODE.OPENMEMORY | MODE.CREATESAMPLE;
var info = new CREATESOUNDEXINFO()
{
length = (uint)buffer.Length
};
info.cbsize = Marshal.SizeOf(info);
Sound sound;
System.createSound(buffer, mode, ref info, out sound);
return(new SoundEffect(filePath.CleanPath(), sound));
}
}
return(null);
}
private static void ExportAudioClip(IExportContainer container, Stream fileStream, AudioClip clip)
{
CREATESOUNDEXINFO exinfo = new CREATESOUNDEXINFO();
FMOD.System system = null;
Sound sound = null;
Sound subsound = null;
try
{
RESULT result = Factory.System_Create(out system);
if (result != RESULT.OK)
{
Logger.Instance.Log(LogType.Error, LogCategory.Export, $"Can't create factory for AudioClip {clip.Name}");
return;
}
result = system.init(1, INITFLAGS.NORMAL, IntPtr.Zero);
if (result != RESULT.OK)
{
Logger.Instance.Log(LogType.Error, LogCategory.Export, $"Can't init system for AudioClip {clip.Name}");
return;
}
byte[] data;
using (MemoryStream memStream = new MemoryStream())
{
clip.ExportBinary(container, memStream);
data = memStream.ToArray();
}
if (data.Length == 0)
{
return;
}
exinfo.cbsize = Marshal.SizeOf(exinfo);
exinfo.length = (uint)data.Length;
result = system.createSound(data, MODE.OPENMEMORY, ref exinfo, out sound);
if (result != RESULT.OK)
{
Logger.Instance.Log(LogType.Error, LogCategory.Export, $"Can't create sound for AudioClip {clip.Name}");
return;
}
result = sound.getSubSound(0, out subsound);
if (result != RESULT.OK)
{
Logger.Instance.Log(LogType.Error, LogCategory.Export, $"Can't get subsound for AudioClip {clip.Name}");
return;
}
result = subsound.getFormat(out SOUND_TYPE type, out SOUND_FORMAT format, out int numChannels, out int bitsPerSample);
if (result != RESULT.OK)
{
Logger.Instance.Log(LogType.Error, LogCategory.Export, $"Can't get format for AudioClip {clip.Name}");
return;
}
result = subsound.getDefaults(out float frequency, out int priority);
if (result != RESULT.OK)
{
Logger.Instance.Log(LogType.Error, LogCategory.Export, $"Can't get defaults for AudioClip {clip.Name}");
return;
}
int sampleRate = (int)frequency;
result = subsound.getLength(out uint length, TIMEUNIT.PCMBYTES);
if (result != RESULT.OK)
{
Logger.Instance.Log(LogType.Error, LogCategory.Export, $"Can't get length for AudioClip {clip.Name}");
return;
}
result = subsound.@lock(0, length, out IntPtr ptr1, out IntPtr ptr2, out uint len1, out uint len2);
if (result != RESULT.OK)
{
Logger.Instance.Log(LogType.Error, LogCategory.Export, $"Can't lock for AudioClip {clip.Name}");
return;
}
using (BinaryWriter writer = new BinaryWriter(fileStream))
{
writer.Write(Encoding.UTF8.GetBytes("RIFF"));
writer.Write(len1 + 36);
writer.Write(Encoding.UTF8.GetBytes("WAVEfmt "));
writer.Write(16);
writer.Write((short)1);
writer.Write((short)numChannels);
writer.Write(sampleRate);
writer.Write(sampleRate * numChannels * bitsPerSample / 8);
writer.Write((short)(numChannels * bitsPerSample / 8));
writer.Write((short)bitsPerSample);
writer.Write(Encoding.UTF8.GetBytes("data"));
writer.Write(len1);
for (int i = 0; i < len1; i++)
{
byte value = Marshal.ReadByte(ptr1, i);
writer.Write(value);
}
}
result = subsound.unlock(ptr1, ptr2, len1, len2);
if (result != RESULT.OK)
{
Logger.Instance.Log(LogType.Error, LogCategory.Export, $"Can't unlock for AudioClip {clip.Name}");
}
}
finally
{
if (subsound != null)
{
subsound.release();
}
if (sound != null)
{
sound.release();
}
if (system != null)
{
system.release();
}
}
}
protected MediaObject()
{
// Zero out the extra info structure.
extraInfo = new CREATESOUNDEXINFO();
extraInfo.cbsize = Marshal.SizeOf(extraInfo);
}
/// <summary>
/// Takes a url and plays the audio found there
/// </summary>
/// <returns>The stream from internet.</returns>
/// <param name="url">URL.</param>
/// <param name="soundReturn">Sound return.</param>
public static void PlaySoundFromNet(string url, out Sound _sound, out Channel _channel, out InternetStreamData _streamData)
{
// Low level
FMOD.System system;
ChannelGroup channelGroup;
Sound sound;
Channel channel;
// Result and network enum
RESULT result = RESULT.OK;
OPENSTATE openState = OPENSTATE.READY;
// Declare
system = RuntimeManager.LowlevelSystem;
system.getMasterChannelGroup(out channelGroup); // Sound will be put on master channel group
// Increase stream buffer size to account for internet lag
// FMOD's example uses TIMEUNIT.RAWBYTES (8 bytes) but this caused the buffer to fill and the file to stop playing
// TIMUNIT.PCMFRACTION is 16 bytes and has meant the file keeps playing
result = system.setStreamBufferSize(64 * 1024, TIMEUNIT.PCMFRACTION);
// Allocate memory for new sound object
CREATESOUNDEXINFO exInfo = new CREATESOUNDEXINFO();
exInfo.cbsize = Marshal.SizeOf(typeof(CREATESOUNDEXINFO));
exInfo.filebuffersize = 1024 * 16; // Increase the default chunk size to hanlde seeking inside large playlist files that me be over 2kb
// Create sound and return the sound object. Non blocking meaning it is opened / prepared in the background. sound.getOpenState gets the info about its loading
result = system.createSound(url, MODE.CREATESTREAM | MODE.NONBLOCKING, ref exInfo, out sound);
// Return if creating sound failed
if (result != RESULT.OK)
{
UnityEngine.Debug.LogError("FMOD Extensions: Failed to create sound from net. " + result);
_sound = new Sound();
_channel = new Channel();
_streamData = new InternetStreamData();
return;
}
_sound = sound;
// Info data returning from the sound object
InternetStreamData streamData = new InternetStreamData(0, 0, false, false, false, false, "Stopped");
// Main function for getting the information from the sound object
result = sound.getOpenState(out openState, out streamData.percent, out streamData.isStarving, out streamData.isDiskBusy);
// Return error message if we can't get the state of the sound
if (result != RESULT.OK)
{
UnityEngine.Debug.LogError("FMOD Extensions: Could not get open state of file. " + result);
_sound = new Sound();
_channel = new Channel();
_streamData = new InternetStreamData();
return;
}
// Wait for file to become ready / for it to play
while (openState != OPENSTATE.READY)
{
result = sound.getOpenState(out openState, out streamData.percent, out streamData.isStarving, out streamData.isDiskBusy);
}
result = system.playSound(sound, channelGroup, false, out channel);
_channel = channel;
if (!channel.hasHandle())
{
result = sound.getOpenState(out openState, out streamData.percent, out streamData.isStarving, out streamData.isDiskBusy);
channel.getPaused(out streamData.isPaused);
channel.isPlaying(out streamData.isPlaying);
channel.getPosition(out streamData.pos, TIMEUNIT.MS);
channel.setVolume(1f);
UnityEngine.Debug.LogFormat("{0} {1} {2}", streamData.isPaused, streamData.isPlaying, streamData.pos);
}
channel.getPaused(out streamData.isPaused);
channel.isPlaying(out streamData.isPlaying);
channel.getPosition(out streamData.pos, TIMEUNIT.MS);
if (openState == OPENSTATE.BUFFERING)
{
streamData.state = "Buffering";
}
else if (openState == OPENSTATE.CONNECTING)
{
streamData.state = "Connecting...";
}
else if (streamData.isPaused)
{
streamData.state = "Paused";
}
else if (streamData.isPlaying)
{
streamData.state = "Playing";
}
_streamData = streamData;
UnityEngine.Debug.Log("FMOD Extensions: Successfully created stream from net");
}
public static byte[] ConvertToWav(byte[] data)
{
RESULT result = Factory.System_Create(out FMOD.System system);
if (result != RESULT.OK)
{
return(null);
}
try
{
result = system.init(1, INITFLAGS.NORMAL, IntPtr.Zero);
if (result != RESULT.OK)
{
return(null);
}
CREATESOUNDEXINFO exinfo = new CREATESOUNDEXINFO();
exinfo.cbsize = Marshal.SizeOf(exinfo);
exinfo.length = (uint)data.Length;
result = system.createSound(data, MODE.OPENMEMORY, ref exinfo, out Sound sound);
if (result != RESULT.OK)
{
return(null);
}
try
{
result = sound.getSubSound(0, out Sound subsound);
if (result != RESULT.OK)
{
return(null);
}
try
{
result = subsound.getFormat(out SOUND_TYPE type, out SOUND_FORMAT format, out int numChannels, out int bitsPerSample);
if (result != RESULT.OK)
{
return(null);
}
result = subsound.getDefaults(out float frequency, out int priority);
if (result != RESULT.OK)
{
return(null);
}
int sampleRate = (int)frequency;
result = subsound.getLength(out uint length, TIMEUNIT.PCMBYTES);
if (result != RESULT.OK)
{
return(null);
}
result = subsound.@lock(0, length, out IntPtr ptr1, out IntPtr ptr2, out uint len1, out uint len2);
if (result != RESULT.OK)
{
return(null);
}
const int WavHeaderLength = 44;
int bufferLen = (int)(WavHeaderLength + len1);
byte[] buffer = new byte[bufferLen];
using (MemoryStream stream = new MemoryStream(buffer))
{
using (BinaryWriter writer = new BinaryWriter(stream))
{
writer.Write(RiffFourCC);
writer.Write(36 + len1);
writer.Write(WaveEightCC);
writer.Write(16);
writer.Write((short)1);
writer.Write((short)numChannels);
writer.Write(sampleRate);
writer.Write(sampleRate * numChannels * bitsPerSample / 8);
writer.Write((short)(numChannels * bitsPerSample / 8));
writer.Write((short)bitsPerSample);
writer.Write(DataFourCC);
writer.Write(len1);
}
}
Marshal.Copy(ptr1, buffer, WavHeaderLength, (int)len1);
subsound.unlock(ptr1, ptr2, len1, len2);
return(buffer);
}
finally
{
subsound.release();
}
}
finally
{
sound.release();
}
}
finally
{
system.release();
}
}
private static extern RESULT FMOD_System_CreateStream(IntPtr system, IntPtr name_or_data, MODE mode, ref CREATESOUNDEXINFO exinfo, ref IntPtr sound);
public static bool ConvertToWav(byte[] data, Stream exportStream)
{
RESULT result = Factory.System_Create(out FMOD.System system);
if (result != RESULT.OK)
{
return(false);
}
try
{
result = system.init(1, INITFLAGS.NORMAL, IntPtr.Zero);
if (result != RESULT.OK)
{
return(false);
}
CREATESOUNDEXINFO exinfo = new CREATESOUNDEXINFO();
exinfo.cbsize = Marshal.SizeOf(exinfo);
exinfo.length = (uint)data.Length;
result = system.createSound(data, MODE.OPENMEMORY, ref exinfo, out Sound sound);
if (result != RESULT.OK)
{
return(false);
}
try
{
result = sound.getSubSound(0, out Sound subsound);
if (result != RESULT.OK)
{
return(false);
}
try
{
result = subsound.getFormat(out SOUND_TYPE type, out SOUND_FORMAT format, out int numChannels, out int bitsPerSample);
if (result != RESULT.OK)
{
return(false);
}
result = subsound.getDefaults(out float frequency, out int priority);
if (result != RESULT.OK)
{
return(false);
}
int sampleRate = (int)frequency;
result = subsound.getLength(out uint length, TIMEUNIT.PCMBYTES);
if (result != RESULT.OK)
{
return(false);
}
result = subsound.@lock(0, length, out IntPtr ptr1, out IntPtr ptr2, out uint len1, out uint len2);
if (result != RESULT.OK)
{
return(false);
}
using (BinaryWriter writer = new BinaryWriter(exportStream))
{
writer.Write(Encoding.UTF8.GetBytes("RIFF"));
writer.Write(len1 + 36);
writer.Write(Encoding.UTF8.GetBytes("WAVEfmt "));
writer.Write(16);
writer.Write((short)1);
writer.Write((short)numChannels);
writer.Write(sampleRate);
writer.Write(sampleRate * numChannels * bitsPerSample / 8);
writer.Write((short)(numChannels * bitsPerSample / 8));
writer.Write((short)bitsPerSample);
writer.Write(Encoding.UTF8.GetBytes("data"));
writer.Write(len1);
for (int i = 0; i < len1; i++)
{
byte value = Marshal.ReadByte(ptr1, i);
writer.Write(value);
}
}
result = subsound.unlock(ptr1, ptr2, len1, len2);
return(result == RESULT.OK);
}
finally
{
subsound.release();
}
}
finally
{
sound.release();
}
}
finally
{
system.release();
}
}
public CreateSoundExInfo(ref CREATESOUNDEXINFO exinfo)
{
FMODInfo = exinfo;
}
