Projektdateien hinzufügen.

GSL Linux/GSL Linux.vcxproj

@@ -0,0 +1,87 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\GSL\GSLDatei.h" />
+    <ClInclude Include="..\GSL\Include\GSLDateiV.h" />
+    <ClInclude Include="..\GSL\Include\GSLSoundV.h" />
+    <ClInclude Include="..\GSL\Player.h" />
+    <ClInclude Include="..\GSL\Sound.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\GSL\Einstieg.cpp" />
+    <ClCompile Include="..\GSL\GSLDatei.cpp" />
+    <ClCompile Include="..\GSL\Player.cpp" />
+    <ClCompile Include="..\GSL\Sound.cpp" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{18020fa4-3b8f-4f29-9865-32558c2912e8}</ProjectGuid>
+    <Keyword>Linux</Keyword>
+    <RootNamespace>GSL_Linux</RootNamespace>
+    <MinimumVisualStudioVersion>15.0</MinimumVisualStudioVersion>
+    <ApplicationType>Linux</ApplicationType>
+    <ApplicationTypeRevision>1.0</ApplicationTypeRevision>
+    <TargetLinuxPlatform>Generic</TargetLinuxPlatform>
+    <LinuxProjectType>{D51BCBC9-82E9-4017-911E-C93873C4EA2B}</LinuxProjectType>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings" />
+  <ImportGroup Label="Shared" />
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <IncludePath>..\..\Framework;../../Framework/release;$(IncludePath);$(ISenseIncludePath);../GSL/Include</IncludePath>
+    <TargetName>gsl</TargetName>
+    <TargetExt>.so</TargetExt>
+    <RemoteProjectDir>$(RemoteRootDir)/gsl/release</RemoteProjectDir>
+    <SourcePath>
+    </SourcePath>
+    <OutDir>$(ProjectDir)bin\$(Platform)\release\</OutDir>
+    <IntDir>$(ProjectDir)obj\$(Platform)\release\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <IncludePath>..\..\Framework;../../Framework/debug;$(IncludePath);$(ISenseIncludePath);../GSL/Include</IncludePath>
+    <TargetName>dbggsl</TargetName>
+    <TargetExt>.so</TargetExt>
+    <RemoteProjectDir>$(RemoteRootDir)/gsl/debug</RemoteProjectDir>
+    <OutDir>$(ProjectDir)bin\$(Platform)\debug\</OutDir>
+    <IntDir>$(ProjectDir)obj\$(Platform)\debug\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Link>
+      <UnresolvedSymbolReferences>false</UnresolvedSymbolReferences>
+    </Link>
+    <ClCompile />
+    <ClCompile>
+      <AdditionalOptions>-fPIC %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Link>
+      <UnresolvedSymbolReferences>false</UnresolvedSymbolReferences>
+    </Link>
+    <ClCompile>
+      <AdditionalOptions>-fPIC %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets" />
+</Project>

GSL Linux/GSL Linux.vcxproj.filters

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Quelldateien">
+      <UniqueIdentifier>{c455f506-5bd7-446d-9416-3753264667e6}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Headerdateien">
+      <UniqueIdentifier>{29af5c28-7c5f-45da-931c-d78d519ae1c9}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\GSL\Include\GSLSoundV.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="..\GSL\Include\GSLDateiV.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="..\GSL\Player.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="..\GSL\Sound.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="..\GSL\GSLDatei.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\GSL\Einstieg.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="..\GSL\GSLDatei.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="..\GSL\Player.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="..\GSL\Sound.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>

GSL Linux/readme/readme.html

@@ -0,0 +1,85 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset='utf-8'>
+
+    <link rel="stylesheet" type="text/css" href="stylesheet.css" media="screen">
+
+    <title>Getting Started</title>
+  </head>
+
+<body>
+
+    <div class="container">
+        <div id="header">
+            <h1>Getting Started</h1>
+            <h2>Visual C++ for Linux Development extension</h2>
+        </div>
+    
+    <table>
+    <tr>    
+    <div id="main_content">
+        
+        <td>
+        <div id="lpanel">
+            <h1>Setting up your project for Linux Development</h1>
+
+            <p>With this extension you can author C++ code for Linux servers, desktops and devices. You can manage your connections to these machines from within VS. VS will automatically copy and remote build your sources and can launch your application with the debugger. Our project system supports targeting specific architectures, including ARM.</p>
+            <img src="images\ArchOptions.gif"/>
+            
+            <h1>Connecting to Linux</h1>
+            <h2>Prerequisites</h2>
+            <p>Today we only support building remotely on the Linux target machine. We are not limited by specific Linux distros but we do have dependencies on the presence of some tools. Specifically, we need openssh-server, g++, gdb and gdbserver. Use your favorite package manager to install them, e.g. on Debian based systems: sudo apt-get install openssh-server g++ gdb gdbserver</p>
+            
+            <h2>First connection</h2>
+            <p>The first time you target a Linux machine you will be prompted for connection information.  This is triggered by building the project.</p>
+            <img src="images\firstconnection.png"/>
+                
+            <h2>Adding and removing connections</h2>
+            <p>To add a new connection, go to Tools > Options and search for Linux. From here you can add and remove connections.</p>
+            <img src="images\ManageConnections.gif"/>
+            
+            <p>To change which connection a project is using go to the project properties remote settings and update the target machine.</p>
+            <img src="images\ChangeRemote.gif"/>
+            
+            <h1>Project Properties</h1>
+            <p>All of the options necessary to control C++ compilation are exposed on the project properies pages. We'll cover a few specific to how things work for Linux. First under remote settings, you will see the remote root is set to ~/projects/ by default and that we are setting the remote project directory to match our project name in that location. </p>
+            <img src="images\OutputTypes.gif"/>
+            
+            <p>Looking at the General settings for the project, you can see how our output and intermediate directories were configured. Additionally, you’ll see that this project was configured as an application – thus our executable is under bin/x64/Debug/ as ConsoleApplication1.out. Notice that for configuration types we also support static and dynamic libraries.</p>
+            
+            <p>Add additional library dependencies on the Linker > Input property page.</p>
+            <img src="images\linker.png"/>
+            
+            <p>You can pass additional pre launch commands to the debugger to do things like launch graphical apps on the remote linux machine.</p>
+            <img src="images\debuggerexport.png"/>
+            
+            <p>You can also send post build events to control remote behavior, as in this example that exports a gpio pin for use without requiring the executable run as super user.</p>
+            <img src="images\postbuild.png"/>
+            
+        </div>
+        </td>
+        <td>
+        <div id="rpanel">
+
+            <h1>Resources</h1>
+
+            <p>Check out the <a href="http://aka.ms/vslinuxext">VS Gallery VC++ for Linux Development page</a> where we will keep updates posted. You can also check out our <a href="https://blogs.msdn.microsoft.com/vcblog/2016/03/30/visual-c-for-linux-development">announcment blog post</a> for more in depth details on configuring the project properties.</p>
+            
+            <p>Here are other utilities you will find useful in connection with this extension.</p>
+            <ul>
+                <li>Learn more about <a href="http://aka.ms/vsiot">IoT Development</a></li>
+                <li><a href="http://aka.ms/vsiotext">VC++ for IoT Development Tools</a></li>
+                <li><a href="https://github.com/Azure/azure-iot-sdks">Azure IoT SDK</a>, includes a C API for connecting small devices to the Azure IoT Hub</li>
+            </ul>
+
+            <h1>Give us feedback</h1>
+            <p><a href="http://aka.ms/vslinux-feedback">UserVoice</a></p>
+        </div>
+        </td>   
+    </div>
+    </tr>
+    </table>
+    </div>
+</body>
+</html>

