Пример #1
0
            private void Parse(LogBuffer parser)
            {
                List <int> arItems = null;
                int        arV2    = 0;
                string     lx      = parser.ReadLineLTrim();

                if (lx.StartsWith("X Lossless Decoder"))
                {
                    Data.Application = lx;
                }

                lx = parser.ReadLineLTrim();
                if (lx.StartsWith("XLD extraction logfile from "))
                {
                    Data.RipDate = lx.Substring(28);
                }

                lx = parser.ReadLineNonempty();
                int slashPos = lx.IndexOf(" / ");

                if (slashPos < 0)
                {
                    IssueModel.Add("Missing '<artist> / <album>', " + parser.GetPlace() + ".");
                    return;
                }
                Data.RipArtist = lx.Substring(0, slashPos);
                Data.RipAlbum  = lx.Substring(slashPos + 3);

                for (;;)
                {
                    lx = parser.ReadLineNonempty();
                    if (parser.EOF)
                    {
                        return;
                    }

                    string px = ParseArg(lx, out string arg);
                    if (arg == null)
                    {
                        break;
                    }
                    if (px == "Used drive")
                    {
                        Data.Drive = arg;
                    }
                    else if (px == "Media type")
                    {
                        Data.Media = arg;
                    }
                    else if (px == "Ripper mode")
                    {
                        Data.ReadMode = arg;
                    }
                    else if (px == "Disable audio cache")
                    {
                        Data.DefeatCache = arg;
                    }
                    else if (px == "Make use of C2 pointers")
                    {
                        Data.UseC2 = arg;
                    }
                    else if (px == "Read offset correction")
                    {
                        Data.ReadOffset = arg;
                    }
                    else if (px == "Gap status")
                    {
                        Data.GapHandling = arg;
                    }
                }

                for (;;)
                {
                    if (parser.EOF || lx == null)
                    {
                        return;
                    }
                    if (lx.StartsWith("TOC"))
                    {
                        ParseToC();
                    }
                    if (lx.StartsWith("AccurateRip Summary"))
                    {
                        ParseAccurateRip();
                    }
                    else if (lx.StartsWith("Track "))
                    {
                        ParseTracks();
                    }
                    else if (lx == "No errors occurred")
                    {
                        Data.HasNoErrors = true;
                        lx = parser.ReadLine();
                        break;
                    }
                    else
                    {
                        lx = parser.ReadLine();
                    }
                }

                for (;;)
                {
                    if (parser.EOF)
                    {
                        break;
                    }
                    if (lx == "-----BEGIN XLD SIGNATURE-----")
                    {
                        lx = parser.ReadLineLTrim();
                        if (!parser.EOF)
                        {
                            Data.storedHash = lx;
                            lx = parser.ReadLineLTrim();
                        }
                    }
                    lx = parser.ReadLineLTrim();
                }

                if (arItems != null)
                {
                    if (arItems.Count != TracksModel.Data.Items.Count || arItems.Count == 0)
                    {
                        Data.ArIssue = IssueModel.Add("AccurateRip table mismatch.", Severity.Error, IssueTags.Failure);
                    }
                    else
                    {
                        Data.AccurateRipConfidence = arItems.Min();
                        Data.AccurateRip           = arV2 == arItems.Count ? 2 : 1;
                    }
                }
                return;

                void ParseToC()
                {
                    // Q: does the ToC include data tracks?
                    lx = parser.ReadLine();
                }

                void ParseAccurateRip()
                {
                    lx = parser.ReadLine();
                    if (lx != null && lx.Contains("Disc not found"))
                    {
                        Data.AccurateRipConfidence = 0; return;
                    }

                    arItems = new List <int>();
                    for (;;)
                    {
                        if (String.IsNullOrWhiteSpace(lx) || lx.StartsWith("->"))
                        {
                            return;
                        }
                        string px = ParseArg(lx, out string arg);
                        if (px.Length != 8 || !Char.IsDigit(px[6]) || !Char.IsDigit(px[7]))
                        {
                            return;
                        }
                        int.TryParse(px.Substring(6), out int tn);
                        if (tn != arItems.Count + 1)
                        {
                            return;
                        }
                        if (arg == "Not Found")
                        {
                            arItems.Add(0);
                        }
                        else if (arg.Contains("OK "))
                        {
                            int p1 = arg.IndexOf("confidence ");
                            if (p1 < 0)
                            {
                                return;         // malformed AR
                            }
                            int p2 = p1 = p1 + 11;
                            for (; p2 < arg.Length; ++p2)
                            {
                                if (!Char.IsDigit(arg[p2]))
                                {
                                    break;
                                }
                            }
                            if (p2 == p1)
                            {
                                return; // malformed AR
                            }
                            int.TryParse(arg.Substring(p1, p2 - p1), out int val);
                            arItems.Add(val);
                            if (arg.Contains("v2"))
                            {
                                ++arV2;
                            }
                        }
                        else
                        {
                            arItems.Add(-1);
                        }
                        lx = parser.ReadLine();
                    }
                }

                void ParseTracks()
                {
                    for (;;)
                    {
                        int    number = 0;
                        string fileName = null;
                        uint?  testCRC = null, copyCRC = null;
                        string arg  = lx.Substring(6);
                        bool   isOk = arg.Length >= 2 && Char.IsDigit(arg[0]);
                        if (isOk)
                        {
                            isOk = int.TryParse(arg, out number);
                        }
                        if (!isOk)
                        {
                            IssueModel.Add($"Malformed track number '{arg}'."); return;
                        }

                        for (;;)
                        {
                            lx = parser.ReadLine();
                            if (parser.EOF || (lx.Length > 0 && lx[0] != ' '))
                            {
                                TracksModel.Add(number, fileName, testCRC, copyCRC);
                                if (lx.StartsWith("Track "))
                                {
                                    break;
                                }
                                else
                                {
                                    return;
                                }
                            }
                            string px = ParseArg(lx, out string ax);
                            if (px == "Filename")
                            {
                                fileName = px;
                            }
                            else if (px == "CRC32 hash (test run)")
                            {
                                if (uint.TryParse(ax, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out uint word))
                                {
                                    testCRC = word;
                                }
                                else
                                {
                                    IssueModel.Add("Malformed test CRC"); return;
                                }
                            }
                            else if (px == "CRC32 hash")
                            {
                                if (uint.TryParse(ax, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out uint word))
                                {
                                    copyCRC = word;
                                }
                                else
                                {
                                    IssueModel.Add("Malformed copy CRC"); return;
                                }
                            }
                        }
                    }
                }
            }
