/// <summary> /// Plays the given file to the specified channel. /// </summary> /// <param name="eventSocket">The EventSocket instance.</param> /// <param name="uuid">The Channel UUID.</param> /// <param name="file">The Path to the file to be played. Note: use forward slashes for path separators.</param> /// <param name="options">Options to customize playback.</param> /// <returns>A PlayResult.</returns> /// <exception cref="FileNotFoundException">Throws FileNotFoundException if FreeSwitch is unable to play the file.</exception>//todo: should it? public static async Task <PlayResult> Play(this EventSocket eventSocket, string uuid, string file, PlayOptions options = null) { // todo: implement options for playback eg a-leg, b-leg, both, using uuid_displace if (options == null) { options = new PlayOptions(); } try { // todo: what if applicationresult is null (hang up occurs before the application completes) var result = new PlayResult( await eventSocket.ExecuteApplication(uuid, "playback", file, loops: options.Loops) .ConfigureAwait(false)); if (!result.Success) { LogFailedApplicationResult(eventSocket, result); } return(result); } catch (TaskCanceledException ex) { return(new PlayResult(null)); } }
void Start() { character = GetComponent <Rigidbody>(); characterCollider = GetComponent <Collider>(); characterNormalScale = transform.localScale; playMode = PlayOptions.Explore; }
public Options() { Mirror = new MirrorOptions(); Play = new PlayOptions(); Test = new TestOptions(); Server = new ServerOptions(); }
public async Task Play(PlayOptions options) { CurrentPlaylistIndex = 0; CurrentPlayOptions = options; _playlist = options.Items.ToList(); _currentPlaybackDispatcher = _presentation.Window.Dispatcher; try { _currentPlaybackDispatcher.Invoke(() => { _hiddenWindow.WindowsFormsHost.Child = _mediaPlayer = new DirectShowPlayer(_logger, _hiddenWindow, this) { BackColor = Color.Black, BorderStyle = BorderStyle.None }; //HideCursor(); }); await PlayTrack(0, options.StartPositionTicks); } catch (Exception ex) { _logger.ErrorException("Error beginning playback", ex); DisposePlayer(); throw; } }
/// <summary> /// Plays the specified player. /// </summary> /// <param name="player">The player.</param> /// <param name="options">The options.</param> /// <param name="configuration">The configuration.</param> /// <returns>Task.</returns> private async Task Play(IMediaPlayer player, PlayOptions options, PlayerConfiguration configuration) { if (options.Items[0].IsPlaceHolder ?? false) { // play a phyical disc in the cdrom drive // Will be re-entrant call, so has to be made befpre the interlocked.CompareExchange below await PlayExternalDisc(true); return; } if (Interlocked.CompareExchange(ref _isStarting, 1, 0) == 0) // prevent race conditions, thread safe check we are not already starting to play an item { try { if (options.Shuffle) { options.Items = options.Items.OrderBy(i => Guid.NewGuid()).ToList(); } var firstItem = options.Items[0]; if (options.StartPositionTicks == 0 && player.SupportsMultiFilePlayback && firstItem.IsVideo && firstItem.LocationType == LocationType.FileSystem && options.GoFullScreen) { try { var intros = await _apiClient.GetIntrosAsync(firstItem.Id, _apiClient.CurrentUserId); options.Items.InsertRange(0, intros.Items); } catch (Exception ex) { _logger.ErrorException("Error retrieving intros", ex); } } options.Configuration = configuration; await player.Play(options); if (player is IInternalMediaPlayer && player is IVideoPlayer && firstItem.IsVideo) { await _presentationManager.Window.Dispatcher.InvokeAsync(() => _presentationManager.WindowOverlay.SetResourceReference(FrameworkElement.StyleProperty, "WindowBackgroundContentDuringPlayback")); if (options.GoFullScreen) { await _nav.NavigateToInternalPlayerPage(); } } OnPlaybackStarted(player, options); } finally { Interlocked.Exchange(ref _isStarting, 0); } } }
/// <summary> /// Gets the process start info. /// </summary> /// <param name="items">The items.</param> /// <param name="options">The options.</param> /// <param name="playerConfiguration">The player configuration.</param> /// <returns>ProcessStartInfo.</returns> protected virtual ProcessStartInfo GetProcessStartInfo(List<BaseItemDto> items, PlayOptions options, PlayerConfiguration playerConfiguration) { return new ProcessStartInfo { FileName = playerConfiguration.Command, Arguments = GetCommandArguments(items, options, playerConfiguration) }; }
static int RunPlay(PlayOptions options) { var engine = new DesktopEngine(); engine.Server.Run(engine); return(0); }
/// <summary> /// Starts playing sound /// </summary> /// <param name="soundEffect"></param> /// <param name="options"></param> /// <param name="volume"></param> /// <param name="pitch"></param> public void PlaySound(SoundEffect soundEffect, PlayOptions options = PlayOptions.None) { soundInstance = soundEffect.CreateInstance(); soundInstance.IsLooped = options.HasFlag(PlayOptions.Looped); soundInstance.Play(); }
/// <summary> /// Starts playing sound /// </summary> /// <param name="soundEffect"></param> /// <param name="options"></param> /// <param name="volume"></param> /// <param name="pitch"></param> public void PlaySound ( SoundEffect soundEffect, PlayOptions options = PlayOptions.None ) { soundInstance = soundEffect.CreateInstance(); soundInstance.IsLooped = options.HasFlag(PlayOptions.Looped); soundInstance.Play(); }
/// <summary> /// Play media full screen /// Some movies (DIVX) take a long time to load so this is required /// </summary> public void PlayMediaFullScreen(PlayOptions playOption) { UserPressedStop = false; LoadingNextFile = true; _mediaPreviewModel.CancelPreviews(); PlayOptions = playOption; Thread playthread = new Thread(new ThreadStart(delegate { bool crashing = true; while (crashing) { try { this.MediaPlayer.URL = PageModel.GetInstance.SelectedMenuItemModel.FilePath; this.MediaPlayer.settings.volume = 100; this.MediaPlayer.Ctlcontrols.currentPosition = 0; this.MediaPlayer.Ctlcontrols.play(); crashing = false; } catch { Thread.Sleep(20); } } SetToFullScreen(); // Playing full screen, give focus back to form1. Application.Current.Dispatcher.Invoke(() => { Application.Current.MainWindow.Focus(); }); // Fix bug where pressing play too quick goes back to non-full screen. // Sleep for a bit. Thread.Sleep(1000); SetToFullScreen(); // Playing full screen, give focus back to form1. Application.Current.Dispatcher.Invoke(() => { Application.Current.MainWindow.Focus(); }); LoadingNextFile = false; Task.Run(() => { KeepFullScreen(); }); })); playthread.Name = "playThread"; playthread.IsBackground = true; playthread.Start(); }
private void PlayInternal(PlayOptions options) { EnsureMediaPlayerCreated(); CurrentPlaylistIndex = 0; CurrentPlayOptions = options; _playlist = options.Items.ToList(); _isPaused = false; var path = options.Items.First().Path; try { //var media = new PathMedia(@"D:\\Video\\TV\\30 Rock\\Season 1\\30 Rock - 1x02 - The Aftermath.mkv"); var media = path.StartsWith("http", StringComparison.OrdinalIgnoreCase) ? (MediaBase) new LocationMedia(path) : (MediaBase) new PathMedia(path); //media.StateChanged += // delegate(MediaBase s, VlcEventArgs<States> args) // { // if (args.Data == States.Ended) // { // var subItems = media.SubItems; // if (subItems.Count > 0) // { // _vlcControl.Play(subItems[0]); // } // } // }; //media.MediaSubItemAdded += // delegate(MediaBase s, VlcEventArgs<MediaBase> args) // { // _vlcControl.Media = args.Data; // _vlcControl.Play(); // }; _vlcControl = new VlcControl(); _vlcControl.Media = media; _vlcControl.PlaybackMode = PlaybackModes.Loop; _vlcControl.Stopped += _vlcControl_Stopped; _vlcControl.Paused += _vlcControl_Paused; _vlcControl.Playing += _vlcControl_Playing; _vlcControl.Play(); _vlcControl.SetHandle(_hiddenWindow.Form.Handle); _userInput.GlobalKeyDown += _userInput_KeyDown; } catch (Exception ex) { _logger.ErrorException("Error beginning playback", ex); DisposePlayer(); } }
/// <summary> /// Plays the internal. /// </summary> /// <param name="items">The items.</param> /// <param name="options">The options.</param> /// <param name="playerConfiguration">The player configuration.</param> protected override void PlayInternal(List<BaseItemDto> items, PlayOptions options, PlayerConfiguration playerConfiguration) { App.Instance.ApplicationWindow.Dispatcher.Invoke(() => { App.Instance.ApplicationWindow.BackdropContainer.Visibility = Visibility.Collapsed; App.Instance.ApplicationWindow.WindowBackgroundContent.SetResourceReference(FrameworkElement.StyleProperty, "WindowBackgroundContentDuringPlayback"); }); App.Instance.NavigateToInternalPlayerPage(); }
/// <summary> /// Called when [playback started]. /// </summary> /// <param name="player">The player.</param> /// <param name="options">The options.</param> private async void OnPlaybackStarted(IMediaPlayer player, PlayOptions options) { EventHelper.QueueEventIfNotNull(PlaybackStarted, this, new PlaybackStartEventArgs { Options = options, Player = player }, _logger); await new PlaybackProgressReporter(_apiClient, player, _logger, this).Start().ConfigureAwait(false); }
public void Play(MovieCallback callback) { this.options = new PlayOptions(); this.options.callback = callback; string methodName = string.Empty; methodName = "PlayPC"; if (methodName != string.Empty) { base.StartCoroutine(methodName, this.options); } }
/// <summary> /// Enables the madvr. /// </summary> /// <param name="options">The options.</param> /// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns> private bool EnableReclock(PlayOptions options) { var video = options.Items.First(); if (!video.IsVideo) { return(false); } if (!_config.Configuration.InternalPlayerConfiguration.EnableReclock) { return(false); } return(true); }
public void PlaySound(AudioClip audioClip, PlayOptions options = null, Action onStopCallback = null) { gameObject.SetActive(true); _audioSource.clip = audioClip; // instantiate the delay counter if (null != options) { _loopCount = options.loopCount; _delayTimer = new Timer(options.startDelay); } else { PlaySound(); } // set the callback on stop, if any _onStopCallback = onStopCallback; }
/// <summary> /// Plays the specified options. /// </summary> /// <param name="options">The options.</param> /// <returns>Task.</returns> public async Task Play(PlayOptions options) { _currentIsoMount = options.Items.Count == 1 && options.Configuration.IsoMethod == IsoConfiguration.Mount ? await GetIsoMount(options.Items[0], CancellationToken.None) : null; CurrentPlaylistIndex = 0; CurrentPlayOptions = options; _playlist = options.Items.ToList(); var process = new Process { EnableRaisingEvents = true, StartInfo = GetProcessStartInfo(options.Items, options, _currentIsoMount) }; Logger.Info("{0} {1}", process.StartInfo.FileName, process.StartInfo.Arguments); try { process.Start(); } catch (Exception ex) { Logger.ErrorException("Error starting player", ex); _playlist.Clear(); throw; } if (options.Configuration.CloseOnStopButton && !CanCloseAutomaticallyOnStopButton) { _userInput.GlobalKeyDown += KeyboardListener_KeyDown; } process.Exited += CurrentProcess_Exited; _currentProcess = process; OnPlayerLaunched(); }
/// <summary> /// Plays the specified options. /// </summary> /// <param name="options">The options.</param> /// <returns>Task.</returns> public Task Play(PlayOptions options) { return(Task.Run(() => { CurrentPlaylistIndex = 0; CurrentPlayOptions = options; _playlist = options.Items.ToList(); var process = new Process { EnableRaisingEvents = true, StartInfo = GetProcessStartInfo(options.Items, options) }; Logger.Info("{0} {1}", process.StartInfo.FileName, process.StartInfo.Arguments); try { process.Start(); } catch (Exception ex) { Logger.ErrorException("Error starting player", ex); _playlist.Clear(); throw; } if (options.Configuration.CloseOnStopButton && !CanCloseAutomaticallyOnStopButton) { _userInput.KeyDown += KeyboardListener_KeyDown; } process.Exited += CurrentProcess_Exited; _currentProcess = process; OnPlayerLaunched(); })); }
public async Task Play(PlayOptions options) { CurrentPlaylistIndex = 0; CurrentPlayOptions = options; _playlist = options.Items.ToList(); try { await PlayTrack(0, options.StartPositionTicks); } catch (Exception ex) { _logger.ErrorException("Error beginning playback", ex); DisposePlayer(); throw; } }
public void PlayClip( AudioClip clip, float volume = 1, PlayOptions playOptions = PlayOptions.PlayOnce) { AudioSource.clip = clip; AudioSource.volume = volume; AudioSource.time = 0; AudioSource.spatialBlend = 1; AudioSource.Play(); if (playOptions == PlayOptions.Loop) { AudioSource.loop = true; StartCoroutine(SlowUpdate()); } else { StartCoroutine(DestroyWithDelay(clip.length)); } }
/// <summary> /// Called when [playback started]. /// </summary> /// <param name="player">The player.</param> /// <param name="options">The options.</param> private async void OnPlaybackStarted(IMediaPlayer player, PlayOptions options) { EventHelper.QueueEventIfNotNull(PlaybackStarted, this, new PlaybackStartEventArgs { Options = options, Player = player }, _logger); lock (_reporterLock) { if (_reporter != null) { _reporter.Dispose(); _reporter = null; } } _reporter = new PlaybackProgressReporter(_apiClient, player, _logger, this); await _reporter.Start().ConfigureAwait(false); }
private void ChoosePlayMode() { PlayOptions currentPlayMode = playMode; Debug.Log("Current play mode = " + currentPlayMode); if (Input.GetButtonDown("TogglePlayModeRight")) { switch (currentPlayMode) { case PlayOptions.Explore: playMode = PlayOptions.Combat; break; case PlayOptions.Sneak: playMode = PlayOptions.Explore; break; case PlayOptions.Combat: playMode = PlayOptions.Sneak; break; } } if (Input.GetButtonDown("TogglePlayModeLeft")) { switch (currentPlayMode) { case PlayOptions.Explore: playMode = PlayOptions.Sneak; break; case PlayOptions.Sneak: playMode = PlayOptions.Combat; break; case PlayOptions.Combat: playMode = PlayOptions.Explore; break; } } }
/// <summary> /// Enables the madvr. /// </summary> /// <param name="options">The options.</param> /// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns> private bool EnableMadvr(PlayOptions options) { var video = options.Items.First(); if (!video.IsVideo) { return(false); } if (!_config.Configuration.InternalPlayerConfiguration.VideoConfig.EnableMadvr) { return(false); } if (!options.GoFullScreen) { return(false); } return(true); }
public AudioHandle Play(string clipId, PlayOptions options) { AudioClip clip = GetClip(clipId); if (clip != null) { AudioHandle handle = GetSource(); AudioSourceInfo sourceInfo = GetSourceInfo(handle); if (sourceInfo != null) { AudioSource source = sourceInfo.Source; source.clip = clip; source.loop = options.Loop; source.transform.localPosition = options.Position; sourceInfo.ClipId = clipId; sourceInfo.TargetVolume = options.Volume; if (options.FadeInTime > 0.0f && !_isMuted) { sourceInfo.VolumeFluctuationSpeed = sourceInfo.TargetVolume / options.FadeInTime; source.volume = 0.0f; } else { SetSourceVolume(sourceInfo, sourceInfo.TargetVolume); } source.Play(); handle._handle_audio_source = source; } return(handle); } return(new AudioHandle()); }
/// <summary> /// Plays the specified player. /// </summary> /// <param name="player">The player.</param> /// <param name="options">The options.</param> /// <param name="configuration">The configuration.</param> /// <returns>Task.</returns> private async Task Play(IMediaPlayer player, PlayOptions options, PlayerConfiguration configuration) { if (options.Shuffle) { options.Items = options.Items.OrderBy(i => Guid.NewGuid()).ToList(); } var firstItem = options.Items[0]; if (options.StartPositionTicks == 0 && player.SupportsMultiFilePlayback && firstItem.IsVideo && firstItem.LocationType == LocationType.FileSystem && options.GoFullScreen) { try { var intros = await _apiClient.GetIntrosAsync(firstItem.Id, _apiClient.CurrentUserId); options.Items.InsertRange(0, intros.Items); } catch (Exception ex) { _logger.ErrorException("Error retrieving intros", ex); } } options.Configuration = configuration; await player.Play(options); if (player is IInternalMediaPlayer && player is IVideoPlayer && firstItem.IsVideo) { await _presentationManager.Window.Dispatcher.InvokeAsync(() => _presentationManager.WindowOverlay.SetResourceReference(FrameworkElement.StyleProperty, "WindowBackgroundContentDuringPlayback")); if (options.GoFullScreen) { await _nav.NavigateToInternalPlayerPage(); } } OnPlaybackStarted(player, options); }
/// <summary> /// Plays the specified options. /// </summary> /// <param name="options">The options.</param> /// <returns>Task.</returns> /// <exception cref="System.ArgumentNullException"> /// options /// or /// options /// </exception> /// <exception cref="System.InvalidOperationException">There are no available players.</exception> public async Task Play(PlayOptions options) { if (options == null) { throw new ArgumentNullException("options"); } if (options.Items == null || options.Items.Count(i => i.LocationType != LocationType.Offline) == 0) { throw new ArgumentException("At least one item must be supplied."); } PlayerConfiguration config; var player = GetPlayer(options.Items, out config); if (player == null) { throw new InvalidOperationException("There are no available players."); } StopAllPlayback(); await Play(player, options, config); }
private void PlayAllEx(PlayOptions options) { if (SelectedSyl == -1) return; if (PlayStatus == ReproductionState.Play) { mW.audio.Stop(); PlayStatus = ReproductionState.Stop; return; } int ms_iniciales = 0, ms_finales = 0; for (int i = 0; i < SelectedSyl; i++) { K tmp = (K)OurK[i]; ms_iniciales += tmp.Milliseconds; } K sel = (K)OurK[SelectedSyl]; ms_finales = ms_iniciales + sel.Milliseconds; double begin_off = (double)ms_iniciales / 100; double end_off = (double)ms_finales / 100; Mode = PlayMode.Other; PlayStatus = ReproductionState.Play; double begin = Tiempo.TimeToSecondDouble(infoTiempoInicial.Text) + begin_off; double off = Tiempo.TimeToSecondDouble(infoTiempoInicial.Text) + end_off; //Tiempo.TimeToSecondDouble(infoTiempoFinal.Text); switch (options) { case PlayOptions.BeforeStart: off = begin; begin = Math.Max(0, off - .5); break; case PlayOptions.BeforeEnd: begin = Math.Max(0, off - .5); break; case PlayOptions.AfterStart: off = begin + .5; break; case PlayOptions.AfterEnd: begin = off; off = begin + .5; break; } PosRel = begin - Tiempo.TimeToSecondDouble(infoTiempoInicial.Text); LastEnd = off-Tiempo.TimeToSecondDouble(infoTiempoInicial.Text); unsafe { byte* buf = (byte*)AudioFull.ToPointer(); byte* buf_final = buf; int principio = (int)(begin * avsaudio.AudioSampleRate * avsaudio.BytesPerSample); if (principio % 2 == 1) principio++; buf += principio; buf_final += (int)(off * avsaudio.AudioSampleRate * avsaudio.BytesPerSample); int size = (int)(buf_final - buf); if (size % 2 == 1) size++; if (size > 0) { byte[] rangeplay = new byte[size]; IntPtr buff = new IntPtr(buf); Marshal.Copy(buff, rangeplay, 0, size); mW.audio = avs2ds.PreparaAudio(rangeplay); AudioActualPosition_Refresh.Enabled = true; mW.audio.Play(0, BufferPlayFlags.Default); } } }
/// <summary> /// Plays the internal. /// </summary> /// <param name="items">The items.</param> /// <param name="options">The options.</param> /// <param name="playerConfiguration">The player configuration.</param> protected override void PlayInternal(List<BaseItemDto> items, PlayOptions options, PlayerConfiguration playerConfiguration) { EnsureMediaPlayerCreated(); _currentPlaylistIndex = 0; MediaList = MediaPlayerFactory.CreateMediaList<IMediaList>(items.Select(GetPlayablePath)); VideoPlayer = MediaPlayerFactory.CreateMediaListPlayer<IMediaListPlayer>(MediaList); VideoPlayer.InnerPlayer.WindowHandle = WindowsFormsPanel.Handle; VideoPlayer.InnerPlayer.Events.PlayerStopped += Events_PlayerStopped; VideoPlayer.Play(); var position = options.StartPositionTicks; if (position > 0) { VideoPlayer.Time = Convert.ToInt64(TimeSpan.FromTicks(position).TotalMilliseconds); } VideoPlayer.MediaListPlayerEvents.MediaListPlayerNextItemSet += MediaListPlayerEvents_MediaListPlayerNextItemSet; base.PlayInternal(items, options, playerConfiguration); }
/// <summary> /// Plays the specified options. /// </summary> /// <param name="options">The options.</param> /// <returns>Task.</returns> public async Task Play(PlayOptions options) { InvokeOnPlayerThread(() => PlayInternal(options)); }
private IEnumerator PlayPC(PlayOptions options) { return(new < PlayPC > c__Iterator273 { options = options, <$> options = options, <> f__this = this });
private void AudioPlayEx(PlayOptions options) { if (AudioState == ReproductionState.Play) { AudioActualPosition_Refresh_500.Enabled = false; AudioState = ReproductionState.Stop; audio.Stop(); audio.Dispose(); audio = null; return; } double inicio = Tiempo.TimeToSecondDouble(textInicio.Text); double fin = 0; if (AudioGrid_Inicio == -1) return; if (AudioGrid_Fin != -1) fin = Tiempo.TimeToSecondDouble(textFin.Text); else if (options == PlayOptions.BeforeEnd || options == PlayOptions.AfterEnd) return; switch (options) { case PlayOptions.BeforeStart: if (inicio < .5) { inicio = 0; fin = .5; } else { inicio -= .5; fin = inicio + .5; } break; case PlayOptions.AfterStart: fin = inicio + .5; break; case PlayOptions.BeforeEnd: fin = Tiempo.TimeToSecondDouble(textFin.Text); inicio = fin - .5; if (inicio < 0) inicio = 0; break; case PlayOptions.AfterEnd: inicio = Tiempo.TimeToSecondDouble(textFin.Text); fin = inicio + .5; break; case PlayOptions.Normal: inicio = Tiempo.TimeToSecondDouble(textInicio.Text); fin = Tiempo.TimeToSecondDouble(textFin.Text); break; } audioGrid_Inicio_500 = inicio; audioGrid_Fin_500 = fin; InicioPlay = inicio; unsafe { byte* buf = (byte*)AudioFull.ToPointer(); byte* buf_final = buf; buf += (int)(inicio * avsaudio.AudioSampleRate * avsaudio.BytesPerSample); IntPtr tmp = new IntPtr(buf); int tesuto = tmp.ToInt32(); if ((tesuto % 2) == 1) buf++; //if (tesuto >= mainW.idx0rz) return; int max_or_mult = (int)Math.Min((int)(fin * avsaudio.AudioSampleRate * avsaudio.BytesPerSample), mainW.idx0rz); buf_final += max_or_mult; int size = (int)(buf_final - buf); if (size < 0) return; AudioTemp = new byte[size]; IntPtr buff = new IntPtr(buf); Marshal.Copy(buff, AudioTemp, 0, size); audio = avs2ds.PreparaAudio(AudioTemp); audio.Play(0, BufferPlayFlags.Default); AudioState = ReproductionState.Play; AudioActualPosition_Refresh_500.Enabled = true; } }
/// <summary> /// Handles Windows media player key strokes /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="T:System.Windows.Input.KeyEventArgs" /> instance containing the event data.</param> public void HandleKeyDown(object sender, KeyEventArgs e) { if (BlockKeyPresses) { //e.IsInputKey = false; return; } BlockKeyPresses = true; // stop if (e.Key == Key.MediaStop || e.Key == Key.V) { if (!LoadingNextFile) { UserPressedStop = true; PlayOptions = PlayOptions.Play; //IsFullScreen = false; //IsPlaying = false; MediaPlayer.Ctlcontrols.stop(); MediaPlayer.fullScreen = false; Application.Current.MainWindow.Focus(); PreviewMedia(false); } } // Skip forwards if (e.Key == Key.MediaNextTrack || e.Key == Key.N) { SkipForward(40); } // skip backwards if (e.Key == Key.P || e.Key == (Key)177 || e.Key == Key.MediaPreviousTrack) { SkipBackwards(40); } // Skip forwards (long) if (e.Key == Key.Right) { SkipForward(700); } // skip backwards (long) if (e.Key == Key.Left) { SkipBackwards(700); } // play, pause. note: this is required both here and in playPanel if (e.Key == Key.MediaPlayPause || e.Key == (Key)179 || e.Key == Key.Play) { if (MediaPlayer.playState == WMPLib.WMPPlayState.wmppsPaused) { MediaPlayer.Ctlcontrols.play(); } else { MediaPlayer.Ctlcontrols.pause(); } } BlockKeyPresses = false; }
/// <summary> /// Plays the internal. /// </summary> /// <param name="items">The items.</param> /// <param name="options">The options.</param> /// <param name="playerConfiguration">The player configuration.</param> protected override void PlayInternal(List<BaseItemDto> items, PlayOptions options, PlayerConfiguration playerConfiguration) { CurrentProcess = new Process { EnableRaisingEvents = true, StartInfo = GetProcessStartInfo(items, options, playerConfiguration) }; Logger.Info("{0} {1}", CurrentProcess.StartInfo.FileName, CurrentProcess.StartInfo.Arguments); CurrentProcess.Start(); OnExternalPlayerLaunched(); if (!CanCloseAutomatically) { KeyboardListener.KeyDown += KeyboardListener_KeyDown; } CurrentProcess.Exited += CurrentProcess_Exited; }
/// <summary> /// Gets the command arguments. /// </summary> /// <param name="items">The items.</param> /// <param name="options">The options.</param> /// <param name="playerConfiguration">The player configuration.</param> /// <returns>System.String.</returns> protected virtual string GetCommandArguments(List<BaseItemDto> items, PlayOptions options, PlayerConfiguration playerConfiguration) { var args = playerConfiguration.Args; if (string.IsNullOrEmpty(args)) { return string.Empty; } return GetCommandArguments(items, args); }
internal static extern int playAudio(int sourceIndex, PlayOptions playOptions);
/// <summary> /// Gets the process start info. /// </summary> /// <param name="items">The items.</param> /// <param name="options">The options.</param> /// <returns>ProcessStartInfo.</returns> protected virtual ProcessStartInfo GetProcessStartInfo(IEnumerable <BaseItemDto> items, PlayOptions options) { return(new ProcessStartInfo { FileName = options.Configuration.Command, Arguments = GetCommandArguments(items, options) }); }
/// <summary> /// Gets the command arguments. /// </summary> /// <param name="items">The items.</param> /// <param name="options">The options.</param> /// <returns>System.String.</returns> protected virtual string GetCommandArguments(IEnumerable <BaseItemDto> items, PlayOptions options) { return(GetCommandArguments(items, options.Configuration.Args)); }
public void Play(string path, PlayOptions po = PlayOptions.localPlayer, string PlayerPath = "", string WorkingDirectory = "") { P = new Process(); bool flag = po == PlayOptions.localPlayer; if (flag) { try { P.StartInfo.FileName = path; bool flag2 = WorkingDirectory != ""; if (flag2) { P.StartInfo.WorkingDirectory = WorkingDirectory; } P.Start(); } catch { throw new Exception("文件无法读取或无打开方式"); } } else { bool flag3 = po == PlayOptions.ffplay; if (flag3) { bool flag4 = !File.Exists(ffplayPath); if (flag4) { throw new FileNotFoundException("ffplay路径不存在或未设置"); } P.StartInfo.FileName = ffplayPath; string text = ""; bool flag5 = path.Substring(0, 1) != "\""; if (flag5) { text = "\"" + path; } bool flag6 = path.Substring(path.Length - 1, 1) != "\""; if (flag6) { text += "\""; } P.StartInfo.Arguments = "-i " + text; bool flag7 = WorkingDirectory != ""; if (flag7) { P.StartInfo.WorkingDirectory = WorkingDirectory; } P.Start(); } else { bool flag8 = po == PlayOptions.Custom; if (flag8) { bool flag9 = !File.Exists(PlayerPath); if (flag9) { throw new FileNotFoundException("播放器路径无效"); } P.StartInfo.FileName = PlayerPath; P.StartInfo.Arguments = (path ?? ""); bool flag10 = WorkingDirectory != ""; if (flag10) { P.StartInfo.WorkingDirectory = WorkingDirectory; } P.Start(); } } } }
public AudioHandle Play(string clipId, PlayOptions options) { AudioClip clip = GetClip (clipId); if (clip != null) { AudioHandle handle = GetSource (); AudioSourceInfo sourceInfo = GetSourceInfo (handle); if (sourceInfo != null) { AudioSource source = sourceInfo.Source; source.clip = clip; source.loop = options.Loop; source.transform.localPosition = options.Position; sourceInfo.ClipId = clipId; sourceInfo.TargetVolume = options.Volume; if (options.FadeInTime > 0.0f && !_isMuted) { sourceInfo.VolumeFluctuationSpeed = sourceInfo.TargetVolume / options.FadeInTime; source.volume = 0.0f; } else { SetSourceVolume (sourceInfo, sourceInfo.TargetVolume); } source.Play (); handle._handle_audio_source = source; } return handle; } return new AudioHandle (); }