GSL Linux/readme/stylesheet.css

@@ -0,0 +1,119 @@
+body {
+  margin: 0;
+  padding: 0;
+  border: 0;
+  color: #1E1E1E;
+  font-size: 13px;
+  font-family: "Segoe UI", Helvetica, Arial, sans-serif;
+  line-height: 1.45;
+  word-wrap: break-word;
+}
+
+/* General & 'Reset' Stuff */
+
+
+.container {
+  width: 1100px;
+  margin: 0 auto;
+}
+
+section {
+  display: block;
+  margin: 0;
+}
+
+h1, h2, h3, h4, h5, h6 {
+  margin: 0;
+}
+
+table, tr {
+    width: 1100px;
+    padding: 0px;
+    vertical-align: top;
+  }
+
+/* Header, <header>
+   header   - container
+   h1       - project name
+   h2       - project description
+*/
+
+#header {
+  color: #FFF;
+  background: #68217a;
+  position:relative;
+}
+h1, h2 {
+  font-family: "Segoe UI Light", "Segoe UI", Helvetica, Arial, sans-serif;
+  line-height: 1;
+  margin: 0 18px;;
+  padding: 0;
+}
+#header h1 {
+  font-size: 3.4em;
+  padding-top: 18px;
+  font-weight: normal;
+  margin-left: 15px;
+}
+
+#header h2 {
+  font-size: 1.5em;
+  margin-top: 10px;
+  padding-bottom: 18px;
+  font-weight: normal;
+}
+
+#main_content {
+  width: 100%;
+  display: flex;
+  flex-direction: row;
+}
+
+
+h1, h2, h3, h4, h5, h6 {
+  font-weight: bolder;
+}
+
+#main_content h1 {
+  font-size: 1.8em;
+  margin-top: 34px;
+}
+
+    #main_content h1:first-child {
+        margin-top: 30px;
+    }
+
+#main_content h2 {
+  font-size: 1.8em;
+}
+p, ul {
+    margin: 11px 18px;
+}
+
+#main_content a {
+    color: #06C;
+    text-decoration: none;
+}
+ul {
+        margin-top: 13px;
+    margin-left: 18px;
+    padding-left: 0;
+}
+    ul li {
+        margin-left: 18px;
+        padding-left: 0;
+    }
+#lpanel {
+    width: 870px;
+    float: left;
+}
+#rpanel ul {
+    list-style-type: none;
+}
+    #rpanel ul li {
+        line-height: 1.8em;
+    }
+#rpanel {
+    background: #e7e7e7;
+    width: 230px;
+}

GSL.sln

@@ -0,0 +1,42 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.26020.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GSL", "GSL\GSL.vcxproj", "{91CDEEEA-E249-45DF-812A-A30E27A44066}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GSL Linux", "GSL Linux\GSL Linux.vcxproj", "{18020FA4-3B8F-4F29-9865-32558C2912E8}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|ARM = Debug|ARM
+		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
+		Release|ARM = Release|ARM
+		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{91CDEEEA-E249-45DF-812A-A30E27A44066}.Debug|ARM.ActiveCfg = Debug|Win32
+		{91CDEEEA-E249-45DF-812A-A30E27A44066}.Debug|Win32.ActiveCfg = Debug|Win32
+		{91CDEEEA-E249-45DF-812A-A30E27A44066}.Debug|Win32.Build.0 = Debug|Win32
+		{91CDEEEA-E249-45DF-812A-A30E27A44066}.Debug|x64.ActiveCfg = Debug|x64
+		{91CDEEEA-E249-45DF-812A-A30E27A44066}.Debug|x64.Build.0 = Debug|x64
+		{91CDEEEA-E249-45DF-812A-A30E27A44066}.Release|ARM.ActiveCfg = Release|Win32
+		{91CDEEEA-E249-45DF-812A-A30E27A44066}.Release|Win32.ActiveCfg = Release|Win32
+		{91CDEEEA-E249-45DF-812A-A30E27A44066}.Release|Win32.Build.0 = Release|Win32
+		{91CDEEEA-E249-45DF-812A-A30E27A44066}.Release|x64.ActiveCfg = Release|x64
+		{91CDEEEA-E249-45DF-812A-A30E27A44066}.Release|x64.Build.0 = Release|x64
+		{18020FA4-3B8F-4F29-9865-32558C2912E8}.Debug|ARM.ActiveCfg = Debug|x64
+		{18020FA4-3B8F-4F29-9865-32558C2912E8}.Debug|Win32.ActiveCfg = Debug|x64
+		{18020FA4-3B8F-4F29-9865-32558C2912E8}.Debug|x64.ActiveCfg = Debug|x64
+		{18020FA4-3B8F-4F29-9865-32558C2912E8}.Debug|x64.Build.0 = Debug|x64
+		{18020FA4-3B8F-4F29-9865-32558C2912E8}.Release|ARM.ActiveCfg = Release|x64
+		{18020FA4-3B8F-4F29-9865-32558C2912E8}.Release|Win32.ActiveCfg = Release|x64
+		{18020FA4-3B8F-4F29-9865-32558C2912E8}.Release|x64.ActiveCfg = Release|x64
+		{18020FA4-3B8F-4F29-9865-32558C2912E8}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

GSL/Einstieg.cpp

@@ -0,0 +1,42 @@
+#ifdef WIN32
+#include "Player.h"
+#include "Include/GSLDateiV.h"
+#else
+#include "Player.h"
+#include "GSLDateiV.h"
+#endif
+
+using namespace GSL;
+
+#ifdef WIN32
+extern GSLPlayer *_player;
+static int numInits = 0;
+
+int WINAPI DllMain( HINSTANCE hinst, DWORD fdwReason, LPVOID lpvReserved )
+{
+	switch( fdwReason )
+	{
+	case DLL_PROCESS_DETACH:
+		delete _player;
+		_player = 0;
+		break;
+	case DLL_PROCESS_ATTACH:
+		_player = new GSLPlayer();
+		return 1;
+	}
+	return 0;
+}
+#endif
+
+extern "C"
+{
+	__declspec( dllexport ) GSLSoundV *getSound( SoundKopf &kpf )
+	{
+		return new GSLSound( kpf );
+	}
+
+	__declspec( dllexport ) GSLDateiV *getGSLDatei()
+	{
+		return new GSLDatei();
+	}
+}

GSL/GSL.vcxproj

