酷狗 KRC 文件的解析

清理硬盘发现以前写过一个进行一半的代码，这次补全并从硬盘删掉。

格式说明来自 https://shansing.com/read/392/

krc解码并解压缩后得到一个字符串，例子：

[id:$00000000]
[ar:信乐团]
[ti:北京一夜]
[by:韩佯Τé]
[hash:766fe295bf2722a9ede2abdd61d580c1]
[total:278438]
[sign:大家去北京玩一夜吧!!!!]
[53883,3092]<0,632,0>One <632,784,0>Night <1416,372,0>in <1788,548,0>北<2336,755,0>京
[56675,3539]<0,560,0>我<560,416,0>留<976,392,0>下<1368,412,0>许<1780,392,0>多<2172,1366,0>情
[59914,2577]<0,549,0>不<549,276,0>管<825,252,0>你<1077,214,0>爱<1291,182,0>与<1473,212,0>不 <1685,887,0>爱
[62191,3344]<0,560,0>都<560,210,0>是<770,210,0>历<980,204,0>史<1184,202,0>的<1386,564,0>尘<1950,1387,0>埃

开头的几行就不用解释了，lrc也有。

其中快速匹配歌词的可能方式是靠计算歌曲文件的hash，以及匹配歌词与歌曲的total

歌词开始的行格式：

[此行开始时刻距0时刻的毫秒数,此行持续的毫秒数]<0,此字持续的毫秒数,0>歌<此字开始的时刻距此行开始时刻的毫秒数,此字持续的毫秒数,0>词<此字开始的时刻距此行开始时刻的毫秒数,此字持续的毫秒数,0>正<此字开始的时刻距此行开始时刻的毫秒数,此字持续的毫秒数,0>文

具体代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.IO.Compression;
using ICSharpCode.SharpZipLib.Zip.Compression;
using ICSharpCode.SharpZipLib.Zip.Compression.Streams;
using System.Diagnostics;

namespace KRC.KRCLib
{
    public static class KRCFile
    {
        /// <summary>
        /// 异或加密 密钥
        /// </summary>
        public static readonly char[] KRCFileXorKey = { '@', 'G', 'a', 'w', '^', '2', 't', 'G', 'Q', '6', '1', '-', 'Î', 'Ò', 'n', 'i' };

        /// <summary>
        /// KRC 文件头
        /// </summary>
        public static readonly char[] KRCFileHead = { 'k', 'r', 'c', '1' };

        /// <summary>
        /// KRC 文件头的字节
        /// </summary>
        public static readonly byte[] KRCFileHeadBytes = { 0x6B, 0x72, 0x63, 0x31 };


        /// <summary>
        /// 解码
        /// </summary>
        public static string DecodeFileToString(string krcFilePath)
        {
            //krc1
            var headBytes = new byte[4];
            byte[] encodedBytes;
            byte[] zipedBytes;

            using (var krcfs = new FileStream(krcFilePath, FileMode.Open))
            {
                encodedBytes = new byte[krcfs.Length - headBytes.Length];
                zipedBytes = new byte[krcfs.Length - headBytes.Length];

                //读文件头标记
                krcfs.Read(headBytes, 0, headBytes.Length);

                //读XOR加密的内容
                krcfs.Read(encodedBytes, 0, encodedBytes.Length);

                //关闭文件
                krcfs.Close();
            }

            for (var i = 0; i < encodedBytes.Length; i++)
            {
                zipedBytes[i] = (byte)(encodedBytes[i] ^ KRCFileXorKey[i % 16]);
            }

            //前面3字节是 UTF-8 的 BOM
            var unzipedBytes = Decompress(zipedBytes);

            //编码器带有BOM输出时多了3字节，所以跳过开头的3字节bom
            var text = RemoveBom(Encoding.UTF8.GetString(unzipedBytes));

            return text;
        }

        /// <summary>
        /// 编码到字节数组
        /// </summary>
        /// <param name="inText"></param>
        /// <returns></returns>
        public static byte[] EncodeStringToBytes(string inText)
        {
            //用默认的，编码时带有UTF-8的BOM
            byte[] inbytes = Encoding.UTF8.GetPreamble().Concat(Encoding.UTF8.GetBytes(inText)).ToArray();

            byte[] zipedBytes = Compress(inbytes);

            int encodedBytesLength = zipedBytes.Length;

            var encodedBytes = new byte[zipedBytes.Length];


            for (int i = 0; i < encodedBytesLength; i++)
            {
                int l = i % 16;

                encodedBytes[i] = (byte)(zipedBytes[i] ^ KRCFileXorKey[l]);
            }

            byte[] byets = null;

            using (var ms = new MemoryStream())
            {
                ms.Write(KRCFileHeadBytes, 0, KRCFileHeadBytes.Length);
                ms.Write(encodedBytes, 0, encodedBytes.Length);
                ms.Flush();
                byets = ms.ToArray();
            }

            return byets;
        }

