using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Voice;
using Photon.Voice.Unity;
using UnityEngine;
using UnityEngine.Networking;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("sasnews")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+32d474e6f962f181dcdbc32bc77786a062d91c21")]
[assembly: AssemblyProduct("super_soundboard")]
[assembly: AssemblyTitle("super_soundboard")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace super_soundboard
{
public class AudioStreamAdapter : Stream
{
private readonly CircularBuffer _buffer;
private readonly AutoResetEvent _dataAvailable = new AutoResetEvent(initialState: false);
private bool _isClosed = false;
public override bool CanRead => true;
public override bool CanSeek => false;
public override bool CanWrite => true;
public override long Length => _buffer.Count;
public override long Position
{
get
{
return 0L;
}
set
{
throw new NotSupportedException();
}
}
public AudioStreamAdapter(int bufferSize)
{
_buffer = new CircularBuffer(bufferSize);
}
public override void Flush()
{
}
public override int Read(byte[] buffer, int offset, int count)
{
int num = 0;
while (num < count)
{
if (_isClosed && _buffer.Count == 0)
{
return num;
}
int num2 = _buffer.Read(buffer, offset + num, count - num);
if (num2 == 0)
{
if (_isClosed)
{
return num;
}
_dataAvailable.WaitOne(100);
}
else
{
num += num2;
}
}
return num;
}
public override void Write(byte[] buffer, int offset, int count)
{
if (!_isClosed)
{
_buffer.Write(buffer, offset, count);
_dataAvailable.Set();
}
}
public void Write(float[] samples)
{
byte[] array = new byte[samples.Length * 2];
for (int i = 0; i < samples.Length; i++)
{
float num = samples[i];
if (num > 1f)
{
num = 1f;
}
if (num < -1f)
{
num = -1f;
}
short num2 = (short)(num * 32767f);
array[i * 2] = (byte)((uint)num2 & 0xFFu);
array[i * 2 + 1] = (byte)((uint)(num2 >> 8) & 0xFFu);
}
Write(array, 0, array.Length);
}
public override void Close()
{
_isClosed = true;
_dataAvailable.Set();
base.Close();
}
public override long Seek(long offset, SeekOrigin origin)
{
throw new NotSupportedException();
}
public override void SetLength(long value)
{
throw new NotSupportedException();
}
}
public class CircularBuffer
{
private readonly byte[] _buffer;
private int _head;
private int _tail;
private int _count;
private readonly object _lock = new object();
public int Count
{
get
{
lock (_lock)
{
return _count;
}
}
}
public CircularBuffer(int size)
{
_buffer = new byte[size];
}
public int Read(byte[] buffer, int offset, int count)
{
lock (_lock)
{
if (_count == 0)
{
return 0;
}
int num = Math.Min(count, _count);
int num2 = Math.Min(_buffer.Length - _head, num);
Array.Copy(_buffer, _head, buffer, offset, num2);
Array.Copy(_buffer, 0, buffer, offset + num2, num - num2);
_head = (_head + num) % _buffer.Length;
_count -= num;
return num;
}
}
public void Write(byte[] buffer, int offset, int count)
{
lock (_lock)
{
if (count <= _buffer.Length - _count)
{
int num = Math.Min(_buffer.Length - _tail, count);
Array.Copy(buffer, offset, _buffer, _tail, num);
Array.Copy(buffer, offset + num, _buffer, 0, count - num);
_tail = (_tail + count) % _buffer.Length;
_count += count;
}
}
}
}
[HarmonyPatch(typeof(PlayerController))]
internal static class ExamplePlayerControllerPatch
{
[HarmonyPrefix]
[HarmonyPatch("Start")]
private static void Start_Prefix(PlayerController __instance)
{
super_soundboard.Logger.LogDebug((object)$"{__instance} Start Prefix");
}
[HarmonyPostfix]
[HarmonyPatch("Start")]
private static void Start_Postfix(PlayerController __instance)
{
super_soundboard.Logger.LogDebug((object)$"{__instance} Start Postfix");
}
}
public class SoundboardLoopback
{
private int _readIdx;
private int _writeIdx;
private int _samplesAvailable;
private readonly float[] _samples;
private readonly object _lock = new object();
public AudioClip Clip { get; }
public int SamplesAvailable
{
get
{
lock (_lock)
{
return _samplesAvailable;
}
}
}
public SoundboardLoopback()
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Expected O, but got Unknown
//IL_0055: Expected O, but got Unknown
_samples = new float[24000];
Clip = AudioClip.Create("SoundboardLoopback", _samples.Length, 1, 48000, true, new PCMReaderCallback(OnRead), new PCMSetPositionCallback(OnSetPosition));
}
public void Push(float[] buffer)
{
lock (_lock)
{
foreach (float num in buffer)
{
_samples[_writeIdx++] = num;
if (_writeIdx >= _samples.Length)
{
_writeIdx = 0;
}
if (_samplesAvailable < _samples.Length)
{
_samplesAvailable++;
}
else
{
_readIdx = (_readIdx + 1) % _samples.Length;
}
}
}
}
private void OnRead(float[] outSamples)
{
lock (_lock)
{
Array.Clear(outSamples, 0, outSamples.Length);
int num = Math.Min(outSamples.Length, _samplesAvailable);
for (int i = 0; i < num; i++)
{
outSamples[i] = _samples[_readIdx++];
if (_readIdx >= _samples.Length)
{
_readIdx = 0;
}
}
_samplesAvailable -= num;
}
}
private void OnSetPosition(int position)
{
}
public int ReadInto(float[] buffer, int offset, int count)
{
int num = 0;
lock (_lock)
{
for (int i = 0; i < count; i++)
{
if (_samplesAvailable == 0)
{
break;
}
buffer[offset + i] = _samples[_readIdx++];
if (_readIdx >= _samples.Length)
{
_readIdx = 0;
}
_samplesAvailable--;
num++;
}
}
return num;
}
}
public class SoundboardMixer : IAudioReader<float>, IDataReader<float>, IDisposable, IAudioDesc
{
private readonly SoundboardLoopback _loopback = super_soundboard.LoopbackInstance;
private readonly PlayerVoiceChat _vc;
private AudioClip? _micClip;
private string? _micDevice;
private int _lastMicPos;
private bool _isDisposed = false;
private int _deviceIndex = 0;
private int _noProgressCount = 0;
private readonly int[] _sampleRates = new int[3] { 48000, 44100, 32000 };
private int _currentSampleRate = 48000;
private readonly Queue<float> _micBuffer = new Queue<float>();
private readonly object _bufferLock = new object();
private const int MAX_BUFFER_SIZE = 96000;
private IAudioReader<float>? _recorderAudioReader = null;
private object? _recorderMicInputObject = null;
private Func<float[], int>? _recorderReadFunc = null;
public int SamplingRate => 48000;
public int Channels => 1;
public string? Error { get; private set; } = null;
public bool IsDisposed => _isDisposed;
public bool IsEof => false;
public SoundboardMixer(PlayerVoiceChat voiceChat, object? micInput)
{
object micInput2 = micInput;
base..ctor();
_vc = voiceChat;
if (micInput2 != null)
{
try
{
super_soundboard.Logger.LogDebug((object)("super_soundboard: Using recorder-provided MicInput of type " + micInput2.GetType().FullName));
object obj = micInput2;
AudioClip val = (AudioClip)((obj is AudioClip) ? obj : null);
if (val != null)
{
_micClip = val;
_lastMicPos = 0;
super_soundboard.Logger.LogDebug((object)("super_soundboard: Using recorder's AudioClip MicInput ('" + (_micDevice ?? "(unknown)") + "')."));
return;
}
if (micInput2 is IAudioReader<float> recorderAudioReader)
{
_micClip = null;
_recorderAudioReader = recorderAudioReader;
super_soundboard.Logger.LogDebug((object)"super_soundboard: Using recorder's IAudioReader<float> MicInput.");
return;
}
_recorderMicInputObject = micInput2;
try
{
Type type = micInput2.GetType();
super_soundboard.Logger.LogDebug((object)("super_soundboard: Recorder MicInput type: " + type.FullName));
MethodInfo method = type.GetMethod("Read", new Type[1] { typeof(float[]) });
MethodInfo methodInfo = type.GetMethod("ReadInto", new Type[3]
{
typeof(float[]),
typeof(int),
typeof(int)
}) ?? type.GetMethod("ReadInto", new Type[2]
{
typeof(float[]),
typeof(int)
});
MethodInfo method2 = type.GetMethod("ReadSamples", new Type[1] { typeof(float[]) });
MethodInfo method3 = type.GetMethod("Read", new Type[1] { typeof(byte[]) });
MethodInfo chosen = null;
if (method != null)
{
chosen = method;
}
else if (method2 != null)
{
chosen = method2;
}
else if (methodInfo != null)
{
chosen = methodInfo;
}
if (chosen != null)
{
_recorderReadFunc = delegate(float[] buf)
{
try
{
object obj2 = chosen.Invoke(micInput2, new object[1] { buf });
if (obj2 == null)
{
return -1;
}
if (obj2 is bool flag)
{
return flag ? buf.Length : 0;
}
if (obj2 is int result)
{
return result;
}
return -1;
}
catch (Exception ex4)
{
super_soundboard.Logger.LogDebug((object)("super_soundboard: Recorder MicInput read invocation failed: " + ex4.Message));
return -1;
}
};
super_soundboard.Logger.LogDebug((object)("super_soundboard: Recorder MicInput supports method '" + chosen.Name + "', using it to read samples."));
}
else
{
super_soundboard.Logger.LogDebug((object)"super_soundboard: Recorder MicInput does not expose a compatible Read method.");
}
}
catch (Exception ex)
{
super_soundboard.Logger.LogDebug((object)("super_soundboard: Error inspecting Recorder MicInput: " + ex.Message));
}
}
catch (Exception ex2)
{
super_soundboard.Logger.LogDebug((object)("super_soundboard: Error handling recorder MicInput: " + ex2.Message));
}
}
if (!super_soundboard.AutoStartMicrophone)
{
super_soundboard.Logger.LogDebug((object)"super_soundboard: AutoStartMicrophone is disabled; not starting local Microphone.");
return;
}
try
{
StartLocalMicInternal();
}
catch (Exception ex3)
{
super_soundboard.Logger.LogWarning((object)("super_soundboard: Failed to start microphone: " + ex3.Message));
}
}
public void EnsureLocalMicStarted()
{
if (_recorderAudioReader != null || _recorderReadFunc != null || (Object)(object)_micClip != (Object)null)
{
super_soundboard.Logger.LogDebug((object)"super_soundboard: Local mic start skipped; recorder input already present or mic already started.");
return;
}
try
{
StartLocalMicInternal();
}
catch (Exception ex)
{
super_soundboard.Logger.LogWarning((object)("super_soundboard: EnsureLocalMicStarted failed: " + ex.Message));
}
}
public void StopLocalMic()
{
try
{
if (!string.IsNullOrEmpty(_micDevice))
{
Microphone.End(_micDevice);
super_soundboard.Logger.LogDebug((object)("super_soundboard: Stopped microphone '" + _micDevice + "' via StopLocalMic."));
_micDevice = null;
_micClip = null;
_noProgressCount = 0;
}
}
catch (Exception ex)
{
super_soundboard.Logger.LogDebug((object)("super_soundboard: StopLocalMic exception: " + ex.Message));
}
}
private void StartLocalMicInternal()
{
string[] devices = Microphone.devices;
if (devices.Length != 0)
{
_deviceIndex = 0;
_micDevice = devices[_deviceIndex];
_currentSampleRate = _sampleRates[0];
_micClip = Microphone.Start(_micDevice, true, 10, _currentSampleRate);
_lastMicPos = 0;
super_soundboard.Logger.LogDebug((object)("super_soundboard: Started microphone '" + _micDevice + "' with 10s buffer"));
if (super_soundboard.AutoSwitchMicrophone)
{
super_soundboard.Logger.LogDebug((object)"super_soundboard: Microphone auto-switch enabled; will try other devices if no data is produced.");
}
}
else
{
super_soundboard.Logger.LogWarning((object)"super_soundboard: No microphone devices found!");
}
}
public void Update()
{
if (_isDisposed)
{
return;
}
float[] array = null;
if ((Object)(object)_micClip != (Object)null)
{
int position = Microphone.GetPosition(_micDevice);
int num = ((position < _lastMicPos) ? (_micClip.samples - _lastMicPos + position) : (position - _lastMicPos));
if (position == _lastMicPos)
{
_noProgressCount++;
}
else
{
_noProgressCount = 0;
}
if (super_soundboard.AutoSwitchMicrophone && _noProgressCount > 120)
{
super_soundboard.Logger.LogWarning((object)$"SoundboardMixer: No progress on microphone '{_micDevice}' detected; attempting to switch device (attempts: {_noProgressCount}).");
TrySwitchDevice();
return;
}
if (num > 0)
{
array = new float[num];
if (_lastMicPos + num <= _micClip.samples)
{
_micClip.GetData(array, _lastMicPos);
}
else
{
int num2 = _micClip.samples - _lastMicPos;
int num3 = num - num2;
float[] array2 = new float[num2];
_micClip.GetData(array2, _lastMicPos);
Array.Copy(array2, 0, array, 0, num2);
float[] array3 = new float[num3];
_micClip.GetData(array3, 0);
Array.Copy(array3, 0, array, num2, num3);
}
_lastMicPos = (_lastMicPos + num) % _micClip.samples;
}
}
else
{
int num4 = 1024;
float[] array4 = new float[num4];
bool flag = false;
int num5 = 0;
if (_recorderAudioReader != null)
{
try
{
if (((IDataReader<float>)(object)_recorderAudioReader).Read(array4))
{
flag = true;
num5 = array4.Length;
}
}
catch (Exception ex)
{
super_soundboard.Logger.LogDebug((object)("super_soundboard: Recorder IAudioReader read failed: " + ex.Message));
}
}
else if (_recorderReadFunc != null)
{
try
{
num5 = _recorderReadFunc(array4);
if (num5 > 0)
{
flag = true;
}
}
catch (Exception ex2)
{
super_soundboard.Logger.LogDebug((object)("super_soundboard: Recorder read func failed: " + ex2.Message));
}
}
if (flag && num5 > 0)
{
array = new float[num5];
Array.Copy(array4, 0, array, 0, num5);
}
}
if (array == null || array.Length == 0)
{
return;
}
if ((Object)(object)super_soundboard.SpeechManagerInstance != (Object)null)
{
super_soundboard.SpeechManagerInstance.ProcessAudio(array);
}
lock (_bufferLock)
{
float[] array5 = array;
foreach (float item in array5)
{
_micBuffer.Enqueue(item);
}
while (_micBuffer.Count > 96000)
{
_micBuffer.Dequeue();
}
}
}
public bool Read(float[] buffer)
{
if (_isDisposed)
{
Array.Clear(buffer, 0, buffer.Length);
return false;
}
bool flag = (Object)(object)_micClip != (Object)null || _recorderAudioReader != null || _recorderReadFunc != null;
lock (_bufferLock)
{
int count = _micBuffer.Count;
if (flag)
{
if (count < buffer.Length)
{
return false;
}
}
else if (_loopback.SamplesAvailable == 0)
{
return false;
}
int num = Math.Min(count, buffer.Length);
for (int i = 0; i < num; i++)
{
buffer[i] = _micBuffer.Dequeue();
}
for (int j = num; j < buffer.Length; j++)
{
buffer[j] = 0f;
}
}
if (_loopback.SamplesAvailable > 0)
{
float[] array = new float[buffer.Length];
int num2 = _loopback.ReadInto(array, 0, buffer.Length);
for (int k = 0; k < num2; k++)
{
buffer[k] = Math.Max(-1f, Math.Min(1f, buffer[k] + array[k]));
}
}
float masterVolume = super_soundboard.MasterVolume;
if (Math.Abs(masterVolume - 1f) > 0.0001f)
{
for (int l = 0; l < buffer.Length; l++)
{
buffer[l] *= masterVolume;
}
}
return true;
}
public void Dispose()
{
if (_isDisposed)
{
return;
}
_isDisposed = true;
try
{
if (!string.IsNullOrEmpty(_micDevice))
{
Microphone.End(_micDevice);
super_soundboard.Logger.LogDebug((object)("super_soundboard: Stopped microphone '" + _micDevice + "' on Dispose."));
_micDevice = null;
_micClip = null;
}
}
catch (Exception ex)
{
super_soundboard.Logger.LogDebug((object)("super_soundboard: Exception while stopping microphone: " + ex.Message));
}
}
private void TrySwitchDevice()
{
try
{
string[] devices = Microphone.devices;
if (devices == null || devices.Length == 0)
{
super_soundboard.Logger.LogWarning((object)"super_soundboard: TrySwitchDevice: no microphone devices available.");
return;
}
int num = (_deviceIndex + 1) % devices.Length;
for (int i = 0; i < devices.Length; i++)
{
int num2 = (num + i) % devices.Length;
string text = devices[num2];
int[] sampleRates = _sampleRates;
foreach (int num3 in sampleRates)
{
try
{
if (!string.IsNullOrEmpty(_micDevice))
{
Microphone.End(_micDevice);
}
}
catch
{
}
try
{
AudioClip val = Microphone.Start(text, true, 10, num3);
int position = Microphone.GetPosition(text);
if (position > 0 && (Object)(object)val != (Object)null)
{
_micDevice = text;
_micClip = val;
_lastMicPos = position;
_deviceIndex = num2;
_currentSampleRate = num3;
_noProgressCount = 0;
super_soundboard.Logger.LogDebug((object)$"super_soundboard: Switched to microphone '{text}' at {num3} Hz");
return;
}
}
catch (Exception ex)
{
super_soundboard.Logger.LogDebug((object)("super_soundboard: Try start mic '" + text + "' failed: " + ex.Message));
}
}
}
string text2 = devices[num];
try
{
if (!string.IsNullOrEmpty(_micDevice))
{
Microphone.End(_micDevice);
}
}
catch
{
}
try
{
_micDevice = text2;
_micClip = Microphone.Start(_micDevice, true, 10, _currentSampleRate);
_lastMicPos = 0;
_deviceIndex = num;
_noProgressCount = 0;
super_soundboard.Logger.LogDebug((object)("super_soundboard: Started microphone '" + _micDevice + "' after switching (no immediate progress)."));
}
catch (Exception ex2)
{
super_soundboard.Logger.LogDebug((object)("super_soundboard: Failed to start fallback mic '" + text2 + "': " + ex2.Message));
}
}
catch (Exception ex3)
{
super_soundboard.Logger.LogDebug((object)("super_soundboard: Exception in TrySwitchDevice: " + ex3.Message));
}
}
}
public class SpeechManager : MonoBehaviour
{
[CompilerGenerated]
private sealed class <DownloadAndCache>d__26 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public string filename;
public SpeechManager <>4__this;
private string <localPath>5__1;
private string <uri>5__2;
private Task<byte[]> <task>5__3;
private Exception <ex>5__4;
private UnityWebRequest <www>5__5;
private bool <hasError>5__6;
private AudioClip <clip>5__7;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <DownloadAndCache>d__26(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || num == 2)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<localPath>5__1 = null;
<uri>5__2 = null;
<task>5__3 = null;
<ex>5__4 = null;
<www>5__5 = null;
<clip>5__7 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0285: Unknown result type (might be due to invalid IL or missing references)
//IL_028b: Invalid comparison between Unknown and I4
//IL_0238: Unknown result type (might be due to invalid IL or missing references)
try
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
if (<>4__this._soundCache.ContainsKey(filename))
{
return false;
}
if (!<>4__this.IsValidFilename(filename))
{
super_soundboard.Logger.LogError((object)("Invalid filename detected: " + filename + ". Filename contains forbidden characters."));
return false;
}
<localPath>5__1 = Path.Combine(<>4__this._cacheDir, filename);
if (!File.Exists(<localPath>5__1))
{
<task>5__3 = _httpClient.GetByteArrayAsync(<>4__this.ApiBaseUrl + "/api/sounds/" + filename);
goto IL_0114;
}
goto IL_0200;
case 1:
<>1__state = -1;
goto IL_0114;
case 2:
{
<>1__state = -3;
<hasError>5__6 = false;
<hasError>5__6 = (int)<www>5__5.result != 1;
if (<hasError>5__6)
{
super_soundboard.Logger.LogError((object)("Failed to load cached sound " + filename + ": " + <www>5__5.error));
}
else
{
<clip>5__7 = DownloadHandlerAudioClip.GetContent(<www>5__5);
if ((Object)(object)<clip>5__7 != (Object)null)
{
((Object)<clip>5__7).name = filename;
<>4__this._soundCache[filename] = <clip>5__7;
super_soundboard.Logger.LogDebug((object)("Cached sound: " + filename));
}
<clip>5__7 = null;
}
<>m__Finally1();
<www>5__5 = null;
return false;
}
IL_0114:
if (!<task>5__3.IsCompleted)
{
<>2__current = null;
<>1__state = 1;
return true;
}
if (<task>5__3.IsFaulted)
{
super_soundboard.Logger.LogError((object)("Failed to download sound " + filename + ": " + (<task>5__3.Exception?.InnerException?.Message ?? <task>5__3.Exception?.Message)));
return false;
}
try
{
File.WriteAllBytes(<localPath>5__1, <task>5__3.Result);
}
catch (Exception ex)
{
<ex>5__4 = ex;
super_soundboard.Logger.LogError((object)("Failed to write sound file " + <localPath>5__1 + ": " + <ex>5__4.Message));
return false;
}
<task>5__3 = null;
goto IL_0200;
IL_0200:
<uri>5__2 = "file://" + <localPath>5__1.Replace("\\", "/");
<www>5__5 = UnityWebRequestMultimedia.GetAudioClip(<uri>5__2, <>4__this.GetAudioTypeFromExtension(filename));
<>1__state = -3;
<>2__current = <www>5__5.SendWebRequest();
<>1__state = 2;
return true;
}
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
if (<www>5__5 != null)
{
((IDisposable)<www>5__5).Dispose();
}
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <DownloadAndCacheAndPlay>d__41 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public string filename;
public float volumePercent;
public SpeechManager <>4__this;
private AudioClip <clip>5__1;
private float <localVolumeScale>5__2;
private float <remoteVolumeScale>5__3;
private AudioSource <source>5__4;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <DownloadAndCacheAndPlay>d__41(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<clip>5__1 = null;
<source>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = <>4__this.DownloadAndCache(filename);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (<>4__this._soundCache.TryGetValue(filename, out <clip>5__1))
{
super_soundboard.Logger.LogInfo((object)$"Playing sound after download: {filename} (Vol: {volumePercent}%)");
<localVolumeScale>5__2 = volumePercent / 100f * super_soundboard.LocalVolume * super_soundboard.MasterVolume;
<remoteVolumeScale>5__3 = volumePercent / 100f * super_soundboard.RemoteVolume * super_soundboard.MasterVolume;
if ((Object)(object)super_soundboard.Instance != (Object)null)
{
<source>5__4 = ((Component)super_soundboard.Instance).GetComponent<AudioSource>();
if ((Object)(object)<source>5__4 != (Object)null)
{
<source>5__4.PlayOneShot(<clip>5__1, <localVolumeScale>5__2);
}
<source>5__4 = null;
}
((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.PushToLoopback(<clip>5__1, <remoteVolumeScale>5__3));
}
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <FetchConfigAndStart>d__20 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public SpeechManager <>4__this;
private int <retryCount>5__1;
private Task<string> <task>5__2;
private string <json>5__3;
private Mapping[] <>s__4;
private int <>s__5;
private Mapping <m>5__6;
private Exception <ex>5__7;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <FetchConfigAndStart>d__20(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<task>5__2 = null;
<json>5__3 = null;
<>s__4 = null;
<m>5__6 = null;
<ex>5__7 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0151: Unknown result type (might be due to invalid IL or missing references)
//IL_015b: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<retryCount>5__1 = 0;
goto IL_03cb;
case 1:
<>1__state = -1;
goto IL_00b0;
case 2:
{
<>1__state = -1;
goto IL_03cb;
}
IL_03cb:
if (<retryCount>5__1 < 10)
{
super_soundboard.Logger.LogDebug((object)$"SpeechManager: Fetching config from {<>4__this.ApiBaseUrl}/api/config (Attempt {<retryCount>5__1 + 1}/{10})...");
<task>5__2 = _httpClient.GetStringAsync(<>4__this.ApiBaseUrl + "/api/config");
goto IL_00b0;
}
return false;
IL_00b0:
if (!<task>5__2.IsCompleted)
{
<>2__current = null;
<>1__state = 1;
return true;
}
if (<task>5__2.IsFaulted)
{
super_soundboard.Logger.LogWarning((object)("Failed to fetch config: " + (<task>5__2.Exception?.InnerException?.Message ?? <task>5__2.Exception?.Message)));
<retryCount>5__1++;
if (<retryCount>5__1 < 10)
{
<>2__current = (object)new WaitForSeconds(2f);
<>1__state = 2;
return true;
}
super_soundboard.Logger.LogError((object)$"SpeechManager: Gave up fetching config after {10} attempts.");
return false;
}
super_soundboard.Logger.LogDebug((object)"SpeechManager: Config response received, parsing...");
try
{
<json>5__3 = <task>5__2.Result;
super_soundboard.Logger.LogDebug((object)$"SpeechManager: Config JSON length: {<json>5__3.Length}");
<>4__this._config = new ConfigData();
<>4__this._config.mappings = <>4__this.ParseMappings(<json>5__3);
if (<>4__this._config?.mappings != null && <>4__this._config.mappings.Length != 0)
{
super_soundboard.Logger.LogDebug((object)$"Loaded {<>4__this._config.mappings.Length} mappings.");
<>s__4 = <>4__this._config.mappings;
for (<>s__5 = 0; <>s__5 < <>s__4.Length; <>s__5++)
{
<m>5__6 = <>s__4[<>s__5];
if (<m>5__6.keywords != null && <m>5__6.keywords.Length != 0)
{
super_soundboard.Logger.LogDebug((object)string.Format("Mapping: [{0}] -> {1} (Vol: {2})", string.Join(", ", <m>5__6.keywords), <m>5__6.file, <m>5__6.volume));
}
<m>5__6 = null;
}
<>s__4 = null;
((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.PreloadAllSounds());
<>4__this.StartRecognition();
}
else
{
super_soundboard.Logger.LogError((object)"Failed to parse mappings from config.");
}
return false;
}
catch (Exception ex)
{
<ex>5__7 = ex;
super_soundboard.Logger.LogError((object)("Error parsing config: " + <ex>5__7.Message));
super_soundboard.Logger.LogError((object)("Stack trace: " + <ex>5__7.StackTrace));
return false;
}
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <PreloadAllSounds>d__25 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public SpeechManager <>4__this;
private HashSet<string> <uniqueFiles>5__1;
private Mapping[] <>s__2;
private int <>s__3;
private Mapping <mapping>5__4;
private HashSet<string>.Enumerator <>s__5;
private string <filename>5__6;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <PreloadAllSounds>d__25(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<uniqueFiles>5__1 = null;
<>s__2 = null;
<mapping>5__4 = null;
<>s__5 = default(HashSet<string>.Enumerator);
<filename>5__6 = null;
<>1__state = -2;
}
private bool MoveNext()
{
if (<>1__state != 0)
{
return false;
}
<>1__state = -1;
if (<>4__this._config == null || <>4__this._config.mappings == null || <>4__this._config.mappings.Length == 0)
{
super_soundboard.Logger.LogWarning((object)"No mappings to preload");
return false;
}
<uniqueFiles>5__1 = new HashSet<string>();
<>s__2 = <>4__this._config.mappings;
for (<>s__3 = 0; <>s__3 < <>s__2.Length; <>s__3++)
{
<mapping>5__4 = <>s__2[<>s__3];
if (!string.IsNullOrEmpty(<mapping>5__4.file))
{
<uniqueFiles>5__1.Add(<mapping>5__4.file);
}
<mapping>5__4 = null;
}
<>s__2 = null;
if (<uniqueFiles>5__1.Count > 0)
{
<>4__this._cachedSoundList = new string[<uniqueFiles>5__1.Count];
<uniqueFiles>5__1.CopyTo(<>4__this._cachedSoundList);
super_soundboard.Logger.LogDebug((object)$"Preloading {<uniqueFiles>5__1.Count} mapped sounds...");
<>s__5 = <uniqueFiles>5__1.GetEnumerator();
try
{
while (<>s__5.MoveNext())
{
<filename>5__6 = <>s__5.Current;
((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.DownloadAndCache(<filename>5__6));
<filename>5__6 = null;
}
}
finally
{
((IDisposable)<>s__5).Dispose();
}
<>s__5 = default(HashSet<string>.Enumerator);
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <PushToLoopback>d__42 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public AudioClip clip;
public float volumeScale;
public SpeechManager <>4__this;
private float[] <data>5__1;
private float[] <monoData>5__2;
private float[] <resampledData>5__3;
private int <position>5__4;
private int <chunkSize>5__5;
private int <i>5__6;
private int <i>5__7;
private float <ratio>5__8;
private int <newLength>5__9;
private int <i>5__10;
private float <srcPos>5__11;
private int <srcIdx>5__12;
private float <frac>5__13;
private int <i>5__14;
private int <remaining>5__15;
private int <count>5__16;
private float[] <chunk>5__17;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <PushToLoopback>d__42(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<data>5__1 = null;
<monoData>5__2 = null;
<resampledData>5__3 = null;
<chunk>5__17 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0461: Unknown result type (might be due to invalid IL or missing references)
//IL_046b: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<data>5__1 = new float[clip.samples * clip.channels];
clip.GetData(<data>5__1, 0);
if (clip.channels == 2)
{
<monoData>5__2 = new float[clip.samples];
<i>5__6 = 0;
while (<i>5__6 < clip.samples)
{
<monoData>5__2[<i>5__6] = (<data>5__1[<i>5__6 * 2] + <data>5__1[<i>5__6 * 2 + 1]) * 0.5f;
<i>5__6++;
}
}
else if (clip.channels == 1)
{
<monoData>5__2 = <data>5__1;
}
else
{
super_soundboard.Logger.LogWarning((object)$"Unsupported channel count: {clip.channels}. Using first channel.");
<monoData>5__2 = new float[clip.samples];
<i>5__7 = 0;
while (<i>5__7 < clip.samples)
{
<monoData>5__2[<i>5__7] = <data>5__1[<i>5__7 * clip.channels];
<i>5__7++;
}
}
if (clip.frequency != 48000)
{
<ratio>5__8 = 48000f / (float)clip.frequency;
<newLength>5__9 = (int)((float)<monoData>5__2.Length * <ratio>5__8);
<resampledData>5__3 = new float[<newLength>5__9];
<i>5__10 = 0;
while (<i>5__10 < <newLength>5__9)
{
<srcPos>5__11 = (float)<i>5__10 / <ratio>5__8;
<srcIdx>5__12 = (int)<srcPos>5__11;
<frac>5__13 = <srcPos>5__11 - (float)<srcIdx>5__12;
if (<srcIdx>5__12 + 1 < <monoData>5__2.Length)
{
<resampledData>5__3[<i>5__10] = <monoData>5__2[<srcIdx>5__12] * (1f - <frac>5__13) + <monoData>5__2[<srcIdx>5__12 + 1] * <frac>5__13;
}
else if (<srcIdx>5__12 < <monoData>5__2.Length)
{
<resampledData>5__3[<i>5__10] = <monoData>5__2[<srcIdx>5__12];
}
<i>5__10++;
}
super_soundboard.Logger.LogDebug((object)$"Resampled audio from {clip.frequency}Hz to 48000Hz ({<monoData>5__2.Length} -> {<newLength>5__9} samples)");
}
else
{
<resampledData>5__3 = <monoData>5__2;
}
if (Math.Abs(volumeScale - 1f) > 0.01f)
{
<i>5__14 = 0;
while (<i>5__14 < <resampledData>5__3.Length)
{
<resampledData>5__3[<i>5__14] *= volumeScale;
<i>5__14++;
}
}
<position>5__4 = 0;
<chunkSize>5__5 = 4800;
break;
case 1:
<>1__state = -1;
<chunk>5__17 = null;
break;
}
if (<position>5__4 < <resampledData>5__3.Length)
{
<remaining>5__15 = <resampledData>5__3.Length - <position>5__4;
<count>5__16 = Math.Min(<chunkSize>5__5, <remaining>5__15);
<chunk>5__17 = new float[<count>5__16];
Array.Copy(<resampledData>5__3, <position>5__4, <chunk>5__17, 0, <count>5__16);
super_soundboard.LoopbackInstance?.Push(<chunk>5__17);
<position>5__4 += <count>5__16;
<>2__current = (object)new WaitForSeconds(0.1f);
<>1__state = 1;
return true;
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <SendAudioData>d__32 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public float[] samples;
public SpeechManager <>4__this;
private byte[] <pcmData>5__1;
private string <base64Audio>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SendAudioData>d__32(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<pcmData>5__1 = null;
<base64Audio>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<pcmData>5__1 = <>4__this.ConvertToPCM16(samples);
<base64Audio>5__2 = Convert.ToBase64String(<pcmData>5__1);
<>2__current = <>4__this.SendToGoogleSpeechToText(<base64Audio>5__2);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <SendToGoogleSpeechToText>d__34 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public string base64Audio;
public SpeechManager <>4__this;
private string <apiKey>5__1;
private string <url>5__2;
private string <jsonBody>5__3;
private UnityWebRequest <www>5__4;
private byte[] <bodyRaw>5__5;
private string <responseText>5__6;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SendToGoogleSpeechToText>d__34(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || num == 1)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<apiKey>5__1 = null;
<url>5__2 = null;
<jsonBody>5__3 = null;
<www>5__4 = null;
<bodyRaw>5__5 = null;
<responseText>5__6 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Expected O, but got Unknown
//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Expected O, but got Unknown
//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Expected O, but got Unknown
//IL_0166: Unknown result type (might be due to invalid IL or missing references)
//IL_0181: Unknown result type (might be due to invalid IL or missing references)
//IL_0187: Invalid comparison between Unknown and I4
try
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<apiKey>5__1 = super_soundboard.GoogleApiKey;
if (string.IsNullOrEmpty(<apiKey>5__1))
{
super_soundboard.Logger.LogError((object)"SpeechManager: API Key is empty! Cannot send request.");
return false;
}
<url>5__2 = "https://speech.googleapis.com/v1/speech:recognize?key=" + <apiKey>5__1;
<jsonBody>5__3 = $"\r\n {{\r\n \"config\": {{\r\n \"encoding\": \"LINEAR16\",\r\n \"sampleRateHertz\": {16000},\r\n \"languageCode\": \"{super_soundboard.GoogleSpeechLanguage}\",\r\n \"model\": \"default\"\r\n }},\r\n \"audio\": {{\r\n \"content\": \"{base64Audio}\"\r\n }}\r\n }}";
<www>5__4 = new UnityWebRequest(<url>5__2, "POST");
<>1__state = -3;
<bodyRaw>5__5 = Encoding.UTF8.GetBytes(<jsonBody>5__3);
<www>5__4.uploadHandler = (UploadHandler)new UploadHandlerRaw(<bodyRaw>5__5);
<www>5__4.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
<www>5__4.SetRequestHeader("Content-Type", "application/json");
super_soundboard.Logger.LogDebug((object)("SpeechManager: Sending request to Google API... (Key: " + <apiKey>5__1.Substring(0, 5) + "...)"));
<>2__current = <www>5__4.SendWebRequest();
<>1__state = 1;
return true;
case 1:
<>1__state = -3;
super_soundboard.Logger.LogDebug((object)$"SpeechManager: Request completed. Result: {<www>5__4.result}");
if ((int)<www>5__4.result == 1)
{
<responseText>5__6 = <www>5__4.downloadHandler.text;
super_soundboard.Logger.LogDebug((object)("SpeechManager: Google API Response: " + <responseText>5__6));
<>4__this.ParseGoogleResponse(<responseText>5__6);
<responseText>5__6 = null;
}
else
{
super_soundboard.Logger.LogError((object)("Google API Error: " + <www>5__4.error));
super_soundboard.Logger.LogError((object)$"Response Code: {<www>5__4.responseCode}");
super_soundboard.Logger.LogError((object)("Response Body: " + <www>5__4.downloadHandler.text));
}
<bodyRaw>5__5 = null;
<>m__Finally1();
<www>5__4 = null;
return false;
}
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
if (<www>5__4 != null)
{
((IDisposable)<www>5__4).Dispose();
}
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private static readonly HttpClient _httpClient = new HttpClient();
private string _cacheDir = "";
private const int SAMPLE_RATE = 16000;
private const float SILENCE_THRESHOLD_TIME = 0.5f;
private const float MAX_RECORDING_DURATION = 5f;
private const float VAD_THRESHOLD = 0.001f;
private float _silenceTimer = 0f;
private float _recordingDuration = 0f;
private bool _isSpeaking = false;
private List<float> _currentUtterance = new List<float>();
private object _audioLock = new object();
private int _logThrottle = 0;
private ConfigData? _config;
private Dictionary<string, AudioClip> _soundCache = new Dictionary<string, AudioClip>();
private string[]? _cachedSoundList;
private readonly Queue<Action> _mainThreadActions = new Queue<Action>();
private string ApiBaseUrl => super_soundboard.ApiBaseUrl;
public void Initialize()
{
string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? ".";
_cacheDir = Path.Combine(path, "cache");
if (!Directory.Exists(_cacheDir))
{
Directory.CreateDirectory(_cacheDir);
}
super_soundboard.Logger.LogDebug((object)("SpeechManager: Initializing, starting config fetch from " + ApiBaseUrl + "..."));
((MonoBehaviour)this).StartCoroutine(FetchConfigAndStart());
}
public void OnApiBaseUrlChanged()
{
super_soundboard.Logger.LogInfo((object)("SpeechManager: Detected ApiBaseUrl change to " + ApiBaseUrl + ". Refreshing config and clearing caches..."));
_config = null;
_cachedSoundList = null;
try
{
foreach (AudioClip value in _soundCache.Values)
{
if ((Object)(object)value != (Object)null)
{
Object.Destroy((Object)(object)value);
}
}
}
catch (Exception ex)
{
super_soundboard.Logger.LogWarning((object)("SpeechManager: Error while destroying cached clips: " + ex.Message));
}
_soundCache.Clear();
try
{
_httpClient.BaseAddress = new Uri(ApiBaseUrl);
}
catch
{
}
((MonoBehaviour)this).StartCoroutine(FetchConfigAndStart());
}
[IteratorStateMachine(typeof(<FetchConfigAndStart>d__20))]
private IEnumerator FetchConfigAndStart()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <FetchConfigAndStart>d__20(0)
{
<>4__this = this
};
}
private Mapping[] ParseMappings(string json)
{
List<Mapping> list = new List<Mapping>();
try
{
Match match = Regex.Match(json, "\"mappings\"\\s*:\\s*\\[");
if (!match.Success)
{
super_soundboard.Logger.LogError((object)"Mappings array not found in JSON");
return new Mapping[0];
}
int num = match.Index + match.Length - 1;
int num2 = 0;
int num3 = num;
for (int i = num; i < json.Length; i++)
{
if (json[i] == '[')
{
num2++;
}
if (json[i] == ']')
{
num2--;
if (num2 == 0)
{
num3 = i;
break;
}
}
}
if (num3 <= num)
{
super_soundboard.Logger.LogError((object)"Could not find end of mappings array");
return new Mapping[0];
}
string text = json.Substring(num + 1, num3 - num - 1);
List<string> list2 = new List<string>();
int num4 = 0;
int num5 = -1;
for (int j = 0; j < text.Length; j++)
{
if (text[j] == '{')
{
if (num4 == 0)
{
num5 = j;
}
num4++;
}
else if (text[j] == '}')
{
num4--;
if (num4 == 0 && num5 != -1)
{
string item = text.Substring(num5, j - num5 + 1);
list2.Add(item);
num5 = -1;
}
}
}
super_soundboard.Logger.LogDebug((object)$"Found {list2.Count} mapping objects");
foreach (string item2 in list2)
{
Mapping mapping = new Mapping();
mapping.keywords = ExtractStringArray(item2, "keywords");
mapping.file = ExtractString(item2, "file");
mapping.volume = ExtractFloat(item2, "volume");
if (mapping.keywords != null && mapping.keywords.Length != 0 && !string.IsNullOrEmpty(mapping.file))
{
list.Add(mapping);
}
}
}
catch (Exception ex)
{
super_soundboard.Logger.LogError((object)("Error parsing mappings: " + ex.Message));
}
return list.ToArray();
}
private string[] ExtractStringArray(string json, string fieldName)
{
List<string> list = new List<string>();
try
{
string value = "\"" + fieldName + "\":[";
int num = json.IndexOf(value);
if (num == -1)
{
return new string[0];
}
int num2 = json.IndexOf("[", num);
int num3 = json.IndexOf("]", num2);
if (num2 == -1 || num3 == -1)
{
return new string[0];
}
string text = json.Substring(num2 + 1, num3 - num2 - 1);
bool flag = false;
int num4 = -1;
for (int i = 0; i < text.Length; i++)
{
if (text[i] != '"')
{
continue;
}
if (!flag)
{
num4 = i + 1;
flag = true;
continue;
}
if (num4 != -1)
{
string text2 = text.Substring(num4, i - num4);
if (!string.IsNullOrEmpty(text2))
{
list.Add(text2);
}
}
flag = false;
}
}
catch
{
}
return list.ToArray();
}
private string ExtractString(string json, string fieldName)
{
try
{
string text = "\"" + fieldName + "\":\"";
int num = json.IndexOf(text);
if (num == -1)
{
return "";
}
int num2 = num + text.Length;
int num3 = json.IndexOf("\"", num2);
if (num3 == -1)
{
return "";
}
return json.Substring(num2, num3 - num2);
}
catch
{
return "";
}
}
private float ExtractFloat(string json, string fieldName)
{
try
{
string text = "\"" + fieldName + "\":";
int num = json.IndexOf(text);
if (num == -1)
{
return 100f;
}
int num2 = num + text.Length;
int i;
for (i = num2; i < json.Length && (char.IsDigit(json[i]) || json[i] == '.' || json[i] == '-'); i++)
{
}
if (i > num2)
{
string s = json.Substring(num2, i - num2);
if (float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
{
return result;
}
}
}
catch
{
}
return 100f;
}
[IteratorStateMachine(typeof(<PreloadAllSounds>d__25))]
private IEnumerator PreloadAllSounds()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <PreloadAllSounds>d__25(0)
{
<>4__this = this
};
}
[IteratorStateMachine(typeof(<DownloadAndCache>d__26))]
private IEnumerator DownloadAndCache(string filename)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <DownloadAndCache>d__26(0)
{
<>4__this = this,
filename = filename
};
}
private AudioType GetAudioTypeFromExtension(string filePath)
{
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
string text = Path.GetExtension(filePath).ToLowerInvariant();
if (1 == 0)
{
}
AudioType result = (AudioType)(text switch
{
".wav" => 20,
".ogg" => 14,
".mp3" => 13,
_ => 20,
});
if (1 == 0)
{
}
return result;
}
private bool IsValidFilename(string filename)
{
if (string.IsNullOrWhiteSpace(filename))
{
return false;
}
string fileName = Path.GetFileName(filename);
if (fileName != filename)
{
return false;
}
string text = Path.GetExtension(fileName).ToLowerInvariant();
return text == ".wav" || text == ".ogg" || text == ".mp3";
}
private void StartRecognition()
{
if (!super_soundboard.SpeechRecognitionEnabled)
{
super_soundboard.Logger.LogDebug((object)"Speech recognition is disabled in config.");
}
else if (string.IsNullOrEmpty(super_soundboard.GoogleApiKey))
{
super_soundboard.Logger.LogWarning((object)"Google API Key is missing. Speech recognition will not work.");
}
else
{
super_soundboard.Logger.LogDebug((object)"SpeechManager: Ready to receive audio from SoundboardMixer.");
}
}
public void ProcessAudio(float[] buffer)
{
if (!super_soundboard.SpeechRecognitionEnabled || string.IsNullOrEmpty(super_soundboard.GoogleApiKey))
{
return;
}
int num = buffer.Length / 3;
float[] array = new float[num];
for (int i = 0; i < num; i++)
{
array[i] = buffer[i * 3];
}
float num2 = 0f;
for (int j = 0; j < array.Length; j++)
{
if (Mathf.Abs(array[j]) > num2)
{
num2 = Mathf.Abs(array[j]);
}
}
if (_logThrottle++ > 100)
{
_logThrottle = 0;
if (num2 > 0f)
{
super_soundboard.Logger.LogDebug((object)$"SpeechManager: MaxVol={num2:F4}, IsSpeaking={_isSpeaking}, Duration={_recordingDuration:F2}");
}
}
lock (_audioLock)
{
if (num2 > 0.001f)
{
_isSpeaking = true;
_silenceTimer = 0f;
_recordingDuration += (float)buffer.Length / 48000f;
}
else if (_isSpeaking)
{
_silenceTimer += (float)buffer.Length / 48000f;
}
if (_isSpeaking)
{
_currentUtterance.AddRange(array);
}
bool flag = false;
if (_isSpeaking && _silenceTimer >= 0.5f)
{
flag = true;
}
else if (_recordingDuration >= 5f)
{
flag = true;
}
if (flag)
{
SendCurrentUtterance();
_isSpeaking = false;
_silenceTimer = 0f;
_recordingDuration = 0f;
}
}
}
private void SendCurrentUtterance()
{
if (_currentUtterance.Count != 0)
{
float[] samples = _currentUtterance.ToArray();
_currentUtterance.Clear();
super_soundboard.Logger.LogDebug((object)$"SpeechManager: Sending utterance of {samples.Length} samples to Google...");
EnqueueMainThread(delegate
{
((MonoBehaviour)this).StartCoroutine(SendAudioData(samples));
});
}
}
[IteratorStateMachine(typeof(<SendAudioData>d__32))]
private IEnumerator SendAudioData(float[] samples)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SendAudioData>d__32(0)
{
<>4__this = this,
samples = samples
};
}
private byte[] ConvertToPCM16(float[] samples)
{
byte[] array = new byte[samples.Length * 2];
int num = 0;
foreach (float num2 in samples)
{
short num3 = (short)(Mathf.Clamp(num2, -1f, 1f) * 32767f);
array[num++] = (byte)((uint)num3 & 0xFFu);
array[num++] = (byte)((uint)(num3 >> 8) & 0xFFu);
}
return array;
}
[IteratorStateMachine(typeof(<SendToGoogleSpeechToText>d__34))]
private IEnumerator SendToGoogleSpeechToText(string base64Audio)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SendToGoogleSpeechToText>d__34(0)
{
<>4__this = this,
base64Audio = base64Audio
};
}
private void ParseGoogleResponse(string json)
{
try
{
if (string.IsNullOrEmpty(json))
{
super_soundboard.Logger.LogWarning((object)"SpeechManager: Empty response from Google.");
return;
}
MatchCollection matchCollection = Regex.Matches(json, "\"transcript\"\\s*:\\s*\"([^\"]+)\"");
if (matchCollection.Count > 0)
{
foreach (Match item in matchCollection)
{
if (item.Success && item.Groups.Count > 1)
{
string value = item.Groups[1].Value;
super_soundboard.Logger.LogInfo((object)("Google Recognized: " + value));
CheckKeywords(value);
}
}
return;
}
if (json.Contains("\"results\""))
{
super_soundboard.Logger.LogWarning((object)("SpeechManager: No transcripts found in JSON via Regex. (Raw: " + json + ")"));
}
else
{
super_soundboard.Logger.LogDebug((object)("SpeechManager: No results parsed from JSON (likely silence). (Raw: " + json + ")"));
}
}
catch (Exception ex)
{
super_soundboard.Logger.LogError((object)("Error parsing Google response: " + ex.Message));
}
}
private void CheckKeywords(string text)
{
if (_config == null || _config.mappings == null)
{
super_soundboard.Logger.LogWarning((object)"CheckKeywords: Config is null or has no mappings. Cannot check keywords.");
return;
}
Mapping[] mappings = _config.mappings;
foreach (Mapping mapping in mappings)
{
if (mapping.keywords == null)
{
continue;
}
string[] keywords = mapping.keywords;
foreach (string text2 in keywords)
{
if (text.Contains(text2))
{
super_soundboard.Logger.LogInfo((object)("Keyword matched: '" + text2 + "' -> Playing " + mapping.file));
if (mapping.file != null)
{
PlaySound(mapping.file, mapping.volume);
return;
}
}
}
}
}
private void EnqueueMainThread(Action action)
{
lock (_mainThreadActions)
{
_mainThreadActions.Enqueue(action);
}
}
private void Update()
{
lock (_mainThreadActions)
{
while (_mainThreadActions.Count > 0)
{
_mainThreadActions.Dequeue()();
}
}
}
public void PlayRandomSound()
{
if (_cachedSoundList != null && _cachedSoundList.Length != 0)
{
string filename = _cachedSoundList[Random.Range(0, _cachedSoundList.Length)];
PlaySound(filename, 100f);
}
else
{
super_soundboard.Logger.LogWarning((object)"No sounds available to play randomly.");
}
}
private void PlaySound(string filename, float volumePercent)
{
if (_soundCache.TryGetValue(filename, out AudioClip value))
{
super_soundboard.Logger.LogInfo((object)$"Playing cached sound: {filename} (Vol: {volumePercent}%)");
float num = volumePercent / 100f * super_soundboard.LocalVolume * super_soundboard.MasterVolume;
float volumeScale = volumePercent / 100f * super_soundboard.RemoteVolume * super_soundboard.MasterVolume;
if ((Object)(object)super_soundboard.Instance != (Object)null)
{
AudioSource component = ((Component)super_soundboard.Instance).GetComponent<AudioSource>();
if ((Object)(object)component != (Object)null)
{
component.PlayOneShot(value, num);
}
}
((MonoBehaviour)this).StartCoroutine(PushToLoopback(value, volumeScale));
}
else
{
((MonoBehaviour)this).StartCoroutine(DownloadAndCacheAndPlay(filename, volumePercent));
}
}
[IteratorStateMachine(typeof(<DownloadAndCacheAndPlay>d__41))]
private IEnumerator DownloadAndCacheAndPlay(string filename, float volumePercent)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <DownloadAndCacheAndPlay>d__41(0)
{
<>4__this = this,
filename = filename,
volumePercent = volumePercent
};
}
[IteratorStateMachine(typeof(<PushToLoopback>d__42))]
private IEnumerator PushToLoopback(AudioClip clip, float volumeScale)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <PushToLoopback>d__42(0)
{
<>4__this = this,
clip = clip,
volumeScale = volumeScale
};
}
private void OnDestroy()
{
}
}
[Serializable]
public class ConfigResponse
{
public bool success;
public ConfigData? data;
}
[Serializable]
public class ConfigData
{
public Mapping[]? mappings;
public int cooldownMs;
public string? lang;
public int wsPort;
}
[Serializable]
public class Mapping
{
public string[]? keywords;
public string? file;
public float volume;
}
[Serializable]
public class SoundListResponse
{
public bool success;
public string[]? data;
}
[BepInPlugin("sasnews.super_soundboard", "super_soundboard", "1.0")]
public class super_soundboard : BaseUnityPlugin
{
private AudioSource? _source;
private static ConfigEntry<bool>? _speechRecognitionEnabled;
private static ConfigEntry<float>? _localVolume;
private static ConfigEntry<float>? _remoteVolume;
private static ConfigEntry<string>? _apiBaseUrl;
private static ConfigEntry<string>? _googleApiKey;
private static ConfigEntry<string>? _googleSpeechLanguage;
private static ConfigEntry<KeyCode>? _debugHotkey;
private static ConfigEntry<bool>? _autoStartMicrophone;
private static ConfigEntry<bool>? _autoSwitchMicrophone;
private SoundboardMixer? _soundboardMixer;
private PlayerVoiceChat? _vc;
private PlayerVoiceChat? _lastVc;
private int _initRetryCount = 0;
private const int MAX_INIT_RETRIES = 10;
private float _nextRetryTime = 0f;
internal static super_soundboard Instance { get; private set; }
private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;
internal static ManualLogSource Logger => Instance._logger;
internal static bool SpeechRecognitionEnabled => _speechRecognitionEnabled?.Value ?? true;
internal static float LocalVolume => _localVolume?.Value ?? 1f;
internal static float RemoteVolume => _remoteVolume?.Value ?? 1f;
internal static string ApiBaseUrl
{
get
{
string text = _apiBaseUrl?.Value ?? "http://localhost:3211";
return text.TrimEnd('/');
}
}
internal static string GoogleApiKey => _googleApiKey?.Value ?? "AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgw";
internal static string GoogleSpeechLanguage => _googleSpeechLanguage?.Value ?? "ja-JP";
internal static bool AutoStartMicrophone => _autoStartMicrophone?.Value ?? false;
internal static bool AutoSwitchMicrophone => _autoSwitchMicrophone?.Value ?? false;
internal static float MasterVolume => 0.5f;
internal static SoundboardLoopback? LoopbackInstance { get; private set; }
internal static SpeechManager? SpeechManagerInstance { get; private set; }
private void Awake()
{
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Expected O, but got Unknown
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
//IL_00e5: Expected O, but got Unknown
Instance = this;
_googleApiKey = ((BaseUnityPlugin)this).Config.Bind<string>("SpeechRecognition", "GoogleApiKey", "AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgw", "API Key for Google Cloud Speech-to-Text. If empty, speech recognition may not work.");
_googleSpeechLanguage = ((BaseUnityPlugin)this).Config.Bind<string>("SpeechRecognition", "GoogleSpeechLanguage", "ja-JP", "Language code for speech recognition (e.g. ja-JP, en-US)");
_speechRecognitionEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("SpeechRecognition", "Enabled", true, "Enable/disable automatic speech recognition");
_localVolume = ((BaseUnityPlugin)this).Config.Bind<float>("SpeechRecognition", "LocalVolume", 1f, new ConfigDescription("Volume for sounds you hear locally (0.0 = mute, 1.0 = normal, 2.0 = double)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
_remoteVolume = ((BaseUnityPlugin)this).Config.Bind<float>("SpeechRecognition", "RemoteVolume", 1f, new ConfigDescription("Volume for sounds sent to voice chat (0.0 = mute, 1.0 = normal, 2.0 = double)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
_apiBaseUrl = ((BaseUnityPlugin)this).Config.Bind<string>("SpeechRecognition", "ApiBaseUrl", "http://localhost:3211", "Base URL for the soundboard API server");
_apiBaseUrl.SettingChanged += ApiBaseUrlSettingChanged;
_debugHotkey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Keybinds", "DebugPlayRandomSound", (KeyCode)290, "Key to play a random sound (selectable). Use any Unity KeyCode value.");
_autoStartMicrophone = ((BaseUnityPlugin)this).Config.Bind<bool>("Microphone", "AutoStart", true, "Automatically start a microphone if the Recorder does not provide an input (set true to allow auto-start). Default: true");
_autoSwitchMicrophone = ((BaseUnityPlugin)this).Config.Bind<bool>("Microphone", "AutoSwitch", false, "Automatically switch microphone device if the current device produces no samples. Default: false");
_autoStartMicrophone.SettingChanged += AutoStartSettingChanged;
_autoSwitchMicrophone.SettingChanged += AutoSwitchSettingChanged;
SpeechManagerInstance = ((Component)this).gameObject.AddComponent<SpeechManager>();
SpeechManagerInstance.Initialize();
_source = ((Component)this).gameObject.AddComponent<AudioSource>();
_source.playOnAwake = false;
_source.loop = false;
_source.spatialBlend = 0f;
_source.dopplerLevel = 0f;
_source.priority = 128;
LoopbackInstance = new SoundboardLoopback();
Logger.LogDebug((object)"super_soundboard: Awake finished.");
}
private void Update()
{
//IL_014b: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)_vc == (Object)null)
{
_vc = Object.FindObjectOfType<PlayerVoiceChat>();
if ((Object)(object)_vc != (Object)null)
{
Logger.LogDebug((object)"super_soundboard: Found PlayerVoiceChat. Initializing soundboard recorder bridge...");
_lastVc = _vc;
InitSoundboard();
}
}
else if ((Object)(object)_lastVc != (Object)(object)_vc)
{
Logger.LogDebug((object)"super_soundboard: PlayerVoiceChat instance changed (scene reload detected). Resetting...");
_soundboardMixer?.Dispose();
_soundboardMixer = null;
_lastVc = _vc;
_initRetryCount = 0;
_nextRetryTime = 0f;
InitSoundboard();
}
else if (_soundboardMixer == null && _initRetryCount < 10 && Time.time >= _nextRetryTime)
{
Logger.LogDebug((object)$"super_soundboard: Retrying initialization (attempt {_initRetryCount + 1}/{10})...");
InitSoundboard();
_initRetryCount++;
_nextRetryTime = Time.time + 1f;
}
ConfigEntry<KeyCode>? debugHotkey = _debugHotkey;
if (Input.GetKeyDown((KeyCode)((debugHotkey == null) ? 290 : ((int)debugHotkey.Value))))
{
SpeechManagerInstance?.PlayRandomSound();
}
_soundboardMixer?.Update();
}
private void InitSoundboard()
{
if ((Object)(object)_vc == (Object)null)
{
return;
}
try
{
Recorder val = _vc.recorder;
if ((Object)(object)val == (Object)null)
{
Logger.LogDebug((object)"super_soundboard: PlayerVoiceChat.recorder is null — attempting fallback search for Recorder in scene...");
Recorder val2 = Object.FindObjectOfType<Recorder>();
if (!((Object)(object)val2 != (Object)null))
{
if (_initRetryCount == 0 || _initRetryCount >= 9)
{
Logger.LogWarning((object)"========================================");
Logger.LogWarning((object)"super_soundboard: Recorder not found on PlayerVoiceChat.");
if (_initRetryCount >= 9)
{
Logger.LogWarning((object)"Voice chat integration is not available.");
Logger.LogWarning((object)"Sounds will only play locally (you can hear them).");
Logger.LogWarning((object)"Others in voice chat will NOT hear the soundboard.");
}
else
{
Logger.LogWarning((object)"Will retry in a moment...");
}
Logger.LogWarning((object)"========================================");
}
return;
}
Logger.LogDebug((object)("super_soundboard: Found Recorder on GameObject '" + ((Object)((Component)val2).gameObject).name + "' (type " + ((object)val2).GetType().FullName + "). Will use it."));
val = val2;
try
{
PropertyInfo property = ((object)_vc).GetType().GetProperty("recorder", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null && property.CanWrite)
{
property.SetValue(_vc, val);
Logger.LogDebug((object)"super_soundboard: Assigned found Recorder to PlayerVoiceChat.recorder property.");
}
else
{
FieldInfo field = ((object)_vc).GetType().GetField("recorder", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null)
{
field.SetValue(_vc, val);
Logger.LogDebug((object)"super_soundboard: Assigned found Recorder to PlayerVoiceChat.recorder field.");
}
else
{
Logger.LogDebug((object)"super_soundboard: Could not assign Recorder to PlayerVoiceChat (no accessible property/field).");
}
}
}
catch (Exception ex)
{
Logger.LogDebug((object)("super_soundboard: Exception while assigning Recorder to PlayerVoiceChat: " + ex.Message));
}
}
try
{
PropertyInfo property2 = ((object)val).GetType().GetProperty("enabled");
if (property2 != null && property2.PropertyType == typeof(bool))
{
if (!(bool)property2.GetValue(val))
{
property2.SetValue(val, true);
Logger.LogDebug((object)"super_soundboard: Enabled the Recorder component.");
}
}
else
{
Behaviour val3 = (Behaviour)(object)val;
if ((Object)(object)val3 != (Object)null && !val3.enabled)
{
val3.enabled = true;
Logger.LogDebug((object)"super_soundboard: Enabled the Recorder component (cast to Behaviour).");
}
}
}
catch (Exception ex2)
{
Logger.LogDebug((object)("super_soundboard: Could not enable Recorder: " + ex2.Message));
}
try
{
Component val4 = (Component)(object)val;
string text = (((Object)(object)val4 != (Object)null) ? ((Object)val4.gameObject).name : "(unknown)");
Logger.LogDebug((object)("super_soundboard: Using Recorder type " + ((object)val).GetType().FullName + " on GameObject '" + text + "'"));
Logger.LogDebug((object)string.Format("super_soundboard: Recorder has InputFactory? {0}", ((object)val).GetType().GetProperty("InputFactory") != null));
Logger.LogDebug((object)string.Format("super_soundboard: Recorder has SourceType? {0}", ((object)val).GetType().GetProperty("SourceType") != null));
}
catch (Exception ex3)
{
Logger.LogDebug((object)("super_soundboard: Error inspecting Recorder: " + ex3.Message));
}
try
{
string[] devices = Microphone.devices;
if (devices == null || devices.Length == 0)
{
Logger.LogWarning((object)"super_soundboard: No microphone devices found on this machine (Microphone.devices is empty).");
}
else
{
Logger.LogDebug((object)string.Format("super_soundboard: Microphone devices ({0}): {1}", devices.Length, string.Join(", ", devices)));
}
}
catch (Exception ex4)
{
Logger.LogDebug((object)("super_soundboard: Could not query Microphone.devices: " + ex4.Message));
}
if (_soundboardMixer == null)
{
object obj = null;
try
{
PropertyInfo property3 = ((object)val).GetType().GetProperty("MicInput", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property3 != null)
{
obj = property3.GetValue(val);
Logger.LogDebug((object)$"super_soundboard: Found MicInput property: {obj != null}");
}
}
catch (Exception ex5)
{
Logger.LogDebug((object)("super_soundboard: Could not access MicInput: " + ex5.Message));
}
_soundboardMixer = new SoundboardMixer(_vc, obj);
}
try
{
PropertyInfo property4 = ((object)val).GetType().GetProperty("TransmitEnabled");
if (property4 != null && property4.PropertyType == typeof(bool))
{
try
{
bool flag = (bool)property4.GetValue(val);
Logger.LogDebug((object)$"super_soundboard: TransmitEnabled property exists, current value: {flag}");
}
catch (Exception ex6)
{
Logger.LogDebug((object)("super_soundboard: Could not read TransmitEnabled value: " + ex6.Message));
}
property4.SetValue(val, true);
Logger.LogDebug((object)"super_soundboard: TransmitEnabled set to true");
}
else
{
Logger.LogDebug((object)"super_soundboard: TransmitEnabled property not found on Recorder.");
}
PropertyInfo property5 = ((object)val).GetType().GetProperty("RecordingEnabled");
if (property5 != null && property5.PropertyType == typeof(bool))
{
try
{
bool flag2 = (bool)property5.GetValue(val);
Logger.LogDebug((object)$"super_soundboard: RecordingEnabled property exists, current value: {flag2}");
}
catch (Exception ex7)
{
Logger.LogDebug((object)("super_soundboard: Could not read RecordingEnabled value: " + ex7.Message));
}
property5.SetValue(val, true);
Logger.LogDebug((object)"super_soundboard: RecordingEnabled set to true");
}
else
{
Logger.LogDebug((object)"super_soundboard: RecordingEnabled property not found on Recorder.");
}
}
catch (Exception arg)
{
Logger.LogWarning((object)$"super_soundboard: Failed to enable recording/transmit: {arg}");
}
try
{
PropertyInfo property6 = ((object)val).GetType().GetProperty("InputFactory");
if (property6 != null)
{
Func<IAudioReader<float>> value = CreateMixerFactory;
property6.SetValue(val, value);
Logger.LogDebug((object)"super_soundboard: InputFactory set.");
}
else
{
Logger.LogError((object)("super_soundboard: InputFactory property not found on Recorder (recorder type: " + ((object)val).GetType().FullName + "). This may indicate a Photon Voice version mismatch."));
}
}
catch (Exception arg2)
{
Logger.LogError((object)$"super_soundboard: Failed to set InputFactory: {arg2}");
}
try
{
PropertyInfo property7 = ((object)val).GetType().GetProperty("SourceType");
if (property7 != null && property7.PropertyType.IsEnum)
{
object obj2 = Enum.ToObject(property7.PropertyType, 2);
property7.SetValue(val, obj2);
Logger.LogDebug((object)$"super_soundboard: SourceType set to {obj2} (Factory)");
}
}
catch (Exception arg3)
{
Logger.LogWarning((object)$"super_soundboard: Failed to set SourceType: {arg3}");
}
try
{
Component[] array = Object.FindObjectsOfType<Component>();
Component[] array2 = array;
foreach (Component val5 in array2)
{
Type type = ((object)val5).GetType();
if (!(type.Name == "PhotonVoiceView") && (type.FullName == null || !type.FullName.Contains("Photon.Voice")))
{
continue;
}
try
{
string text2 = "(unknown)";
if (val5 != null)
{
Component val6 = val5;
if (true)
{
text2 = ((Object)val6.gameObject).name;
}
}
Logger.LogDebug((object)("super_soundboard: Found PhotonVoiceView on '" + text2 + "' (type " + type.FullName + ")"));
object obj3 = null;
PropertyInfo property8 = type.GetProperty("RecorderInUse", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property8 != null)
{
obj3 = property8.GetValue(val5);
if (obj3 == null)
{
property8.SetValue(val5, val);
obj3 = val;
Logger.LogDebug((object)"super_soundboard: Assigned Recorder to PhotonVoiceView.RecorderInUse");
}
}
else
{
FieldInfo field2 = type.GetField("recorderInUse", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field2 != null)
{
obj3 = field2.GetValue(val5);
if (obj3 == null)
{
field2.SetValue(val5, val);
obj3 = val;
Logger.LogDebug((object)"super_soundboard: Assigned Recorder to PhotonVoiceView.recorderInUse");
}
}
else
{
Logger.LogDebug((object)"super_soundboard: PhotonVoiceView has no accessible RecorderInUse property/field.");
}
}
if (obj3 == null)
{
continue;
}
try
{
PropertyInfo property9 = obj3.GetType().GetProperty("TransmitEnabled");
if (property9 != null && property9.PropertyType == typeof(bool))
{
try
{
bool flag3 = (bool)property9.GetValue(obj3);
Logger.LogDebug((object)$"super_soundboard: PhotonVoiceView recorder TransmitEnabled current: {flag3}");
}
catch
{
}
property9.SetValue(obj3, true);
Logger.LogDebug((object)"super_soundboard: Set PhotonVoiceView recorder TransmitEnabled = true");
}
}
catch (Exception ex8)
{
Logger.LogDebug((object)("super_soundboard: Could not set PhotonVoiceView recorder TransmitEnabled: " + ex8.Message));
}
}
catch (Exception ex9)
{
Logger.LogDebug((object)("super_soundboard: Error handling PhotonVoiceView instance: " + ex9.Message));
}
}
}
catch (Exception ex10)
{
Logger.LogDebug((object)("super_soundboard: Error searching for PhotonVoiceView: " + ex10.Message));
}
try
{
MethodInfo method = ((object)val).GetType().GetMethod("RestartRecording");
if (method != null)
{
method.Invoke(val, null);
}
else
{
((object)val).GetType().GetMethod("StartRecording")?.Invoke(val, null);
}
}
catch (Exception arg4)
{
Logger.LogWarning((object)$"super_soundboard: Failed to restart recording: {arg4}");
}
Logger.LogDebug((object)"super_soundboard: Recorder hooked with SoundboardMixer (Factory mode).");
_initRetryCount = 10;
}
catch (Exception arg5)
{
Logger.LogError((object)$"super_soundboard: InitSoundboard failed: {arg5}");
}
}
private IAudioReader<float> CreateMixerFactory()
{
if (_soundboardMixer == null || _soundboardMixer.IsDisposed)
{
SoundboardMixer? soundboardMixer = _soundboardMixer;
if (soundboardMixer != null && soundboardMixer.IsDisposed)
{
Logger.LogDebug((object)"super_soundboard: Previous SoundboardMixer was disposed, creating new instance in CreateMixerFactory.");
}
else
{
Logger.LogDebug((object)"super_soundboard: Creating new SoundboardMixer instance in CreateMixerFactory.");
}
object micInput = null;
try
{
Recorder val = _vc?.recorder;
if ((Object)(object)val != (Object)null)
{
PropertyInfo property = ((object)val).GetType().GetProperty("MicInput", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (property != null)
{
micInput = property.GetValue(val);
}
}
}
catch (Exception ex)
{
Logger.LogDebug((object)("super_soundboard: Could not access MicInput in CreateMixerFactory: " + ex.Message));
}
_soundboardMixer = new SoundboardMixer(_vc, micInput);
}
return (IAudioReader<float>)(object)_soundboardMixer;
}
private void OnDestroy()
{
_soundboardMixer?.Dispose();
try
{
if (_autoStartMicrophone != null)
{
_autoStartMicrophone.SettingChanged -= AutoStartSettingChanged;
}
if (_autoSwitchMicrophone != null)
{
_autoSwitchMicrophone.SettingChanged -= AutoSwitchSettingChanged;
}
if (_apiBaseUrl != null)
{
_apiBaseUrl.SettingChanged -= ApiBaseUrlSettingChanged;
}
}
catch
{
}
}
private void OnAutoStartChanged()
{
Logger.LogInfo((object)$"super_soundboard: AutoStartMicrophone changed => {AutoStartMicrophone}");
if (_soundboardMixer != null)
{
if (AutoStartMicrophone)
{
_soundboardMixer.EnsureLocalMicStarted();
}
else
{
_soundboardMixer.StopLocalMic();
}
}
}
private void OnAutoSwitchChanged()
{
Logger.LogInfo((object)$"super_soundboard: AutoSwitchMicrophone changed => {AutoSwitchMicrophone}");
}
private void AutoStartSettingChanged(object? sender, EventArgs e)
{
OnAutoStartChanged();
}
private void AutoSwitchSettingChanged(object? sender, EventArgs e)
{
OnAutoSwitchChanged();
}
private void ApiBaseUrlSettingChanged(object? sender, EventArgs e)
{
OnApiBaseUrlChanged();
}
private void OnApiBaseUrlChanged()
{
string apiBaseUrl = ApiBaseUrl;
try
{
if (_apiBaseUrl != null && _apiBaseUrl.Value != apiBaseUrl)
{
_apiBaseUrl.Value = apiBaseUrl;
}
}
catch (Exception ex)
{
Logger.LogWarning((object)("super_soundboard: Could not persist normalized ApiBaseUrl: " + ex.Message));
}
Logger.LogInfo((object)("super_soundboard: ApiBaseUrl changed => " + apiBaseUrl));
try
{
SpeechManagerInstance?.OnApiBaseUrlChanged();
}
catch (Exception ex2)
{
Logger.LogWarning((object)("super_soundboard: Error notifying SpeechManager of ApiBaseUrl change: " + ex2.Message));
}
}
}
}