@@ -0,0 +1,188 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="Einstieg.cpp" />
+    <ClCompile Include="GSLDatei.cpp" />
+    <ClCompile Include="Player.cpp" />
+    <ClCompile Include="Sound.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="GSLDatei.h" />
+    <ClInclude Include="Include\GSLDateiV.h" />
+    <ClInclude Include="Include\GSLSoundV.h" />
+    <ClInclude Include="Player.h" />
+    <ClInclude Include="Sound.h" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{91CDEEEA-E249-45DF-812A-A30E27A44066}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>GSL</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\Framework;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\Framework;$(IncludePath)</IncludePath>
+    <LibraryPath>..\..\Framework\x64\Debug;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>..\..\Framework;$(IncludePath)</IncludePath>
+    <LibraryPath>..\..\Framework\Release;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>..\..\Framework;$(IncludePath)</IncludePath>
+    <LibraryPath>..\..\Framework\x64\Release;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;GSL_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>Framework.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;GSL_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>Framework.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <CustomBuildStep>
+      <Command>copy "..\x64\Debug\GSL.dll" "..\..\..\Spiele Platform\Klient\patcher\patcher\data\bin\GSL.dll"</Command>
+    </CustomBuildStep>
+    <CustomBuildStep>
+      <Outputs>kopieren...;%(Outputs)</Outputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;GSL_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>Framework.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <CustomBuildStep>
+      <Command>copy "..\Release\GSL.dll" "..\..\..\Spiele Platform\Klient\Fertig\x32\data\bin\GSL.dll"</Command>
+    </CustomBuildStep>
+    <CustomBuildStep>
+      <Outputs>kopieren...;%(Outputs)</Outputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;GSL_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>Framework.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <CustomBuildStep>
+      <Command>copy "..\x64\Release\GSL.dll" "..\..\..\Spiele Platform\Klient\Fertig\x64\data\bin\GSL.dll"</Command>
+    </CustomBuildStep>
+    <CustomBuildStep>
+      <Outputs>kopieren...;%(Outputs)</Outputs>
+    </CustomBuildStep>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

GSL/GSL.vcxproj.filters

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Quelldateien">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Headerdateien">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Ressourcendateien">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="Player.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Sound.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Einstieg.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="GSLDatei.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="Player.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Sound.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="GSLDatei.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\GSLSoundV.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Include\GSLDateiV.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

GSL/GSLDatei.cpp

