public AudioDirection GetDirection()
{
AudioDirection result = AudioDirection.None;
foreach (AudioDirection direction in ListeningTo.Values)
{
if (direction == AudioDirection.None)
{
continue;
}
if (result == AudioDirection.None)
{
result = direction;
}
else if (direction == AudioDirection.Both ||
(direction == AudioDirection.Left && result == AudioDirection.Right) ||
(direction == AudioDirection.Right && result == AudioDirection.Left))
{
result = AudioDirection.Both;
}
if (result == AudioDirection.Both)
{
break;
}
}
return(result);
}
public void SetUsers(List<ulong> users, AudioDirection direction)
{
// ensure chat/im connects to self as well
Direction = direction;
Users = users;
// re-apply settings to new users
SelectedButton.PerformClick();
}
public void SetUsers(List <ulong> users, AudioDirection direction)
{
// ensure chat/im connects to self as well
Direction = direction;
Users = users;
// re-apply settings to new users
SelectedButton.PerformClick();
}
/// <summary>
/// Converts a AudioDirection value to a corresponding string value
/// </summary>
/// <param name="enumValue">The AudioDirection value to convert</param>
/// <returns>The representative string value</returns>
public static string ToValue(AudioDirection enumValue)
{
switch (enumValue)
{
//only valid enum elements can be used
//this is necessary to avoid errors
case AudioDirection.IN:
case AudioDirection.OUT:
return(stringValues[(int)enumValue]);
//an invalid enum value was requested
default:
return(null);
}
}
public void ListenTo(int window, ulong user, AudioDirection direction)
{
if (Core.InvokeRequired)
{
Core.RunInCoreAsync(() => ListenTo(window, user, direction));
return;
}
// incoming voice from user will be outputted to speaker, and window notified
if (!RemoteVoices.ContainsKey(user))
{
RemoteVoices[user] = new RemoteVoice();
}
RemoteVoice remote = RemoteVoices[user];
remote.ListeningTo[window] = direction;
}
public void ProcessBuffers()
{
try
{
while (FilledBuffers < BufferCount)
{
byte[] data = null;
lock (AudioQueue) // either gets called from core, or system thread
{
if (AudioQueue.Count == 0)
{
return;
}
data = AudioQueue.Dequeue();
}
// keep a log of received audio that user can back track through
lock (History)
{
History.Enqueue(data);
while (History.Count > HistoryLength)
{
History.Dequeue();
}
}
// decode
Speex.speex_bits_reset(ref DecodeBits);
Speex.speex_bits_read_from(ref DecodeBits, data, data.Length);
byte[] mono = new byte[FrameSize * 2];
int success = Speex.speex_decode_int(SpeexDecoder, ref DecodeBits, mono);
if (success != 0)
{
continue;
}
// cancel echo
//if (Voices.Recorder != null && FrameSize == Voices.Recorder.FrameSize)
// Speex.speex_echo_playback(Voices.Recorder.EchoState, mono);
// get volume
short maxVolume = 0;
for (int i = 0; i < mono.Length / 2; i++)
{
short val = BitConverter.ToInt16(mono, i * 2);
if (val > maxVolume)
{
maxVolume = val;
}
}
if (maxVolume > User.VolumeIn)
{
User.VolumeIn = maxVolume;
}
// find out where audio should come out from, if at all
// return down here so that even if user not listening, window shows volume bar
AudioDirection direction = User.GetDirection();
if (direction == AudioDirection.None)
{
continue;
}
// shifting to one side
PlayBuffer buffer = Buffers[NextBuffer];
for (int i = 0; i < mono.Length / 2; i++)
{
switch (direction)
{
case AudioDirection.Both:
Buffer.BlockCopy(mono, i * 2, buffer.Data, i * 4, 2); // left
Buffer.BlockCopy(mono, i * 2, buffer.Data, i * 4 + 2, 2); // right
break;
case AudioDirection.Left:
Buffer.BlockCopy(mono, i * 2, buffer.Data, i * 4, 2); // left
break;
case AudioDirection.Right:
Buffer.BlockCopy(mono, i * 2, buffer.Data, i * 4 + 2, 2); // right
break;
}
}
WinMM.ErrorCheck(WinMM.waveOutWrite(WaveHandle, ref buffer.Header, Marshal.SizeOf(buffer.Header)));
FilledBuffers++;
NextBuffer++;
if (NextBuffer >= BufferCount)
{
NextBuffer = 0;
}
}
}
catch (Exception ex)
{
Voices.Core.RunInCoreAsync(() =>
{
Dispose();
Voices.Core.Network.UpdateLog("Voice", "Error filling buffers: " + ex.Message);
});
}
}
void Chat_MembersUpdate()
{
MemberTree.BeginUpdate();
MemberTree.Nodes.Clear();
NodeMap.Clear();
List <ulong> users = new List <ulong>();
Room.Members.LockReading(delegate()
{
if (Room.Members.SafeCount == 0)
{
MemberTree.EndUpdate();
return;
}
users = Room.Members.ToList();
TreeListNode root = MemberTree.virtualParent;
if (Room.Host != 0)
{
root = new MemberNode(this, Room.Host);
if (Room.IsLoop)
{
((MemberNode)root).IsLoopRoot = true;
}
else
{
NodeMap[Room.Host] = root as MemberNode;
}
UpdateNode(root as MemberNode);
MemberTree.Nodes.Add(root);
root.Expand();
}
foreach (ulong id in Room.Members)
{
if (id != Room.Host)
{
// if they left the room dont show them
if (!ChatService.IsCommandRoom(Room.Kind))
{
if (Room.Members.SafeCount == 0)
{
continue;
}
}
MemberNode node = new MemberNode(this, id);
NodeMap[id] = node;
UpdateNode(node);
GuiUtils.InsertSubNode(root, node);
}
}
});
MemberTree.EndUpdate();
if (VoiceButton != null)
{
AudioDirection direction = AudioDirection.Both;
if (ParentView.ViewHigh != null && ParentView.ViewLow != null)
{
if (Room.Kind == RoomKind.Command_High || Room.Kind == RoomKind.Live_High)
{
direction = AudioDirection.Left;
}
else if (Room.Kind == RoomKind.Command_Low || Room.Kind == RoomKind.Live_Low)
{
direction = AudioDirection.Right;
}
}
VoiceButton.SetUsers(users, direction);
}
}
public void ListenTo(int window, ulong user, AudioDirection direction)
{
if (Core.InvokeRequired)
{
Core.RunInCoreAsync(() => ListenTo(window, user, direction));
return;
}
// incoming voice from user will be outputted to speaker, and window notified
if (!RemoteVoices.ContainsKey(user))
RemoteVoices[user] = new RemoteVoice();
RemoteVoice remote = RemoteVoices[user];
remote.ListeningTo[window] = direction;
}
