Add BilibiliParser

Author: xqq

3rdparty/rapidxml

@@ -17,13 +17,13 @@
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>v120</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <ConfigurationType>StaticLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
     <PlatformToolset>v120</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
@@ -67,6 +67,7 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBWTFDANMAKU_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <SDLCheck>true</SDLCheck>
+      <AdditionalIncludeDirectories>$(ProjectDir)3rdparty;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -78,11 +79,13 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClInclude Include="src\BaseDanmaku.hpp" />
+    <ClInclude Include="src\BilibiliParser.hpp" />
     <ClInclude Include="src\DanmakusManager.hpp" />
     <ClInclude Include="src\Displayer.hpp" />
     <ClInclude Include="src\DisplayerImpl.hpp" />
     <ClInclude Include="src\GlobalConfig.hpp" />
     <ClInclude Include="src\ITimer.hpp" />
+    <ClInclude Include="src\IParser.hpp" />
     <ClInclude Include="src\R2LDanmaku.hpp" />
     <ClInclude Include="src\Renderable.hpp" />
     <ClInclude Include="src\DanmakusRetainer.hpp" />
@@ -97,6 +100,7 @@
     <ClInclude Include="src\WinmmTimer.hpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="src\BilibiliParser.cpp" />
     <ClCompile Include="src\DisplayerImpl.cpp" />
     <ClCompile Include="src\dllmain.cpp">
       <CompileAsManaged Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</CompileAsManaged>

libwtfdanmaku.vcxproj

@@ -69,6 +69,12 @@
     <ClInclude Include="src\Controller.hpp">
       <Filter>src</Filter>
     </ClInclude>
+    <ClInclude Include="src\BilibiliParser.hpp">
+      <Filter>src</Filter>
+    </ClInclude>
+    <ClInclude Include="src\IParser.hpp">
+      <Filter>src</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="src\BaseDanmaku.cpp">
@@ -116,5 +122,8 @@
     <ClCompile Include="src\Controller.cpp">
       <Filter>src</Filter>
     </ClCompile>
+    <ClCompile Include="src\BilibiliParser.cpp">
+      <Filter>src</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

libwtfdanmaku.vcxproj.filters