@@ -0,0 +1,495 @@
+#include "GSLDatei.h"
+#ifdef WIN32
+#include "Sound.h"
+#else
+#include "Sound.h"
+#endif
+
+using namespace GSL;
+
+// Inhalt der GSLDatei Klasse aus GSLDatei.h
+// Konstruktor
+GSLDatei::GSLDatei()
+{
+	sounds = new Array< SoundKopf >();
+	pfad = new Text();
+	InitializeCriticalSection( &cs );
+	ref = 1;
+}
+
+// Destruktor
+GSLDatei::~GSLDatei()
+{
+	sounds->release();
+	pfad->release();
+	DeleteCriticalSection( &cs );
+}
+
+// Datei open
+void GSLDatei::setDatei( Framework::Text *txt )
+{
+	EnterCriticalSection( &cs );
+	pfad->setText( txt );
+	LeaveCriticalSection( &cs );
+}
+
+void GSLDatei::setDatei( char *txt )
+{
+	EnterCriticalSection( &cs );
+	pfad->setText( txt );
+	LeaveCriticalSection( &cs );
+}
+
+bool GSLDatei::leseDaten()
+{
+	EnterCriticalSection( &cs );
+	sounds->leeren();
+	Datei d;
+	d.setDatei( *pfad );
+	if( !d.getSize() )
+		return 1;
+	if( !d.open( Datei::Style::lesen ) )
+	{
+		LeaveCriticalSection( &cs );
+		return 0;
+	}
+	unsigned char sAnz = 0;
+	d.lese( (char*)&sAnz, 1 );
+	// Datei Sound - Köpfe einlesen
+	for( int i = 0; i < sAnz; i++ )
+	{
+		SoundKopf kpf;
+		bool bit = 0;
+		char len = 0;
+		// Namenslänge lesen
+		for( int i = 0; i < 4; i++ )
+		{
+			d.getNextBit( bit );
+			len = (char)( len | ( ( (char)bit << ( 3 - i ) ) & ( 1 << ( 3 - i ) ) ) );
+		}
+		len &= 15;
+		// Name lesen
+		for( int i = 0; i < len; i++ )
+		{
+			char zeichen = 0;
+			for( int j = 0; j < 5; j++ )
+			{
+				d.getNextBit( bit );
+				zeichen = (char)( zeichen | ( ( (char)bit << ( 4 - j ) ) & ( 1 << ( 4 - j ) ) ) );
+			}
+			zeichen &= 31;
+			if( zeichen == 27 )
+				zeichen = 'ü';
+			if( zeichen == 28 )
+				zeichen = 'ö';
+			if( zeichen == 29 )
+				zeichen = 'ä';
+			if( zeichen == 30 )
+				zeichen = 'ß';
+			if( zeichen == 31 )
+				zeichen = '.';
+			if( zeichen < 27 )
+				zeichen = (char)( zeichen + 'a' );
+			kpf.name.append( &zeichen, 1 );
+		} // Chanel Anzahl lesen
+		d.getNextBit( bit );
+		kpf.channels = (char)( bit + 1 );
+		// Sample Rate lesen
+		d.lese( (char*)&kpf.sampleRate, 4 );
+		// Position des Sounds in der Datei lesen
+		d.lese( (char*)&kpf.datPos, 8 );
+		// Länge des Sounds lesen
+		int sLen = 0;
+		d.lese( (char*)&sLen, 4 );
+		kpf.datEnd = kpf.datPos + sLen;
+		kpf.pfad = pfad->getText();
+		sounds->add( kpf );
+	}
+	d.close();
+	LeaveCriticalSection( &cs );
+	return 1;
+}
+
+int GSLDatei::getSoundAnzahl()
+{
+	return sounds->getEintragAnzahl();
+}
+
+Text *GSLDatei::getSoundName( int num )
+{
+	if( !sounds->hat( num ) )
+		return 0;
+	return new Text( sounds->get( num ).name );
+}
+
+// Laden
+GSLSoundV *GSLDatei::getSound( Framework::Text *name )
+{
+	GSLSoundV *ret = getSound( *name );
+	name->release();
+	return ret;
+}
+
+GSLSoundV *GSLDatei::getSound( char *name )
+{
+	EnterCriticalSection( &cs );
+	int anz = sounds->getEintragAnzahl();
+	for( int i = 0; i < anz; i++ )
+	{
+		if( sounds->get( i ).name.istGleich( name ) )
+		{
+			LeaveCriticalSection( &cs );
+			return new GSLSound( sounds->get( i ) );
+		}
+	}
+	LeaveCriticalSection( &cs );
+	return 0;
+}
+
+// Speichern
+bool GSLDatei::speicherSound( GSLSoundV *zSound, Framework::Text *name )
+{
+	bool ret = speicherSound( zSound, *name );
+	name->release();
+	return ret;
+}
+
+bool GSLDatei::speicherSound( GSLSoundV *zSound, char *name )
+{
+	Text kName;
+	for( char *c = name; *c; ++c )
+	{
+		if( *c >= 'A' && *c <= 'Z' )
+			kName.append( (char)( *c + 32 ) );
+		if( *c >= 'a' && *c <= 'z' )
+			kName.append( *c );
+		if( *c == 'Ü' || *c == 'ü' )
+			kName.append( 'ü' );
+		if( *c == 'Ö' || *c == 'ö' )
+			kName.append( 'ö' );
+		if( *c == 'Ä' || *c == 'ä' )
+			kName.append( 'ä' );
+		if( *c == 'ß' )
+			kName.append( 'ß' );
+		if( *c == '.' )
+			kName.append( '.' );
+		if( kName.getLength() == 15 )
+			break;
+	}
+	name = kName;
+	EnterCriticalSection( &cs );
+	// Prüfen ob bereits vorhanden
+	int anz = sounds->getEintragAnzahl();
+	for( int i = 0; i < anz; i++ )
+	{
+		if( sounds->get( i ).name.istGleich( name ) )
+		{
+			LeaveCriticalSection( &cs );
+			return 0;
+		}
+	}
+	Text tmpPf = pfad->getText();
+	tmpPf += "_";
+	GetFreePfad( &tmpPf );
+	Datei tmp;
+	tmp.setDatei( tmpPf );
+	tmp.erstellen();
+	if( !tmp.open( Datei::Style::schreiben ) )
+	{
+		LeaveCriticalSection( &cs );
+		return 0;
+	}
+	char *buffer = new char[ 0x4000 ];
+	// Neuen Sound in Temporäre Datei schreiben
+	zSound->open();
+	while( 1 )
+	{
+		int len = 0;
+		if( ( len = zSound->getDaten( buffer, 0x4000 ) ) < 0 )
+			break;
+		tmp.schreibe( buffer, len );
+	}
+	zSound->close();
+	delete buffer;
+	tmp.close();
+	int hLen = 1;
+	unsigned char sAnz = (unsigned char)sounds->getEintragAnzahl();
+	// Sound Kopf Länge errechnen
+	for( int i = 0; i < sAnz; i++ )
+	{
+		SoundKopf kpf = sounds->get( i );
+		hLen += ( 140 + 5 * kpf.name.getLength() ) / 8;
+	}
+	Datei alt;
+	alt.setDatei( *pfad );
+	// Sound Kopf Erstellen
+	SoundKopf kpf;
+	kpf.channels = (char)( !zSound->istMono() + 1 );
+	kpf.name = name;
+	kpf.pfad = pfad->getText();
+	kpf.sampleRate = zSound->getSampleRate();
+	kpf.datPos = ( alt.getSize() <= 0 ? 1 : alt.getSize() );
+	kpf.datEnd = tmp.getSize() + kpf.datPos;
+	sounds->add( kpf );
+	Text neuPf = pfad->getText();
+	neuPf += "_";
+	GetFreePfad( &neuPf );
+	Datei neu;
+	neu.setDatei( neuPf );
+	neu.erstellen();
+	if( !neu.open( Datei::Style::schreiben ) )
+	{
+		sounds->remove( sAnz );
+		tmp.remove();
+		LeaveCriticalSection( &cs );
+		return 0;
+	}
+	sAnz = (unsigned char)sounds->getEintragAnzahl();
+	neu.schreibe( (char*)&sAnz, 1 );
+	// Sound Köpfe speichern
+	for( int i = 0; i < sAnz; i++ )
+	{
+		SoundKopf k = sounds->get( i );
+		k.datPos += ( 140 + 5 * kpf.name.getLength() ) / 8;
+		k.datEnd += ( 140 + 5 * kpf.name.getLength() ) / 8;
+		int l = k.name.getLength();
+		// Namenslänge speichern
+		neu.setNextBit( ( l & 8 ) != 0 );
+		neu.setNextBit( ( l & 4 ) != 0 );
+		neu.setNextBit( ( l & 2 ) != 0 );
+		neu.setNextBit( ( l & 1 ) != 0 );
+		for( int j = 0; j < l; j++ )
+		{ // Name speichern
+			char c = k.name.getText()[ j ];
+			if( c == 'ü' )
+				c = 27;
+			if( c == 'ö' )
+				c = 28;
+			if( c == 'ä' )
+				c = 29;
+			if( c == 'ß' )
+				c = 30;
+			if( c == '.' )
+				c = 31;
+			if( c >= 'a' && c <= 'z' )
+				c = (char)( c - 'a' );
+			neu.setNextBit( ( c & 16 ) != 0 );
+			neu.setNextBit( ( c & 8 ) != 0 );
+			neu.setNextBit( ( c & 4 ) != 0 );
+			neu.setNextBit( ( c & 2 ) != 0 );
+			neu.setNextBit( ( c & 1 ) != 0 );
+		} // Chanels speichern
+		neu.setNextBit( ( k.channels - 1 ) == 1 );
+		// Sample Rate speichern
+		neu.schreibe( (char*)&k.sampleRate, 4 );
+		// Datei Position schreiben
+		neu.schreibe( (char*)&k.datPos, 8 );
+		// Länge des Sounds Speichern
+		int sLen = (int)( k.datEnd - k.datPos );
+		neu.schreibe( (char*)&sLen, 4 );
+	}
+	// alte Sounds kopieren
+	char *byte = new char[ 2048 ];
+	if( sAnz > 1 )
+	{
+		if( !alt.open( Datei::Style::lesen ) )
+		{
+			tmp.remove();
+			neu.close();
+			neu.remove();
+			sounds->remove( sAnz );
+			LeaveCriticalSection( &cs );
+			return 0;
+		}
+		alt.setLPosition( hLen, 0 );
+		for( __int64 i = hLen; i < alt.getSize(); )
+		{
+			int l = 2048;
+			if( l > alt.getSize() - i )
+				l = (int)( alt.getSize() - i );
+			alt.lese( byte, l );
+			neu.schreibe( byte, l );
+			i += l;
+		}
+		alt.close();
+	}
+	// Neuen Sound kopieren
+	if( !tmp.open( Datei::Style::lesen ) )
+	{
+		tmp.remove();
+		neu.close();
+		neu.remove();
+		sounds->remove( sAnz );
+		LeaveCriticalSection( &cs );
+		return 0;
+	}
+	for( int i = 0; i < (int)tmp.getSize(); )
+	{
+		int l = 2048;
+		if( l > tmp.getSize() - i )
+			l = (int)( tmp.getSize() - i );
+		tmp.lese( byte, l );
+		neu.schreibe( byte, l );
+		i += l;
+	}
+	delete[] byte;
+	tmp.close();
+	neu.close();
+	// Dateien Umbenennen und remove
+	tmp.remove();
+	alt.remove();
+	neu.umbenennen( *pfad );
+	leseDaten();
+	LeaveCriticalSection( &cs );
+	return 1;
+}
+
+// Löschen
+bool GSLDatei::removeSound( Framework::Text *name )
+{
+	bool ret = removeSound( *name );
+	name->release();
+	return ret;
+}
+
+bool GSLDatei::removeSound( char *name )
+{
+	EnterCriticalSection( &cs );
+	// Prüfen ob vorhanden
+	int anz = sounds->getEintragAnzahl();
+	int num = -1;
+	for( int i = 0; i < anz; i++ )
+	{
+		if( sounds->get( i ).name.istGleich( name ) )
+		{
+			num = i;
+			break;
+		}
+	}
+	if( num < 0 )
+	{
+		LeaveCriticalSection( &cs );
+		return 1;
+	}
+	Text neuPf = pfad->getText();
+	neuPf += "_";
+	GetFreePfad( &neuPf );
+	Datei neu;
+	neu.setDatei( neuPf );
+	neu.erstellen();
+	if( !neu.open( Datei::Style::schreiben ) )
+	{
+		LeaveCriticalSection( &cs );
+		return 0;
+	}
+	SoundKopf kpf = sounds->get( num );
+	unsigned char sAnz = (unsigned char)( anz - 1 );
+	neu.schreibe( (char*)&sAnz, 1 );
+	// Sound Köpfe speichern
+	for( int i = 0; i <= sAnz; i++ )
+	{
+		if( i == num )
+			continue;
+		SoundKopf k = sounds->get( i );
+		k.datPos -= ( 140 + 5 * kpf.name.getLength() ) / 8;
+		k.datEnd -= ( 140 + 5 * kpf.name.getLength() ) / 8;
+		if( i > num )
+		{
+			k.datPos -= kpf.datEnd - kpf.datPos;
+			k.datEnd -= kpf.datEnd - kpf.datPos;
+		}
+		int l = k.name.getLength();
+		// Namenslänge speichern
+		neu.setNextBit( ( l & 8 ) != 0 );
+		neu.setNextBit( ( l & 4 ) != 0 );
+		neu.setNextBit( ( l & 2 ) != 0 );
+		neu.setNextBit( ( l & 1 ) != 0 );
+		for( int j = 0; j < l; j++ )
+		{ // Name speichern
+			char c = k.name.getText()[ j ];
+			if( c == 'ü' )
+				c = 27;
+			if( c == 'ö' )
+				c = 28;
+			if( c == 'ä' )
+				c = 29;
+			if( c == 'ß' )
+				c = 30;
+			if( c == '.' )
+				c = 31;
+			if( c >= 'a' && c <= 'z' )
+				c = (char)( c - 'a' );
+			neu.setNextBit( ( c & 16 ) != 0 );
+			neu.setNextBit( ( c & 8 ) != 0 );
+			neu.setNextBit( ( c & 4 ) != 0 );
+			neu.setNextBit( ( c & 2 ) != 0 );
+			neu.setNextBit( ( c & 1 ) != 0 );
+		} // Chanels speichern
+		neu.setNextBit( ( k.channels - 1 ) == 1 );
+		// Sample Rate speichern
+		neu.schreibe( (char*)&k.sampleRate, 4 );
+		// Datei Position schreiben
+		neu.schreibe( (char*)&k.datPos, 8 );
+		// Länge des Sounds Speichern
+		int sLen = (int)( k.datEnd - k.datPos );
+		neu.schreibe( (char*)&sLen, 4 );
+	}
+	// Alte Sounds kopieren
+	Datei alt;
+	alt.setDatei( *pfad );
+	if( sAnz )
+	{
+		if( !alt.open( Datei::Style::lesen ) )
+		{
+			neu.close();
+			neu.remove();
+			LeaveCriticalSection( &cs );
+			return 0;
+		}
+		alt.setLPosition( neu.getSPosition() + ( 140 + 5 * kpf.name.getLength() ) / 8, 0 );
+		char *byte = new char[ 2048 ];
+		for( __int64 i = alt.getLPosition(); i < kpf.datPos; )
+		{
+			int l = 2048;
+			if( l > kpf.datPos - i )
+				l = (int)( kpf.datPos - i );
+			alt.lese( byte, l );
+			neu.schreibe( byte, l );
+			i += l;
+		}
+		alt.setLPosition( kpf.datEnd, 0 );
+		for( __int64 i = alt.getLPosition(); i < alt.getSize(); )
+		{
+			int l = 2048;
+			if( l > alt.getSize() - i )
+				l = (int)( alt.getSize() - i );
+			alt.lese( byte, l );
+			neu.schreibe( byte, l );
+			i += l;
+		}
+		delete[] byte;
+		alt.close();
+	}
+	neu.close();
+	// Dateien Umbenennen und remove
+	alt.remove();
+	neu.umbenennen( *pfad );
+	leseDaten();
+	LeaveCriticalSection( &cs );
+	return 1;
+}
+
+// Reference Counting
+GSLDateiV *GSLDatei::getThis()
+{
+	ref++;
+	return this;
+}
+
+GSLDateiV *GSLDatei::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

