public SongWindow(SongMeta meta)
{
_song = SongLoader.Load(meta);
InitializeComponent();
Text = $"Score: {meta.Artist} - {meta.Name} [{meta.Instrument}]";
albumArtwork.Image = _song.GetCover();
score1.SetSong(_song);
_player = _song.GetSongPlayer();
for (int x = 0; x < _player.Channels; x++)
{
AddFader(x);
}
seekBar1.Samples = (long)(_player.Length.TotalSeconds * 44100.0 + 0.5);
seekBar1.OnSliderDrop += i => _player.Position = TimeSpan.FromSeconds(i);
_timer = new Timer();
_timer.Interval = 30;
_timer.Tick += TimerTick;
_timer.Start();
waveform1.WaveData = _song.GetWaveform();
waveform1.Sections = _song.Sections;
waveform1.Beats = _song.Beats;
waveform1.Looper.OnLoop += d => _player.Position = TimeSpan.FromSeconds(d);
}
public QueueEventPublisher(
IVoteableQueue<ISongStream> queue,
ISongStreamPlayer streamPlayer,
ISongPlayer songPlayer)
{
_queue = queue;
_streamPlayer = streamPlayer;
_songPlayer = songPlayer;
}
public SongStreamHandler(
IVoteableQueue<ISongStream> queue,
ISongStreamPlayer streamPlayer,
ISongPlayer songPlayer)
{
_queue = queue;
_streamPlayer = streamPlayer;
_songPlayer = songPlayer;
}
public static void HelpMe(HttpListenerResponse response, string tempId, ISongPlayer songPlayer, bool large)
{
if (!large)
{
HelpMeSmall(response, tempId ?? string.Empty, songPlayer);
}
else
{
HelpMeLarge(response, tempId ?? string.Empty, songPlayer);
}
}
public static void HelpMe(HttpListenerResponse response, string tempId, ISongPlayer songPlayer, bool large)
{
if (!large)
{
HelpMeSmall(response, tempId ?? string.Empty, songPlayer);
}
else
{
HelpMeLarge(response, tempId ?? string.Empty, songPlayer);
}
}
static void SongQueueSample(ISongPlayer player, ISongProvider songProvider)
{
var queue = new VoteableQueue<Song>();
queue.ItemAdded += (sender, eventArgs) =>
{
Console.WriteLine("Added song " + eventArgs.Item.Item.Name + " to queue");
if (queue.CurrentQueue.Count() == 1)
{
VoteableQueueItem<Song> head;
if (queue.TryPeek(out head))
{
player.Start(head.Item);
}
}
};
player.CurrentSongChanged += (sender, eventArgs) => Console.WriteLine("Current song is " + eventArgs.NewValue.Name);
player.CurrentSongCompleted += (sender, eventArgs) =>
{
VoteableQueueItem<Song> head;
if (queue.TryDequeue(out head))
{
if (queue.TryPeek(out head))
{
player.Start(head.Item);
}
}
};
string query;
do
{
Console.WriteLine("Enter query >> ");
query = Console.ReadLine();
if (!string.IsNullOrEmpty(query))
{
songProvider
.GetSongs(query, CancellationToken.None)
.ContinueWith(resultTask =>
{
var song = resultTask.Result.FirstOrDefault();
if (song != null)
{
queue.Enqueue(song);
}
});
}
} while (string.IsNullOrEmpty(query));
}
private static void HelpMeLarge(HttpListenerResponse response, string tempId, ISongPlayer songPlayer)
{
// use cached image if possible
if (tempId.Equals(_lastId, StringComparison.OrdinalIgnoreCase) && _lastImage != null)
{
WriteImage(response, _lastImage);
return;
}
// get from player
MemoryStream imageStream = null;
if (!string.IsNullOrEmpty(tempId))
{
try
{
// this is locked in function
imageStream = songPlayer.GetImageStream(tempId, true);
}
catch (Exception)
{
imageStream = null;
}
using (MemoryStream streamFromSongPlayer = imageStream)
{
if (streamFromSongPlayer != null)
{
// set last id
_lastId = tempId;
_lastImage = streamFromSongPlayer.ToArray();
WriteImage(response, _lastImage);
return;
}
}
}
// cache large if not present
if (_emptyImageLarge == null)
{
using (Stream stream = Assembly.GetEntryAssembly().GetManifestResourceStream("SongRequest.Static.empty.png"))
using (MemoryStream memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
_emptyImageLarge = memoryStream.ToArray();
}
}
WriteImage(response, _emptyImageLarge);
}
public AppModule(
IRegionManager regionManager,
IVoteableQueue<ISongStream> queue,
ISongPlayer songPlayer,
ISongStreamPlayer streamPlayer)
{
_regionManager = regionManager;
_queue = queue;
_queue.ItemAdded += QueueOnItemAdded;
_streamPlayer = streamPlayer;
_streamPlayer.NextSong += StreamPlayerNextSongChanged;
_songPlayer = songPlayer;
_songPlayer.CurrentSongCompleted += SongPlayerOnCurrentSongCompleted;
}
public GtGameController(GtFactory pFactory, GtFileLoader pFileLoader, ISongPlayer pSongPlayer, IAudioEffects pAudioEffects)
{
if (pSongPlayer == null)
{
throw new InvalidParameter("pSongPlayer can't be null");
}
if (pFactory == null)
{
throw new InvalidParameter("pFactory can't be null");
}
if (pAudioEffects == null)
{
throw new InvalidParameter("pAudioEffects can't be null");
}
Initialize(pFactory, pFileLoader, pSongPlayer, pAudioEffects);
}
private void Initialize(GtFactory pFactory, GtFileLoader pFileLoader, ISongPlayer pSongPlayer, IAudioEffects pAudioEffects)
{
this.Factory = pFactory;
this.SongPlayer = pSongPlayer;
this.fFileLoader = pFileLoader;
this.AudioEffects = pAudioEffects;
this.CurrentScreen = EnumGameScreen.Undefined;
this.AudioListener = pFactory.Instantiate <IAudioListener>(SAMPLE_FREQUENCE);
//must be after AudioListener instantiation
this.GameRoundController = pFactory.Instantiate <IGtGameRoundController>(pFactory, this);
this.TuneController = pFactory.Instantiate <IGtTuneController>();
this.AudioListener.Start();
}
public static void HelpMe(HttpListenerResponse response, string tempId, ISongPlayer songPlayer, bool large)
{
// if no temp id, return
if (string.IsNullOrEmpty(tempId))
{
response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
lock (_lockObject)
{
if (!large)
{
HelpMeSmall(response, tempId, songPlayer);
}
else
{
HelpMeLarge(response, tempId, songPlayer);
}
}
}
public void SetupSong(int pNumberOfPlayers, ISongPlayer pSongPlayer,
string pArtist, string pAlbum, string pSong, float pPitch, params GtSceneGuitar[] pGtSceneGuitars)
{
this.fNumberOfPlayers = pNumberOfPlayers;
if ((this.fNumberOfPlayers < 1) || (this.fNumberOfPlayers > 2))
{
throw new InvalidGameRoundControlerParameters(string.Format("GtGameController must have one or two players: {0} found.", this.fNumberOfPlayers));
}
if (pGtSceneGuitars == null)
{
throw new InvalidGameRoundControlerParameters("null parameter is not allowed.");
}
if (pGtSceneGuitars.Count() != this.fNumberOfPlayers)
{
throw new InvalidGameRoundControlerParameters(string.Format("There are {0} players and {1} GtSceneGuitar in SetupSong(pGtSceneGuitars).", pGtSceneGuitars.Count(), this.fNumberOfPlayers));
}
if (pSongPlayer == null)
{
throw new InvalidGameRoundControlerParameters("null parameter is not allowed.");
}
this.SongPlayer = pSongPlayer;
this.Artist = pArtist;
this.Album = pAlbum;
this.Song = pSong;
this.Pitch = pPitch;
fSceneGuitars = pGtSceneGuitars;
}
public PlayerController(ISongPlayer songPlayer)
{
_songPlayer = songPlayer;
}
private static void HelpMeSmall(HttpListenerResponse response, string tempId, ISongPlayer songPlayer)
{
if (thumbnailBuffer.ContainsKey(tempId))
{
WriteImage(response, thumbnailBuffer[tempId]);
return;
}
// get from player
MemoryStream imageStream = null;
if (!string.IsNullOrEmpty(tempId))
{
try
{
// this is locked in function
imageStream = songPlayer.GetImageStream(tempId, false);
}
catch (Exception)
{
imageStream = null;
}
using (MemoryStream streamFromSongPlayer = imageStream)
{
if (streamFromSongPlayer != null)
{
if (!thumbnailBuffer.ContainsKey(tempId))
thumbnailBuffer.Add(tempId, streamFromSongPlayer.ToArray());
WriteImage(response, streamFromSongPlayer);
return;
}
}
}
// cache small if not present
if (_emptyImageSmall == null)
{
using (Stream stream = Assembly.GetEntryAssembly().GetManifestResourceStream("SongRequest.Static.empty_small.png"))
using (MemoryStream memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
_emptyImageSmall = memoryStream.ToArray();
}
}
if (!thumbnailBuffer.ContainsKey(tempId))
thumbnailBuffer.Add(tempId, _emptyImageSmall);
WriteImage(response, _emptyImageSmall);
}
public SongsController(
ICommandService <EditSong> editSong,
ICommandService <UploadSong> uploadSong,
ICommandService <DeleteSong> deleteSong,
IQueryService <GetSongForEditById, Song> getSongForEdit,
IQueryService <GetSongForDeleteById, Song> getSongForDelete,
IQueryService <GetSongsCount, int> getSongsCount,
IQueryService <GetSongs, IEnumerable <Song> > getSongs,
IQueryService <GetApprovedSongsByUser, IEnumerable <Song> > getSongsByUser,
ISongPlayer songPlayer)
{
if (editSong is null)
{
throw new ArgumentNullException(nameof(editSong));
}
if (uploadSong is null)
{
throw new ArgumentNullException(nameof(uploadSong));
}
if (deleteSong is null)
{
throw new ArgumentNullException(nameof(deleteSong));
}
if (getSongForEdit is null)
{
throw new ArgumentException(nameof(getSongForEdit));
}
if (getSongForDelete is null)
{
throw new ArgumentException(nameof(getSongForDelete));
}
if (getSongsCount is null)
{
throw new ArgumentException(nameof(getSongsCount));
}
if (getSongs is null)
{
throw new ArgumentException(nameof(getSongs));
}
if (getSongsByUser is null)
{
throw new ArgumentException(nameof(getSongsByUser));
}
if (songPlayer is null)
{
throw new ArgumentException(nameof(songPlayer));
}
this.editSong = editSong;
this.uploadSong = uploadSong;
this.deleteSong = deleteSong;
this.getSongForEdit = getSongForEdit;
this.getSongForDelete = getSongForDelete;
this.getSongsCount = getSongsCount;
this.getSongs = getSongs;
this.getSongsByUser = getSongsByUser;
this.songPlayer = songPlayer;
}
public override void Process(HttpListenerRequest request, HttpListenerResponse response)
{
string[] actionPath = request.RawUrl.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
string action = actionPath[1].ToLower();
ISongPlayer songPlayer = SongPlayerFactory.GetSongPlayer();
string requester = GetRequester(request);
response.AppendHeader("Cache-Control", "no-cache");
switch (action)
{
case "queue":
switch (request.HttpMethod)
{
case "GET":
response.ContentType = "application/json";
WriteUtf8String(response.OutputStream, JsonConvert.SerializeObject(
new
{
Queue = songPlayer.PlayQueue.ToList(),
PlayerStatus = songPlayer.PlayerStatus,
Self = requester
}
));
break;
case "POST":
if (!ClientAllowed(requester))
{
return;
}
using (var reader = new StreamReader(request.InputStream))
{
songPlayer.Enqueue(reader.ReadToEnd(), requester);
}
break;
case "DELETE":
if (!ClientAllowed(requester))
{
return;
}
using (var reader = new StreamReader(request.InputStream))
{
songPlayer.Dequeue(reader.ReadToEnd(), requester);
}
break;
}
break;
case "playlist":
{
if (!ClientAllowed(requester))
{
return;
}
if (request.HttpMethod == "POST")
{
using (var reader = new StreamReader(request.InputStream))
{
string posted = reader.ReadToEnd();
var playlistRequest = JsonConvert.DeserializeAnonymousType(posted, new { Filter = string.Empty, Page = 0, SortBy = "artist", Ascending = true });
Song[] songs = songPlayer.GetPlayList(
playlistRequest.Filter,
playlistRequest.SortBy,
playlistRequest.Ascending
).ToArray();
response.ContentType = "application/json";
WriteUtf8String(response.OutputStream, JsonConvert.SerializeObject(
new
{
TotalPageCount = (songs.Length + (_pageSize - 1)) / _pageSize,
CurrentPage = playlistRequest.Page,
SongsForCurrentPage = songs.Skip((playlistRequest.Page - 1) * _pageSize).Take(_pageSize).ToArray(),
SortBy = playlistRequest.SortBy,
Ascending = playlistRequest.Ascending
}
));
}
}
break;
}
case "next":
if (!ClientAllowed(requester))
{
return;
}
response.ContentType = "application/json";
songPlayer.Next(requester);
break;
case "rescan":
if (!ClientAllowed(requester))
{
return;
}
response.ContentType = "application/json";
songPlayer.Rescan();
ImageHelper.Purge();
break;
case "pause":
if (!ClientAllowed(requester))
{
return;
}
response.ContentType = "application/json";
songPlayer.Pause();
break;
case "volume":
if (!ClientAllowed(requester))
{
return;
}
response.ContentType = "application/json";
if (request.HttpMethod == "POST")
{
using (var reader = new StreamReader(request.InputStream))
{
string posted = reader.ReadToEnd();
int volume;
if (int.TryParse(posted, out volume))
{
songPlayer.Volume = volume;
}
WriteUtf8String(response.OutputStream, JsonConvert.SerializeObject(songPlayer.Volume));
}
}
break;
case "image":
string tempId;
bool large = false;
if (actionPath.Length == 4)
{
tempId = actionPath[2];
if (!string.IsNullOrEmpty(tempId))
{
tempId = WebUtility.HtmlDecode(tempId);
}
if (actionPath[3].Equals("large", StringComparison.OrdinalIgnoreCase))
{
large = true;
}
}
else
{
tempId = string.Empty;
if (actionPath[2].Equals("large", StringComparison.OrdinalIgnoreCase))
{
large = true;
}
}
ImageHelper.HelpMe(response, tempId, songPlayer, large);
break;
default:
response.ContentType = "text/plain";
WriteUtf8String(response.OutputStream, request.RawUrl);
break;
}
}
private static void HelpMeLarge(HttpListenerResponse response, string tempId, ISongPlayer songPlayer)
{
int size = 300;
string cacheFolder = Path.Combine(_imageCachePath, tempId.Length > 2 ? tempId.Substring(0, 2) : tempId);
string cacheKey = Path.Combine(cacheFolder, tempId + "_" + size + ".png");
if (File.Exists(cacheKey))
{
using (FileStream fileStream = File.OpenRead(cacheKey))
{
WriteImage(response, fileStream);
return;
}
}
lock (_lockObject)
{
// get from player
MemoryStream imageStream = null;
if (!string.IsNullOrEmpty(tempId))
{
try
{
// this is locked in function
imageStream = songPlayer.GetImageStream(tempId, size);
}
catch (Exception)
{
imageStream = null;
}
using (MemoryStream streamFromSongPlayer = imageStream)
{
if (streamFromSongPlayer != null)
{
if (!Directory.Exists(cacheFolder))
{
Directory.CreateDirectory(cacheFolder);
}
using (FileStream fileStream = File.Create(cacheKey))
{
streamFromSongPlayer.CopyTo(fileStream);
}
WriteImage(response, streamFromSongPlayer);
return;
}
}
}
// cache large if not present
if (_emptyImageLarge == null)
{
using (Stream stream = Assembly.GetEntryAssembly().GetManifestResourceStream("SongRequest.Static.empty.png"))
using (MemoryStream memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
_emptyImageLarge = memoryStream.ToArray();
}
}
WriteImage(response, _emptyImageLarge);
}
}
private static void HelpMeSmall(HttpListenerResponse response, string tempId, ISongPlayer songPlayer)
{
if (thumbnailBuffer.ContainsKey(tempId))
{
WriteImage(response, thumbnailBuffer[tempId]);
return;
}
// get from player
MemoryStream imageStream = null;
if (!string.IsNullOrEmpty(tempId))
{
try
{
// this is locked in function
imageStream = songPlayer.GetImageStream(tempId, false);
}
catch (Exception)
{
imageStream = null;
}
using (MemoryStream streamFromSongPlayer = imageStream)
{
if (streamFromSongPlayer != null)
{
if (!thumbnailBuffer.ContainsKey(tempId))
{
thumbnailBuffer.Add(tempId, streamFromSongPlayer.ToArray());
}
WriteImage(response, streamFromSongPlayer);
return;
}
}
}
// cache small if not present
if (_emptyImageSmall == null)
{
using (Stream stream = Assembly.GetEntryAssembly().GetManifestResourceStream("SongRequest.Static.empty_small.png"))
using (MemoryStream memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
_emptyImageSmall = memoryStream.ToArray();
}
}
if (!thumbnailBuffer.ContainsKey(tempId))
{
thumbnailBuffer.Add(tempId, _emptyImageSmall);
}
WriteImage(response, _emptyImageSmall);
}
public MainWindowViewModel(ISongProvider songProvider, ISongPlayer songPlayer)
{
_songProvider = songProvider;
_songPlayer = songPlayer;
}
public SongHistoryService(ISongPlayer songPlayer)
{
_songPlayer = songPlayer;
_songHistory = new ConcurrentStack<Song>();
_maximumLength = 200;
}
public MainHub()
{
_songPlayer = GlobalHost.DependencyResolver.Resolve<ISongPlayer>();
_queue = GlobalHost.DependencyResolver.Resolve<IVoteableQueue<ISongStream>>();
}
public PlayerEventPublisher(ISongPlayer player, IVoteableQueue<ISongStream> queue)
{
_player = player;
_queue = queue;
}
private static void HelpMeLarge(HttpListenerResponse response, string tempId, ISongPlayer songPlayer)
{
int size = 300;
string cacheFolder = Path.Combine(_imageCachePath, tempId.Length > 2 ? tempId.Substring(0, 2) : tempId);
string cacheKey = Path.Combine(cacheFolder, tempId + "_" + size + ".png");
if (File.Exists(cacheKey))
{
using (FileStream fileStream = File.OpenRead(cacheKey))
{
WriteImage(response, fileStream);
return;
}
}
lock (_lockObject)
{
// get from player
MemoryStream imageStream = null;
if (!string.IsNullOrEmpty(tempId))
{
try
{
// this is locked in function
imageStream = songPlayer.GetImageStream(tempId, size);
}
catch (Exception)
{
imageStream = null;
}
using (MemoryStream streamFromSongPlayer = imageStream)
{
if (streamFromSongPlayer != null)
{
if (!Directory.Exists(cacheFolder))
Directory.CreateDirectory(cacheFolder);
using (FileStream fileStream = File.Create(cacheKey))
{
streamFromSongPlayer.CopyTo(fileStream);
}
WriteImage(response, streamFromSongPlayer);
return;
}
}
}
// cache large if not present
if (_emptyImageLarge == null)
{
using (Stream stream = Assembly.GetEntryAssembly().GetManifestResourceStream("SongRequest.Static.empty.png"))
using (MemoryStream memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
_emptyImageLarge = memoryStream.ToArray();
}
}
WriteImage(response, _emptyImageLarge);
}
}
private static void HelpMeLarge(HttpListenerResponse response, string tempId, ISongPlayer songPlayer)
{
// use cached image if possible
if (tempId.Equals(_lastId, StringComparison.OrdinalIgnoreCase) && _lastImage != null)
{
WriteImage(response, _lastImage);
return;
}
// get from player
MemoryStream imageStream = null;
if (!string.IsNullOrEmpty(tempId))
{
try
{
// this is locked in function
imageStream = songPlayer.GetImageStream(tempId, true);
}
catch (Exception)
{
imageStream = null;
}
using (MemoryStream streamFromSongPlayer = imageStream)
{
if (streamFromSongPlayer != null)
{
// set last id
_lastId = tempId;
_lastImage = streamFromSongPlayer.ToArray();
WriteImage(response, _lastImage);
return;
}
}
}
// cache large if not present
if (_emptyImageLarge == null)
{
using (Stream stream = Assembly.GetEntryAssembly().GetManifestResourceStream("SongRequest.Static.empty.png"))
using (MemoryStream memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
_emptyImageLarge = memoryStream.ToArray();
}
}
WriteImage(response, _emptyImageLarge);
}
public TorshifyHub()
{
_player = GlobalHost.DependencyResolver.Resolve<ISongPlayer>();
}