Пример #2
0
            string Parse(LogBuffer parser)
            {
                string lx = null;

                ParseHeader();

                if (!Data.IsRangeRip)
                {
                    lx = ParseTracks();
                    if (Data.Issues.HasFatal)
                    {
                        return(null);
                    }
                }

                while (!parser.EOF && !lx.Contains("errors") && !lx.StartsWith("==== "))
                {
                    lx = parser.ReadLineLTrim();
                }

                if (lx == "No errors occured" || lx == "No errors occurred")
                {
                    lx = parser.ReadLineLTrim();
                }
                else if (lx == "There were errors")
                {
                    if (Data.Issues.MaxSeverity < Severity.Error)
                    {
                        IssueModel.Add("There were errors.");
                    }
                    lx = parser.ReadLineLTrim();
                }
                else
                {
                    IssueModel.Add("Missing 'errors' line.");
                }

                if (Data.IsRangeRip)
                {
                    if (lx == "AccurateRip summary")
                    {
                        for (;;)
                        {
                            lx = parser.ReadLineLTrim();
                            if (parser.EOF || !lx.StartsWith("Track "))
                            {
                                break;
                            }

                            if (lx.Contains("ccurately ripped (confidence "))
                            {
                                int arVersion    = lx.Contains("AR v2") ? 2 : 1;
                                int advanced     = ConvertTo.FromStringToInt32(lx, 40, out int val);
                                int arConfidence = advanced > 0 && val > 0 ? val : -1;
                                lx = parser.ReadLineLTrim();

                                if (Data.AccurateRipConfidence == null || Data.AccurateRipConfidence.Value > arConfidence)
                                {
                                    Data.AccurateRipConfidence = arConfidence;
                                }
                                if (Data.AccurateRip == null || Data.AccurateRip.Value > arVersion)
                                {
                                    Data.AccurateRip = arVersion;
                                }
                            }
                        }
                    }
                }

                if (lx == "All tracks accurately ripped")
                {
                    lx = parser.ReadLineLTrim();
                }

                if (lx.StartsWith("End of status report"))
                {
                    lx = parser.ReadLineLTrim();
                }

                if (lx.StartsWith("---- CUETools"))
                {
                    lx = ParseCueTools();
                }

                while (!parser.EOF && !lx.StartsWith("==== "))
                {
                    lx = parser.ReadLine();
                }

                if (lx.StartsWith("==== Log checksum ") && lx.Length >= 82)
                {
                    Data.storedHash = ConvertTo.FromHexStringToBytes(lx, 18, 32);

                    lx = parser.ReadLine();
                    if (!parser.EOF || !String.IsNullOrEmpty(lx))
                    {
                        IssueModel.Add("Unexpected content at end of file.", Severity.Warning, IssueTags.StrictErr);
                    }
                }

                return(lx);

                string ParseHeader()
                {
                    lx = parser.ReadLine();
                    if (lx.StartsWith("Exact Audio Copy V"))
                    {
                        var spacePos = lx.IndexOf(' ', 18);
                        if (spacePos > 0)
                        {
                            Data.EacVersionString = lx.Substring(18, spacePos - 18);
                        }

                        lx = parser.ReadLine();
                        lx = parser.ReadLine();
                    }

                    if (!lx.StartsWith("EAC extraction logfile from "))
                    {
                        IssueModel.Add("Unexpected contents, " + parser.GetPlace() + ": Expecting 'EAC extraction logfile'.");
                        return(lx);
                    }

                    lx = lx.Substring(28);
                    if (lx.Length < 12)
                    {
                        IssueModel.Add("Missing rip date, " + parser.GetPlace() + ".");
                        return(lx);
                    }
                    Data.RipDate = lx.EndsWith(" for CD") ? lx.Substring(0, lx.Length - 7) : lx;

                    lx = parser.ReadLine();
                    if (String.IsNullOrWhiteSpace(lx))
                    {
                        lx = parser.ReadLine();
                    }

                    int slashPos = lx.IndexOf('/');

                    if (slashPos < 0)
                    {
                        IssueModel.Add("Missing '<artist> / <album>', " + parser.GetPlace() + ".");
                        return(lx);
                    }
                    Data.RipArtist = lx.Substring(0, slashPos).Trim();
                    Data.RipAlbum  = lx.Substring(slashPos + 1).Trim();

                    for (;;)
                    {
TOP:
                        if (parser.EOF)
                        {
                            lx = String.Empty;
                            return(lx);
                        }

                        lx = parser.ReadLine();
                        if (lx.StartsWith("Track ") || lx.StartsWith("===="))
                        {
                            return(lx);
                        }

                        if (lx == "Range status and errors")
                        {
                            Data.IsRangeRip = true;
                            lx = parser.ReadLine();
                            return(lx);
                        }

                        if (lx == "TOC of the extracted CD")
                        {
                            for (Data.TocTrackCount = 0;;)
                            {
                                lx = parser.ReadLine();
                                if (parser.EOF || lx.StartsWith("==== ") || (lx.StartsWith("Track") && !lx.Contains("|")))
                                {
                                    return(lx);
                                }

                                if (lx == "Range status and errors")
                                {
                                    Data.IsRangeRip = true;
                                    lx = parser.ReadLine();
                                    return(lx);
                                }

                                if (lx.Length >= 60)
                                {
                                    if (int.TryParse(lx.Substring(0, 9), out int tn))
                                    {
                                        ++Data.TocTrackCount;
                                    }
                                }
                            }
                        }

                        int ik0 = 0, ik1 = 0, ii = 0, iv0 = 0, iv1;
                        for (;; ++ik0)
                        {
                            if (ik0 >= lx.Length)
                            {
                                goto TOP;
                            }
                            else if (lx[ik0] != ' ')
                            {
                                for (ii = ik0, ik1 = ii;;)
                                {
                                    ++ii;
                                    if (ii >= lx.Length)
                                    {
                                        string kk = lx.Substring(ik0, ik1 - ik0 + 1);
                                        if (kk == "Installed external ASPI interface" || kk == "Native Win32 interface for Win NT & 2000")
                                        {
                                            Data.Interface = kk;
                                        }
                                        goto TOP;
                                    }
                                    if (lx[ii] == ':')
                                    {
                                        break;
                                    }
                                    if (lx[ii] != ' ')
                                    {
                                        ik1 = ii;
                                    }
                                }

                                for (iv0 = ii + 1;; ++iv0)
                                {
                                    if (iv0 >= lx.Length)
                                    {
                                        goto TOP;
                                    }
                                    else if (lx[iv0] != ' ')
                                    {
                                        for (ii = iv0 + 1, iv1 = iv0;; ++ii)
                                        {
                                            if (ii == lx.Length)
                                            {
                                                break;
                                            }
                                            else if (lx[ii] != ' ')
                                            {
                                                iv1 = ii;
                                            }
                                        }

                                        string optKey = lx.Substring(ik0, ik1 - ik0 + 1),
                                               optVal = lx.Substring(iv0, iv1 - iv0 + 1);
                                        if (optKey == "Used drive")
                                        {
                                            Data.Drive = optVal;
                                        }
                                        else if (optKey == "Utilize accurate stream")
                                        {
                                            Data.AccurateStream = optVal;
                                        }
                                        else if (optKey == "Defeat audio cache")
                                        {
                                            Data.DefeatCache = optVal;
                                        }
                                        else if (optKey == "Make use of C2 pointers")
                                        {
                                            Data.UseC2 = optVal;
                                        }
                                        else if (optKey == "Read mode")
                                        {
                                            Data.ReadMode = optVal;
                                        }
                                        else if (optKey == "Read offset correction" || optKey == "Combined read/write offset correction")
                                        {
                                            Data.ReadOffset = optVal;
                                        }
                                        else if (optKey == "Overread into Lead-In and Lead-Out")
                                        {
                                            Data.Overread = optVal;
                                        }
                                        else if (optKey == "Fill up missing offset samples with silence")
                                        {
                                            Data.FillWithSilence = optVal;
                                        }
                                        else if (optKey == "Delete leading and trailing silent blocks")
                                        {
                                            Data.TrimSilence = optVal;
                                        }
                                        else if (optKey == "Null samples used in CRC calculations")
                                        {
                                            Data.CalcWithNulls = optVal;
                                        }
                                        else if (optKey == "Normalize to")
                                        {
                                            Data.NormalizeTo = optVal;
                                        }
                                        else if (optKey == "Used interface")
                                        {
                                            Data.Interface = optVal;
                                        }
                                        else if (optKey == "Gap handling")
                                        {
                                            Data.GapHandling = optVal;
                                        }
                                        else if (optKey == "Sample format")
                                        {
                                            Data.SampleFormat = optVal;
                                        }
                                        else if (optKey == "Quality")
                                        {
                                            Data.Quality = optVal;
                                        }
                                        else if (optKey == "Add ID3 tag")
                                        {
                                            Data.Id3Tag = optVal;
                                        }
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }

                string ParseTracks()
                {
                    for (;;)
                    {
                        if (parser.EOF ||
                            lx == "No errors occured" ||
                            lx == "No errors occurred" ||
                            lx == "There were errors" ||
                            lx.Contains("accurate"))
                        {
                            break;
                        }

                        if (!lx.StartsWith("Track") || lx.StartsWith("Track quality"))
                        {
                            lx = parser.ReadLineLTrim();
                            continue;
                        }

                        bool success = Int32.TryParse(lx.Substring(6), out int num);
                        if (!success)
                        {
                            Data.TkIssue = IssueModel.Add("Invalid track " + parser.GetPlace(), Severity.Fatal, IssueTags.Failure);
                            break;
                        }

                        lx = parser.ReadLineLTrim();
                        if (!lx.StartsWith("Filename "))
                        {
                            Data.TkIssue = IssueModel.Add($"Track {num}: Missing 'Filename'.", Severity.Error, IssueTags.Failure);
                        }
                        else
                        {
                            lx = ParseTrack(num);
                        }
                    }
                    return(lx);
                }

                string ParseTrack(int num)
                {
                    string name = "", peak = "", speed = "", pregap = "", qual = "";
                    int?   arVersion = null;
                    int?   arConfidence = null;
                    uint?  testCrc = null, copyCrc = null;
                    bool   trackErr = false;
                    uint   word;

                    name = lx.Substring(9);
                    if (name.Length < 10 || (lx.Length < 252 && !lx.EndsWith(".wav")))
                    {
                        IssueModel.Add("Unexpected extension " + parser.GetPlace());
                    }

                    lx = parser.ReadLineLTrim();
                    if (lx.StartsWith("Pre-gap length  "))
                    {
                        pregap = lx.Substring(16); lx = parser.ReadLineLTrim();
                    }

                    for (;;)
                    {
                        if (parser.EOF)
                        {
                            return(lx);
                        }

                        if (lx.StartsWith("Track quality") || lx.StartsWith("Peak level "))
                        {
                            break;
                        }

                        if (lx.StartsWith("Track "))
                        {
                            return(lx);  // Unexpected start of next track.
                        }
                        if (!trackErr)
                        {
                            trackErr = true;
                            IssueModel.Add($"Track {num}: '{lx}'.");
                        }
                        lx = parser.ReadLineLTrim();
                    }

                    if (lx.StartsWith("Peak level "))
                    {
                        peak = lx.Substring(11); lx = parser.ReadLineLTrim();
                    }

                    if (lx.StartsWith("Extraction speed "))
                    {
                        speed = lx.Substring(17); lx = parser.ReadLineLTrim();
                    }

                    if (lx.StartsWith("Track quality "))
                    {
                        qual = lx.Substring(14); lx = parser.ReadLineLTrim();
                    }

                    if (lx.StartsWith("Test CRC "))
                    {
                        if (uint.TryParse(lx.Substring(9), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out word))
                        {
                            testCrc = word;
                        }
                        else
                        {
                            Data.TpIssue = IssueModel.Add($"Track {num}: Invalid test CRC-32.", Severity.Error, IssueTags.Failure);
                        }
                        lx = parser.ReadLineLTrim();
                    }

                    if (!lx.StartsWith("Copy CRC "))
                    {
                        IssueModel.Add($"Track {num}: Missing copy CRC-32.", Severity.Warning);
                    }
                    else
                    {
                        if (uint.TryParse(lx.Substring(9), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out word))
                        {
                            copyCrc = word;
                        }
                        else
                        {
                            Data.TkIssue = IssueModel.Add($"Track {num}: Invalid copy CRC-32.", Severity.Error, IssueTags.Failure);
                        }
                        lx = parser.ReadLineLTrim();
                    }

                    if (lx.StartsWith("Accurately ripped (confidence "))
                    {
                        arVersion = lx.Contains("AR v2") ? 2 : 1;
                        int advanced = ConvertTo.FromStringToInt32(lx, 30, out int val);
                        arConfidence = advanced > 0 && val > 0 ? val : -1;
                        lx           = parser.ReadLineLTrim();
                    }
                    else if (lx.StartsWith("Cannot be verified"))
                    {
                        arVersion    = lx.Contains("AR v2") ? 2 : 1;
                        arConfidence = -1;
                        lx           = parser.ReadLineLTrim();
                    }
                    else if (lx.StartsWith("Track not present"))
                    {
                        if (peak != "0.0 %")
                        {
                            arConfidence = 0;
                        }
                        lx = parser.ReadLineLTrim();
                    }

                    if (arConfidence != null)
                    {
                        if (Data.AccurateRipConfidence == null || Data.AccurateRipConfidence > arConfidence)
                        {
                            Data.AccurateRipConfidence = arConfidence;
                        }
                        if (arVersion != null)
                        {
                            if (Data.AccurateRip == null || Data.AccurateRip.Value > arVersion.Value)
                            {
                                Data.AccurateRip = arVersion;
                            }
                        }
                    }

                    bool hasOK = false;

                    if (lx == "Copy OK")
                    {
                        hasOK = true;
                        lx    = parser.ReadLineLTrim();
                    }

                    TracksModel.Add(num, name, pregap, peak, speed, qual, testCrc, copyCrc, hasOK, arVersion, arConfidence);
                    return(lx);
                }

                string ParseCueTools()
                {
                    do
                    {
                        lx = parser.ReadLineLTrim();
                        if (parser.EOF || lx.StartsWith("==== "))
                        {
                            return(lx);
                        }
                    } while (!lx.StartsWith("[CTDB"));

                    if (lx.Contains("not present"))
                    {
                        Data.CueToolsConfidence = 0;
                        lx = parser.ReadLineLTrim();
                        if (!parser.EOF && lx.StartsWith("Submit"))
                        {
                            lx = parser.ReadLineLTrim();
                        }
                        return(lx);
                    }

                    if (!lx.Contains(" found"))
                    {
                        return(lx);
                    }

                    do
                    {
                        lx = parser.ReadLineLTrim();
                        if (parser.EOF || lx.StartsWith("==== "))
                        {
                            return(lx);
                        }

                        if (lx.StartsWith("["))
                        {
                            int ctConfidence = -1;
                            if (lx.Contains("Accurately ripped"))
                            {
                                int advanced = ConvertTo.FromStringToInt32(lx, 12, out ctConfidence);
                            }
                            Data.CueToolsConfidence = ctConfidence;
                            lx = parser.ReadLineLTrim();
                            return(lx);
                        }
                    } while (!lx.StartsWith("Track"));

                    for (int tx = 0; ; ++tx)
                    {
                        lx = parser.ReadLine();
                        if (parser.EOF || lx.StartsWith("==== ") || lx.StartsWith("All tracks"))
                        {
                            return(lx);
                        }

                        int ctConfidence;
                        if (lx.Contains("Accurately ripped"))
                        {
                            int advanced = ConvertTo.FromStringToInt32(lx, 9, out ctConfidence);
                            if (advanced == 0)
                            {
                                Data.CueToolsConfidence = -1; return(lx);
                            }
                        }
                        else if (lx.Contains("Differs"))
                        {
                            ctConfidence = -1;
                        }
                        else
                        {
                            break;
                        }

                        if (tx < TracksModel.Data.Items.Count)
                        {
                            TracksModel.SetCtConfidence(tx, ctConfidence);
                        }
                        if (Data.CueToolsConfidence == null || Data.CueToolsConfidence > ctConfidence)
                        {
                            Data.CueToolsConfidence = ctConfidence;
                        }
                    }
                    return(parser.ReadLineLTrim());
                }
            }