GSL/GSLDatei.h

@@ -0,0 +1,61 @@
+#ifndef GSLDatei_H
+#define GSLDatei_H
+
+#include <Text.h>
+#include <Array.h>
+#include <Datei.h>
+#ifdef WIN32
+#include "Include/GSLDateiV.h"
+#else
+#include "GSLDateiV.h"
+#endif
+
+using namespace Framework;
+
+namespace GSL
+{
+	struct SoundKopf
+	{
+		Text name;
+		char channels;
+		unsigned int sampleRate;
+		__int64 datPos;
+		__int64 datEnd;
+		Text pfad;
+	};
+
+	class GSLDatei : public GSLDateiV
+	{
+	private:
+		Array< SoundKopf > *sounds;
+		Text *pfad;
+		CRITICAL_SECTION cs;
+		int ref;
+
+	public:
+		// Konstruktor
+		GSLDatei();
+		// Destruktor
+		~GSLDatei();
+		// Datei open
+		void setDatei( Framework::Text *txt ) override;
+		void setDatei( char *txt ) override;
+		bool leseDaten() override;
+		int getSoundAnzahl() override;
+		Text *getSoundName( int num ) override;
+		// Laden
+		GSLSoundV *getSound( Framework::Text *name ) override;
+		GSLSoundV *getSound( char *name ) override;
+		// Speichern
+		bool speicherSound( GSLSoundV *zSound, Framework::Text *name ) override;
+		bool speicherSound( GSLSoundV *zSound, char *name ) override;
+		// Löschen
+		bool removeSound( Framework::Text *name ) override;
+		bool removeSound( char *name ) override;
+		// Reference Counting
+		GSLDateiV *getThis() override;
+		GSLDateiV *release() override;
+	};
+}
+
+#endif

GSL/Include/GSLDateiV.h

@@ -0,0 +1,34 @@
+#ifndef GSLDateiV_H
+#define GSLDateiV_H
+
+#include <Text.h>
+#include "GSLSoundV.h"
+
+namespace GSL
+{
+    class GSLDateiV
+    {
+    public:
+        virtual ~GSLDateiV()
+        {}
+        virtual void setDatei( Framework::Text *txt ) = 0;
+        virtual void setDatei( char *txt ) = 0;
+        virtual bool leseDaten() = 0;
+        virtual int getSoundAnzahl() = 0;
+        virtual Framework::Text *getSoundName( int num ) = 0;
+        // Laden
+        virtual GSLSoundV *getSound( Framework::Text *name ) = 0;
+        virtual GSLSoundV *getSound( char *name ) = 0;
+        // Speichern
+        virtual bool speicherSound( GSLSoundV *zSound, Framework::Text *name ) = 0;
+        virtual bool speicherSound( GSLSoundV *zSound, char *name ) = 0;
+        // Löschen
+        virtual bool removeSound( Framework::Text *name ) = 0;
+        virtual bool removeSound( char *name ) = 0;
+        // Reference Counting
+        virtual GSLDateiV *getThis() = 0;
+        virtual GSLDateiV *release() = 0;
+    };
+}
+
+#endif

GSL/Include/GSLSoundV.h