@@ -13,7 +13,7 @@ using std::weak_ptr;
 
 namespace WTFDanmaku {
 
-    enum DanmakuType {
+    enum DanmakuType : int {
         kNull = 0,
         kScrolling = 1,
         kBottom = 4,

src/BaseDanmaku.hpp

@@ -0,0 +1,84 @@
+#include <clocale>
+#include <codecvt>
+#include "../3rdparty/rapidxml/rapidxml.hpp"
+#include "../3rdparty/rapidxml/rapidxml_utils.hpp"
+#include "DanmakuFactory.hpp"
+#include "BilibiliParser.hpp"
+
+using namespace rapidxml;
+
+namespace WTFDanmaku {
+
+    BilibiliParser::BilibiliParser() {
+        mDanmakus = std::move(std::unique_ptr<std::vector<DanmakuRef>>(new std::vector<DanmakuRef>));
+    }
+
+    bool BilibiliParser::ParseStringSource(const char* str) {
+        return ParseXml(str);
+    }
+
+    bool BilibiliParser::ParseFileSource(const char* filePath) {
+        file<> xmlFile(filePath);
+        return ParseXml(xmlFile.data());
+    }
+
+    bool BilibiliParser::ParseXml(const char* data) {
+        if (mDanmakus.get() == nullptr)
+            return false;
+
+        int bufferSize = strlen(data) + 1;
+        char* buf = new char[bufferSize];
+        std::unique_ptr<char> buffer(buf);
+        memset(buf, 0, bufferSize);
+        strcpy_s(buf, bufferSize, data);
+
+        xml_document<> doc;
+        doc.parse<0>(buf);
+
+        xml_node<char>* root = doc.first_node("i");
+        if (root == nullptr)
+            return false;
+
+        for (auto node = root->first_node("d"); node != nullptr; node = node->next_sibling()) {
+            const char* attr = node->first_attribute("p")->value();
+            auto attributes = SplitString(attr, ',');
+
+            if (attributes.size() >= 8) {
+                time_t time = static_cast<time_t>(std::stod(attributes[0]) * 1000);
+                DanmakuType type = static_cast<DanmakuType>(std::stoi(attributes[1]));
+                int textSize = static_cast<int>(std::stof(attributes[2]));
+                int textColor = std::stoi(attributes[3]) | 0xFF000000;
+                time_t timestamp = std::stoull(attributes[4]);
+                int danmakuId = std::stoi(attributes[7]);
+                std::wstring comment = UTF8ToWideString(node->value());
+
+                DanmakuRef danmaku = DanmakuFactory::CreateDanmaku(type, time, comment, textSize, textColor, timestamp, danmakuId);
+                if (danmaku != nullptr) {
+                    mDanmakus->push_back(danmaku);
+                }
+            }
+        }
+        return true;
+    }
+
+    std::unique_ptr<std::vector<DanmakuRef>> BilibiliParser::GetDanmakus() {
+        return std::move(mDanmakus);
+    }
+
+    std::vector<std::string> BilibiliParser::SplitString(const char* input, char delimiter) {
+        std::vector<std::string> fragments;
+        while (auto next = strchr(input, delimiter)) {
+            fragments.push_back(std::string(input, next));
+            input = next + 1;
+        }
+        fragments.push_back(std::string(input));
+        return fragments;
+    }
+
+    std::wstring BilibiliParser::UTF8ToWideString(const char* input) {
+        std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>, wchar_t> u8to16conv;
+        std::wstring wide = u8to16conv.from_bytes(input);
+        return wide;
+    }
+
+}

src/BilibiliParser.cpp

@@ -0,0 +1,29 @@
+#ifndef _WTF_BILIBILI_PARSER_HPP
+#define _WTF_BILIBILI_PARSER_HPP
+
+#include "IParser.hpp"
+
+namespace WTFDanmaku {
+
+    class BilibiliParser : public IParser {
+    public:
+        static inline ParserRef Create() {
+            return std::make_shared<BilibiliParser>();
+        }
+    public:
+        explicit BilibiliParser();
+        virtual ~BilibiliParser() = default;
+        virtual bool ParseStringSource(const char* str) override;
+        virtual bool ParseFileSource(const char* filePath) override;
+        virtual std::unique_ptr<std::vector<DanmakuRef>> GetDanmakus() override;
+    private:
+        bool ParseXml(const char* data);
+        static std::vector<std::string> BilibiliParser::SplitString(const char* input, char delimiter);
+        static std::wstring UTF8ToWideString(const char* input);
+    private:
+        std::unique_ptr<std::vector<DanmakuRef>> mDanmakus;
+    };
+
+}
+
+#endif // _WTF_BILIBILI_PARSER_HPP

src/BilibiliParser.hpp

@@ -0,0 +1,25 @@
+#ifndef _WTF_IPARSER_HPP
+#define _WTF_IPARSER_HPP
+
+#include <cstdint>
+#include <vector>
+#include <memory>
+#include "BaseDanmaku.hpp"
+#include "Noncopyable.hpp"
+
+namespace WTFDanmaku {
+
+    class IParser : public Noncopyable {
+    public:
+        explicit IParser() = default;
+        virtual ~IParser() = default;
+        virtual bool ParseStringSource(const char* str) = 0;
+        virtual bool ParseFileSource(const char* filePath) = 0;
+        virtual std::unique_ptr<std::vector<DanmakuRef>> GetDanmakus() = 0;
+    };
+
+    typedef std::shared_ptr<IParser> ParserRef;
+
+}
+
+#endif // _WTF_IPARSER_HPP