/// <summary>
/// Plays a media file
/// </summary>
/// <param name="fileName"></param>
public void Play(string fileName)
{
if (String.IsNullOrWhiteSpace(fileName))
{
throw new ArgumentNullException("Please specifiy a filename");
}
// Get the format
var fileFormat = fileName.Substring(fileName.LastIndexOf('.') + 1).ToLower();
// Check it
if (String.IsNullOrWhiteSpace(fileFormat))
{
throw new ArgumentNullException("Please specifiy a valid file to play");
}
// This object can play 'wav' files, however, any other format requires another player
switch (fileFormat)
{
case "wav":
Console.WriteLine();
break;
default:
_playerAdapter.Play(fileName); // Use the adapter
break;
}
}
void OnPlayButtonClickHandler()
{
if (rawImage.enabled)
{
if (vPlayer.isPlaying)
{
vPlayer.Pause();
playButton.GetComponent <Image>().sprite = playImage;
}
else
{
vPlayer.Play();
playButton.GetComponent <Image>().sprite = pauseImage;
}
}
}
/// <summary>
/// plays the currently selected song, if no song is selected it plays the first one inside the playlist,
/// if no song is inside the playlist, the random function is used to get a song from the library
/// </summary>
private void Play()
{
if (_mediaPlayer.IsPlaying())
{
if (PlaybackPaused)
{
Pause();
return;
}
_mediaPlayer.Stop();
}
if (CurrentSong == null && PlaylistService != null)
{
CurrentSong = PlaylistService.GetNextPlaylistItem(SequentialPlayback == false, null, true);
}
if (CurrentSong == null)
{
return;
}
_mediaPlayer.Play(CurrentSong);
PlaybackPaused = false;
PreviousSongCommand.RaiseCanExecuteChanged();
PauseCommand.RaiseCanExecuteChanged();
((IPlayerView)View).SetArtistAndTitle(CurrentSong.Song.Artist, CurrentSong.Song.Title);
int durationOfSongInMs = _mediaPlayer.GetDurationOfPlayedSong();
((IPlayerView)View).SetSongDuration(durationOfSongInMs);
}
private bool ExecuteEmptyResponse(IMediaPlayer mediaPlayer, BaseRequest message, Stream outStream)
{
switch (message)
{
case SetVolume m: mediaPlayer.SetVolume(m.Volume); break;
case SetMute m: mediaPlayer.SetMute(m.IsMuted); break;
case SetPlaybackSpeed m: mediaPlayer.SetPlaybackSpeed(m.Speed); break;
case SetAudioTrack m: mediaPlayer.SetAudioTrack(m.TrackId); break;
case SetVideoTrack m: mediaPlayer.SetVideoTrack(m.TrackId); break;
case Play _: mediaPlayer.Play(); break;
case Pause _: mediaPlayer.Pause(); break;
case LocalFileStreamDisconnect _: mediaPlayer.DisconnectLocalFileStream(); break;
case StepForward _: mediaPlayer.StepForward(); break;
case StepBack _: mediaPlayer.StepBack(); break;
case Seek m: mediaPlayer.Seek(m.Position); break;
default: return(false);
}
responseService.ReturnEmptyResponse(outStream, message);
return(true);
}
/// <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);
}
}
}
public void Handle(string command)
{
switch (command)
{
case "/play":
player.Play();
break;
case "/pause":
player.Pause();
break;
case "/next":
player.Play();
break;
}
}
private void Play(Track source)
{
var fileToPlay = new Uri(source.Location);
if (_mediaPlayer.Source == null || !_mediaPlayer.Source.Equals(fileToPlay))
{
_mediaPlayer.Open(fileToPlay);
//Playing.Text = source.Name;
}
_mediaPlayer.Play();
}
public void Process(string[] args)
{
/* code that parses the arguments */
if (args.Length < 2)
{
throw new Exception("Not enough parameters provided");
}
string operation = args[0];
string file = args[1];
string extension = Path.GetExtension(file);
extension = extension.Substring(1, extension.Length - 1);
bool isSupportedFormat = Enum.TryParse(extension, ignoreCase: true, out MediaFormat format);
IMediaPlugIn mediaPlugIn = null;
int effectStartIndex = 2;
if (!isSupportedFormat)
{
if (args.Length < 4)
{
throw new Exception("Custom media type requires plugin asembly path and it's type");
}
format = MediaFormat.Custom;
mediaPlugIn = GetMediaPlugIn(args[2], args[3]);
effectStartIndex = 4;
}
string[] effects = args.Skip(effectStartIndex).ToArray(); //new string[args.Length - effectStartIndex+1];
//args.CopyTo(effects, effectStartIndex);
IMediaEffect[] mediaEffects = GetMediaEffects(effects);
MediaPlayerFactory factory = new MediaPlayerFactory();
IMediaPlayer player = factory.GetMediaPlayer(format, mediaPlugIn);
Enum.TryParse(operation, out MediaOperation mediaOperation);
switch (mediaOperation)
{
case MediaOperation.Play:
player.Play(file, mediaEffects);
break;
case MediaOperation.Decompress:
player.Decompress(file);
break;
default: throw new InvalidOperationException("Operation not supported");
}
}
public void Process(string id, string jukeCoreMediaPath)
{
_console.WriteLine($"Processing ID {id}");
var medias = _mediaFactory.Create(id, jukeCoreMediaPath);
_playlist.Set(medias);
var firstMedia = _playlist.Next();
_mediaPlayer.Play(firstMedia);
}
public static Task PlayPause(this IMediaPlayer mediaPlayer)
{
var status = mediaPlayer.State;
if (status == MediaPlayerState.Paused || status == MediaPlayerState.Stopped)
{
return(mediaPlayer.Play());
}
else
{
return(mediaPlayer.Pause());
}
}
private void PlayRecordedVoice()
{
AllowRecording = false;
AllowStopping = true;
AllowPlaying = false;
AllowDeleting = false;
mediaState = MediaState.PLAY;
mediaPlayer.Play(mediaFilePath, (s, e) =>
{
AllowStopping = false;
AllowPlaying = true;
AllowDeleting = true;
});
}
private void OnPressed(object sender, EventArgs e)
{
try
{
_console.WriteLine("Next button was pressed!");
var media = _playlist.Next();
ThreadPool.QueueUserWorkItem(_ => _mediaPlayer.Play(media));
}
catch (Exception exception)
{
_console.WriteLine(exception.Message);
}
}
private void PlayRecordedAudio()
{
if (string.IsNullOrEmpty(voiceNotePath))
{
return;
}
AllowPlaying = false;
AllowStopping = true;
mediaPlayer.Play(voiceNotePath, (s, e) =>
{
AllowStopping = false;
AllowPlaying = true;
});
}
public static void TogglePlayPause(this IMediaPlayer player)
{
if (player == null)
{
throw new ArgumentNullException(nameof(player));
}
if (player.IsPlaying)
{
player.Pause();
}
else
{
player.Play();
}
}
public void Play(string audioType, string fileName)
{
if (audioType == "Mp3")
{
Console.WriteLine("playing mp3 file name:" + fileName);
}
else if (audioType == "Vlc" || audioType == "Mp4")
{
_mediaPlayer = new MediaAdapter(audioType);
_mediaPlayer.Play(audioType, fileName);
}
else
{
Console.WriteLine("Invalid media" + audioType + "format not supported");
}
}
public void Play(string type, string name)
{
if (string.Compare(type, "avi", true) == 0)
{
Console.WriteLine("Playing avi video named: {0}", name);
}
else if (string.Compare(type, "mp4", true) == 0 || string.Compare(type, "vlc", true) == 0)
{
player = new MediaAdapter(type);
player.Play(type, name);
}
else
{
Console.WriteLine("Invalid media. {0} format not supported.", type);
}
}
public void Play(AudioType audioType, string fileName)
{
switch (audioType)
{
case AudioType.MP3:
Console.WriteLine($"Playing mp3 file. Name:{fileName}");
break;
case AudioType.VLC:
case AudioType.MP4:
mediaAdapter = new MediaAdapter(audioType);
mediaAdapter.Play(audioType, fileName);
break;
default:
Console.WriteLine($"Invalid media.{audioType} format not supported");
break;
}
}
public void TogglePlayState()
{
if (Data.State is EpisodeStatePendingDownload)
{
Data.Download();
}
else if (Data.State is EpisodeStateDownloaded)
{
if (Data.Played)
{
Data.Position = TimeSpan.FromSeconds(0);
Data.Played = false;
}
Task t = m_MediaPlayer.Play(Data);
}
else if (Data.State is EpisodeStatePlaying)
{
m_MediaPlayer.Pause(Data);
}
}
/// <summary>
/// Called when a button is fired in the view
/// </summary>
/// <param name="obj">The object.</param>
private void OnVideoControl(string obj)
{
switch (obj)
{
case "pause":
_mediaElement.Pause();
break;
case "play":
_mediaElement.Play();
break;
case "stop":
_mediaElement.Stop();
break;
default:
break;
}
}
/// <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);
}
public ActionResult Get(string fileName)
{
_mediaPlayer.Play(fileName);
return(Ok());
}
/// <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);
}
// Starts video playback.
public void Play()
{
mediaPlayer.Play();
}
public void PlayMedia(string fileName)
{
_mediaPlayer.Play(fileName);
}
/// <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 disk in the cdrom drive
// Will be re-entrant call, so has to be made befpre the interlocked.CompareExchange below
await PlayExternalDisk(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;
var playTask = player.Play(options);
if (player is IInternalMediaPlayer && player is IVideoPlayer && firstItem.IsVideo)
{
if (options.GoFullScreen)
{
await _nav.Navigate(Go.To.FullScreenPlayback());
}
}
await playTask;
OnPlaybackStarted(player, options);
}
finally
{
Interlocked.Exchange(ref _isStarting, 0);
}
}
}
public async void Play(string directory)
{
await _player.Play(new File(directory));
}
private void BtnPlay_Click(object sender, RoutedEventArgs e)
{
_mediaPlayerWrapper.Play();
}
public void Main()
{
IMediaPlayer player = GetMediaPlayer();
player.Play();
}
/// <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);
}
}
}
public void Play()
{
_player.Play();
}
private static void PlayVideo(string url)
{
_mediaPlayer.Play(url);
}