        /// <summary>
        /// 移除UTF-8 BOM
        /// </summary>
        /// <param name="p"></param>
        /// <returns></returns>
        private static string RemoveBom(string p)
        {
            string bomMarkUtf8 = Encoding.UTF8.GetString(Encoding.UTF8.GetPreamble());
            if (p.StartsWith(bomMarkUtf8))
                p = p.Remove(0, bomMarkUtf8.Length);
            return p.Replace("", "");
        }

        #region 压缩 解压缩
        private static byte[] Compress(byte[] pBytes)
        {
            byte[] outdata = null;
            using (var mMemory = new MemoryStream(pBytes))
            using (var mStream = new DeflaterOutputStream(mMemory, new Deflater(Deflater.DEFAULT_COMPRESSION), 131072))
            {
                mStream.Write(pBytes, 0, pBytes.Length);
                mStream.Flush();
                mMemory.Flush();
                outdata = mMemory.ToArray();
            }
            return outdata;
        }

        /// <summary>
        /// 解压缩
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        private static byte[] Decompress(byte[] data)
        {
            byte[] outdata = null;
            using (var ms = new MemoryStream())
            using (var inputStream = new InflaterInputStream(new MemoryStream(data), new Inflater(false)))
            {
                inputStream.CopyTo(ms);
                ms.Flush();

                outdata = ms.ToArray();
                ms.Close();
            }
            return outdata;
        }
        #endregion


    }
}

using System;
using System.CodeDom;
using System.Diagnostics;
using System.Text.RegularExpressions;

namespace KRC.KRCLib
{
    /// <summary>
    /// KRC文件行字符
    /// </summary>
    [DebuggerDisplay("{DebuggerDisplay}")]
    public class KRCLyricsChar
    {
        /// <summary>
        /// 字符
        /// </summary>
        public char Char { get; set; }

        /// <summary>
        /// 字符KRC字符串
        /// </summary>
        public string KRCCharString
        {
            get
            {
                return string.Format(@"<{0},{1},{2}>{3}", this.CharStart.TotalMilliseconds, this.CharDuring.TotalMilliseconds, 0, this.Char);
            }
        }

        /// <summary>
        /// 字符起始时间(计算时加上字符所属行的起始时间)
        /// </summary>
        public TimeSpan CharStart { get; set; }

        /// <summary>
        /// 字符时长
        /// </summary>
        public TimeSpan CharDuring { get; set; }

        public KRCLyricsChar()
        {
            this.CharStart = TimeSpan.Zero;
            this.CharDuring = TimeSpan.Zero;
        }

        public KRCLyricsChar(string krcCharString)
            : this()
        {
            var chars = Regex.Match(krcCharString, @"<(d+),(d+),(d+)>(.?)");

            if (chars.Success)
            {
                if (chars.Groups.Count >= 4)
                {
                    var charstart = chars.Groups[1].Value;
                    var charduring = chars.Groups[2].Value;
                    var unknowAlwaysZero = chars.Groups[3].Value;

                    this.CharStart = TimeSpan.FromMilliseconds(double.Parse(charstart));
                    this.CharDuring = TimeSpan.FromMilliseconds(double.Parse(charduring));

                    if (chars.Groups.Count >= 5)
                    {
                        var charchar = chars.Groups[4].Value;
                        this.Char = char.Parse(charchar);
                    }
                    else
                    {
                        this.Char = char.Parse(" ");
                    }
                }
            }
        }