@@ -0,0 +1,32 @@
+#ifndef GSLSoundV_H
+#define GSLSoundV_H
+
+#include <Thread.h>
+
+namespace GSL
+{
+    class GSLSoundV : protected Framework::Thread
+    {
+    public:
+        virtual ~GSLSoundV()
+        {}
+        virtual void playSound() = 0;
+        virtual void setPause( bool p ) = 0;
+        virtual void stopSound() = 0;
+        virtual void warteAufSound( int zeit ) = 0;
+        // Lautstärke: 0 - 0xFFFF
+        virtual void setVolume( unsigned int links, unsigned int rechts ) = 0;
+        // zum Speichern
+        virtual void open() = 0;
+        virtual int getDaten( char *buffer, int len ) = 0;
+        virtual void close() = 0;
+        virtual bool istMono() const = 0;
+        virtual int getSampleRate() const = 0;
+        virtual __int64 getDatLength() const = 0;
+        // Reference Counting
+        virtual GSLSoundV *getThis() = 0;
+        virtual GSLSoundV *release() = 0;
+    };
+}
+
+#endif

GSL/Player.cpp

@@ -0,0 +1,78 @@
+#include "Player.h"
+
+using namespace GSL;
+
+GSLPlayer *_player = 0;
+
+#ifdef WIN32
+void CALLBACK AudioOutProc( HWAVEOUT hOut, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2 )
+{
+	_player->sendSoundMSG( hOut, uMsg, dwInstance, dwParam1, dwParam2 );
+}
+#endif
+
+// Inhalt der GSLPlayer Klasse aus Player.h
+// Konstruktor
+GSLPlayer::GSLPlayer()
+{
+	InitializeCriticalSection( &cs );
+}
+
+// Destruktor
+GSLPlayer::~GSLPlayer()
+{
+	sounds.leeren();
+	DeleteCriticalSection( &cs );
+}
+
+// nicht constant
+bool GSLPlayer::addSound( GSLSound *snd )
+{
+	EnterCriticalSection( &cs );
+	int anz = sounds.getEintragAnzahl();
+	for( int i = 0; i < anz; i++ )
+	{
+		if( sounds.z( i ) == snd )
+		{
+			snd->release();
+			LeaveCriticalSection( &cs );
+			return 0;
+		}
+	}
+	sounds.add( snd );
+	LeaveCriticalSection( &cs );
+	return 1;
+}
+
+void GSLPlayer::removeSound( GSLSound *zSnd )
+{
+	EnterCriticalSection( &cs );
+	int anz = sounds.getEintragAnzahl();
+	for( int i = 0; i < anz; i++ )
+	{
+		if( sounds.z( i ) == zSnd )
+		{
+			LeaveCriticalSection( &cs );
+			sounds.remove( i );
+			return;
+		}
+	}
+	LeaveCriticalSection( &cs );
+}
+
+#ifdef WIN32
+void GSLPlayer::sendSoundMSG( HWAVEOUT hOut, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2 )
+{
+	EnterCriticalSection( &cs );
+	int anz = sounds.getEintragAnzahl();
+	for( int i = 0; i < anz; i++ )
+	{
+		if( sounds.z( i ) && sounds.z( i )->getHandle() == hOut )
+		{
+			sounds.z( i )->msg( uMsg, dwInstance, dwParam1, dwParam2 );
+			break;
+		}
+	}
+	LeaveCriticalSection( &cs );
+}
+#endif

GSL/Player.h

@@ -0,0 +1,43 @@
+#ifndef Player_H
+#define Player_H
+
+#ifdef WIN32
+#include <io.h>
+#include <stdio.h>
+#include <windows.h>
+#include <windowsx.h>
+#include <mmsystem.h>
+#include <Array.h>
+#include "Sound.h"
+
+#pragma comment( lib, "winmm.lib" )
+#else
+#include <Array.h>
+#include "Sound.h"
+#endif
+
+using namespace Framework;
+
+namespace GSL
+{
+	class GSLPlayer
+	{
+	private:
+		RCArray< GSLSound > sounds;
+		CRITICAL_SECTION cs;
+
+	public:
+		// Konstruktor
+		GSLPlayer();
+		// Destruktor
+		~GSLPlayer();
+		// nicht constant
+		bool addSound( GSLSound *snd );
+		void removeSound( GSLSound *zSnd );
+#ifdef WIN32
+		void sendSoundMSG( HWAVEOUT hOut, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2 );
+#endif
+	};
+}
+
+#endif

GSL/Sound.cpp

