private void DrawWaveForm()
{
ClearPanels();
ClearLabels();
lblFileName.Invoke(new MethodInvoker(() => lblFileName.Text = "Analysis of audio file: " + (Parser.Songs == null ? Path.GetFileName(InputFile) : Parser.Songs[0].InternalName + ".mogg")));
var BassStream = Bass.BASS_StreamCreateFile(Tools.GetOggStreamIntPtr(), 0L, Tools.PlayingSongOggData.Length, BASSFlag.BASS_STREAM_DECODE);
if (BassStream == 0)
{
MessageBox.Show("Error processing audio stream:\n" + Bass.BASS_ErrorGetCode(), Text, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
var length = Bass.BASS_ChannelGetLength(BassStream);
var duration = Math.Round(Bass.BASS_ChannelBytes2Seconds(BassStream, length), 2);
var audio_info = Bass.BASS_ChannelGetInfo(BassStream);
string size;
if (Tools.PlayingSongOggData.Length >= 1048576)
{
size = Math.Round((double)Tools.PlayingSongOggData.Length / 1048576, 2) + " MB";
}
else
{
size = Math.Round((double)Tools.PlayingSongOggData.Length / 1024, 2) + " KB";
}
var minutes = Parser.GetSongDuration((duration * 1000).ToString(CultureInfo.InvariantCulture));
lblStart.Invoke(new MethodInvoker(() => lblStart.Text = "0:00"));
lblLength.Invoke(new MethodInvoker(() => lblLength.Text = minutes));
var info = "Channels: " + audio_info.chans + " | Sample rate: " + audio_info.freq + " Hz | Length: " + duration + " seconds ("
+ minutes + ") | File size: " + Tools.PlayingSongOggData.Length + " bytes (" + size + ")";
lblFileInfo.Invoke(new MethodInvoker(() => lblFileInfo.Text = info));
WaveForm WaveImage;
switch (audio_info.chans)
{
case 1:
WaveImage = GetNewWaveForm(false);
if (!WaveImage.RenderStart(BassStream, false, true))
{
MessageBox.Show("Error rendering audio stream:\n" + Bass.BASS_ErrorGetCode(), Text, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
ClearPanels();
return;
}
panelWave.BackgroundImage = WaveImage.CreateBitmap(WaveWidth, WaveHeight, -1, -1, highQualityDrawing.Checked);
break;
case 2:
WaveImage = GetNewWaveForm(true);
if (!WaveImage.RenderStart(BassStream, false, true))
{
MessageBox.Show("Error rendering audio stream:\n" + Bass.BASS_ErrorGetCode(), Text, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
ClearPanels();
return;
}
panelWave.BackgroundImage = WaveImage.CreateBitmap(WaveWidth, WaveHeight, -1, -1, highQualityDrawing.Checked);
break;
default:
try
{
List <string> TrackNames;
List <bool> TrackIsStereo;
var splitter = new MoggSplitter();
var ArrangedChannels = splitter.ArrangeStreamChannels(audio_info.chans, Path.GetExtension(InputFile) != ".wav");
GetTrackNames(out TrackNames, out TrackIsStereo);
var height = WaveHeight / audio_info.chans;
var top = 0;
var index = 0;
var maxCount = TrackNames.Any() ? TrackNames.Count : audio_info.chans;
for (var i = 0; i < maxCount; i++)
{
var multiplier = TrackIsStereo.Any() && TrackIsStereo[i] ? 2 : 1;
var panel = new Panel();
Invoke(new MethodInvoker(delegate { panel.Parent = panelWave; }));
panel.Invoke(new MethodInvoker(() => panel.Left = -1));
panel.Invoke(new MethodInvoker(() => panel.Top = top - 1));
panel.Invoke(new MethodInvoker(() => panel.Width = WaveWidth + 2));
panel.Invoke(new MethodInvoker(() => panel.Height = (height * multiplier) + 1));
panel.Invoke(new MethodInvoker(() => panel.BackgroundImageLayout = ImageLayout.Stretch));
panel.Invoke(new MethodInvoker(() => panel.Anchor = AnchorStyles.Left | AnchorStyles.Top | AnchorStyles.Right));
if (outlineAudioTracks.Checked && i < maxCount - 1)
{
panel.Invoke(new MethodInvoker(() => panel.BorderStyle = BorderStyle.FixedSingle));
}
var map = TrackIsStereo.Any() && TrackIsStereo[i] ? new[] { ArrangedChannels[index], ArrangedChannels[index + 1], -1 } :
new[] { ArrangedChannels[index], -1 };
var channel_stream = BassMix.BASS_Split_StreamCreate(BassStream, BASSFlag.BASS_STREAM_DECODE, map);
WaveImage = GetNewWaveForm(TrackIsStereo.Any() && TrackIsStereo[i]);
if (!WaveImage.RenderStart(channel_stream, false, true))
{
MessageBox.Show("Error rendering audio stream:\n" + Bass.BASS_ErrorGetCode(), Text, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
ClearPanels();
ClearLabels();
return;
}
var endFrame = WaveImage.Position2Frames((length / audio_info.chans) * multiplier);
panel.BackgroundImage = WaveImage.CreateBitmap(WaveWidth, height * multiplier, -1, endFrame, highQualityDrawing.Checked);
var font = new Font("Times New Roman", 10f, FontStyle.Bold);
var label = new Label();
Invoke(new MethodInvoker(delegate { label.Parent = panel; }));
label.Invoke(new MethodInvoker(() => label.Visible = labelAudioChannels.Checked));
label.Invoke(new MethodInvoker(() => label.Location = new Point(3, 3)));
label.Invoke(new MethodInvoker(() => label.BackColor = Color.Transparent));
label.Invoke(new MethodInvoker(() => label.ForeColor = Color.White));
label.Invoke(new MethodInvoker(() => label.Font = font));
label.Invoke(new MethodInvoker(() => label.Text = TrackNames.Count > 0 ? TrackNames[i] : "chan. " + i));
ChannelLabels.Add(label);
Bass.BASS_StreamFree(channel_stream);
ChannelPanels.Add(panel);
top += (height * multiplier);
index += multiplier;
}
}
catch (Exception ex)
{
MessageBox.Show("Error rendering audio stream:\n" + ex.Message + "\n\n" + Bass.BASS_ErrorGetCode(), Text, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
ClearPanels();
ClearLabels();
return;
}
break;
}
Bass.BASS_StreamFree(BassStream);
if (InputFiles.Count <= 1)
{
return;
}
var file = Path.GetDirectoryName(InputFile) + "\\" + Tools.CleanString(Path.GetFileNameWithoutExtension(InputFile), false) + ".jpg";
TakeScreenshot(file);
}
private void backgroundWorker1_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
{
var rb1 = 0;
var rb2 = 0;
var rb3 = 0;
var rb4 = 0;
var rb4_dlc = 0;
var dlc = 0;
var rbn1 = 0;
var rbn2 = 0;
var greenday = 0;
var beatles = 0;
var acdc = 0;
var customs = 0;
var lego = 0;
var ratingff = 0;
var ratingm = 0;
var ratingsr = 0;
var male = 0;
var female = 0;
var master = 0;
var live = 0;
var rhythm = 0;
var doublebass = 0;
var rb3vers = 0;
var drums = 0;
var guitar = 0;
var proguitar = 0;
var bass = 0;
var probass = 0;
var keys = 0;
var prokeys = 0;
var vocals = 0;
var harm2 = 0;
var harm3 = 0;
var min2 = 0;
var min2to4 = 0;
var min4to6 = 0;
var min6to8 = 0;
var min8to10 = 0;
var min10plus = 0;
long shortest = 0;
var shortestsong = "";
long longest = 0;
var longestsong = "";
var topartists = new List <string>();
var featured = 0;
var rerecord = 0;
var before50s = 0;
var the50s = 0;
var the60s = 0;
var the70s = 0;
var the80s = 0;
var the90s = 0;
var the00s = 0;
var the10s = 0;
var oldest = 0;
var newest = 0;
var singles = 0;
var warmup = 0;
var apprentice = 0;
var solid = 0;
var moderate = 0;
var challenging = 0;
var nightmare = 0;
var impossible = 0;
var artists = new List <string>();
var albums = new List <string>();
var all_artists = new List <string>();
var proguitartuning = 0;
var probasstuning = 0;
foreach (var song in Songs)
{
if (!string.IsNullOrWhiteSpace(song.ProGuitarTuning) && song.ProGuitarDiff > 0)
{
proguitartuning++;
}
if (!string.IsNullOrWhiteSpace(song.ProBassTuning) && song.ProBassDiff > 0)
{
probasstuning++;
}
switch (song.BandDiff)
{
case 1:
warmup++;
break;
case 2:
apprentice++;
break;
case 3:
solid++;
break;
case 4:
moderate++;
break;
case 5:
challenging++;
break;
case 6:
nightmare++;
break;
case 7:
impossible++;
break;
}
switch (song.GetSource())
{
case "RB1":
rb1++;
break;
case "RB2":
rb2++;
break;
case "RB3":
rb3++;
break;
case "RB4":
rb4++;
break;
case "RBN1":
rbn1++;
break;
case "RBN2":
rbn2++;
break;
case "DLC":
if (song.Source == "rb4_dlc")
{
rb4_dlc++;
}
else
{
dlc++;
}
break;
case "TBRB":
beatles++;
break;
case "GDRB":
greenday++;
break;
case "Lego":
lego++;
break;
case "AC/DC":
acdc++;
break;
case "Custom":
customs++;
break;
}
switch (song.Rating)
{
case 1:
ratingff++;
break;
case 2:
ratingsr++;
break;
case 3:
ratingm++;
break;
}
switch (song.GetGender())
{
case "Female":
female++;
break;
case "Male":
male++;
break;
}
if (song.Master)
{
master++;
}
var name = song.Name.ToLowerInvariant();
if (name.Contains("rhythm") && (name.Contains("guitar") || name.Contains("version")))
{
rhythm++;
}
if (name.Contains("(live)"))
{
live++;
}
if (name.Contains("rb3 version"))
{
rb3vers++;
}
if (name.Contains("2x") && (name.Contains("bass") || name.Contains("pedal")))
{
doublebass++;
}
if (song.DrumsDiff > 0)
{
drums++;
}
if (song.BassDiff > 0)
{
bass++;
}
if (song.ProBassDiff > 0)
{
probass++;
}
if (song.GuitarDiff > 0)
{
guitar++;
}
if (song.ProGuitarDiff > 0)
{
proguitar++;
}
if ((song.KeysDiff > 0 && song.ProKeysDiff > 0) || (song.KeysDiff > 0 && (!name.Contains("rhythm"))))
{
keys++; //don't count rhythm on keys as "keys"
}
if (song.ProKeysDiff > 0)
{
prokeys++;
}
if (song.VocalsDiff > 0)
{
switch (song.VocalParts)
{
case 1:
vocals++;
break;
case 2:
harm2++;
break;
case 3:
harm3++;
break;
}
}
if (song.Length < shortest || shortest == 0)
{
shortest = song.Length;
shortestsong = song.Artist + " - " + song.Name;
}
else if (song.Length > longest)
{
longest = song.Length;
longestsong = song.Artist + " - " + song.Name;
}
if (song.Length <= 120000) //2 min
{
min2++;
}
else if (song.Length > 120000 && song.Length <= 240000) //2 min to 4 min
{
min2to4++;
}
else if (song.Length > 240000 && song.Length < 360000) //4 min to 6 min
{
min4to6++;
}
else if (song.Length > 360000 && song.Length <= 480000) //6 min to 8 min
{
min6to8++;
}
else if (song.Length > 480000 && song.Length <= 600000) //8 min to 10 min
{
min8to10++;
}
else if (song.Length > 600000) //over 10 min
{
min10plus++;
}
if (CleanName(song.Name, true).Contains("ft.") || CleanName(song.Artist, true).Contains("ft."))
{
featured++;
}
if (song.YearRecorded > song.YearReleased)
{
rerecord++;
}
var year = song.YearRecorded == 0 ? song.YearReleased : song.YearRecorded;
if (year < 1950)
{
before50s++;
}
else if (year >= 1950 && year < 1960)
{
the50s++;
}
else if (year >= 1960 && year < 1970)
{
the60s++;
}
else if (year >= 1970 && year < 1980)
{
the70s++;
}
else if (year >= 1980 && year < 1990)
{
the80s++;
}
else if (year >= 1990 && year < 2000)
{
the90s++;
}
else if (year >= 2000 && year < 2010)
{
the00s++;
}
else if (year > 2010)
{
the10s++;
}
if (year > newest)
{
newest = year;
}
if (year < oldest || oldest == 0)
{
oldest = year;
}
if (string.IsNullOrWhiteSpace(song.Album))
{
singles++;
}
//unique artists
if (!artists.Contains(CleanName(song.Artist).ToLowerInvariant()))
{
artists.Add(CleanName(song.Artist).ToLowerInvariant());
}
//unique albums
if (!albums.Contains(song.Album.ToLowerInvariant()))
{
albums.Add(song.Album.ToLowerInvariant());
}
//all artists for counting later
all_artists.Add(CleanName(song.Artist));
}
var mostsongs = 0;
foreach (var artist in all_artists)
{
var count = all_artists.Count(s => artist.ToLowerInvariant().Contains(s.ToLowerInvariant()));
if (count == mostsongs && !topartists.Contains(artist))
{
topartists.Add(artist);
mostsongs = count;
}
else if (count > mostsongs)
{
topartists.Clear();
topartists.Add(artist);
mostsongs = count;
}
}
//dynamically grab only the genres that are present and count them
//rather than hardcoding all 30 possible Genres
var genres = (from song in Songs where song.Genre != "" select song.Genre).ToList();
genres.Sort();
var Genres = new List <Genres>();
foreach (var genre in genres)
{
var exists = false;
var genre1 = genre;
foreach (var gen in Genres.Where(gen => gen.Name == genre1))
{
exists = true;
gen.Count++;
break;
}
if (exists || string.IsNullOrWhiteSpace(genre))
{
continue;
}
Genres.Add(new Genres());
Genres[Genres.Count - 1].Count = 1;
Genres[Genres.Count - 1].Name = genre;
}
var limit = ActiveConsole == "Wii" ? 952 : 2952;
var isRB4 = ActiveConsole == "PS4" || ActiveConsole == "Xbox One";
var Duplicates = FindDuplicates();
//duplicates include all instances, for every two songs one is unique, one is not
Duplicates = Duplicates % 2 == 0 ? (Duplicates / 2) : ((Duplicates / 2) + 1);
AddInfo("Setlist Name", ActiveSetlist);
AddInfo("Console", ActiveConsole);
AddInfo("Game", isRB4 ? "Rock Band 4" : (isBlitzCache? "Rock Band: Blitz" : "Rock Band 3"));
if (!isBlitzCache && !isRB4)
{
AddInfo("Song Limit", limit.ToString(CultureInfo.InvariantCulture));
}
AddInfo("Songs in Setlist", Songs.Count.ToString(CultureInfo.InvariantCulture));
if (ActiveConsole != "PS3" && !isRB4)
{
AddInfo("Packages in Cache", CachePackages.ToString(CultureInfo.InvariantCulture));
}
AddInfo("Unique Artists", artists.Count.ToString(CultureInfo.InvariantCulture));
AddInfo("Unique Songs", (Songs.Count - Duplicates).ToString(CultureInfo.InvariantCulture));
AddInfo("Duplicate Songs", Duplicates.ToString(CultureInfo.InvariantCulture));
AddInfo("", "");
AddInfo("Songs by Source", "");
AddInfo("Rock Band 1", rb1 + GetPercent(rb1));
AddInfo("Rock Band 2", rb2 + GetPercent(rb2));
AddInfo("Rock Band 3", rb3 + GetPercent(rb3));
if (isRB4)
{
AddInfo("Rock Band 4", rb4 + GetPercent(rb4));
AddInfo("Pre-RB4 DLC", dlc + GetPercent(dlc));
AddInfo("RB4 DLC", rb4_dlc + GetPercent(rb4_dlc));
}
else
{
AddInfo("Official DLC", dlc + GetPercent(dlc));
}
AddInfo("Rock Band Network 1", rbn1 + GetPercent(rbn1));
AddInfo("Rock Band Network 2", rbn2 + GetPercent(rbn2));
AddInfo("Lego Rock Band", lego + GetPercent(lego));
AddInfo("AC/DC Track Pack", acdc + GetPercent(acdc));
AddInfo("Green Day: Rock Band", greenday + GetPercent(greenday));
if (!isRB4)
{
AddInfo("The Beatles: Rock Band", beatles + GetPercent(beatles));
AddInfo("Customs", customs + GetPercent(customs));
}
AddInfo("", "");
AddInfo("Songs by Instruments", "");
AddInfo("Guitar", guitar + GetPercent(guitar));
if (!isRB4)
{
AddInfo("Pro Guitar", proguitar + GetPercent(proguitar));
}
AddInfo("Bass", bass + GetPercent(bass));
if (!isRB4)
{
AddInfo("Pro Bass", probass + GetPercent(probass));
}
AddInfo("Drums", drums + GetPercent(drums));
if (!isRB4)
{
AddInfo("Keys", keys + GetPercent(keys));
AddInfo("Pro Keys", prokeys + GetPercent(prokeys));
}
AddInfo("1 Part Vocals", vocals + GetPercent(vocals));
AddInfo("2 Part Harmonies", harm2 + GetPercent(harm2));
AddInfo("3 Part Harmonies", harm3 + GetPercent(harm3));
AddInfo("", "");
AddInfo("Songs by Difficulty", "");
AddInfo("Warmup", warmup + GetPercent(warmup));
AddInfo("Apprentice", apprentice + GetPercent(apprentice));
AddInfo("Solid", solid + GetPercent(solid));
AddInfo("Moderate", moderate + GetPercent(moderate));
AddInfo("Challenging", challenging + GetPercent(challenging));
AddInfo("Nightmare", nightmare + GetPercent(nightmare));
AddInfo("Impossible", impossible + GetPercent(impossible));
AddInfo("", "");
AddInfo("Songs by Genre", "");
foreach (var genre in Genres)
{
AddInfo(genre.Name, genre.Count + GetPercent(genre.Count));
}
//following metrics are not available in Blitz cache files
if (!isBlitzCache)
{
AddInfo("", "");
AddInfo("Songs by Duration", "");
AddInfo("Shortest Song", shortestsong);
AddInfo("Shortest Song", Parser.GetSongDuration(shortest.ToString(CultureInfo.InvariantCulture)));
AddInfo("Longest Song", longestsong);
AddInfo("Longest Song", Parser.GetSongDuration(longest.ToString(CultureInfo.InvariantCulture)));
AddInfo("2:00 or Less", min2 + GetPercent(min2));
AddInfo("2:01 to 4:00", min2to4 + GetPercent(min2to4));
AddInfo("4:01 to 6:00", min4to6 + GetPercent(min4to6));
AddInfo("6:01 to 8:00", min6to8 + GetPercent(min6to8));
AddInfo("8:01 to 10:00", min8to10 + GetPercent(min8to10));
AddInfo("10:01 or More", min10plus + GetPercent(min10plus));
AddInfo("", "");
AddInfo("Songs by Rating", "");
AddInfo("Family Friendly", ratingff + GetPercent(ratingff));
AddInfo("Supervision Recommended", ratingsr + GetPercent(ratingsr));
AddInfo("Mature", ratingm + GetPercent(ratingm));
AddInfo("Not Rated", (Songs.Count - ratingff - ratingm - ratingsr) + GetPercent(Songs.Count - ratingff - ratingm - ratingsr));
AddInfo("", "");
AddInfo("Songs by Lead Singer", "");
AddInfo("Feminine", female + GetPercent(female));
AddInfo("Masculine", male + GetPercent(male));
AddInfo("N/A (Instrumental)", (Songs.Count - male - female) + GetPercent(Songs.Count - male - female));
}
AddInfo("", "");
AddInfo("Songs by Type", "");
if (!isBlitzCache)
{
AddInfo("Master", master + GetPercent(master));
AddInfo("Cover", (Songs.Count - master) + GetPercent(Songs.Count - master));
}
AddInfo("Single", singles + GetPercent(singles));
AddInfo("Re-Record", rerecord + GetPercent(rerecord));
AddInfo("Live", live + GetPercent(live));
AddInfo("RB3 Version", rb3vers + GetPercent(rb3vers));
if (!isRB4)
{
AddInfo("2X Bass Pedal", doublebass + GetPercent(doublebass));
AddInfo("Rhythm Version", rhythm + GetPercent(rhythm));
}
AddInfo("", "");
AddInfo("Songs by Decade", "");
AddInfo("Oldest Song", oldest.ToString(CultureInfo.InvariantCulture));
AddInfo("Newest Song", newest.ToString(CultureInfo.InvariantCulture));
AddInfo("Before 1950", before50s + GetPercent(before50s));
AddInfo("The 50s (1950-1959)", the50s + GetPercent(the50s));
AddInfo("The 60s (1960-1969)", the60s + GetPercent(the60s));
AddInfo("The 70s (1970-1979)", the70s + GetPercent(the70s));
AddInfo("The 80s (1980-1989)", the80s + GetPercent(the80s));
AddInfo("The 90s (1990-1999)", the90s + GetPercent(the90s));
AddInfo("The 00s (2000-2009)", the00s + GetPercent(the00s));
AddInfo("The 10s (2010+)", the10s + GetPercent(the10s));
AddInfo("", "");
AddInfo("Other Metrics", "");
AddInfo("Most Songs by an Artist", mostsongs + GetPercent(mostsongs));
foreach (var artist in topartists)
{
AddInfo(topartists.Count > 1? "Artists" : "Artist" + " With Most Songs", artist);
}
AddInfo("Unique Albums", albums.Count + GetPercent(albums.Count));
AddInfo("Songs With Featured Artists", featured + GetPercent(featured));
if (!isRB4)
{
AddInfo("Songs With Pro Guitar Tuning", proguitartuning + GetPercent(proguitartuning));
AddInfo("Songs With Pro Bass Tuning", probasstuning + GetPercent(probasstuning));
}
}
