public string getAvsCode(SortedList<String, String[]> fileDetails, Track video, SortedList<String, String> EncOpts)
{
ExtApplication filter;
switch (EncOpts["sharpen"])
{
case "1":
filter = ToolsManager.Instance.getTool("UnFilter");
if (!filter.isInstalled())
filter.download();
return "UnFilter(20,20)\r\n";
case "2":
filter = ToolsManager.Instance.getTool("Toon-v1.0-lite");
if (!filter.isInstalled())
filter.download();
return "ToonLite(strength=0.75)\r\n";
case "3":
filter = ToolsManager.Instance.getTool("aWarpSharp");
if (!filter.isInstalled())
filter.download();
return "aWarpSharp()\r\n";
case "4":
filter = ToolsManager.Instance.getTool("MSharpen");
if (!filter.isInstalled())
filter.download();
return "MSharpen()\r\n";
default:
return "";
}
}
public string getAvsCode(SortedList<String, String[]> fileDetails, Track video, SortedList<String, String> EncOpts)
{
ExtApplication filter;
switch (EncOpts["denoise"])
{
case "1":
filter = ToolsManager.Instance.getTool("UnDot");
if (!filter.isInstalled())
filter.download();
return "UnDot()\r\n";
case "2":
filter = ToolsManager.Instance.getTool("FluxSmooth");
if (!filter.isInstalled())
filter.download();
return "FluxSmoothST()\r\n";
case "3":
filter = ToolsManager.Instance.getTool("HQDN3D");
if (!filter.isInstalled())
filter.download();
return "HQDN3D()\r\n";
case "4":
filter = ToolsManager.Instance.getTool("UnDot");
if (!filter.isInstalled())
filter.download();
filter = ToolsManager.Instance.getTool("Deen");
if (!filter.isInstalled())
filter.download();
return "UnDot.Deen()\r\n";
default:
return "";
}
}
public TrackConnection(Vector2 p1, Vector2 p2, Track track)
{
this.track = track;
Point1 = new TrackPoint(p1, track);
Point2 = new TrackPoint(p2, track);
id = track.NewId;
}
private async Task CreateTaskAsync(Track track)
{
await _semaphoreSlim.WaitAsync();
using (var timer = _insightsService.TrackTimeEvent("SongMatched", new Dictionary<string, string>
{
{"Title", track.Title},
{"Artists", track.Artists},
{"Album", track.AlbumTitle},
{"Album artist", track.AlbumArtist}
}))
try
{
var uri = await _matchEngineService.GetLinkAsync(track.Title, track.DisplayArtist);
if (uri != null)
{
timer.AddProperty("Status", "Found match");
track.AudioWebUri = uri.ToString();
track.Status = TrackStatus.None;
await _downloadService.StartDownloadAsync(track);
}
else
{
timer.AddProperty("Status", "No match");
track.Status = TrackStatus.NoMatch;
}
await _libraryService.UpdateTrackAsync(track);
}
catch
{
timer.AddProperty("Status", "Error");
}
_semaphoreSlim.Release();
}
public Track ReadTrack(string uri)
{
var document = reader.GetSpotifyData(BasePath + "?uri=" + uri);
var track = document.Elements().FirstOrDefault();
var val = new Track
{
SpotifyLink = uri,
Name = track.Element(ns + SpotifyTags.Name).Value,
Artist = (from artist in track.Descendants(ns + SpotifyTags.Artist)
select new Artist
{
Name = artist.Element(ns + SpotifyTags.Name).Value,
SpotifyLink = artist.Attribute(SpotifyTags.SpotifyLink) != null ? artist.Attribute("href").Value : String.Empty
}).FirstOrDefault(),
Album = (from album in track.Descendants(ns + SpotifyTags.Album)
select new Album
{
Name = album.Element(ns + SpotifyTags.Name).Value,
SpotifyLink = album.Attribute(SpotifyTags.SpotifyLink) != null ? album.Attribute("href").Value : String.Empty,
Released = album.Element(ns + SpotifyTags.Released) != null ? Int32.Parse(album.Element(ns + SpotifyTags.Released).Value) : 0
}).FirstOrDefault(),
TrackNumber = Int32.Parse(track.Element(ns + SpotifyTags.TrackNumber).Value),
Length = Double.Parse(track.Element(ns + SpotifyTags.Length).Value),
Popularity = Double.Parse(track.Element(ns + SpotifyTags.Popularity).Value)
};
return (val);
}
XmlDocument CreateXML(string result, Track[] items = null)
{
XmlDocument xmldoc = new XmlDocument();
XmlDeclaration decl = xmldoc.CreateXmlDeclaration("1.0", "utf-8", null);
xmldoc.AppendChild(decl);
XmlNode root = xmldoc.CreateElement("HttpResponse");
xmldoc.AppendChild(root);
XmlNode res = xmldoc.CreateElement("Result");
res.InnerText = result;
root.AppendChild(res);
XmlNode args = xmldoc.CreateElement("Params");
root.AppendChild(args);
if (items!=null)
{
for (int i = 0; i < items.Length; i++)
{
XmlNode node = xmldoc.CreateElement("Song");
args.AppendChild(node);
XmlNode name = xmldoc.CreateElement("Name");
name.InnerText = items[i].Name;
XmlNode title = xmldoc.CreateElement("Title");
title.InnerText = items[i].Title;
XmlNode filestream = xmldoc.CreateElement("FileStream");
filestream.InnerText = items[i].FileStream;
node.AppendChild(name);
node.AppendChild(title);
node.AppendChild(filestream);
}
}
return xmldoc;
}
public Track Map(S.ITrack track, SpotifyMusicProvider musicProvider, string user, bool mapAlbum=false,bool mapArtists=false)
{
string trackLink = track.GetLinkString();
var trackResult = new Track
{
Link = trackLink,
Name = track.Name,
IsAvailable = track.IsAvailable,
Duration = track.Duration,
DurationMilliseconds = (long)track.Duration.TotalMilliseconds,
MusicProvider = musicProvider.Descriptor,
ExternalLink = new Uri(musicProvider.ExternalLinkBaseUrl, "/track/" + trackLink)
};
if (mapAlbum && track.Album != null)
{
trackResult.Album = albumMapper.Map(track.Album, musicProvider);
}
if (mapArtists && track.Artists != null)
{
trackResult.Artists = track.Artists.Select(t => artistMapper.Map(t,musicProvider)).ToArray();
}
//We want to set whether the track is already queued
if(alreadyQueuedHelper!=null)
{
trackResult = alreadyQueuedHelper.ResetAlreadyQueued((trackResult), user);
}
return trackResult;
}
public TrackPoint(Vector2 position, Track track)
{
this.track = track;
track.Register(this);
this.position = position;
id = track.NewId;
}
public bool encode(SortedList<String, String[]> fileDetails, int i, Track audio, SortedList<String, String> EncOpts)
{
try
{
ExtApplication besweet = ToolsManager.Instance.getTool("besweet");
MiniProcess proc = new AudioProcess(fileDetails["audLength"][0], LanguageController.Instance.getLanguageString("audioEncodingTrack") + " (ID = " + (i) + ")", fileDetails["name"][0] + "AudioEncodingProcess");
ProcessManager.Instance.Process = proc;
proc.stdErrDisabled(false);
proc.stdOutDisabled(false);
LogBookController.Instance.addLogLine("Encoding to vorbis", LogMessageCategories.Video);
proc.initProcess();
proc.setFilename(Path.Combine(besweet.getInstallPath(), "BeSweet.exe"));
if (!besweet.isInstalled())
besweet.download();
audio.encodePath = LocationManager.TempFolder + Path.GetFileNameWithoutExtension(audio.demuxPath) + "_output.ogg";
proc.setArguments("-core( -input \"" + audio.demuxPath + "\" -output \"" + audio.encodePath + "\" ) -azid( -s stereo -c normal -L -3db ) -ota( -hybridgain ) -ogg( -b " + EncOpts["audbr"] + " )");
int exitCode = proc.startProcess();
LogBookController.Instance.addLogLine("Encoding audio completed", LogMessageCategories.Video);
return ProcessManager.hasProcessExitedCorrectly(proc, exitCode);
}
catch (Exception error)
{
LogBookController.Instance.addLogLine("Error encoding audio to Vorbis. (" + error.Source + ", " + error.Message + ", " + error.Data + ", " + error.ToString() + ")", LogMessageCategories.Error);
return false;
}
}
public void Update(Track track)
{
foreach (Particle p in particles)
{
p.Move(track);
}
}
bool checkMovable(Track.MoveDestination direction)
{
int lineNo = mTarget.getLineNo();
int index = mTarget.getIndex();
return track.checkMove(lineNo, index, direction);
}
Vector3 getOffsetFromPlace(Track.MoveDestination dir)
{
Vector3 returnOffset = Vector3.zero;
GridManager gm = GameObject.FindObjectOfType<GridManager>();
switch (dir)
{
case Track.MoveDestination.FORWARD:
returnOffset = new Vector3(0f, 0f, gm.gridLength);
break;
case Track.MoveDestination.BACKWARD:
returnOffset = new Vector3(0f, 0f, gm.gridLength * -1.0f);
break;
case Track.MoveDestination.WESTLINE:
returnOffset = getWestLineOffset();
break;
case Track.MoveDestination.EASTLINE:
returnOffset = getEastLineOffset();
break;
case Track.MoveDestination.MIDLINE:
returnOffset = getMidLineOffset();
break;
case Track.MoveDestination.NORTHLINE:
returnOffset = getNorthLineOffset();
break;
case Track.MoveDestination.SOUTHLINE:
returnOffset = getSouthLineOffset();
break;
}
return returnOffset;
}
public Sector(int id, int sectorNr, Track track)
{
this.Id = id;
this.SectorNr = sectorNr;
this.Track = track;
this.Blocked = false;
}
protected override void UpdateTrack(Track tbd)
{
if (tbd != _Tr)
return;
tbd.UpdateTrackOnly(this);
}
/// <summary>
/// Gets all preferred tracks for the specified track
/// </summary>
/// <param name="track">The track.</param>
/// <returns>A list of tracks in the library the specified track should prefer to mix with</returns>
public List<Track> GetMixableTracks(Track track, int mixLevel)
{
var tracks = new List<Track>();
if (track == null) return tracks;
if (mixLevel == 1)
{
var excludeTracks = new List<Track>();
excludeTracks.Add(track);
excludeTracks.AddRange(GetMixableTracks(track, 0));
excludeTracks.AddRange(GetMixableTracks(track, 2));
excludeTracks.AddRange(GetMixableTracks(track, 3));
excludeTracks.AddRange(GetMixableTracks(track, 4));
excludeTracks.AddRange(GetMixableTracks(track, 5));
var tracksInRange = BassHelper.GetTracksInBPMRange(track.EndBPM, 5M, _library.GetTracks());
return tracksInRange
.Distinct()
.Except(excludeTracks)
.ToList();
}
else
{
foreach (var toTrack in GetMixTracks(track).GetToTracks(mixLevel))
{
var mixableTrack = _library.GetTracks()
.Where(t => t.Description == toTrack.TrackDescription)
.FirstOrDefault();
if (mixableTrack != null) tracks.Add(mixableTrack);
}
}
return tracks;
}
public ActionResult Agenda(int eventid)
{
var tracks = service.GetAgenda(eventid);
List<Track> model = new List<Track>();
foreach (var track in tracks)
{
Track t = new Track() { ID = track.ID, Name = track.Name, Description = track.Description };
foreach (var session in track.Sessions.OrderBy((s) => s.StartTime))
t.Sessions.Add(new Session()
{
ID = session.ID,
Name = session.Name,
Description = session.Description,
Speaker = session.Speaker,
SpeakerID = session.SpeakerID,
StartTime = session.StartTime.Value.ToShortTimeString(),
EndTime = session.EndTime.Value.ToShortTimeString(),
Location = string.IsNullOrEmpty(session.Location) ? string.Empty : session.Location
});
model.Add(t);
}
return View(model);
}
public override void playTrack(Track track) {
base.playTrack(track);
PlaybackPosition = 0;
consumedTrackLength = 0;
totalTrackLength = (int)track.Duration.TotalMilliseconds;
}
public static string GetTrackArtistsNames(Track track)
{
var ret = "";
for (int i = 0; i < track.NumArtists(); i++)
ret += (i != 0 ? ", " : "") + track.Artist(i).Name();
return ret;
}
public void NextWithQueuedTracks_SequenceShouldIncludeEnqueuedTracks()
{
var track1 = new Track("Track1");
var track2 = new Track("Track2");
var track3 = new Track("Track3");
var enqueued1 = new Track("Enqueued1");
var enqueued2 = new Track("Enqueued2");
_playlist.Initialize(track1, track2, track3);
_playlist.Enqueue(enqueued1, enqueued2);
var expected = new[]
{
track1,
enqueued1,
enqueued2,
track2,
track3
};
for (int i = 0; i < expected.Length - 1; i++)
{
Assert.AreEqual(expected[i], _playlist.Current);
_playlist.Next();
}
}
public static void UpdateMusic(Track track)
{
string title = null;
string artist = null;
const string album = "";
var enable = track != null && track.Status == TrackStatus.Playing;
if (enable)
{
title = track.Title;
artist = track.Artist;
}
var buffer = String.Format("\\0Music\\0{0}\\0{{0}} - {{1}}\\0{1}\\0{2}\\0{3}\\0\\0\0", (enable ? "1" : "0"), title, artist, album);
COPYDATASTRUCT data;
data.dwData = 0x0547;
data.lpData = VarPtr(buffer);
data.cbData = buffer.Length * 2;
var hWnd = 0;
do
{
hWnd = FindWindowEx(0, hWnd, "MsnMsgrUIManager", null);
SendMessage(hWnd, WM_COPYDATA, 0, VarPtr(data));
} while (hWnd != 0);
}
public static void OnInit()
{
MacroEx macro = new MacroEx();
WaitForMsg wait = new WaitForMsg(1042635, 1008124, 1008125, 1043297, 1055086, 1055087, 503172, 503171);
macro.Insert(-1, new UseFishingPole(wait));
macro.Insert(-1, new WaitForTargetAction(new[] { "", "2" }));
macro.Insert(-1, new TargetRelLocAction(0, 0));
macro.Insert(-1, new AttackClosestAction());
macro.Insert(-1, new Clean());
Track track = new Track();
macro.Insert(-1, track);
macro.Insert(-1, new WaitForTrack(track));
macro.Insert(-1, new TrackResponse(track));
macro.Insert(-1, wait);
macro.Insert(-1, new SailAction(wait));
Command.Register("fish", args => MacroManager.HotKeyPlay(macro));
Core.AddHotkey("Fishing", () => MacroManager.HotKeyPlay(macro));
MacroEx sos = new MacroEx();
WaitForMsg waitSos = new WaitForMsg(1042635, 1008124, 1008125, 1043297, 1055086, 1055087, 503172, 503171, 501747);
sos.Insert(-1, new UseFishingPole(waitSos));
sos.Insert(-1, new WaitForTargetAction(new[] { "", "2" }));
sos.Insert(-1, new TargetRelLocAction(0, 0));
sos.Insert(-1, waitSos);
sos.Insert(-1, new FoundSOSAction(waitSos));
Command.Register("sos", args => MacroManager.HotKeyPlay(sos));
Core.AddHotkey("SOS", () => MacroManager.HotKeyPlay(sos));
Command.Register("sit", OnCommand);
}
public async Task InternalSaveAsync(Track track, byte[] albumData, byte[] artistData)
{
using (_insightsService.TrackTimeEvent("SongSaved",
new Dictionary<string, string>
{
{ "Track type", track.Type.ToString() },
{ "Title", track.Title },
{ "Artists", track.Artists },
{ "Album", track.AlbumTitle },
{ "Album artist", track.AlbumArtist }
}))
{
var isMatching = track.AudioWebUri == null && track.AudioLocalUri == null;
track.Status = isMatching ? TrackStatus.Matching : TrackStatus.None;
// Download artwork
await DownloadAlbumArtworkAsync(track, albumData);
await DownloadArtistArtworkAsync(track, artistData);
await _libraryService.AddTrackAsync(track);
// proccess it
if (isMatching)
{
_matchingService.Queue(track);
}
else if (track.AudioLocalUri == null)
{
await _downloadService.StartDownloadAsync(track);
}
}
}
public static float CPAPointsEx(Vector2 p1, Vector2 v1, Vector2 p2, Vector2 v2, Vector2 p1End, Vector2 p2End,
out Vector2 p1Out, out Vector2 p2Out)
{
Track tr1 = new Track(p1, v1);
Track tr2 = new Track(p2, v2);
float ctime = cpa_time(tr1, tr2);
if (ctime == 0)
{
bool collision;
var collisionTime = MathUtils.GetCollisionTime(p1, p2, v1, v2, 10, 10, out collision);
if (collision)
{
ctime = collisionTime;
}
}
Vector2 P1 = tr1.P0 + (ctime * tr1.V);
Vector2 P2 = tr2.P0 + (ctime * tr2.V);
//P1 = d(p1, P1) > d(p1, p1end) ? p1end : P1;
//P2 = d(p2, P2) > d(p2, p2end) ? p2end : P2;
p1Out = P1;//P1.ProjectOn(p1, p1end).SegmentPoint;//P1;
p2Out = P2;//P2.ProjectOn(p2, p2end).SegmentPoint;
return D(P1, P2);
}
void PlayOrResume(Track track)
{
if (track == null) throw new ArgumentNullException("track");
if (!CanPlay(track)) return;
if (!track.Equals(CurrentTrack))
{
Stop();
try
{
naudio.OpenFile(track.Filename);
}
catch (Exception e)
{
Log.WarnFormat("Unable to play {0}.", track.Filename);
Log.Warn(e);
return;
}
CurrentTrack = track;
messenger.SendToUI(new PlayerLoadedEvent(track));
}
naudio.Play();
}
public static void PrintTrack(SpotifySession aSession, Track aTrack)
{
int duration = aTrack.Duration();
Console.Write(" {0} ", Track.IsStarred(aSession, aTrack) ? "*" : " ");
Console.Write("Track {0} [{1}:{2:D02}] has {3} artist(s), {4}% popularity",
aTrack.Name(),
duration / 60000,
(duration / 1000) % 60,
aTrack.NumArtists(),
aTrack.Popularity());
if (aTrack.Disc() != 0)
{
Console.Write(", {0} on disc {1}",
aTrack.Index(),
aTrack.Disc());
}
for (int i = 0; i < aTrack.NumArtists(); ++i)
{
var artist = aTrack.Artist(i);
Console.Write("\tArtist {0}: {1}", i + 1, artist.Name());
}
var link = Link.CreateFromTrack(aTrack, 0);
Console.WriteLine("\t\t{0}", link.AsString());
link.Release();
}
static Track GetTrack(ref byte[] arrayToParse, ref LocFile01.Track[] tracks)
{
Track track = new Track();
int cursor = 0;
int cursor1 = 0;
// Want a searchable string in which we look for data.
string parseMe = Encoding.UTF8.GetString(arrayToParse, 0, arrayToParse.Length);
// 0xFF 52/R 21/! 0D seems to be identifier.
cursor = parseMe.IndexOf("R!") + 3;
// Name on GPS is terminated by 0x26/&.
cursor1 = parseMe.IndexOf("&");
track.NameOnGps = parseMe.Substring(cursor, cursor1 - cursor);
cursor1++;
arrayToParse = Extensions.Right(arrayToParse, cursor1, arrayToParse.Length - cursor1);
parseMe = Encoding.UTF8.GetString(arrayToParse, 0, arrayToParse.Length);
cursor = 0;
// Label on map seems to be terminated by 0x00.
while (arrayToParse[cursor] != 0x0)
{
track.LabelOnMap = track.LabelOnMap + (char)arrayToParse[cursor];
cursor++;
}
cursor++;
arrayToParse = Extensions.Right(arrayToParse, cursor1, arrayToParse.Length - cursor1);
// Get rid of eight bytes we don't know what to do with.
arrayToParse = Extensions.Right(arrayToParse, 8, arrayToParse.Length - 8);
parseMe = Encoding.UTF8.GetString(arrayToParse, 0, arrayToParse.Length);
cursor = 0;
GetTrackPoints(ref arrayToParse, ref track);
return track;
}
public static Inbox PostTracks(
SpotifySession session,
string username,
Track[] tracks,
string message,
InboxPostComplete callback,
object userdata)
{
using (var utf8_username = SpotifyMarshalling.StringToUtf8(username))
using (var utf8_message = SpotifyMarshalling.StringToUtf8(message))
using (var track_array = SpotifyMarshalling.ArrayToNativeArray(tracks.Select(x=>x._handle).ToArray()))
{
IntPtr listenerToken = ListenerTable.PutUniqueObject(callback, userdata);
IntPtr ptr = NativeMethods.sp_inbox_post_tracks(
session._handle,
utf8_username.IntPtr,
track_array.IntPtr,
track_array.Length,
utf8_message.IntPtr,
InboxPostCompleteDelegate,
listenerToken);
Inbox search = InboxTable.GetUniqueObject(ptr);
search.ListenerToken = listenerToken;
return search;
}
}
public void Poll()
{
if (!_session.Authenticated)
return;
if (_session != null && _session.Authenticated && _lfmUser != null)
{
var track = _lfmUser.GetNowPlaying();
if (track != null)
{
if (_currentTrack == null || (_currentTrack.GetID() != track.GetID()))
{
var album = track.GetAlbum();
var artist = track.Artist;
if (OnTrackChange != null)
OnTrackChange(this, new LastFmArgs() { Album = (album == null ? "" : album.Title), Artist = (artist == null ? "" : artist.Name), ArtistImage = null, Title = track.Title });
}
_currentTrack = track;
}
}
}
/// <summary>
/// Adds a track to a channel
/// </summary>
/// <param name="file"></param>
/// <param name="channelId"></param>
/// <param name="trackName"></param>
/// <param name="artistName"></param>
/// <returns></returns>
public ActionResult AddTrack(HttpPostedFileBase file, int channelId, int? userId, string trackName, string artistName)
{
if (userId.HasValue)
{
try
{
// Verify that the user selected a file
if (file != null && file.ContentLength > 0)
{
Stream stream = file.InputStream;
MemoryStream memory = new MemoryStream();
stream.CopyTo(memory);
Track track = new Track();
track.Artist = artistName;
track.Name = trackName;
using (RentItServiceClient proxy = new RentItServiceClient())
{
proxy.AddTrack(userId.Value, channelId, memory);
}
}
}
catch (Exception)
{
}
return Redirect(Request.UrlReferrer.PathAndQuery);
}
return RedirectToAction("Index", "Home");
}
/*[STAThread]
static void Main() {
if(!SoundCloudCore.Connect(new Login(user, pass, ClientID, ClientSecret)))
return;
var list = new List<int>();
for(var i = 0; i < Me.LikesCount; i += 10) {
if(i >= Me.LikesCount)
break;
list = list.Concat(Me.GetLikedTracks(i, 10)).ToList();
Console.WriteLine("SEARCHING: " + i + "/" + Me.LikesCount);
}
Console.WriteLine("COMPLETED: " + list.Count + " / " + Me.LikesCount + "Track info was downloaded");
// Download all tracks to folder
foreach(var id in list)
DownloadTrack(SoundCloudCore.Tracks[id]);
Directory.Delete("Images", true);
Console.ReadLine();
}*/
static void DownloadTrack(Track track)
{
var wc = new WebClient();
if(!Directory.Exists("Tracks")) Directory.CreateDirectory("Tracks");
if(!Directory.Exists("Images")) Directory.CreateDirectory("Images");
var path = "Tracks\\" + track.Title + ".mp3";
if(System.IO.File.Exists(path)) return;
try {
wc.DownloadFile(new Uri(track.StreamUrl), path);
// Write tag
if(!System.IO.File.Exists(path)) return;
var tag = TagLib.File.Create(path);
tag.Tag.Title = track.Title;
tag.Tag.BeatsPerMinute = (uint)track.Bpm;
tag.Tag.Year = (uint)track.Created.Year;
// Get track cover
var imgPath = "Images\\" + track.Title + ".jpg";
wc.DownloadFile(new Uri(track.GetCover(AlbumSize.x300)), imgPath);
if(System.IO.File.Exists(imgPath)) {
var pic = new IPicture[1];
pic[0] = new Picture(imgPath);
tag.Tag.Pictures = pic;
}
// Save tag info
tag.Save();
Console.WriteLine("Downloaded track: " + track.Title);
}
catch(Exception ex) { Console.WriteLine("Error downloading track: " + track.Title + "; Exception: " + ex.Message); }
}
public PlaylistTrack RemoveTrackFromPlaylist(Playlist playlist, Track track)
{
return(playlist.RemoveTrack(track.Id));
}
internal void MapLastFMAPITrackToTrack_ReturnsExpectedTrack()
{
var track = new Track();
var trackExtra = new LastFMTrack()
{
Album = new Album()
{
Title = "Album Title",
Position = "5",
Image = new List <Image>()
{
new Image()
{
Size = AlbumCoverSize.extralarge.ToString(), Url = "http://xlarge-cover-url.local"
},
new Image()
{
Size = AlbumCoverSize.large.ToString(), Url = "http://large-cover-url.local"
},
new Image()
{
Size = AlbumCoverSize.medium.ToString(), Url = "http://medium-cover-url.local"
},
new Image()
{
Size = AlbumCoverSize.small.ToString(), Url = "http://small-cover-url.local"
},
}
},
Toptags = new Toptags()
{
Tag = new List <Tag>()
{
new Tag()
{
Name = "Reggae", Url = "http://reggae-tag.local"
},
new Tag()
{
Name = "Rock", Url = "http://rock-tag.local"
},
new Tag()
{
Name = "Jazz", Url = "http://jazz-tag.local"
},
}
},
Duration = 1337000,
};
_lastFMAPI.MapLastFMTrackToTrack(track, trackExtra);
Assert.Equal("Album Title", track.Album);
Assert.Equal(5, track.AlbumPosition);
Assert.Equal(new[] { "Reggae", "Rock", "Jazz" }, track.Genres);
Assert.Equal(1337, track.Length);
Assert.Equal("http://xlarge-cover-url.local", track.ArtExtraLargeUrl);
Assert.Equal("http://large-cover-url.local", track.ArtLargeUrl);
Assert.Equal("http://medium-cover-url.local", track.ArtMediumUrl);
Assert.Equal("http://small-cover-url.local", track.ArtSmallUrl);
}
//VegasだとvarとかC#3.0のLinqのメソッド形式の入力がエラー
public void FromVegas(Vegas vegas)
{
// 音声ファイルのパス取得
string soundFolderPath = Path.GetDirectoryName(vegas.Project.FilePath) + VoiceFolderName;
// ファイル名（拡張子無し）を取得
List <string> filePathsNoEx = new List <string>();
foreach (string file in Directory.GetFiles(soundFolderPath, "*" + VoiceFileEx))
{
filePathsNoEx.Add(Path.GetDirectoryName(file) + @"\" + Path.GetFileNameWithoutExtension(file));
}
/*
* List<string> filePathsNoEx = Directory.GetFiles(soundFolderPath, "*" + VoiceFileEx)
* .Select(x => x.Replace(x, System.IO.Path.GetFileNameWithoutExtension(x))).ToList();
*/
// テキストファイルとそのテキストファイルの名前をDictionary形式で宣言
Dictionary <string, string> textDataDic = new Dictionary <string, string>();
// 選択されたテキストイベントを取得(Take名が指定の名称プレフィックスと一致している場合のみ)
List <TrackEvent> selectedTextEvents = new List <TrackEvent>();
foreach (TrackEvent ev in FindSelectedEvents(vegas.Project))
{
if (ev.ActiveTake.Name.IndexOf(TitleNamePrefix, StringComparison.Ordinal) != -1)
{
selectedTextEvents.Add(ev);
}
}
/*
* List<TrackEvent> selectedTextEvents =
* FindSelectedEvents(vegas.Project).Where(x => x.Name.IndexOf(TitleNamePrefix, StringComparison.Ordinal) != -1).ToList();
*/
// 選択されたトラックを取得
Track selectedTrack = FindSelectedTrack(vegas.Project);
if (selectedTrack.MediaType != MediaType.Audio)
{
selectedTrack = FindVoiceroid2Track(vegas.Project);
}
if (!CheckConfiguration(selectedTextEvents, selectedTrack, filePathsNoEx))
{
return;
}
// テキストファイル読み込み
foreach (string name in filePathsNoEx)
{
StreamReader sr = new StreamReader(
name + VoiceTextFileEx, Encoding.GetEncoding("Shift_JIS"));
string text = sr.ReadToEnd();
sr.Close();
// 改行コードはタイトルに含まれないため、削除
textDataDic.Add(text.Replace("\n", ""), name + VoiceFileEx);
}
// テキストイベント群と音声ファイル群でテキストが一致しているものをサーチ
List <TrackEvent> fileExistTextEvents = new List <TrackEvent>();
foreach (TrackEvent ev in selectedTextEvents)
{
if (textDataDic.ContainsKey(ev.ActiveTake.Name.Replace(TitleNamePrefix, "")))
{
fileExistTextEvents.Add(ev);
}
}
// List<TrackEvent> fileExistTextEvents = selectedTextEvents.Where(x => textDataDic.ContainsKey(x.Name.Replace(TitleNamePrefix, ""))).ToList();
// ダイアログのメッセージ生成
string message = MakeDialogMessage(fileExistTextEvents, selectedTrack, textDataDic);
// 確認ダイアログ生成
DialogResult result = MessageBox.Show(message,
"確認",
MessageBoxButtons.OKCancel,
MessageBoxIcon.Exclamation,
MessageBoxDefaultButton.Button2);
if (result != DialogResult.OK)
{
return;
}
// 処理実行
foreach (TrackEvent textEvent in fileExistTextEvents)
{
InsertFileAt(vegas, textDataDic[textEvent.ActiveTake.Name.Replace(TitleNamePrefix, "")], selectedTrack.Index, textEvent.Start);
}
}
private static void WriteArtworkFile(string directory, AlbumArtworkSaveFormat saveFormat, Track track, PictureCacheEntry albumArtwork)
{
string fileName = null;
switch (saveFormat)
{
case AlbumArtworkSaveFormat.DontSave:
break;
case AlbumArtworkSaveFormat.AsCover:
fileName = albumArtwork?.OriginalPicture.FileType.Append("cover");
break;
case AlbumArtworkSaveFormat.AsArtistAlbum:
fileName = albumArtwork?.OriginalPicture.FileType.Append($"{track.Artist} - {track.Album.Title}");
break;
default:
throw new ArgumentOutOfRangeException();
}
if (fileName == null)
{
return;
}
SysFile.WriteAllBytes(Path.Combine(directory, fileName), albumArtwork.FullSize);
}
public static string GetPathFromMtpTrack(Track track)
{
return(String.Format("mtp://{0}/{1}", track.FileId, track.FileName));
}
public void WriteBytes(BinaryWriter writer)
{
Header.WriteBytes(writer);
Track.WriteBytes(writer);
}
/// <summary>
/// Construct a new drawable track instance.
/// </summary>
/// <param name="track">The audio track to wrap.</param>
/// <param name="disposeTrackOnDisposal">Whether the track should be automatically disposed on drawable disposal/expiry.</param>
public DrawableTrack(Track track, bool disposeTrackOnDisposal = true)
: base(track, disposeTrackOnDisposal)
{
this.track = track;
}
public bool WriteSectorsTag(byte[] data, ulong sectorAddress, uint length, SectorTagType tag)
{
if (!IsWriting)
{
ErrorMessage = "Tried to write on a non-writable image";
return(false);
}
Track track =
writingTracks.FirstOrDefault(trk => sectorAddress >= trk.TrackStartSector &&
sectorAddress <= trk.TrackEndSector);
if (track is null)
{
ErrorMessage = $"Can't found track containing {sectorAddress}";
return(false);
}
switch (tag)
{
case SectorTagType.CdTrackFlags:
case SectorTagType.CdTrackIsrc: return(WriteSectorTag(data, sectorAddress, tag));
case SectorTagType.CdSectorSubchannel:
{
if (track.TrackSubchannelType == 0)
{
ErrorMessage =
$"Trying to write subchannel to track {track.TrackSequence}, that does not have subchannel";
return(false);
}
if (data.Length % 96 != 0)
{
ErrorMessage = "Incorrect data size for subchannel";
return(false);
}
FileStream trackStream = writingStreams.FirstOrDefault(kvp => kvp.Key == track.TrackSequence).Value;
if (trackStream == null)
{
ErrorMessage = $"Can't found file containing {sectorAddress}";
return(false);
}
for (uint i = 0; i < length; i++)
{
trackStream.
Seek((long)(track.TrackFileOffset + (((i + sectorAddress) - track.TrackStartSector) * (ulong)(track.TrackRawBytesPerSector + 96))) + track.TrackRawBytesPerSector,
SeekOrigin.Begin);
trackStream.Write(data, (int)(i * 96), 96);
}
return(true);
}
default:
ErrorMessage = $"Unsupported tag type {tag}";
return(false);
}
}
public bool SetTracks(List <Track> tracks)
{
if (!IsWriting)
{
ErrorMessage = "Tried to write on a non-writable image";
return(false);
}
if (tracks == null ||
tracks.Count == 0)
{
ErrorMessage = "Invalid tracks sent";
return(false);
}
if (writingTracks != null &&
writingStreams != null)
{
foreach (FileStream oldTrack in writingStreams.Select(t => t.Value).Distinct())
{
oldTrack.Close();
}
}
ulong currentOffset = 0;
writingTracks = new List <Track>();
foreach (Track track in tracks.OrderBy(t => t.TrackSequence))
{
if (track.TrackSubchannelType == TrackSubchannelType.Q16 ||
track.TrackSubchannelType == TrackSubchannelType.Q16Interleaved)
{
ErrorMessage =
$"Unsupported subchannel type {track.TrackSubchannelType} for track {track.TrackSequence}";
return(false);
}
Track newTrack = track;
newTrack.TrackFile = separateTracksWriting ? writingBaseName + $"_track{track.TrackSequence:D2}.bin"
: writingBaseName + ".bin";
newTrack.TrackFileOffset = separateTracksWriting ? 0 : currentOffset;
writingTracks.Add(newTrack);
currentOffset += (ulong)newTrack.TrackRawBytesPerSector *
((newTrack.TrackEndSector - newTrack.TrackStartSector) + 1);
if (track.TrackSubchannelType != TrackSubchannelType.None)
{
currentOffset += 96 * ((newTrack.TrackEndSector - newTrack.TrackStartSector) + 1);
}
}
writingStreams = new Dictionary <uint, FileStream>();
if (separateTracksWriting)
{
foreach (Track track in writingTracks)
{
writingStreams.Add(track.TrackSequence,
new FileStream(track.TrackFile, FileMode.OpenOrCreate, FileAccess.ReadWrite,
FileShare.None));
}
}
else
{
var jointstream = new FileStream(writingBaseName + ".bin", FileMode.OpenOrCreate, FileAccess.ReadWrite,
FileShare.None);
foreach (Track track in writingTracks)
{
writingStreams.Add(track.TrackSequence, jointstream);
}
}
return(true);
}
private void initTrack(int startX, int startY, char[][] grid)
{
//Place a "ghost" cart on the track that will ride the entire length of the track, acting as a "rail layer" so-to-speak
//since we are starting at the top left, we can safely go right OR down. But we are gonna choose right.
var track = new Track(new Coord(startX, startY));
track.AddRail(startX, startY, grid[startX][startY], true);
//Now, starting from our initial position, "ride" along the track, "laying" the rails and turning as needed until we get back
//to our initial position.
var nextX = startX;
var nextY = startY + 1;
var currentDirection = Direction.Right;
//In our array of arrays, "Down" is when X is INCREASING. "Right" is when Y is INCREASING.
while (!track.IsComplete)
{
var nextRail = grid[nextX][nextY];
if (!nextRail.IsCurve())
{
if (nextRail.IsIntersection())
{
track.AddRail(nextX, nextY, nextRail, IntersectionMap);
}
else
{
track.AddRail(nextX, nextY, nextRail);
}
switch (currentDirection)
{
case Direction.Right:
nextY++;
break;
case Direction.Left:
nextY--;
break;
case Direction.Down:
nextX++;
break;
case Direction.Up:
nextX--;
break;
}
}
else
{
track.AddRail(nextX, nextY, nextRail);
if (nextRail == '\\')
{
switch (currentDirection)
{
case Direction.Right:
currentDirection = Direction.Down;
nextX = nextX + 1;
break;
case Direction.Left:
currentDirection = Direction.Up;
nextX = nextX - 1;
break;
case Direction.Down:
currentDirection = Direction.Right;
nextY = nextY + 1;
break;
case Direction.Up:
currentDirection = Direction.Left;
nextY = nextY - 1;
break;
}
}
else if (nextRail == '/')
{
switch (currentDirection)
{
case Direction.Down:
currentDirection = Direction.Left;
nextY = nextY - 1;
break;
case Direction.Up:
currentDirection = Direction.Right;
nextY = nextY + 1;
break;
case Direction.Right:
currentDirection = Direction.Up;
nextX = nextX - 1;
break;
case Direction.Left:
currentDirection = Direction.Down;
nextX = nextX + 1;
break;
}
}
}
}
Tracks.Add(track);
}
public bool WriteSectors(byte[] data, ulong sectorAddress, uint length)
{
if (!IsWriting)
{
ErrorMessage = "Tried to write on a non-writable image";
return(false);
}
Track track =
writingTracks.FirstOrDefault(trk => sectorAddress >= trk.TrackStartSector &&
sectorAddress <= trk.TrackEndSector);
if (track is null)
{
ErrorMessage = $"Can't found track containing {sectorAddress}";
return(false);
}
FileStream trackStream = writingStreams.FirstOrDefault(kvp => kvp.Key == track.TrackSequence).Value;
if (trackStream == null)
{
ErrorMessage = $"Can't found file containing {sectorAddress}";
return(false);
}
if (track.TrackBytesPerSector != track.TrackRawBytesPerSector)
{
ErrorMessage = "Invalid write mode for this sector";
return(false);
}
if (sectorAddress + length > track.TrackEndSector + 1)
{
ErrorMessage = "Can't cross tracks";
return(false);
}
if (data.Length % track.TrackRawBytesPerSector != 0)
{
ErrorMessage = "Incorrect data size";
return(false);
}
// cdrdao audio tracks are endian swapped corresponding to Aaru
if (track.TrackType == TrackType.Audio)
{
byte[] swapped = new byte[data.Length];
for (long i = 0; i < swapped.Length; i += 2)
{
swapped[i] = data[i + 1];
swapped[i + 1] = data[i];
}
data = swapped;
}
switch (track.TrackSubchannelType)
{
case TrackSubchannelType.None:
trackStream.
Seek((long)(track.TrackFileOffset + ((sectorAddress - track.TrackStartSector) * (ulong)track.TrackRawBytesPerSector)),
SeekOrigin.Begin);
trackStream.Write(data, 0, data.Length);
ErrorMessage = "";
return(true);
case TrackSubchannelType.Raw:
case TrackSubchannelType.RawInterleaved:
trackStream.
Seek((long)(track.TrackFileOffset + ((sectorAddress - track.TrackStartSector) * (ulong)(track.TrackRawBytesPerSector + 96))),
SeekOrigin.Begin);
for (uint i = 0; i < length; i++)
{
trackStream.Write(data, (int)(i * track.TrackRawBytesPerSector), track.TrackRawBytesPerSector);
trackStream.Position += 96;
}
ErrorMessage = "";
return(true);
default:
ErrorMessage = "Invalid subchannel mode for this sector";
return(false);
}
}
public bool WriteSectorTag(byte[] data, ulong sectorAddress, SectorTagType tag)
{
if (!IsWriting)
{
ErrorMessage = "Tried to write on a non-writable image";
return(false);
}
Track track =
writingTracks.FirstOrDefault(trk => sectorAddress >= trk.TrackStartSector &&
sectorAddress <= trk.TrackEndSector);
if (track is null)
{
ErrorMessage = $"Can't found track containing {sectorAddress}";
return(false);
}
switch (tag)
{
case SectorTagType.CdTrackFlags:
{
if (data.Length != 1)
{
ErrorMessage = "Incorrect data size for track flags";
return(false);
}
trackFlags.Add((byte)sectorAddress, data[0]);
return(true);
}
case SectorTagType.CdTrackIsrc:
{
if (data != null)
{
trackIsrcs.Add((byte)sectorAddress, Encoding.UTF8.GetString(data));
}
return(true);
}
case SectorTagType.CdSectorSubchannel:
{
if (track.TrackSubchannelType == 0)
{
ErrorMessage =
$"Trying to write subchannel to track {track.TrackSequence}, that does not have subchannel";
return(false);
}
if (data.Length != 96)
{
ErrorMessage = "Incorrect data size for subchannel";
return(false);
}
FileStream trackStream = writingStreams.FirstOrDefault(kvp => kvp.Key == track.TrackSequence).Value;
if (trackStream == null)
{
ErrorMessage = $"Can't found file containing {sectorAddress}";
return(false);
}
trackStream.
Seek((long)(track.TrackFileOffset + ((sectorAddress - track.TrackStartSector) * (ulong)(track.TrackRawBytesPerSector + 96))) + track.TrackRawBytesPerSector,
SeekOrigin.Begin);
trackStream.Write(data, 0, data.Length);
return(true);
}
default:
ErrorMessage = $"Unsupported tag type {tag}";
return(false);
}
}
static void ParseRotationTrack(FileReader reader, Header header, Track track, AnimationGroup group)
{
switch (track.OpCode)
{
case 0x14: //4 Shorts Custom Count
{
uint count = reader.ReadUInt32();
for (int f = 0; f < count; f++)
{
float frame = (f * count) / header.FrameCount;
short[] quat = reader.ReadInt16s(4);
group.RotateX.AddKey(frame, quat[0] / 32767.0f);
group.RotateY.AddKey(frame, quat[1] / 32767.0f);
group.RotateZ.AddKey(frame, quat[2] / 32767.0f);
group.RotateW.AddKey(frame, quat[3] / 32767.0f);
}
}
break;
case 0x16: //4 Shorts Constant
{
/* short[] quat = reader.ReadInt16s(4);
* group.RotateX.AddKey(0, quat[0] / 32767.0f);
* group.RotateY.AddKey(0, quat[1] / 32767.0f);
* group.RotateZ.AddKey(0, quat[2] / 32767.0f);
* group.RotateW.AddKey(0, quat[3] / 32767.0f);*/
}
break;
}
return;
switch (track.OpCode)
{
case 0x0F: //4 Singles Frame Count
{
for (int f = 0; f < header.FrameCount; f++)
{
float frame = f;
float[] quat = reader.ReadSingles(4);
Quaternion quaternion = new Quaternion(quat[0], quat[1], quat[2], quat[3]);
group.RotateX.AddKey(frame, quaternion.X);
group.RotateY.AddKey(frame, quaternion.Y);
group.RotateZ.AddKey(frame, quaternion.Z);
group.RotateW.AddKey(frame, quaternion.W);
}
}
break;
case 0x13: //4 Singles Custom Count
{
uint count = reader.ReadUInt32();
for (int f = 0; f < count; f++)
{
float frame = (f * count) / header.FrameCount;
float[] quat = reader.ReadSingles(4);
group.RotateX.AddKey(frame, quat[0]);
group.RotateY.AddKey(frame, quat[1]);
group.RotateZ.AddKey(frame, quat[2]);
group.RotateW.AddKey(frame, quat[3]);
}
}
break;
case 0x15: //4 Singles Constant
{
float[] quat = reader.ReadSingles(4);
group.RotateX.AddKey(0, quat[0]);
group.RotateY.AddKey(0, quat[1]);
group.RotateZ.AddKey(0, quat[2]);
group.RotateW.AddKey(0, quat[3]);
}
break;
case 0x16: //Short Quat Constant
{
short[] quat = reader.ReadInt16s(4);
/* group.RotateX.AddKey(0, quat[0] / 0x7FFF);
* group.RotateY.AddKey(0, quat[1] / 0x7FFF);
* group.RotateZ.AddKey(0, quat[2] / 0x7FFF);
* group.RotateW.AddKey(0, quat[3] / 0x7FFF);*/
Console.WriteLine($"track {track.OpCode} Unknown {track.Unknown} {string.Join(",", quat)}");
}
break;
case 0x17: //Short X Axis Angle
{
var euler = new Vector3(reader.ReadInt16() / 180.0f, 0, 0) * STMath.Deg2Rad;
var quat = STMath.FromEulerAngles(euler);
group.RotateX.AddKey(0, quat.X);
group.RotateY.AddKey(0, quat.Y);
group.RotateZ.AddKey(0, quat.Z);
group.RotateW.AddKey(0, quat.W);
}
break;
case 0x18: //Short Y Axis Angle (Degrees) Frame Count
{
for (int f = 0; f < header.FrameCount; f++)
{
float frame = f;
var euler = new Vector3(0, reader.ReadInt16() / 180.0f, 0) * STMath.Deg2Rad;
var quat = STMath.FromEulerAngles(euler);
group.RotateX.AddKey(frame, quat.X);
group.RotateY.AddKey(frame, quat.Y);
group.RotateZ.AddKey(frame, quat.Z);
group.RotateW.AddKey(frame, quat.W);
}
}
break;
case 0x19: //Short Z Axis Angle (Degrees) Frame Count
{
for (int f = 0; f < header.FrameCount; f++)
{
float frame = f;
var euler = new Vector3(0, 0, reader.ReadInt16() / 180.0f) * STMath.Deg2Rad;
var quat = STMath.FromEulerAngles(euler);
group.RotateX.AddKey(frame, quat.X);
group.RotateY.AddKey(frame, quat.Y);
group.RotateZ.AddKey(frame, quat.Z);
group.RotateW.AddKey(frame, quat.W);
}
}
break;
/* case 0x1A: //Consta
* {
* ushort flag = reader.ReadUInt16();
* short[] angles = reader.ReadInt16s(2);
* ushort[] param = reader.ReadUInt16s(2);
*
* var euler = new Vector3(reader.ReadInt16() / 180.0f, 0, 0) * STMath.Deg2Rad;
* var quat = STMath.FromEulerAngles(euler);
* group.RotateX.AddKey(0, quat.X);
* group.RotateY.AddKey(0, quat.Y);
* group.RotateZ.AddKey(0, quat.Z);
* group.RotateW.AddKey(0, quat.W);
* }
* break;
* case 0x1B:
* {
* ushort flag = reader.ReadUInt16();
* // short[] quat = reader.ReadInt16s(4);
*
* var euler = new Vector3(0, reader.ReadInt16() / 180.0f, 0) * STMath.Deg2Rad;
* var quat = STMath.FromEulerAngles(euler);
* group.RotateX.AddKey(0, quat.X);
* group.RotateY.AddKey(0, quat.Y);
* group.RotateZ.AddKey(0, quat.Z);
* group.RotateW.AddKey(0, quat.W);
* }
* break;
* case 0x1C:
* {
* ushort flag = reader.ReadUInt16();
* // short[] quat = reader.ReadInt16s(4);
*
* var euler = new Vector3(0, 0, reader.ReadInt16() / 180.0f) * STMath.Deg2Rad;
* var quat = STMath.FromEulerAngles(euler);
* group.RotateX.AddKey(0, quat.X);
* group.RotateY.AddKey(0, quat.Y);
* group.RotateZ.AddKey(0, quat.Z);
* group.RotateW.AddKey(0, quat.W);
* }
* break;*/
default:
Console.WriteLine($"Unknown Op Code! Track {track.Index} Type {track.Type} OpCode {track.OpCode}");
break;
}
}
public bool WriteSectorsLong(byte[] data, ulong sectorAddress, uint length)
{
if (!IsWriting)
{
ErrorMessage = "Tried to write on a non-writable image";
return(false);
}
Track track =
writingTracks.FirstOrDefault(trk => sectorAddress >= trk.TrackStartSector &&
sectorAddress <= trk.TrackEndSector);
if (track is null)
{
ErrorMessage = $"Can't found track containing {sectorAddress}";
return(false);
}
FileStream trackStream = writingStreams.FirstOrDefault(kvp => kvp.Key == track.TrackSequence).Value;
if (trackStream == null)
{
ErrorMessage = $"Can't found file containing {sectorAddress}";
return(false);
}
if (sectorAddress + length > track.TrackEndSector + 1)
{
ErrorMessage = "Can't cross tracks";
return(false);
}
if (data.Length % track.TrackRawBytesPerSector != 0)
{
ErrorMessage = "Incorrect data size";
return(false);
}
// cdrdao audio tracks are endian swapped corresponding to Aaru
if (track.TrackType == TrackType.Audio)
{
byte[] swapped = new byte[data.Length];
for (long i = 0; i < swapped.Length; i += 2)
{
swapped[i] = data[i + 1];
swapped[i + 1] = data[i];
}
data = swapped;
}
uint subchannelSize = (uint)(track.TrackSubchannelType != TrackSubchannelType.None ? 96 : 0);
for (uint i = 0; i < length; i++)
{
trackStream.
Seek((long)(track.TrackFileOffset + (((i + sectorAddress) - track.TrackStartSector) * (ulong)(track.TrackRawBytesPerSector + subchannelSize))),
SeekOrigin.Begin);
trackStream.Write(data, (int)(i * track.TrackRawBytesPerSector), track.TrackRawBytesPerSector);
}
return(true);
}
static void ParseScaleTrack(FileReader reader, Header header, Track track, AnimationGroup group)
{
}
public bool WriteSector(byte[] data, ulong sectorAddress)
{
if (!IsWriting)
{
ErrorMessage = "Tried to write on a non-writable image";
return(false);
}
Track track =
writingTracks.FirstOrDefault(trk => sectorAddress >= trk.TrackStartSector &&
sectorAddress <= trk.TrackEndSector);
if (track is null)
{
ErrorMessage = $"Can't found track containing {sectorAddress}";
return(false);
}
FileStream trackStream = writingStreams.FirstOrDefault(kvp => kvp.Key == track.TrackSequence).Value;
if (trackStream == null)
{
ErrorMessage = $"Can't found file containing {sectorAddress}";
return(false);
}
if (track.TrackBytesPerSector != track.TrackRawBytesPerSector)
{
ErrorMessage = "Invalid write mode for this sector";
return(false);
}
if (data.Length != track.TrackRawBytesPerSector)
{
ErrorMessage = "Incorrect data size";
return(false);
}
// cdrdao audio tracks are endian swapped corresponding to Aaru
if (track.TrackType == TrackType.Audio)
{
byte[] swapped = new byte[data.Length];
for (long i = 0; i < swapped.Length; i += 2)
{
swapped[i] = data[i + 1];
swapped[i + 1] = data[i];
}
data = swapped;
}
trackStream.
Seek((long)(track.TrackFileOffset + ((sectorAddress - track.TrackStartSector) * (ulong)track.TrackRawBytesPerSector)),
SeekOrigin.Begin);
trackStream.Write(data, 0, data.Length);
return(true);
}
// Update is called once per frame
void Update()
{
switch (flow)
{
/////////////////////////about file loading///////////////////////////////
case 0:
switch (fileFlow)
{
//for init sites
case 0:
titles = new List <Title>();
dicLevel_0 = new Dictionary <string, List <Title> >();
dicLevel_1 = new Dictionary <string, List <Title> >();
dicLevel_2 = new Dictionary <string, List <Title> >();
mouseTest = GameObject.Find("Main Camera").GetComponent <MouseTest>();
planes = new GameObject[16];
planeTextures = new List <Texture>();
for (int i = 0; i < 16; i++)
{
planes[i] = GameObject.Find("Plane" + i);
}
//for create drawer
tracks = new List <Track>();
map = GameObject.Find("Directional light").GetComponent <Map>();
fileFlow = 1;
break;
//create monitor
case 1:
monitors = map.monitorCreator(new Vector3(0, 0.05f, 0), 8, 8, 5, monitorPrefab);
fileFlow = 2;
break;
//create planes
case 2:
map.planes = planes;
for (int i = 0; i < map.planes.Length; i++)
{
planeTextures.Add(map.planes[i].GetComponent <Renderer>().material.mainTexture);
}
basicZoom = map.zoom;
fileFlow = 0;
flow = 1;
break;
default:
break;
}
break;
////////////////////////////////////about title///////////////////////////
case 1:
switch (titleFlow)
{
//load title file
case 0:
titleResult = Title.getTitle("files", "Trajectory_1", lineNumber);
lineNumber = (float)titleResult[1];
if (lineNumber != -1)
{
if (((Title)titleResult[0]).latitute <41.0041f && ((Title)titleResult[0]).latitute> 39.3573f && ((Title)titleResult[0]).lontitute <117.6202f && ((Title)titleResult[0]).lontitute> 115.0552f)
{
titles.Add((Title)titleResult[0]);
}
}
else
{
titleFlow = 1;
break;
}
break;
//calculate the center
case 1:
if (number < titles.Count)
{
avgLat += titles[number].latitute;
avgLon += titles[number].lontitute;
number++;
}
else
{
number = 0;
avgLat /= titles.Count;
avgLon /= titles.Count;
titleFlow = 2;
}
break;
//create center and refresh map
case 2:
center = new Position(avgLat, avgLon, new PTime(0));
map.Refresh(center, 4, 4);
titleFlow = 3;
break;
//calculate the titles area
case 3:
if (number < titles.Count)
{
titles[number].getMonitorLevelPosition(center, map.fullLat, map.fullLon);
//for level_0
if (!dicLevel_0.ContainsKey(titles[number].level_0))
{
dicLevel_0.Add(titles[number].level_0, new List <Title>());
dicLevel_0[titles[number].level_0].Add(titles[number]);
}
else
{
dicLevel_0[titles[number].level_0].Add(titles[number]);
}
//for level_1
if (!dicLevel_1.ContainsKey(titles[number].level_1))
{
dicLevel_1.Add(titles[number].level_1, new List <Title>());
dicLevel_1[titles[number].level_1].Add(titles[number]);
}
else
{
dicLevel_1[titles[number].level_1].Add(titles[number]);
}
//for level_2
if (!dicLevel_2.ContainsKey(titles[number].level_2))
{
dicLevel_2.Add(titles[number].level_2, new List <Title>());
dicLevel_2[titles[number].level_2].Add(titles[number]);
}
else
{
dicLevel_2[titles[number].level_2].Add(titles[number]);
}
number++;
}
else
{
number = 0;
flow = 2;
titleFlow = 0;
}
break;
default:
break;
}
break;
////////////////////////////////////about map//////////////////////////
case 2:
switch (mapFlow)
{
//refresh map
case 0:
map.Refresh(center, 4, 4);
mapFlow = 1;
break;
//get planes
case 1:
StartCoroutine(map._Refresh(map.planes[number], map.points[number]));
number++;
if (number >= map.planes.Length)
{
number = 0;
mapFlow = 0;
flow = 3;
}
break;
default:
break;
}
break;
//////////////////////////////////wait and show monitor///////////////////
case 3:
switch (waitFlow)
{
//wait plane texture done
case 0:
planeWaitTime -= Time.deltaTime;
if (planeWaitTime < 0)
{
//to delay some time
planeWaitTime = 1;
for (int i = 0; i < map.planes.Length; i++)
{
if (map.planes[i].GetComponent <Renderer>().material.mainTexture != planeTextures[i])
{
waitFlow = 1;
}
else
{
waitFlow = 0;
StartCoroutine(map._Refresh(map.planes[i], map.points[i]));
break;
}
}
}
break;
//show the monitor area numbers
case 1:
switch (levelNow)
{
case 0:
int temp_0 = 0;
for (int i = 0; i < monitors.Length; i++)
{
temp_0 = i;
if (dicLevel_0.ContainsKey(temp_0.ToString()))
{
monitors[i].transform.FindChild("Area").GetComponent <TextMesh>().text = dicLevel_0[temp_0.ToString()].Count.ToString();
}
else
{
monitors[i].transform.FindChild("Area").GetComponent <TextMesh>().text = "0";
}
}
break;
case 1:
int temp_1 = 0;
for (int i = 0; i < monitors.Length; i++)
{
temp_1 = i;
if (dicLevel_1.ContainsKey(lastLevel_0 + "" + temp_1))
{
monitors[i].transform.FindChild("Area").GetComponent <TextMesh>().text = dicLevel_1[lastLevel_0 + "" + temp_1].Count.ToString();
}
else
{
monitors[i].transform.FindChild("Area").GetComponent <TextMesh>().text = "0";
}
}
break;
//in levelnow = 2
case 2:
break;
default:
Debug.Log("map's zoom level error");
break;
}
waitFlow = 2;
break;
//renew the cache texture and unlock the mouselock
case 2:
for (int i = 0; i < map.planes.Length; i++)
{
planeTextures[i] = map.planes[i].GetComponent <Renderer>().material.mainTexture;
}
mouseTest.mouseLock = true;
waitFlow = 0;
if (levelNow != 2)
{
//just wait
flow = 999;
}
else
{
//show tracks
flow = 400;
}
break;
default:
break;
}
break;
//////////////////////////show tracks//////////////////////////////////
case 400:
foreach (Title title in dicLevel_1[lastLevel_0 + "" + lastLevel_1])
{
tracks.Add(Track.LoadTargetFileLine("files", "Trajectory_1", title.lineNumber));
Debug.Log(title.name);
}
flow = 999;
break;
////////////////////////just wait////////////////////////////////
case 999:
break;
default:
break;
}
}
static void ParseTranslationTrack(FileReader reader, Header header, Track track, AnimationGroup group)
{
return;
switch (track.OpCode)
{
case 0x06:
{
for (int f = 0; f < header.FrameCount; f++)
{
float frame = f;
float[] loc = reader.ReadSingles(3);
group.TranslateX.AddKey(frame, loc[0]);
group.TranslateY.AddKey(frame, loc[1]);
group.TranslateZ.AddKey(frame, loc[2]);
}
}
break;
case 0x08:
{
for (int f = 0; f < header.FrameCount; f++)
{
float frame = f;
float[] loc = reader.ReadHalfSingles(3);
group.TranslateX.AddKey(frame, loc[0]);
group.TranslateY.AddKey(frame, loc[1]);
group.TranslateZ.AddKey(frame, loc[2]);
}
}
break;
case 0x9:
{
uint count = reader.ReadUInt32();
for (int f = 0; f < count; f++)
{
float frame = (f * count) / header.FrameCount;
float[] loc = reader.ReadSingles(3);
group.TranslateX.AddKey(frame, loc[0]);
group.TranslateY.AddKey(frame, loc[1]);
group.TranslateZ.AddKey(frame, loc[2]);
}
}
break;
case 0xA:
{
uint count = reader.ReadUInt16();
for (int f = 0; f < count; f++)
{
float frame = (f * count) / header.FrameCount;
float[] loc = reader.ReadHalfSingles(3);
group.TranslateX.AddKey(frame, loc[0]);
group.TranslateY.AddKey(frame, loc[1]);
group.TranslateZ.AddKey(frame, loc[2]);
}
}
break;
case 0xB:
{
float[] loc = reader.ReadSingles(3);
group.TranslateX.AddKey(0, loc[0]);
group.TranslateY.AddKey(0, loc[1]);
group.TranslateZ.AddKey(0, loc[2]);
}
break;
case 0xC:
{
float[] loc = reader.ReadHalfSingles(3);
group.TranslateX.AddKey(0, loc[0]);
group.TranslateY.AddKey(0, loc[1]);
group.TranslateZ.AddKey(0, loc[2]);
}
break;
case 0xD:
{
uint axis = reader.ReadUInt32();
var unk = reader.ReadBytes(8);
uint count = reader.ReadUInt32();
for (int f = 0; f < count; f++)
{
float frame = (f * count) / header.FrameCount;
float value = reader.ReadSingle();
var loc = new Vector3(0, 0, 0);
if (axis == 0)
{
loc = new Vector3(value, 0, 0);
}
else if (axis == 1)
{
loc = new Vector3(0, value, 0);
}
else if (axis == 2)
{
loc = new Vector3(0, 0, value);
}
group.TranslateX.AddKey(0, loc.X);
group.TranslateY.AddKey(0, loc.Y);
group.TranslateZ.AddKey(0, loc.Z);
}
}
break;
case 0xE:
{
uint unk1 = reader.ReadUInt32();
ushort unk2 = reader.ReadUInt16();
ushort count = reader.ReadUInt16();
for (int f = 0; f < count; f++)
{
float frame = (f * count) / header.FrameCount;
float positionX = reader.ReadHalfSingle();
var loc = new Vector3(positionX, 0, 0);
group.TranslateX.AddKey(0, loc.X);
group.TranslateY.AddKey(0, loc.Y);
group.TranslateZ.AddKey(0, loc.Z);
}
}
break;
}
}
public TrackViewModel(Track track)
{
Track = track;
}
protected override async Task DoWorkAsync(CancellationToken cancellationToken)
{
try
{
Console.WriteLine("Voice Channel Worker Connecting");
var audioClient = await _voiceChannel.ConnectAsync();
using var audioOutStream = audioClient.CreatePCMStream(AudioApplication.Music);
_ = Task.Run(() => _assistantManager(cancellationToken));
_mainTrack = new Track();
_mainTrack.OnClipCompleted += async(s, e) =>
{
if (_mainTrack.Playlist.Count == 0)
{
_mainTrack.Enqueue(new FFmpegClip(await _getNextAsync()));
}
};
_mainTrack.Enqueue(new FFmpegClip(await _getNextAsync()));
await _mainTrack.PrepareAsync();
_ttsTrack = new Track();
await _ttsTrack.PrepareAsync();
await using var mainTrack = _mainTrack.SetVolume(Program.SoundVolume / 100f);
await mainTrack.PrepareAsync();
await using var ttsTrack = _ttsTrack.SetVolume(Program.VoiceAssistantVolume / 100f);
await ttsTrack.PrepareAsync();
await using var mixTrack = new MixedTrack(mainTrack, ttsTrack);
await mixTrack.PrepareAsync();
while (!cancellationToken.IsCancellationRequested)
{
var blockSize = 2880;
var buffer = new byte[blockSize];
var byteCount = await mixTrack.ReadAsync(buffer, 0, blockSize, cancellationToken);
if (byteCount == 0)
{
await Task.Delay(TimeSpan.FromMilliseconds(50));
continue;
}
cancellationToken.ThrowIfCancellationRequested();
await audioOutStream.WriteAsync(buffer, 0, byteCount, cancellationToken);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
finally
{
Console.WriteLine("Voice Channel Worker Disconnecting");
await _voiceChannel.DisconnectAsync();
}
}
public FileManager(UserSettings userSettings, Track track)
{
_userSettings = userSettings;
_track = track;
}
public void SetValue_Should_Not_Cause_StackOverflow(bool useXamlBinding)
{
var viewModel = new TestStackOverflowViewModel()
{
Value = 50
};
Track track = null;
var target = new TestRange()
{
Template = new FuncControlTemplate <RangeBase>(c =>
{
track = new Track()
{
Width = 100,
Orientation = Orientation.Horizontal,
[~~Track.MinimumProperty] = c[~~RangeBase.MinimumProperty],
[~~Track.MaximumProperty] = c[~~RangeBase.MaximumProperty],
Name = "PART_Track",
Thumb = new Thumb()
};
if (useXamlBinding)
{
track.Bind(Track.ValueProperty, new Binding("Value")
{
Mode = BindingMode.TwoWay,
Source = c,
Priority = BindingPriority.Style
});
}
else
{
track[~~Track.ValueProperty] = c[~~RangeBase.ValueProperty];
}
return(track);
}),
Minimum = 0,
Maximum = 100,
DataContext = viewModel
};
target.Bind(TestRange.ValueProperty, new Binding("Value")
{
Mode = BindingMode.TwoWay
});
target.ApplyTemplate();
track.Measure(new Size(100, 0));
track.Arrange(new Rect(0, 0, 100, 0));
Assert.Equal(1, viewModel.SetterInvokedCount);
// Issues #855 and #824 were causing a StackOverflowException at this point.
target.Value = 51.001;
Assert.Equal(2, viewModel.SetterInvokedCount);
double expected = 51;
Assert.Equal(expected, viewModel.Value);
Assert.Equal(expected, target.Value);
Assert.Equal(expected, track.Value);
}
/*public Key[] getContextSelectionKeys() {
* List<Key> keys = new List<Key>();
* foreach(Key key in getSelectedTrack().keys) {
* for(int i=0;i<contextSelection.Count;i+=2) {
* // if selection start frame > frame, break out of sorted list
* if(contextSelection[i] > key.frame) break;
* if(contextSelection[i] <= key.frame && contextSelection[i+1] >= key.frame) keys.Add(key);
* }
* }
* return keys.ToArray();
* }*/
// offset context selection frames by an amount. can be positive or negative
//returns keys that are to be deleted
public Key[] offsetContextSelectionFramesBy(Take take, ITarget itarget, int offset)
{
if (offset == 0)
{
return(new Key[0]);
}
if (contextSelection.Count <= 0)
{
return(new Key[0]);
}
List <Key> rkeys = new List <Key>();
List <Key> keysToDelete = new List <Key>();
foreach (int track_id in contextSelectionTrackIds)
{
bool shouldUpdateCache = false;
Track _track = take.getTrack(track_id);
foreach (Key key in _track.keys)
{
for (int i = 0; i < contextSelection.Count; i += 2)
{
// move context selection
if (contextSelection[i] <= key.frame && contextSelection[i + 1] >= key.frame)
{
// if there is already a key in the new frame position, mark for deletion
bool keyToOverwriteInContextSelection = false;
if (_track.hasKeyOnFrame(key.frame + offset))
{
// check if the key is in the selection
for (int j = 0; j < contextSelection.Count; j += 2)
{
if (contextSelection[j] <= (key.frame + offset) && contextSelection[j + 1] >= (key.frame + offset))
{
keyToOverwriteInContextSelection = true;
break;
}
}
// if not key is not in selection, mark for deletion
if (!keyToOverwriteInContextSelection)
{
keysToDelete.Add(_track.getKeyOnFrame(key.frame + offset));
}
}
key.frame += offset;
if (!shouldUpdateCache)
{
shouldUpdateCache = true;
}
break;
}
}
}
// delete keys that were overwritten
foreach (Key key in keysToDelete)
{
_track.keys.Remove(key);
rkeys.Add(key);
}
keysToDelete.Clear();
// update cache
if (shouldUpdateCache)
{
_track.updateCache(itarget);
}
}
// update context selection
for (int i = 0; i < contextSelection.Count; i++)
{
// move context selection
contextSelection[i] += offset;
}
// clear ghost selection
ghostSelection = new List <int>();
return(rkeys.ToArray());
}
public void SetTrackInfo(int lapsNumber, int trackLength)
{
this.track = new Track(lapsNumber, trackLength);
}
public Track Add(Track newTrack)
{
_context.Track.Add(newTrack);
_context.SaveChanges();
return(newTrack);
}
internal void SynchronizeSingleTrack(Track track)
{
_syncUtil.ManifestUtil.ProgressUtil.SongsToDownload = 1;
_syncUtil.FinalizePropertiesForTrack(track);
_syncUtil.DownloadUtil.DownloadTrackAndTag(ref track);
}
public PlaylistTrack AddTrackToPlaylist(Playlist playlist, Track track)
{
return(playlist.AddTrack(track.Id, _trackRepository));
}
/// <summary>
/// Creates a chapter off a single audio file and initializes
/// the metadata with the track's metadata.
/// </summary>
/// <param name="track">Track to reference</param>
internal Chapter(Track track)
{
AudioPath = new AudioPath(track.Path);
Metadata = new ChapterMetadata(track);
}
public virtual bool CanCreate(Track track, Staff staff)
{
return(!HideOnPercussionTrack || staff.StaffKind != StaffKind.Percussion);
}
public void addTrack(Track track)
{
track.song = this;
tracks.Add(track);
}
