private unsafe VoiceState GetState() { VoiceState result = new VoiceState(); GetStateNative(Instance.ToPointer(), out result, 0); return(result); }
public bool JoinAnchorRoom() { if (VoiceState.Inited != State) { Debug.Log("Error:GVoiceManager.JoinAnchorRoom VoiceState.Inited = " + State); if (IsInRoom) { EventDispatcher.Instance.DispatchEvent(new ShowUIHintBoard(GameUtils.GetDictionaryText(301040))); } return(false); } bool canSpeek = false; if (IsAnchor) { canSpeek = true; NetManager.Instance.StartCoroutine(AnchorEnterRoom()); } Debug.Log("GVoiceManager.JoinAnchorRoom roomName=" + AnchorRoom + " isAnchor=" + canSpeek); m_voiceengine.SetMode(GCloudVoiceMode.RealTime); if ((int)GCloudVoiceErr.GCLOUD_VOICE_SUCC != m_voiceengine.JoinNationalRoom(AnchorRoom, canSpeek ? GCloudVoiceRole.ANCHOR : GCloudVoiceRole.AUDIENCE, TimeOutMillSeconds)) { return(false); } State = VoiceState.JoiningRoom; mRoomType = RoomType.Anchor; return(true); }
public void Start(int channel, int note, int velocity) { this.note = note; this.velocity = velocity; this.channel = channel; time = 0.0; fadeMultiplier = 1.0f; decayCounter = 0; fadeCounter = 0; //Set note parameters in samples attack = inst.getAttack(note); release = inst.getRelease(note); hold = inst.getHold(note); decay = inst.getDecay(note); //Set counters and initial state decayCounter = decay; if (attack == 0) { state = VoiceState.Sustain; } else { state = VoiceState.Attack; fadeCounter = attack; } inUse = true; }
/// <summary> /// Initializes a new instance of the <see cref="BindableVoiceState"/> class. /// </summary> internal BindableVoiceState( IMessenger messenger, IDiscordService discordService, QuarrelClient quarrelClient, IDispatcherService dispatcherService, VoiceState state) : base(messenger, discordService, quarrelClient, dispatcherService) { _state = state; JoinStreamCommand = new RelayCommand(JoinStream); _messenger.Register <VoiceStateUpdatedMessage>(this, (_, m) => { if (m.VoiceState.User.Id == State.User.Id) { _dispatcherService.RunOnUIThread(() => { OnPropertyChanged(nameof(State)); OnPropertyChanged(nameof(CanJoin)); }); } }); _messenger.Register <StreamCreatedMessage>(this, (_, m) => { if (m.StreamKey.EndsWith(State.User.Id.ToString())) { _dispatcherService.RunOnUIThread(() => { IsWatching = true; }); } }); }
/// <summary> /// Updates the voice state and sends the data to the Lavalink Node if the voice server /// is also provided. /// </summary> /// <param name="voiceState">the voice state data</param> /// <returns>a task that represents the asynchronous operation</returns> /// <exception cref="InvalidOperationException">thrown if the player is destroyed</exception> internal Task UpdateAsync(VoiceState voiceState) { EnsureNotDestroyed(); _voiceState = voiceState; return(UpdateAsync()); }
public void Start(int channel, int note, int velocity) { this.note = note; this.velocity = velocity; this.channel = channel; time = 0.0; fadeMultiplier = 1.0f; decayCounter = 0; fadeCounter = 0; //Set note parameters in samples attack = inst.getAttack(note); release = inst.getRelease(note); hold = inst.getHold(note); decay = inst.getDecay(note); //Set counters and initial state decayCounter = decay; if (attack == 0) state = VoiceState.Sustain; else { state = VoiceState.Attack; fadeCounter = attack; } inUse = true; }
public void End() { if (voiceState == VoiceState.Playing) { voiceState = VoiceState.ReleaseRequested; } }
/// <summary> /// Create a new <see cref="DataSourceVersion2Command"/>. /// </summary> /// <param name="voiceState">The <see cref="VoiceState"/> to generate the command from.</param> /// <param name="state">The <see cref="VoiceUpdateState"/> to generate the command from.</param> /// <param name="outputBufferIndex">The output buffer index to use.</param> /// <param name="channelIndex">The target channel index.</param> /// <param name="nodeId">The node id associated to this command.</param> public void GenerateDataSourceVersion2(ref VoiceState voiceState, Memory <VoiceUpdateState> state, ushort outputBufferIndex, ushort channelIndex, int nodeId) { DataSourceVersion2Command command = new DataSourceVersion2Command(ref voiceState, state, outputBufferIndex, channelIndex, nodeId); command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command); AddCommand(command); }
/// <summary> /// Create a new <see cref="AdpcmDataSourceCommandVersion1"/>. /// </summary> /// <param name="voiceState">The <see cref="VoiceState"/> to generate the command from.</param> /// <param name="state">The <see cref="VoiceUpdateState"/> to generate the command from.</param> /// <param name="outputBufferIndex">The output buffer index to use.</param> /// <param name="nodeId">The node id associated to this command.</param> public void GenerateAdpcmDataSourceVersion1(ref VoiceState voiceState, Memory <VoiceUpdateState> state, ushort outputBufferIndex, int nodeId) { AdpcmDataSourceCommandVersion1 command = new AdpcmDataSourceCommandVersion1(ref voiceState, state, outputBufferIndex, nodeId); command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command); AddCommand(command); }
/// <summary> /// Updates the voice state and sends the data to the Lavalink Node if the voice server /// is also provided. /// </summary> /// <param name="voiceState">the voice state data</param> /// <returns>a task that represents the asynchronous operation</returns> /// <exception cref="InvalidOperationException">thrown if the player is destroyed</exception> internal Task UpdateAsync(VoiceState voiceState) { EnsureNotDestroyed(); VoiceState = voiceState; VoiceChannelId = voiceState.VoiceChannelId; return(UpdateAsync()); }
private void OnVoiceStateUpdated(object sender, VoiceState e) { _messenger.Send(new VoiceStateUpdatedMessage(e)); if (e.User.Id == MyId) { _messenger.Send(new MyVoiceStateUpdatedMessage(e)); } }
private Task OnVoiceStateUpdated(SocketUser user, SocketVoiceState oldSocketVoiceState, SocketVoiceState socketVoiceState) { var guildId = socketVoiceState.VoiceChannel?.Guild?.Id ?? oldSocketVoiceState.VoiceChannel.Guild.Id; var oldVoiceState = new VoiceState(oldSocketVoiceState.VoiceChannel?.Id, guildId, oldSocketVoiceState.VoiceSessionId); var voiceState = new VoiceState(socketVoiceState.VoiceChannel?.Id, guildId, socketVoiceState.VoiceSessionId); var args = new VoiceStateUpdateEventArgs(user.Id, voiceState, oldVoiceState); return(VoiceStateUpdated.InvokeAsync(this, args)); }
/// <summary> /// The asynchronous callback when a voice state update was received. /// </summary> /// <param name="voiceServer">the voice state data</param> /// <returns>a task that represents the asynchronous operation</returns> private Task OnVoiceStateUpdated(global::DSharpPlus.EventArgs.VoiceStateUpdateEventArgs eventArgs) { var sessionId = eventArgs.GetSessionId(); var guildId = eventArgs.Before?.Channel?.Guild?.Id ?? eventArgs.After.Channel.Guild.Id; var oldVoiceState = new VoiceState(eventArgs.Before?.Channel?.Id, guildId, sessionId); var voiceState = new VoiceState(eventArgs.After.Channel?.Id, guildId, sessionId); var args = new Events.VoiceStateUpdateEventArgs(eventArgs.User.Id, voiceState, oldVoiceState); return(VoiceStateUpdated.InvokeAsync(this, args)); }
/// <summary> /// Asynchronously triggered when the player has connected to a voice channel. /// </summary> /// <param name="voiceServer">the voice server connected to</param> /// <param name="voiceState">the voice state</param> /// <returns>a task that represents the asynchronous operation</returns> public async override Task OnConnectedAsync(VoiceServer voiceServer, VoiceState voiceState) { // check if a volume has been stored if (_volumes.TryGetValue(GuildId, out var volume) && Volume != volume) { // here the volume is restored await SetVolumeAsync(volume); } await base.OnConnectedAsync(voiceServer, voiceState); }
private async void ConnectToVoiceChannel(VoiceServerUpdate data, VoiceState state) { var message = new ValueSet { ["type"] = "connect", ["config"] = JsonConvert.SerializeObject(data), ["state"] = JsonConvert.SerializeObject(state), ["inputId"] = _settingsService.Roaming.GetValue <string>(SettingKeys.InputDevice), ["outputId"] = _settingsService.Roaming.GetValue <string>(SettingKeys.OutputDevice), }; AppServiceResponse response = await SendServiceMessage(message); }
private async void Gateway_VoiceStateUpdated(object sender, Gateway.GatewayEventArgs <VoiceState> e) { await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { if (e.EventData.UserId == DisplayedUser.UserId) { DisplayedUser = e.EventData; OnPropertyChanged(null, DisplayedUserProperty); } }); }
public CS_VOICESTATE_TYPE TryGetVoiceState(ulong uid) { for (int i = 0; i < this.m_voiceStateList.Count; i++) { VoiceState state = this.m_voiceStateList[i]; if ((state != null) && (state.uid == uid)) { return(state.state); } } return(CS_VOICESTATE_TYPE.CS_VOICESTATE_NONE); }
public void Stop() { if (_synth.FadeOutDuration == 0) { IsAlive = false; } else { _fadeCounter = (int)((1.0f - _fadeMultiplier) * _synth.FadeOutDuration); _state = VoiceState.Release; } }
public void Start(RegionPair region, int channel, int key, int velocity) { this.exclusiveClass = region.ExclusiveClass; this.channel = channel; this.key = key; this.velocity = velocity; if (velocity > 0) { // According to the Polyphone's implementation, the initial attenuation should be reduced to 40%. // I'm not sure why, but this indeed improves the loudness variability. var sampleAttenuation = 0.4F * region.InitialAttenuation; var filterAttenuation = 0.5F * region.InitialFilterQ; var decibels = 2 * SoundFontMath.LinearToDecibels(velocity / 127F) - sampleAttenuation - filterAttenuation; noteGain = SoundFontMath.DecibelsToLinear(decibels); } else { noteGain = 0F; } cutoff = region.InitialFilterCutoffFrequency; resonance = SoundFontMath.DecibelsToLinear(region.InitialFilterQ); vibLfoToPitch = 0.01F * region.VibratoLfoToPitch; modLfoToPitch = 0.01F * region.ModulationLfoToPitch; modEnvToPitch = 0.01F * region.ModulationEnvelopeToPitch; modLfoToCutoff = region.ModulationLfoToFilterCutoffFrequency; modEnvToCutoff = region.ModulationEnvelopeToFilterCutoffFrequency; dynamicCutoff = modLfoToCutoff != 0 || modEnvToCutoff != 0; modLfoToVolume = region.ModulationLfoToVolume; dynamicVolume = modLfoToVolume > 0.05F; instrumentPan = SoundFontMath.Clamp(region.Pan, -50F, 50F); instrumentReverb = 0.01F * region.ReverbEffectsSend; instrumentChorus = 0.01F * region.ChorusEffectsSend; volEnv.Start(region, key, velocity); modEnv.Start(region, key, velocity); vibLfo.StartVibrato(region, key, velocity); modLfo.StartModulation(region, key, velocity); oscillator.Start(synthesizer.SoundFont.WaveDataArray, region); filter.ClearBuffer(); filter.SetLowPassFilter(cutoff, resonance); smoothedCutoff = cutoff; voiceState = VoiceState.Playing; voiceLength = 0; }
private Task OnVoiceStateUpdated(SocketUser user, SocketVoiceState oldSocketVoiceState, SocketVoiceState socketVoiceState) { var guildId = oldSocketVoiceState.VoiceChannel?.Guild?.Id ?? socketVoiceState.VoiceChannel.Guild.Id; // create voice state var voiceState = new VoiceState( voiceChannelId: socketVoiceState.VoiceChannel?.Id, guildId: guildId, voiceSessionId: socketVoiceState.VoiceSessionId); // invoke event return(VoiceStateUpdated.InvokeAsync(this, new VoiceStateUpdateEventArgs(user.Id, voiceState))); }
/// <inheritdoc/> public VoiceState[] GetVoiceStates() { VoiceState[] states = new VoiceState[_users.Count]; int i = 0; foreach (var user in _users) { states[i] = Context.Voice.GetVoiceState(user) !; i++; } return(states); }
private void GenerateDataSource(ref VoiceState voiceState, Memory <VoiceUpdateState> dspState, int channelIndex) { if (voiceState.MixId != Constants.UnusedMixId) { ref MixState mix = ref _mixContext.GetState(voiceState.MixId); _commandBuffer.GenerateDepopPrepare(dspState, _rendererContext.DepopBuffer, mix.BufferCount, mix.BufferOffset, voiceState.NodeId, voiceState.WasPlaying); }
public void SetVoiceState(ulong uid, CS_VOICESTATE_TYPE state) { for (int i = 0; i < this.m_voiceStateList.Count; i++) { VoiceState state2 = this.m_voiceStateList[i]; if ((state2 != null) && (state2.uid == uid)) { state2.state = state; return; } } this.m_voiceStateList.Add(new VoiceState(uid, state)); }
/// <summary> /// Speak the specified text using RT-Voice. You can override this /// if you need to do anything extra. /// </summary> /// <param name="text">Text.</param> public virtual void Speak(string text) { var voice = GetVoice(); var voiceName = (voice == null) ? "Default Speaker" : voice.Name; if (DialogueDebug.LogInfo) { Debug.Log("Dialogue System: RT-Voice speaking with " + voiceName + ": '" + text + "'", this); } Speaker.Silence(); m_audioSource.Stop(); voiceState = VoiceState.Starting; Speaker.Speak(text, m_audioSource, voice, true); }
internal void Update(MemberVoiceState model) { if (model.IsSelfMuted == true) { _voiceState |= VoiceState.SelfMuted; } else if (model.IsSelfMuted == false) { _voiceState &= ~VoiceState.SelfMuted; } if (model.IsSelfDeafened == true) { _voiceState |= VoiceState.SelfDeafened; } else if (model.IsSelfDeafened == false) { _voiceState &= ~VoiceState.SelfDeafened; } if (model.IsServerMuted == true) { _voiceState |= VoiceState.ServerMuted; } else if (model.IsServerMuted == false) { _voiceState &= ~VoiceState.ServerMuted; } if (model.IsServerDeafened == true) { _voiceState |= VoiceState.ServerDeafened; } else if (model.IsServerDeafened == false) { _voiceState &= ~VoiceState.ServerDeafened; } if (model.IsServerSuppressed == true) { _voiceState |= VoiceState.ServerSuppressed; } else if (model.IsServerSuppressed == false) { _voiceState &= ~VoiceState.ServerSuppressed; } /*if (model.SessionId != null) * SessionId = model.SessionId; * if (model.Token != null) * Token = model.Token;*/ _voiceChannelId = model.ChannelId; //Allows null }
private async void ConnectToVoiceChannel(VoiceServerUpdate data, VoiceState state) { voipCall?.NotifyCallEnded(); VoipCallCoordinator vcc = VoipCallCoordinator.GetDefault(); var status = await vcc.ReserveCallResourcesAsync("WebRTCBackgroundTask.VoipBackgroundTask"); // TODO: More info for Mobile voipCall = vcc.RequestNewOutgoingCall(string.Empty, string.Empty, "Quarrel", VoipPhoneCallMedia.Audio); voipCall.NotifyCallActive(); voiceConnection = new VoiceConnection(data, state, webrtcManager); voiceConnection.Speak += Speak; await voiceConnection.ConnectAsync(); }
public NoteData(SourceVoice v, float freqRatio, byte velocity = 127, bool perc = false) { if (velocity > 127) { throw new ArgumentOutOfRangeException("velocity", "Velocity cannot be greater than 127."); } Voice = v; FrequencyRatio = freqRatio; Velocity = 0f; IsPercussion = perc; PercussionPan = 63; FadeVolume = 1f; State = VoiceState.Active; }
//--Private Methods private void resetVoice() { inUse = false; state = VoiceState.None; note = 0; time = 0.0; fadeMultiplier = 1.0f; decayCounter = 0; fadeCounter = 0; pan = 0.0f; channel = 0; rightpan = 1.0f; leftpan = 1.0f; velocity = 127; }
public VoiceConnection(VoiceServerUpdate config, VoiceState state) { //var qualifiers = ResourceContext.GetForCurrentView().QualifierValues; //mobile = (qualifiers.ContainsKey("DeviceFamily") && qualifiers["DeviceFamily"] == "Mobile"); _webMessageSocket = new WebMessageSocket(); _udpSocket = new UDPSocket(); _state = state; _voiceServerConfig = config; eventHandlers = GetEventHandlers(); operationHandlers = GetOperationHandlers(); PrepareSocket(); }
private void ReleaseIfNecessary(Channel channelInfo) { if (voiceLength < synthesizer.MinimumVoiceDuration) { return; } if (voiceState == VoiceState.ReleaseRequested && !channelInfo.HoldPedal) { volEnv.Release(); modEnv.Release(); oscillator.Release(); voiceState = VoiceState.Released; } }
/// <inheritdoc/> /// <exception cref="ObjectDisposedException">thrown if the instance is disposed</exception> protected Task OnVoiceStateUpdated(DiscordClient _, global::DSharpPlus.EventArgs.VoiceStateUpdateEventArgs eventArgs) { // session id is the same as the resume key so DSharpPlus should be able to give us the // session key in either before or after voice state var sessionId = eventArgs.Before?.GetSessionId() ?? eventArgs.After.GetSessionId(); // create voice state var voiceState = new VoiceState( voiceChannelId: eventArgs.After?.Channel?.Id, guildId: eventArgs.Guild.Id, voiceSessionId: sessionId); // invoke event return(VoiceStateUpdated.InvokeAsync(this, new Events.VoiceStateUpdateEventArgs(eventArgs.User.Id, voiceState))); }
public void Process(float[,] workingBuffer) { if (IsAlive) { int samplesPerBuffer = workingBuffer.GetLength(1); for (int i = 0; i < samplesPerBuffer; i++) { if (_state == VoiceState.Attack) { _fadeMultiplier = (float)_fadeCounter / _synth.FadeInDuration; ++_fadeCounter; if (_fadeCounter >= _synth.FadeInDuration) { _state = VoiceState.Sustain; } } else if (_state == VoiceState.Release) { _fadeMultiplier = 1.0f - (float)_fadeCounter / _synth.FadeOutDuration; ++_fadeCounter; if (_fadeCounter >= _synth.FadeOutDuration) { IsAlive = false; return; } } else { _fadeMultiplier = 1.0f; } float sample = _synth.Oscillator(_frequency, _time); workingBuffer[0, i] += sample * 0.2f * _fadeMultiplier; _time += 1.0f / Synth.SampleRate; } } }
public void Stop() { if (hold == 0) { if (release == 0) { state = VoiceState.None; inUse = false; } else { state = VoiceState.Release; fadeCounter = release; } } else { state = VoiceState.Hold; fadeCounter = hold; } }
//--Private Methods private void resetVoice() { inUse = false; state = VoiceState.None; note = 0; time = 0.0; fadeMultiplier = 1.0f; decayCounter = 0; fadeCounter = 0; pan = 0.0f; channel = 0; rightpan = 1.0f; leftpan = 1.0f; velocity = 127; }
public void Process(float[,] workingBuffer, int startIndex, int endIndex) { if (inUse) { //quick checks to do before we go through our main loop if (synth.Channels == 2 && pan != synth.PanPositions[channel]) this.setPan(synth.PanPositions[channel]); //set sampleRate for tune variableSampleRate = synth.SampleRate * Math.Pow(2.0, (synth.TunePositions[channel] * -1.0) / 12.0); //main loop for (int i = startIndex; i < endIndex; i++) { //manage states and calculate volume level switch (state) { case VoiceState.Attack: fadeCounter--; if (fadeCounter <= 0) { state = VoiceState.Sustain; fadeMultiplier = 1.0f; } else { fadeMultiplier = 1.0f - (fadeCounter / (float)attack); } break; case VoiceState.Sustain: decayCounter--; if (decayCounter <= 0) { state = VoiceState.None; inUse = false; fadeMultiplier = 0.0f; } else { fadeMultiplier = decayCounter / (float)decay; } break; case VoiceState.Hold: fadeCounter--;//not used for volume decayCounter--; if (decayCounter <= 0) { state = VoiceState.None; inUse = false; fadeMultiplier = 0.0f; } else if (fadeCounter <= 0) { state = VoiceState.Release; fadeCounter = release; } else { fadeMultiplier = decayCounter / (float)decay; } break; case VoiceState.Release: fadeCounter--; if (fadeCounter <= 0) { state = VoiceState.None; inUse = false; } else {//Multiply decay with fadeout so volume doesn't suddenly rise when releasing notes fadeMultiplier = (decayCounter / (float)decay) * (fadeCounter / (float)release); } break; } //end of state management //Decide how to sample based on channels available //mono output if (synth.Channels == 1) { float sample = inst.getSampleAtTime(note, 0, synth.SampleRate, ref time); sample = sample * (velocity / 127.0f) * synth.VolPositions[channel]; workingBuffer[0, i] += (sample * fadeMultiplier * gainControl); } //mono sample to stereo output else if (synth.Channels == 2 && inst.allSamplesSupportDualChannel() == false) { float sample = inst.getSampleAtTime(note, 0, synth.SampleRate, ref time); sample = sample * (velocity / 127.0f) * synth.VolPositions[channel]; workingBuffer[0, i] += (sample * fadeMultiplier * leftpan * gainControl); workingBuffer[1, i] += (sample * fadeMultiplier * rightpan * gainControl); } //both support stereo else { } time += 1.0 / variableSampleRate; //bailout of the loop if there is no reason to continue. if (inUse == false) return; } } }
public void StopImmediately() { state = VoiceState.None; inUse = false; }
public void Stop() { if (_synth.FadeOutDuration == 0) { IsAlive = false; } else { _fadeCounter = (int)((1.0f - _fadeMultiplier) * _synth.FadeOutDuration); _state = VoiceState.Release; } }
public void Start(float frequency) { _frequency = frequency; _time = 0.0f; _fadeMultiplier = 0.0f; _fadeCounter = 0; if (_synth.FadeInDuration == 0) { _state = VoiceState.Sustain; } else { _state = VoiceState.Attack; } IsAlive = true; }