@@ -0,0 +1,455 @@
+#include "Sound.h"
+#ifdef WIN32
+#include "Player.h"
+#else
+#include "Player.h"
+#endif
+
+using namespace GSL;
+
+#ifdef WIN32
+extern GSLPlayer *_player;
+void CALLBACK AudioOutProc( HWAVEOUT hOut, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2 );
+#endif
+
+// Inhalt der Sound Klasse aus Sound.h
+// Konstruktor
+GSLSound::GSLSound( const SoundKopf &skpf )
+{
+	kpf = skpf;
+	dat = new Datei();
+	dat->setDatei( kpf.pfad );
+#ifdef WIN32
+    status = 0;
+	hAudioId = 0;
+	uAudioDelay = 0;
+	uAudioCount = 0;
+	uAudioPlay = 16;
+	hAudioCs = { 0 };
+	hAudioEvent = 0;
+	uAudioWrite = 0;
+	uAudioStop = 0;
+	lAudioDone = 0;
+	uAudioWrOk = 0;
+	iAudioThEnd = 0;
+	linksV = 1;
+	rechtsV = 1;
+#endif
+	ref = 1;
+}
+
+// Destruktor
+GSLSound::~GSLSound()
+{
+#ifdef WIN32
+	if( status )
+		stopSound();
+#endif
+	dat->release();
+}
+
+// privat
+int GSLSound::audioOpen()
+{
+#ifdef WIN32
+	WAVEFORMATEX sAudioWm;
+	sAudioWm.wFormatTag = WAVE_FORMAT_PCM;
+	sAudioWm.nChannels = kpf.channels;
+	sAudioWm.nSamplesPerSec = kpf.sampleRate;
+	sAudioWm.nBlockAlign = ( ( 16 * kpf.channels ) + 7 ) >> 3;
+	sAudioWm.nAvgBytesPerSec = kpf.sampleRate * sAudioWm.nBlockAlign;
+	sAudioWm.wBitsPerSample = 16;
+	sAudioWm.cbSize = 0;
+	MMRESULT uRes = waveOutOpen( &hAudioId, WAVE_MAPPER, &sAudioWm, (DWORD_PTR)AudioOutProc, 0x00000000, CALLBACK_FUNCTION );
+	if( uRes || !hAudioId )
+	{
+		memset( &sAudioWm, 0, sizeof( sAudioWm ) );
+		return 1;
+	}
+	uAudioDelay = 0;
+	uAudioWrite = 0;
+	uAudioStop = 0;
+	lAudioDone = 0;
+	for( uAudioCount = 0; uAudioCount < 16; uAudioCount++ )
+	{
+		aAudioHdr[ uAudioCount ] = (LPWAVEHDR)GlobalAllocPtr( GMEM_MOVEABLE | GMEM_SHARE, sizeof( WAVEHDR ) + 0x4000 );
+		if( !aAudioHdr[ uAudioCount ] )
+			break;
+		aAudioHdr[ uAudioCount ]->dwFlags = WHDR_DONE;
+		aAudioHdr[ uAudioCount ]->lpData = (LPSTR)aAudioHdr[ uAudioCount ] + sizeof( WAVEHDR );
+		aAudioHdr[ uAudioCount ]->dwBufferLength = 0x4000;
+		aAudioHdr[ uAudioCount ]->dwUser = uAudioCount;
+		aAudioHdr[ uAudioCount ]->dwBytesRecorded = 0;
+		aAudioHdr[ uAudioCount ]->dwLoops = 1;
+		aAudioHdr[ uAudioCount ]->lpNext = 0;
+		aAudioPtr[ uAudioCount ] = (char*)( aAudioHdr[ uAudioCount ] ) + sizeof( WAVEHDR );
+		if( !waveOutPrepareHeader( hAudioId, aAudioHdr[ uAudioCount ], sizeof( WAVEHDR ) ) )
+			continue;
+		GlobalFreePtr( (LPCVOID)aAudioHdr[ uAudioCount ] );
+		break;
+	}
+	uAudioPlay = uAudioCount - 1;
+	if( uAudioCount < 12 )
+	{
+		audioClose();
+		return 2;
+	}
+	hAudioEvent = CreateEvent( 0, TRUE, TRUE, 0 );
+	if( !hAudioEvent )
+	{
+		audioClose();
+		return 3;
+	}
+	if( waveOutGetDevCaps( (UINT_PTR)hAudioId, (LPWAVEOUTCAPSA)&sAudioCaps, sizeof( WAVEOUTCAPS ) ) )
+		memset( &sAudioCaps, 0, sizeof( sAudioCaps ) );
+	InitializeCriticalSection( &hAudioCs );
+	waveOutReset( hAudioId );
+	waveOutSetVolume( hAudioId, 0xFFFFFFFF );
+#endif
+	dat->open( Datei::Style::lesen );
+#ifdef WIN32
+	uAudioWrOk = 1;
+#endif
+	return 0;
+}
+
+int GSLSound::audioClose()
+{
+	int	 iErr = 0;
+#ifdef WIN32
+	if( !hAudioId )
+		return 1;
+	audioStop();
+	DeleteCriticalSection( &hAudioCs );
+	while( uAudioCount > 0 )
+	{
+		uAudioCount--;
+		if( waveOutUnprepareHeader( hAudioId, aAudioHdr[ uAudioCount ], sizeof( WAVEHDR ) ) )
+			iErr = 1;
+		if( GlobalFreePtr( (LPCVOID)aAudioHdr[ uAudioCount ] ) )
+			iErr = 1;
+		aAudioHdr[ uAudioCount ] = 0;
+		aAudioPtr[ uAudioCount ] = 0;
+	}
+	if( waveOutClose( hAudioId ) )
+		iErr = 1;
+	if( !CloseHandle( hAudioEvent ) )
+		iErr = 1;
+	hAudioId = 0;
+	uAudioWrite = 0;
+	uAudioDelay = 0;
+	uAudioPlay = uAudioCount - 1;
+#endif
+	dat->close();
+	return iErr;
+}
+
+int GSLSound::audioStop()
+{
+#ifdef WIN32
+	unsigned  uPos;
+	if( !hAudioId )
+		return 1;
+	uAudioStop = 1;
+	uAudioWrOk = 0;
+	warteAufThread( 5000 );
+	SetEvent( hAudioEvent );
+	waveOutReset( hAudioId );
+	if( uAudioWrite != 0 && uAudioPlay != uAudioCount - 1 )
+	{
+		for( uPos = 0; uPos < uAudioCount; uPos++ )						// clears all buffers 
+		{
+			memset( aAudioHdr[ uPos ]->lpData, 0, 0x4000 );
+			break;
+		}
+	}
+	uAudioPlay = uAudioCount - 1;
+	uAudioWrite = 0;
+	uAudioDelay = 0;
+	SetEvent( hAudioEvent );
+	uAudioWrOk = 1;
+	if( isRunning() )									// close thread 
+	{
+		warteAufThread( 1000 );
+		if( !iAudioThEnd )
+		{
+			warteAufThread( 1000 );
+			if( run )
+			    ende();
+			Sleep( 100 );
+		}
+	}
+#endif
+	return 0;
+}
+
+int GSLSound::audioSchreiben( unsigned int uCount )
+{
+#ifdef WIN32
+	int	iDelta, i, iPos;
+	WAVEHDR	*pHeader;
+	if( !uAudioWrOk )
+		return 4;
+	if( uCount > 0x4000 )
+		return 2;
+	if( WaitForSingleObject( hAudioEvent, 2000 ) == WAIT_FAILED )
+		return 1;
+	if( uAudioDelay < 8 )
+	{
+		aAudioSize[ uAudioDelay ] = uCount;
+		uAudioDelay++;
+		EnterCriticalSection( &hAudioCs );				// increase write pos 
+		uAudioWrite++;
+		if( uAudioWrite >= uAudioCount )
+			uAudioWrite = 0;
+		LeaveCriticalSection( &hAudioCs );
+		return 0;
+	}
+	if( uAudioDelay == 8 )
+	{
+		uAudioDelay++;
+		for( i = 8; i > 0; i-- )
+		{
+			iPos = uAudioWrite - i;
+			if( iPos < 0 )iPos += uAudioCount;
+			pHeader = aAudioHdr[ iPos ];
+			pHeader->dwBufferLength = aAudioSize[ 8 - i ];
+			if( waveOutWrite( hAudioId, pHeader, sizeof( WAVEHDR ) ) )
+				return 3;
+		}
+	}
+	pHeader = aAudioHdr[ uAudioWrite ];
+	pHeader->dwBufferLength = uCount;
+	if( waveOutWrite( hAudioId, pHeader, sizeof( WAVEHDR ) ) )
+		return 3;
+	EnterCriticalSection( &hAudioCs );
+	uAudioWrite++;
+	if( uAudioWrite >= uAudioCount )
+		uAudioWrite = 0;
+	iDelta = uAudioPlay - uAudioWrite;
+	if( iDelta < 0 )
+		iDelta += uAudioCount;
+	if( iDelta < 2 )
+		ResetEvent( hAudioEvent );
+	LeaveCriticalSection( &hAudioCs );
+#endif
+	return 0;
+}
+
+int GSLSound::audioLesen( char *buff, int len )
+{
+	if( dat->getLPosition() < kpf.datPos )
+		dat->setLPosition( kpf.datPos, 0 );
+	if( dat->getLPosition() >= kpf.datEnd )
+		return -1;
+	if( dat->getLPosition() + len > kpf.datEnd )
+		len = (int)( kpf.datEnd - dat->getLPosition() );
+	if( len > 0 )
+		dat->lese( buff, len );
+#ifdef WIN32
+	for( int i = 0; i < len; i++, buff++ )
+	{
+		if( i % 4 >= 2 )
+			*buff = (char)( *buff * rechtsV );
+		else
+			*buff = (char)( *buff * linksV );
+	}
+#endif
+	return len;
+}
+
+// nicht constant
+void GSLSound::playSound()
+{
+#ifdef WIN32
+	if( !status )
+	{
+		if( _player->addSound( (GSLSound*)getThis() ) )
+			status = 1;
+		if( !audioOpen() )
+		   start();
+		else
+		{
+			_player->removeSound( this );
+			status = 0;
+		}
+	}
+	setPause( 0 );
+#endif
+}
+
+void GSLSound::setPause( bool p )
+{
+#ifdef WIN32
+	if( p )
+	{
+		if( !status )
+			playSound();
+		if( status == 1 )
+		{
+			waveOutPause( hAudioId );
+			status = 2;
+		}
+	}
+	else
+	{
+		if( status == 2 )
+		{
+			waveOutRestart( hAudioId );
+			status = 1;
+		}
+	}
+#endif
+}
+
+void GSLSound::stopSound()
+{
+#ifdef WIN32
+	setPause( 0 );
+	if( status == 1 )
+	{
+		status = 0;
+		_player->removeSound( this );
+		audioClose();
+	}
+#endif
+}
+
+void GSLSound::warteAufSound( int zeit )
+{
+	warteAufThread( zeit );
+}
+
+void GSLSound::setVolume( unsigned int links, unsigned int rechts )
+{
+#ifdef WIN32
+	linksV = (float)links / 0xFFFF;
+	rechtsV = (float)rechts / 0xFFFF;
+#endif
+}
+
+#ifdef WIN32
+void GSLSound::msg( UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2 )
+{
+	WAVEHDR	*pHeader;
+	int	iDelta;
+	switch( uMsg )
+	{
+	case WOM_DONE:
+		pHeader = (WAVEHDR*)dwParam1;
+		EnterCriticalSection( &hAudioCs );
+		InterlockedExchangeAdd( (unsigned __int64*)&lAudioDone, (__int64)pHeader->dwBufferLength );
+		iDelta = (int)( uAudioPlay - pHeader->dwUser );
+		if( iDelta < 0 )
+			iDelta += uAudioCount;
+		if( iDelta > ( (int)uAudioCount >> 1 ) )
+		{
+			uAudioPlay = (unsigned int)pHeader->dwUser;
+			if( uAudioPlay >= uAudioCount )
+				uAudioPlay = 0;
+			iDelta = uAudioPlay - uAudioWrite;
+			if( iDelta < 0 )
+				iDelta += uAudioCount;
+			if( iDelta >= 2 )
+				SetEvent( hAudioEvent );
+		}
+		LeaveCriticalSection( &hAudioCs );
+		break;
+	}
+}
+#endif
+
+void GSLSound::thread()
+{
+#ifdef WIN32
+	iAudioThEnd = 0;
+	uAudioStop = 0;
+	if( !hAudioId )
+		return;
+	int iCount;
+	while( !uAudioStop && hAudioId )
+	{
+		iCount = audioLesen( aAudioPtr[ uAudioWrite ], 0x4000 );
+		if( iCount <= 0 )
+			break;
+		audioSchreiben( iCount );
+	}
+	iAudioThEnd = 1;
+	stopSound();
+#endif
+	run = 0;
+}
+
+// zum Speichern
+void GSLSound::open()
+{
+#ifdef WIN32
+	if( !status )
+	{
+		dat->open( Datei::Style::lesen );
+		status = 3;
+	}
+#else
+    dat->open( Datei::Style::lesen );
+#endif
+}
+
+int GSLSound::getDaten( char *buffer, int len )
+{
+#ifdef WIN32
+	if( status != 3 )
+		return -1;
+#endif
+	return audioLesen( buffer, len );
+}
+
+void GSLSound::close()
+{
+#ifdef WIN32
+	if( status == 3 )
+	{
+		dat->close();
+		status = 0;
+	}
+#else
+    dat->close();
+#endif
+}
+
+bool GSLSound::istMono() const
+{
+	return kpf.channels == 1;
+}
+
+int GSLSound::getSampleRate() const
+{
+	return kpf.sampleRate;
+}
+
+__int64 GSLSound::getDatLength() const
+{
+    return kpf.datEnd - kpf.datPos;
+}
+
+// constant
+#ifdef WIN32
+HWAVEOUT GSLSound::getHandle() const
+{
+	return hAudioId;
+}
+#endif
+
+// Reference Counting
+GSLSoundV *GSLSound::getThis()
+{
+	ref++;
+	return this;
+}
+
+GSLSoundV *GSLSound::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