        public string DebuggerDisplay
        {
            get
            {
                return string.Format(@"{0:hh:mm:ss.fff} {1:hh:mm:ss.fff} {2}", this.CharStart, this.CharDuring, this.Char);
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text.RegularExpressions;

namespace KRC.KRCLib
{
    /// <summary>
    /// KRC文件行
    /// </summary>
    [DebuggerDisplay("{DebuggerDisplay}")]
    public class KRCLyricsLine
    {
        private readonly List<KRCLyricsChar> _chars = new List<KRCLyricsChar>();

        /// <summary>
        /// 行字符串
        /// </summary>
        public string KRCLineString 
        {
            get
            {
                return string.Format(@"[{0},{1}]{2}", this.LineStart.TotalMilliseconds, this.LineDuring.TotalMilliseconds,
                    string.Join("", this.Chars.Select(x => x.KRCCharString)));
            } 
        }

        /// <summary>
        /// 行开始事件
        /// </summary>
        public TimeSpan LineStart { get; set; }

        /// <summary>
        /// 行总时间
        /// </summary>
        public TimeSpan LineDuring 
        {
            get
            {
                //计算行时间
                var sum = this.Chars.Select(x => x.CharDuring.TotalMilliseconds).Sum();
                return TimeSpan.FromMilliseconds(sum);
            }
        }

        /// <summary>
        /// 行内字符
        /// </summary>

        public List<KRCLyricsChar> Chars
        {
            get { return _chars; }
        }

        public KRCLyricsLine()
        {
            this.LineStart = TimeSpan.Zero;
        }


        public KRCLyricsLine(string krclinestring):this()
        {
            var regLineTime = new Regex(@"^[(.*),(.*)](.*)");

            var m1 = regLineTime.Match(krclinestring);
            if (m1.Success && m1.Groups.Count == 4)
            {
                var linestart = m1.Groups[1].Value;
                var linelength = m1.Groups[2].Value;

                this.LineStart = TimeSpan.FromMilliseconds(double.Parse(linestart));
                //this.LineDuring = TimeSpan.FromMilliseconds(double.Parse(linelength));
                
                var linecontent = m1.Groups[3].Value;

                var chars = Regex.Matches(linecontent, @"<(d+),(d+),(d+)>(.?)");

                foreach (Match m in chars)
                {
                    this.Chars.Add(new KRCLyricsChar(m.Value));
                }
            }
        }

        public string DebuggerDisplay
        {
            get
            {
                return string.Format(@"{0:hh:mm:ss.fff} {1:hh:mm:ss.fff} {2}", this.LineStart, this.LineDuring,
                    string.Join(",", this.Chars.Select(x => x.Char.ToString())));
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace KRC.KRCLib
{
    /// <summary>
    /// KRC歌词文件
    /// </summary>
    public class KRCLyrics
    {
        public List<KRCLyricsLine> Lines
        {
            get { return _lines; }
        }

        /// <summary>
        /// 歌词文本
        /// </summary>
        public string KRCString { get; set; }

        /// <summary>
        /// ID （总是$00000000，意义未知）
        /// </summary>
        public string ID { get; set; }

        /// <summary>
        /// 艺术家
        /// </summary>
        public string Ar { get; set; }

        /// <summary>
        /// 
        /// </summary>
        public string Al { get; set; }

        /// <summary>
        /// 标题
        /// </summary>
        public string Title { get; set; }

        /// <summary>
        /// 歌词文件作者
        /// </summary>
        public string By { get; set; }

        /// <summary>
        /// 歌曲文件Hash
        /// </summary>
        public string Hash { get; set; }

        /// <summary>
        /// 总时长
        /// </summary>
        public TimeSpan Total 
        {
            get
            {
                //计算总时间=所有行时间
                var sum = this.Lines.Select(x => x.LineDuring.TotalMilliseconds).Sum();
                return TimeSpan.FromMilliseconds(sum);
            }
        }

        /// <summary>
        /// 偏移
        /// </summary>
        public TimeSpan Offset { get; set; }

        private readonly List<KRCLyricsLine> _lines = new List<KRCLyricsLine>();
        private readonly List<Tuple<Regex, Action<string>>> _properties;
        private readonly Regex _regGetValueFromKeyValuePair = new Regex(@"[(.*):(.*)]");

        /// <summary>
        /// 默认构造
        /// </summary>
        public KRCLyrics()
        {
            //this.Total = TimeSpan.Zero;
            this.Offset = TimeSpan.Zero;

            this._properties = new List<Tuple<Regex, Action<string>>>()
            {
                new Tuple<Regex, Action<string>>(new Regex("\[id:[^\]]+\]"), (s) => { this.ID = s; }),
                new Tuple<Regex, Action<string>>(new Regex("\[al:[^\n]+\n"), (s) => { this.Al = s; }),
                new Tuple<Regex, Action<string>>(new Regex("\[ar:[^\]]+\]"), (s) => { this.Ar = s; }),
                new Tuple<Regex, Action<string>>(new Regex("\[ti:[^\]]+\]"), (s) => { this.Title = s; }),
                new Tuple<Regex, Action<string>>(new Regex("\[hash:[^\n]+\n"), (s) => { this.Hash = s; }),
                new Tuple<Regex, Action<string>>(new Regex("\[by:[^\n]+\n"), (s) => { this.By = s; }),
                new Tuple<Regex, Action<string>>(new Regex("\[total:[^\n]+\n"), (s) =>
                {
                    //this.Total = TimeSpan.FromMilliseconds(double.Parse(s));
                }),
                new Tuple<Regex, Action<string>>(new Regex("\[offset:[^\n]+\n"), (s) =>
                {
                    this.Offset = TimeSpan.FromMilliseconds(double.Parse(s));
                }),
            };
        }

        /// <summary>
        /// 构造
        /// </summary>
        /// <param name="krcstring">KRC字符文本</param>
        private KRCLyrics(string krcstring):this()
        {
            this.KRCString = krcstring;
            this.LoadProperties();
            this.LoadLines();
        }

        /// <summary>
        /// 加载KRC属性
        /// </summary>
        private void LoadProperties()
        {
            foreach (var prop in _properties)
            {
                var m = prop.Item1.Match(this.KRCString);
                if (m.Success)
                {
                    var mm = _regGetValueFromKeyValuePair.Match(m.Value);

                    if (mm.Success && mm.Groups.Count == 3)
                    {
                        prop.Item2(mm.Groups[2].Value);
                    }
                }
            }
        }

        /// <summary>
        /// 加载KRC所有行数据
        /// </summary>
        private void LoadLines()
        {
            var linesMachCollection = Regex.Matches(this.KRCString, @"[d{1,}[^
]+
");
            foreach (Match m in linesMachCollection)
            {
                this.Lines.Add(new KRCLyricsLine(m.Value));
            }
        }

        /// <summary>
        /// 保存到文件
        /// </summary>
        /// <param name="outputFilePath"></param>
        public void SaveToFile(string outputFilePath)
        {
            var sb = new StringBuilder();
            sb.AppendLine(string.Format("[id:{0}]", this.ID));


            if (!string.IsNullOrEmpty(this.Al))
            {
                sb.AppendLine(string.Format("[al:{0}]", this.Al));
            }

            if (!string.IsNullOrEmpty(this.Ar))
            {
                sb.AppendLine(string.Format("[ar:{0}]", this.Ar));
            }

            if (!string.IsNullOrEmpty(this.Title))
            {
                sb.AppendLine(string.Format("[ti:{0}]", this.Title));
            }

            if (!string.IsNullOrEmpty(this.Hash))
            {
                sb.AppendLine(string.Format("[hash:{0}]", this.Hash));
            }

            if (!string.IsNullOrEmpty(this.By))
            {
                sb.AppendLine(string.Format("[by:{0}]", this.By));
            }

            if (this.Total!= TimeSpan.Zero)
            {
                sb.AppendLine(string.Format("[total:{0}]", this.Total.TotalMilliseconds));
            }

            if (this.Offset != TimeSpan.Zero)
            {
                sb.AppendLine(string.Format("[offset:{0}]", this.Offset.TotalMilliseconds));
            }


            foreach (var line in this.Lines)
            {
                sb.AppendLine(line.KRCLineString);
            }


            var bytes = KRCFile.EncodeStringToBytes(sb.ToString());


            File.WriteAllBytes(outputFilePath, bytes);

        }

        /// <summary>
        /// 从文件加载
        /// </summary>
        /// <param name="inputFilePath"></param>
        /// <returns></returns>
        public static KRCLyrics LoadFromFile(string inputFilePath)
        {
            var str = KRCFile.DecodeFileToString(inputFilePath);

            return LoadFromString(str);
        }

        /// <summary>
        /// 从文本加载
        /// </summary>
        /// <param name="krcstring"></param>
        /// <returns></returns>
        public static KRCLyrics LoadFromString(string krcstring)
        {
            var aa = new KRCLyrics(krcstring);
            return aa;
        }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using KRC.KRCLib;

namespace KRC.Test
{
    class Program
    {
        static void Main(string[] args)
        {
            string inputFile = @"杨钰莹.桃花运-b0c4014bd991a6a637445defa56822f9.krc";
            string outputFile = @"123.krc";
            KRCLyrics krc = KRCLyrics.LoadFromFile(inputFile);
            Console.WriteLine("解码 [{0}] 完毕。", inputFile);
            krc.SaveToFile(outputFile);
            Console.WriteLine("另存为 [{0}] 完毕。", outputFile);
            Console.ReadLine();
        }
    }
}