Add parsing in of cuesheets

DICUI.Library/CueSheets/CueFile.cs

@@ -1,10 +1,10 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
+using System.IO;
 
 /// <remarks>
 /// Information sourced from http://web.archive.org/web/20070221154246/http://www.goldenhawk.com/download/cdrwin.pdf
 /// </remarks>
-namespace DICUI.Library.CueSheets
+namespace DICUI.CueSheets
 {
     /// <summary>
     /// The audio or data file’s filetype
@@ -45,7 +45,7 @@ namespace DICUI.Library.CueSheets
         /// <summary>
         /// filename
         /// </summary>
-        public string Name { get; set; }
+        public string FileName { get; set; }
 
         /// <summary>
         /// filetype
@@ -56,5 +56,94 @@ namespace DICUI.Library.CueSheets
         /// List of TRACK in FILE
         /// </summary>
         public List<CueTrack> Tracks { get; set; }
+
+        /// <summary>
+        /// Create an empty FILE
+        /// </summary>
+        public CueFile()
+        {
+        }
+
+        /// <summary>
+        /// Fill a FILE from a stream reader
+        /// </summary>
+        /// <param name="fileName">File name to set</param>
+        /// <param name="fileType">File type to set</param>
+        /// <param name="sr">StreamReader to pull from</param>
+        public CueFile(string fileName, string fileType, StreamReader sr)
+        {
+            if (sr == null)
+                return;
+
+            // Set the current fields
+            this.FileName = fileName;
+            this.FileType = GetFileType(fileType);
+
+            while (!sr.EndOfStream)
+            {
+                string line = sr.ReadLine().Trim();
+                string[] splitLine = line.Split(' ');
+
+                // If we have an empty line, we skip
+                if (string.IsNullOrWhiteSpace(line))
+                    continue;
+
+                switch (splitLine[0])
+                {
+                    // Read comments
+                    case "REM":
+                        // We ignore all comments for now
+                        break;
+
+                    // Read track information
+                    case "TRACK":
+                        if (splitLine.Length < 3)
+                            continue; // TODO: Make this throw an exception
+
+                        if (this.Tracks == null)
+                            this.Tracks = new List<CueTrack>();
+
+                        var track = new CueTrack(splitLine[1], splitLine[2], sr);
+                        if (track == default)
+                            continue; // TODO: Make this throw an exception
+
+                        this.Tracks.Add(track);
+                        break;
+
+                    // Default means return
+                    default:
+                        return;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get the file type from a given string
+        /// </summary>
+        /// <param name="fileType">String to get value from</param>
+        /// <returns>CueFileType, if possible (default BINARY)</returns>
+        private CueFileType GetFileType(string fileType)
+        {
+            switch (fileType.ToLowerInvariant())
+            {
+                case "binary":
+                    return CueFileType.BINARY;
+
+                case "motorola":
+                    return CueFileType.MOTOROLA;
+
+                case "aiff":
+                    return CueFileType.AIFF;
+
+                case "wave":
+                    return CueFileType.WAVE;
+
+                case "mp3":
+                    return CueFileType.MP3;
+
+                default:
+                    return CueFileType.BINARY;
+            }
+        }
     }
 }

DICUI.Library/CueSheets/CueIndex.cs

@@ -1,7 +1,9 @@
-/// <remarks>
+using System.Linq;
+
+/// <remarks>
 /// Information sourced from http://web.archive.org/web/20070221154246/http://www.goldenhawk.com/download/cdrwin.pdf
 /// </remarks>
-namespace DICUI.Library.CueSheets
+namespace DICUI.CueSheets
 {
     /// <summary>
     /// Represents a single INDEX in a TRACK
@@ -9,25 +11,86 @@ namespace DICUI.Library.CueSheets
     public class CueIndex
     {
         /// <summary>
-        /// number, between 0 and 99
+        /// INDEX number, between 0 and 99
         /// </summary>
         public int Index { get; set; }
 
         /// <summary>
-        /// Starting time of index in minutes
+        /// Starting time of INDEX in minutes
         /// </summary>
         public int Minutes { get; set; }
 
         /// <summary>
-        /// Starting time of index in seconds
+        /// Starting time of INDEX in seconds
         /// </summary>
         /// <remarks>There are 60 seconds in a minute</remarks>
         public int Seconds { get; set; }
 
         /// <summary>
-        /// Starting time of index in frames.
+        /// Starting time of INDEX in frames.
         /// </summary>
         /// <remarks>There are 75 frames per second</remarks>
         public int Frames { get; set; }
+
+        /// <summary>
+        /// Create an empty INDEX
+        /// </summary>
+        public CueIndex()
+        {
+        }
+
+        /// <summary>
+        /// Fill a INDEX from a stream reader
+        /// </summary>
+        /// <param name="index">Index to set</param>
+        /// <param name="startTime">Start time to set</param>
+        public CueIndex(string index, string startTime)
+        {
+            // Set the current fields
+            if (!int.TryParse(index, out int parsedIndex))
+                return; // TODO: Make this throw an exception
+            else if (parsedIndex < 1 || parsedIndex > 99)
+                return; // TODO: Make this throw an exception
+
+            // Ignore empty lines
+            if (string.IsNullOrWhiteSpace(startTime))
+                return; // TODO: Make this throw an exception
+
+            // Ignore lines that don't contain the correct information
+            if (startTime.Length != 8 || startTime.Count(c => c == ':') != 2)
+                return; // TODO: Make this throw an exception
+
+            // Split the line
+            string[] splitTime = startTime.Split(':');
+            if (splitTime.Length != 3)
+                return; // TODO: Make this throw an exception
+
+            // Parse the lengths
+            int[] lengthSegments = new int[3];
+
+            // Minutes
+            if (!int.TryParse(splitTime[0], out lengthSegments[0]))
+                return; // TODO: Make this throw an exception
+            else if (lengthSegments[0] < 0)
+                return; // TODO: Make this throw an exception
+
+            // Seconds
+            if (!int.TryParse(splitTime[1], out lengthSegments[1]))
+                return; // TODO: Make this throw an exception
+            else if (lengthSegments[1] < 0 || lengthSegments[1] > 60)
+                return; // TODO: Make this throw an exception
+
+            // Frames
+            if (!int.TryParse(splitTime[2], out lengthSegments[2]))
+                return; // TODO: Make this throw an exception
+            else if (lengthSegments[2] < 0 || lengthSegments[2] > 75)
+                return; // TODO: Make this throw an exception
+
+            // Set the values
+            this.Index = parsedIndex;
+            this.Minutes = lengthSegments[0];
+            this.Seconds = lengthSegments[1];
+            this.Frames = lengthSegments[2];
+        }
     }
 }

DICUI.Library/CueSheets/CueSheet.cs

@@ -1,13 +1,11 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using System.IO;
 
 /// <remarks>
 /// Information sourced from http://web.archive.org/web/20070221154246/http://www.goldenhawk.com/download/cdrwin.pdf
 /// </remarks>
-namespace DICUI.Library.CueSheets
+namespace DICUI.CueSheets
 {
     /// <summary>
     /// Represents a single cuesheet
@@ -43,5 +41,108 @@ namespace DICUI.Library.CueSheets
         /// List of FILE in cuesheet
         /// </summary>
         public List<CueFile> Files { get; set; }
+
+        /// <summary>
+        /// Create an empty cuesheet
+        /// </summary>
+        public CueSheet()
+        {
+        }
+
+        /// <summary>
+        /// Create a cuesheet from a file, if possible
+        /// </summary>
+        /// <param name="filename"></param>
+        public CueSheet(string filename)
+        {
+            // Check that the file exists
+            if (!File.Exists(filename))
+                return;
+
+            // Check the extension
+            string ext = Path.GetExtension(filename).TrimStart('.');
+            if (!string.Equals(ext, "cue", StringComparison.OrdinalIgnoreCase)
+                && !string.Equals(ext, "txt", StringComparison.OrdinalIgnoreCase))
+            {
+                return;
+            }
+
+            // Open the file and begin reading
+            using (var sr = new StreamReader(filename))
+            {
+                while (!sr.EndOfStream)
+                {
+                    string line = sr.ReadLine().Trim();
+                    string[] splitLine = line.Split(' ');
+
+                    // If we have an empty line, we skip
+                    if (string.IsNullOrWhiteSpace(line))
+                        continue;
+
+                    switch (splitLine[0])
+                    {
+                        // Read comments
+                        case "REM":
+                            // We ignore all comments for now
+                            break;
+
+                        // Read MCN
+                        case "CATALOG":
+                            if (splitLine.Length < 2)
+                                continue; // TODO: Make this throw an exception
+
+                            this.Catalog = splitLine[1];
+                            break;
+
+                        // Read external CD-Text file path
+                        case "CDTEXTFILE":
+                            if (splitLine.Length < 2)
+                                continue; // TODO: Make this throw an exception
+
+                            this.CdTextFile = splitLine[1];
+                            break;
+
+                        // Read CD-Text enhanced performer
+                        case "PERFORMER":
+                            if (splitLine.Length < 2)
+                                continue; // TODO: Make this throw an exception
+
+                            this.Performer = splitLine[1];
+                            break;
+
+                        // Read CD-Text enhanced songwriter
+                        case "SONGWRITER":
+                            if (splitLine.Length < 2)
+                                continue; // TODO: Make this throw an exception
+
+                            this.Songwriter = splitLine[1];
+                            break;
+
+                        // Read CD-Text enhanced title
+                        case "TITLE":
+                            if (splitLine.Length < 2)
+                                continue; // TODO: Make this throw an exception
+
+                            this.Title = splitLine[1];
+                            break;
+
+                        // Read file information
+                        case "FILE":
+                            if (splitLine.Length < 3)
+                                continue; // TODO: Make this throw an exception
+
+                            if (this.Files == null)
+                                this.Files = new List<CueFile>();
+
+                            var file = new CueFile(splitLine[1], splitLine[2], sr);
+                            if (file == default)
+                                continue; // TODO: Make this throw an exception
+
+                            this.Files.Add(file);
+                            break;
+                    }
+                }
+            }
+        }
     }
 }

DICUI.Library/CueSheets/CueTrack.cs

@@ -1,10 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 
 /// <remarks>
 /// Information sourced from http://web.archive.org/web/20070221154246/http://www.goldenhawk.com/download/cdrwin.pdf
 /// </remarks>
-namespace DICUI.Library.CueSheets
+namespace DICUI.CueSheets
 {
     /// <summary>
     /// Track datatype
@@ -140,5 +141,215 @@ namespace DICUI.Library.CueSheets
         /// POSTGAP
         /// </summary>
         public PostGap PostGap { get; set; }
+
+        /// <summary>
+        /// Create an empty TRACK
+        /// </summary>
+        public CueTrack()
+        {
+        }
+
+        /// <summary>
+        /// Fill a TRACK from a stream reader
+        /// </summary>
+        /// <param name="number">Number to set</param>
+        /// <param name="dataType">Data type to set</param>
+        /// <param name="sr">StreamReader to pull from</param>
+        public CueTrack(string number, string dataType, StreamReader sr)
+        {
+            if (sr == null)
+                return;
+
+            // Set the current fields
+            if (!int.TryParse(number, out int parsedNumber))
+                return; // TODO: Make this throw an exception
+            else if (parsedNumber < 1 || parsedNumber > 99)
+                return; // TODO: Make this throw an exception
+
+            this.Number = parsedNumber;
+            this.DataType = GetDataType(dataType);
+
+            while (!sr.EndOfStream)
+            {
+                string line = sr.ReadLine().Trim();
+                string[] splitLine = line.Split(' ');
+
+                // If we have an empty line, we skip
+                if (string.IsNullOrWhiteSpace(line))
+                    continue;
+
+                switch (splitLine[0])
+                {
+                    // Read comments
+                    case "REM":
+                        // We ignore all comments for now
+                        break;
+
+                    // Read flag information
+                    case "FLAGS":
+                        if (splitLine.Length < 2)
+                            continue; // TODO: Make this throw an exception
+
+                        this.Flags = GetFlags(splitLine);
+                        break;
+
+                    // Read International Standard Recording Code
+                    case "ISRC":
+                        if (splitLine.Length < 2)
+                            continue; // TODO: Make this throw an exception
+
+                        this.ISRC = splitLine[1];
+                        break;
+
+                    // Read CD-Text enhanced performer
+                    case "PERFORMER":
+                        if (splitLine.Length < 2)
+                            continue; // TODO: Make this throw an exception
+
+                        this.Performer = splitLine[1];
+                        break;
+
+                    // Read CD-Text enhanced songwriter
+                    case "SONGWRITER":
+                        if (splitLine.Length < 2)
+                            continue; // TODO: Make this throw an exception
+
+                        this.Songwriter = splitLine[1];
+                        break;
+
+                    // Read CD-Text enhanced title
+                    case "TITLE":
+                        if (splitLine.Length < 2)
+                            continue; // TODO: Make this throw an exception
+
+                        this.Title = splitLine[1];
+                        break;
+
+                    // Read pregap information
+                    case "PREGAP":
+                        if (splitLine.Length < 2)
+                            continue; // TODO: Make this throw an exception
+
+                        var pregap = new PreGap(splitLine[1]);
+                        if (pregap == default)
+                            continue; // TODO: Make this throw an exception
+
+                        this.PreGap = pregap;
+                        break;
+
+                    // Read index information
+                    case "INDEX":
+                        if (splitLine.Length < 3)
+                            continue; // TODO: Make this throw an exception
+
+                        if (this.Indices == null)
+                            this.Indices = new List<CueIndex>();
+
+                        var index = new CueIndex(splitLine[1], splitLine[2]);
+                        if (index == default)
+                            continue; // TODO: Make this throw an exception
+
+                        this.Indices.Add(index);
+                        break;
+
+                    // Read postgap information
+                    case "POSTGAP":
+                        if (splitLine.Length < 2)
+                            continue; // TODO: Make this throw an exception
+
+                        var postgap = new PostGap(splitLine[1]);
+                        if (postgap == default)
+                            continue; // TODO: Make this throw an exception
+
+                        this.PostGap = postgap;
+                        break;
+
+                    // Default means return
+                    default:
+                        return;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get the data type from a given string
+        /// </summary>
+        /// <param name="dataType">String to get value from</param>
+        /// <returns>CueTrackDataType, if possible (default AUDIO)</returns>
+        private CueTrackDataType GetDataType(string dataType)
+        {
+            switch (dataType.ToLowerInvariant())
+            {
+                case "audio":
+                    return CueTrackDataType.AUDIO;
+
+                case "cdg":
+                    return CueTrackDataType.CDG;
+
+                case "mode1/2048":
+                    return CueTrackDataType.MODE1_2048;
+
+                case "mode1/2352":
+                    return CueTrackDataType.MODE1_2352;
+
+                case "mode2/2336":
+                    return CueTrackDataType.MODE2_2336;
+
+                case "mode2/2352":
+                    return CueTrackDataType.MODE2_2352;
+
+                case "cdi/2336":
+                    return CueTrackDataType.CDI_2336;
+
+                case "cdi/2352":
+                    return CueTrackDataType.CDI_2352;
+
+                default:
+                    return CueTrackDataType.AUDIO;
+            }
+        }
+
+        /// <summary>
+        /// Get the flag value for an array of strings
+        /// </summary>
+        /// <param name="flagStrings">Possible flags as strings</param>
+        /// <returns>CueTrackFlag value representing the strings, if possible</returns>
+        private CueTrackFlag GetFlags(string[] flagStrings)
+        {
+            CueTrackFlag flag = 0;
+
+            foreach (string flagString in flagStrings)
+            {
+                // TODO: Make default throw an exception
+                switch (flagString.ToLowerInvariant())
+                {
+                    case "flags":
+                        // No-op since this is the start of the line
+                        break;
+
+                    case "dcp":
+                        flag |= CueTrackFlag.DCP;
+                        break;
+
+                    case "4ch":
+                        flag |= CueTrackFlag.FourCH;
+                        break;
+
+                    case "pre":
+                        flag |= CueTrackFlag.PRE;
+                        break;
+
+                    case "scms":
+                        flag |= CueTrackFlag.SCMS;
+                        break;
+
+                    case "data":
+                        flag |= CueTrackFlag.DATA;
+                        break;
+                }
+            }
+
+            return flag;
+        }
     }
 }

DICUI.Library/CueSheets/PostGap.cs

@@ -1,28 +1,82 @@
-/// <remarks>
+using System.Linq;
+
+/// <remarks>
 /// Information sourced from http://web.archive.org/web/20070221154246/http://www.goldenhawk.com/download/cdrwin.pdf
 /// </remarks>
-namespace DICUI.Library.CueSheets
+namespace DICUI.CueSheets
 {
     /// <summary>
-    /// Represents postgap information of a track
+    /// Represents POSTGAP information of a track
     /// </summary>
     public class PostGap
     {
         /// <summary>
-        /// Length of postgap in minutes
+        /// Length of POSTGAP in minutes
         /// </summary>
         public int Minutes { get; set; }
 
         /// <summary>
-        /// Length of postgap in seconds
+        /// Length of POSTGAP in seconds
         /// </summary>
         /// <remarks>There are 60 seconds in a minute</remarks>
         public int Seconds { get; set; }
 
         /// <summary>
-        /// Length of postgap in frames.
+        /// Length of POSTGAP in frames.
         /// </summary>
         /// <remarks>There are 75 frames per second</remarks>
         public int Frames { get; set; }
+
+        /// Create an empty POSTGAP
+        /// </summary>
+        public PostGap()
+        {
+        }
+
+        /// <summary>
+        /// Create a POSTGAP from a mm:ss:ff length
+        /// </summary>
+        /// <param name="length">String to get length information from</param>
+        public PostGap(string length)
+        {
+            // Ignore empty lines
+            if (string.IsNullOrWhiteSpace(length))
+                return; // TODO: Make this throw an exception
+
+            // Ignore lines that don't contain the correct information
+            if (length.Length != 8 || length.Count(c => c == ':') != 2)
+                return; // TODO: Make this throw an exception
+
+            // Split the line
+            string[] splitLength = length.Split(':');
+            if (splitLength.Length != 3)
+                return; // TODO: Make this throw an exception
+
+            // Parse the lengths
+            int[] lengthSegments = new int[3];
+
+            // Minutes
+            if (!int.TryParse(splitLength[0], out lengthSegments[0]))
+                return; // TODO: Make this throw an exception
+            else if (lengthSegments[0] < 0)
+                return; // TODO: Make this throw an exception
+
+            // Seconds
+            if (!int.TryParse(splitLength[1], out lengthSegments[1]))
+                return; // TODO: Make this throw an exception
+            else if (lengthSegments[1] < 0 || lengthSegments[1] > 60)
+                return; // TODO: Make this throw an exception
+
+            // Frames
+            if (!int.TryParse(splitLength[2], out lengthSegments[2]))
+                return; // TODO: Make this throw an exception
+            else if (lengthSegments[2] < 0 || lengthSegments[2] > 75)
+                return; // TODO: Make this throw an exception
+
+            // Set the values
+            this.Minutes = lengthSegments[0];
+            this.Seconds = lengthSegments[1];
+            this.Frames = lengthSegments[2];
+        }
     }
 }

DICUI.Library/CueSheets/PreGap.cs

@@ -1,28 +1,83 @@
-/// <remarks>
+using System.Linq;
+
+/// <remarks>
 /// Information sourced from http://web.archive.org/web/20070221154246/http://www.goldenhawk.com/download/cdrwin.pdf
 /// </remarks>
-namespace DICUI.Library.CueSheets
+namespace DICUI.CueSheets
 {
     /// <summary>
-    /// Represents pregap information of a track
+    /// Represents PREGAP information of a track
     /// </summary>
     public class PreGap
     {
         /// <summary>
-        /// Length of postgap in minutes
+        /// Length of PREGAP in minutes
         /// </summary>
         public int Minutes { get; set; }
 
         /// <summary>
-        /// Length of postgap in seconds
+        /// Length of PREGAP in seconds
         /// </summary>
         /// <remarks>There are 60 seconds in a minute</remarks>
         public int Seconds { get; set; }
 
         /// <summary>
-        /// Length of postgap in frames.
+        /// Length of PREGAP in frames.
         /// </summary>
         /// <remarks>There are 75 frames per second</remarks>
         public int Frames { get; set; }
+
+        /// <summary>
+        /// Create an empty PREGAP
+        /// </summary>
+        public PreGap()
+        {
+        }
+
+        /// <summary>
+        /// Create a PREGAP from a mm:ss:ff length
+        /// </summary>
+        /// <param name="length">String to get length information from</param>
+        public PreGap(string length)
+        {
+            // Ignore empty lines
+            if (string.IsNullOrWhiteSpace(length))
+                return; // TODO: Make this throw an exception
+
+            // Ignore lines that don't contain the correct information
+            if (length.Length != 8 || length.Count(c => c == ':') != 2)
+                return; // TODO: Make this throw an exception
+
+            // Split the line
+            string[] splitLength = length.Split(':');
+            if (splitLength.Length != 3)
+                return; // TODO: Make this throw an exception
+
+            // Parse the lengths
+            int[] lengthSegments = new int[3];
+
+            // Minutes
+            if (!int.TryParse(splitLength[0], out lengthSegments[0]))
+                return; // TODO: Make this throw an exception
+            else if (lengthSegments[0] < 0)
+                return; // TODO: Make this throw an exception
+
+            // Seconds
+            if (!int.TryParse(splitLength[1], out lengthSegments[1]))
+                return; // TODO: Make this throw an exception
+            else if (lengthSegments[1] < 0 || lengthSegments[1] > 60)
+                return; // TODO: Make this throw an exception
+
+            // Frames
+            if (!int.TryParse(splitLength[2], out lengthSegments[2]))
+                return; // TODO: Make this throw an exception
+            else if (lengthSegments[2] < 0 || lengthSegments[2] > 75)
+                return; // TODO: Make this throw an exception
+
+            // Set the values
+            this.Minutes = lengthSegments[0];
+            this.Seconds = lengthSegments[1];
+            this.Frames = lengthSegments[2];
+        }
     }
 }