GSL/Sound.h

@@ -0,0 +1,83 @@
+#ifndef Sound_H
+#define Sound_H
+
+#ifdef WIN32
+#include "GSLDatei.h"
+#include "Include/GSLSoundV.h"
+#include <mmsystem.h>
+#else
+#include "GSLDatei.h"
+#include "GSLSoundV.h"
+#endif
+
+using namespace Framework;
+
+namespace GSL
+{
+	class GSLSound : public GSLSoundV
+	{
+	private:
+		Datei *dat;
+		SoundKopf kpf;
+#ifdef WIN32
+        int status;
+		HWAVEOUT hAudioId;
+		unsigned int uAudioDelay;
+		unsigned int uAudioCount;
+		WAVEHDR *aAudioHdr[ 16 ];
+		char *aAudioPtr[ 16 ];
+		unsigned int uAudioPlay;
+		CRITICAL_SECTION hAudioCs;
+		HANDLE hAudioEvent;
+		WAVEOUTCAPS sAudioCaps;
+		unsigned int uAudioWrite;
+		unsigned int uAudioStop;
+		int lAudioDone;
+		unsigned int uAudioWrOk;
+		volatile int iAudioThEnd;
+		unsigned int aAudioSize[ 8 ];
+		float linksV;
+		float rechtsV;
+#endif
+		int ref;
+
+		// privat
+		int audioOpen();
+		int audioClose();
+		int audioStop();
+		int audioSchreiben( unsigned int uCount );
+		int audioLesen( char *buff, int len );
+
+	public:
+		// Konstruktor
+		GSLSound( const SoundKopf &skpf );
+		// Destruktor
+		~GSLSound();
+		// nicht constant
+		void playSound() override;
+		void setPause( bool p ) override;
+		void stopSound() override;
+		void warteAufSound( int zeit ) override;
+		void setVolume( unsigned int links, unsigned int rechts ) override;
+#ifdef WIN32
+		void msg( UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2 );
+#endif
+		void thread() override;
+		// zum Speichern
+		void open() override;
+		int getDaten( char *buffer, int len ) override;
+		void close() override;
+		bool istMono() const override;
+		int getSampleRate() const override;
+        __int64 getDatLength() const override;
+		// constant
+#ifdef WIN32
+		HWAVEOUT getHandle() const;
+#endif
+		// Reference Counting
+		GSLSoundV *getThis() override;
+		GSLSoundV *release() override;
+	};
+}
+
+#endif

build.bat

@@ -0,0 +1,6 @@
+"D:\Visual Studio 2017\MSBuild\15.0\Bin\MSBuild.exe" GSL.sln /t:GSL:rebuild /p:configuration=debug /p:platform=x64
+"D:\Visual Studio 2017\MSBuild\15.0\Bin\MSBuild.exe" GSL.sln /t:GSL:rebuild /p:configuration=release /p:platform=x64
+"D:\Visual Studio 2017\MSBuild\15.0\Bin\MSBuild.exe" GSL.sln /t:GSL:rebuild /p:configuration=release /p:platform=win32
+
+"D:\Visual Studio 2017\MSBuild\15.0\Bin\MSBuild.exe" "GSL Linux/GSL Linux.vcxproj" /t:rebuild /p:configuration=debug /p:platform=x64
+"D:\Visual Studio 2017\MSBuild\15.0\Bin\MSBuild.exe" "GSL Linux/GSL Linux.vcxproj" /t:rebuild /p:configuration=release /p:platform=x64