Add network remote WIP

Fixes #1679

.clang-format

@@ -0,0 +1,219 @@
+---
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -1
+AlignAfterOpenBracket: Align
+AlignArrayOfStructures: None
+AlignConsecutiveAssignments:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  PadOperators:    true
+AlignConsecutiveBitFields:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  PadOperators:    false
+AlignConsecutiveDeclarations:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  PadOperators:    false
+AlignConsecutiveMacros:
+  Enabled:         true
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  PadOperators:    false
+AlignEscapedNewlines: Left
+AlignOperands:   DontAlign
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortEnumsOnASingleLine: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: All
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: AllIfsAndElse
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: No
+AttributeMacros:
+  - __capability
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: Never
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      true
+  BeforeLambdaBody: false
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: Always
+BreakBeforeBraces: Custom
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: false
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: false
+ColumnLimit:     0
+CommentPragmas:  '^ IWYU pragma:'
+QualifierAlignment: Leave
+CompactNamespaces: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 2
+Cpp11BracedListStyle: false
+DeriveLineEnding: true
+DerivePointerAlignment: false
+DisableFormat:   true
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: LogicalBlock
+ExperimentalAutoDetectBinPacking: false
+PackConstructorInitializers: BinPack
+BasedOnStyle:    ''
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+AllowAllConstructorInitializersOnNextLine: true
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IfMacros:
+  - KJ_IF_MAYBE
+IncludeBlocks:   Preserve
+IncludeCategories:
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        3
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '.*'
+    Priority:        1
+    SortPriority:    0
+    CaseSensitive:   false
+IncludeIsMainRegex: '(Test)?$'
+IncludeIsMainSourceRegex: ''
+IndentAccessModifiers: false
+IndentCaseLabels: true
+IndentCaseBlocks: false
+IndentGotoLabels: true
+IndentPPDirectives: AfterHash
+IndentExternBlock: AfterExternBlock
+IndentRequiresClause: true
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+InsertBraces:    false
+InsertTrailingCommas: None
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLines:
+  AtEndOfFile: true
+  AtStartOfBlock: true
+  AtStartOfFile: true
+LambdaBodyIndentation: Signature
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 100
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 0
+PenaltyBreakBeforeFirstCallParameter: 0
+PenaltyBreakComment: 0
+PenaltyBreakFirstLessLess: 0
+PenaltyBreakOpenParenthesis: 0
+PenaltyBreakString: 0
+PenaltyBreakTemplateDeclaration: 0
+PenaltyExcessCharacter: 0
+PenaltyReturnTypeOnItsOwnLine: 0
+PenaltyIndentedWhitespace: 0
+PointerAlignment: Right
+PPIndentWidth:   -1
+ReferenceAlignment: Pointer
+ReflowComments:  false
+RemoveBracesLLVM: false
+RequiresClausePosition: OwnLine
+SeparateDefinitionBlocks: Leave
+ShortNamespaceLines: 1
+SortIncludes:    false
+SortJavaStaticImport: Before
+SortUsingDeclarations: false
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: true
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeParensOptions:
+  AfterControlStatements: true
+  AfterForeachMacros: true
+  AfterFunctionDefinitionName: false
+  AfterFunctionDeclarationName: false
+  AfterIfMacros:   true
+  AfterOverloadedOperator: false
+  AfterRequiresInClause: false
+  AfterRequiresInExpression: false
+  BeforeNonEmptyParentheses: false
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles:  Never
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInLineCommentPrefix:
+  Minimum:         1
+  Maximum:         -1
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+BitFieldColonSpacing: Both
+Standard:        Latest
+StatementAttributeLikeMacros:
+  - Q_EMIT
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        8
+UseCRLF:         false
+UseTab:          Never
+WhitespaceSensitiveMacros:
+  - STRINGIZE
+  - PP_STRINGIZE
+  - BOOST_PP_STRINGIZE
+  - NS_SWIFT_NAME
+  - CF_SWIFT_NAME
+...
+

.github/FUNDING.yml

@@ -1 +1,4 @@
 github: jonaski
+patreon: jonaskvinge
+ko_fi: jonaskvinge
+custom: https://paypal.me/jonaskvinge

.github/ISSUE_TEMPLATE/ISSUE_TEMPLATE.md

@@ -7,6 +7,10 @@ assignees: ''
 
 ---
 
+- [ ] I have checked the [FAQ](https://wiki.strawberrymusicplayer.org/wiki/FAQ) for answers.
+- [ ] I have checked the [Changelog](https://github.com/strawberrymusicplayer/strawberry/blob/master/Changelog) that the issue is not already fixed. 
+- [ ] I believe this issue is a bug, and not a general technical issue, question or feature requests that can be discussed on the [forum](https://forum.strawberrymusicplayer.org/). 
+
 **Describe the bug**
 A clear and concise description of what the bug is.
 

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: daily

.gitignore

@@ -1,117 +1,16 @@
-# This file is used to ignore files which are generated
-# ----------------------------------------------------------------------------
-
-# Build
-build/
-bin/
-
-# CMake
-CMakeLists.txt.user
-CMakeCache.txt
-CMakeFiles
-CMakeScripts
-Makefile*
-Testing
-cmake_install.cmake
-install_manifest.txt
-compile_commands.json
-CTestTestfile.cmake
-_deps
-
-# Prerequisites
-*.d
-
-# Compiled Object files
-*.slo
-*.lo
-*.o
-*.obj
-
-# Precompiled Headers
-*.gch
-*.pch
-
-# Compiled Dynamic libraries
-*.so
-*.so.*
-*.dylib
-*.dll
-
-# Fortran module files
-*.mod
-*.smod
-
-# Compiled Static libraries
-*.lai
-*.la
-*.a
-*.lib
-
-# Executables
-*.exe
-*.out
-*.app
-
-# Dump files
-*.core
-*.stackdump
-
-# Qt
-*build-*
-moc_*.cpp
-moc_*.h
-qrc_*.cpp
-ui_*.h
-*.moc
-*.qm
-
-# QtCreator
-CMakeLists.txt.user*
-*.pro.user
-*.pro.user.*
-*creator.user*
-target_wrapper.*
-compile_commands.json
-
-# Temporary files
-*~
-*.autosave
-*.orig
-*.rej
-.*.kate-swp
-.swp.*
-.*.swp
-*.flc
-
-# Directory files
-.directory
-.DS_Store
-Thumbs.db
-
-# MinGW generated files
-*.Debug
-*.Release
-
-# Package files
-*.spec
-*.nsi
-*.plist
-
-# Stuff in dist
-maketarball.sh
-create-dmg.sh
-changelog
-PKGBUILD
-
-# Translations
-translations.pot
-zanata.xml
-.zanata-cache/
-
-# Snap
-parts/
-prime/
-stage/
-*.snap
-/snap/.snapcraft/
-/*_source.tar.bz2
+/build
+/bin
+/CMakeLists.txt.user
+/.qtcreator
+/.kdev4
+/strawberry.kdev4
+/.vscode
+/.code-workspace
+/.sublime-workspace
+/.idea
+/.vs
+/out
+/CMakeSettings.json
+/dist/scripts/maketarball.sh
+/debian/changelog
+_codeql_detected_source_root

.travis.yml

@@ -1,60 +0,0 @@
-sudo: required
-language: C++
-os:
-  - linux
-  - osx
-services:
-  - docker
-compiler:
-  - gcc
-
-before_install:
-  - if ! [ "$DEPLOY_KEY_ENC" == "" ]; then
-      echo $DEPLOY_KEY_ENC | base64 --decode | openssl aes-256-cbc -K $encrypted_83a41ac424a6_key -iv $encrypted_83a41ac424a6_iv -out ~/.ssh/id_rsa -d ;
-      chmod 600 ~/.ssh/id_rsa ;
-    fi
-  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
-      docker build -f Dockerfile -t strawberry-build . || travis_terminate 1;
-      docker run --name build -itd strawberry-build /bin/bash || travis_terminate 1;
-      docker exec build git clone https://github.com/jonaski/strawberry;
-    fi
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
-      git fetch --unshallow || travis_terminate 1;
-      git pull || travis_terminate 1;
-      brew update || travis_terminate 1;
-      brew unlink python || travis_terminate 1;
-      brew install glib pkgconfig libffi protobuf protobuf-c qt gettext gnutls fftw sqlite chromaprint;
-      brew install gstreamer gst-plugins-base gst-plugins-good gst-plugins-bad gst-plugins-ugly gst-libav;
-      brew install libcdio libmtp libimobiledevice libplist;
-      brew install create-dmg;
-      export Qt5_DIR=/usr/local/opt/qt5/lib/cmake;
-      export Qt5LinguistTools_DIR=/usr/local/opt/qt5/lib/cmake/Qt5LinguistTools;
-      export PATH="/usr/local/opt/gettext/bin:$PATH";
-      export PKG_CONFIG_PATH=/usr/local/opt/libffi/lib/pkgconfig/:$PKG_CONFIG_PATH;
-      ls /usr/local/lib/gstreamer-1.0;
-    fi
-before_script:
-  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then docker exec build cmake -Hstrawberry -Bbuild ; fi
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then mkdir build; cd build; cmake .. -DUSE_BUNDLE=ON ; fi
-script:
-- if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then docker exec build make -C build -j8 ; fi
-- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
-      make -j8 || travis_terminate 1;
-      make install || travis_terminate 1;
-      sudo make dmg;
-  fi
-after_success:
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then ls -lh strawberry*.dmg; fi
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]] && [[ "$CC_FOR_BUILD" == "gcc" ]] && [ -f ~/.ssh/id_rsa ]; then
-      if [[ "$TRAVIS_BRANCH" == "master" ]]; then
-        rsync -e "ssh -o StrictHostKeyChecking=no" -va strawberry*.dmg travis@echoes.jkvinge.net:/home/travis/builds/macos;
-      elif [[ "$TRAVIS_BRANCH" == "macos" ]]; then
-        rsync -e "ssh -o StrictHostKeyChecking=no" -va strawberry*.dmg travis@echoes.jkvinge.net:/home/travis/builds/macos-test;
-      fi
-    fi
-
-branches:
-  except:
-    - # Do not build tags that we create when we upload to GitHub Releases
-    - /^(?i:continuous)$/
-  

3rdparty/README.md

@@ -1,42 +0,0 @@
-3rdparty libraries located in this directory
-============================================
-
-singleapplication
------------------
-This is a small static library used by Strawberry to prevent it from starting twice per user session.
-If the user tries to start strawberry twice, the main window will maximize instead of starting another instance.
-If you dynamically link to your systems version, you'll need two versions, one defined as QApplication and
-one as a QCoreApplication.
-It is included here because it is not packed by distros and is also used on macOS and Windows.
-
-URL: https://github.com/itay-grudev/SingleApplication
-
-
-taglib
-------
-
-TagLib is a library for reading and editing the meta-data of several popular audio formats. It is also used
-by Strawberry to identify audio files. It is important that it is kept up-to-date for Strawberry to function
-correctly.
-
-It is kept in 3rdparty because there currently is no official release of TagLib with the features and bugfixes
-that are in the official repository. And also because some distros use older, or unpatched versions.
-
-There is a bug in the latest version (1.11.1) corrupting Ogg files,
-see: https://github.com/taglib/taglib/issues/864
-If you decide to use the systems taglib, make sure it has been patched with the following commit:
-https://github.com/taglib/taglib/commit/9336c82da3a04552168f208cd7a5fa4646701ea4
-
-The current taglib in 3rdparty also has the following features:
-- Audio file detection by content.
-- DSF and DSDIFF support
-
-URL: https://github.com/taglib/taglib
-
-
-utf8-cpp
---------
-
-This is 2 header files used by taglib, but kept in a separate directory because it is maintained by others.
-
-URL: http://utfcpp.sourceforge.net/

3rdparty/discord-rpc/CMakeLists.txt

@@ -0,0 +1,41 @@
+set(DISCORD_RPC_SOURCES
+  discord_rpc.h
+  discord_register.h
+  discord_rpc.cpp
+  discord_rpc_connection.h
+  discord_rpc_connection.cpp
+  discord_serialization.h
+  discord_serialization.cpp
+  discord_connection.h
+  discord_backoff.h
+  discord_msg_queue.h
+)
+
+if(UNIX)
+  list(APPEND DISCORD_RPC_SOURCES discord_connection_unix.cpp)
+  if(APPLE)
+    list(APPEND DISCORD_RPC_SOURCES discord_register_osx.m)
+    add_definitions(-DDISCORD_OSX)
+  else()
+    list(APPEND DISCORD_RPC_SOURCES discord_register_linux.cpp)
+    add_definitions(-DDISCORD_LINUX)
+  endif()
+endif()
+
+if(WIN32)
+  list(APPEND DISCORD_RPC_SOURCES discord_connection_win.cpp discord_register_win.cpp)
+  add_definitions(-DDISCORD_WINDOWS)
+endif()
+
+add_library(discord-rpc STATIC ${DISCORD_RPC_SOURCES})
+
+if(APPLE)
+  target_link_libraries(discord-rpc PRIVATE "-framework AppKit")
+endif()
+
+if(WIN32)
+  target_link_libraries(discord-rpc PRIVATE psapi advapi32)
+endif()
+
+target_include_directories(discord-rpc SYSTEM PRIVATE ${RapidJSON_INCLUDE_DIRS})
+target_include_directories(discord-rpc PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})

3rdparty/discord-rpc/LICENSE

@@ -0,0 +1,19 @@
+Copyright 2017 Discord, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

3rdparty/discord-rpc/README.md

@@ -0,0 +1,162 @@
+# Discord RPC
+
+## Fork Notice
+
+This library was slightly modified for Strawberry Music Player with some extra features from the new API and shared library support/more unnecessary components removed. The original repository is [here](https://github.com/discord/discord-rpc)
+
+## Deprecation Notice
+
+This library has been deprecated in favor of Discord's GameSDK. [Learn more here](https://discordapp.com/developers/docs/game-sdk/sdk-starter-guide)
+
+---
+
+This is a library for interfacing your game with a locally running Discord desktop client. It's known to work on Windows, macOS, and Linux. You can use the lib directly if you like, or use it as a guide to writing your own if it doesn't suit your game as is. PRs/feedback welcome if you have an improvement everyone might want, or can describe how this doesn't meet your needs.
+
+Included here are some quick demos that implement the very minimal subset to show current status, and
+have callbacks for where a more complete game would do more things (joining, spectating, etc).
+
+## Documentation
+
+The most up to date documentation for Rich Presence can always be found on our [developer site](https://discordapp.com/developers/docs/rich-presence/how-to)! If you're interested in rolling your own native implementation of Rich Presence via IPC sockets instead of using our SDK—hey, you've got free time, right?—check out the ["Hard Mode" documentation](https://github.com/discordapp/discord-rpc/blob/master/documentation/hard-mode.md).
+
+## Basic Usage
+
+Zeroith, you should be set up to build things because you are a game developer, right?
+
+First, head on over to the [Discord developers site](https://discordapp.com/developers/applications/me) and make yourself an app. Keep track of `Client ID` -- you'll need it here to pass to the init function.
+
+### Unreal Engine 4 Setup
+
+To use the Rich Presense plugin with Unreal Engine Projects:
+
+1.  Download the latest [release](https://github.com/discordapp/discord-rpc/releases) for each operating system you are targeting and the zipped source code
+2.  In the source code zip, copy the UE plugin—`examples/unrealstatus/Plugins/discordrpc`—to your project's plugin directory
+3.  At `[YOUR_UE_PROJECT]/Plugins/discordrpc/source/ThirdParty/DiscordRpcLibrary/`, create an `Include` folder and copy `discord_rpc.h` and `discord_register.h` to it from the zip
+4.  Follow the steps below for each OS
+5.  Build your UE4 project
+6.  Launch the editor, and enable the Discord plugin.
+
+#### Windows
+
+- At `[YOUR_UE_PROJECT]/Plugins/discordrpc/source/ThirdParty/DiscordRpcLibrary/`, create a `Win64` folder
+- Copy `lib/discord-rpc.lib` and `bin/discord-rpc.dll` from `[RELEASE_ZIP]/win64-dynamic` to the `Win64` folder
+
+#### Mac
+
+- At `[YOUR_UE_PROJECT]/Plugins/discordrpc/source/ThirdParty/DiscordRpcLibrary/`, create a `Mac` folder
+- Copy `libdiscord-rpc.dylib` from `[RELEASE_ZIP]/osx-dynamic/lib` to the `Mac` folder
+
+#### Linux
+
+- At `[YOUR_UE_PROJECT]/Plugins/discordrpc/source/ThirdParty/DiscordRpcLibrary/`, create a `Linux` folder
+- Inside, create another folder `x86_64-unknown-linux-gnu`
+- Copy `libdiscord-rpc.so` from `[RELEASE_ZIP]/linux-dynamic/lib` to `Linux/x86_64-unknown-linux-gnu`
+
+### Unity Setup
+
+If you're a Unity developer looking to integrate Rich Presence into your game, follow this simple guide to get started towards success:
+
+1. Download the DLLs for any platform that you need from [our releases](https://github.com/discordapp/discord-rpc/releases)
+2. In your Unity project, create a `Plugins` folder inside your `Assets` folder if you don't already have one
+3. Copy the file `DiscordRpc.cs` from [here](https://github.com/discordapp/discord-rpc/blob/master/examples/button-clicker/Assets/DiscordRpc.cs) into your `Assets` folder. This is basically your header file for the SDK
+
+We've got our `Plugins` folder ready, so let's get platform-specific!
+
+#### Windows
+
+4. Create `x86` and `x86_64` folders inside `Assets/Plugins/`
+5. Copy `discord-rpc-win/win64-dynamic/bin/discord-rpc.dll` to `Assets/Plugins/x86_64/`
+6. Copy `discord-rpc-win/win32-dynamic/bin/discord-rpc.dll` to `Assets/Plugins/x86/`
+7. Click on both DLLs and make sure they are targetting the correct architectures in the Unity editor properties pane
+8. Done!
+
+#### MacOS
+
+4. Copy `discord-rpc-osx/osx-dynamic/lib/libdiscord-rpc.dylib` to `Assets/Plugins/`
+5. Rename `libdiscord-rpc.dylib` to `discord-rpc.bundle`
+6. Done!
+
+#### Linux
+
+4. Copy `discord-rpc-linux/linux-dynamic-lib/libdiscord-rpc.so` to `Assets/Plugins/`
+5. Done!
+
+You're ready to roll! For code examples on how to interact with the SDK using the `DiscordRpc.cs` header file, check out [our example](https://github.com/discordapp/discord-rpc/blob/master/examples/button-clicker/Assets/DiscordController.cs)
+
+### From package
+
+Download a release package for your platform(s) -- they have subdirs with various prebuilt options, select the one you need add `/include` to your compile includes, `/lib` to your linker paths, and link with `discord-rpc`. For the dynamically linked builds, you'll need to ship the associated file along with your game.
+
+### From repo
+
+First-eth, you'll want `CMake`. There's a few different ways to install it on your system, and you should refer to [their website](https://cmake.org/install/). Many package managers provide ways of installing CMake as well.
+
+To make sure it's installed correctly, type `cmake --version` into your flavor of terminal/cmd. If you get a response with a version number, you're good to go!
+
+There's a [CMake](https://cmake.org/download/) file that should be able to generate the lib for you; Sometimes I use it like this:
+
+```sh
+    cd <path to discord-rpc>
+    mkdir build
+    cd build
+    cmake .. -DCMAKE_INSTALL_PREFIX=<path to install discord-rpc to>
+    cmake --build . --config Release --target install
+```
+
+There is a wrapper build script `build.py` that runs `cmake` with a few different options.
+
+Usually, I run `build.py` to get things started, then use the generated project files as I work on things. It does depend on `click` library, so do a quick `pip install click` to make sure you have it if you want to run `build.py`.
+
+There are some CMake options you might care about:
+
+| flag                                                                                     | default | does                                                                                                                                                  |
+| ---------------------------------------------------------------------------------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ENABLE_IO_THREAD`                                                                       | `ON`    | When enabled, we start up a thread to do io processing, if disabled you should call `Discord_UpdateConnection` yourself.                              |
+| `USE_STATIC_CRT`                                                                         | `OFF`   | (Windows) Enable to statically link the CRT, avoiding requiring users install the redistributable package. (The prebuilt binaries enable this option) |
+| [`BUILD_SHARED_LIBS`](https://cmake.org/cmake/help/v3.7/variable/BUILD_SHARED_LIBS.html) | `OFF`   | Build library as a DLL                                                                                                                                |
+| `WARNINGS_AS_ERRORS`                                                                     | `OFF`   | When enabled, compiles with `-Werror` (on \*nix platforms).                                                                                           |
+
+## Continuous Builds
+
+Why do we have three of these? Three times the fun!
+
+| CI                   | badge                                                                                                                                            |
+| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| TravisCI             | [![Build status](https://travis-ci.org/discordapp/discord-rpc.svg?branch=master)](https://travis-ci.org/discordapp/discord-rpc)                  |
+| AppVeyor             | [![Build status](https://ci.appveyor.com/api/projects/status/qvkoc0w1c4f4b8tj?svg=true)](https://ci.appveyor.com/project/crmarsh/discord-rpc)    |
+| Buildkite (internal) | [![Build status](https://badge.buildkite.com/e103d79d247f6776605a15246352a04b8fd83d69211b836111.svg)](https://buildkite.com/discord/discord-rpc) |
+
+## Sample: send-presence
+
+This is a text adventure "game" that inits/deinits the connection to Discord, and sends a presence update on each command.
+
+## Sample: button-clicker
+
+This is a sample [Unity](https://unity3d.com/) project that wraps a DLL version of the library, and sends presence updates when you click on a button. Run `python build.py unity` in the root directory to build the correct library files and place them in their respective folders.
+
+## Sample: unrealstatus
+
+This is a sample [Unreal](https://www.unrealengine.com) project that wraps the DLL version of the library with an Unreal plugin, exposes a blueprint class for interacting with it, and uses that to make a very simple UI. Run `python build.py unreal` in the root directory to build the correct library files and place them in their respective folders.
+
+## Wrappers and Implementations
+
+Below is a table of unofficial, community-developed wrappers for and implementations of Rich Presence in various languages. If you would like to have yours added, please make a pull request adding your repository to the table. The repository should include:
+
+- The code
+- A brief ReadMe of how to use it
+- A working example
+
+###### Rich Presence Wrappers and Implementations
+
+| Name                                                                      | Language                          |
+| ------------------------------------------------------------------------- | --------------------------------- |
+| [Discord RPC C#](https://github.com/Lachee/discord-rpc-csharp)            | C#                                |
+| [Discord RPC D](https://github.com/voidblaster/discord-rpc-d)             | [D](https://dlang.org/)           |
+| [discord-rpc.jar](https://github.com/Vatuu/discord-rpc 'Discord-RPC.jar') | Java                              |
+| [java-discord-rpc](https://github.com/MinnDevelopment/java-discord-rpc)   | Java                              |
+| [Discord-IPC](https://github.com/jagrosh/DiscordIPC)                      | Java                              |
+| [Discord Rich Presence](https://npmjs.org/discord-rich-presence)          | JavaScript                        |
+| [drpc4k](https://github.com/Bluexin/drpc4k)                               | [Kotlin](https://kotlinlang.org/) |
+| [lua-discordRPC](https://github.com/pfirsich/lua-discordRPC)              | LuaJIT (FFI)                      |
+| [pypresence](https://github.com/qwertyquerty/pypresence)                  | [Python](https://python.org/)     |
+| [SwordRPC](https://github.com/Azoy/SwordRPC)                              | [Swift](https://swift.org)        |

3rdparty/discord-rpc/discord_backoff.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2017 Discord, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#ifndef DISCORD_BACKOFF_H
+#define DISCORD_BACKOFF_H
+
+#include <algorithm>
+#include <random>
+#include <cstdint>
+#include <ctime>
+
+namespace discord_rpc {
+
+struct Backoff {
+  int64_t minAmount;
+  int64_t maxAmount;
+  int64_t current;
+  int fails;
+  std::mt19937_64 randGenerator;
+  std::uniform_real_distribution<> randDistribution;
+
+  double rand01() { return randDistribution(randGenerator); }
+
+  Backoff(int64_t min, int64_t max)
+      : minAmount(min), maxAmount(max), current(min), fails(0), randGenerator(static_cast<uint64_t>(time(0))) {
+  }
+
+  void reset() {
+    fails = 0;
+    current = minAmount;
+  }
+
+  int64_t nextDelay() {
+    ++fails;
+    int64_t delay = static_cast<int64_t>(static_cast<double>(current) * 2.0 * rand01());
+    current = std::min(current + delay, maxAmount);
+    return current;
+  }
+};
+
+}  // namespace discord_rpc
+
+#endif  // DISCORD_BACKOFF_H

3rdparty/discord-rpc/discord_connection.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2017 Discord, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#ifndef DISCORD_CONNECTION_H
+#define DISCORD_CONNECTION_H
+
+// This is to wrap the platform specific kinds of connect/read/write.
+
+#include <cstdlib>
+
+namespace discord_rpc {
+
+// not really connectiony, but need per-platform
+int GetProcessId();
+
+struct BaseConnection {
+  static BaseConnection *Create();
+  static void Destroy(BaseConnection*&);
+  bool isOpen = false;
+  bool Open();
+  bool Close();
+  bool Write(const void *data, size_t length);
+  bool Read(void *data, size_t length);
+};
+
+}  // namespace discord_rpc
+
+#endif  // DISCORD_CONNECTION_H

3rdparty/discord-rpc/discord_connection_unix.cpp

@@ -0,0 +1,160 @@
+/*
+ * Copyright 2017 Discord, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#include "discord_connection.h"
+
+#include <cerrno>
+#include <fcntl.h>
+#include <cstdio>
+#include <cstring>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+namespace discord_rpc {
+
+int GetProcessId() {
+  return ::getpid();
+}
+
+struct BaseConnectionUnix : public BaseConnection {
+  int sock{ -1 };
+};
+
+static BaseConnectionUnix Connection;
+static sockaddr_un PipeAddr{};
+#ifdef MSG_NOSIGNAL
+static int MsgFlags = MSG_NOSIGNAL;
+#else
+static int MsgFlags = 0;
+#endif
+
+static const char *GetTempPath() {
+
+  const char *temp = getenv("XDG_RUNTIME_DIR");
+  temp = temp ? temp : getenv("TMPDIR");
+  temp = temp ? temp : getenv("TMP");
+  temp = temp ? temp : getenv("TEMP");
+  temp = temp ? temp : "/tmp";
+
+  return temp;
+
+}
+
+BaseConnection *BaseConnection::Create() {
+  PipeAddr.sun_family = AF_UNIX;
+  return &Connection;
+}
+
+void BaseConnection::Destroy(BaseConnection *&c) {
+
+  auto self = reinterpret_cast<BaseConnectionUnix*>(c);
+  self->Close();
+  c = nullptr;
+
+}
+
+bool BaseConnection::Open() {
+
+  const char *tempPath = GetTempPath();
+  auto self = reinterpret_cast<BaseConnectionUnix*>(this);
+  self->sock = socket(AF_UNIX, SOCK_STREAM, 0);
+  if (self->sock == -1) {
+    return false;
+  }
+  fcntl(self->sock, F_SETFL, O_NONBLOCK);
+#ifdef SO_NOSIGPIPE
+  int optval = 1;
+  setsockopt(self->sock, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval));
+#endif
+
+  for (int pipeNum = 0; pipeNum < 10; ++pipeNum) {
+    snprintf(PipeAddr.sun_path, sizeof(PipeAddr.sun_path), "%s/discord-ipc-%d", tempPath, pipeNum);
+    int err = connect(self->sock, reinterpret_cast<const sockaddr*>(&PipeAddr), sizeof(PipeAddr));
+    if (err == 0) {
+      self->isOpen = true;
+      return true;
+    }
+  }
+  self->Close();
+
+  return false;
+
+}
+
+bool BaseConnection::Close() {
+
+  auto self = reinterpret_cast<BaseConnectionUnix*>(this);
+  if (self->sock == -1) {
+    return false;
+  }
+  close(self->sock);
+  self->sock = -1;
+  self->isOpen = false;
+
+  return true;
+
+}
+
+bool BaseConnection::Write(const void *data, size_t length) {
+
+  auto self = reinterpret_cast<BaseConnectionUnix*>(this);
+
+  if (self->sock == -1) {
+    return false;
+  }
+
+  ssize_t sentBytes = send(self->sock, data, length, MsgFlags);
+  if (sentBytes < 0) {
+    Close();
+  }
+
+  return sentBytes == static_cast<ssize_t>(length);
+
+}
+
+bool BaseConnection::Read(void *data, size_t length) {
+
+  auto self = reinterpret_cast<BaseConnectionUnix*>(this);
+
+  if (self->sock == -1) {
+    return false;
+  }
+
+  long res = recv(self->sock, data, length, MsgFlags);
+  if (res < 0) {
+    if (errno == EAGAIN) {
+      return false;
+    }
+    Close();
+  }
+  else if (res == 0) {
+    Close();
+  }
+
+  return static_cast<size_t>(res) == length;
+
+}
+
+}  // namespace discord_rpc

3rdparty/discord-rpc/discord_connection_win.cpp

@@ -0,0 +1,160 @@
+/*
+ * Copyright 2017 Discord, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#include "discord_connection.h"
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMCX
+#define NOSERVICE
+#define NOIME
+
+#include <cassert>
+#include <windows.h>
+
+namespace discord_rpc {
+
+int GetProcessId() {
+  return static_cast<int>(::GetCurrentProcessId());
+}
+
+struct BaseConnectionWin : public BaseConnection {
+  HANDLE pipe{ INVALID_HANDLE_VALUE };
+};
+
+static BaseConnectionWin Connection;
+
+BaseConnection *BaseConnection::Create() {
+  return &Connection;
+}
+
+void BaseConnection::Destroy(BaseConnection *&c) {
+
+  auto self = reinterpret_cast<BaseConnectionWin*>(c);
+  self->Close();
+  c = nullptr;
+
+}
+
+bool BaseConnection::Open() {
+
+  wchar_t pipeName[]{ L"\\\\?\\pipe\\discord-ipc-0" };
+  const size_t pipeDigit = sizeof(pipeName) / sizeof(wchar_t) - 2;
+  pipeName[pipeDigit] = L'0';
+  auto self = reinterpret_cast<BaseConnectionWin*>(this);
+  for (;;) {
+    self->pipe = ::CreateFileW(pipeName, GENERIC_READ | GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, nullptr);
+    if (self->pipe != INVALID_HANDLE_VALUE) {
+      self->isOpen = true;
+      return true;
+    }
+
+    auto lastError = GetLastError();
+    if (lastError == ERROR_FILE_NOT_FOUND) {
+      if (pipeName[pipeDigit] < L'9') {
+        pipeName[pipeDigit]++;
+        continue;
+      }
+    }
+    else if (lastError == ERROR_PIPE_BUSY) {
+      if (!WaitNamedPipeW(pipeName, 10000)) {
+        return false;
+      }
+      continue;
+    }
+    return false;
+  }
+
+}
+
+bool BaseConnection::Close() {
+
+  auto self = reinterpret_cast<BaseConnectionWin*>(this);
+  ::CloseHandle(self->pipe);
+  self->pipe = INVALID_HANDLE_VALUE;
+  self->isOpen = false;
+
+  return true;
+
+}
+
+bool BaseConnection::Write(const void *data, size_t length) {
+
+  if (length == 0) {
+    return true;
+  }
+  auto self = reinterpret_cast<BaseConnectionWin*>(this);
+  assert(self);
+  if (!self) {
+    return false;
+  }
+  if (self->pipe == INVALID_HANDLE_VALUE) {
+    return false;
+  }
+  assert(data);
+  if (!data) {
+    return false;
+  }
+  const DWORD bytesLength = static_cast<DWORD>(length);
+  DWORD bytesWritten = 0;
+
+  return ::WriteFile(self->pipe, data, bytesLength, &bytesWritten, nullptr) == TRUE && bytesWritten == bytesLength;
+
+}
+
+bool BaseConnection::Read(void *data, size_t length) {
+
+  assert(data);
+  if (!data) {
+    return false;
+  }
+  auto self = reinterpret_cast<BaseConnectionWin*>(this);
+  assert(self);
+  if (!self) {
+    return false;
+  }
+  if (self->pipe == INVALID_HANDLE_VALUE) {
+    return false;
+  }
+  DWORD bytesAvailable = 0;
+  if (::PeekNamedPipe(self->pipe, nullptr, 0, nullptr, &bytesAvailable, nullptr)) {
+    if (bytesAvailable >= length) {
+      DWORD bytesToRead = static_cast<DWORD>(length);
+      DWORD bytesRead = 0;
+      if (::ReadFile(self->pipe, data, bytesToRead, &bytesRead, nullptr) == TRUE) {
+        assert(bytesToRead == bytesRead);
+        return true;
+      }
+      else {
+        Close();
+      }
+    }
+  }
+  else {
+    Close();
+  }
+
+  return false;
+
+}
+
+}  // namespace discord_rpc

3rdparty/discord-rpc/discord_msg_queue.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2017 Discord, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#ifndef DISCORD_MSG_QUEUE_H
+#define DISCORD_MSG_QUEUE_H
+
+#include <atomic>
+
+// A simple queue. No locks, but only works with a single thread as producer and a single thread as
+// a consumer. Mutex up as needed.
+
+namespace discord_rpc {
+
+template<typename ElementType, std::size_t QueueSize>
+class MsgQueue {
+  ElementType queue_[QueueSize];
+  std::atomic_uint nextAdd_{ 0 };
+  std::atomic_uint nextSend_{ 0 };
+  std::atomic_uint pendingSends_{ 0 };
+
+ public:
+  MsgQueue() {}
+
+  ElementType *GetNextAddMessage() {
+    // if we are falling behind, bail
+    if (pendingSends_.load() >= QueueSize) {
+      return nullptr;
+    }
+    auto index = (nextAdd_++) % QueueSize;
+    return &queue_[index];
+  }
+  void CommitAdd() { ++pendingSends_; }
+
+  bool HavePendingSends() const { return pendingSends_.load() != 0; }
+  ElementType *GetNextSendMessage() {
+    auto index = (nextSend_++) % QueueSize;
+    return &queue_[index];
+  }
+  void CommitSend() { --pendingSends_; }
+};
+
+}  // namespace discord_rpc
+
+#endif  // DISCORD_MSG_QUEUE_H

3rdparty/discord-rpc/discord_register.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2017 Discord, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#ifndef DISCORD_REGISTER_H
+#define DISCORD_REGISTER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void Discord_Register(const char *applicationId, const char *command);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // DISCORD_REGISTER_H

3rdparty/discord-rpc/discord_register_linux.cpp

@@ -0,0 +1,120 @@
+/*
+ * Copyright 2017 Discord, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#include "discord_rpc.h"
+#include "discord_register.h"
+
+#include <cstdio>
+#include <errno.h>
+#include <cstdlib>
+#include <cstring>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+namespace {
+
+static bool Mkdir(const char *path) {
+  int result = mkdir(path, 0755);
+  if (result == 0) {
+    return true;
+  }
+  if (errno == EEXIST) {
+    return true;
+  }
+  return false;
+}
+
+}  // namespace
+
+// We want to register games so we can run them from Discord client as discord-<appid>://
+extern "C" void Discord_Register(const char *applicationId, const char *command) {
+
+  // Add a desktop file and update some mime handlers so that xdg-open does the right thing.
+
+  const char *home = getenv("HOME");
+  if (!home) {
+    return;
+  }
+
+  char exePath[1024]{};
+  if (!command || !command[0]) {
+    const ssize_t size = readlink("/proc/self/exe", exePath, sizeof(exePath));
+    if (size <= 0 || size >= static_cast<ssize_t>(sizeof(exePath))) {
+      return;
+    }
+    exePath[size] = '\0';
+    command = exePath;
+  }
+
+  constexpr char desktopFileFormat[] = "[Desktop Entry]\n"
+                                       "Name=Game %s\n"
+                                       "Exec=%s %%u\n"  // note: it really wants that %u in there
+                                       "Type=Application\n"
+                                       "NoDisplay=true\n"
+                                       "Categories=Discord;Games;\n"
+                                       "MimeType=x-scheme-handler/discord-%s;\n";
+  char desktopFile[2048]{};
+  int fileLen = snprintf(desktopFile, sizeof(desktopFile), desktopFileFormat, applicationId, command, applicationId);
+  if (fileLen <= 0) {
+    return;
+  }
+
+  char desktopFilename[256]{};
+  (void)snprintf(desktopFilename, sizeof(desktopFilename), "/discord-%s.desktop", applicationId);
+
+  char desktopFilePath[1024]{};
+  (void)snprintf(desktopFilePath, sizeof(desktopFilePath), "%s/.local", home);
+  if (!Mkdir(desktopFilePath)) {
+    return;
+  }
+  strcat(desktopFilePath, "/share");
+  if (!Mkdir(desktopFilePath)) {
+    return;
+  }
+  strcat(desktopFilePath, "/applications");
+  if (!Mkdir(desktopFilePath)) {
+    return;
+  }
+  strcat(desktopFilePath, desktopFilename);
+
+  FILE *fp = fopen(desktopFilePath, "w");
+  if (fp) {
+    fwrite(desktopFile, 1, fileLen, fp);
+    fclose(fp);
+  }
+  else {
+    return;
+  }
+
+  char xdgMimeCommand[1024]{};
+  snprintf(xdgMimeCommand,
+           sizeof(xdgMimeCommand),
+           "xdg-mime default discord-%s.desktop x-scheme-handler/discord-%s",
+           applicationId,
+           applicationId);
+  if (system(xdgMimeCommand) < 0) {
+    fprintf(stderr, "Failed to register mime handler\n");
+  }
+
+}

3rdparty/discord-rpc/discord_register_osx.m

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2017 Discord, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#include <stdio.h>
+#include <sys/stat.h>
+
+#import <AppKit/AppKit.h>
+
+#include "discord_register.h"
+
+static void RegisterCommand(const char *applicationId, const char *command) {
+
+  // There does not appear to be a way to register arbitrary commands on OSX, so instead we'll save the command
+  // to a file in the Discord config path, and when it is needed, Discord can try to load the file there, open
+  // the command therein (will pass to js's window.open, so requires a url-like thing)
+
+  // Note: will not work for sandboxed apps
+  NSString *home = NSHomeDirectory();
+  if (!home) {
+    return;
+  }
+
+  NSString *path = [[[[[[home stringByAppendingPathComponent:@"Library"]
+                              stringByAppendingPathComponent:@"Application Support"]
+                              stringByAppendingPathComponent:@"discord"]
+                              stringByAppendingPathComponent:@"games"]
+                              stringByAppendingPathComponent:[NSString stringWithUTF8String:applicationId]]
+                              stringByAppendingPathExtension:@"json"];
+  [[NSFileManager defaultManager] createDirectoryAtPath:[path stringByDeletingLastPathComponent] withIntermediateDirectories:YES attributes:nil error:nil];
+
+  NSString *jsonBuffer = [NSString stringWithFormat:@"{\"command\": \"%s\"}", command];
+  [jsonBuffer writeToFile:path atomically:NO encoding:NSUTF8StringEncoding error:nil];
+
+}
+
+static void RegisterURL(const char *applicationId) {
+
+  char url[256];
+  snprintf(url, sizeof(url), "discord-%s", applicationId);
+  CFStringRef cfURL = CFStringCreateWithCString(NULL, url, kCFStringEncodingUTF8);
+
+  NSString* myBundleId = [[NSBundle mainBundle] bundleIdentifier];
+  if (!myBundleId) {
+    fprintf(stderr, "No bundle id found\n");
+    return;
+  }
+
+  NSURL* myURL = [[NSBundle mainBundle] bundleURL];
+  if (!myURL) {
+    fprintf(stderr, "No bundle url found\n");
+    return;
+  }
+
+  OSStatus status = LSSetDefaultHandlerForURLScheme(cfURL, (__bridge CFStringRef)myBundleId);
+  if (status != noErr) {
+    fprintf(stderr, "Error in LSSetDefaultHandlerForURLScheme: %d\n", (int)status);
+    return;
+  }
+
+  status = LSRegisterURL((__bridge CFURLRef)myURL, true);
+  if (status != noErr) {
+    fprintf(stderr, "Error in LSRegisterURL: %d\n", (int)status);
+  }
+
+}
+
+void Discord_Register(const char *applicationId, const char *command) {
+
+  if (command) {
+    RegisterCommand(applicationId, command);
+  }
+  else {
+    // raii lite
+    @autoreleasepool {
+      RegisterURL(applicationId);
+    }
+  }
+
+}

3rdparty/discord-rpc/discord_register_win.cpp

@@ -0,0 +1,165 @@
+/*
+ * Copyright 2017 Discord, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#include "discord_rpc.h"
+#include "discord_register.h"
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMCX
+#define NOSERVICE
+#define NOIME
+
+#include <windows.h>
+#include <psapi.h>
+#include <cstdio>
+
+/**
+ * Updated fixes for MinGW and WinXP
+ * This block is written the way it does not involve changing the rest of the code
+ * Checked to be compiling
+ * 1) strsafe.h belongs to Windows SDK and cannot be added to MinGW
+ * #include guarded, functions redirected to <string.h> substitutes
+ * 2) RegSetKeyValueW and LSTATUS are not declared in <winreg.h>
+ * The entire function is rewritten
+ */
+#ifdef __MINGW32__
+#  include <wchar.h>
+/// strsafe.h fixes
+static HRESULT StringCbPrintfW(LPWSTR pszDest, size_t cbDest, LPCWSTR pszFormat, ...) {
+  HRESULT ret;
+  va_list va;
+  va_start(va, pszFormat);
+  cbDest /= 2;  // Size is divided by 2 to convert from bytes to wide characters - causes segfault
+                // othervise
+  ret = vsnwprintf(pszDest, cbDest, pszFormat, va);
+  pszDest[cbDest - 1] = 0;  // Terminate the string in case a buffer overflow; -1 will be returned
+  va_end(va);
+  return ret;
+}
+#else
+#  include <cwchar>
+#  include <strsafe.h>
+#endif  // __MINGW32__
+
+/// winreg.h fixes
+#ifndef LSTATUS
+#  define LSTATUS LONG
+#endif
+#ifdef RegSetKeyValueW
+#  undefine RegSetKeyValueW
+#endif
+#define RegSetKeyValueW regset
+
+static LSTATUS regset(HKEY hkey, LPCWSTR subkey, LPCWSTR name, DWORD type, const void *data, DWORD len) {
+
+  HKEY htkey = hkey, hsubkey = nullptr;
+  LSTATUS ret;
+  if (subkey && subkey[0]) {
+    if ((ret = RegCreateKeyExW(hkey, subkey, 0, 0, 0, KEY_ALL_ACCESS, 0, &hsubkey, 0)) !=
+        ERROR_SUCCESS)
+      return ret;
+    htkey = hsubkey;
+  }
+  ret = RegSetValueExW(htkey, name, 0, type, static_cast<const BYTE*>(data), len);
+  if (hsubkey && hsubkey != hkey)
+    RegCloseKey(hsubkey);
+  return ret;
+
+}
+
+static void Discord_RegisterW(const wchar_t *applicationId, const wchar_t *command) {
+
+  // https://msdn.microsoft.com/en-us/library/aa767914(v=vs.85).aspx
+  // we want to register games so we can run them as discord-<appid>://
+  // Update the HKEY_CURRENT_USER, because it doesn't seem to require special permissions.
+
+  wchar_t exeFilePath[MAX_PATH]{};
+  DWORD exeLen = GetModuleFileNameW(nullptr, exeFilePath, MAX_PATH);
+  wchar_t openCommand[1024]{};
+
+  if (command && command[0]) {
+    StringCbPrintfW(openCommand, sizeof(openCommand), L"%s", command);
+  }
+  else {
+    // StringCbCopyW(openCommand, sizeof(openCommand), exeFilePath);
+    StringCbPrintfW(openCommand, sizeof(openCommand), L"%s", exeFilePath);
+  }
+
+  wchar_t protocolName[64]{};
+  StringCbPrintfW(protocolName, sizeof(protocolName), L"discord-%s", applicationId);
+  wchar_t protocolDescription[128]{};
+  StringCbPrintfW(protocolDescription, sizeof(protocolDescription), L"URL:Run game %s protocol", applicationId);
+  wchar_t urlProtocol = 0;
+
+  wchar_t keyName[256]{};
+  StringCbPrintfW(keyName, sizeof(keyName), L"Software\\Classes\\%s", protocolName);
+  HKEY key;
+  auto status = RegCreateKeyExW(HKEY_CURRENT_USER, keyName, 0, nullptr, 0, KEY_WRITE, nullptr, &key, nullptr);
+  if (status != ERROR_SUCCESS) {
+    fprintf(stderr, "Error creating key\n");
+    return;
+  }
+  DWORD len;
+  LSTATUS result;
+  len = static_cast<DWORD>(lstrlenW(protocolDescription) + 1);
+  result = RegSetKeyValueW(key, nullptr, nullptr, REG_SZ, protocolDescription, len * sizeof(wchar_t));
+  if (FAILED(result)) {
+    fprintf(stderr, "Error writing description\n");
+  }
+
+  len = static_cast<DWORD>(lstrlenW(protocolDescription) + 1);
+  result = RegSetKeyValueW(key, nullptr, L"URL Protocol", REG_SZ, &urlProtocol, sizeof(wchar_t));
+  if (FAILED(result)) {
+    fprintf(stderr, "Error writing description\n");
+  }
+
+  result = RegSetKeyValueW(key, L"DefaultIcon", nullptr, REG_SZ, exeFilePath, (exeLen + 1) * sizeof(wchar_t));
+  if (FAILED(result)) {
+    fprintf(stderr, "Error writing icon\n");
+  }
+
+  len = static_cast<DWORD>(lstrlenW(openCommand) + 1);
+  result = RegSetKeyValueW(key, L"shell\\open\\command", nullptr, REG_SZ, openCommand, len * sizeof(wchar_t));
+  if (FAILED(result)) {
+    fprintf(stderr, "Error writing command\n");
+  }
+  RegCloseKey(key);
+
+}
+
+extern "C" void Discord_Register(const char *applicationId, const char *command) {
+
+  wchar_t appId[32]{};
+  MultiByteToWideChar(CP_UTF8, 0, applicationId, -1, appId, 32);
+
+  wchar_t openCommand[1024]{};
+  const wchar_t *wcommand = nullptr;
+  if (command && command[0]) {
+    const auto commandBufferLen = sizeof(openCommand) / sizeof(*openCommand);
+    MultiByteToWideChar(CP_UTF8, 0, command, -1, openCommand, commandBufferLen);
+    wcommand = openCommand;
+  }
+
+  Discord_RegisterW(appId, wcommand);
+
+}

3rdparty/discord-rpc/discord_rpc.cpp

@@ -0,0 +1,510 @@
+/*
+ * Copyright 2017 Discord, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#include <atomic>
+#include <chrono>
+#include <mutex>
+#include <condition_variable>
+#include <thread>
+
+#include "discord_rpc.h"
+#include "discord_backoff.h"
+#include "discord_register.h"
+#include "discord_msg_queue.h"
+#include "discord_rpc_connection.h"
+#include "discord_serialization.h"
+
+using namespace discord_rpc;
+
+static void Discord_UpdateConnection();
+
+namespace {
+
+constexpr size_t MaxMessageSize{ 16 * 1024 };
+constexpr size_t MessageQueueSize{ 8 };
+constexpr size_t JoinQueueSize{ 8 };
+
+struct QueuedMessage {
+  size_t length;
+  char buffer[MaxMessageSize];
+
+  void Copy(const QueuedMessage &other) {
+    length = other.length;
+    if (length) {
+      memcpy(buffer, other.buffer, length);
+    }
+  }
+};
+
+struct User {
+  // snowflake (64bit int), turned into a ascii decimal string, at most 20 chars +1 null
+  // terminator = 21
+  char userId[32];
+  // 32 unicode glyphs is max name size => 4 bytes per glyph in the worst case, +1 for null
+  // terminator = 129
+  char username[344];
+  // 4 decimal digits + 1 null terminator = 5
+  char discriminator[8];
+  // optional 'a_' + md5 hex digest (32 bytes) + null terminator = 35
+  char avatar[128];
+  // Rounded way up because I'm paranoid about games breaking from future changes in these sizes
+};
+
+static RpcConnection *Connection{ nullptr };
+static DiscordEventHandlers QueuedHandlers{};
+static DiscordEventHandlers Handlers{};
+static std::atomic_bool WasJustConnected{ false };
+static std::atomic_bool WasJustDisconnected{ false };
+static std::atomic_bool GotErrorMessage{ false };
+static std::atomic_bool WasJoinGame{ false };
+static std::atomic_bool WasSpectateGame{ false };
+static std::atomic_bool UpdatePresence{ false };
+static char JoinGameSecret[256];
+static char SpectateGameSecret[256];
+static int LastErrorCode{ 0 };
+static char LastErrorMessage[256];
+static int LastDisconnectErrorCode{ 0 };
+static char LastDisconnectErrorMessage[256];
+static std::mutex PresenceMutex;
+static std::mutex HandlerMutex;
+static QueuedMessage QueuedPresence{};
+static MsgQueue<QueuedMessage, MessageQueueSize> SendQueue;
+static MsgQueue<User, JoinQueueSize> JoinAskQueue;
+static User connectedUser;
+
+// We want to auto connect, and retry on failure, but not as fast as possible. This does expoential backoff from 0.5 seconds to 1 minute
+static Backoff ReconnectTimeMs(500, 60 * 1000);
+static auto NextConnect = std::chrono::system_clock::now();
+static int Pid{ 0 };
+static int Nonce{ 1 };
+
+class IoThreadHolder {
+ private:
+  std::atomic_bool keepRunning{ true };
+  std::mutex waitForIOMutex;
+  std::condition_variable waitForIOActivity;
+  std::thread ioThread;
+
+ public:
+  void Start() {
+    keepRunning.store(true);
+    ioThread = std::thread([&]() {
+        const std::chrono::duration<int64_t, std::milli> maxWait { 500LL };
+        Discord_UpdateConnection();
+        while (keepRunning.load()) {
+          std::unique_lock<std::mutex> lock(waitForIOMutex);
+          waitForIOActivity.wait_for(lock, maxWait);
+          Discord_UpdateConnection();
+        }
+      });
+  }
+
+  void Notify() { waitForIOActivity.notify_all(); }
+
+  void Stop() {
+    keepRunning.exchange(false);
+    Notify();
+    if (ioThread.joinable()) {
+      ioThread.join();
+    }
+  }
+
+  ~IoThreadHolder() { Stop(); }
+};
+
+static IoThreadHolder *IoThread{ nullptr };
+
+static void UpdateReconnectTime() {
+
+  NextConnect = std::chrono::system_clock::now() + std::chrono::duration<int64_t, std::milli> { ReconnectTimeMs.nextDelay() };
+
+}
+
+static void SignalIOActivity() {
+
+  if (IoThread != nullptr) {
+    IoThread->Notify();
+  }
+
+}
+
+static bool RegisterForEvent(const char *evtName) {
+
+  auto qmessage = SendQueue.GetNextAddMessage();
+  if (qmessage) {
+    qmessage->length = JsonWriteSubscribeCommand(qmessage->buffer, sizeof(qmessage->buffer), Nonce++, evtName);
+    SendQueue.CommitAdd();
+    SignalIOActivity();
+    return true;
+  }
+
+  return false;
+
+}
+
+static bool DeregisterForEvent(const char *evtName) {
+
+  auto qmessage = SendQueue.GetNextAddMessage();
+  if (qmessage) {
+    qmessage->length = JsonWriteUnsubscribeCommand(qmessage->buffer, sizeof(qmessage->buffer), Nonce++, evtName);
+    SendQueue.CommitAdd();
+    SignalIOActivity();
+    return true;
+  }
+
+  return false;
+
+}
+
+} // namespace
+
+static void Discord_UpdateConnection() {
+
+  if (!Connection) {
+    return;
+  }
+
+  if (!Connection->IsOpen()) {
+    if (std::chrono::system_clock::now() >= NextConnect) {
+      UpdateReconnectTime();
+      Connection->Open();
+    }
+  }
+  else {
+    // reads
+
+    for (;;) {
+      JsonDocument message;
+
+      if (!Connection->Read(message)) {
+        break;
+      }
+
+      const char *evtName = GetStrMember(&message, "evt");
+      const char *nonce = GetStrMember(&message, "nonce");
+
+      if (nonce) {
+        // in responses only -- should use to match up response when needed.
+
+        if (evtName && strcmp(evtName, "ERROR") == 0) {
+          auto data = GetObjMember(&message, "data");
+          LastErrorCode = GetIntMember(data, "code");
+          StringCopy(LastErrorMessage, GetStrMember(data, "message", ""));
+          GotErrorMessage.store(true);
+        }
+      }
+      else {
+        // should have evt == name of event, optional data
+        if (evtName == nullptr) {
+          continue;
+        }
+
+        auto data = GetObjMember(&message, "data");
+
+        if (strcmp(evtName, "ACTIVITY_JOIN") == 0) {
+          auto secret = GetStrMember(data, "secret");
+          if (secret) {
+            StringCopy(JoinGameSecret, secret);
+            WasJoinGame.store(true);
+          }
+        }
+        else if (strcmp(evtName, "ACTIVITY_SPECTATE") == 0) {
+          auto secret = GetStrMember(data, "secret");
+          if (secret) {
+            StringCopy(SpectateGameSecret, secret);
+            WasSpectateGame.store(true);
+          }
+        }
+        else if (strcmp(evtName, "ACTIVITY_JOIN_REQUEST") == 0) {
+          auto user = GetObjMember(data, "user");
+          auto userId = GetStrMember(user, "id");
+          auto username = GetStrMember(user, "username");
+          auto avatar = GetStrMember(user, "avatar");
+          auto joinReq = JoinAskQueue.GetNextAddMessage();
+          if (userId && username && joinReq) {
+            StringCopy(joinReq->userId, userId);
+            StringCopy(joinReq->username, username);
+            auto discriminator = GetStrMember(user, "discriminator");
+            if (discriminator) {
+              StringCopy(joinReq->discriminator, discriminator);
+            }
+            if (avatar) {
+              StringCopy(joinReq->avatar, avatar);
+            }
+            else {
+              joinReq->avatar[0] = 0;
+            }
+            JoinAskQueue.CommitAdd();
+          }
+        }
+      }
+    }
+
+    // writes
+    if (UpdatePresence.exchange(false) && QueuedPresence.length) {
+      QueuedMessage local;
+      {
+        std::lock_guard<std::mutex> guard(PresenceMutex);
+        local.Copy(QueuedPresence);
+      }
+      if (!Connection->Write(local.buffer, local.length)) {
+        // if we fail to send, requeue
+        std::lock_guard<std::mutex> guard(PresenceMutex);
+        QueuedPresence.Copy(local);
+        UpdatePresence.exchange(true);
+      }
+    }
+
+    while (SendQueue.HavePendingSends()) {
+      auto qmessage = SendQueue.GetNextSendMessage();
+      Connection->Write(qmessage->buffer, qmessage->length);
+      SendQueue.CommitSend();
+    }
+  }
+
+}
+
+extern "C" void Discord_Initialize(const char *applicationId, DiscordEventHandlers *handlers, const int autoRegister) {
+
+  IoThread = new (std::nothrow) IoThreadHolder();
+  if (IoThread == nullptr) {
+    return;
+  }
+
+  if (autoRegister) {
+    Discord_Register(applicationId, nullptr);
+  }
+
+  Pid = GetProcessId();
+
+  {
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+
+    if (handlers) {
+      QueuedHandlers = *handlers;
+    }
+    else {
+      QueuedHandlers = {};
+    }
+
+    Handlers = {};
+  }
+
+  if (Connection) {
+    return;
+  }
+
+  Connection = RpcConnection::Create(applicationId);
+  Connection->onConnect = [](JsonDocument &readyMessage) {
+    Discord_UpdateHandlers(&QueuedHandlers);
+    if (QueuedPresence.length > 0) {
+      UpdatePresence.exchange(true);
+      SignalIOActivity();
+    }
+    auto data = GetObjMember(&readyMessage, "data");
+    auto user = GetObjMember(data, "user");
+    auto userId = GetStrMember(user, "id");
+    auto username = GetStrMember(user, "username");
+    auto avatar = GetStrMember(user, "avatar");
+    if (userId && username) {
+      StringCopy(connectedUser.userId, userId);
+      StringCopy(connectedUser.username, username);
+      auto discriminator = GetStrMember(user, "discriminator");
+      if (discriminator) {
+        StringCopy(connectedUser.discriminator, discriminator);
+      }
+      if (avatar) {
+        StringCopy(connectedUser.avatar, avatar);
+      }
+      else {
+        connectedUser.avatar[0] = 0;
+      }
+    }
+    WasJustConnected.exchange(true);
+    ReconnectTimeMs.reset();
+  };
+  Connection->onDisconnect = [](int err, const char *message) {
+    LastDisconnectErrorCode = err;
+    StringCopy(LastDisconnectErrorMessage, message);
+    WasJustDisconnected.exchange(true);
+    UpdateReconnectTime();
+  };
+
+  IoThread->Start();
+
+}
+
+extern "C" void Discord_Shutdown() {
+
+  if (!Connection) {
+    return;
+  }
+  Connection->onConnect = nullptr;
+  Connection->onDisconnect = nullptr;
+  Handlers = {};
+  QueuedPresence.length = 0;
+  UpdatePresence.exchange(false);
+  if (IoThread != nullptr) {
+    IoThread->Stop();
+    delete IoThread;
+    IoThread = nullptr;
+  }
+
+  RpcConnection::Destroy(Connection);
+
+}
+
+extern "C" void Discord_UpdatePresence(const DiscordRichPresence *presence) {
+
+  {
+    std::lock_guard<std::mutex> guard(PresenceMutex);
+    QueuedPresence.length = JsonWriteRichPresenceObj(QueuedPresence.buffer, sizeof(QueuedPresence.buffer), Nonce++, Pid, presence);
+    UpdatePresence.exchange(true);
+  }
+
+  SignalIOActivity();
+
+}
+
+extern "C" void Discord_ClearPresence(void) {
+  Discord_UpdatePresence(nullptr);
+}
+
+extern "C" void Discord_Respond(const char *userId, /* DISCORD_REPLY_ */ int reply) {
+
+  // if we are not connected, let's not batch up stale messages for later
+  if (!Connection || !Connection->IsOpen()) {
+    return;
+  }
+  auto qmessage = SendQueue.GetNextAddMessage();
+  if (qmessage) {
+    qmessage->length = JsonWriteJoinReply(qmessage->buffer, sizeof(qmessage->buffer), userId, reply, Nonce++);
+    SendQueue.CommitAdd();
+    SignalIOActivity();
+  }
+
+}
+
+extern "C" void Discord_RunCallbacks() {
+
+  // Note on some weirdness: internally we might connect, get other signals, disconnect any number
+  // of times inbetween calls here. Externally, we want the sequence to seem sane, so any other
+  // signals are book-ended by calls to ready and disconnect.
+
+  if (!Connection) {
+    return;
+  }
+
+  const bool wasDisconnected = WasJustDisconnected.exchange(false);
+  const bool isConnected = Connection->IsOpen();
+
+  if (isConnected) {
+    // if we are connected, disconnect cb first
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+    if (wasDisconnected && Handlers.disconnected) {
+      Handlers.disconnected(LastDisconnectErrorCode, LastDisconnectErrorMessage);
+    }
+  }
+
+  if (WasJustConnected.exchange(false)) {
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+    if (Handlers.ready) {
+      DiscordUser du{ connectedUser.userId, connectedUser.username, connectedUser.discriminator, connectedUser.avatar };
+      Handlers.ready(&du);
+    }
+  }
+
+  if (GotErrorMessage.exchange(false)) {
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+    if (Handlers.errored) {
+      Handlers.errored(LastErrorCode, LastErrorMessage);
+    }
+  }
+
+  if (WasJoinGame.exchange(false)) {
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+    if (Handlers.joinGame) {
+      Handlers.joinGame(JoinGameSecret);
+    }
+  }
+
+  if (WasSpectateGame.exchange(false)) {
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+    if (Handlers.spectateGame) {
+      Handlers.spectateGame(SpectateGameSecret);
+    }
+  }
+
+  // Right now this batches up any requests and sends them all in a burst; I could imagine a world
+  // where the implementer would rather sequentially accept/reject each one before the next invite
+  // is sent. I left it this way because I could also imagine wanting to process these all and
+  // maybe show them in one common dialog and/or start fetching the avatars in parallel, and if
+  // not it should be trivial for the implementer to make a queue themselves.
+  while (JoinAskQueue.HavePendingSends()) {
+    const auto req = JoinAskQueue.GetNextSendMessage();
+    {
+      std::lock_guard<std::mutex> guard(HandlerMutex);
+      if (Handlers.joinRequest) {
+        DiscordUser du{ req->userId, req->username, req->discriminator, req->avatar };
+        Handlers.joinRequest(&du);
+      }
+    }
+    JoinAskQueue.CommitSend();
+  }
+
+  if (!isConnected) {
+    // if we are not connected, disconnect message last
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+    if (wasDisconnected && Handlers.disconnected) {
+      Handlers.disconnected(LastDisconnectErrorCode, LastDisconnectErrorMessage);
+    }
+  }
+
+}
+
+extern "C" void Discord_UpdateHandlers(DiscordEventHandlers *newHandlers) {
+
+  if (newHandlers) {
+#define HANDLE_EVENT_REGISTRATION(handler_name, event)            \
+        if (!Handlers.handler_name && newHandlers->handler_name) {      \
+          RegisterForEvent(event);                                      \
+        }                                                               \
+        else if (Handlers.handler_name && !newHandlers->handler_name) { \
+          DeregisterForEvent(event);                                    \
+        }
+
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+    HANDLE_EVENT_REGISTRATION(joinGame, "ACTIVITY_JOIN")
+    HANDLE_EVENT_REGISTRATION(spectateGame, "ACTIVITY_SPECTATE")
+    HANDLE_EVENT_REGISTRATION(joinRequest, "ACTIVITY_JOIN_REQUEST")
+
+#undef HANDLE_EVENT_REGISTRATION
+
+    Handlers = *newHandlers;
+  }
+  else {
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+    Handlers = {};
+  }
+
+}

3rdparty/discord-rpc/discord_rpc.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2017 Discord, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#ifndef DISCORD_RPC_H
+#define DISCORD_RPC_H
+
+#include <cstdint>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct DiscordRichPresence {
+  int type;
+  int status_display_type;
+  const char *name;    /* max 128 bytes */
+  const char *state;   /* max 128 bytes */
+  const char *details; /* max 128 bytes */
+  int64_t startTimestamp;
+  int64_t endTimestamp;
+  const char *largeImageKey;  /* max 32 bytes */
+  const char *largeImageText; /* max 128 bytes */
+  const char *smallImageKey;  /* max 32 bytes */
+  const char *smallImageText; /* max 128 bytes */
+  const char *partyId;        /* max 128 bytes */
+  int partySize;
+  int partyMax;
+  int partyPrivacy;
+  const char *matchSecret;    /* max 128 bytes */
+  const char *joinSecret;     /* max 128 bytes */
+  const char *spectateSecret; /* max 128 bytes */
+  int8_t instance;
+} DiscordRichPresence;
+
+typedef struct DiscordUser {
+  const char *userId;
+  const char *username;
+  const char *discriminator;
+  const char *avatar;
+} DiscordUser;
+
+typedef struct DiscordEventHandlers {
+  void (*ready)(const DiscordUser *request);
+  void (*disconnected)(int errorCode, const char *message);
+  void (*errored)(int errorCode, const char *message);
+  void (*joinGame)(const char *joinSecret);
+  void (*spectateGame)(const char *spectateSecret);
+  void (*joinRequest)(const DiscordUser *request);
+} DiscordEventHandlers;
+
+#define DISCORD_REPLY_NO      0
+#define DISCORD_REPLY_YES     1
+#define DISCORD_REPLY_IGNORE  2
+#define DISCORD_PARTY_PRIVATE 0
+#define DISCORD_PARTY_PUBLIC  1
+
+void Discord_Initialize(const char *applicationId, DiscordEventHandlers *handlers, const int autoRegister);
+void Discord_Shutdown(void);
+
+// checks for incoming messages, dispatches callbacks
+void Discord_RunCallbacks(void);
+
+void Discord_UpdatePresence(const DiscordRichPresence *presence);
+void Discord_ClearPresence(void);
+
+void Discord_Respond(const char *userid, /* DISCORD_REPLY_ */ int reply);
+
+void Discord_UpdateHandlers(DiscordEventHandlers *handlers);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif  // DISCORD_RPC_H

3rdparty/discord-rpc/discord_rpc_connection.cpp

@@ -0,0 +1,168 @@
+/*
+ * Copyright 2017 Discord, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#include "discord_rpc_connection.h"
+#include "discord_serialization.h"
+
+namespace discord_rpc {
+
+static const int RpcVersion = 1;
+static RpcConnection Instance;
+
+RpcConnection *RpcConnection::Create(const char *applicationId) {
+
+  Instance.connection = BaseConnection::Create();
+  StringCopy(Instance.appId, applicationId);
+  return &Instance;
+
+}
+
+void RpcConnection::Destroy(RpcConnection *&c) {
+
+  c->Close();
+  BaseConnection::Destroy(c->connection);
+  c = nullptr;
+
+}
+
+void RpcConnection::Open() {
+
+  if (state == State::Connected) {
+    return;
+  }
+
+  if (state == State::Disconnected && !connection->Open()) {
+    return;
+  }
+
+  if (state == State::SentHandshake) {
+    JsonDocument message;
+    if (Read(message)) {
+      auto cmd = GetStrMember(&message, "cmd");
+      auto evt = GetStrMember(&message, "evt");
+      if (cmd && evt && !strcmp(cmd, "DISPATCH") && !strcmp(evt, "READY")) {
+        state = State::Connected;
+        if (onConnect) {
+          onConnect(message);
+        }
+      }
+    }
+  }
+  else {
+    sendFrame.opcode = Opcode::Handshake;
+    sendFrame.length = static_cast<uint32_t>(JsonWriteHandshakeObj(sendFrame.message, sizeof(sendFrame.message), RpcVersion, appId));
+
+    if (connection->Write(&sendFrame, sizeof(MessageFrameHeader) + sendFrame.length)) {
+      state = State::SentHandshake;
+    }
+    else {
+      Close();
+    }
+  }
+
+}
+
+void RpcConnection::Close() {
+
+  if (onDisconnect && (state == State::Connected || state == State::SentHandshake)) {
+    onDisconnect(lastErrorCode, lastErrorMessage);
+  }
+  connection->Close();
+  state = State::Disconnected;
+
+}
+
+bool RpcConnection::Write(const void *data, size_t length) {
+
+  sendFrame.opcode = Opcode::Frame;
+  memcpy(sendFrame.message, data, length);
+  sendFrame.length = static_cast<uint32_t>(length);
+  if (!connection->Write(&sendFrame, sizeof(MessageFrameHeader) + length)) {
+    Close();
+    return false;
+  }
+
+  return true;
+
+}
+
+bool RpcConnection::Read(JsonDocument &message) {
+
+  if (state != State::Connected && state != State::SentHandshake) {
+    return false;
+  }
+  MessageFrame readFrame{};
+  for (;;) {
+    bool didRead = connection->Read(&readFrame, sizeof(MessageFrameHeader));
+    if (!didRead) {
+      if (!connection->isOpen) {
+        lastErrorCode = static_cast<int>(ErrorCode::PipeClosed);
+        StringCopy(lastErrorMessage, "Pipe closed");
+        Close();
+      }
+      return false;
+    }
+
+    if (readFrame.length > 0) {
+      didRead = connection->Read(readFrame.message, readFrame.length);
+      if (!didRead) {
+        lastErrorCode = static_cast<int>(ErrorCode::ReadCorrupt);
+        StringCopy(lastErrorMessage, "Partial data in frame");
+        Close();
+        return false;
+      }
+      readFrame.message[readFrame.length] = 0;
+    }
+
+    switch (readFrame.opcode) {
+      case Opcode::Close: {
+        message.ParseInsitu(readFrame.message);
+        lastErrorCode = GetIntMember(&message, "code");
+        StringCopy(lastErrorMessage, GetStrMember(&message, "message", ""));
+        Close();
+        return false;
+      }
+      case Opcode::Frame:
+        message.ParseInsitu(readFrame.message);
+        return true;
+      case Opcode::Ping:
+        readFrame.opcode = Opcode::Pong;
+        if (!connection->Write(&readFrame, sizeof(MessageFrameHeader) + readFrame.length)) {
+          Close();
+        }
+        break;
+      case Opcode::Pong:
+        break;
+      case Opcode::Handshake:
+      default:
+        // something bad happened
+        lastErrorCode = static_cast<int>(ErrorCode::ReadCorrupt);
+        StringCopy(lastErrorMessage, "Bad ipc frame");
+        Close();
+        return false;
+    }
+  }
+
+}
+
+}  // namespace discord_rpc

3rdparty/discord-rpc/discord_rpc_connection.h

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2017 Discord, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#ifndef DISCORD_RPC_CONNECTION_H
+#define DISCORD_RPC_CONNECTION_H
+
+#include "discord_connection.h"
+#include "discord_serialization.h"
+
+namespace discord_rpc {
+
+// I took this from the buffer size libuv uses for named pipes; I suspect ours would usually be much smaller.
+constexpr size_t MaxRpcFrameSize = 64 * 1024;
+
+struct RpcConnection {
+  enum class ErrorCode : int {
+    Success = 0,
+    PipeClosed = 1,
+    ReadCorrupt = 2,
+  };
+
+  enum class Opcode : uint32_t {
+    Handshake = 0,
+    Frame = 1,
+    Close = 2,
+    Ping = 3,
+    Pong = 4,
+  };
+
+  struct MessageFrameHeader {
+    Opcode opcode;
+    uint32_t length;
+  };
+
+  struct MessageFrame : public MessageFrameHeader {
+    char message[MaxRpcFrameSize - sizeof(MessageFrameHeader)];
+  };
+
+  enum class State : uint32_t {
+    Disconnected,
+    SentHandshake,
+    AwaitingResponse,
+    Connected,
+  };
+
+  BaseConnection *connection{ nullptr };
+  State state{ State::Disconnected };
+  void (*onConnect)(JsonDocument &message) { nullptr };
+  void (*onDisconnect)(int errorCode, const char *message) { nullptr };
+  char appId[64]{};
+  int lastErrorCode{ 0 };
+  char lastErrorMessage[256]{};
+  RpcConnection::MessageFrame sendFrame;
+
+  static RpcConnection *Create(const char *applicationId);
+  static void Destroy(RpcConnection*&);
+
+  inline bool IsOpen() const { return state == State::Connected; }
+
+  void Open();
+  void Close();
+  bool Write(const void *data, size_t length);
+  bool Read(JsonDocument &message);
+};
+
+}  // namespace discord_rpc
+
+#endif  // DISCORD_RPC_CONNECTION_H

3rdparty/discord-rpc/discord_serialization.cpp

@@ -0,0 +1,285 @@
+/*
+ * Copyright 2017 Discord, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#include "discord_serialization.h"
+#include "discord_connection.h"
+#include "discord_rpc.h"
+
+namespace discord_rpc {
+
+template<typename T>
+void NumberToString(char *dest, T number) {
+
+  if (!number) {
+    *dest++ = '0';
+    *dest++ = 0;
+    return;
+  }
+  if (number < 0) {
+    *dest++ = '-';
+    number = -number;
+  }
+  char temp[32];
+  int place = 0;
+  while (number) {
+    auto digit = number % 10;
+    number = number / 10;
+    temp[place++] = '0' + static_cast<char>(digit);
+  }
+  for (--place; place >= 0; --place) {
+    *dest++ = temp[place];
+  }
+  *dest = 0;
+
+}
+
+// it's ever so slightly faster to not have to strlen the key
+template<typename T>
+void WriteKey(JsonWriter &w, T &k) {
+  w.Key(k, sizeof(T) - 1);
+}
+
+struct WriteObject {
+  JsonWriter &writer;
+  WriteObject(JsonWriter &w)
+      : writer(w) {
+    writer.StartObject();
+  }
+  template<typename T>
+  WriteObject(JsonWriter &w, T &name)
+      : writer(w) {
+    WriteKey(writer, name);
+    writer.StartObject();
+  }
+  ~WriteObject() { writer.EndObject(); }
+};
+
+struct WriteArray {
+  JsonWriter &writer;
+  template<typename T>
+  WriteArray(JsonWriter &w, T &name)
+      : writer(w) {
+    WriteKey(writer, name);
+    writer.StartArray();
+  }
+  ~WriteArray() { writer.EndArray(); }
+};
+
+template<typename T>
+void WriteOptionalString(JsonWriter &w, T &k, const char *value) {
+
+  if (value && value[0]) {
+    w.Key(k, sizeof(T) - 1);
+    w.String(value);
+  }
+
+}
+
+static void JsonWriteNonce(JsonWriter &writer, const int nonce) {
+
+  WriteKey(writer, "nonce");
+  char nonceBuffer[32];
+  NumberToString(nonceBuffer, nonce);
+  writer.String(nonceBuffer);
+
+}
+
+size_t JsonWriteRichPresenceObj(char *dest, const size_t maxLen, const int nonce, const int pid, const DiscordRichPresence *presence) {
+
+  JsonWriter writer(dest, maxLen);
+
+  {
+    WriteObject top(writer);
+
+    JsonWriteNonce(writer, nonce);
+
+    WriteKey(writer, "cmd");
+    writer.String("SET_ACTIVITY");
+
+    {
+      WriteObject args(writer, "args");
+
+      WriteKey(writer, "pid");
+      writer.Int(pid);
+
+      if (presence != nullptr) {
+        WriteObject activity(writer, "activity");
+
+        if (presence->type >= 0 && presence->type <= 5) {
+          WriteKey(writer, "type");
+          writer.Int(presence->type);
+
+          WriteKey(writer, "status_display_type");
+          writer.Int(presence->status_display_type);
+        }
+
+        WriteOptionalString(writer, "name", presence->name);
+        WriteOptionalString(writer, "state", presence->state);
+        WriteOptionalString(writer, "details", presence->details);
+
+        if (presence->startTimestamp || presence->endTimestamp) {
+          WriteObject timestamps(writer, "timestamps");
+
+          if (presence->startTimestamp) {
+            WriteKey(writer, "start");
+            writer.Int64(presence->startTimestamp);
+          }
+
+          if (presence->endTimestamp) {
+            WriteKey(writer, "end");
+            writer.Int64(presence->endTimestamp);
+          }
+        }
+
+        if ((presence->largeImageKey && presence->largeImageKey[0]) ||
+            (presence->largeImageText && presence->largeImageText[0]) ||
+            (presence->smallImageKey && presence->smallImageKey[0]) ||
+            (presence->smallImageText && presence->smallImageText[0])) {
+          WriteObject assets(writer, "assets");
+          WriteOptionalString(writer, "large_image", presence->largeImageKey);
+          WriteOptionalString(writer, "large_text", presence->largeImageText);
+          WriteOptionalString(writer, "small_image", presence->smallImageKey);
+          WriteOptionalString(writer, "small_text", presence->smallImageText);
+        }
+
+        if ((presence->partyId && presence->partyId[0]) || presence->partySize ||
+            presence->partyMax || presence->partyPrivacy) {
+          WriteObject party(writer, "party");
+          WriteOptionalString(writer, "id", presence->partyId);
+          if (presence->partySize && presence->partyMax) {
+            WriteArray size(writer, "size");
+            writer.Int(presence->partySize);
+            writer.Int(presence->partyMax);
+          }
+
+          if (presence->partyPrivacy) {
+            WriteKey(writer, "privacy");
+            writer.Int(presence->partyPrivacy);
+          }
+        }
+
+        if ((presence->matchSecret && presence->matchSecret[0]) ||
+            (presence->joinSecret && presence->joinSecret[0]) ||
+            (presence->spectateSecret && presence->spectateSecret[0])) {
+          WriteObject secrets(writer, "secrets");
+          WriteOptionalString(writer, "match", presence->matchSecret);
+          WriteOptionalString(writer, "join", presence->joinSecret);
+          WriteOptionalString(writer, "spectate", presence->spectateSecret);
+        }
+
+        writer.Key("instance");
+        writer.Bool(presence->instance != 0);
+      }
+    }
+  }
+
+  return writer.Size();
+}
+
+size_t JsonWriteHandshakeObj(char *dest, size_t maxLen, int version, const char *applicationId) {
+
+  JsonWriter writer(dest, maxLen);
+
+  {
+    WriteObject obj(writer);
+    WriteKey(writer, "v");
+    writer.Int(version);
+    WriteKey(writer, "client_id");
+    writer.String(applicationId);
+  }
+
+  return writer.Size();
+
+}
+
+size_t JsonWriteSubscribeCommand(char *dest, size_t maxLen, int nonce, const char *evtName) {
+
+  JsonWriter writer(dest, maxLen);
+
+  {
+    WriteObject obj(writer);
+
+    JsonWriteNonce(writer, nonce);
+
+    WriteKey(writer, "cmd");
+    writer.String("SUBSCRIBE");
+
+    WriteKey(writer, "evt");
+    writer.String(evtName);
+  }
+
+  return writer.Size();
+
+}
+
+size_t JsonWriteUnsubscribeCommand(char *dest, size_t maxLen, int nonce, const char *evtName) {
+
+  JsonWriter writer(dest, maxLen);
+
+  {
+    WriteObject obj(writer);
+
+    JsonWriteNonce(writer, nonce);
+
+    WriteKey(writer, "cmd");
+    writer.String("UNSUBSCRIBE");
+
+    WriteKey(writer, "evt");
+    writer.String(evtName);
+  }
+
+  return writer.Size();
+
+}
+
+size_t JsonWriteJoinReply(char *dest, size_t maxLen, const char *userId, const int reply, const int nonce) {
+
+  JsonWriter writer(dest, maxLen);
+
+  {
+    WriteObject obj(writer);
+
+    WriteKey(writer, "cmd");
+    if (reply == DISCORD_REPLY_YES) {
+      writer.String("SEND_ACTIVITY_JOIN_INVITE");
+    }
+    else {
+      writer.String("CLOSE_ACTIVITY_JOIN_REQUEST");
+    }
+
+    WriteKey(writer, "args");
+    {
+      WriteObject args(writer);
+
+      WriteKey(writer, "user_id");
+      writer.String(userId);
+    }
+
+    JsonWriteNonce(writer, nonce);
+  }
+
+  return writer.Size();
+
+}
+
+}  // namespace discord_rpc

3rdparty/discord-rpc/discord_serialization.h

@@ -0,0 +1,213 @@
+/*
+ * Copyright 2017 Discord, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#ifndef DISCORD_SERIALIZATION_H
+#define DISCORD_SERIALIZATION_H
+
+#include <rapidjson/document.h>
+#include <rapidjson/stringbuffer.h>
+#include <rapidjson/writer.h>
+
+struct DiscordRichPresence;
+
+namespace discord_rpc {
+
+// if only there was a standard library function for this
+template<size_t Len>
+inline size_t StringCopy(char (&dest)[Len], const char *src) {
+  if (!src || !Len) {
+    return 0;
+  }
+  size_t copied;
+  char *out = dest;
+  for (copied = 1; *src && copied < Len; ++copied) {
+    *out++ = *src++;
+  }
+  *out = 0;
+  return copied - 1;
+}
+
+size_t JsonWriteHandshakeObj(char *dest, size_t maxLen, int version, const char *applicationId);
+
+// Commands
+size_t JsonWriteRichPresenceObj(char *dest, const size_t maxLen, const int nonce, const int pid, const DiscordRichPresence *presence);
+size_t JsonWriteSubscribeCommand(char *dest, size_t maxLen, int nonce, const char *evtName);
+
+size_t JsonWriteUnsubscribeCommand(char *dest, size_t maxLen, int nonce, const char *evtName);
+
+size_t JsonWriteJoinReply(char *dest, size_t maxLen, const char *userId, int reply, int nonce);
+
+// I want to use as few allocations as I can get away with, and to do that with RapidJson, you need
+// to supply some of your own allocators for stuff rather than use the defaults
+
+class LinearAllocator {
+ public:
+  char *buffer_;
+  char *end_;
+  LinearAllocator() {
+    assert(0);  // needed for some default case in rapidjson, should not use
+  }
+  LinearAllocator(char *buffer, size_t size)
+      : buffer_(buffer), end_(buffer + size) {
+  }
+  static const bool kNeedFree = false;
+  void *Malloc(size_t size) {
+    char *res = buffer_;
+    buffer_ += size;
+    if (buffer_ > end_) {
+      buffer_ = res;
+      return nullptr;
+    }
+    return res;
+  }
+  void *Realloc(void *originalPtr, size_t originalSize, size_t newSize) {
+    if (newSize == 0) {
+      return nullptr;
+    }
+    // allocate how much you need in the first place
+    assert(!originalPtr && !originalSize);
+    // unused parameter warning
+    (void)(originalPtr);
+    (void)(originalSize);
+    return Malloc(newSize);
+  }
+  static void Free(void *ptr) {
+    /* shrug */
+    (void)ptr;
+  }
+};
+
+template<size_t Size>
+class FixedLinearAllocator : public LinearAllocator {
+ public:
+  char fixedBuffer_[Size];
+  FixedLinearAllocator()
+      : LinearAllocator(fixedBuffer_, Size) {
+  }
+  static const bool kNeedFree = false;
+};
+
+// wonder why this isn't a thing already, maybe I missed it
+class DirectStringBuffer {
+ public:
+  using Ch = char;
+  char *buffer_;
+  char *end_;
+  char *current_;
+
+  DirectStringBuffer(char *buffer, size_t maxLen)
+      : buffer_(buffer), end_(buffer + maxLen), current_(buffer) {
+  }
+
+  void Put(char c) {
+    if (current_ < end_) {
+      *current_++ = c;
+    }
+  }
+  void Flush() {}
+  size_t GetSize() const { return static_cast<size_t>(current_ - buffer_); }
+};
+
+using MallocAllocator = rapidjson::CrtAllocator;
+using PoolAllocator = rapidjson::MemoryPoolAllocator<MallocAllocator>;
+using UTF8 = rapidjson::UTF8<char>;
+// Writer appears to need about 16 bytes per nested object level (with 64bit size_t)
+using StackAllocator = FixedLinearAllocator<2048>;
+constexpr size_t WriterNestingLevels = 2048 / (2 * sizeof(size_t));
+using JsonWriterBase =
+  rapidjson::Writer<DirectStringBuffer, UTF8, UTF8, StackAllocator, rapidjson::kWriteNoFlags>;
+class JsonWriter : public JsonWriterBase {
+ public:
+  DirectStringBuffer stringBuffer_;
+  StackAllocator stackAlloc_;
+
+  JsonWriter(char *dest, size_t maxLen)
+      : JsonWriterBase(stringBuffer_, &stackAlloc_, WriterNestingLevels), stringBuffer_(dest, maxLen), stackAlloc_() {
+  }
+
+  size_t Size() const { return stringBuffer_.GetSize(); }
+};
+
+using JsonDocumentBase = rapidjson::GenericDocument<UTF8, PoolAllocator, StackAllocator>;
+class JsonDocument : public JsonDocumentBase {
+ public:
+  static const int kDefaultChunkCapacity = 32 * 1024;
+  // json parser will use this buffer first, then allocate more if needed; I seriously doubt we
+  // send any messages that would use all of this, though.
+  char parseBuffer_[32 * 1024];
+  MallocAllocator mallocAllocator_;
+  PoolAllocator poolAllocator_;
+  StackAllocator stackAllocator_;
+  JsonDocument()
+      : JsonDocumentBase(rapidjson::kObjectType,
+                         &poolAllocator_,
+                         sizeof(stackAllocator_.fixedBuffer_),
+                         &stackAllocator_),
+        poolAllocator_(parseBuffer_, sizeof(parseBuffer_), kDefaultChunkCapacity, &mallocAllocator_), stackAllocator_() {
+  }
+};
+
+using JsonValue = rapidjson::GenericValue<UTF8, PoolAllocator>;
+
+inline JsonValue *GetObjMember(JsonValue *obj, const char *name) {
+
+  if (obj) {
+    auto member = obj->FindMember(name);
+    if (member != obj->MemberEnd() && member->value.IsObject()) {
+      return &member->value;
+    }
+  }
+
+  return nullptr;
+
+}
+
+inline int GetIntMember(JsonValue *obj, const char *name, int notFoundDefault = 0) {
+
+  if (obj) {
+    auto member = obj->FindMember(name);
+    if (member != obj->MemberEnd() && member->value.IsInt()) {
+      return member->value.GetInt();
+    }
+  }
+
+  return notFoundDefault;
+
+}
+
+inline const char *GetStrMember(JsonValue *obj, const char *name, const char *notFoundDefault = nullptr) {
+
+  if (obj) {
+    auto member = obj->FindMember(name);
+    if (member != obj->MemberEnd() && member->value.IsString()) {
+      return member->value.GetString();
+    }
+  }
+
+  return notFoundDefault;
+
+}
+
+}  // namespace discord_rpc
+
+#endif  // DISCORD_SERIALIZATION_H

3rdparty/singleapplication/CMakeLists.txt

@@ -1,32 +0,0 @@
-cmake_minimum_required(VERSION 2.8.11)
-
-include(CheckIncludeFiles)
-include(CheckFunctionExists)
-
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
-set(CMAKE_CXX_STANDARD 11)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --std=c++11 -U__STRICT_ANSI__ -Wall -Woverloaded-virtual -Wno-sign-compare -fpermissive")
-
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wextra -Wpedantic")
-endif()
-
-if(CMAKE_VERSION VERSION_GREATER 3.0)
-  check_function_exists(geteuid HAVE_GETEUID)
-  check_function_exists(getpwuid HAVE_GETPWUID)
-endif()
-
-set(SINGLEAPP-SOURCES singleapplication.cpp singleapplication_p.cpp)
-set(SINGLEAPP-MOC-HEADERS singleapplication.h singleapplication_p.h)
-QT5_WRAP_CPP(SINGLEAPP-SOURCES-MOC ${SINGLEAPP-MOC-HEADERS})
-ADD_LIBRARY(singleapplication STATIC ${SINGLEAPP-SOURCES} ${SINGLEAPP-SOURCES-MOC})
-target_link_libraries(singleapplication Qt5::Core Qt5::Widgets Qt5::Network)
-
-set(SINGLECOREAPP-SOURCES singlecoreapplication.cpp singlecoreapplication_p.cpp)
-set(SINGLECOREAPP-MOC-HEADERS singlecoreapplication.h singlecoreapplication_p.h)
-QT5_WRAP_CPP(SINGLECOREAPP-SOURCES-MOC ${SINGLECOREAPP-MOC-HEADERS})
-ADD_LIBRARY(singlecoreapplication STATIC ${SINGLECOREAPP-SOURCES} ${SINGLECOREAPP-SOURCES-MOC})
-target_link_libraries(singlecoreapplication Qt5::Core Qt5::Widgets Qt5::Network)
-
-configure_file(config.h.in "${CMAKE_CURRENT_BINARY_DIR}/config.h")
-include_directories(${CMAKE_CURRENT_BINARY_DIR})

3rdparty/singleapplication/README.md

@@ -1,265 +0,0 @@
-SingleApplication
-=================
-
-This is a replacement of the QtSingleApplication for `Qt5`.
-
-Keeps the Primary Instance of your Application and kills each subsequent
-instances. It can (if enabled) spawn secondary (non-related to the primary)
-instances and can send data to the primary instance from secondary instances.
-
-Usage
------
-
-The `SingleApplication` class inherits from whatever `Q[Core|Gui]Application`
-class you specify via the `QAPPLICATION_CLASS` macro (`QCoreApplication` is the
-default). Further usage is similar to the use of the `Q[Core|Gui]Application`
-classes.
-
-The library sets up a `QLocalServer` and a `QSharedMemory` block. The first
-instance of your Application is your Primary Instance. It would check if the
-shared memory block exists and if not it will start a `QLocalServer` and listen
-for connections. Each subsequent instance of your application would check if the
-shared memory block exists and if it does, it will connect to the QLocalServer
-to notify the primary instance that a new instance had been started, after which
-it would terminate with status code `0`. In the Primary Instance
-`SingleApplication` would emit the `instanceStarted()` signal upon detecting
-that a new instance had been started.
-
-The library uses `stdlib` to terminate the program with the `exit()` function.
-
-You can use the library as if you use any other `QCoreApplication` derived
-class:
-
-```cpp
-#include <QApplication>
-#include <SingleApplication.h>
-
-int main( int argc, char* argv[] )
-{
-    SingleApplication app( argc, argv );
-
-    return app.exec();
-}
-```
-
-To include the library files I would recommend that you add it as a git
-submodule to your project and include it's contents with a `.pri` file. Here is
-how:
-
-```bash
-git submodule add git@github.com:itay-grudev/SingleApplication.git singleapplication
-```
-
-Then include the `singleapplication.pri` file in your `.pro` project file. Also
-don't forget to specify which `QCoreApplication` class your app is using if it
-is not `QCoreApplication`.
-
-```qmake
-include(singleapplication/singleapplication.pri)
-DEFINES += QAPPLICATION_CLASS=QApplication
-```
-
-The `Instance Started` signal
-------------------------
-
-The SingleApplication class implements a `instanceStarted()` signal. You can
-bind to that signal to raise your application's window when a new instance had
-been started, for example.
-
-```cpp
-// window is a QWindow instance
-QObject::connect(
-    &app,
-    &SingleApplication::instanceStarted,
-    &window,
-    &QWindow::raise
-);
-```
-
-Using `SingleApplication::instance()` is a neat way to get the
-`SingleApplication` instance for binding to it's signals anywhere in your
-program.
-
-__Note:__ On Windows the ability to bring the application windows to the
-foreground is restricted. See [Windows specific implementations](Windows.md)
-for a workaround and an example implementation.
-
-
-Secondary Instances
--------------------
-
-If you want to be able to launch additional Secondary Instances (not related to
-your Primary Instance) you have to enable that with the third parameter of the
-`SingleApplication` constructor. The default is `false` meaning no Secondary
-Instances. Here is an example of how you would start a Secondary Instance send
-a message with the command line arguments to the primary instance and then shut
-down.
-
-```cpp
-int main(int argc, char *argv[])
-{
-    SingleApplication app( argc, argv, true );
-
-    if( app.isSecondary() ) {
-        app.sendMessage(  app.arguments().join(' ')).toUtf8() );
-        app.exit( 0 );
-    }
-
-    return app.exec();
-}
-```
-
-*__Note:__ A secondary instance won't cause the emission of the
-`instanceStarted()` signal by default. See `SingleApplication::Mode` for more
-details.*
-
-You can check whether your instance is a primary or secondary with the following
-methods:
-
-```cpp
-app.isPrimary();
-// or
-app.isSecondary();
-```
-
-*__Note:__ If your Primary Instance is terminated a newly launched instance
-will replace the Primary one even if the Secondary flag has been set.*
-
-API
----
-
-### Members
-
-```cpp
-SingleApplication::SingleApplication( int &argc, char *argv[], bool allowSecondary = false, Options options = Mode::User, int timeout = 100 )
-```
-
-Depending on whether `allowSecondary` is set, this constructor may terminate
-your app if there is already a primary instance running. Additional `Options`
-can be specified to set whether the SingleApplication block should work
-user-wide or system-wide. Additionally the `Mode::SecondaryNotification` may be
-used to notify the primary instance whenever a secondary instance had been
-started (disabled by default). `timeout` specifies the maximum time in
-milliseconds to wait for blocking operations.
-
-*__Note:__ `argc` and `argv` may be changed as Qt removes arguments that it
-recognizes.*
-
-*__Note:__ `Mode::SecondaryNotification` only works if set on both the primary
-and the secondary instance.*
-
-*__Note:__ Operating system can restrict the shared memory blocks to the same
-user, in which case the User/System modes will have no effect and the block will
-be user wide.*
-
----
-
-```cpp
-bool SingleApplication::sendMessage( QByteArray message, int timeout = 100 )
-```
-
-Sends `message` to the Primary Instance. Uses `timeout` as a the maximum timeout
-in milliseconds for blocking functions
-
----
-
-```cpp
-bool SingleApplication::isPrimary()
-```
-
-Returns if the instance is the primary instance.
-
----
-
-```cpp
-bool SingleApplication::isSecondary()
-```
-Returns if the instance is a secondary instance.
-
----
-
-```cpp
-quint32 SingleApplication::instanceId()
-```
-
-Returns a unique identifier for the current instance.
-
----
-
-```cpp
-qint64 SingleApplication::primaryPid()
-```
-
-Returns the process ID (PID) of the primary instance.
-
-### Signals
-
-```cpp
-void SingleApplication::instanceStarted()
-```
-
-Triggered whenever a new instance had been started, except for secondary
-instances if the `Mode::SecondaryNotification` flag is not specified.
-
----
-
-```cpp
-void SingleApplication::receivedMessage( quint32 instanceId, QByteArray message )
-```
-
-Triggered whenever there is a message received from a secondary instance.
-
----
-
-### Flags
-
-```cpp
-enum SingleApplication::Mode
-```
-
-*   `Mode::User` - The SingleApplication block should apply user wide. This adds
-    user specific data to the key used for the shared memory and server name.
-    This is the default functionality.
-*   `Mode::System` – The SingleApplication block applies system-wide.
-*   `Mode::SecondaryNotification` – Whether to trigger `instanceStarted()` even
-    whenever secondary instances are started.
-*   `Mode::ExcludeAppPath` – Excludes the application path from the server name
-    (and memory block) hash.
-*   `Mode::ExcludeAppVersion` – Excludes the application version from the server
-    name (and memory block) hash.
-
-*__Note:__ `Mode::SecondaryNotification` only works if set on both the primary
-and the secondary instance.*
-
-*__Note:__ Operating system can restrict the shared memory blocks to the same
-user, in which case the User/System modes will have no effect and the block will
-be user wide.*
-
----
-
-Versioning
-----------
-
-Each major version introduces either very significant changes or is not
-backwards compatible with the previous version. Minor versions only add
-additional features, bug fixes or performance improvements and are backwards
-compatible with the previous release. See [`CHANGELOG.md`](CHANGELOG.md) for
-more details.
-
-Implementation
---------------
-
-The library is implemented with a QSharedMemory block which is thread safe and
-guarantees a race condition will not occur. It also uses a QLocalSocket to
-notify the main process that a new instance had been spawned and thus invoke the
-`instanceStarted()` signal and for messaging the primary instance.
-
-Additionally the library can recover from being forcefully killed on *nix
-systems and will reset the memory block given that there are no other
-instances running.
-
-License
--------
-This library and it's supporting documentation are released under
-`The MIT License (MIT)` with the exception of the Qt calculator examples which
-is distributed under the BSD license.

3rdparty/singleapplication/config.h.in

@@ -1,2 +0,0 @@
-#cmakedefine HAVE_GETEUID
-#cmakedefine HAVE_GETPWUID

3rdparty/singleapplication/singleapplication.cpp

@@ -1,184 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) Itay Grudev 2015 - 2018
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//
-//  W A R N I N G !!!
-//  -----------------
-//
-// This is a modified version of SingleApplication,
-// The original version is at:
-//
-// https://github.com/itay-grudev/SingleApplication
-//
-//
-
-#include <QtGlobal>
-#include <QCoreApplication>
-#include <QThread>
-#include <QSharedMemory>
-#include <QByteArray>
-#include <QDateTime>
-#include <QTime>
-
-#include "singleapplication.h"
-#include "singleapplication_p.h"
-
-/**
- * @brief Constructor.
- * Checks and fires up LocalServer or closes the program if another instance already exists
- * @param argc
- * @param argv
- * @param {bool} allowSecondaryInstances
- */
-SingleApplication::SingleApplication(int &argc, char *argv[], bool allowSecondary, Options options, int timeout)
-  : app_t(argc, argv), d_ptr(new SingleApplicationPrivate(this)) {
-
-  Q_D(SingleApplication);
-
-  // Store the current mode of the program
-  d->options = options;
-
-  // Generating an application ID used for identifying the shared memory block and QLocalServer
-  d->genBlockServerName();
-
-#ifdef Q_OS_UNIX
-  // By explicitly attaching it and then deleting it we make sure that the
-  // memory is deleted even after the process has crashed on Unix.
-  d->memory = new QSharedMemory(d->blockServerName);
-  d->memory->attach();
-  delete d->memory;
-#endif
-  // Guarantee thread safe behaviour with a shared memory block.
-  d->memory = new QSharedMemory(d->blockServerName);
-
-  // Create a shared memory block
-  if (d->memory->create(sizeof(InstancesInfo))) {
-    // Initialize the shared memory block
-    d->memory->lock();
-    d->initializeMemoryBlock();
-    d->memory->unlock();
-  }
-  else {
-    // Attempt to attach to the memory segment
-    if (! d->memory->attach()) {
-      qCritical() << "SingleApplication: Unable to attach to shared memory block.";
-      qCritical() << d->memory->errorString();
-      delete d;
-      ::exit(EXIT_FAILURE);
-    }
-  }
-
-  InstancesInfo* inst = static_cast<InstancesInfo*>(d->memory->data());
-  QTime time;
-  time.start();
-
-  // Make sure the shared memory block is initialised and in consistent state
-  while (true) {
-    d->memory->lock();
-
-    if (d->blockChecksum() == inst->checksum) break;
-
-    if (time.elapsed() > 5000) {
-      qWarning() << "SingleApplication: Shared memory block has been in an inconsistent state from more than 5s. Assuming primary instance failure.";
-      d->initializeMemoryBlock();
-    }
-
-    d->memory->unlock();
-
-    // Random sleep here limits the probability of a collision between two racing apps
-    qsrand(QDateTime::currentMSecsSinceEpoch() % std::numeric_limits<uint>::max());
-    QThread::sleep(8 + static_cast <unsigned long>(static_cast <float>(qrand()) / RAND_MAX * 10));
-  }
-
-  if (inst->primary == false) {
-    d->startPrimary();
-    d->memory->unlock();
-    return;
-  }
-
-  // Check if another instance can be started
-  if (allowSecondary) {
-    inst->secondary += 1;
-    inst->checksum = d->blockChecksum();
-    d->instanceNumber = inst->secondary;
-    d->startSecondary();
-    if (d->options & Mode::SecondaryNotification) {
-      d->connectToPrimary(timeout, SingleApplicationPrivate::SecondaryInstance);
-    }
-    d->memory->unlock();
-    return;
-  }
-
-  d->memory->unlock();
-
-  d->connectToPrimary(timeout, SingleApplicationPrivate::NewInstance);
-
-  delete d;
-
-  ::exit(EXIT_SUCCESS);
-
-}
-
-/**
- * @brief Destructor
- */
-SingleApplication::~SingleApplication() {
-  Q_D(SingleApplication);
-  delete d;
-}
-
-bool SingleApplication::isPrimary() {
-  Q_D(SingleApplication);
-  return d->server != nullptr;
-}
-
-bool SingleApplication::isSecondary() {
-  Q_D(SingleApplication);
-  return d->server == nullptr;
-}
-
-quint32 SingleApplication::instanceId() {
-  Q_D(SingleApplication);
-  return d->instanceNumber;
-}
-
-qint64 SingleApplication::primaryPid() {
-  Q_D(SingleApplication);
-  return d->primaryPid();
-}
-
-bool SingleApplication::sendMessage(QByteArray message, int timeout) {
-
-  Q_D(SingleApplication);
-
-  // Nobody to connect to
-  if (isPrimary()) return false;
-
-  // Make sure the socket is connected
-  d->connectToPrimary(timeout,  SingleApplicationPrivate::Reconnect);
-
-  d->socket->write(message);
-  bool dataWritten = d->socket->waitForBytesWritten(timeout);
-  d->socket->flush();
-  return dataWritten;
-
-}

3rdparty/singleapplication/singleapplication.h

@@ -1,141 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) Itay Grudev 2015 - 2018
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//
-//  W A R N I N G !!!
-//  -----------------
-//
-// This is a modified version of SingleApplication,
-// The original version is at:
-//
-// https://github.com/itay-grudev/SingleApplication
-//
-//
-
-#ifndef SINGLEAPPLICATION_H
-#define SINGLEAPPLICATION_H
-
-#include <QtGlobal>
-#include <QApplication>
-#include <QLocalSocket>
-
-class SingleApplicationPrivate;
-
-/**
- * @brief The SingleApplication class handles multipe instances of the same
- * Application
- * @see QCoreApplication
- */
-class SingleApplication : public QApplication {
-  Q_OBJECT
-
-  typedef QApplication app_t;
-
-public:
-  /**
-   * @brief Mode of operation of SingleApplication.
-   * Whether the block should be user-wide or system-wide and whether the
-   * primary instance should be notified when a secondary instance had been
-   * started.
-   * @note Operating system can restrict the shared memory blocks to the same
-   * user, in which case the User/System modes will have no effect and the
-   * block will be user wide.
-   * @enum
-   */
-  enum Mode {
-    User                   = 1 << 0,
-    System                 = 1 << 1,
-    SecondaryNotification  = 1 << 2,
-    ExcludeAppVersion      = 1 << 3,
-    ExcludeAppPath         = 1 << 4
-  };
-  Q_DECLARE_FLAGS(Options, Mode)
-
-  /**
-   * @brief Intitializes a SingleApplication instance with argc command line
-   * arguments in argv
-   * @arg {int &} argc - Number of arguments in argv
-   * @arg {const char *[]} argv - Supplied command line arguments
-   * @arg {bool} allowSecondary - Whether to start the instance as secondary
-   * if there is already a primary instance.
-   * @arg {Mode} mode - Whether for the SingleApplication block to be applied
-   * User wide or System wide.
-   * @arg {int} timeout - Timeout to wait in milliseconds.
-   * @note argc and argv may be changed as Qt removes arguments that it
-   * recognizes
-   * @note Mode::SecondaryNotification only works if set on both the primary
-   * instance and the secondary instance.
-   * @note The timeout is just a hint for the maximum time of blocking
-   * operations. It does not guarantee that the SingleApplication
-   * initialisation will be completed in given time, though is a good hint.
-   * Usually 4*timeout would be the worst case (fail) scenario.
-   * @see See the corresponding QAPPLICATION_CLASS constructor for reference
-   */
-  explicit SingleApplication( int &argc, char *argv[], bool allowSecondary = false, Options options = Mode::User, int timeout = 1000 );
-  ~SingleApplication();
-
-  /**
-   * @brief Returns if the instance is the primary instance
-   * @returns {bool}
-   */
-  bool isPrimary();
-
-  /**
-   * @brief Returns if the instance is a secondary instance
-   * @returns {bool}
-   */
-  bool isSecondary();
-
-  /**
-   * @brief Returns a unique identifier for the current instance
-   * @returns {qint32}
-   */
-  quint32 instanceId();
-
-  /**
-   * @brief Returns the process ID (PID) of the primary instance
-   * @returns {qint64}
-   */
-  qint64 primaryPid();
-
-  /**
-   * @brief Sends a message to the primary instance. Returns true on success.
-   * @param {int} timeout - Timeout for connecting
-   * @returns {bool}
-   * @note sendMessage() will return false if invoked from the primary
-   * instance.
-   */
-  bool sendMessage( QByteArray message, int timeout = 1000 );
-
- signals:
-  void instanceStarted();
-  void receivedMessage( quint32 instanceId, QByteArray message );
-
- private:
-  SingleApplicationPrivate *d_ptr;
-  Q_DECLARE_PRIVATE(SingleApplication)
-
-};
-
-Q_DECLARE_OPERATORS_FOR_FLAGS(SingleApplication::Options)
-
-#endif // SINGLEAPPLICATION_H

3rdparty/singleapplication/singleapplication_p.cpp

@@ -1,409 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) Itay Grudev 2015 - 2018
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//
-//  W A R N I N G !!!
-//  -----------------
-//
-// This is a modified version of SingleApplication,
-// The original version is at:
-//
-// https://github.com/itay-grudev/SingleApplication
-//
-//
-
-#include "config.h"
-
-#include <QtGlobal>
-
-#include <cstdlib>
-#include <cstddef>
-
-#ifdef Q_OS_UNIX
-#  include <unistd.h>
-#  include <sys/types.h>
-#  include <pwd.h>
-#endif
-
-#include <QDir>
-#include <QByteArray>
-#include <QDataStream>
-#include <QCryptographicHash>
-#include <QLocalServer>
-#include <QLocalSocket>
-
-#include "singleapplication.h"
-#include "singleapplication_p.h"
-
-#ifdef Q_OS_WIN
-#  include <windows.h>
-#  include <lmcons.h>
-#endif
-
-SingleApplicationPrivate::SingleApplicationPrivate(SingleApplication *q_ptr)
-  : q_ptr(q_ptr),
-    memory(nullptr),
-    socket(nullptr),
-    server(nullptr),
-    instanceNumber(-1)
-    {}
-
-SingleApplicationPrivate::~SingleApplicationPrivate() {
-
-  if (socket != nullptr) {
-    socket->close();
-    delete socket;
-  }
-
-  memory->lock();
-  InstancesInfo* inst = static_cast<InstancesInfo*>(memory->data());
-  if (server != nullptr) {
-    server->close();
-    delete server;
-    inst->primary = false;
-    inst->primaryPid = -1;
-    inst->checksum = blockChecksum();
-  }
-  memory->unlock();
-
-  delete memory;
-
-}
-
-void SingleApplicationPrivate::genBlockServerName() {
-
-  QCryptographicHash appData(QCryptographicHash::Sha256);
-  appData.addData("SingleApplication", 17);
-  appData.addData(SingleApplication::app_t::applicationName().toUtf8());
-  appData.addData(SingleApplication::app_t::organizationName().toUtf8());
-  appData.addData(SingleApplication::app_t::organizationDomain().toUtf8());
-
-  if (!(options & SingleApplication::Mode::ExcludeAppVersion)) {
-    appData.addData(SingleApplication::app_t::applicationVersion().toUtf8());
-  }
-
-  if (! (options & SingleApplication::Mode::ExcludeAppPath)) {
-#ifdef Q_OS_WIN
-    appData.addData(SingleApplication::app_t::applicationFilePath().toLower().toUtf8());
-#else
-    appData.addData(SingleApplication::app_t::applicationFilePath().toUtf8());
-#endif
-  }
-
-  // User level block requires a user specific data in the hash
-  if (options & SingleApplication::Mode::User) {
-#ifdef Q_OS_UNIX
-    QByteArray username;
-#if defined(HAVE_GETEUID) && defined(HAVE_GETPWUID)
-    uid_t uid = geteuid();
-    if (uid != -1) {
-      struct passwd *pw = getpwuid(uid);
-      if (pw) {
-        username = pw->pw_name;
-      }
-    }
-#endif
-    if (username.isEmpty()) username = qgetenv("USER");
-    appData.addData(username);
-#endif
-#ifdef Q_OS_WIN
-    wchar_t username [ UNLEN + 1 ];
-    // Specifies size of the buffer on input
-    DWORD usernameLength = UNLEN + 1;
-    if (GetUserNameW(username, &usernameLength)) {
-      appData.addData(QString::fromWCharArray(username).toUtf8());
-    }
-    else {
-      appData.addData(qgetenv("USERNAME"));
-    }
-#endif
-  }
-
-  // Replace the backslash in RFC 2045 Base64 [a-zA-Z0-9+/=] to comply with server naming requirements.
-  blockServerName = appData.result().toBase64().replace("/", "_");
-
-}
-
-void SingleApplicationPrivate::initializeMemoryBlock() {
-
-  InstancesInfo* inst = static_cast<InstancesInfo*>(memory->data());
-  inst->primary = false;
-  inst->secondary = 0;
-  inst->primaryPid = -1;
-  inst->checksum = blockChecksum();
-
-}
-
-void SingleApplicationPrivate::startPrimary() {
-
-  Q_Q(SingleApplication);
-
-  // Successful creation means that no main process exists
-  // So we start a QLocalServer to listen for connections
-  QLocalServer::removeServer(blockServerName);
-  server = new QLocalServer();
-
-  // Restrict access to the socket according to the
-  // SingleApplication::Mode::User flag on User level or no restrictions
-  if (options & SingleApplication::Mode::User) {
-    server->setSocketOptions(QLocalServer::UserAccessOption);
-  }
-  else {
-    server->setSocketOptions(QLocalServer::WorldAccessOption);
-  }
-
-  server->listen(blockServerName);
-  QObject::connect(server, &QLocalServer::newConnection, this, &SingleApplicationPrivate::slotConnectionEstablished);
-
-  // Reset the number of connections
-  InstancesInfo* inst = static_cast <InstancesInfo*>(memory->data());
-
-  inst->primary = true;
-  inst->primaryPid = q->applicationPid();
-  inst->checksum = blockChecksum();
-
-  instanceNumber = 0;
-
-}
-
-void SingleApplicationPrivate::startSecondary() {}
-
-void SingleApplicationPrivate::connectToPrimary(int msecs, ConnectionType connectionType) {
-
-  // Connect to the Local Server of the Primary Instance if not already connected.
-  if (socket == nullptr) {
-    socket = new QLocalSocket();
-  }
-
-  // If already connected - we are done;
-  if (socket->state() == QLocalSocket::ConnectedState)
-    return;
-
-  // If not connect
-  if (socket->state() == QLocalSocket::UnconnectedState ||
-    socket->state() == QLocalSocket::ClosingState) {
-    socket->connectToServer(blockServerName);
-  }
-
-  // Wait for being connected
-  if (socket->state() == QLocalSocket::ConnectingState) {
-    socket->waitForConnected(msecs);
-  }
-
-  // Initialisation message according to the SingleApplication protocol
-  if (socket->state() == QLocalSocket::ConnectedState) {
-    // Notify the parent that a new instance had been started;
-    QByteArray initMsg;
-    QDataStream writeStream(&initMsg, QIODevice::WriteOnly);
-
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
-    writeStream.setVersion(QDataStream::Qt_5_6);
-#endif
-
-    writeStream << blockServerName.toLatin1();
-    writeStream << static_cast<quint8>(connectionType);
-    writeStream << instanceNumber;
-    quint16 checksum = qChecksum(initMsg.constData(), static_cast<quint32>(initMsg.length()));
-    writeStream << checksum;
-
-    // The header indicates the message length that follows
-    QByteArray header;
-    QDataStream headerStream(&header, QIODevice::WriteOnly);
-
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
-    headerStream.setVersion(QDataStream::Qt_5_6);
-#endif
-    headerStream << static_cast <quint64>(initMsg.length());
-
-    socket->write(header);
-    socket->write(initMsg);
-    socket->flush();
-    socket->waitForBytesWritten(msecs);
-  }
-
-}
-
-quint16 SingleApplicationPrivate::blockChecksum() {
-
-  return qChecksum(static_cast <const char *>(memory->data()), offsetof(InstancesInfo, checksum));
-
-}
-
-qint64 SingleApplicationPrivate::primaryPid() {
-
-  qint64 pid;
-
-  memory->lock();
-  InstancesInfo* inst = static_cast<InstancesInfo*>(memory->data());
-  pid = inst->primaryPid;
-  memory->unlock();
-
-  return pid;
-
-}
-
-/**
- * @brief Executed when a connection has been made to the LocalServer
- */
-void SingleApplicationPrivate::slotConnectionEstablished() {
-
-  QLocalSocket *nextConnSocket = server->nextPendingConnection();
-  connectionMap.insert(nextConnSocket, ConnectionInfo());
-
-  QObject::connect(nextConnSocket, &QLocalSocket::aboutToClose,
-    [nextConnSocket, this]() {
-      auto &info = connectionMap[nextConnSocket];
-      Q_EMIT this->slotClientConnectionClosed(nextConnSocket, info.instanceId);
-    }
-  );
-
-  QObject::connect(nextConnSocket, &QLocalSocket::disconnected,
-    [nextConnSocket, this](){
-      connectionMap.remove(nextConnSocket);
-      nextConnSocket->deleteLater();
-    }
-  );
-
-  QObject::connect(nextConnSocket, &QLocalSocket::readyRead,
-    [nextConnSocket, this]() {
-      auto &info = connectionMap[nextConnSocket];
-      switch(info.stage) {
-      case StageHeader:
-        readInitMessageHeader(nextConnSocket);
-        break;
-      case StageBody:
-        readInitMessageBody(nextConnSocket);
-        break;
-      case StageConnected:
-        Q_EMIT this->slotDataAvailable(nextConnSocket, info.instanceId);
-        break;
-      default:
-        break;
-      };
-    }
-  );
-
-}
-
-void SingleApplicationPrivate::readInitMessageHeader(QLocalSocket *sock) {
-
-  if (!connectionMap.contains(sock)) {
-    return;
-  }
-
-  if (sock->bytesAvailable() < (qint64) sizeof(quint64)) {
-    return;
-  }
-
-  QDataStream headerStream(sock);
-
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
-  headerStream.setVersion(QDataStream::Qt_5_6);
-#endif
-
-  // Read the header to know the message length
-  quint64 msgLen = 0;
-  headerStream >> msgLen;
-  ConnectionInfo &info = connectionMap[sock];
-  info.stage = StageBody;
-  info.msgLen = msgLen;
-
-  if (sock->bytesAvailable() >= (qint64) msgLen) {
-    readInitMessageBody(sock);
-  }
-
-}
-
-void SingleApplicationPrivate::readInitMessageBody(QLocalSocket *sock) {
-
-  Q_Q(SingleApplication);
-
-  if (!connectionMap.contains(sock)) {
-    return;
-  }
-
-  ConnectionInfo &info = connectionMap[sock];
-  if (sock->bytesAvailable() < (qint64)info.msgLen) {
-    return;
-  }
-
-  // Read the message body
-  QByteArray msgBytes = sock->read(info.msgLen);
-  QDataStream readStream(msgBytes);
-
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
-  readStream.setVersion(QDataStream::Qt_5_6);
-#endif
-
-  // server name
-  QByteArray latin1Name;
-  readStream >> latin1Name;
-
-  // connection type
-  ConnectionType connectionType = InvalidConnection;
-  quint8 connTypeVal = InvalidConnection;
-  readStream >> connTypeVal;
-  connectionType = static_cast <ConnectionType>(connTypeVal);
-
-  // instance id
-  quint32 instanceId = 0;
-  readStream >> instanceId;
-
-  // checksum
-  quint16 msgChecksum = 0;
-  readStream >> msgChecksum;
-
-  const quint16 actualChecksum = qChecksum(msgBytes.constData(), static_cast<quint32>(msgBytes.length() - sizeof(quint16)));
-
-  bool isValid = readStream.status() == QDataStream::Ok && QLatin1String(latin1Name) == blockServerName && msgChecksum == actualChecksum;
-
-  if (!isValid) {
-    sock->close();
-    return;
-  }
-
-  info.instanceId = instanceId;
-  info.stage = StageConnected;
-
-  if (connectionType == NewInstance || (connectionType == SecondaryInstance && options & SingleApplication::Mode::SecondaryNotification)) {
-    Q_EMIT q->instanceStarted();
-  }
-
-  if (sock->bytesAvailable() > 0) {
-    Q_EMIT this->slotDataAvailable(sock, instanceId);
-  }
-
-}
-
-void SingleApplicationPrivate::slotDataAvailable(QLocalSocket *dataSocket, quint32 instanceId) {
-
-  Q_Q(SingleApplication);
-  Q_EMIT q->receivedMessage(instanceId, dataSocket->readAll());
-
-}
-
-void SingleApplicationPrivate::slotClientConnectionClosed(QLocalSocket *closedSocket, quint32 instanceId) {
-
-  if (closedSocket->bytesAvailable() > 0)
-    Q_EMIT slotDataAvailable(closedSocket, instanceId);
-
-}

3rdparty/singleapplication/singleapplication_p.h

@@ -1,103 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) Itay Grudev 2015 - 2016
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//
-//  W A R N I N G !!!
-//  -----------------
-//
-// This is a modified version of SingleApplication,
-// The original version is at:
-//
-// https://github.com/itay-grudev/SingleApplication
-//
-//
-
-#ifndef SINGLEAPPLICATION_P_H
-#define SINGLEAPPLICATION_P_H
-
-#include <QtGlobal>
-#include <QLocalSocket>
-#include <QLocalServer>
-#include <QSharedMemory>
-#include <QMap>
-
-#include "singleapplication.h"
-
-struct InstancesInfo {
-  bool primary;
-  quint32 secondary;
-  qint64 primaryPid;
-  quint16 checksum;
-};
-
-struct ConnectionInfo {
-  explicit ConnectionInfo() : msgLen(0), instanceId(0), stage(0) {}
-  qint64 msgLen;
-  quint32 instanceId;
-  quint8 stage;
-};
-
-class SingleApplicationPrivate : public QObject {
-  Q_OBJECT
- public:
-  enum ConnectionType : quint8 {
-    InvalidConnection = 0,
-    NewInstance = 1,
-    SecondaryInstance = 2,
-    Reconnect = 3
-  };
-  enum ConnectionStage : quint8 {
-    StageHeader = 0,
-    StageBody = 1,
-    StageConnected = 2,
-  };
-  Q_DECLARE_PUBLIC(SingleApplication)
-
-  SingleApplicationPrivate( SingleApplication *q_ptr );
-  ~SingleApplicationPrivate();
-
-  void genBlockServerName();
-  void initializeMemoryBlock();
-  void startPrimary();
-  void startSecondary();
-  void connectToPrimary(int msecs, ConnectionType connectionType );
-  quint16 blockChecksum();
-  qint64 primaryPid();
-  void readInitMessageHeader(QLocalSocket *socket);
-  void readInitMessageBody(QLocalSocket *socket);
-
-  SingleApplication *q_ptr;
-  QSharedMemory *memory;
-  QLocalSocket *socket;
-  QLocalServer *server;
-  quint32 instanceNumber;
-  QString blockServerName;
-  SingleApplication::Options options;
-  QMap<QLocalSocket*, ConnectionInfo> connectionMap;
-
- public slots:
-  void slotConnectionEstablished();
-  void slotDataAvailable(QLocalSocket*, quint32);
-  void slotClientConnectionClosed(QLocalSocket*, quint32);
-};
-
-#endif  // SINGLEAPPLICATION_P_H

3rdparty/singleapplication/singlecoreapplication.cpp

@@ -1,185 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) Itay Grudev 2015 - 2018
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//
-//  W A R N I N G !!!
-//  -----------------
-//
-// This is a modified version of SingleApplication,
-// The original version is at:
-//
-// https://github.com/itay-grudev/SingleApplication
-//
-//
-
-#include <QtGlobal>
-#include <QCoreApplication>
-#include <QThread>
-#include <QSharedMemory>
-#include <QByteArray>
-#include <QDateTime>
-#include <QTime>
-
-#include "singlecoreapplication.h"
-#include "singlecoreapplication_p.h"
-
-/**
- * @brief Constructor. Checks and fires up LocalServer or closes the program
- * if another instance already exists
- * @param argc
- * @param argv
- * @param {bool} allowSecondaryInstances
- */
-SingleCoreApplication::SingleCoreApplication(int &argc, char *argv[], bool allowSecondary, Options options, int timeout)
-  : app_t(argc, argv), d_ptr(new SingleCoreApplicationPrivate(this)) {
-
-  Q_D(SingleCoreApplication);
-
-  // Store the current mode of the program
-  d->options = options;
-
-  // Generating an application ID used for identifying the shared memory
-  // block and QLocalServer
-  d->genBlockServerName();
-
-#ifdef Q_OS_UNIX
-  // By explicitly attaching it and then deleting it we make sure that the
-  // memory is deleted even after the process has crashed on Unix.
-  d->memory = new QSharedMemory(d->blockServerName);
-  d->memory->attach();
-  delete d->memory;
-#endif
-  // Guarantee thread safe behaviour with a shared memory block.
-  d->memory = new QSharedMemory(d->blockServerName);
-
-  // Create a shared memory block
-  if (d->memory->create(sizeof(InstancesInfo))) {
-    // Initialize the shared memory block
-    d->memory->lock();
-    d->initializeMemoryBlock();
-    d->memory->unlock();
-  }
-  else {
-    // Attempt to attach to the memory segment
-    if (!d->memory->attach()) {
-      qCritical() << "SingleCoreApplication: Unable to attach to shared memory block.";
-      qCritical() << d->memory->errorString();
-      delete d;
-      ::exit(EXIT_FAILURE);
-    }
-  }
-
-  InstancesInfo* inst = static_cast<InstancesInfo*>(d->memory->data());
-  QTime time;
-  time.start();
-
-  // Make sure the shared memory block is initialised and in consistent state
-  while (true) {
-    d->memory->lock();
-
-    if(d->blockChecksum() == inst->checksum) break;
-
-    if (time.elapsed() > 5000) {
-      qWarning() << "SingleCoreApplication: Shared memory block has been in an inconsistent state from more than 5s. Assuming primary instance failure.";
-      d->initializeMemoryBlock();
-    }
-
-    d->memory->unlock();
-
-    // Random sleep here limits the probability of a collision between two racing apps
-    qsrand(QDateTime::currentMSecsSinceEpoch() % std::numeric_limits<uint>::max());
-    QThread::sleep(8 + static_cast <unsigned long>(static_cast <float>(qrand()) / RAND_MAX * 10));
-  }
-
-  if (inst->primary == false) {
-    d->startPrimary();
-    d->memory->unlock();
-    return;
-  }
-
-  // Check if another instance can be started
-  if (allowSecondary) {
-    inst->secondary += 1;
-    inst->checksum = d->blockChecksum();
-    d->instanceNumber = inst->secondary;
-    d->startSecondary();
-    if(d->options & Mode::SecondaryNotification) {
-      d->connectToPrimary(timeout, SingleCoreApplicationPrivate::SecondaryInstance);
-    }
-    d->memory->unlock();
-    return;
-  }
-
-  d->memory->unlock();
-
-  d->connectToPrimary(timeout, SingleCoreApplicationPrivate::NewInstance);
-
-  delete d;
-
-  ::exit(EXIT_SUCCESS);
-
-}
-
-/**
- * @brief Destructor
- */
-SingleCoreApplication::~SingleCoreApplication() {
-  Q_D(SingleCoreApplication);
-  delete d;
-}
-
-bool SingleCoreApplication::isPrimary() {
-  Q_D(SingleCoreApplication);
-  return d->server != nullptr;
-}
-
-bool SingleCoreApplication::isSecondary() {
-  Q_D(SingleCoreApplication);
-  return d->server == nullptr;
-}
-
-quint32 SingleCoreApplication::instanceId() {
-  Q_D(SingleCoreApplication);
-  return d->instanceNumber;
-}
-
-qint64 SingleCoreApplication::primaryPid() {
-  Q_D(SingleCoreApplication);
-  return d->primaryPid();
-}
-
-bool SingleCoreApplication::sendMessage(QByteArray message, int timeout) {
-
-  Q_D(SingleCoreApplication);
-
-  // Nobody to connect to
-  if(isPrimary()) return false;
-
-  // Make sure the socket is connected
-  d->connectToPrimary(timeout,  SingleCoreApplicationPrivate::Reconnect);
-
-  d->socket->write(message);
-  bool dataWritten = d->socket->waitForBytesWritten(timeout);
-  d->socket->flush();
-  return dataWritten;
-
-}

3rdparty/singleapplication/singlecoreapplication.h

@@ -1,140 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) Itay Grudev 2015 - 2018
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//
-//  W A R N I N G !!!
-//  -----------------
-//
-// This is a modified version of SingleApplication,
-// The original version is at:
-//
-// https://github.com/itay-grudev/SingleApplication
-//
-//
-
-#ifndef SINGLECOREAPPLICATION_H
-#define SINGLECOREAPPLICATION_H
-
-#include <QtGlobal>
-#include <QCoreApplication>
-#include <QLocalSocket>
-
-class SingleCoreApplicationPrivate;
-
-/**
- * @brief The SingleCoreApplication class handles multiple instances of the same
- * Application
- * @see QCoreApplication
- */
-class SingleCoreApplication : public QCoreApplication {
-  Q_OBJECT
-
-  typedef QCoreApplication app_t;
-
-public:
-  /**
-   * @brief Mode of operation of SingleCoreApplication.
-   * Whether the block should be user-wide or system-wide and whether the
-   * primary instance should be notified when a secondary instance had been
-   * started.
-   * @note Operating system can restrict the shared memory blocks to the same
-   * user, in which case the User/System modes will have no effect and the
-   * block will be user wide.
-   * @enum
-   */
-  enum Mode {
-    User                   = 1 << 0,
-    System                 = 1 << 1,
-    SecondaryNotification  = 1 << 2,
-    ExcludeAppVersion      = 1 << 3,
-    ExcludeAppPath         = 1 << 4
-  };
-  Q_DECLARE_FLAGS(Options, Mode)
-
-  /**
-   * @brief Intitializes a SingleCoreApplication instance with argc command line
-   * arguments in argv
-   * @arg {int &} argc - Number of arguments in argv
-   * @arg {const char *[]} argv - Supplied command line arguments
-   * @arg {bool} allowSecondary - Whether to start the instance as secondary
-   * if there is already a primary instance.
-   * @arg {Mode} mode - Whether for the SingleCoreApplication block to be applied
-   * User wide or System wide.
-   * @arg {int} timeout - Timeout to wait in milliseconds.
-   * @note argc and argv may be changed as Qt removes arguments that it
-   * recognizes
-   * @note Mode::SecondaryNotification only works if set on both the primary
-   * instance and the secondary instance.
-   * @note The timeout is just a hint for the maximum time of blocking
-   * operations. It does not guarantee that the SingleCoreApplication
-   * initialisation will be completed in given time, though is a good hint.
-   * Usually 4*timeout would be the worst case (fail) scenario.
-   * @see See the corresponding QAPPLICATION_CLASS constructor for reference
-   */
-  explicit SingleCoreApplication( int &argc, char *argv[], bool allowSecondary = false, Options options = Mode::User, int timeout = 1000 );
-  ~SingleCoreApplication();
-
-  /**
-   * @brief Returns if the instance is the primary instance
-   * @returns {bool}
-   */
-  bool isPrimary();
-
-  /**
-   * @brief Returns if the instance is a secondary instance
-   * @returns {bool}
-   */
-  bool isSecondary();
-
-  /**
-   * @brief Returns a unique identifier for the current instance
-   * @returns {qint32}
-   */
-  quint32 instanceId();
-
-  /**
-   * @brief Returns the process ID (PID) of the primary instance
-   * @returns {qint64}
-   */
-  qint64 primaryPid();
-
-  /**
-   * @brief Sends a message to the primary instance. Returns true on success.
-   * @param {int} timeout - Timeout for connecting
-   * @returns {bool}
-   * @note sendMessage() will return false if invoked from the primary
-   * instance.
-   */
-  bool sendMessage( QByteArray message, int timeout = 1000 );
-
- signals:
-  void instanceStarted();
-  void receivedMessage( quint32 instanceId, QByteArray message );
-
-private:
-  SingleCoreApplicationPrivate *d_ptr;
-  Q_DECLARE_PRIVATE(SingleCoreApplication)
-};
-
-Q_DECLARE_OPERATORS_FOR_FLAGS(SingleCoreApplication::Options)
-
-#endif // SINGLECOREAPPLICATION_H

3rdparty/singleapplication/singlecoreapplication_p.cpp

@@ -1,409 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) Itay Grudev 2015 - 2018
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//
-//  W A R N I N G !!!
-//  -----------------
-//
-// This is a modified version of SingleApplication,
-// The original version is at:
-//
-// https://github.com/itay-grudev/SingleApplication
-//
-//
-
-#include "config.h"
-
-#include <QtGlobal>
-
-#include <cstdlib>
-#include <cstddef>
-
-#ifdef Q_OS_UNIX
-#  include <unistd.h>
-#  include <sys/types.h>
-#  include <pwd.h>
-#endif
-
-#include <QDir>
-#include <QByteArray>
-#include <QDataStream>
-#include <QCryptographicHash>
-#include <QLocalServer>
-#include <QLocalSocket>
-
-#include "singlecoreapplication.h"
-#include "singlecoreapplication_p.h"
-
-#ifdef Q_OS_WIN
-#  include <windows.h>
-#  include <lmcons.h>
-#endif
-
-SingleCoreApplicationPrivate::SingleCoreApplicationPrivate(SingleCoreApplication *q_ptr)
-  : q_ptr(q_ptr),
-    memory(nullptr),
-    socket(nullptr),
-    server(nullptr),
-    instanceNumber(-1)
-    {}
-
-SingleCoreApplicationPrivate::~SingleCoreApplicationPrivate() {
-
-  if (socket != nullptr) {
-    socket->close();
-    delete socket;
-  }
-
-  memory->lock();
-  InstancesInfo* inst = static_cast<InstancesInfo*>(memory->data());
-  if (server != nullptr) {
-    server->close();
-    delete server;
-    inst->primary = false;
-    inst->primaryPid = -1;
-    inst->checksum = blockChecksum();
-  }
-  memory->unlock();
-
-  delete memory;
-
-}
-
-void SingleCoreApplicationPrivate::genBlockServerName() {
-
-  QCryptographicHash appData(QCryptographicHash::Sha256);
-  appData.addData("SingleApplication", 17);
-  appData.addData(SingleCoreApplication::app_t::applicationName().toUtf8());
-  appData.addData(SingleCoreApplication::app_t::organizationName().toUtf8());
-  appData.addData(SingleCoreApplication::app_t::organizationDomain().toUtf8());
-
-  if (!(options & SingleCoreApplication::Mode::ExcludeAppVersion)) {
-    appData.addData(SingleCoreApplication::app_t::applicationVersion().toUtf8());
-  }
-
-  if (!(options & SingleCoreApplication::Mode::ExcludeAppPath)) {
-#ifdef Q_OS_WIN
-    appData.addData(SingleCoreApplication::app_t::applicationFilePath().toLower().toUtf8());
-#else
-    appData.addData(SingleCoreApplication::app_t::applicationFilePath().toUtf8());
-#endif
-  }
-
-  // User level block requires a user specific data in the hash
-  if (options & SingleCoreApplication::Mode::User) {
-#ifdef Q_OS_UNIX
-    QByteArray username;
-#if defined(HAVE_GETEUID) && defined(HAVE_GETPWUID)
-    uid_t uid = geteuid();
-    if (uid != -1) {
-      struct passwd *pw = getpwuid(uid);
-      if (pw) {
-        username = pw->pw_name;
-      }
-    }
-#endif
-    if (username.isEmpty()) username = qgetenv("USER");
-    appData.addData(username);
-#endif
-#ifdef Q_OS_WIN
-    wchar_t username [ UNLEN + 1 ];
-    // Specifies size of the buffer on input
-    DWORD usernameLength = UNLEN + 1;
-    if (GetUserNameW(username, &usernameLength)) {
-      appData.addData(QString::fromWCharArray(username).toUtf8());
-    }
-    else {
-      appData.addData(qgetenv("USERNAME"));
-    }
-#endif
-  }
-
-  // Replace the backslash in RFC 2045 Base64 [a-zA-Z0-9+/=] to comply with server naming requirements.
-  blockServerName = appData.result().toBase64().replace("/", "_");
-
-}
-
-void SingleCoreApplicationPrivate::initializeMemoryBlock() {
-
-  InstancesInfo* inst = static_cast<InstancesInfo*>(memory->data());
-  inst->primary = false;
-  inst->secondary = 0;
-  inst->primaryPid = -1;
-  inst->checksum = blockChecksum();
-
-}
-
-void SingleCoreApplicationPrivate::startPrimary() {
-
-  Q_Q(SingleCoreApplication);
-
-  // Successful creation means that no main process exists
-  // So we start a QLocalServer to listen for connections
-  QLocalServer::removeServer(blockServerName);
-  server = new QLocalServer();
-
-  // Restrict access to the socket according to the
-  // SingleCoreApplication::Mode::User flag on User level or no restrictions
-  if (options & SingleCoreApplication::Mode::User) {
-    server->setSocketOptions(QLocalServer::UserAccessOption);
-  }
-  else {
-    server->setSocketOptions(QLocalServer::WorldAccessOption);
-  }
-
-  server->listen(blockServerName);
-  QObject::connect(server, &QLocalServer::newConnection, this, &SingleCoreApplicationPrivate::slotConnectionEstablished);
-
-  // Reset the number of connections
-  InstancesInfo* inst = static_cast <InstancesInfo*>(memory->data());
-
-  inst->primary = true;
-  inst->primaryPid = q->applicationPid();
-  inst->checksum = blockChecksum();
-
-  instanceNumber = 0;
-
-}
-
-void SingleCoreApplicationPrivate::startSecondary() {}
-
-void SingleCoreApplicationPrivate::connectToPrimary(int msecs, ConnectionType connectionType) {
-
-  // Connect to the Local Server of the Primary Instance if not already connected.
-  if (socket == nullptr) {
-    socket = new QLocalSocket();
-  }
-
-  // If already connected - we are done;
-  if (socket->state() == QLocalSocket::ConnectedState)
-    return;
-
-  // If not connect
-  if (socket->state() == QLocalSocket::UnconnectedState ||
-    socket->state() == QLocalSocket::ClosingState) {
-    socket->connectToServer(blockServerName);
-  }
-
-  // Wait for being connected
-  if (socket->state() == QLocalSocket::ConnectingState) {
-    socket->waitForConnected(msecs);
-  }
-
-  // Initialisation message according to the SingleCoreApplication protocol
-  if (socket->state() == QLocalSocket::ConnectedState) {
-    // Notify the parent that a new instance had been started;
-    QByteArray initMsg;
-    QDataStream writeStream(&initMsg, QIODevice::WriteOnly);
-
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
-    writeStream.setVersion(QDataStream::Qt_5_6);
-#endif
-
-    writeStream << blockServerName.toLatin1();
-    writeStream << static_cast<quint8>(connectionType);
-    writeStream << instanceNumber;
-    quint16 checksum = qChecksum(initMsg.constData(), static_cast<quint32>(initMsg.length()));
-    writeStream << checksum;
-
-    // The header indicates the message length that follows
-    QByteArray header;
-    QDataStream headerStream(&header, QIODevice::WriteOnly);
-
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
-    headerStream.setVersion(QDataStream::Qt_5_6);
-#endif
-    headerStream << static_cast <quint64>(initMsg.length());
-
-    socket->write(header);
-    socket->write(initMsg);
-    socket->flush();
-    socket->waitForBytesWritten(msecs);
-  }
-
-}
-
-quint16 SingleCoreApplicationPrivate::blockChecksum() {
-
-  return qChecksum(static_cast <const char*> (memory->data()), offsetof(InstancesInfo, checksum));
-
-}
-
-qint64 SingleCoreApplicationPrivate::primaryPid() {
-
-  qint64 pid;
-
-  memory->lock();
-  InstancesInfo* inst = static_cast<InstancesInfo*>(memory->data());
-  pid = inst->primaryPid;
-  memory->unlock();
-
-  return pid;
-
-}
-
-/**
- * @brief Executed when a connection has been made to the LocalServer
- */
-void SingleCoreApplicationPrivate::slotConnectionEstablished() {
-
-  QLocalSocket *nextConnSocket = server->nextPendingConnection();
-  connectionMap.insert(nextConnSocket, ConnectionInfo());
-
-  QObject::connect(nextConnSocket, &QLocalSocket::aboutToClose,
-    [nextConnSocket, this]() {
-      auto &info = connectionMap[nextConnSocket];
-      Q_EMIT this->slotClientConnectionClosed(nextConnSocket, info.instanceId);
-    }
-  );
-
-  QObject::connect(nextConnSocket, &QLocalSocket::disconnected,
-    [nextConnSocket, this](){
-      connectionMap.remove(nextConnSocket);
-      nextConnSocket->deleteLater();
-    }
-  );
-
-  QObject::connect(nextConnSocket, &QLocalSocket::readyRead,
-    [nextConnSocket, this]() {
-      auto &info = connectionMap[nextConnSocket];
-      switch(info.stage) {
-      case StageHeader:
-        readInitMessageHeader(nextConnSocket);
-        break;
-      case StageBody:
-        readInitMessageBody(nextConnSocket);
-        break;
-      case StageConnected:
-        Q_EMIT this->slotDataAvailable(nextConnSocket, info.instanceId);
-        break;
-      default:
-        break;
-      };
-    }
-  );
-
-}
-
-void SingleCoreApplicationPrivate::readInitMessageHeader(QLocalSocket *sock) {
-
-  if (!connectionMap.contains(sock)) {
-    return;
-  }
-
-  if (sock->bytesAvailable() < (qint64)sizeof(quint64)) {
-    return;
-  }
-
-  QDataStream headerStream(sock);
-
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
-  headerStream.setVersion(QDataStream::Qt_5_6);
-#endif
-
-  // Read the header to know the message length
-  quint64 msgLen = 0;
-  headerStream >> msgLen;
-  ConnectionInfo &info = connectionMap[sock];
-  info.stage = StageBody;
-  info.msgLen = msgLen;
-
-  if (sock->bytesAvailable() >= (qint64) msgLen) {
-    readInitMessageBody(sock);
-  }
-
-}
-
-void SingleCoreApplicationPrivate::readInitMessageBody(QLocalSocket *sock) {
-
-  Q_Q(SingleCoreApplication);
-
-  if (!connectionMap.contains(sock)) {
-    return;
-  }
-
-  ConnectionInfo &info = connectionMap[sock];
-  if (sock->bytesAvailable() < (qint64)info.msgLen) {
-    return;
-  }
-
-  // Read the message body
-  QByteArray msgBytes = sock->read(info.msgLen);
-  QDataStream readStream(msgBytes);
-
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
-  readStream.setVersion(QDataStream::Qt_5_6);
-#endif
-
-  // server name
-  QByteArray latin1Name;
-  readStream >> latin1Name;
-
-  // connection type
-  ConnectionType connectionType = InvalidConnection;
-  quint8 connTypeVal = InvalidConnection;
-  readStream >> connTypeVal;
-  connectionType = static_cast <ConnectionType>(connTypeVal);
-
-  // instance id
-  quint32 instanceId = 0;
-  readStream >> instanceId;
-
-  // checksum
-  quint16 msgChecksum = 0;
-  readStream >> msgChecksum;
-
-  const quint16 actualChecksum = qChecksum(msgBytes.constData(), static_cast<quint32>(msgBytes.length() - sizeof(quint16)));
-
-  bool isValid = readStream.status() == QDataStream::Ok && QLatin1String(latin1Name) == blockServerName && msgChecksum == actualChecksum;
-
-  if (!isValid) {
-    sock->close();
-    return;
-  }
-
-  info.instanceId = instanceId;
-  info.stage = StageConnected;
-
-  if (connectionType == NewInstance || (connectionType == SecondaryInstance && options & SingleCoreApplication::Mode::SecondaryNotification)) {
-    Q_EMIT q->instanceStarted();
-  }
-
-  if (sock->bytesAvailable() > 0) {
-    Q_EMIT this->slotDataAvailable(sock, instanceId);
-  }
-
-}
-
-void SingleCoreApplicationPrivate::slotDataAvailable(QLocalSocket *dataSocket, quint32 instanceId) {
-
-  Q_Q(SingleCoreApplication);
-  Q_EMIT q->receivedMessage(instanceId, dataSocket->readAll());
-
-}
-
-void SingleCoreApplicationPrivate::slotClientConnectionClosed(QLocalSocket *closedSocket, quint32 instanceId) {
-
-  if (closedSocket->bytesAvailable() > 0)
-    Q_EMIT slotDataAvailable(closedSocket, instanceId);
-
-}

3rdparty/singleapplication/singlecoreapplication_p.h

@@ -1,103 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) Itay Grudev 2015 - 2016
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//
-//  W A R N I N G !!!
-//  -----------------
-//
-// This is a modified version of SingleApplication,
-// The original version is at:
-//
-// https://github.com/itay-grudev/SingleApplication
-//
-//
-
-#ifndef SINGLECOREAPPLICATION_P_H
-#define SINGLECOREAPPLICATION_P_H
-
-#include <QtGlobal>
-#include <QLocalSocket>
-#include <QLocalServer>
-#include <QSharedMemory>
-#include <QMap>
-
-#include "singlecoreapplication.h"
-
-struct InstancesInfo {
-  bool primary;
-  quint32 secondary;
-  qint64 primaryPid;
-  quint16 checksum;
-};
-
-struct ConnectionInfo {
-  explicit ConnectionInfo() : msgLen(0), instanceId(0), stage(0) {}
-  qint64 msgLen;
-  quint32 instanceId;
-  quint8 stage;
-};
-
-class SingleCoreApplicationPrivate : public QObject {
-  Q_OBJECT
- public:
-  enum ConnectionType : quint8 {
-    InvalidConnection = 0,
-    NewInstance = 1,
-    SecondaryInstance = 2,
-    Reconnect = 3
-  };
-  enum ConnectionStage : quint8 {
-    StageHeader = 0,
-    StageBody = 1,
-    StageConnected = 2,
-  };
-  Q_DECLARE_PUBLIC(SingleCoreApplication)
-
-  SingleCoreApplicationPrivate( SingleCoreApplication *q_ptr );
-  ~SingleCoreApplicationPrivate();
-
-  void genBlockServerName();
-  void initializeMemoryBlock();
-  void startPrimary();
-  void startSecondary();
-  void connectToPrimary(int msecs, ConnectionType connectionType );
-  quint16 blockChecksum();
-  qint64 primaryPid();
-  void readInitMessageHeader(QLocalSocket *socket);
-  void readInitMessageBody(QLocalSocket *socket);
-
-  SingleCoreApplication *q_ptr;
-  QSharedMemory *memory;
-  QLocalSocket *socket;
-  QLocalServer *server;
-  quint32 instanceNumber;
-  QString blockServerName;
-  SingleCoreApplication::Options options;
-  QMap<QLocalSocket*, ConnectionInfo> connectionMap;
-
- public slots:
-  void slotConnectionEstablished();
-  void slotDataAvailable(QLocalSocket*, quint32);
-  void slotClientConnectionClosed(QLocalSocket*, quint32);
-};
-
-#endif  // SINGLECOREAPPLICATION_P_H

3rdparty/taglib/CMakeLists.txt

@@ -1,406 +0,0 @@
-cmake_minimum_required(VERSION 2.8.11)
-
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
-set(CMAKE_CXX_STANDARD 11)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --std=c++11 -U__STRICT_ANSI__ -fpermissive -Wall -Woverloaded-virtual -Wno-sign-compare -Wno-delete-non-virtual-dtor")
-
-set(TAGLIB_SOVERSION_CURRENT  17)
-set(TAGLIB_SOVERSION_REVISION 0)
-set(TAGLIB_SOVERSION_AGE      16)
-
-math(EXPR TAGLIB_SOVERSION_MAJOR "${TAGLIB_SOVERSION_CURRENT} - ${TAGLIB_SOVERSION_AGE}")
-math(EXPR TAGLIB_SOVERSION_MINOR "${TAGLIB_SOVERSION_AGE}")
-math(EXPR TAGLIB_SOVERSION_PATCH "${TAGLIB_SOVERSION_REVISION}")
-
-include(TestBigEndian)
-test_big_endian(IS_BIG_ENDIAN)
-
-if(NOT IS_BIG_ENDIAN)
-  add_definitions(-DSYSTEM_BYTEORDER=1)
-else()
-  add_definitions(-DSYSTEM_BYTEORDER=2)
-endif()
-
-include(ConfigureChecks.cmake)
-configure_file(config.h.cmake "${CMAKE_CURRENT_BINARY_DIR}/config.h")
-configure_file(taglib_config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/taglib_config.h)
-
-add_definitions(-DHAVE_CONFIG_H)
-add_definitions(-DTAGLIB_STATIC)
-
-set(CMAKE_INCLUDE_CURRENT_DIR ON)
-include_directories(
-  ${CMAKE_CURRENT_SOURCE_DIR}/toolkit
-  ${CMAKE_CURRENT_SOURCE_DIR}/asf
-  ${CMAKE_CURRENT_SOURCE_DIR}/mpeg
-  ${CMAKE_CURRENT_SOURCE_DIR}/ogg
-  ${CMAKE_CURRENT_SOURCE_DIR}/ogg/flac
-  ${CMAKE_CURRENT_SOURCE_DIR}/flac
-  ${CMAKE_CURRENT_SOURCE_DIR}/mpc
-  ${CMAKE_CURRENT_SOURCE_DIR}/mp4
-  ${CMAKE_CURRENT_SOURCE_DIR}/ogg/vorbis
-  ${CMAKE_CURRENT_SOURCE_DIR}/ogg/speex
-  ${CMAKE_CURRENT_SOURCE_DIR}/ogg/opus
-  ${CMAKE_CURRENT_SOURCE_DIR}/mpeg/id3v2
-  ${CMAKE_CURRENT_SOURCE_DIR}/mpeg/id3v2/frames
-  ${CMAKE_CURRENT_SOURCE_DIR}/mpeg/id3v1
-  ${CMAKE_CURRENT_SOURCE_DIR}/ape
-  ${CMAKE_CURRENT_SOURCE_DIR}/wavpack
-  ${CMAKE_CURRENT_SOURCE_DIR}/trueaudio
-  ${CMAKE_CURRENT_SOURCE_DIR}/riff
-  ${CMAKE_CURRENT_SOURCE_DIR}/riff/aiff
-  ${CMAKE_CURRENT_SOURCE_DIR}/riff/wav
-  ${CMAKE_CURRENT_SOURCE_DIR}/mod
-  ${CMAKE_CURRENT_SOURCE_DIR}/s3m
-  ${CMAKE_CURRENT_SOURCE_DIR}/it
-  ${CMAKE_CURRENT_SOURCE_DIR}/xm
-  ${CMAKE_CURRENT_SOURCE_DIR}/dsf
-  ${CMAKE_CURRENT_SOURCE_DIR}/dsdiff
-  ${CMAKE_SOURCE_DIR}/3rdparty
-)
-
-if(ZLIB_FOUND)
-  include_directories(${ZLIB_INCLUDE_DIR})
-elseif(HAVE_ZLIB_SOURCE)
-  include_directories(${ZLIB_SOURCE})
-endif()
-
-set(tag_HDRS
-  tag.h
-  fileref.h
-  audioproperties.h
-  taglib_export.h
-  ${CMAKE_CURRENT_BINARY_DIR}/taglib_config.h
-  toolkit/taglib.h
-  toolkit/tstring.h
-  toolkit/tlist.h
-  toolkit/tlist.tcc
-  toolkit/tstringlist.h
-  toolkit/tbytevector.h
-  toolkit/tbytevectorlist.h
-  toolkit/tbytevectorstream.h
-  toolkit/tiostream.h
-  toolkit/tfile.h
-  toolkit/tfilestream.h
-  toolkit/tmap.h
-  toolkit/tmap.tcc
-  toolkit/tpropertymap.h
-  toolkit/trefcounter.h
-  toolkit/tdebuglistener.h
-  mpeg/mpegfile.h
-  mpeg/mpegproperties.h
-  mpeg/mpegheader.h
-  mpeg/xingheader.h
-  mpeg/id3v1/id3v1tag.h
-  mpeg/id3v1/id3v1genres.h
-  mpeg/id3v2/id3v2.h
-  mpeg/id3v2/id3v2extendedheader.h
-  mpeg/id3v2/id3v2frame.h
-  mpeg/id3v2/id3v2header.h
-  mpeg/id3v2/id3v2synchdata.h
-  mpeg/id3v2/id3v2footer.h
-  mpeg/id3v2/id3v2framefactory.h
-  mpeg/id3v2/id3v2tag.h
-  mpeg/id3v2/frames/attachedpictureframe.h
-  mpeg/id3v2/frames/commentsframe.h
-  mpeg/id3v2/frames/eventtimingcodesframe.h
-  mpeg/id3v2/frames/generalencapsulatedobjectframe.h
-  mpeg/id3v2/frames/ownershipframe.h
-  mpeg/id3v2/frames/popularimeterframe.h
-  mpeg/id3v2/frames/privateframe.h
-  mpeg/id3v2/frames/relativevolumeframe.h
-  mpeg/id3v2/frames/synchronizedlyricsframe.h
-  mpeg/id3v2/frames/textidentificationframe.h
-  mpeg/id3v2/frames/uniquefileidentifierframe.h
-  mpeg/id3v2/frames/unknownframe.h
-  mpeg/id3v2/frames/unsynchronizedlyricsframe.h
-  mpeg/id3v2/frames/urllinkframe.h
-  mpeg/id3v2/frames/chapterframe.h
-  mpeg/id3v2/frames/tableofcontentsframe.h
-  mpeg/id3v2/frames/podcastframe.h
-  ogg/oggfile.h
-  ogg/oggpage.h
-  ogg/oggpageheader.h
-  ogg/xiphcomment.h
-  ogg/vorbis/vorbisfile.h
-  ogg/vorbis/vorbisproperties.h
-  ogg/flac/oggflacfile.h
-  ogg/speex/speexfile.h
-  ogg/speex/speexproperties.h
-  ogg/opus/opusfile.h
-  ogg/opus/opusproperties.h
-  flac/flacfile.h
-  flac/flacpicture.h
-  flac/flacproperties.h
-  flac/flacmetadatablock.h
-  ape/apefile.h
-  ape/apeproperties.h
-  ape/apetag.h
-  ape/apefooter.h
-  ape/apeitem.h
-  mpc/mpcfile.h
-  mpc/mpcproperties.h
-  wavpack/wavpackfile.h
-  wavpack/wavpackproperties.h
-  trueaudio/trueaudiofile.h
-  trueaudio/trueaudioproperties.h
-  riff/rifffile.h
-  riff/aiff/aifffile.h
-  riff/aiff/aiffproperties.h
-  riff/wav/wavfile.h
-  riff/wav/wavproperties.h
-  riff/wav/infotag.h
-  asf/asffile.h
-  asf/asfproperties.h
-  asf/asftag.h
-  asf/asfattribute.h
-  asf/asfpicture.h
-  mp4/mp4file.h
-  mp4/mp4atom.h
-  mp4/mp4tag.h
-  mp4/mp4item.h
-  mp4/mp4properties.h
-  mp4/mp4coverart.h
-  mod/modfilebase.h
-  mod/modfile.h
-  mod/modtag.h
-  mod/modproperties.h
-  it/itfile.h
-  it/itproperties.h
-  s3m/s3mfile.h
-  s3m/s3mproperties.h
-  xm/xmfile.h
-  xm/xmproperties.h
-  dsf/dsffile.h
-  dsf/dsfproperties.h
-  dsdiff/dsdifffile.h
-  dsdiff/dsdiffproperties.h
-  dsdiff/dsdiffdiintag.h
-)
-
-set(mpeg_SRCS
-  mpeg/mpegfile.cpp
-  mpeg/mpegproperties.cpp
-  mpeg/mpegheader.cpp
-  mpeg/xingheader.cpp
-)
-
-set(id3v1_SRCS
-  mpeg/id3v1/id3v1tag.cpp
-  mpeg/id3v1/id3v1genres.cpp
-)
-
-set(id3v2_SRCS
-  mpeg/id3v2/id3v2framefactory.cpp
-  mpeg/id3v2/id3v2synchdata.cpp
-  mpeg/id3v2/id3v2tag.cpp
-  mpeg/id3v2/id3v2header.cpp
-  mpeg/id3v2/id3v2frame.cpp
-  mpeg/id3v2/id3v2footer.cpp
-  mpeg/id3v2/id3v2extendedheader.cpp
-  )
-
-set(frames_SRCS
-  mpeg/id3v2/frames/attachedpictureframe.cpp
-  mpeg/id3v2/frames/commentsframe.cpp
-  mpeg/id3v2/frames/eventtimingcodesframe.cpp
-  mpeg/id3v2/frames/generalencapsulatedobjectframe.cpp
-  mpeg/id3v2/frames/ownershipframe.cpp
-  mpeg/id3v2/frames/popularimeterframe.cpp
-  mpeg/id3v2/frames/privateframe.cpp
-  mpeg/id3v2/frames/relativevolumeframe.cpp
-  mpeg/id3v2/frames/synchronizedlyricsframe.cpp
-  mpeg/id3v2/frames/textidentificationframe.cpp
-  mpeg/id3v2/frames/uniquefileidentifierframe.cpp
-  mpeg/id3v2/frames/unknownframe.cpp
-  mpeg/id3v2/frames/unsynchronizedlyricsframe.cpp
-  mpeg/id3v2/frames/urllinkframe.cpp
-  mpeg/id3v2/frames/chapterframe.cpp
-  mpeg/id3v2/frames/tableofcontentsframe.cpp
-  mpeg/id3v2/frames/podcastframe.cpp
-)
-
-set(ogg_SRCS
-  ogg/oggfile.cpp
-  ogg/oggpage.cpp
-  ogg/oggpageheader.cpp
-  ogg/xiphcomment.cpp
-)
-
-set(vorbis_SRCS
-  ogg/vorbis/vorbisfile.cpp
-  ogg/vorbis/vorbisproperties.cpp
-)
-
-set(flacs_SRCS
-  flac/flacfile.cpp
-  flac/flacpicture.cpp
-  flac/flacproperties.cpp
-  flac/flacmetadatablock.cpp
-  flac/flacunknownmetadatablock.cpp
-)
-
-set(oggflacs_SRCS
-  ogg/flac/oggflacfile.cpp
-)
-
-set(mpc_SRCS
-  mpc/mpcfile.cpp
-  mpc/mpcproperties.cpp
-)
-
-set(mp4_SRCS
-  mp4/mp4file.cpp
-  mp4/mp4atom.cpp
-  mp4/mp4tag.cpp
-  mp4/mp4item.cpp
-  mp4/mp4properties.cpp
-  mp4/mp4coverart.cpp
-)
-
-set(ape_SRCS
-  ape/apetag.cpp
-  ape/apefooter.cpp
-  ape/apeitem.cpp
-  ape/apefile.cpp
-  ape/apeproperties.cpp
-)
-
-set(wavpack_SRCS
-  wavpack/wavpackfile.cpp
-  wavpack/wavpackproperties.cpp
-)
-
-set(speex_SRCS
-  ogg/speex/speexfile.cpp
-  ogg/speex/speexproperties.cpp
-)
-
-set(opus_SRCS
-  ogg/opus/opusfile.cpp
-  ogg/opus/opusproperties.cpp
-)
-
-set(trueaudio_SRCS
-  trueaudio/trueaudiofile.cpp
-  trueaudio/trueaudioproperties.cpp
-)
-
-set(asf_SRCS
-  asf/asftag.cpp
-  asf/asffile.cpp
-  asf/asfproperties.cpp
-  asf/asfattribute.cpp
-  asf/asfpicture.cpp
-)
-
-set(riff_SRCS
-  riff/rifffile.cpp
-)
-
-set(aiff_SRCS
-  riff/aiff/aifffile.cpp
-  riff/aiff/aiffproperties.cpp
-)
-
-set(wav_SRCS
-  riff/wav/wavfile.cpp
-  riff/wav/wavproperties.cpp
-  riff/wav/infotag.cpp
-)
-
-set(mod_SRCS
-  mod/modfilebase.cpp
-  mod/modfile.cpp
-  mod/modtag.cpp
-  mod/modproperties.cpp
-)
-
-set(s3m_SRCS
-  s3m/s3mfile.cpp
-  s3m/s3mproperties.cpp
-)
-
-set(it_SRCS
-  it/itfile.cpp
-  it/itproperties.cpp
-)
-
-set(xm_SRCS
-  xm/xmfile.cpp
-  xm/xmproperties.cpp
-)
-
-set(dsf_SRCS
-  dsf/dsffile.cpp
-  dsf/dsfproperties.cpp
-)
-
-set(dsdiff_SRCS
-  dsdiff/dsdifffile.cpp
-  dsdiff/dsdiffproperties.cpp
-  dsdiff/dsdiffdiintag.cpp
-)
-
-set(toolkit_SRCS
-  toolkit/tstring.cpp
-  toolkit/tstringlist.cpp
-  toolkit/tbytevector.cpp
-  toolkit/tbytevectorlist.cpp
-  toolkit/tbytevectorstream.cpp
-  toolkit/tiostream.cpp
-  toolkit/tfile.cpp
-  toolkit/tfilestream.cpp
-  toolkit/tdebug.cpp
-  toolkit/tpropertymap.cpp
-  toolkit/trefcounter.cpp
-  toolkit/tdebuglistener.cpp
-  toolkit/tzlib.cpp
-)
-
-if(HAVE_ZLIB_SOURCE)
-  set(zlib_SRCS
-    ${ZLIB_SOURCE}/adler32.c
-    ${ZLIB_SOURCE}/crc32.c
-    ${ZLIB_SOURCE}/inffast.c
-    ${ZLIB_SOURCE}/inflate.c
-    ${ZLIB_SOURCE}/inftrees.c
-    ${ZLIB_SOURCE}/zutil.c
-  )
-endif()
-
-set(tag_LIB_SRCS
-  ${mpeg_SRCS} ${id3v1_SRCS} ${id3v2_SRCS} ${frames_SRCS} ${ogg_SRCS}
-  ${vorbis_SRCS} ${oggflacs_SRCS} ${mpc_SRCS} ${ape_SRCS} ${toolkit_SRCS} ${flacs_SRCS}
-  ${wavpack_SRCS} ${speex_SRCS} ${trueaudio_SRCS} ${riff_SRCS} ${aiff_SRCS} ${wav_SRCS}
-  ${asf_SRCS} ${mp4_SRCS} ${mod_SRCS} ${s3m_SRCS} ${it_SRCS} ${xm_SRCS} ${opus_SRCS} ${dsf_SRCS} ${dsdiff_SRCS}
-  ${zlib_SRCS}
-  tag.cpp
-  tagunion.cpp
-  fileref.cpp
-  audioproperties.cpp
-  tagutils.cpp
-)
-
-add_library(tag STATIC ${tag_LIB_SRCS} ${tag_HDRS})
-
-if(HAVE_ZLIB AND NOT HAVE_ZLIB_SOURCE)
-  target_link_libraries(tag ${ZLIB_LIBRARIES})
-endif()
-
-set_target_properties(tag PROPERTIES
-  VERSION ${TAGLIB_SOVERSION_MAJOR}.${TAGLIB_SOVERSION_MINOR}.${TAGLIB_SOVERSION_PATCH}
-  SOVERSION ${TAGLIB_SOVERSION_MAJOR}
-  DEFINE_SYMBOL MAKE_TAGLIB_LIB
-  LINK_INTERFACE_LIBRARIES ""
-)
-
-foreach(header ${tag_HDRS})
-  get_filename_component(header_name ${header} NAME)
-  configure_file(
-    "${header}"
-    "${CMAKE_CURRENT_BINARY_DIR}/headers/taglib/${header_name}"
-    COPYONLY
-  )
-endforeach()
-

3rdparty/taglib/COPYING

@@ -1,502 +0,0 @@
-                  GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 2.1, February 1999
-
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.
- 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the Lesser GPL.  It also counts
- as the successor of the GNU Library Public License, version 2, hence
- the version number 2.1.]
-
-                            Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Lesser General Public License, applies to some
-specially designated software packages--typically libraries--of the
-Free Software Foundation and other authors who decide to use it.  You
-can use it too, but we suggest you first think carefully about whether
-this license or the ordinary General Public License is the better
-strategy to use in any particular case, based on the explanations below.
-
-  When we speak of free software, we are referring to freedom of use,
-not price.  Our General Public Licenses are designed to make sure that
-you have the freedom to distribute copies of free software (and charge
-for this service if you wish); that you receive source code or can get
-it if you want it; that you can change the software and use pieces of
-it in new free programs; and that you are informed that you can do
-these things.
-
-  To protect your rights, we need to make restrictions that forbid
-distributors to deny you these rights or to ask you to surrender these
-rights.  These restrictions translate to certain responsibilities for
-you if you distribute copies of the library or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link other code with the library, you must provide
-complete object files to the recipients, so that they can relink them
-with the library after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  We protect your rights with a two-step method: (1) we copyright the
-library, and (2) we offer you this license, which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  To protect each distributor, we want to make it very clear that
-there is no warranty for the free library.  Also, if the library is
-modified by someone else and passed on, the recipients should know
-that what they have is not the original version, so that the original
-author's reputation will not be affected by problems that might be
-introduced by others.
-
-  Finally, software patents pose a constant threat to the existence of
-any free program.  We wish to make sure that a company cannot
-effectively restrict the users of a free program by obtaining a
-restrictive license from a patent holder.  Therefore, we insist that
-any patent license obtained for a version of the library must be
-consistent with the full freedom of use specified in this license.
-
-  Most GNU software, including some libraries, is covered by the
-ordinary GNU General Public License.  This license, the GNU Lesser
-General Public License, applies to certain designated libraries, and
-is quite different from the ordinary General Public License.  We use
-this license for certain libraries in order to permit linking those
-libraries into non-free programs.
-
-  When a program is linked with a library, whether statically or using
-a shared library, the combination of the two is legally speaking a
-combined work, a derivative of the original library.  The ordinary
-General Public License therefore permits such linking only if the
-entire combination fits its criteria of freedom.  The Lesser General
-Public License permits more lax criteria for linking other code with
-the library.
-
-  We call this license the "Lesser" General Public License because it
-does Less to protect the user's freedom than the ordinary General
-Public License.  It also provides other free software developers Less
-of an advantage over competing non-free programs.  These disadvantages
-are the reason we use the ordinary General Public License for many
-libraries.  However, the Lesser license provides advantages in certain
-special circumstances.
-
-  For example, on rare occasions, there may be a special need to
-encourage the widest possible use of a certain library, so that it becomes
-a de-facto standard.  To achieve this, non-free programs must be
-allowed to use the library.  A more frequent case is that a free
-library does the same job as widely used non-free libraries.  In this
-case, there is little to gain by limiting the free library to free
-software only, so we use the Lesser General Public License.
-
-  In other cases, permission to use a particular library in non-free
-programs enables a greater number of people to use a large body of
-free software.  For example, permission to use the GNU C Library in
-non-free programs enables many more people to use the whole GNU
-operating system, as well as its variant, the GNU/Linux operating
-system.
-
-  Although the Lesser General Public License is Less protective of the
-users' freedom, it does ensure that the user of a program that is
-linked with the Library has the freedom and the wherewithal to run
-that program using a modified version of the Library.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, whereas the latter must
-be combined with the library in order to run.
-
-                  GNU LESSER GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library or other
-program which contains a notice placed by the copyright holder or
-other authorized party saying it may be distributed under the terms of
-this Lesser General Public License (also called "this License").
-Each licensee is addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also combine or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Use a suitable shared library mechanism for linking with the
-    Library.  A suitable mechanism is one that (1) uses at run time a
-    copy of the library already present on the user's computer system,
-    rather than copying library functions into the executable, and (2)
-    will operate properly with a modified version of the library, if
-    the user installs one, as long as the modified version is
-    interface-compatible with the version that the work was made with.
-
-    c) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    d) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    e) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the materials to be distributed need not include anything that is
-normally distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties with
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Lesser General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-                            NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-                     END OF TERMS AND CONDITIONS
-
-           How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2.1 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!

3rdparty/taglib/ConfigureChecks.cmake

@@ -1,215 +0,0 @@
-include(CheckLibraryExists)
-include(CheckTypeSize)
-include(CheckCXXSourceCompiles)
-
-# Check if the size of numeric types are suitable.
-
-check_type_size("short" SIZEOF_SHORT)
-if(NOT ${SIZEOF_SHORT} EQUAL 2)
-  message(FATAL_ERROR "TagLib requires that short is 16-bit wide.")
-endif()
-
-check_type_size("int" SIZEOF_INT)
-if(NOT ${SIZEOF_INT} EQUAL 4)
-  message(FATAL_ERROR "TagLib requires that int is 32-bit wide.")
-endif()
-
-check_type_size("long long" SIZEOF_LONGLONG)
-if(NOT ${SIZEOF_LONGLONG} EQUAL 8)
-  message(FATAL_ERROR "TagLib requires that long long is 64-bit wide.")
-endif()
-
-check_type_size("wchar_t" SIZEOF_WCHAR_T)
-if(${SIZEOF_WCHAR_T} LESS 2)
-  message(FATAL_ERROR "TagLib requires that wchar_t is sufficient to store a UTF-16 char.")
-endif()
-
-check_type_size("float" SIZEOF_FLOAT)
-if(NOT ${SIZEOF_FLOAT} EQUAL 4)
-  message(FATAL_ERROR "TagLib requires that float is 32-bit wide.")
-endif()
-
-check_type_size("double" SIZEOF_DOUBLE)
-if(NOT ${SIZEOF_DOUBLE} EQUAL 8)
-  message(FATAL_ERROR "TagLib requires that double is 64-bit wide.")
-endif()
-
-# Determine which kind of atomic operations your compiler supports.
-
-check_cxx_source_compiles("
-  #include <atomic>
-  int main() {
-    std::atomic_int x(1);
-    ++x;
-    --x;
-    return 0;
-  }
-" HAVE_STD_ATOMIC)
-
-if(NOT HAVE_STD_ATOMIC)
-  check_cxx_source_compiles("
-    int main() {
-      volatile int x;
-      __sync_add_and_fetch(&x, 1);
-      int y = __sync_sub_and_fetch(&x, 1);
-      return 0;
-    }
-  " HAVE_GCC_ATOMIC)
-
-  if(NOT HAVE_GCC_ATOMIC)
-    check_cxx_source_compiles("
-      #include <libkern/OSAtomic.h>
-      int main() {
-        volatile int32_t x;
-        OSAtomicIncrement32Barrier(&x);
-        int32_t y = OSAtomicDecrement32Barrier(&x);
-        return 0;
-      }
-    " HAVE_MAC_ATOMIC)
-
-    if(NOT HAVE_MAC_ATOMIC)
-      check_cxx_source_compiles("
-        #include <windows.h>
-        int main() {
-          volatile LONG x;
-          InterlockedIncrement(&x);
-          LONG y = InterlockedDecrement(&x);
-          return 0;
-        }
-      " HAVE_WIN_ATOMIC)
-
-      if(NOT HAVE_WIN_ATOMIC)
-        check_cxx_source_compiles("
-          #include <ia64intrin.h>
-          int main() {
-            volatile int x;
-            __sync_add_and_fetch(&x, 1);
-            int y = __sync_sub_and_fetch(&x, 1);
-            return 0;
-          }
-        " HAVE_IA64_ATOMIC)
-      endif()
-    endif()
-  endif()
-endif()
-
-# Determine which kind of byte swap functions your compiler supports.
-
-check_cxx_source_compiles("
-  int main() {
-    __builtin_bswap16(0);
-    __builtin_bswap32(0);
-    __builtin_bswap64(0);
-    return 0;
-  }
-" HAVE_GCC_BYTESWAP)
-
-if(NOT HAVE_GCC_BYTESWAP)
-  check_cxx_source_compiles("
-    #include <byteswap.h>
-    int main() {
-      __bswap_16(0);
-      __bswap_32(0);
-      __bswap_64(0);
-      return 0;
-    }
-  " HAVE_GLIBC_BYTESWAP)
-
-  if(NOT HAVE_GLIBC_BYTESWAP)
-    check_cxx_source_compiles("
-      #include <stdlib.h>
-      int main() {
-        _byteswap_ushort(0);
-        _byteswap_ulong(0);
-        _byteswap_uint64(0);
-        return 0;
-      }
-    " HAVE_MSC_BYTESWAP)
-
-    if(NOT HAVE_MSC_BYTESWAP)
-      check_cxx_source_compiles("
-        #include <libkern/OSByteOrder.h>
-        int main() {
-          OSSwapInt16(0);
-          OSSwapInt32(0);
-          OSSwapInt64(0);
-          return 0;
-        }
-      " HAVE_MAC_BYTESWAP)
-
-      if(NOT HAVE_MAC_BYTESWAP)
-        check_cxx_source_compiles("
-          #include <sys/endian.h>
-          int main() {
-            swap16(0);
-            swap32(0);
-            swap64(0);
-            return 0;
-          }
-        " HAVE_OPENBSD_BYTESWAP)
-      endif()
-    endif()
-  endif()
-endif()
-
-# Determine whether your compiler supports some safer version of vsprintf.
-
-check_cxx_source_compiles("
-  #include <cstdio>
-  #include <cstdarg>
-  int main() {
-    char buf[20];
-    va_list args;
-    vsnprintf(buf, 20, \"%d\", args);
-    return 0;
-  }
-" HAVE_VSNPRINTF)
-
-if(NOT HAVE_VSNPRINTF)
-  check_cxx_source_compiles("
-    #include <cstdio>
-    #include <cstdarg>
-    int main() {
-      char buf[20];
-      va_list args;
-      vsprintf_s(buf, \"%d\", args);
-      return 0;
-    }
-  " HAVE_VSPRINTF_S)
-endif()
-
-# Determine whether your compiler supports ISO _strdup.
-
-check_cxx_source_compiles("
-  #include <cstring>
-  int main() {
-    _strdup(0);
-    return 0;
-  }
-" HAVE_ISO_STRDUP)
-
-# Determine whether zlib is installed.
-
-if(NOT ZLIB_SOURCE)
-  find_package(ZLIB)
-  if(ZLIB_FOUND)
-    set(HAVE_ZLIB 1)
-  else()
-    set(HAVE_ZLIB 0)
-  endif()
-endif()
-
-# Determine whether CppUnit is installed.
-
-if(BUILD_TESTS AND NOT BUILD_SHARED_LIBS)
-  find_package(CppUnit)
-  if(NOT CppUnit_FOUND)
-    message(STATUS "CppUnit not found, disabling tests.")
-    set(BUILD_TESTS OFF)
-  endif()
-endif()
-
-# Detect WinRT mode
-if(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
-	set(PLATFORM WINRT 1)
-endif()

3rdparty/taglib/README.md

@@ -1,26 +0,0 @@
-# TagLib
-
-[![Build Status](https://travis-ci.org/taglib/taglib.svg?branch=master)](https://travis-ci.org/taglib/taglib)
-
-### TagLib Audio Metadata Library
-
-http://taglib.org/
-
-TagLib is a library for reading and editing the metadata of several
-popular audio formats. Currently it supports both ID3v1 and [ID3v2][]
-for MP3 files, [Ogg Vorbis][] comments and ID3 tags 
-in [FLAC][], MPC, Speex, WavPack, TrueAudio, WAV, AIFF, MP4, APE,
-DSF, DFF, and ASF files.
-
-TagLib is distributed under the [GNU Lesser General Public License][]
-(LGPL) and [Mozilla Public License][] (MPL). Essentially that means that
-it may be used in proprietary applications, but if changes are made to
-TagLib they must be contributed back to the project. Please review the
-licenses if you are considering using TagLib in your project.
-
-  [ID3v2]: http://www.id3.org 
-  [Ogg Vorbis]: http://vorbis.com/
-  [FLAC]: https://xiph.org/flac/
-  [GNU Lesser General Public License]: http://www.gnu.org/licenses/lgpl.html
-  [Mozilla Public License]: http://www.mozilla.org/MPL/MPL-1.1.html
-

3rdparty/taglib/ape/ape-tag-format.txt

@@ -1,170 +0,0 @@
-================================================================================
-= APE Tag Specification, Version 2.000
-================================================================================
-
-Original Content     (C) 2004, Frank Klemm <frank.klemm@elster.offl.uni-jena.de>
-Formatting / Editing (C) 2004, Scott Wheeler <wheeler@kde.org>
-
-================================================================================
-= Contents
-================================================================================
-
-1   - APE Tag General Structure
-2   - APE Tag Header / Footer Format
-3   - APE Tag Flags
-4   - APE Tag Item Format
-5   - APE Tag Item Supported Keys
-6   - APE Tag Item Content
-7   - Data Types
-7.1 - Data Types / UTF-8
-7.2 - Data Types / Dates
-7.3 - Data Types / Timestamps
-
-================================================================================
-= 1 - APE Tag General Structure
-================================================================================
-
-Member of Basic Components of SV8 Stream Note:
-
-It is strongly recommended that the data size be stored in the tags.  The size
-should normally be in the roughly one kilobyte, never more than 8 kilobytes.
-
-Larger data should be stored externally using link entries.  Linked data is much
-easier to process by normal programs, so for instance JPEG data should not be
-included inside the audio file.
-
-APE Tag Version 2.000 (with header, recommended):
-
-/================================\
-| APE Tag Header    | 32 bytes   |
-|-------------------|------------|
-| APE Tag Item 1    | > 10 bytes |
-| APE Tag Item 2    | > 10 bytes |
-| APE Tag Item n-1  | > 10 bytes |
-| APE Tag Item n    | > 10 bytes |
-|-------------------|------------|
-| APE Tag Footer    | 32 bytes   |
-\================================/
-
-
-APE tag items should be sorted ascending by size.  When streaming, parts of the
-APE tag may be dropped to reduce the danger of drop outs between tracks.  This
-is not required, but is strongly recommended.  It would be desirable for the i
-tems to be sorted by importance / size, but this is not feasible.  This
-convention should only be broken when adding less important small items and it
-is not desirable to rewrite the entire tag.  An APE tag at the end of a file
-(the recommended location) must have at least a footer; an APE tag at the
-beginning of a file (strongly discouraged) must have at least a header.
-
-APE Tag Version 1.000 (without header, deprecated)
-
-/================================\
-| APE Tag Item 1    | > 10 bytes |
-| APE Tag Item 2    | > 10 bytes |
-| APE Tag Item n-1  | > 10 bytes |
-| APE Tag Item n    | > 10 bytes |
-|-------------------|------------|
-| APE Tag Footer    | 32 bytes   |
-\================================/
-
-================================================================================
-= 2 - APE Tag Header / Footer Format
-================================================================================
-
-Contains number, length and attributes of all tag items
-
-Header and Footer are different in 1 bit in the Tags Flags to distinguish
-between them.
-
-Member of APE Tag 2.0
-
-/===========================================================================\
-| Preamble       | 8 bytes | { 'A', 'P', 'E', 'T', 'A', 'G', 'E', 'X' }     |
-|----------------|---------|------------------------------------------------|
-| Version Number | 4 bytes | 1000 = Version 1.000, 2000 = Version 2.000     |
-|----------------|---------|------------------------------------------------|
-| Tag Size       | 4 bytes | Tag size in bytes including footer and all tag |
-|                |         | items excluding the header (for 1.000          |
-|                |         | compatibility)                                 |
-|----------------|---------|------------------------------------------------|
-| Item Count     | 4 bytes | Number of items in the tag                     |
-|----------------|---------|------------------------------------------------|
-| Tag Flags      | 4 bytes | Global flags                                   |
-|----------------|---------|------------------------------------------------|
-| Reserved       | 8 bytes | Must be zeroed                                 |
-\===========================================================================/
-
-================================================================================
-= 3 - APE Tag Flags
-================================================================================
-
-The general flag structure for either items or headers / footers is the same.
-Bits 31, 30 and 29 are specific to headers / footers, whereas 2 through 0 are
-item specific.
-
-Note: APE Tags from Version 1.0 do not use any of the following.  All flags in
-that version are zeroed and ignored when reading.
-
-/=================================================================\
-| Contains Header | Bit 31      | 1 - has header | 0 - no header  |
-|-----------------|-------------|---------------------------------|
-| Contains Footer | Bit 30      | 1 - has footer | 0 - no footer  |
-|-----------------|-------------|---------------------------------|
-| Is Header       | Bit 29      | 1 - is header  | 0 - is footer  |
-|-----------------|-------------|---------------------------------|
-| Undefined       | Bits 28 - 3 | Undefined, must be zeroed       |
-|-----------------|-------------|---------------------------------|
-| Encoding        | Bits 2 - 1  | 00 - UTF-8                      |
-|                 |             | 01 - Binary Data *              |
-|                 |             | 10 - External Reference **      |
-|                 |             | 11 - Reserved                   |
-|-----------------|-------------|---------------------------------|
-| Read Only       | Bit 0       | 1 - read only  | 0 - read/write |
-\=================================================================/
-
- (*) Should be ignored by tools for editing text values
-(**) Allowed external reference formats:
-     - http://host/directory/filename.ext
-     - ftp://host/directory/filename.ext
-     - filename.ext
-     - /directory/filename.ext
-     - DRIVE:/directory/filename.ext
-
-     Note: External references are also UTF-8 encoded.
-
-================================================================================
-= 4 - APE Tag Item Format
-================================================================================
-
-APE Tag Items are stored as key-value pairs.  APE Tags Item Key are case
-sensitive, however it is illegal to use keys which only differ in case and
-it is recommended that tag reading not be case sensitive.
-
-Every key can only occur (at most) once. It is not possible to repeat a key
-to signify updated contents.
-
-Tags can be partially or completely repeated in the streaming format.  This
-makes it possible to display an artist and / or title if it was missed at the
-beginning of the stream.  It is recommended that the important information like
-artist, album and title should occur approximately every 2 minutes in the
-stream and again 5 to 10 seconds before the end.  However, care should be tak
-en not to replicate this information too often or during passages with high
-bitrate demands to avoid unnecessary drop-outs.
-
-/==============================================================================\
-| Content Size   | 4 bytes       | Length of the value in bytes                |
-|----------------|---------------|---------------------------------------------|
-| Flags          | 4 bytes       | Item flags                                  |
-|----------------|---------------|---------------------------------------------|
-| Key            | 2 - 255 bytes | Item key                                    |
-|----------------|---------------|---------------------------------------------|
-| Key Terminator | 1 byte        | Null byte that indicates the end of the key |
-|----------------|---------------|---------------------------------------------|
-| Value          | variable      | Content (formatted according to the flags)  |
-\==============================================================================/
-
-================================================================================
-
-Sections 5 - 7 haven't yet been converted from:
-
-http://www.personal.uni-jena.de/~pfk/mpp/sv8/apetag.html

3rdparty/taglib/ape/apefile.cpp

@@ -1,314 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2010 by Alex Novichkov
-    email                : novichko@atnet.ru
-
-    copyright            : (C) 2006 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
-                           (original WavPack implementation)
-
-    copyright            : (C) 2004 by Allan Sandfeld Jensen
-    email                : kde@carewolf.org
-                           (original MPC implementation)
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <tbytevector.h>
-#include <tstring.h>
-#include <tdebug.h>
-#include <tagunion.h>
-#include <id3v1tag.h>
-#include <id3v2header.h>
-#include <tpropertymap.h>
-#include <tagutils.h>
-
-#include "apefile.h"
-#include "apetag.h"
-#include "apefooter.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-namespace
-{
-  enum { ApeAPEIndex = 0, ApeID3v1Index = 1 };
-}
-
-class APE::File::FilePrivate
-{
-public:
-  FilePrivate() :
-    APELocation(-1),
-    APESize(0),
-    ID3v1Location(-1),
-    ID3v2Header(0),
-    ID3v2Location(-1),
-    ID3v2Size(0),
-    properties(0) {}
-
-  ~FilePrivate()
-  {
-    delete ID3v2Header;
-    delete properties;
-  }
-
-  long APELocation;
-  long APESize;
-
-  long ID3v1Location;
-
-  ID3v2::Header *ID3v2Header;
-  long ID3v2Location;
-  long ID3v2Size;
-
-  TagUnion tag;
-
-  Properties *properties;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// static members
-////////////////////////////////////////////////////////////////////////////////
-
-bool APE::File::isSupported(IOStream *stream)
-{
-  // An APE file has an ID "MAC " somewhere. An ID3v2 tag may precede.
-
-  const ByteVector buffer = Utils::readHeader(stream, bufferSize(), true);
-  return (buffer.find("MAC ") >= 0);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// public members
-////////////////////////////////////////////////////////////////////////////////
-
-APE::File::File(FileName file, bool readProperties, Properties::ReadStyle) :
-  Strawberry_TagLib::TagLib::File(file),
-  d(new FilePrivate())
-{
-  if(isOpen())
-    read(readProperties);
-}
-
-APE::File::File(IOStream *stream, bool readProperties, Properties::ReadStyle) :
-  Strawberry_TagLib::TagLib::File(stream),
-  d(new FilePrivate())
-{
-  if(isOpen())
-    read(readProperties);
-}
-
-APE::File::~File()
-{
-  delete d;
-}
-
-Strawberry_TagLib::TagLib::Tag *APE::File::tag() const
-{
-  return &d->tag;
-}
-
-PropertyMap APE::File::properties() const
-{
-  return d->tag.properties();
-}
-
-void APE::File::removeUnsupportedProperties(const StringList &properties)
-{
-  d->tag.removeUnsupportedProperties(properties);
-}
-
-PropertyMap APE::File::setProperties(const PropertyMap &properties)
-{
-  if(ID3v1Tag())
-    ID3v1Tag()->setProperties(properties);
-
-  return APETag(true)->setProperties(properties);
-}
-
-APE::Properties *APE::File::audioProperties() const
-{
-  return d->properties;
-}
-
-bool APE::File::save()
-{
-  if(readOnly()) {
-    debug("APE::File::save() -- File is read only.");
-    return false;
-  }
-
-  // Update ID3v1 tag
-
-  if(ID3v1Tag() && !ID3v1Tag()->isEmpty()) {
-
-    // ID3v1 tag is not empty. Update the old one or create a new one.
-
-    if(d->ID3v1Location >= 0) {
-      seek(d->ID3v1Location);
-    }
-    else {
-      seek(0, End);
-      d->ID3v1Location = tell();
-    }
-
-    writeBlock(ID3v1Tag()->render());
-  }
-  else {
-
-    // ID3v1 tag is empty. Remove the old one.
-
-    if(d->ID3v1Location >= 0) {
-      truncate(d->ID3v1Location);
-      d->ID3v1Location = -1;
-    }
-  }
-
-  // Update APE tag
-
-  if(APETag() && !APETag()->isEmpty()) {
-
-    // APE tag is not empty. Update the old one or create a new one.
-
-    if(d->APELocation < 0) {
-      if(d->ID3v1Location >= 0)
-        d->APELocation = d->ID3v1Location;
-      else
-        d->APELocation = length();
-    }
-
-    const ByteVector data = APETag()->render();
-    insert(data, d->APELocation, d->APESize);
-
-    if(d->ID3v1Location >= 0)
-      d->ID3v1Location += (static_cast<long>(data.size()) - d->APESize);
-
-    d->APESize = data.size();
-  }
-  else {
-
-    // APE tag is empty. Remove the old one.
-
-    if(d->APELocation >= 0) {
-      removeBlock(d->APELocation, d->APESize);
-
-      if(d->ID3v1Location >= 0)
-        d->ID3v1Location -= d->APESize;
-
-      d->APELocation = -1;
-      d->APESize = 0;
-    }
-  }
-
-  return true;
-}
-
-ID3v1::Tag *APE::File::ID3v1Tag(bool create)
-{
-  return d->tag.access<ID3v1::Tag>(ApeID3v1Index, create);
-}
-
-APE::Tag *APE::File::APETag(bool create)
-{
-  return d->tag.access<APE::Tag>(ApeAPEIndex, create);
-}
-
-void APE::File::strip(int tags)
-{
-  if(tags & ID3v1)
-    d->tag.set(ApeID3v1Index, 0);
-
-  if(tags & APE)
-    d->tag.set(ApeAPEIndex, 0);
-
-  if(!ID3v1Tag())
-    APETag(true);
-}
-
-bool APE::File::hasAPETag() const
-{
-  return (d->APELocation >= 0);
-}
-
-bool APE::File::hasID3v1Tag() const
-{
-  return (d->ID3v1Location >= 0);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// private members
-////////////////////////////////////////////////////////////////////////////////
-
-void APE::File::read(bool readProperties)
-{
-  // Look for an ID3v2 tag
-
-  d->ID3v2Location = Utils::findID3v2(this);
-
-  if(d->ID3v2Location >= 0) {
-    seek(d->ID3v2Location);
-    d->ID3v2Header = new ID3v2::Header(readBlock(ID3v2::Header::size()));
-    d->ID3v2Size = d->ID3v2Header->completeTagSize();
-  }
-
-  // Look for an ID3v1 tag
-
-  d->ID3v1Location = Utils::findID3v1(this);
-
-  if(d->ID3v1Location >= 0)
-    d->tag.set(ApeID3v1Index, new ID3v1::Tag(this, d->ID3v1Location));
-
-  // Look for an APE tag
-
-  d->APELocation = Utils::findAPE(this, d->ID3v1Location);
-
-  if(d->APELocation >= 0) {
-    d->tag.set(ApeAPEIndex, new APE::Tag(this, d->APELocation));
-    d->APESize = APETag()->footer()->completeTagSize();
-    d->APELocation = d->APELocation + APE::Footer::size() - d->APESize;
-  }
-
-  if(d->ID3v1Location < 0)
-    APETag(true);
-
-  // Look for APE audio properties
-
-  if(readProperties) {
-
-    long streamLength;
-
-    if(d->APELocation >= 0)
-      streamLength = d->APELocation;
-    else if(d->ID3v1Location >= 0)
-      streamLength = d->ID3v1Location;
-    else
-      streamLength = length();
-
-    if(d->ID3v2Location >= 0) {
-      seek(d->ID3v2Location + d->ID3v2Size);
-      streamLength -= (d->ID3v2Location + d->ID3v2Size);
-    }
-    else {
-      seek(0);
-    }
-
-    d->properties = new Properties(this, streamLength);
-  }
-}

3rdparty/taglib/ape/apefile.h

@@ -1,237 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2010 by Alex Novichkov
-    email                : novichko@atnet.ru
-
-    copyright            : (C) 2006 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
-                           (original WavPack implementation)
-
-    copyright            : (C) 2004 by Allan Sandfeld Jensen
-    email                : kde@carewolf.org
-                           (original MPC implementation)
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_APEFILE_H
-#define TAGLIB_APEFILE_H
-
-#include "tfile.h"
-#include "taglib_export.h"
-#include "apeproperties.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  class Tag;
-
-  namespace ID3v1 { class Tag; }
-  namespace APE { class Tag; }
-
-  //! An implementation of APE metadata
-
-  /*!
-   * This is implementation of APE metadata.
-   *
-   * This supports ID3v1 and APE (v1 and v2) style comments as well as reading stream
-   * properties from the file.
-   */
-
-  namespace APE {
-
-    //! An implementation of TagLib::File with APE specific methods
-
-    /*!
-     * This implements and provides an interface for APE files to the
-     * TagLib::Tag and TagLib::AudioProperties interfaces by way of implementing
-     * the abstract TagLib::File API as well as providing some additional
-     * information specific to APE files.
-     */
-
-    class TAGLIB_EXPORT File : public Strawberry_TagLib::TagLib::File
-    {
-    public:
-      /*!
-       * This set of flags is used for various operations and is suitable for
-       * being OR-ed together.
-       */
-      enum TagTypes {
-        //! Empty set.  Matches no tag types.
-        NoTags  = 0x0000,
-        //! Matches ID3v1 tags.
-        ID3v1   = 0x0001,
-        //! Matches APE tags.
-        APE     = 0x0002,
-        //! Matches all tag types.
-        AllTags = 0xffff
-      };
-
-      /*!
-       * Constructs an APE file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read.
-       *
-       * \note In the current implementation, \a propertiesStyle is ignored.
-       */
-      File(FileName file, bool readProperties = true,
-           Properties::ReadStyle propertiesStyle = Properties::Average);
-
-      /*!
-       * Constructs an APE file from \a stream.  If \a readProperties is true the
-       * file's audio properties will also be read.
-       *
-       * \note TagLib will *not* take ownership of the stream, the caller is
-       * responsible for deleting it after the File object.
-       *
-       * \note In the current implementation, \a propertiesStyle is ignored.
-       */
-      File(IOStream *stream, bool readProperties = true,
-           Properties::ReadStyle propertiesStyle = Properties::Average);
-
-      /*!
-       * Destroys this instance of the File.
-       */
-      virtual ~File();
-
-      /*!
-       * Returns the Tag for this file.  This will be an APE tag, an ID3v1 tag
-       * or a combination of the two.
-       */
-      virtual Strawberry_TagLib::TagLib::Tag *tag() const;
-
-      /*!
-       * Implements the unified property interface -- export function.
-       * If the file contains both an APE and an ID3v1 tag, only APE
-       * will be converted to the PropertyMap.
-       */
-      PropertyMap properties() const;
-
-      /*!
-       * Removes unsupported properties. Forwards to the actual Tag's
-       * removeUnsupportedProperties() function.
-       */
-      void removeUnsupportedProperties(const StringList &properties);
-
-      /*!
-       * Implements the unified property interface -- import function.
-       * Creates an APEv2 tag if necessary. A potentially existing ID3v1
-       * tag will be updated as well.
-       */
-      PropertyMap setProperties(const PropertyMap &);
-
-      /*!
-       * Returns the APE::Properties for this file.  If no audio properties
-       * were read then this will return a null pointer.
-       */
-      virtual Properties *audioProperties() const;
-
-      /*!
-       * Saves the file.
-       *
-       * \note According to the official Monkey's Audio SDK, an APE file
-       * can only have either ID3V1 or APE tags, so a parameter is used here.
-       */
-      virtual bool save();
-
-      /*!
-       * Returns a pointer to the ID3v1 tag of the file.
-       *
-       * If \a create is false (the default) this may return a null pointer
-       * if there is no valid ID3v1 tag.  If \a create is true it will create
-       * an ID3v1 tag if one does not exist and returns a valid pointer.
-       *
-       * \note This may return a valid pointer regardless of whether or not the
-       * file on disk has an ID3v1 tag.  Use hasID3v1Tag() to check if the file
-       * on disk actually has an ID3v1 tag.
-       *
-       * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
-       * deleted by the user.  It will be deleted when the file (object) is
-       * destroyed.
-       *
-       * \see hasID3v1Tag()
-       */
-      ID3v1::Tag *ID3v1Tag(bool create = false);
-
-      /*!
-       * Returns a pointer to the APE tag of the file.
-       *
-       * If \a create is false (the default) this may return a null pointer
-       * if there is no valid APE tag.  If \a create is true it will create
-       * an APE tag if one does not exist and returns a valid pointer.
-       *
-       * \note This may return a valid pointer regardless of whether or not the
-       * file on disk has an APE tag.  Use hasAPETag() to check if the file
-       * on disk actually has an APE tag.
-       *
-       * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
-       * deleted by the user.  It will be deleted when the file (object) is
-       * destroyed.
-       *
-       * \see hasAPETag()
-       */
-      APE::Tag *APETag(bool create = false);
-
-      /*!
-       * This will remove the tags that match the OR-ed together TagTypes from the
-       * file.  By default it removes all tags.
-       *
-       * \note This will also invalidate pointers to the tags
-       * as their memory will be freed.
-       * \note In order to make the removal permanent save() still needs to be called
-       */
-      void strip(int tags = AllTags);
-
-      /*!
-       * Returns whether or not the file on disk actually has an APE tag.
-       *
-       * \see APETag()
-       */
-      bool hasAPETag() const;
-
-      /*!
-       * Returns whether or not the file on disk actually has an ID3v1 tag.
-       *
-       * \see ID3v1Tag()
-       */
-      bool hasID3v1Tag() const;
-
-      /*!
-       * Returns whether or not the given \a stream can be opened as an APE
-       * file.
-       *
-       * \note This method is designed to do a quick check.  The result may
-       * not necessarily be correct.
-       */
-      static bool isSupported(IOStream *stream);
-
-    private:
-      File(const File &);
-      File &operator=(const File &);
-
-      void read(bool readProperties);
-
-      class FilePrivate;
-      FilePrivate *d;
-    };
-  }
-}
-}
-
-#endif

3rdparty/taglib/ape/apefooter.cpp

@@ -1,234 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2004 by Allan Sandfeld Jensen
-                           (C) 2002 - 2008 by Scott Wheeler (id3v2header.cpp)
-    email                : kde@carewolf.org
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <iostream>
-#include <bitset>
-
-#include <tstring.h>
-#include <tdebug.h>
-
-#include "apefooter.h"
-
-using namespace Strawberry_TagLib::TagLib;
-using namespace APE;
-
-class APE::Footer::FooterPrivate
-{
-public:
-  FooterPrivate() :
-    version(0),
-    footerPresent(true),
-    headerPresent(false),
-    isHeader(false),
-    itemCount(0),
-    tagSize(0) {}
-
-  unsigned int version;
-
-  bool footerPresent;
-  bool headerPresent;
-
-  bool isHeader;
-
-  unsigned int itemCount;
-  unsigned int tagSize;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// static members
-////////////////////////////////////////////////////////////////////////////////
-
-unsigned int APE::Footer::size()
-{
-  return 32;
-}
-
-ByteVector APE::Footer::fileIdentifier()
-{
-  return ByteVector("APETAGEX");
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// public members
-////////////////////////////////////////////////////////////////////////////////
-
-APE::Footer::Footer() :
-  d(new FooterPrivate())
-{
-}
-
-APE::Footer::Footer(const ByteVector &data) :
-  d(new FooterPrivate())
-{
-  parse(data);
-}
-
-APE::Footer::~Footer()
-{
-  delete d;
-}
-
-unsigned int APE::Footer::version() const
-{
-  return d->version;
-}
-
-bool APE::Footer::headerPresent() const
-{
-  return d->headerPresent;
-}
-
-bool APE::Footer::footerPresent() const
-{
-  return d->footerPresent;
-}
-
-bool APE::Footer::isHeader() const
-{
-  return d->isHeader;
-}
-
-void APE::Footer::setHeaderPresent(bool b) const
-{
-  d->headerPresent = b;
-}
-
-unsigned int APE::Footer::itemCount() const
-{
-  return d->itemCount;
-}
-
-void APE::Footer::setItemCount(unsigned int s)
-{
-  d->itemCount = s;
-}
-
-unsigned int APE::Footer::tagSize() const
-{
-  return d->tagSize;
-}
-
-unsigned int APE::Footer::completeTagSize() const
-{
-  if(d->headerPresent)
-    return d->tagSize + size();
-  else
-    return d->tagSize;
-}
-
-void APE::Footer::setTagSize(unsigned int s)
-{
-  d->tagSize = s;
-}
-
-void APE::Footer::setData(const ByteVector &data)
-{
-  parse(data);
-}
-
-ByteVector APE::Footer::renderFooter() const
-{
-  return render(false);
-}
-
-ByteVector APE::Footer::renderHeader() const
-{
-  if(!d->headerPresent)
-    return ByteVector();
-  else
-    return render(true);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// protected members
-////////////////////////////////////////////////////////////////////////////////
-
-void APE::Footer::parse(const ByteVector &data)
-{
-  if(data.size() < size())
-    return;
-
-  // The first eight bytes, data[0..7], are the File Identifier, "APETAGEX".
-
-  // Read the version number
-
-  d->version = data.toUInt(8, false);
-
-  // Read the tag size
-
-  d->tagSize = data.toUInt(12, false);
-
-  // Read the item count
-
-  d->itemCount = data.toUInt(16, false);
-
-  // Read the flags
-
-  std::bitset<32> flags(TAGLIB_CONSTRUCT_BITSET(data.toUInt(20, false)));
-
-  d->headerPresent = flags[31];
-  d->footerPresent = !flags[30];
-  d->isHeader = flags[29];
-
-}
-
-ByteVector APE::Footer::render(bool isHeader) const
-{
-  ByteVector v;
-
-  // add the file identifier -- "APETAGEX"
-
-  v.append(fileIdentifier());
-
-  // add the version number -- we always render a 2.000 tag regardless of what
-  // the tag originally was.
-
-  v.append(ByteVector::fromUInt(2000, false));
-
-  // add the tag size
-
-  v.append(ByteVector::fromUInt(d->tagSize, false));
-
-  // add the item count
-
-  v.append(ByteVector::fromUInt(d->itemCount, false));
-
-  // render and add the flags
-
-  std::bitset<32> flags;
-
-  flags[31] = d->headerPresent;
-  flags[30] = false; // footer is always present
-  flags[29] = isHeader;
-
-  v.append(ByteVector::fromUInt(flags.to_ulong(), false));
-
-  // add the reserved 64bit
-
-  v.append(ByteVector::fromLongLong(0));
-
-  return v;
-}

3rdparty/taglib/ape/apefooter.h

@@ -1,175 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2004 by Allan Sandfeld Jensen
-    email                : kde@carewolf.org
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_APEFOOTER_H
-#define TAGLIB_APEFOOTER_H
-
-#include "tbytevector.h"
-#include "taglib_export.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  namespace APE {
-
-    //! An implementation of APE footers
-
-    /*!
-     * This class implements APE footers (and headers). It attempts to follow, both
-     * semantically and programmatically, the structure specified in
-     * the APE v2.0 standard.  The API is based on the properties of APE footer and
-     * headers specified there.
-     */
-
-    class TAGLIB_EXPORT Footer
-    {
-    public:
-      /*!
-       * Constructs an empty APE footer.
-       */
-      Footer();
-
-      /*!
-       * Constructs an APE footer based on \a data.  parse() is called
-       * immediately.
-       */
-      Footer(const ByteVector &data);
-
-      /*!
-       * Destroys the footer.
-       */
-      virtual ~Footer();
-
-      /*!
-       * Returns the version number.  (Note: This is the 1000 or 2000.)
-       */
-      unsigned int version() const;
-
-      /*!
-       * Returns true if a header is present in the tag.
-       */
-      bool headerPresent() const;
-
-      /*!
-       * Returns true if a footer is present in the tag.
-       */
-      bool footerPresent() const;
-
-      /*!
-       * Returns true this is actually the header.
-       */
-      bool isHeader() const;
-
-      /*!
-       * Sets whether the header should be rendered or not
-       */
-      void setHeaderPresent(bool b) const;
-
-      /*!
-       * Returns the number of items in the tag.
-       */
-      unsigned int itemCount() const;
-
-      /*!
-       * Set the item count to \a s.
-       * \see itemCount()
-       */
-      void setItemCount(unsigned int s);
-
-      /*!
-       * Returns the tag size in bytes.  This is the size of the frame content and footer.
-       * The size of the \e entire tag will be this plus the header size, if present.
-       *
-       * \see completeTagSize()
-       */
-      unsigned int tagSize() const;
-
-      /*!
-       * Returns the tag size, including if present, the header
-       * size.
-       *
-       * \see tagSize()
-       */
-      unsigned int completeTagSize() const;
-
-      /*!
-       * Set the tag size to \a s.
-       * \see tagSize()
-       */
-      void setTagSize(unsigned int s);
-
-      /*!
-       * Returns the size of the footer.  Presently this is always 32 bytes.
-       */
-      static unsigned int size();
-
-      /*!
-       * Returns the string used to identify an APE tag inside of a file.
-       * Presently this is always "APETAGEX".
-       */
-      static ByteVector fileIdentifier();
-
-      /*!
-       * Sets the data that will be used as the footer.  32 bytes,
-       * starting from \a data will be used.
-       */
-      void setData(const ByteVector &data);
-
-      /*!
-       * Renders the footer back to binary format.
-       */
-      ByteVector renderFooter() const;
-
-      /*!
-       * Renders the header corresponding to the footer. If headerPresent is
-       * set to false, it returns an empty ByteVector.
-       */
-      ByteVector renderHeader() const;
-
-    protected:
-      /*!
-       * Called by setData() to parse the footer data.  It makes this information
-       * available through the public API.
-       */
-      void parse(const ByteVector &data);
-
-      /*!
-       * Called by renderFooter and renderHeader
-       */
-      ByteVector render(bool isHeader) const;
-
-    private:
-      Footer(const Footer &);
-      Footer &operator=(const Footer &);
-
-      class FooterPrivate;
-      FooterPrivate *d;
-    };
-
-  }
-}
-}
-
-#endif

3rdparty/taglib/ape/apeitem.cpp

@@ -1,301 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2004 by Allan Sandfeld Jensen
-    email                : kde@carewolf.com
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <tbytevectorlist.h>
-#include <tdebug.h>
-
-#include "apeitem.h"
-
-using namespace Strawberry_TagLib::TagLib;
-using namespace APE;
-
-class APE::Item::ItemPrivate
-{
-public:
-  ItemPrivate() :
-    type(Text),
-    readOnly(false) {}
-
-  Item::ItemTypes type;
-  String key;
-  ByteVector value;
-  StringList text;
-  bool readOnly;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// public members
-////////////////////////////////////////////////////////////////////////////////
-
-APE::Item::Item() :
-  d(new ItemPrivate())
-{
-}
-
-APE::Item::Item(const String &key, const String &value) :
-  d(new ItemPrivate())
-{
-  d->key = key;
-  d->text.append(value);
-}
-
-APE::Item::Item(const String &key, const StringList &values) :
-  d(new ItemPrivate())
-{
-  d->key = key;
-  d->text = values;
-}
-
-APE::Item::Item(const String &key, const ByteVector &value, bool binary) :
-  d(new ItemPrivate())
-{
-  d->key = key;
-  if(binary) {
-    d->type = Binary;
-    d->value = value;
-  }
-  else {
-    d->text.append(value);
-  }
-}
-
-APE::Item::Item(const Item &item) :
-  d(new ItemPrivate(*item.d))
-{
-}
-
-APE::Item::~Item()
-{
-  delete d;
-}
-
-Item &APE::Item::operator=(const Item &item)
-{
-  Item(item).swap(*this);
-  return *this;
-}
-
-void APE::Item::swap(Item &item)
-{
-  using std::swap;
-
-  swap(d, item.d);
-}
-
-void APE::Item::setReadOnly(bool readOnly)
-{
-  d->readOnly = readOnly;
-}
-
-bool APE::Item::isReadOnly() const
-{
-  return d->readOnly;
-}
-
-void APE::Item::setType(APE::Item::ItemTypes val)
-{
-  d->type = val;
-}
-
-APE::Item::ItemTypes APE::Item::type() const
-{
-  return d->type;
-}
-
-String APE::Item::key() const
-{
-  return d->key;
-}
-
-ByteVector APE::Item::binaryData() const
-{
-  return d->value;
-}
-
-void APE::Item::setBinaryData(const ByteVector &value)
-{
-  d->type = Binary;
-  d->value = value;
-  d->text.clear();
-}
-
-ByteVector APE::Item::value() const
-{
-  // This seems incorrect as it won't be actually rendering the value to keep it
-  // up to date.
-
-  return d->value;
-}
-
-void APE::Item::setKey(const String &key)
-{
-  d->key = key;
-}
-
-void APE::Item::setValue(const String &value)
-{
-  d->type = Text;
-  d->text = value;
-  d->value.clear();
-}
-
-void APE::Item::setValues(const StringList &value)
-{
-  d->type = Text;
-  d->text = value;
-  d->value.clear();
-}
-
-void APE::Item::appendValue(const String &value)
-{
-  d->type = Text;
-  d->text.append(value);
-  d->value.clear();
-}
-
-void APE::Item::appendValues(const StringList &values)
-{
-  d->type = Text;
-  d->text.append(values);
-  d->value.clear();
-}
-
-int APE::Item::size() const
-{
-  int result = 8 + d->key.size() + 1;
-  switch(d->type) {
-    case Text:
-      if(!d->text.isEmpty()) {
-        StringList::ConstIterator it = d->text.begin();
-
-        result += it->data(String::UTF8).size();
-        it++;
-        for(; it != d->text.end(); ++it)
-          result += 1 + it->data(String::UTF8).size();
-      }
-      break;
-
-    case Binary:
-    case Locator:
-      result += d->value.size();
-      break;
-  }
-  return result;
-}
-
-StringList APE::Item::toStringList() const
-{
-  return d->text;
-}
-
-StringList APE::Item::values() const
-{
-  return d->text;
-}
-
-String APE::Item::toString() const
-{
-  if(d->type == Text && !isEmpty())
-    return d->text.front();
-  else
-    return String();
-}
-
-bool APE::Item::isEmpty() const
-{
-  switch(d->type) {
-    case Text:
-      if(d->text.isEmpty())
-        return true;
-      if(d->text.size() == 1 && d->text.front().isEmpty())
-        return true;
-      return false;
-    case Binary:
-    case Locator:
-      return d->value.isEmpty();
-    default:
-      return false;
-  }
-}
-
-void APE::Item::parse(const ByteVector &data)
-{
-  // 11 bytes is the minimum size for an APE item
-
-  if(data.size() < 11) {
-    debug("APE::Item::parse() -- no data in item");
-    return;
-  }
-
-  const unsigned int valueLength  = data.toUInt(0, false);
-  const unsigned int flags        = data.toUInt(4, false);
-
-  // An item key can contain ASCII characters from 0x20 up to 0x7E, not UTF-8.
-  // We assume that the validity of the given key has been checked.
-
-  d->key = String(&data[8], String::Latin1);
-
-  const ByteVector value = data.mid(8 + d->key.size() + 1, valueLength);
-
-  setReadOnly(flags & 1);
-  setType(ItemTypes((flags >> 1) & 3));
-
-  if(Text == d->type)
-    d->text = StringList(ByteVectorList::split(value, '\0'), String::UTF8);
-  else
-    d->value = value;
-}
-
-ByteVector APE::Item::render() const
-{
-  ByteVector data;
-  unsigned int flags = ((d->readOnly) ? 1 : 0) | (d->type << 1);
-  ByteVector value;
-
-  if(isEmpty())
-    return data;
-
-  if(d->type == Text) {
-    StringList::ConstIterator it = d->text.begin();
-
-    value.append(it->data(String::UTF8));
-    it++;
-    for(; it != d->text.end(); ++it) {
-      value.append('\0');
-      value.append(it->data(String::UTF8));
-    }
-    d->value = value;
-  }
-  else
-    value.append(d->value);
-
-  data.append(ByteVector::fromUInt(value.size(), false));
-  data.append(ByteVector::fromUInt(flags, false));
-  data.append(d->key.data(String::Latin1));
-  data.append(ByteVector('\0'));
-  data.append(value);
-
-  return data;
-}

3rdparty/taglib/ape/apeitem.h

@@ -1,226 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2004 by Allan Sandfeld Jensen
-    email                : kde@carewolf.org
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_APEITEM_H
-#define TAGLIB_APEITEM_H
-
-#include "tbytevector.h"
-#include "tstring.h"
-#include "tstringlist.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  namespace APE {
-
-    //! An implementation of APE-items
-
-    /*!
-     * This class provides the features of items in the APEv2 standard.
-     */
-    class TAGLIB_EXPORT Item
-    {
-    public:
-      /*!
-       * Enum of types an Item can have. The value of 3 is reserved.
-       */
-      enum ItemTypes {
-        //! Item contains text information coded in UTF-8
-        Text = 0,
-        //! Item contains binary information
-        Binary = 1,
-        //! Item is a locator of external stored information
-        Locator = 2
-      };
-      /*!
-       * Constructs an empty item.
-       */
-      Item();
-
-      /*!
-       * Constructs a text item with \a key and \a value.
-       */
-      // BIC: Remove this, StringList has a constructor from a single string
-      Item(const String &key, const String &value);
-
-      /*!
-       * Constructs a text item with \a key and \a values.
-       */
-      Item(const String &key, const StringList &values);
-
-      /*!
-       * Constructs an item with \a key and \a value.
-       * If \a binary is true a Binary item will be created, otherwise \a value will be interpreted as text
-       */
-      Item(const String &key, const ByteVector &value, bool binary);
-
-      /*!
-       * Construct an item as a copy of \a item.
-       */
-      Item(const Item &item);
-
-      /*!
-       * Destroys the item.
-       */
-      virtual ~Item();
-
-      /*!
-       * Copies the contents of \a item into this item.
-       */
-      Item &operator=(const Item &item);
-
-      /*!
-       * Exchanges the content of this item by the content of \a item.
-       */
-      void swap(Item &item);
-
-      /*!
-       * Returns the key.
-       */
-      String key() const;
-
-      /*!
-       * Returns the binary value.
-       * If the item type is not \a Binary, always returns an empty ByteVector.
-       */
-      ByteVector binaryData() const;
-
-     /*!
-      * Set the binary value to \a value
-      * The item's type will also be set to \a Binary
-      */
-      void setBinaryData(const ByteVector &value);
-
-#ifndef DO_NOT_DOCUMENT
-      /* Remove in next binary incompatible release */
-      ByteVector value() const;
-#endif
-
-      /*!
-       * Sets the key for the item to \a key.
-       */
-      void setKey(const String &key);
-
-      /*!
-       * Sets the text value of the item to \a value and clears any previous contents.
-       *
-       * \see toString()
-       */
-      void setValue(const String &value);
-
-      /*!
-       * Sets the text value of the item to the list of values in \a value and clears
-       * any previous contents.
-       *
-       * \see toStringList()
-       */
-      void setValues(const StringList &values);
-
-      /*!
-       * Appends \a value to create (or extend) the current list of text values.
-       *
-       * \see toString()
-       */
-      void appendValue(const String &value);
-
-      /*!
-       * Appends \a values to extend the current list of text values.
-       *
-       * \see toStringList()
-       */
-      void appendValues(const StringList &values);
-
-      /*!
-       * Returns the size of the full item.
-       */
-      int size() const;
-
-      /*!
-       * Returns the value as a single string.  In case of multiple strings,
-       * the first is returned.  If the data type is not \a Text, always returns
-       * an empty String.
-       */
-      String toString() const;
-
-#ifndef DO_NOT_DOCUMENT
-      /* Remove in next binary incompatible release */
-      StringList toStringList() const;
-#endif
-
-      /*!
-       * Returns the list of text values.  If the data type is not \a Text, always
-       * returns an empty StringList.
-       */
-      StringList values() const;
-
-      /*!
-       * Render the item to a ByteVector.
-       */
-      ByteVector render() const;
-
-      /*!
-       * Parse the item from the ByteVector \a data.
-       */
-      void parse(const ByteVector& data);
-
-      /*!
-       * Set the item to read-only.
-       */
-      void setReadOnly(bool readOnly);
-
-      /*!
-       * Return true if the item is read-only.
-       */
-      bool isReadOnly() const;
-
-      /*!
-       * Sets the type of the item to \a type.
-       *
-       * \see ItemTypes
-       */
-      void setType(ItemTypes type);
-
-      /*!
-       * Returns the type of the item.
-       */
-      ItemTypes type() const;
-
-      /*!
-       * Returns if the item has any real content.
-       */
-      bool isEmpty() const;
-
-    private:
-      class ItemPrivate;
-      ItemPrivate *d;
-    };
-  }
-
-}
-}
-
-#endif
-
-

3rdparty/taglib/ape/apeproperties.cpp

@@ -1,252 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2010 by Alex Novichkov
-    email                : novichko@atnet.ru
-
-    copyright            : (C) 2006 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
-                           (original WavPack implementation)
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <tstring.h>
-#include <tdebug.h>
-#include <bitset>
-#include "id3v2tag.h"
-#include "apeproperties.h"
-#include "apefile.h"
-#include "apetag.h"
-#include "apefooter.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-class APE::Properties::PropertiesPrivate
-{
-public:
-  PropertiesPrivate() :
-    length(0),
-    bitrate(0),
-    sampleRate(0),
-    channels(0),
-    version(0),
-    bitsPerSample(0),
-    sampleFrames(0) {}
-
-  int length;
-  int bitrate;
-  int sampleRate;
-  int channels;
-  int version;
-  int bitsPerSample;
-  unsigned int sampleFrames;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// public members
-////////////////////////////////////////////////////////////////////////////////
-
-APE::Properties::Properties(File *, ReadStyle style) :
-  AudioProperties(style),
-  d(new PropertiesPrivate())
-{
-  debug("APE::Properties::Properties() -- This constructor is no longer used.");
-}
-
-APE::Properties::Properties(File *file, long streamLength, ReadStyle style) :
-  AudioProperties(style),
-  d(new PropertiesPrivate())
-{
-  read(file, streamLength);
-}
-
-APE::Properties::~Properties()
-{
-  delete d;
-}
-
-int APE::Properties::length() const
-{
-  return lengthInSeconds();
-}
-
-int APE::Properties::lengthInSeconds() const
-{
-  return d->length / 1000;
-}
-
-int APE::Properties::lengthInMilliseconds() const
-{
-  return d->length;
-}
-
-int APE::Properties::bitrate() const
-{
-  return d->bitrate;
-}
-
-int APE::Properties::sampleRate() const
-{
-  return d->sampleRate;
-}
-
-int APE::Properties::channels() const
-{
-  return d->channels;
-}
-
-int APE::Properties::version() const
-{
-  return d->version;
-}
-
-int APE::Properties::bitsPerSample() const
-{
-  return d->bitsPerSample;
-}
-
-unsigned int APE::Properties::sampleFrames() const
-{
-  return d->sampleFrames;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// private members
-////////////////////////////////////////////////////////////////////////////////
-
-namespace
-{
-  int headerVersion(const ByteVector &header)
-  {
-    if(header.size() < 6 || !header.startsWith("MAC "))
-      return -1;
-
-    return header.toUShort(4, false);
-  }
-}
-
-void APE::Properties::read(File *file, long streamLength)
-{
-  // First, we assume that the file pointer is set at the first descriptor.
-  long offset = file->tell();
-  int version = headerVersion(file->readBlock(6));
-
-  // Next, we look for the descriptor.
-  if(version < 0) {
-    offset = file->find("MAC ", offset);
-    file->seek(offset);
-    version = headerVersion(file->readBlock(6));
-  }
-
-  if(version < 0) {
-    debug("APE::Properties::read() -- APE descriptor not found");
-    return;
-  }
-
-  d->version = version;
-
-  if(d->version >= 3980)
-    analyzeCurrent(file);
-  else
-    analyzeOld(file);
-
-  if(d->sampleFrames > 0 && d->sampleRate > 0) {
-    const double length = d->sampleFrames * 1000.0 / d->sampleRate;
-    d->length  = static_cast<int>(length + 0.5);
-    d->bitrate = static_cast<int>(streamLength * 8.0 / length + 0.5);
-  }
-}
-
-void APE::Properties::analyzeCurrent(File *file)
-{
-  // Read the descriptor
-  file->seek(2, File::Current);
-  const ByteVector descriptor = file->readBlock(44);
-  if(descriptor.size() < 44) {
-    debug("APE::Properties::analyzeCurrent() -- descriptor is too short.");
-    return;
-  }
-
-  const unsigned int descriptorBytes = descriptor.toUInt(0, false);
-
-  if((descriptorBytes - 52) > 0)
-    file->seek(descriptorBytes - 52, File::Current);
-
-  // Read the header
-  const ByteVector header = file->readBlock(24);
-  if(header.size() < 24) {
-    debug("APE::Properties::analyzeCurrent() -- MAC header is too short.");
-    return;
-  }
-
-  // Get the APE info
-  d->channels      = header.toShort(18, false);
-  d->sampleRate    = header.toUInt(20, false);
-  d->bitsPerSample = header.toShort(16, false);
-
-  const unsigned int totalFrames = header.toUInt(12, false);
-  if(totalFrames == 0)
-    return;
-
-  const unsigned int blocksPerFrame   = header.toUInt(4, false);
-  const unsigned int finalFrameBlocks = header.toUInt(8, false);
-  d->sampleFrames = (totalFrames - 1) * blocksPerFrame + finalFrameBlocks;
-}
-
-void APE::Properties::analyzeOld(File *file)
-{
-  const ByteVector header = file->readBlock(26);
-  if(header.size() < 26) {
-    debug("APE::Properties::analyzeOld() -- MAC header is too short.");
-    return;
-  }
-
-  const unsigned int totalFrames = header.toUInt(18, false);
-
-  // Fail on 0 length APE files (catches non-finalized APE files)
-  if(totalFrames == 0)
-    return;
-
-  const short compressionLevel = header.toShort(0, false);
-  unsigned int blocksPerFrame;
-  if(d->version >= 3950)
-    blocksPerFrame = 73728 * 4;
-  else if(d->version >= 3900 || (d->version >= 3800 && compressionLevel == 4000))
-    blocksPerFrame = 73728;
-  else
-    blocksPerFrame = 9216;
-
-  // Get the APE info
-  d->channels   = header.toShort(4, false);
-  d->sampleRate = header.toUInt(6, false);
-
-  const unsigned int finalFrameBlocks = header.toUInt(22, false);
-  d->sampleFrames = (totalFrames - 1) * blocksPerFrame + finalFrameBlocks;
-
-  // Get the bit depth from the RIFF-fmt chunk.
-  file->seek(16, File::Current);
-  const ByteVector fmt = file->readBlock(28);
-  if(fmt.size() < 28 || !fmt.startsWith("WAVEfmt ")) {
-    debug("APE::Properties::analyzeOld() -- fmt header is too short.");
-    return;
-  }
-
-  d->bitsPerSample = fmt.toShort(26, false);
-}

3rdparty/taglib/ape/apeproperties.h

@@ -1,145 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2010 by Alex Novichkov
-    email                : novichko@atnet.ru
-
-    copyright            : (C) 2006 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
-                           (original WavPack implementation)
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_APEPROPERTIES_H
-#define TAGLIB_APEPROPERTIES_H
-
-#include "taglib_export.h"
-#include "audioproperties.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  namespace APE {
-
-    class File;
-
-    //! An implementation of audio property reading for APE
-
-    /*!
-     * This reads the data from an APE stream found in the AudioProperties
-     * API.
-     */
-
-    class TAGLIB_EXPORT Properties : public AudioProperties
-    {
-    public:
-      /*!
-       * Create an instance of APE::Properties with the data read from the
-       * APE::File \a file.
-       *
-       * \deprecated
-       */
-      TAGLIB_DEPRECATED Properties(File *file, ReadStyle style = Average);
-
-      /*!
-       * Create an instance of APE::Properties with the data read from the
-       * APE::File \a file.
-       */
-      Properties(File *file, long streamLength, ReadStyle style = Average);
-
-      /*!
-       * Destroys this APE::Properties instance.
-       */
-      virtual ~Properties();
-
-      /*!
-       * Returns the length of the file in seconds.  The length is rounded down to
-       * the nearest whole second.
-       *
-       * \note This method is just an alias of lengthInSeconds().
-       *
-       * \deprecated
-       */
-      TAGLIB_DEPRECATED virtual int length() const;
-
-      /*!
-       * Returns the length of the file in seconds.  The length is rounded down to
-       * the nearest whole second.
-       *
-       * \see lengthInMilliseconds()
-       */
-      // BIC: make virtual
-      int lengthInSeconds() const;
-
-      /*!
-       * Returns the length of the file in milliseconds.
-       *
-       * \see lengthInSeconds()
-       */
-      // BIC: make virtual
-      int lengthInMilliseconds() const;
-
-      /*!
-       * Returns the average bit rate of the file in kb/s.
-       */
-      virtual int bitrate() const;
-
-      /*!
-       * Returns the sample rate in Hz.
-       */
-      virtual int sampleRate() const;
-
-      /*!
-       * Returns the number of audio channels.
-       */
-      virtual int channels() const;
-
-      /*!
-       * Returns the number of bits per audio sample.
-       */
-      int bitsPerSample() const;
-
-      /*!
-       * Returns the total number of audio samples in file.
-       */
-      unsigned int sampleFrames() const;
-
-      /*!
-       * Returns APE version.
-       */
-      int version() const;
-
-    private:
-      Properties(const Properties &);
-      Properties &operator=(const Properties &);
-
-      void read(File *file, long streamLength);
-
-      void analyzeCurrent(File *file);
-      void analyzeOld(File *file);
-
-      class PropertiesPrivate;
-      PropertiesPrivate *d;
-    };
-  }
-}
-}
-
-#endif

3rdparty/taglib/ape/apetag.cpp

@@ -1,437 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2004 by Allan Sandfeld Jensen
-    email                : kde@carewolf.com
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x5130)
-// Sun Studio finds multiple specializations of Map because
-// it considers specializations with and without class types
-// to be different; this define forces Map to use only the
-// specialization with the class keyword.
-#define WANT_CLASS_INSTANTIATION_OF_MAP (1)
-#endif
-
-#include <tfile.h>
-#include <tstring.h>
-#include <tmap.h>
-#include <tpropertymap.h>
-#include <tdebug.h>
-#include <tutils.h>
-
-#include "apetag.h"
-#include "apefooter.h"
-#include "apeitem.h"
-
-using namespace Strawberry_TagLib::TagLib;
-using namespace APE;
-
-namespace
-{
-  const unsigned int MinKeyLength = 2;
-  const unsigned int MaxKeyLength = 255;
-
-  bool isKeyValid(const ByteVector &key)
-  {
-    const char *invalidKeys[] = { "ID3", "TAG", "OGGS", "MP+", 0 };
-
-    // only allow printable ASCII including space (32..126)
-
-    for(ByteVector::ConstIterator it = key.begin(); it != key.end(); ++it) {
-      const int c = static_cast<unsigned char>(*it);
-      if(c < 32 || c > 126)
-        return false;
-    }
-
-    const String upperKey = String(key).upper();
-    for(size_t i = 0; invalidKeys[i] != 0; ++i) {
-      if(upperKey == invalidKeys[i])
-        return false;
-    }
-
-    return true;
-  }
-}
-
-class APE::Tag::TagPrivate
-{
-public:
-  TagPrivate() :
-    file(0),
-    footerLocation(0) {}
-
-  File *file;
-  long footerLocation;
-
-  Footer footer;
-  ItemListMap itemListMap;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// public methods
-////////////////////////////////////////////////////////////////////////////////
-
-APE::Tag::Tag() :
-  Strawberry_TagLib::TagLib::Tag(),
-  d(new TagPrivate())
-{
-}
-
-APE::Tag::Tag(Strawberry_TagLib::TagLib::File *file, long footerLocation) :
-  Strawberry_TagLib::TagLib::Tag(),
-  d(new TagPrivate())
-{
-  d->file = file;
-  d->footerLocation = footerLocation;
-
-  read();
-}
-
-APE::Tag::~Tag()
-{
-  delete d;
-}
-
-ByteVector APE::Tag::fileIdentifier()
-{
-  return ByteVector::fromCString("APETAGEX");
-}
-
-String APE::Tag::title() const
-{
-  if(d->itemListMap["TITLE"].isEmpty())
-    return String();
-  return d->itemListMap["TITLE"].values().toString();
-}
-
-String APE::Tag::artist() const
-{
-  if(d->itemListMap["ARTIST"].isEmpty())
-    return String();
-  return d->itemListMap["ARTIST"].values().toString();
-}
-
-String APE::Tag::album() const
-{
-  if(d->itemListMap["ALBUM"].isEmpty())
-    return String();
-  return d->itemListMap["ALBUM"].values().toString();
-}
-
-String APE::Tag::comment() const
-{
-  if(d->itemListMap["COMMENT"].isEmpty())
-    return String();
-  return d->itemListMap["COMMENT"].values().toString();
-}
-
-String APE::Tag::genre() const
-{
-  if(d->itemListMap["GENRE"].isEmpty())
-    return String();
-  return d->itemListMap["GENRE"].values().toString();
-}
-
-unsigned int APE::Tag::year() const
-{
-  if(d->itemListMap["YEAR"].isEmpty())
-    return 0;
-  return d->itemListMap["YEAR"].toString().toInt();
-}
-
-unsigned int APE::Tag::track() const
-{
-  if(d->itemListMap["TRACK"].isEmpty())
-    return 0;
-  return d->itemListMap["TRACK"].toString().toInt();
-}
-
-void APE::Tag::setTitle(const String &s)
-{
-  addValue("TITLE", s, true);
-}
-
-void APE::Tag::setArtist(const String &s)
-{
-  addValue("ARTIST", s, true);
-}
-
-void APE::Tag::setAlbum(const String &s)
-{
-  addValue("ALBUM", s, true);
-}
-
-void APE::Tag::setComment(const String &s)
-{
-  addValue("COMMENT", s, true);
-}
-
-void APE::Tag::setGenre(const String &s)
-{
-  addValue("GENRE", s, true);
-}
-
-void APE::Tag::setYear(unsigned int i)
-{
-  if(i == 0)
-    removeItem("YEAR");
-  else
-    addValue("YEAR", String::number(i), true);
-}
-
-void APE::Tag::setTrack(unsigned int i)
-{
-  if(i == 0)
-    removeItem("TRACK");
-  else
-    addValue("TRACK", String::number(i), true);
-}
-
-namespace
-{
-  // conversions of tag keys between what we use in PropertyMap and what's usual
-  // for APE tags
-  //                                    usual,         APE
-  const char *keyConversions[][2] =  {{"TRACKNUMBER", "TRACK"       },
-                                      {"DATE",        "YEAR"        },
-                                      {"ALBUMARTIST", "ALBUM ARTIST"},
-                                      {"DISCNUMBER",  "DISC"        },
-                                      {"REMIXER",     "MIXARTIST"   }};
-  const size_t keyConversionsSize = sizeof(keyConversions) / sizeof(keyConversions[0]);
-}
-
-PropertyMap APE::Tag::properties() const
-{
-  PropertyMap properties;
-  ItemListMap::ConstIterator it = itemListMap().begin();
-  for(; it != itemListMap().end(); ++it) {
-    String tagName = it->first.upper();
-    // if the item is Binary or Locator, or if the key is an invalid string,
-    // add to unsupportedData
-    if(it->second.type() != Item::Text || tagName.isEmpty()) {
-      properties.unsupportedData().append(it->first);
-    }
-    else {
-      // Some tags need to be handled specially
-      for(size_t i = 0; i < keyConversionsSize; ++i) {
-        if(tagName == keyConversions[i][1])
-          tagName = keyConversions[i][0];
-      }
-      properties[tagName].append(it->second.toStringList());
-    }
-  }
-  return properties;
-}
-
-void APE::Tag::removeUnsupportedProperties(const StringList &properties)
-{
-  StringList::ConstIterator it = properties.begin();
-  for(; it != properties.end(); ++it)
-    removeItem(*it);
-}
-
-PropertyMap APE::Tag::setProperties(const PropertyMap &origProps)
-{
-  PropertyMap properties(origProps); // make a local copy that can be modified
-
-  // see comment in properties()
-  for(size_t i = 0; i < keyConversionsSize; ++i)
-    if(properties.contains(keyConversions[i][0])) {
-      properties.insert(keyConversions[i][1], properties[keyConversions[i][0]]);
-      properties.erase(keyConversions[i][0]);
-    }
-
-  // first check if tags need to be removed completely
-  StringList toRemove;
-  ItemListMap::ConstIterator remIt = itemListMap().begin();
-  for(; remIt != itemListMap().end(); ++remIt) {
-    String key = remIt->first.upper();
-    // only remove if a) key is valid, b) type is text, c) key not contained in new properties
-    if(!key.isEmpty() && remIt->second.type() == APE::Item::Text && !properties.contains(key))
-      toRemove.append(remIt->first);
-  }
-
-  for(StringList::ConstIterator removeIt = toRemove.begin(); removeIt != toRemove.end(); removeIt++)
-    removeItem(*removeIt);
-
-  // now sync in the "forward direction"
-  PropertyMap::ConstIterator it = properties.begin();
-  PropertyMap invalid;
-  for(; it != properties.end(); ++it) {
-    const String &tagName = it->first;
-    if(!checkKey(tagName))
-      invalid.insert(it->first, it->second);
-    else if(!(itemListMap().contains(tagName)) || !(itemListMap()[tagName].values() == it->second)) {
-      if(it->second.isEmpty())
-        removeItem(tagName);
-      else {
-        StringList::ConstIterator valueIt = it->second.begin();
-        addValue(tagName, *valueIt, true);
-        ++valueIt;
-        for(; valueIt != it->second.end(); ++valueIt)
-          addValue(tagName, *valueIt, false);
-      }
-    }
-  }
-  return invalid;
-}
-
-bool APE::Tag::checkKey(const String &key)
-{
-  if(key.size() < MinKeyLength || key.size() > MaxKeyLength)
-    return false;
-
-  return isKeyValid(key.data(String::UTF8));
-}
-
-APE::Footer *APE::Tag::footer() const
-{
-  return &d->footer;
-}
-
-const APE::ItemListMap& APE::Tag::itemListMap() const
-{
-  return d->itemListMap;
-}
-
-void APE::Tag::removeItem(const String &key)
-{
-  d->itemListMap.erase(key.upper());
-}
-
-void APE::Tag::addValue(const String &key, const String &value, bool replace)
-{
-  if(replace)
-    removeItem(key);
-
-  if(value.isEmpty())
-    return;
-
-  // Text items may contain more than one value.
-  // Binary or locator items may have only one value, hence always replaced.
-
-  ItemListMap::Iterator it = d->itemListMap.find(key.upper());
-
-  if(it != d->itemListMap.end() && it->second.type() == Item::Text)
-    it->second.appendValue(value);
-  else
-    setItem(key, Item(key, value));
-}
-
-void APE::Tag::setData(const String &key, const ByteVector &value)
-{
-  removeItem(key);
-
-  if(value.isEmpty())
-    return;
-
-  setItem(key, Item(key, value, true));
-}
-
-void APE::Tag::setItem(const String &key, const Item &item)
-{
-  if(!checkKey(key)) {
-    debug("APE::Tag::setItem() - Couldn't set an item due to an invalid key.");
-    return;
-  }
-
-  d->itemListMap[key.upper()] = item;
-}
-
-bool APE::Tag::isEmpty() const
-{
-  return d->itemListMap.isEmpty();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// protected methods
-////////////////////////////////////////////////////////////////////////////////
-
-void APE::Tag::read()
-{
-  if(d->file && d->file->isValid()) {
-
-    d->file->seek(d->footerLocation);
-    d->footer.setData(d->file->readBlock(Footer::size()));
-
-    if(d->footer.tagSize() <= Footer::size() ||
-       d->footer.tagSize() > static_cast<unsigned long>(d->file->length()))
-      return;
-
-    d->file->seek(d->footerLocation + Footer::size() - d->footer.tagSize());
-    parse(d->file->readBlock(d->footer.tagSize() - Footer::size()));
-  }
-}
-
-ByteVector APE::Tag::render() const
-{
-  ByteVector data;
-  unsigned int itemCount = 0;
-
-  for(ItemListMap::ConstIterator it = d->itemListMap.begin(); it != d->itemListMap.end(); ++it) {
-    data.append(it->second.render());
-    itemCount++;
-  }
-
-  d->footer.setItemCount(itemCount);
-  d->footer.setTagSize(data.size() + Footer::size());
-  d->footer.setHeaderPresent(true);
-
-  return d->footer.renderHeader() + data + d->footer.renderFooter();
-}
-
-void APE::Tag::parse(const ByteVector &data)
-{
-  // 11 bytes is the minimum size for an APE item
-
-  if(data.size() < 11)
-    return;
-
-  unsigned int pos = 0;
-
-  for(unsigned int i = 0; i < d->footer.itemCount() && pos <= data.size() - 11; i++) {
-
-    const int nullPos = data.find('\0', pos + 8);
-    if(nullPos < 0) {
-      debug("APE::Tag::parse() - Couldn't find a key/value separator. Stopped parsing.");
-      return;
-    }
-
-    const unsigned int keyLength = nullPos - pos - 8;
-    const unsigned int valLegnth = data.toUInt(pos, false);
-
-    if(keyLength >= MinKeyLength
-      && keyLength <= MaxKeyLength
-      && isKeyValid(data.mid(pos + 8, keyLength)))
-    {
-      APE::Item item;
-      item.parse(data.mid(pos));
-
-      d->itemListMap.insert(item.key().upper(), item);
-    }
-    else {
-      debug("APE::Tag::parse() - Skipped an item due to an invalid key.");
-    }
-
-    pos += keyLength + valLegnth + 9;
-  }
-}

3rdparty/taglib/ape/apetag.h

@@ -1,210 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2004 by Allan Sandfeld Jensen
-    email                : kde@carewolf.org
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_APETAG_H
-#define TAGLIB_APETAG_H
-
-#include "tag.h"
-#include "tbytevector.h"
-#include "tmap.h"
-#include "tstring.h"
-#include "taglib_export.h"
-
-#include "apeitem.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  class File;
-
-  //! An implementation of the APE tagging format
-
-  namespace APE {
-
-    class Footer;
-
-    /*!
-     * A mapping between a list of item names, or keys, and the associated item.
-     *
-     * \see APE::Tag::itemListMap()
-     */
-    typedef Map<const String, Item> ItemListMap;
-
-
-    //! An APE tag implementation
-
-    class TAGLIB_EXPORT Tag : public Strawberry_TagLib::TagLib::Tag
-    {
-    public:
-      /*!
-       * Create an APE tag with default values.
-       */
-      Tag();
-
-      /*!
-       * Create an APE tag and parse the data in \a file with APE footer at
-       * \a tagOffset.
-       */
-      Tag(Strawberry_TagLib::TagLib::File *file, long footerLocation);
-
-      /*!
-       * Destroys this Tag instance.
-       */
-      virtual ~Tag();
-
-      /*!
-       * Renders the in memory values to a ByteVector suitable for writing to
-       * the file.
-       */
-      ByteVector render() const;
-
-      /*!
-       * Returns the string "APETAGEX" suitable for usage in locating the tag in a
-       * file.
-       */
-      static ByteVector fileIdentifier();
-
-      // Reimplementations.
-
-      virtual String title() const;
-      virtual String artist() const;
-      virtual String album() const;
-      virtual String comment() const;
-      virtual String genre() const;
-      virtual unsigned int year() const;
-      virtual unsigned int track() const;
-
-      virtual void setTitle(const String &s);
-      virtual void setArtist(const String &s);
-      virtual void setAlbum(const String &s);
-      virtual void setComment(const String &s);
-      virtual void setGenre(const String &s);
-      virtual void setYear(unsigned int i);
-      virtual void setTrack(unsigned int i);
-
-      /*!
-       * Implements the unified tag dictionary interface -- export function.
-       * APE tags are perfectly compatible with the dictionary interface because they
-       * support both arbitrary tag names and multiple values. Currently only
-       * APE items of type *Text* are handled by the dictionary interface; all *Binary*
-       * and *Locator* items will be put into the unsupportedData list and can be
-       * deleted on request using removeUnsupportedProperties(). The same happens
-       * to Text items if their key is invalid for PropertyMap (which should actually
-       * never happen).
-       *
-       * The only conversion done by this export function is to rename the APE tags
-       * TRACK to TRACKNUMBER, YEAR to DATE, and ALBUM ARTIST to ALBUMARTIST, respectively,
-       * in order to be compliant with the names used in other formats.
-       */
-      PropertyMap properties() const;
-
-      void removeUnsupportedProperties(const StringList &properties);
-
-      /*!
-       * Implements the unified tag dictionary interface -- import function. The same
-       * comments as for the export function apply; additionally note that the APE tag
-       * specification requires keys to have between 2 and 16 printable ASCII characters
-       * with the exception of the fixed strings "ID3", "TAG", "OGGS", and "MP+".
-       */
-      PropertyMap setProperties(const PropertyMap &);
-
-      /*!
-       * Check if the given String is a valid APE tag key.
-       */
-      static bool checkKey(const String&);
-
-      /*!
-       * Returns a pointer to the tag's footer.
-       */
-      Footer *footer() const;
-
-      /*!
-       * Returns a reference to the item list map.  This is an ItemListMap of
-       * all of the items in the tag.
-       *
-       * This is the most powerful structure for accessing the items of the tag.
-       *
-       * APE tags are case-insensitive, all keys in this map have been converted
-       * to upper case.
-       *
-       * \warning You should not modify this data structure directly, instead
-       * use setItem() and removeItem().
-       */
-      const ItemListMap &itemListMap() const;
-
-      /*!
-       * Removes the \a key item from the tag
-       */
-      void removeItem(const String &key);
-
-      /*!
-       * Adds to the text item specified by \a key the data \a value.  If \a replace
-       * is true, then all of the other values on the same key will be removed
-       * first.  If a binary item exists for \a key it will be removed first.
-       */
-      void addValue(const String &key, const String &value, bool replace = true);
-
-     /*!
-      * Set the binary data for the key specified by \a item to \a value
-      * This will convert the item to type \a Binary if it isn't already and
-      * all of the other values on the same key will be removed.
-      */
-      void setData(const String &key, const ByteVector &value);
-
-      /*!
-       * Sets the \a key item to the value of \a item. If an item with the \a key is already
-       * present, it will be replaced.
-       */
-      void setItem(const String &key, const Item &item);
-
-      /*!
-       * Returns true if the tag does not contain any data.
-       */
-      bool isEmpty() const;
-
-    protected:
-
-      /*!
-       * Reads from the file specified in the constructor.
-       */
-      void read();
-
-      /*!
-       * Parses the body of the tag in \a data.
-       */
-      void parse(const ByteVector &data);
-
-    private:
-      Tag(const Tag &);
-      Tag &operator=(const Tag &);
-
-      class TagPrivate;
-      TagPrivate *d;
-    };
-  }
-}
-}
-
-#endif

3rdparty/taglib/asf/asfattribute.cpp

@@ -1,351 +0,0 @@
-/**************************************************************************
-    copyright            : (C) 2005-2007 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
- **************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <taglib.h>
-#include <tdebug.h>
-#include <trefcounter.h>
-
-#include "asfattribute.h"
-#include "asffile.h"
-#include "asfutils.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-class ASF::Attribute::AttributePrivate : public RefCounter
-{
-public:
-  AttributePrivate() :
-    pictureValue(ASF::Picture::fromInvalid()),
-    numericValue(0),
-    stream(0),
-    language(0) {}
-  AttributeTypes type;
-  String stringValue;
-  ByteVector byteVectorValue;
-  ASF::Picture pictureValue;
-  unsigned long long numericValue;
-  int stream;
-  int language;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// public members
-////////////////////////////////////////////////////////////////////////////////
-
-ASF::Attribute::Attribute() :
-  d(new AttributePrivate())
-{
-  d->type = UnicodeType;
-}
-
-ASF::Attribute::Attribute(const ASF::Attribute &other) :
-  d(other.d)
-{
-  d->ref();
-}
-
-ASF::Attribute::Attribute(const String &value) :
-  d(new AttributePrivate())
-{
-  d->type = UnicodeType;
-  d->stringValue = value;
-}
-
-ASF::Attribute::Attribute(const ByteVector &value) :
-  d(new AttributePrivate())
-{
-  d->type = BytesType;
-  d->byteVectorValue = value;
-}
-
-ASF::Attribute::Attribute(const ASF::Picture &value) :
-  d(new AttributePrivate())
-{
-  d->type = BytesType;
-  d->pictureValue = value;
-}
-
-ASF::Attribute::Attribute(unsigned int value) :
-  d(new AttributePrivate())
-{
-  d->type = DWordType;
-  d->numericValue = value;
-}
-
-ASF::Attribute::Attribute(unsigned long long value) :
-  d(new AttributePrivate())
-{
-  d->type = QWordType;
-  d->numericValue = value;
-}
-
-ASF::Attribute::Attribute(unsigned short value) :
-  d(new AttributePrivate())
-{
-  d->type = WordType;
-  d->numericValue = value;
-}
-
-ASF::Attribute::Attribute(bool value) :
-  d(new AttributePrivate())
-{
-  d->type = BoolType;
-  d->numericValue = value;
-}
-
-ASF::Attribute &ASF::Attribute::operator=(const ASF::Attribute &other)
-{
-  Attribute(other).swap(*this);
-  return *this;
-}
-
-void ASF::Attribute::swap(Attribute &other)
-{
-  using std::swap;
-
-  swap(d, other.d);
-}
-
-ASF::Attribute::~Attribute()
-{
-  if(d->deref())
-    delete d;
-}
-
-ASF::Attribute::AttributeTypes ASF::Attribute::type() const
-{
-  return d->type;
-}
-
-String ASF::Attribute::toString() const
-{
-  return d->stringValue;
-}
-
-ByteVector ASF::Attribute::toByteVector() const
-{
-  if(d->pictureValue.isValid())
-    return d->pictureValue.render();
-  return d->byteVectorValue;
-}
-
-unsigned short ASF::Attribute::toBool() const
-{
-  return d->numericValue ? 1 : 0;
-}
-
-unsigned short ASF::Attribute::toUShort() const
-{
-  return static_cast<unsigned short>(d->numericValue);
-}
-
-unsigned int ASF::Attribute::toUInt() const
-{
-  return static_cast<unsigned int>(d->numericValue);
-}
-
-unsigned long long ASF::Attribute::toULongLong() const
-{
-  return static_cast<unsigned long long>(d->numericValue);
-}
-
-ASF::Picture ASF::Attribute::toPicture() const
-{
-  return d->pictureValue;
-}
-
-String ASF::Attribute::parse(ASF::File &f, int kind)
-{
-  unsigned int size, nameLength;
-  String name;
-  d->pictureValue = Picture::fromInvalid();
-  // extended content descriptor
-  if(kind == 0) {
-    nameLength = readWORD(&f);
-    name = readString(&f, nameLength);
-    d->type = ASF::Attribute::AttributeTypes(readWORD(&f));
-    size = readWORD(&f);
-  }
-  // metadata & metadata library
-  else {
-    int temp = readWORD(&f);
-    // metadata library
-    if(kind == 2) {
-      d->language = temp;
-    }
-    d->stream = readWORD(&f);
-    nameLength = readWORD(&f);
-    d->type = ASF::Attribute::AttributeTypes(readWORD(&f));
-    size = readDWORD(&f);
-    name = readString(&f, nameLength);
-  }
-
-  if(kind != 2 && size > 65535) {
-    debug("ASF::Attribute::parse() -- Value larger than 64kB");
-  }
-
-  switch(d->type) {
-  case WordType:
-    d->numericValue = readWORD(&f);
-    break;
-
-  case BoolType:
-    if(kind == 0) {
-      d->numericValue = (readDWORD(&f) != 0);
-    }
-    else {
-      d->numericValue = (readWORD(&f) != 0);
-    }
-    break;
-
-  case DWordType:
-    d->numericValue = readDWORD(&f);
-    break;
-
-  case QWordType:
-    d->numericValue = readQWORD(&f);
-    break;
-
-  case UnicodeType:
-    d->stringValue = readString(&f, size);
-    break;
-
-  case BytesType:
-  case GuidType:
-    d->byteVectorValue = f.readBlock(size);
-    break;
-  }
-
-  if(d->type == BytesType && name == "WM/Picture") {
-    d->pictureValue.parse(d->byteVectorValue);
-    if(d->pictureValue.isValid()) {
-      d->byteVectorValue.clear();
-    }
-  }
-
-  return name;
-}
-
-int ASF::Attribute::dataSize() const
-{
-  switch (d->type) {
-  case WordType:
-    return 2;
-  case BoolType:
-    return 4;
-  case DWordType:
-    return 4;
-  case QWordType:
-    return 5;
-  case UnicodeType:
-    return d->stringValue.size() * 2 + 2;
-  case BytesType:
-    if(d->pictureValue.isValid())
-      return d->pictureValue.dataSize();
-  case GuidType:
-    return d->byteVectorValue.size();
-  }
-  return 0;
-}
-
-ByteVector ASF::Attribute::render(const String &name, int kind) const
-{
-  ByteVector data;
-
-  switch (d->type) {
-  case WordType:
-    data.append(ByteVector::fromShort(toUShort(), false));
-    break;
-
-  case BoolType:
-    if(kind == 0) {
-      data.append(ByteVector::fromUInt(toBool(), false));
-    }
-    else {
-      data.append(ByteVector::fromShort(toBool(), false));
-    }
-    break;
-
-  case DWordType:
-    data.append(ByteVector::fromUInt(toUInt(), false));
-    break;
-
-  case QWordType:
-    data.append(ByteVector::fromLongLong(toULongLong(), false));
-    break;
-
-  case UnicodeType:
-    data.append(renderString(d->stringValue));
-    break;
-
-  case BytesType:
-    if(d->pictureValue.isValid()) {
-      data.append(d->pictureValue.render());
-      break;
-    }
-  case GuidType:
-    data.append(d->byteVectorValue);
-    break;
-  }
-
-  if(kind == 0) {
-    data = renderString(name, true) +
-           ByteVector::fromShort((int)d->type, false) +
-           ByteVector::fromShort(data.size(), false) +
-           data;
-  }
-  else {
-    ByteVector nameData = renderString(name);
-    data = ByteVector::fromShort(kind == 2 ? d->language : 0, false) +
-           ByteVector::fromShort(d->stream, false) +
-           ByteVector::fromShort(nameData.size(), false) +
-           ByteVector::fromShort((int)d->type, false) +
-           ByteVector::fromUInt(data.size(), false) +
-           nameData +
-           data;
-  }
-
-  return data;
-}
-
-int ASF::Attribute::language() const
-{
-  return d->language;
-}
-
-void ASF::Attribute::setLanguage(int value)
-{
-  d->language = value;
-}
-
-int ASF::Attribute::stream() const
-{
-  return d->stream;
-}
-
-void ASF::Attribute::setStream(int value)
-{
-  d->stream = value;
-}

3rdparty/taglib/asf/asfattribute.h

@@ -1,210 +0,0 @@
-/**************************************************************************
-    copyright            : (C) 2005-2007 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
- **************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_ASFATTRIBUTE_H
-#define TAGLIB_ASFATTRIBUTE_H
-
-#include "tstring.h"
-#include "tbytevector.h"
-#include "taglib_export.h"
-#include "asfpicture.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib
-{
-
-  namespace ASF
-  {
-
-    class File;
-    class Picture;
-
-    class TAGLIB_EXPORT Attribute
-    {
-    public:
-
-      /*!
-       * Enum of types an Attribute can have.
-       */
-      enum AttributeTypes {
-        UnicodeType = 0,
-        BytesType   = 1,
-        BoolType    = 2,
-        DWordType   = 3,
-        QWordType   = 4,
-        WordType    = 5,
-        GuidType    = 6
-      };
-
-      /*!
-       * Constructs an empty attribute.
-       */
-      Attribute();
-
-      /*!
-       * Constructs an attribute with \a key and a UnicodeType \a value.
-       */
-      Attribute(const String &value);
-
-      /*!
-       * Constructs an attribute with \a key and a BytesType \a value.
-       */
-      Attribute(const ByteVector &value);
-
-      /*!
-       * Constructs an attribute with \a key and a Picture \a value.
-       *
-       * This attribute is compatible with the ID3 frame, APIC. The ID3 specification for the APIC frame stipulates that,
-       * while there may be any number of APIC frames associated with a file,
-       * only one may be of type 1 and only one may be of type 2.
-       *
-       * The specification also states that the description of the picture can be no longer than 64 characters, but can be empty.
-       * WM/Picture attributes added with TagLib::ASF are not automatically validated to conform to ID3 specifications.
-       * You must add code in your application to perform validations if you want to maintain complete compatibility with ID3.
-       */
-      Attribute(const Picture &value);
-
-      /*!
-       * Constructs an attribute with \a key and a DWordType \a value.
-       */
-      Attribute(unsigned int value);
-
-      /*!
-       * Constructs an attribute with \a key and a QWordType \a value.
-       */
-      Attribute(unsigned long long value);
-
-      /*!
-       * Constructs an attribute with \a key and a WordType \a value.
-       */
-      Attribute(unsigned short value);
-
-      /*!
-       * Constructs an attribute with \a key and a BoolType \a value.
-       */
-      Attribute(bool value);
-
-      /*!
-       * Construct an attribute as a copy of \a other.
-       */
-      Attribute(const Attribute &item);
-
-      /*!
-       * Copies the contents of \a other into this item.
-       */
-      Attribute &operator=(const Attribute &other);
-
-      /*!
-       * Exchanges the content of the Attribute by the content of \a other.
-       */
-      void swap(Attribute &other);
-
-      /*!
-       * Destroys the attribute.
-       */
-      virtual ~Attribute();
-
-      /*!
-       * Returns type of the value.
-       */
-      AttributeTypes type() const;
-
-      /*!
-       * Returns the BoolType \a value.
-       */
-      unsigned short toBool() const;
-
-      /*!
-       * Returns the WordType \a value.
-       */
-      unsigned short toUShort() const;
-
-      /*!
-       * Returns the DWordType \a value.
-       */
-      unsigned int toUInt() const;
-
-      /*!
-       * Returns the QWordType \a value.
-       */
-      unsigned long long toULongLong() const;
-
-      /*!
-       * Returns the UnicodeType \a value.
-       */
-      String toString() const;
-
-      /*!
-       * Returns the BytesType \a value.
-       */
-      ByteVector toByteVector() const;
-
-      /*!
-       * Returns the Picture \a value.
-       */
-      Picture toPicture() const;
-
-      /*!
-       * Returns the language number, or 0 is no stream number was set.
-       */
-      int language() const;
-
-      /*!
-       * Sets the language number.
-       */
-      void setLanguage(int value);
-
-      /*!
-       * Returns the stream number, or 0 is no stream number was set.
-       */
-      int stream() const;
-
-      /*!
-       * Sets the stream number.
-       */
-      void setStream(int value);
-
-#ifndef DO_NOT_DOCUMENT
-      /* THIS IS PRIVATE, DON'T TOUCH IT! */
-      String parse(ASF::File &file, int kind = 0);
-#endif
-
-      //! Returns the size of the stored data
-      int dataSize() const;
-
-    private:
-      friend class File;
-
-      ByteVector render(const String &name, int kind = 0) const;
-
-      class AttributePrivate;
-      AttributePrivate *d;
-    };
-  }
-
-}
-}
-
-#endif

3rdparty/taglib/asf/asffile.cpp

@@ -1,705 +0,0 @@
-/**************************************************************************
-    copyright            : (C) 2005-2007 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
- **************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <tdebug.h>
-#include <tbytevectorlist.h>
-#include <tpropertymap.h>
-#include <tstring.h>
-#include <tagutils.h>
-
-#include "asffile.h"
-#include "asftag.h"
-#include "asfproperties.h"
-#include "asfutils.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-class ASF::File::FilePrivate
-{
-public:
-  class BaseObject;
-  class UnknownObject;
-  class FilePropertiesObject;
-  class StreamPropertiesObject;
-  class ContentDescriptionObject;
-  class ExtendedContentDescriptionObject;
-  class HeaderExtensionObject;
-  class CodecListObject;
-  class MetadataObject;
-  class MetadataLibraryObject;
-
-  FilePrivate():
-    headerSize(0),
-    tag(0),
-    properties(0),
-    contentDescriptionObject(0),
-    extendedContentDescriptionObject(0),
-    headerExtensionObject(0),
-    metadataObject(0),
-    metadataLibraryObject(0)
-  {
-    objects.setAutoDelete(true);
-  }
-
-  ~FilePrivate()
-  {
-    delete tag;
-    delete properties;
-  }
-
-  unsigned long long headerSize;
-
-  ASF::Tag *tag;
-  ASF::Properties *properties;
-
-  List<BaseObject *> objects;
-
-  ContentDescriptionObject         *contentDescriptionObject;
-  ExtendedContentDescriptionObject *extendedContentDescriptionObject;
-  HeaderExtensionObject            *headerExtensionObject;
-  MetadataObject                   *metadataObject;
-  MetadataLibraryObject            *metadataLibraryObject;
-};
-
-namespace
-{
-  const ByteVector headerGuid("\x30\x26\xB2\x75\x8E\x66\xCF\x11\xA6\xD9\x00\xAA\x00\x62\xCE\x6C", 16);
-  const ByteVector filePropertiesGuid("\xA1\xDC\xAB\x8C\x47\xA9\xCF\x11\x8E\xE4\x00\xC0\x0C\x20\x53\x65", 16);
-  const ByteVector streamPropertiesGuid("\x91\x07\xDC\xB7\xB7\xA9\xCF\x11\x8E\xE6\x00\xC0\x0C\x20\x53\x65", 16);
-  const ByteVector contentDescriptionGuid("\x33\x26\xB2\x75\x8E\x66\xCF\x11\xA6\xD9\x00\xAA\x00\x62\xCE\x6C", 16);
-  const ByteVector extendedContentDescriptionGuid("\x40\xA4\xD0\xD2\x07\xE3\xD2\x11\x97\xF0\x00\xA0\xC9\x5E\xA8\x50", 16);
-  const ByteVector headerExtensionGuid("\xb5\x03\xbf_.\xa9\xcf\x11\x8e\xe3\x00\xc0\x0c Se", 16);
-  const ByteVector metadataGuid("\xEA\xCB\xF8\xC5\xAF[wH\204g\xAA\214D\xFAL\xCA", 16);
-  const ByteVector metadataLibraryGuid("\224\034#D\230\224\321I\241A\x1d\x13NEpT", 16);
-  const ByteVector codecListGuid("\x40\x52\xd1\x86\x1d\x31\xd0\x11\xa3\xa4\x00\xa0\xc9\x03\x48\xf6", 16);
-  const ByteVector contentEncryptionGuid("\xFB\xB3\x11\x22\x23\xBD\xD2\x11\xB4\xB7\x00\xA0\xC9\x55\xFC\x6E", 16);
-  const ByteVector extendedContentEncryptionGuid("\x14\xE6\x8A\x29\x22\x26 \x17\x4C\xB9\x35\xDA\xE0\x7E\xE9\x28\x9C", 16);
-  const ByteVector advancedContentEncryptionGuid("\xB6\x9B\x07\x7A\xA4\xDA\x12\x4E\xA5\xCA\x91\xD3\x8D\xC1\x1A\x8D", 16);
-}
-
-class ASF::File::FilePrivate::BaseObject
-{
-public:
-  ByteVector data;
-  virtual ~BaseObject() {}
-  virtual ByteVector guid() const = 0;
-  virtual void parse(ASF::File *file, unsigned int size);
-  virtual ByteVector render(ASF::File *file);
-};
-
-class ASF::File::FilePrivate::UnknownObject : public ASF::File::FilePrivate::BaseObject
-{
-  ByteVector myGuid;
-public:
-  explicit UnknownObject(const ByteVector &guid);
-  ByteVector guid() const;
-};
-
-class ASF::File::FilePrivate::FilePropertiesObject : public ASF::File::FilePrivate::BaseObject
-{
-public:
-  ByteVector guid() const;
-  void parse(ASF::File *file, unsigned int size);
-};
-
-class ASF::File::FilePrivate::StreamPropertiesObject : public ASF::File::FilePrivate::BaseObject
-{
-public:
-  ByteVector guid() const;
-  void parse(ASF::File *file, unsigned int size);
-};
-
-class ASF::File::FilePrivate::ContentDescriptionObject : public ASF::File::FilePrivate::BaseObject
-{
-public:
-  ByteVector guid() const;
-  void parse(ASF::File *file, unsigned int size);
-  ByteVector render(ASF::File *file);
-};
-
-class ASF::File::FilePrivate::ExtendedContentDescriptionObject : public ASF::File::FilePrivate::BaseObject
-{
-public:
-  ByteVectorList attributeData;
-  ByteVector guid() const;
-  void parse(ASF::File *file, unsigned int size);
-  ByteVector render(ASF::File *file);
-};
-
-class ASF::File::FilePrivate::MetadataObject : public ASF::File::FilePrivate::BaseObject
-{
-public:
-  ByteVectorList attributeData;
-  ByteVector guid() const;
-  void parse(ASF::File *file, unsigned int size);
-  ByteVector render(ASF::File *file);
-};
-
-class ASF::File::FilePrivate::MetadataLibraryObject : public ASF::File::FilePrivate::BaseObject
-{
-public:
-  ByteVectorList attributeData;
-  ByteVector guid() const;
-  void parse(ASF::File *file, unsigned int size);
-  ByteVector render(ASF::File *file);
-};
-
-class ASF::File::FilePrivate::HeaderExtensionObject : public ASF::File::FilePrivate::BaseObject
-{
-public:
-  List<ASF::File::FilePrivate::BaseObject *> objects;
-  HeaderExtensionObject();
-  ByteVector guid() const;
-  void parse(ASF::File *file, unsigned int size);
-  ByteVector render(ASF::File *file);
-};
-
-class ASF::File::FilePrivate::CodecListObject : public ASF::File::FilePrivate::BaseObject
-{
-public:
-  ByteVector guid() const;
-  void parse(ASF::File *file, unsigned int size);
-
-private:
-  enum CodecType
-  {
-    Video   = 0x0001,
-    Audio   = 0x0002,
-    Unknown = 0xFFFF
-  };
-};
-
-void ASF::File::FilePrivate::BaseObject::parse(ASF::File *file, unsigned int size)
-{
-  data.clear();
-  if(size > 24 && size <= (unsigned int)(file->length()))
-    data = file->readBlock(size - 24);
-  else
-    data = ByteVector();
-}
-
-ByteVector ASF::File::FilePrivate::BaseObject::render(ASF::File * /*file*/)
-{
-  return guid() + ByteVector::fromLongLong(data.size() + 24, false) + data;
-}
-
-ASF::File::FilePrivate::UnknownObject::UnknownObject(const ByteVector &guid) : myGuid(guid)
-{
-}
-
-ByteVector ASF::File::FilePrivate::UnknownObject::guid() const
-{
-  return myGuid;
-}
-
-ByteVector ASF::File::FilePrivate::FilePropertiesObject::guid() const
-{
-  return filePropertiesGuid;
-}
-
-void ASF::File::FilePrivate::FilePropertiesObject::parse(ASF::File *file, unsigned int size)
-{
-  BaseObject::parse(file, size);
-  if(data.size() < 64) {
-    debug("ASF::File::FilePrivate::FilePropertiesObject::parse() -- data is too short.");
-    return;
-  }
-
-  const long long duration = data.toLongLong(40, false);
-  const long long preroll  = data.toLongLong(56, false);
-  file->d->properties->setLengthInMilliseconds(static_cast<int>(duration / 10000.0 - preroll + 0.5));
-}
-
-ByteVector ASF::File::FilePrivate::StreamPropertiesObject::guid() const
-{
-  return streamPropertiesGuid;
-}
-
-void ASF::File::FilePrivate::StreamPropertiesObject::parse(ASF::File *file, unsigned int size)
-{
-  BaseObject::parse(file, size);
-  if(data.size() < 70) {
-    debug("ASF::File::FilePrivate::StreamPropertiesObject::parse() -- data is too short.");
-    return;
-  }
-
-  file->d->properties->setCodec(data.toUShort(54, false));
-  file->d->properties->setChannels(data.toUShort(56, false));
-  file->d->properties->setSampleRate(data.toUInt(58, false));
-  file->d->properties->setBitrate(static_cast<int>(data.toUInt(62, false) * 8.0 / 1000.0 + 0.5));
-  file->d->properties->setBitsPerSample(data.toUShort(68, false));
-}
-
-ByteVector ASF::File::FilePrivate::ContentDescriptionObject::guid() const
-{
-  return contentDescriptionGuid;
-}
-
-void ASF::File::FilePrivate::ContentDescriptionObject::parse(ASF::File *file, unsigned int /*size*/)
-{
-  const int titleLength     = readWORD(file);
-  const int artistLength    = readWORD(file);
-  const int copyrightLength = readWORD(file);
-  const int commentLength   = readWORD(file);
-  const int ratingLength    = readWORD(file);
-  file->d->tag->setTitle(readString(file,titleLength));
-  file->d->tag->setArtist(readString(file,artistLength));
-  file->d->tag->setCopyright(readString(file,copyrightLength));
-  file->d->tag->setComment(readString(file,commentLength));
-  file->d->tag->setRating(readString(file,ratingLength));
-}
-
-ByteVector ASF::File::FilePrivate::ContentDescriptionObject::render(ASF::File *file)
-{
-  const ByteVector v1 = renderString(file->d->tag->title());
-  const ByteVector v2 = renderString(file->d->tag->artist());
-  const ByteVector v3 = renderString(file->d->tag->copyright());
-  const ByteVector v4 = renderString(file->d->tag->comment());
-  const ByteVector v5 = renderString(file->d->tag->rating());
-  data.clear();
-  data.append(ByteVector::fromShort(v1.size(), false));
-  data.append(ByteVector::fromShort(v2.size(), false));
-  data.append(ByteVector::fromShort(v3.size(), false));
-  data.append(ByteVector::fromShort(v4.size(), false));
-  data.append(ByteVector::fromShort(v5.size(), false));
-  data.append(v1);
-  data.append(v2);
-  data.append(v3);
-  data.append(v4);
-  data.append(v5);
-  return BaseObject::render(file);
-}
-
-ByteVector ASF::File::FilePrivate::ExtendedContentDescriptionObject::guid() const
-{
-  return extendedContentDescriptionGuid;
-}
-
-void ASF::File::FilePrivate::ExtendedContentDescriptionObject::parse(ASF::File *file, unsigned int /*size*/)
-{
-  int count = readWORD(file);
-  while(count--) {
-    ASF::Attribute attribute;
-    String name = attribute.parse(*file);
-    file->d->tag->addAttribute(name, attribute);
-  }
-}
-
-ByteVector ASF::File::FilePrivate::ExtendedContentDescriptionObject::render(ASF::File *file)
-{
-  data.clear();
-  data.append(ByteVector::fromShort(attributeData.size(), false));
-  data.append(attributeData.toByteVector(""));
-  return BaseObject::render(file);
-}
-
-ByteVector ASF::File::FilePrivate::MetadataObject::guid() const
-{
-  return metadataGuid;
-}
-
-void ASF::File::FilePrivate::MetadataObject::parse(ASF::File *file, unsigned int /*size*/)
-{
-  int count = readWORD(file);
-  while(count--) {
-    ASF::Attribute attribute;
-    String name = attribute.parse(*file, 1);
-    file->d->tag->addAttribute(name, attribute);
-  }
-}
-
-ByteVector ASF::File::FilePrivate::MetadataObject::render(ASF::File *file)
-{
-  data.clear();
-  data.append(ByteVector::fromShort(attributeData.size(), false));
-  data.append(attributeData.toByteVector(""));
-  return BaseObject::render(file);
-}
-
-ByteVector ASF::File::FilePrivate::MetadataLibraryObject::guid() const
-{
-  return metadataLibraryGuid;
-}
-
-void ASF::File::FilePrivate::MetadataLibraryObject::parse(ASF::File *file, unsigned int /*size*/)
-{
-  int count = readWORD(file);
-  while(count--) {
-    ASF::Attribute attribute;
-    String name = attribute.parse(*file, 2);
-    file->d->tag->addAttribute(name, attribute);
-  }
-}
-
-ByteVector ASF::File::FilePrivate::MetadataLibraryObject::render(ASF::File *file)
-{
-  data.clear();
-  data.append(ByteVector::fromShort(attributeData.size(), false));
-  data.append(attributeData.toByteVector(""));
-  return BaseObject::render(file);
-}
-
-ASF::File::FilePrivate::HeaderExtensionObject::HeaderExtensionObject()
-{
-  objects.setAutoDelete(true);
-}
-
-ByteVector ASF::File::FilePrivate::HeaderExtensionObject::guid() const
-{
-  return headerExtensionGuid;
-}
-
-void ASF::File::FilePrivate::HeaderExtensionObject::parse(ASF::File *file, unsigned int /*size*/)
-{
-  file->seek(18, File::Current);
-  long long dataSize = readDWORD(file);
-  long long dataPos = 0;
-  while(dataPos < dataSize) {
-    ByteVector guid = file->readBlock(16);
-    if(guid.size() != 16) {
-      file->setValid(false);
-      break;
-    }
-    bool ok;
-    long long size = readQWORD(file, &ok);
-    if(!ok) {
-      file->setValid(false);
-      break;
-    }
-    BaseObject *obj;
-    if(guid == metadataGuid) {
-      file->d->metadataObject = new MetadataObject();
-      obj = file->d->metadataObject;
-    }
-    else if(guid == metadataLibraryGuid) {
-      file->d->metadataLibraryObject = new MetadataLibraryObject();
-      obj = file->d->metadataLibraryObject;
-    }
-    else {
-      obj = new UnknownObject(guid);
-    }
-    obj->parse(file, (unsigned int)size);
-    objects.append(obj);
-    dataPos += size;
-  }
-}
-
-ByteVector ASF::File::FilePrivate::HeaderExtensionObject::render(ASF::File *file)
-{
-  data.clear();
-  for(List<BaseObject *>::ConstIterator it = objects.begin(); it != objects.end(); ++it) {
-    data.append((*it)->render(file));
-  }
-  data = ByteVector("\x11\xD2\xD3\xAB\xBA\xA9\xcf\x11\x8E\xE6\x00\xC0\x0C\x20\x53\x65\x06\x00", 18) + ByteVector::fromUInt(data.size(), false) + data;
-  return BaseObject::render(file);
-}
-
-ByteVector ASF::File::FilePrivate::CodecListObject::guid() const
-{
-  return codecListGuid;
-}
-
-void ASF::File::FilePrivate::CodecListObject::parse(ASF::File *file, unsigned int size)
-{
-  BaseObject::parse(file, size);
-  if(data.size() <= 20) {
-    debug("ASF::File::FilePrivate::CodecListObject::parse() -- data is too short.");
-    return;
-  }
-
-  unsigned int pos = 16;
-
-  const int count = data.toUInt(pos, false);
-  pos += 4;
-
-  for(int i = 0; i < count; ++i) {
-
-    if(pos >= data.size())
-      break;
-
-    const CodecType type = static_cast<CodecType>(data.toUShort(pos, false));
-    pos += 2;
-
-    int nameLength = data.toUShort(pos, false);
-    pos += 2;
-
-    const unsigned int namePos = pos;
-    pos += nameLength * 2;
-
-    const int descLength = data.toUShort(pos, false);
-    pos += 2;
-
-    const unsigned int descPos = pos;
-    pos += descLength * 2;
-
-    const int infoLength = data.toUShort(pos, false);
-    pos += 2 + infoLength * 2;
-
-    if(type == CodecListObject::Audio) {
-      // First audio codec found.
-
-      const String name(data.mid(namePos, nameLength * 2), String::UTF16LE);
-      file->d->properties->setCodecName(name.stripWhiteSpace());
-
-      const String desc(data.mid(descPos, descLength * 2), String::UTF16LE);
-      file->d->properties->setCodecDescription(desc.stripWhiteSpace());
-
-      break;
-    }
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// static members
-////////////////////////////////////////////////////////////////////////////////
-
-bool ASF::File::isSupported(IOStream *stream)
-{
-  // An ASF file has to start with the designated GUID.
-
-  const ByteVector id = Utils::readHeader(stream, 16, false);
-  return (id == headerGuid);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// public members
-////////////////////////////////////////////////////////////////////////////////
-
-ASF::File::File(FileName file, bool, Properties::ReadStyle) :
-  Strawberry_TagLib::TagLib::File(file),
-  d(new FilePrivate())
-{
-  if(isOpen())
-    read();
-}
-
-ASF::File::File(IOStream *stream, bool, Properties::ReadStyle) :
-  Strawberry_TagLib::TagLib::File(stream),
-  d(new FilePrivate())
-{
-  if(isOpen())
-    read();
-}
-
-ASF::File::~File()
-{
-  delete d;
-}
-
-ASF::Tag *ASF::File::tag() const
-{
-  return d->tag;
-}
-
-PropertyMap ASF::File::properties() const
-{
-  return d->tag->properties();
-}
-
-void ASF::File::removeUnsupportedProperties(const StringList &properties)
-{
-  d->tag->removeUnsupportedProperties(properties);
-}
-
-PropertyMap ASF::File::setProperties(const PropertyMap &properties)
-{
-  return d->tag->setProperties(properties);
-}
-
-ASF::Properties *ASF::File::audioProperties() const
-{
-  return d->properties;
-}
-
-bool ASF::File::save()
-{
-  if(readOnly()) {
-    debug("ASF::File::save() -- File is read only.");
-    return false;
-  }
-
-  if(!isValid()) {
-    debug("ASF::File::save() -- Trying to save invalid file.");
-    return false;
-  }
-
-  if(!d->contentDescriptionObject) {
-    d->contentDescriptionObject = new FilePrivate::ContentDescriptionObject();
-    d->objects.append(d->contentDescriptionObject);
-  }
-  if(!d->extendedContentDescriptionObject) {
-    d->extendedContentDescriptionObject = new FilePrivate::ExtendedContentDescriptionObject();
-    d->objects.append(d->extendedContentDescriptionObject);
-  }
-  if(!d->headerExtensionObject) {
-    d->headerExtensionObject = new FilePrivate::HeaderExtensionObject();
-    d->objects.append(d->headerExtensionObject);
-  }
-  if(!d->metadataObject) {
-    d->metadataObject = new FilePrivate::MetadataObject();
-    d->headerExtensionObject->objects.append(d->metadataObject);
-  }
-  if(!d->metadataLibraryObject) {
-    d->metadataLibraryObject = new FilePrivate::MetadataLibraryObject();
-    d->headerExtensionObject->objects.append(d->metadataLibraryObject);
-  }
-
-  d->extendedContentDescriptionObject->attributeData.clear();
-  d->metadataObject->attributeData.clear();
-  d->metadataLibraryObject->attributeData.clear();
-
-  const AttributeListMap allAttributes = d->tag->attributeListMap();
-
-  for(AttributeListMap::ConstIterator it = allAttributes.begin(); it != allAttributes.end(); ++it) {
-
-    const String &name = it->first;
-    const AttributeList &attributes = it->second;
-
-    bool inExtendedContentDescriptionObject = false;
-    bool inMetadataObject = false;
-
-    for(AttributeList::ConstIterator jt = attributes.begin(); jt != attributes.end(); ++jt) {
-
-      const Attribute &attribute = *jt;
-      const bool largeValue = (attribute.dataSize() > 65535);
-      const bool guid       = (attribute.type() == Attribute::GuidType);
-
-      if(!inExtendedContentDescriptionObject && !guid && !largeValue && attribute.language() == 0 && attribute.stream() == 0) {
-        d->extendedContentDescriptionObject->attributeData.append(attribute.render(name));
-        inExtendedContentDescriptionObject = true;
-      }
-      else if(!inMetadataObject && !guid && !largeValue && attribute.language() == 0 && attribute.stream() != 0) {
-        d->metadataObject->attributeData.append(attribute.render(name, 1));
-        inMetadataObject = true;
-      }
-      else {
-        d->metadataLibraryObject->attributeData.append(attribute.render(name, 2));
-      }
-    }
-  }
-
-  ByteVector data;
-  for(List<FilePrivate::BaseObject *>::ConstIterator it = d->objects.begin(); it != d->objects.end(); ++it) {
-    data.append((*it)->render(this));
-  }
-
-  seek(16);
-  writeBlock(ByteVector::fromLongLong(data.size() + 30, false));
-  writeBlock(ByteVector::fromUInt(d->objects.size(), false));
-  writeBlock(ByteVector("\x01\x02", 2));
-
-  insert(data, 30, static_cast<unsigned long>(d->headerSize - 30));
-
-  d->headerSize = data.size() + 30;
-
-  return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// private members
-////////////////////////////////////////////////////////////////////////////////
-
-void ASF::File::read()
-{
-  if(!isValid())
-    return;
-
-  if(readBlock(16) != headerGuid) {
-    debug("ASF::File::read(): Not an ASF file.");
-    setValid(false);
-    return;
-  }
-
-  d->tag = new ASF::Tag();
-  d->properties = new ASF::Properties();
-
-  bool ok;
-  d->headerSize = readQWORD(this, &ok);
-  if(!ok) {
-    setValid(false);
-    return;
-  }
-  int numObjects = readDWORD(this, &ok);
-  if(!ok) {
-    setValid(false);
-    return;
-  }
-  seek(2, Current);
-
-  FilePrivate::FilePropertiesObject   *filePropertiesObject   = 0;
-  FilePrivate::StreamPropertiesObject *streamPropertiesObject = 0;
-  for(int i = 0; i < numObjects; i++) {
-    const ByteVector guid = readBlock(16);
-    if(guid.size() != 16) {
-      setValid(false);
-      break;
-    }
-    long size = (long)readQWORD(this, &ok);
-    if(!ok) {
-      setValid(false);
-      break;
-    }
-    FilePrivate::BaseObject *obj;
-    if(guid == filePropertiesGuid) {
-      filePropertiesObject = new FilePrivate::FilePropertiesObject();
-      obj = filePropertiesObject;
-    }
-    else if(guid == streamPropertiesGuid) {
-      streamPropertiesObject = new FilePrivate::StreamPropertiesObject();
-      obj = streamPropertiesObject;
-    }
-    else if(guid == contentDescriptionGuid) {
-      d->contentDescriptionObject = new FilePrivate::ContentDescriptionObject();
-      obj = d->contentDescriptionObject;
-    }
-    else if(guid == extendedContentDescriptionGuid) {
-      d->extendedContentDescriptionObject = new FilePrivate::ExtendedContentDescriptionObject();
-      obj = d->extendedContentDescriptionObject;
-    }
-    else if(guid == headerExtensionGuid) {
-      d->headerExtensionObject = new FilePrivate::HeaderExtensionObject();
-      obj = d->headerExtensionObject;
-    }
-    else if(guid == codecListGuid) {
-      obj = new FilePrivate::CodecListObject();
-    }
-    else {
-      if(guid == contentEncryptionGuid ||
-         guid == extendedContentEncryptionGuid ||
-         guid == advancedContentEncryptionGuid) {
-        d->properties->setEncrypted(true);
-      }
-      obj = new FilePrivate::UnknownObject(guid);
-    }
-    obj->parse(this, size);
-    d->objects.append(obj);
-  }
-
-  if(!filePropertiesObject || !streamPropertiesObject) {
-    debug("ASF::File::read(): Missing mandatory header objects.");
-    setValid(false);
-    return;
-  }
-}

3rdparty/taglib/asf/asffile.h

@@ -1,140 +0,0 @@
-/**************************************************************************
-    copyright            : (C) 2005-2007 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
- **************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_ASFFILE_H
-#define TAGLIB_ASFFILE_H
-
-#include "tag.h"
-#include "tfile.h"
-#include "taglib_export.h"
-#include "asfproperties.h"
-#include "asftag.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  //! An implementation of ASF (WMA) metadata
-  namespace ASF {
-
-    /*!
-     * This implements and provides an interface for ASF files to the
-     * TagLib::Tag and TagLib::AudioProperties interfaces by way of implementing
-     * the abstract TagLib::File API as well as providing some additional
-     * information specific to ASF files.
-     */
-    class TAGLIB_EXPORT File : public Strawberry_TagLib::TagLib::File
-    {
-    public:
-
-      /*!
-       * Constructs an ASF file from \a file.
-       *
-       * \note In the current implementation, both \a readProperties and
-       * \a propertiesStyle are ignored.  The audio properties are always
-       * read.
-       */
-      File(FileName file, bool readProperties = true,
-           Properties::ReadStyle propertiesStyle = Properties::Average);
-
-      /*!
-       * Constructs an ASF file from \a stream.
-       *
-       * \note In the current implementation, both \a readProperties and
-       * \a propertiesStyle are ignored.  The audio properties are always
-       * read.
-       *
-       * \note TagLib will *not* take ownership of the stream, the caller is
-       * responsible for deleting it after the File object.
-       */
-      File(IOStream *stream, bool readProperties = true,
-           Properties::ReadStyle propertiesStyle = Properties::Average);
-
-      /*!
-       * Destroys this instance of the File.
-       */
-      virtual ~File();
-
-      /*!
-       * Returns a pointer to the ASF tag of the file.
-       *
-       * ASF::Tag implements the tag interface, so this serves as the
-       * reimplementation of TagLib::File::tag().
-       *
-       * \note The Tag <b>is still</b> owned by the ASF::File and should not be
-       * deleted by the user.  It will be deleted when the file (object) is
-       * destroyed.
-       */
-      virtual Tag *tag() const;
-
-      /*!
-       * Implements the unified property interface -- export function.
-       */
-      PropertyMap properties() const;
-
-      /*!
-       * Removes unsupported properties. Forwards to the actual Tag's
-       * removeUnsupportedProperties() function.
-       */
-      void removeUnsupportedProperties(const StringList &properties);
-
-      /*!
-       * Implements the unified property interface -- import function.
-       */
-      PropertyMap setProperties(const PropertyMap &);
-
-      /*!
-       * Returns the ASF audio properties for this file.
-       */
-      virtual Properties *audioProperties() const;
-
-      /*!
-       * Save the file.
-       *
-       * This returns true if the save was successful.
-       */
-      virtual bool save();
-
-      /*!
-       * Returns whether or not the given \a stream can be opened as an ASF
-       * file.
-       *
-       * \note This method is designed to do a quick check.  The result may
-       * not necessarily be correct.
-       */
-      static bool isSupported(IOStream *stream);
-
-    private:
-      void read();
-
-      class FilePrivate;
-      FilePrivate *d;
-    };
-
-  }
-
-}
-}
-
-#endif

3rdparty/taglib/asf/asfpicture.cpp

@@ -1,183 +0,0 @@
-/**************************************************************************
-    copyright            : (C) 2010 by Anton Sergunov
-    email                : setosha@gmail.com
- **************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <taglib.h>
-#include <tdebug.h>
-#include <trefcounter.h>
-
-#include "asfattribute.h"
-#include "asffile.h"
-#include "asfpicture.h"
-#include "asfutils.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-class ASF::Picture::PicturePrivate : public RefCounter
-{
-public:
-  bool valid;
-  Type type;
-  String mimeType;
-  String description;
-  ByteVector picture;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// Picture class members
-////////////////////////////////////////////////////////////////////////////////
-
-ASF::Picture::Picture() :
-  d(new PicturePrivate())
-{
-  d->valid = true;
-}
-
-ASF::Picture::Picture(const Picture& other) :
-  d(other.d)
-{
-  d->ref();
-}
-
-ASF::Picture::~Picture()
-{
-  if(d->deref())
-    delete d;
-}
-
-bool ASF::Picture::isValid() const
-{
-  return d->valid;
-}
-
-String ASF::Picture::mimeType() const
-{
-  return d->mimeType;
-}
-
-void ASF::Picture::setMimeType(const String &value)
-{
-  d->mimeType = value;
-}
-
-ASF::Picture::Type ASF::Picture::type() const
-{
-  return d->type;
-}
-
-void ASF::Picture::setType(const ASF::Picture::Type& t)
-{
-  d->type = t;
-}
-
-String ASF::Picture::description() const
-{
-  return d->description;
-}
-
-void ASF::Picture::setDescription(const String &desc)
-{
-  d->description = desc;
-}
-
-ByteVector ASF::Picture::picture() const
-{
-  return d->picture;
-}
-
-void ASF::Picture::setPicture(const ByteVector &p)
-{
-  d->picture = p;
-}
-
-int ASF::Picture::dataSize() const
-{
-  return
-    9 + (d->mimeType.length() + d->description.length()) * 2 +
-    d->picture.size();
-}
-
-ASF::Picture& ASF::Picture::operator=(const ASF::Picture& other)
-{
-  Picture(other).swap(*this);
-  return *this;
-}
-
-void ASF::Picture::swap(Picture &other)
-{
-  using std::swap;
-
-  swap(d, other.d);
-}
-
-ByteVector ASF::Picture::render() const
-{
-  if(!isValid())
-    return ByteVector();
-
-  return
-    ByteVector((char)d->type) +
-    ByteVector::fromUInt(d->picture.size(), false) +
-    renderString(d->mimeType) +
-    renderString(d->description) +
-    d->picture;
-}
-
-void ASF::Picture::parse(const ByteVector& bytes)
-{
-  d->valid = false;
-  if(bytes.size() < 9)
-    return;
-  int pos = 0;
-  d->type = (Type)bytes[0]; ++pos;
-  const unsigned int dataLen = bytes.toUInt(pos, false); pos+=4;
-
-  const ByteVector nullStringTerminator(2, 0);
-
-  int endPos = bytes.find(nullStringTerminator, pos, 2);
-  if(endPos < 0)
-    return;
-  d->mimeType = String(bytes.mid(pos, endPos - pos), String::UTF16LE);
-  pos = endPos+2;
-
-  endPos = bytes.find(nullStringTerminator, pos, 2);
-  if(endPos < 0)
-    return;
-  d->description = String(bytes.mid(pos, endPos - pos), String::UTF16LE);
-  pos = endPos+2;
-
-  if(dataLen + pos != bytes.size())
-    return;
-
-  d->picture = bytes.mid(pos, dataLen);
-  d->valid = true;
-  return;
-}
-
-ASF::Picture ASF::Picture::fromInvalid()
-{
-  Picture ret;
-  ret.d->valid = false;
-  return ret;
-}

3rdparty/taglib/asf/asfpicture.h

@@ -1,224 +0,0 @@
-/**************************************************************************
-    copyright            : (C) 2010 by Anton Sergunov
-    email                : setosha@gmail.com
- **************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef ASFPICTURE_H
-#define ASFPICTURE_H
-
-#include "tstring.h"
-#include "tbytevector.h"
-#include "taglib_export.h"
-#include "attachedpictureframe.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib
-{
-  namespace ASF
-  {
-
-    //! An ASF attached picture interface implementation
-
-    /*!
-     * This is an implementation of ASF attached pictures interface.  Pictures may be
-     * included in attributes, one per WM/Picture attribute (but there may be multiple WM/Picture
-     * attribute in a single tag).  These pictures are usually in either JPEG or
-     * PNG format.
-     * \see Attribute::toPicture()
-     * \see Attribute::Attribute(const Picture& picture)
-     */
-    class TAGLIB_EXPORT Picture {
-    public:
-
-      /*!
-       * This describes the function or content of the picture.
-       */
-      enum Type {
-        //! A type not enumerated below
-        Other              = 0x00,
-        //! 32x32 PNG image that should be used as the file icon
-        FileIcon           = 0x01,
-        //! File icon of a different size or format
-        OtherFileIcon      = 0x02,
-        //! Front cover image of the album
-        FrontCover         = 0x03,
-        //! Back cover image of the album
-        BackCover          = 0x04,
-        //! Inside leaflet page of the album
-        LeafletPage        = 0x05,
-        //! Image from the album itself
-        Media              = 0x06,
-        //! Picture of the lead artist or soloist
-        LeadArtist         = 0x07,
-        //! Picture of the artist or performer
-        Artist             = 0x08,
-        //! Picture of the conductor
-        Conductor          = 0x09,
-        //! Picture of the band or orchestra
-        Band               = 0x0A,
-        //! Picture of the composer
-        Composer           = 0x0B,
-        //! Picture of the lyricist or text writer
-        Lyricist           = 0x0C,
-        //! Picture of the recording location or studio
-        RecordingLocation  = 0x0D,
-        //! Picture of the artists during recording
-        DuringRecording    = 0x0E,
-        //! Picture of the artists during performance
-        DuringPerformance  = 0x0F,
-        //! Picture from a movie or video related to the track
-        MovieScreenCapture = 0x10,
-        //! Picture of a large, coloured fish
-        ColouredFish       = 0x11,
-        //! Illustration related to the track
-        Illustration       = 0x12,
-        //! Logo of the band or performer
-        BandLogo           = 0x13,
-        //! Logo of the publisher (record company)
-        PublisherLogo      = 0x14
-      };
-
-      /*!
-       * Constructs an empty picture.
-       */
-      Picture();
-
-      /*!
-       * Construct an picture as a copy of \a other.
-       */
-      Picture(const Picture& other);
-
-      /*!
-       * Destroys the picture.
-       */
-      virtual ~Picture();
-
-      /*!
-       * Copies the contents of \a other into this picture.
-       */
-      Picture& operator=(const Picture& other);
-
-      /*!
-       * Exchanges the content of the Picture by the content of \a other.
-       */
-      void swap(Picture &other);
-
-      /*!
-       * Returns true if Picture stores valid picture
-       */
-      bool isValid() const;
-
-      /*!
-       * Returns the mime type of the image. This should in most cases be
-       * "image/png" or "image/jpeg".
-       * \see setMimeType(const String &)
-       * \see picture()
-       * \see setPicture(const ByteArray&)
-       */
-      String mimeType() const;
-
-      /*!
-       * Sets the mime type of the image.  This should in most cases be
-       * "image/png" or "image/jpeg".
-       * \see setMimeType(const String &)
-       * \see picture()
-       * \see setPicture(const ByteArray&)
-       */
-      void setMimeType(const String &value);
-
-      /*!
-       * Returns the type of the image.
-       *
-       * \see Type
-       * \see setType()
-       */
-      Type type() const;
-
-      /*!
-       * Sets the type for the image.
-       *
-       * \see Type
-       * \see type()
-       */
-      void setType(const ASF::Picture::Type& t);
-
-      /*!
-       * Returns a text description of the image.
-       *
-       * \see setDescription()
-       */
-      String description() const;
-
-      /*!
-       * Sets a textual description of the image to \a desc.
-       *
-       * \see description()
-       */
-      void setDescription(const String &desc);
-
-      /*!
-       * Returns the image data as a ByteVector.
-       *
-       * \note ByteVector has a data() method that returns a const char * which
-       * should make it easy to export this data to external programs.
-       *
-       * \see setPicture()
-       * \see mimeType()
-       */
-      ByteVector picture() const;
-
-      /*!
-       * Sets the image data to \a p.  \a p should be of the type specified in
-       * this frame's mime-type specification.
-       *
-       * \see picture()
-       * \see mimeType()
-       * \see setMimeType()
-       */
-      void setPicture(const ByteVector &p);
-
-      /*!
-       * Returns picture as binary raw data \a value
-       */
-      ByteVector render() const;
-
-      /*!
-       * Returns picture as binary raw data \a value
-       */
-      int dataSize() const;
-
-#ifndef DO_NOT_DOCUMENT
-      /* THIS IS PRIVATE, DON'T TOUCH IT! */
-      void parse(const ByteVector& );
-      static Picture fromInvalid();
-#endif
-
-      private:
-        class PicturePrivate;
-        PicturePrivate *d;
-      };
-  }
-}
-}
-
-#endif // ASFPICTURE_H

3rdparty/taglib/asf/asfproperties.cpp

@@ -1,194 +0,0 @@
-/**************************************************************************
-    copyright            : (C) 2005-2007 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
- **************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <tdebug.h>
-#include <tstring.h>
-#include "asfproperties.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-class ASF::Properties::PropertiesPrivate
-{
-public:
-  PropertiesPrivate() :
-    length(0),
-    bitrate(0),
-    sampleRate(0),
-    channels(0),
-    bitsPerSample(0),
-    codec(ASF::Properties::Unknown),
-    encrypted(false) {}
-
-  int length;
-  int bitrate;
-  int sampleRate;
-  int channels;
-  int bitsPerSample;
-  ASF::Properties::Codec codec;
-  String codecName;
-  String codecDescription;
-  bool encrypted;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// public members
-////////////////////////////////////////////////////////////////////////////////
-
-ASF::Properties::Properties() :
-  AudioProperties(AudioProperties::Average),
-  d(new PropertiesPrivate())
-{
-}
-
-ASF::Properties::~Properties()
-{
-  delete d;
-}
-
-int ASF::Properties::length() const
-{
-  return lengthInSeconds();
-}
-
-int ASF::Properties::lengthInSeconds() const
-{
-  return d->length / 1000;
-}
-
-int ASF::Properties::lengthInMilliseconds() const
-{
-  return d->length;
-}
-
-int ASF::Properties::bitrate() const
-{
-  return d->bitrate;
-}
-
-int ASF::Properties::sampleRate() const
-{
-  return d->sampleRate;
-}
-
-int ASF::Properties::channels() const
-{
-  return d->channels;
-}
-
-int ASF::Properties::bitsPerSample() const
-{
-  return d->bitsPerSample;
-}
-
-ASF::Properties::Codec ASF::Properties::codec() const
-{
-  return d->codec;
-}
-
-String ASF::Properties::codecName() const
-{
-  return d->codecName;
-}
-
-String ASF::Properties::codecDescription() const
-{
-  return d->codecDescription;
-}
-
-bool ASF::Properties::isEncrypted() const
-{
-  return d->encrypted;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// private members
-////////////////////////////////////////////////////////////////////////////////
-
-void ASF::Properties::setLength(int /*length*/)
-{
-  debug("ASF::Properties::setLength() -- This method is deprecated. Do not use.");
-}
-
-void ASF::Properties::setLengthInMilliseconds(int value)
-{
-  d->length = value;
-}
-
-void ASF::Properties::setBitrate(int value)
-{
-  d->bitrate = value;
-}
-
-void ASF::Properties::setSampleRate(int value)
-{
-  d->sampleRate = value;
-}
-
-void ASF::Properties::setChannels(int value)
-{
-  d->channels = value;
-}
-
-void ASF::Properties::setBitsPerSample(int value)
-{
-  d->bitsPerSample = value;
-}
-
-void ASF::Properties::setCodec(int value)
-{
-  switch(value)
-  {
-  case 0x0160:
-    d->codec = WMA1;
-    break;
-  case 0x0161:
-    d->codec = WMA2;
-    break;
-  case 0x0162:
-    d->codec = WMA9Pro;
-    break;
-  case 0x0163:
-    d->codec = WMA9Lossless;
-    break;
-  default:
-    d->codec = Unknown;
-    break;
-  }
-}
-
-void ASF::Properties::setCodecName(const String &value)
-{
-  d->codecName = value;
-}
-
-void ASF::Properties::setCodecDescription(const String &value)
-{
-  d->codecDescription = value;
-}
-
-void ASF::Properties::setEncrypted(bool value)
-{
-  d->encrypted = value;
-}

3rdparty/taglib/asf/asfproperties.h

@@ -1,188 +0,0 @@
-/**************************************************************************
-    copyright            : (C) 2005-2007 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
- **************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_ASFPROPERTIES_H
-#define TAGLIB_ASFPROPERTIES_H
-
-#include "audioproperties.h"
-#include "tstring.h"
-#include "taglib_export.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  namespace ASF {
-
-    //! An implementation of ASF audio properties
-    class TAGLIB_EXPORT Properties : public AudioProperties
-    {
-    public:
-
-      /*!
-       * Audio codec types can be used in ASF file.
-       */
-      enum Codec
-      {
-        /*!
-         * Couldn't detect the codec.
-         */
-        Unknown = 0,
-
-        /*!
-         * Windows Media Audio 1
-         */
-        WMA1,
-
-        /*!
-         * Windows Media Audio 2 or above
-         */
-        WMA2,
-
-        /*!
-         * Windows Media Audio 9 Professional
-         */
-        WMA9Pro,
-
-        /*!
-         * Windows Media Audio 9 Lossless
-         */
-        WMA9Lossless,
-      };
-
-      /*!
-       * Creates an instance of ASF::Properties.
-       */
-      Properties();
-
-      /*!
-       * Destroys this ASF::Properties instance.
-       */
-      virtual ~Properties();
-
-      /*!
-       * Returns the length of the file in seconds.  The length is rounded down to
-       * the nearest whole second.
-       *
-       * \note This method is just an alias of lengthInSeconds().
-       *
-       * \deprecated
-       */
-      virtual int length() const;
-
-      /*!
-       * Returns the length of the file in seconds.  The length is rounded down to
-       * the nearest whole second.
-       *
-       * \see lengthInMilliseconds()
-       */
-      // BIC: make virtual
-      int lengthInSeconds() const;
-
-      /*!
-       * Returns the length of the file in milliseconds.
-       *
-       * \see lengthInSeconds()
-       */
-      // BIC: make virtual
-      int lengthInMilliseconds() const;
-
-      /*!
-       * Returns the average bit rate of the file in kb/s.
-       */
-      virtual int bitrate() const;
-
-      /*!
-       * Returns the sample rate in Hz.
-       */
-      virtual int sampleRate() const;
-
-      /*!
-       * Returns the number of audio channels.
-       */
-      virtual int channels() const;
-
-      /*!
-       * Returns the number of bits per audio sample.
-       */
-      int bitsPerSample() const;
-
-      /*!
-       * Returns the codec used in the file.
-       *
-       * \see codecName()
-       * \see codecDescription()
-       */
-      Codec codec() const;
-
-      /*!
-       * Returns the concrete codec name, for example "Windows Media Audio 9.1"
-       * used in the file if available, otherwise an empty string.
-       *
-       * \see codec()
-       * \see codecDescription()
-       */
-      String codecName() const;
-
-      /*!
-       * Returns the codec description, typically contains the encoder settings,
-       * for example "VBR Quality 50, 44kHz, stereo 1-pass VBR" if available,
-       * otherwise an empty string.
-       *
-       * \see codec()
-       * \see codecName()
-       */
-      String codecDescription() const;
-
-      /*!
-       * Returns whether or not the file is encrypted.
-       */
-      bool isEncrypted() const;
-
-#ifndef DO_NOT_DOCUMENT
-      // deprecated
-      void setLength(int value);
-
-      void setLengthInMilliseconds(int value);
-      void setBitrate(int value);
-      void setSampleRate(int value);
-      void setChannels(int value);
-      void setBitsPerSample(int value);
-      void setCodec(int value);
-      void setCodecName(const String &value);
-      void setCodecDescription(const String &value);
-      void setEncrypted(bool value);
-#endif
-
-    private:
-      class PropertiesPrivate;
-      PropertiesPrivate *d;
-    };
-
-  }
-
-}
-}
-
-#endif

3rdparty/taglib/asf/asftag.cpp

@@ -1,378 +0,0 @@
-/**************************************************************************
-    copyright            : (C) 2005-2007 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
- **************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <tpropertymap.h>
-#include "asftag.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-class ASF::Tag::TagPrivate
-{
-public:
-  String title;
-  String artist;
-  String copyright;
-  String comment;
-  String rating;
-  AttributeListMap attributeListMap;
-};
-
-ASF::Tag::Tag() :
-  Strawberry_TagLib::TagLib::Tag(),
-  d(new TagPrivate())
-{
-}
-
-ASF::Tag::~Tag()
-{
-  delete d;
-}
-
-String ASF::Tag::title() const
-{
-  return d->title;
-}
-
-String ASF::Tag::artist() const
-{
-  return d->artist;
-}
-
-String ASF::Tag::album() const
-{
-  if(d->attributeListMap.contains("WM/AlbumTitle"))
-    return d->attributeListMap["WM/AlbumTitle"][0].toString();
-  return String();
-}
-
-String ASF::Tag::copyright() const
-{
-  return d->copyright;
-}
-
-String ASF::Tag::comment() const
-{
-  return d->comment;
-}
-
-String ASF::Tag::rating() const
-{
-  return d->rating;
-}
-
-unsigned int ASF::Tag::year() const
-{
-  if(d->attributeListMap.contains("WM/Year"))
-    return d->attributeListMap["WM/Year"][0].toString().toInt();
-  return 0;
-}
-
-unsigned int ASF::Tag::track() const
-{
-  if(d->attributeListMap.contains("WM/TrackNumber")) {
-    const ASF::Attribute attr = d->attributeListMap["WM/TrackNumber"][0];
-    if(attr.type() == ASF::Attribute::DWordType)
-      return attr.toUInt();
-    else
-      return attr.toString().toInt();
-  }
-  if(d->attributeListMap.contains("WM/Track"))
-    return d->attributeListMap["WM/Track"][0].toUInt();
-  return 0;
-}
-
-String ASF::Tag::genre() const
-{
-  if(d->attributeListMap.contains("WM/Genre"))
-    return d->attributeListMap["WM/Genre"][0].toString();
-  return String();
-}
-
-void ASF::Tag::setTitle(const String &value)
-{
-  d->title = value;
-}
-
-void ASF::Tag::setArtist(const String &value)
-{
-  d->artist = value;
-}
-
-void ASF::Tag::setCopyright(const String &value)
-{
-  d->copyright = value;
-}
-
-void ASF::Tag::setComment(const String &value)
-{
-  d->comment = value;
-}
-
-void ASF::Tag::setRating(const String &value)
-{
-  d->rating = value;
-}
-
-void ASF::Tag::setAlbum(const String &value)
-{
-  setAttribute("WM/AlbumTitle", value);
-}
-
-void ASF::Tag::setGenre(const String &value)
-{
-  setAttribute("WM/Genre", value);
-}
-
-void ASF::Tag::setYear(unsigned int value)
-{
-  setAttribute("WM/Year", String::number(value));
-}
-
-void ASF::Tag::setTrack(unsigned int value)
-{
-  setAttribute("WM/TrackNumber", String::number(value));
-}
-
-ASF::AttributeListMap& ASF::Tag::attributeListMap()
-{
-  return d->attributeListMap;
-}
-
-const ASF::AttributeListMap &ASF::Tag::attributeListMap() const
-{
-  return d->attributeListMap;
-}
-
-bool ASF::Tag::contains(const String &key) const
-{
-  return d->attributeListMap.contains(key);
-}
-
-void ASF::Tag::removeItem(const String &key)
-{
-  d->attributeListMap.erase(key);
-}
-
-ASF::AttributeList ASF::Tag::attribute(const String &name) const
-{
-  return d->attributeListMap[name];
-}
-
-void ASF::Tag::setAttribute(const String &name, const Attribute &attribute)
-{
-  AttributeList value;
-  value.append(attribute);
-  d->attributeListMap.insert(name, value);
-}
-
-void ASF::Tag::setAttribute(const String &name, const AttributeList &values)
-{
-  d->attributeListMap.insert(name, values);
-}
-
-void ASF::Tag::addAttribute(const String &name, const Attribute &attribute)
-{
-  if(d->attributeListMap.contains(name)) {
-    d->attributeListMap[name].append(attribute);
-  }
-  else {
-    setAttribute(name, attribute);
-  }
-}
-
-bool ASF::Tag::isEmpty() const
-{
-  return Strawberry_TagLib::TagLib::Tag::isEmpty() &&
-         copyright().isEmpty() &&
-         rating().isEmpty() &&
-         d->attributeListMap.isEmpty();
-}
-
-namespace
-{
-  const char *keyTranslation[][2] = {
-    { "WM/AlbumTitle", "ALBUM" },
-    { "WM/AlbumArtist", "ALBUMARTIST" },
-    { "WM/Composer", "COMPOSER" },
-    { "WM/Writer", "WRITER" },
-    { "WM/Conductor", "CONDUCTOR" },
-    { "WM/ModifiedBy", "REMIXER" },
-    { "WM/Year", "DATE" },
-    { "WM/OriginalReleaseYear", "ORIGINALDATE" },
-    { "WM/Producer", "PRODUCER" },
-    { "WM/ContentGroupDescription", "GROUPING" },
-    { "WM/SubTitle", "SUBTITLE" },
-    { "WM/SetSubTitle", "DISCSUBTITLE" },
-    { "WM/TrackNumber", "TRACKNUMBER" },
-    { "WM/PartOfSet", "DISCNUMBER" },
-    { "WM/Genre", "GENRE" },
-    { "WM/BeatsPerMinute", "BPM" },
-    { "WM/Mood", "MOOD" },
-    { "WM/ISRC", "ISRC" },
-    { "WM/Lyrics", "LYRICS" },
-    { "WM/Media", "MEDIA" },
-    { "WM/Publisher", "LABEL" },
-    { "WM/CatalogNo", "CATALOGNUMBER" },
-    { "WM/Barcode", "BARCODE" },
-    { "WM/EncodedBy", "ENCODEDBY" },
-    { "WM/AlbumSortOrder", "ALBUMSORT" },
-    { "WM/AlbumArtistSortOrder", "ALBUMARTISTSORT" },
-    { "WM/ArtistSortOrder", "ARTISTSORT" },
-    { "WM/TitleSortOrder", "TITLESORT" },
-    { "WM/Script", "SCRIPT" },
-    { "WM/Language", "LANGUAGE" },
-    { "MusicBrainz/Track Id", "MUSICBRAINZ_TRACKID" },
-    { "MusicBrainz/Artist Id", "MUSICBRAINZ_ARTISTID" },
-    { "MusicBrainz/Album Id", "MUSICBRAINZ_ALBUMID" },
-    { "MusicBrainz/Album Artist Id", "MUSICBRAINZ_ALBUMARTISTID" },
-    { "MusicBrainz/Release Group Id", "MUSICBRAINZ_RELEASEGROUPID" },
-    { "MusicBrainz/Work Id", "MUSICBRAINZ_WORKID" },
-    { "MusicIP/PUID", "MUSICIP_PUID" },
-    { "Acoustid/Id", "ACOUSTID_ID" },
-    { "Acoustid/Fingerprint", "ACOUSTID_FINGERPRINT" },
-  };
-  const size_t keyTranslationSize = sizeof(keyTranslation) / sizeof(keyTranslation[0]);
-
-  String translateKey(const String &key)
-  {
-    for(size_t i = 0; i < keyTranslationSize; ++i) {
-      if(key == keyTranslation[i][0])
-        return keyTranslation[i][1];
-    }
-
-    return String();
-  }
-}
-
-PropertyMap ASF::Tag::properties() const
-{
-  PropertyMap props;
-
-  if(!d->title.isEmpty()) {
-    props["TITLE"] = d->title;
-  }
-  if(!d->artist.isEmpty()) {
-    props["ARTIST"] = d->artist;
-  }
-  if(!d->copyright.isEmpty()) {
-    props["COPYRIGHT"] = d->copyright;
-  }
-  if(!d->comment.isEmpty()) {
-    props["COMMENT"] = d->comment;
-  }
-
-  ASF::AttributeListMap::ConstIterator it = d->attributeListMap.begin();
-  for(; it != d->attributeListMap.end(); ++it) {
-    const String key = translateKey(it->first);
-    if(!key.isEmpty()) {
-      AttributeList::ConstIterator it2 = it->second.begin();
-      for(; it2 != it->second.end(); ++it2) {
-        if(key == "TRACKNUMBER") {
-          if(it2->type() == ASF::Attribute::DWordType)
-            props.insert(key, String::number(it2->toUInt()));
-          else
-            props.insert(key, it2->toString());
-        }
-        else {
-          props.insert(key, it2->toString());
-        }
-      }
-    }
-    else {
-      props.unsupportedData().append(it->first);
-    }
-  }
-  return props;
-}
-
-void ASF::Tag::removeUnsupportedProperties(const StringList &props)
-{
-  StringList::ConstIterator it = props.begin();
-  for(; it != props.end(); ++it)
-    d->attributeListMap.erase(*it);
-}
-
-PropertyMap ASF::Tag::setProperties(const PropertyMap &props)
-{
-  static Map<String, String> reverseKeyMap;
-  if(reverseKeyMap.isEmpty()) {
-    int numKeys = sizeof(keyTranslation) / sizeof(keyTranslation[0]);
-    for(int i = 0; i < numKeys; i++) {
-      reverseKeyMap[keyTranslation[i][1]] = keyTranslation[i][0];
-    }
-  }
-
-  PropertyMap origProps = properties();
-  PropertyMap::ConstIterator it = origProps.begin();
-  for(; it != origProps.end(); ++it) {
-    if(!props.contains(it->first) || props[it->first].isEmpty()) {
-      if(it->first == "TITLE") {
-        d->title.clear();
-      }
-      else if(it->first == "ARTIST") {
-        d->artist.clear();
-      }
-      else if(it->first == "COMMENT") {
-        d->comment.clear();
-      }
-      else if(it->first == "COPYRIGHT") {
-        d->copyright.clear();
-      }
-      else {
-        d->attributeListMap.erase(reverseKeyMap[it->first]);
-      }
-    }
-  }
-
-  PropertyMap ignoredProps;
-  it = props.begin();
-  for(; it != props.end(); ++it) {
-    if(reverseKeyMap.contains(it->first)) {
-      String name = reverseKeyMap[it->first];
-      removeItem(name);
-      StringList::ConstIterator it2 = it->second.begin();
-      for(; it2 != it->second.end(); ++it2) {
-        addAttribute(name, *it2);
-      }
-    }
-    else if(it->first == "TITLE") {
-      d->title = it->second.toString();
-    }
-    else if(it->first == "ARTIST") {
-      d->artist = it->second.toString();
-    }
-    else if(it->first == "COMMENT") {
-      d->comment = it->second.toString();
-    }
-    else if(it->first == "COPYRIGHT") {
-      d->copyright = it->second.toString();
-    }
-    else {
-      ignoredProps.insert(it->first, it->second);
-    }
-  }
-
-  return ignoredProps;
-}

3rdparty/taglib/asf/asftag.h

@@ -1,212 +0,0 @@
-/**************************************************************************
-    copyright            : (C) 2005-2007 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
- **************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_ASFTAG_H
-#define TAGLIB_ASFTAG_H
-
-#include "tag.h"
-#include "tlist.h"
-#include "tmap.h"
-#include "taglib_export.h"
-#include "asfattribute.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  namespace ASF {
-
-    typedef List<Attribute> AttributeList;
-    typedef Map<String, AttributeList> AttributeListMap;
-
-    class TAGLIB_EXPORT Tag : public Strawberry_TagLib::TagLib::Tag {
-
-      friend class File;
-
-    public:
-
-      Tag();
-
-      virtual ~Tag();
-
-      /*!
-       * Returns the track name.
-       */
-      virtual String title() const;
-
-      /*!
-       * Returns the artist name.
-       */
-      virtual String artist() const;
-
-      /*!
-       * Returns the album name; if no album name is present in the tag
-       * String::null will be returned.
-       */
-      virtual String album() const;
-
-      /*!
-       * Returns the track comment.
-       */
-      virtual String comment() const;
-
-      /*!
-       * Returns the genre name; if no genre is present in the tag String::null
-       * will be returned.
-       */
-      virtual String genre() const;
-
-      /*!
-       * Returns the rating.
-       */
-      virtual String rating() const;
-
-      /*!
-       * Returns the genre name; if no genre is present in the tag String::null
-       * will be returned.
-       */
-      virtual String copyright() const;
-
-      /*!
-       * Returns the year; if there is no year set, this will return 0.
-       */
-      virtual unsigned int year() const;
-
-      /*!
-       * Returns the track number; if there is no track number set, this will
-       * return 0.
-       */
-      virtual unsigned int track() const;
-
-      /*!
-       * Sets the title to \a s.
-       */
-      virtual void setTitle(const String &s);
-
-      /*!
-       * Sets the artist to \a s.
-       */
-      virtual void setArtist(const String &s);
-
-      /*!
-       * Sets the album to \a s.  If \a s is String::null then this value will be
-       * cleared.
-       */
-      virtual void setAlbum(const String &s);
-
-      /*!
-       * Sets the comment to \a s.
-       */
-      virtual void setComment(const String &s);
-
-      /*!
-       * Sets the rating to \a s.
-       */
-      virtual void setRating(const String &s);
-
-      /*!
-       * Sets the copyright to \a s.
-       */
-      virtual void setCopyright(const String &s);
-
-      /*!
-       * Sets the genre to \a s.
-       */
-      virtual void setGenre(const String &s);
-
-      /*!
-       * Sets the year to \a i.  If \a s is 0 then this value will be cleared.
-       */
-      virtual void setYear(unsigned int i);
-
-      /*!
-       * Sets the track to \a i.  If \a s is 0 then this value will be cleared.
-       */
-      virtual void setTrack(unsigned int i);
-
-      /*!
-       * Returns true if the tag does not contain any data.  This should be
-       * reimplemented in subclasses that provide more than the basic tagging
-       * abilities in this class.
-       */
-      virtual bool isEmpty() const;
-
-      /*!
-       * \deprecated
-       */
-      AttributeListMap &attributeListMap();
-
-      /*!
-       * Returns a reference to the item list map.  This is an AttributeListMap of
-       * all of the items in the tag.
-       */
-      // BIC: return by value
-      const AttributeListMap &attributeListMap() const;
-
-      /*!
-       * \return True if a value for \a attribute is currently set.
-       */
-      bool contains(const String &name) const;
-
-      /*!
-       * Removes the \a key attribute from the tag
-       */
-      void removeItem(const String &name);
-
-      /*!
-       * \return The list of values for the key \a name, or an empty list if no
-       * values have been set.
-       */
-      AttributeList attribute(const String &name) const;
-
-      /*!
-       * Sets the \a key attribute to the value of \a attribute. If an attribute
-       * with the \a key is already present, it will be replaced.
-       */
-      void setAttribute(const String &name, const Attribute &attribute);
-
-      /*!
-       * Sets multiple \a values to the key \a name.
-       */
-      void setAttribute(const String &name, const AttributeList &values);
-
-      /*!
-       * Sets the \a key attribute to the value of \a attribute. If an attribute
-       * with the \a key is already present, it will be added to the list.
-       */
-      void addAttribute(const String &name, const Attribute &attribute);
-
-      PropertyMap properties() const;
-      void removeUnsupportedProperties(const StringList& properties);
-      PropertyMap setProperties(const PropertyMap &properties);
-
-    private:
-
-      class TagPrivate;
-      TagPrivate *d;
-    };
-  }
-}
-}
-#endif

3rdparty/taglib/asf/asfutils.h

@@ -1,106 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2015 by Tsuda Kageyu
-    email                : tsuda.kageyu@gmail.com
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_ASFUTILS_H
-#define TAGLIB_ASFUTILS_H
-
-// THIS FILE IS NOT A PART OF THE TAGLIB API
-
-#ifndef DO_NOT_DOCUMENT  // tell Doxygen not to document this header
-
-namespace Strawberry_TagLib {
-namespace TagLib
-{
-  namespace ASF
-  {
-    namespace
-    {
-
-      inline unsigned short readWORD(File *file, bool *ok = 0)
-      {
-        const ByteVector v = file->readBlock(2);
-        if(v.size() != 2) {
-          if(ok) *ok = false;
-          return 0;
-        }
-        if(ok) *ok = true;
-        return v.toUShort(false);
-      }
-
-      inline unsigned int readDWORD(File *file, bool *ok = 0)
-      {
-        const ByteVector v = file->readBlock(4);
-        if(v.size() != 4) {
-          if(ok) *ok = false;
-          return 0;
-        }
-        if(ok) *ok = true;
-        return v.toUInt(false);
-      }
-
-      inline long long readQWORD(File *file, bool *ok = 0)
-      {
-        const ByteVector v = file->readBlock(8);
-        if(v.size() != 8) {
-          if(ok) *ok = false;
-          return 0;
-        }
-        if(ok) *ok = true;
-        return v.toLongLong(false);
-      }
-
-      inline String readString(File *file, int length)
-      {
-        ByteVector data = file->readBlock(length);
-        unsigned int size = data.size();
-        while (size >= 2) {
-          if(data[size - 1] != '\0' || data[size - 2] != '\0') {
-            break;
-          }
-          size -= 2;
-        }
-        if(size != data.size()) {
-          data.resize(size);
-        }
-        return String(data, String::UTF16LE);
-      }
-
-      inline ByteVector renderString(const String &str, bool includeLength = false)
-      {
-        ByteVector data = str.data(String::UTF16LE) + ByteVector::fromShort(0, false);
-        if(includeLength) {
-          data = ByteVector::fromShort(data.size(), false) + data;
-        }
-        return data;
-      }
-
-    }
-  }
-}
-}
-
-#endif
-
-#endif

3rdparty/taglib/audioproperties.cpp

@@ -1,117 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2002 - 2008 by Scott Wheeler
-    email                : wheeler@kde.org
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <tbytevector.h>
-
-#include "aiffproperties.h"
-#include "apeproperties.h"
-#include "asfproperties.h"
-#include "flacproperties.h"
-#include "mp4properties.h"
-#include "mpcproperties.h"
-#include "mpegproperties.h"
-#include "opusproperties.h"
-#include "speexproperties.h"
-#include "trueaudioproperties.h"
-#include "vorbisproperties.h"
-#include "wavproperties.h"
-#include "wavpackproperties.h"
-#include "dsfproperties.h"
-#include "dsdiffproperties.h"
-
-#include "audioproperties.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-// This macro is a workaround for the fact that we can't add virtual functions.
-// Should be true virtual functions in taglib2.
-
-#define VIRTUAL_FUNCTION_WORKAROUND(function_name, default_value)               \
-  if(dynamic_cast<const APE::Properties*>(this))                                \
-    return dynamic_cast<const APE::Properties*>(this)->function_name();         \
-  else if(dynamic_cast<const ASF::Properties*>(this))                           \
-    return dynamic_cast<const ASF::Properties*>(this)->function_name();         \
-  else if(dynamic_cast<const FLAC::Properties*>(this))                          \
-    return dynamic_cast<const FLAC::Properties*>(this)->function_name();        \
-  else if(dynamic_cast<const MP4::Properties*>(this))                           \
-    return dynamic_cast<const MP4::Properties*>(this)->function_name();         \
-  else if(dynamic_cast<const MPC::Properties*>(this))                           \
-    return dynamic_cast<const MPC::Properties*>(this)->function_name();         \
-  else if(dynamic_cast<const MPEG::Properties*>(this))                          \
-    return dynamic_cast<const MPEG::Properties*>(this)->function_name();        \
-  else if(dynamic_cast<const Ogg::Opus::Properties*>(this))                     \
-    return dynamic_cast<const Ogg::Opus::Properties*>(this)->function_name();   \
-  else if(dynamic_cast<const Ogg::Speex::Properties*>(this))                    \
-    return dynamic_cast<const Ogg::Speex::Properties*>(this)->function_name();  \
-  else if(dynamic_cast<const TrueAudio::Properties*>(this))                     \
-    return dynamic_cast<const TrueAudio::Properties*>(this)->function_name();   \
-  else if(dynamic_cast<const RIFF::AIFF::Properties*>(this))                    \
-    return dynamic_cast<const RIFF::AIFF::Properties*>(this)->function_name();  \
-  else if(dynamic_cast<const RIFF::WAV::Properties*>(this))                     \
-    return dynamic_cast<const RIFF::WAV::Properties*>(this)->function_name();   \
-  else if(dynamic_cast<const Vorbis::Properties*>(this))                        \
-    return dynamic_cast<const Vorbis::Properties*>(this)->function_name();      \
-  else if(dynamic_cast<const WavPack::Properties*>(this))                       \
-    return dynamic_cast<const WavPack::Properties*>(this)->function_name();     \
-  else if(dynamic_cast<const DSF::Properties*>(this))                           \
-    return dynamic_cast<const DSF::Properties*>(this)->function_name();         \
-  else if(dynamic_cast<const DSDIFF::Properties*>(this))                        \
-    return dynamic_cast<const DSDIFF::Properties*>(this)->function_name();      \
-  else                                                                          \
-    return (default_value);
-
-class AudioProperties::AudioPropertiesPrivate
-{
-
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// public methods
-////////////////////////////////////////////////////////////////////////////////
-
-AudioProperties::~AudioProperties()
-{
-
-}
-
-int AudioProperties::lengthInSeconds() const
-{
-  VIRTUAL_FUNCTION_WORKAROUND(lengthInSeconds, 0)
-}
-
-int AudioProperties::lengthInMilliseconds() const
-{
-  VIRTUAL_FUNCTION_WORKAROUND(lengthInMilliseconds, 0)
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// protected methods
-////////////////////////////////////////////////////////////////////////////////
-
-AudioProperties::AudioProperties(ReadStyle) :
-  d(0)
-{
-
-}

3rdparty/taglib/audioproperties.h

@@ -1,129 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2002 - 2008 by Scott Wheeler
-    email                : wheeler@kde.org
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_AUDIOPROPERTIES_H
-#define TAGLIB_AUDIOPROPERTIES_H
-
-#include "taglib_export.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  //! A simple, abstract interface to common audio properties
-
-  /*!
-   * The values here are common to most audio formats.  For more specific, codec
-   * dependent values, please see see the subclasses APIs.  This is meant to
-   * compliment the TagLib::File and TagLib::Tag APIs in providing a simple
-   * interface that is sufficient for most applications.
-   */
-
-  class TAGLIB_EXPORT AudioProperties
-  {
-  public:
-
-    /*!
-     * Reading audio properties from a file can sometimes be very time consuming
-     * and for the most accurate results can often involve reading the entire
-     * file.  Because in many situations speed is critical or the accuracy of the
-     * values is not particularly important this allows the level of desired
-     * accuracy to be set.
-     */
-    enum ReadStyle {
-      //! Read as little of the file as possible
-      Fast,
-      //! Read more of the file and make better values guesses
-      Average,
-      //! Read as much of the file as needed to report accurate values
-      Accurate
-    };
-
-    /*!
-     * Destroys this AudioProperties instance.
-     */
-    virtual ~AudioProperties();
-
-    /*!
-     * Returns the length of the file in seconds.
-     */
-    virtual int length() const = 0;
-
-    /*!
-     * Returns the length of the file in seconds.  The length is rounded down to
-     * the nearest whole second.
-     *
-     * \see lengthInMilliseconds()
-     */
-    // BIC: make virtual
-    int lengthInSeconds() const;
-
-    /*!
-     * Returns the length of the file in milliseconds.
-     *
-     * \see lengthInSeconds()
-     */
-    // BIC: make virtual
-    int lengthInMilliseconds() const;
-
-    /*!
-     * Returns the most appropriate bit rate for the file in kb/s.  For constant
-     * bitrate formats this is simply the bitrate of the file.  For variable
-     * bitrate formats this is either the average or nominal bitrate.
-     */
-    virtual int bitrate() const = 0;
-
-    /*!
-     * Returns the sample rate in Hz.
-     */
-    virtual int sampleRate() const = 0;
-
-    /*!
-     * Returns the number of audio channels.
-     */
-    virtual int channels() const = 0;
-
-  protected:
-
-    /*!
-     * Construct an audio properties instance.  This is protected as this class
-     * should not be instantiated directly, but should be instantiated via its
-     * subclasses and can be fetched from the FileRef or File APIs.
-     *
-     * \see ReadStyle
-     */
-    AudioProperties(ReadStyle style);
-
-  private:
-    AudioProperties(const AudioProperties &);
-    AudioProperties &operator=(const AudioProperties &);
-
-    class AudioPropertiesPrivate;
-    AudioPropertiesPrivate *d;
-  };
-
-}
-}
-
-#endif

3rdparty/taglib/config.h.cmake

@@ -1,35 +0,0 @@
-/* config.h. Generated by cmake from config.h.cmake */
-
-#ifndef TAGLIB_CONFIG_H
-#define TAGLIB_CONFIG_H
-
-/* Defined if your compiler supports some byte swap functions */
-#cmakedefine   HAVE_GCC_BYTESWAP 1
-#cmakedefine   HAVE_GLIBC_BYTESWAP 1
-#cmakedefine   HAVE_MSC_BYTESWAP 1
-#cmakedefine   HAVE_MAC_BYTESWAP 1
-#cmakedefine   HAVE_OPENBSD_BYTESWAP 1
-
-/* Defined if your compiler supports some atomic operations */
-#cmakedefine   HAVE_STD_ATOMIC 1
-#cmakedefine   HAVE_GCC_ATOMIC 1
-#cmakedefine   HAVE_MAC_ATOMIC 1
-#cmakedefine   HAVE_WIN_ATOMIC 1
-#cmakedefine   HAVE_IA64_ATOMIC 1
-
-/* Defined if your compiler supports some safer version of vsprintf */
-#cmakedefine   HAVE_VSNPRINTF 1
-#cmakedefine   HAVE_VSPRINTF_S 1
-
-/* Defined if your compiler supports ISO _strdup */
-#cmakedefine   HAVE_ISO_STRDUP 1
-
-/* Defined if zlib is installed */
-#cmakedefine   HAVE_ZLIB 1
-
-/* Indicates whether debug messages are shown even in release mode */
-#cmakedefine   TRACE_IN_RELEASE 1
-
-#cmakedefine TESTS_DIR "@TESTS_DIR@"
-
-#endif

3rdparty/taglib/dsdiff/dsdiffdiintag.cpp

@@ -1,162 +0,0 @@
-/***************************************************************************
- copyright            : (C) 2016 by Damien Plisson, Audirvana
- email                : damien78@audirvana.com
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include "dsdiffdiintag.h"
-#include "tstringlist.h"
-#include "tpropertymap.h"
-
-using namespace Strawberry_TagLib::TagLib;
-using namespace DSDIFF::DIIN;
-
-class DSDIFF::DIIN::Tag::TagPrivate
-{
-public:
-  TagPrivate()
-  {
-  }
-
-  String title;
-  String artist;
-};
-
-DSDIFF::DIIN::Tag::Tag() : Strawberry_TagLib::TagLib::Tag()
-{
-  d = new TagPrivate;
-}
-
-DSDIFF::DIIN::Tag::~Tag()
-{
-  delete d;
-}
-
-String DSDIFF::DIIN::Tag::title() const
-{
-  return d->title;
-}
-
-String DSDIFF::DIIN::Tag::artist() const
-{
-  return d->artist;
-}
-
-String DSDIFF::DIIN::Tag::album() const
-{
-  return String();
-}
-
-String DSDIFF::DIIN::Tag::comment() const
-{
-  return String();
-}
-
-String DSDIFF::DIIN::Tag::genre() const
-{
-  return String();
-}
-
-unsigned int DSDIFF::DIIN::Tag::year() const
-{
-  return 0;
-}
-
-unsigned int DSDIFF::DIIN::Tag::track() const
-{
-  return 0;
-}
-
-void DSDIFF::DIIN::Tag::setTitle(const String &title)
-{
-  if(title.isNull() || title.isEmpty())
-    d->title = String();
-  else
-    d->title = title;
-}
-
-void DSDIFF::DIIN::Tag::setArtist(const String &artist)
-{
-  if(artist.isNull() || artist.isEmpty())
-    d->artist = String();
-  else
-    d->artist = artist;
-}
-
-void DSDIFF::DIIN::Tag::setAlbum(const String &)
-{
-}
-
-void DSDIFF::DIIN::Tag::setComment(const String &)
-{
-}
-
-void DSDIFF::DIIN::Tag::setGenre(const String &)
-{
-}
-
-void DSDIFF::DIIN::Tag::setYear(unsigned int)
-{
-}
-
-void DSDIFF::DIIN::Tag::setTrack(unsigned int)
-{
-}
-
-PropertyMap DSDIFF::DIIN::Tag::properties() const
-{
-  PropertyMap properties;
-  properties["TITLE"] = d->title;
-  properties["ARTIST"] = d->artist;
-  return properties;
-}
-
-PropertyMap DSDIFF::DIIN::Tag::setProperties(const PropertyMap &origProps)
-{
-  PropertyMap properties(origProps);
-  properties.removeEmpty();
-  StringList oneValueSet;
-
-  if(properties.contains("TITLE")) {
-    d->title = properties["TITLE"].front();
-    oneValueSet.append("TITLE");
-  } else
-    d->title = String();
-
-  if(properties.contains("ARTIST")) {
-    d->artist = properties["ARTIST"].front();
-    oneValueSet.append("ARTIST");
-  } else
-    d->artist = String();
-
-  // for each tag that has been set above, remove the first entry in the corresponding
-  // value list. The others will be returned as unsupported by this format.
-  for(StringList::Iterator it = oneValueSet.begin(); it != oneValueSet.end(); ++it) {
-    if(properties[*it].size() == 1)
-      properties.erase(*it);
-    else
-      properties[*it].erase(properties[*it].begin());
-  }
-
-  return properties;
-}
-

3rdparty/taglib/dsdiff/dsdiffdiintag.h

@@ -1,152 +0,0 @@
-/***************************************************************************
- copyright            : (C) 2016 by Damien Plisson, Audirvana
- email                : damien78@audirvana.com
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_DSDIFFDIINTAG_H
-#define TAGLIB_DSDIFFDIINTAG_H
-
-#include "tag.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  namespace DSDIFF {
-
-    namespace DIIN {
-
-      /*!
-       * Tags from the Edited Master Chunk Info
-       *
-       * Only Title and Artist tags are supported
-       */
-      class TAGLIB_EXPORT Tag : public Strawberry_TagLib::TagLib::Tag
-      {
-      public:
-        Tag();
-        virtual ~Tag();
-
-        /*!
-         * Returns the track name; if no track name is present in the tag
-         * String() will be returned.
-         */
-        String title() const;
-
-        /*!
-         * Returns the artist name; if no artist name is present in the tag
-         * String() will be returned.
-         */
-        String artist() const;
-
-        /*!
-         * Not supported.  Therefore always returns String().
-         */
-        String album() const;
-
-        /*!
-         * Not supported.  Therefore always returns String().
-         */
-        String comment() const;
-
-        /*!
-         * Not supported.  Therefore always returns String().
-         */
-        String genre() const;
-
-        /*!
-         * Not supported.  Therefore always returns 0.
-         */
-        unsigned int year() const;
-
-        /*!
-         * Not supported.  Therefore always returns 0.
-         */
-        unsigned int track() const;
-
-        /*!
-         * Sets the title to \a title.  If \a title is String() then this
-         * value will be cleared.
-         */
-        void setTitle(const String &title);
-
-        /*!
-         * Sets the artist to \a artist.  If \a artist is String() then this
-         * value will be cleared.
-         */
-        void setArtist(const String &artist);
-
-        /*!
-         * Not supported and therefore ignored.
-         */
-        void setAlbum(const String &album);
-
-        /*!
-         * Not supported and therefore ignored.
-         */
-        void setComment(const String &comment);
-
-        /*!
-         * Not supported and therefore ignored.
-         */
-        void setGenre(const String &genre);
-
-        /*!
-         * Not supported and therefore ignored.
-         */
-        void setYear(unsigned int year);
-
-        /*!
-         * Not supported and therefore ignored.
-         */
-        void setTrack(unsigned int track);
-
-        /*!
-         * Implements the unified property interface -- export function.
-         * Since the DIIN tag is very limited, the exported map is as well.
-         */
-        PropertyMap properties() const;
-
-        /*!
-         * Implements the unified property interface -- import function.
-         * Because of the limitations of the DIIN file tag, any tags besides
-         * TITLE and ARTIST, will be
-         * returned. Additionally, if the map contains tags with multiple values,
-         * all but the first will be contained in the returned map of unsupported
-         * properties.
-         */
-        PropertyMap setProperties(const PropertyMap &);
-
-      private:
-        Tag(const Tag &);
-        Tag &operator=(const Tag &);
-
-        class TagPrivate;
-        TagPrivate *d;
-      };
-    }
-  }
-}
-}
-
-#endif
-

3rdparty/taglib/dsdiff/dsdifffile.cpp

@@ -1,923 +0,0 @@
-/***************************************************************************
- copyright            : (C) 2016 by Damien Plisson, Audirvana
- email                : damien78@audirvana.com
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <tbytevector.h>
-#include <tdebug.h>
-#include <id3v2tag.h>
-#include <tstringlist.h>
-#include <tpropertymap.h>
-#include <tagutils.h>
-
-#include "tagunion.h"
-#include "dsdifffile.h"
-
-#include <array>
-
-using namespace Strawberry_TagLib::TagLib;
-
-namespace
-{
-  struct Chunk64
-  {
-    ByteVector name;
-    unsigned long long offset;
-    unsigned long long size;
-    char padding;
-  };
-
-  typedef std::vector<Chunk64> ChunkList;
-
-  int chunkIndex(const ChunkList &chunks, const ByteVector &id)
-  {
-    for(int i = 0; i < chunks.size(); i++) {
-      if(chunks[i].name == id)
-        return i;
-    }
-
-    return -1;
-  }
-
-  bool isValidChunkID(const ByteVector &name)
-  {
-    if(name.size() != 4)
-      return false;
-
-    for(int i = 0; i < 4; i++) {
-      if(name[i] < 32 || name[i] > 127)
-        return false;
-    }
-
-    return true;
-  }
-
-  enum {
-    ID3v2Index = 0,
-    DIINIndex = 1
-  };
-  enum {
-    PROPChunk = 0,
-    DIINChunk = 1
-  };
-}
-
-class DSDIFF::File::FilePrivate
-{
-public:
-  FilePrivate() :
-    endianness(BigEndian),
-    size(0),
-    isID3InPropChunk(false),
-    duplicateID3V2chunkIndex(-1),
-    properties(0),
-    id3v2TagChunkID("ID3 "),
-    hasID3v2(false),
-    hasDiin(false)
-  {
-    childChunkIndex[ID3v2Index] = -1;
-    childChunkIndex[DIINIndex] = -1;
-  }
-
-  ~FilePrivate()
-  {
-    delete properties;
-  }
-
-  Endianness endianness;
-  ByteVector type;
-  unsigned long long size;
-  ByteVector format;
-  ChunkList chunks;
-  std::array<ChunkList, 2> childChunks;
-  std::array<int, 2> childChunkIndex;
-  /*
-   * Two possibilities can be found: ID3V2 chunk inside PROP chunk or at root level
-   */
-  bool isID3InPropChunk;
-  /*
-   * ID3 chunks are present. This is then the index of the one in PROP chunk that
-   * will be removed upon next save to remove duplicates.
-   */
-  int duplicateID3V2chunkIndex;
-
-  Properties *properties;
-
-  TagUnion tag;
-
-  ByteVector id3v2TagChunkID;
-
-  bool hasID3v2;
-  bool hasDiin;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// static members
-////////////////////////////////////////////////////////////////////////////////
-
-bool DSDIFF::File::isSupported(IOStream *stream)
-{
-    // A DSDIFF file has to start with "FRM8????????DSD ".
-
-    const ByteVector id = Utils::readHeader(stream, 16, false);
-    return (id.startsWith("FRM8") && id.containsAt("DSD ", 12));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// public members
-////////////////////////////////////////////////////////////////////////////////
-
-DSDIFF::File::File(FileName file, bool readProperties,
-                   Properties::ReadStyle propertiesStyle) : Strawberry_TagLib::TagLib::File(file)
-{
-  d = new FilePrivate;
-  d->endianness = BigEndian;
-  if(isOpen())
-    read(readProperties, propertiesStyle);
-}
-
-DSDIFF::File::File(IOStream *stream, bool readProperties,
-                   Properties::ReadStyle propertiesStyle) : Strawberry_TagLib::TagLib::File(stream)
-{
-  d = new FilePrivate;
-  d->endianness = BigEndian;
-  if(isOpen())
-    read(readProperties, propertiesStyle);
-}
-
-DSDIFF::File::~File()
-{
-  delete d;
-}
-
-Strawberry_TagLib::TagLib::Tag *DSDIFF::File::tag() const
-{
-  return &d->tag;
-}
-
-ID3v2::Tag *DSDIFF::File::ID3v2Tag(bool create) const
-{
-  return d->tag.access<ID3v2::Tag>(ID3v2Index, create);
-}
-
-bool DSDIFF::File::hasID3v2Tag() const
-{
-  return d->hasID3v2;
-}
-
-DSDIFF::DIIN::Tag *DSDIFF::File::DIINTag(bool create) const
-{
-  return d->tag.access<DSDIFF::DIIN::Tag>(DIINIndex, create);
-}
-
-bool DSDIFF::File::hasDIINTag() const
-{
-  return d->hasDiin;
-}
-
-PropertyMap DSDIFF::File::properties() const
-{
-  if(d->hasID3v2)
-    return d->tag.access<ID3v2::Tag>(ID3v2Index, false)->properties();
-
-  return PropertyMap();
-}
-
-void DSDIFF::File::removeUnsupportedProperties(const StringList &unsupported)
-{
-  if(d->hasID3v2)
-    d->tag.access<ID3v2::Tag>(ID3v2Index, false)->removeUnsupportedProperties(unsupported);
-
-  if(d->hasDiin)
-    d->tag.access<DSDIFF::DIIN::Tag>(DIINIndex, false)->removeUnsupportedProperties(unsupported);
-}
-
-PropertyMap DSDIFF::File::setProperties(const PropertyMap &properties)
-{
-  return d->tag.access<ID3v2::Tag>(ID3v2Index, true)->setProperties(properties);
-}
-
-DSDIFF::Properties *DSDIFF::File::audioProperties() const
-{
-  return d->properties;
-}
-
-bool DSDIFF::File::save()
-{
-  return save(AllTags);
-}
-
-bool DSDIFF::File::save(TagTypes tags, StripTags strip, ID3v2::Version version)
-{
-  if(readOnly()) {
-    debug("DSDIFF::File::save() -- File is read only.");
-    return false;
-  }
-
-  if(!isValid()) {
-    debug("DSDIFF::File::save() -- Trying to save invalid file.");
-    return false;
-  }
-
-  //if(strip == StripOthers || strip == StripAll)
-    //File::strip(static_cast<TagTypes>(AllTags & ~tags));
-
-  // First: save ID3V2 chunk
-
-  ID3v2::Tag *id3v2Tag = d->tag.access<ID3v2::Tag>(ID3v2Index, false);
-
-  if(tags & ID3v2 && id3v2Tag) {
-    if(d->isID3InPropChunk) {
-      if(id3v2Tag && !id3v2Tag->isEmpty()) {
-        setChildChunkData(d->id3v2TagChunkID, id3v2Tag->render(version), PROPChunk);
-        d->hasID3v2 = true;
-      }
-      else {
-        // Empty tag: remove it
-        setChildChunkData(d->id3v2TagChunkID, ByteVector(), PROPChunk);
-        d->hasID3v2 = false;
-      }
-    }
-    else {
-      if(id3v2Tag && !id3v2Tag->isEmpty()) {
-        setRootChunkData(d->id3v2TagChunkID, id3v2Tag->render(version));
-        d->hasID3v2 = true;
-      }
-      else {
-        // Empty tag: remove it
-        setRootChunkData(d->id3v2TagChunkID, ByteVector());
-        d->hasID3v2 = false;
-      }
-    }
-  }
-
-  // Second: save the DIIN chunk
-
-  DSDIFF::DIIN::Tag *diinTag = d->tag.access<DSDIFF::DIIN::Tag>(DIINIndex, false);
-
-  if(tags & DIIN && diinTag) {
-    if(!diinTag->title().isEmpty()) {
-      ByteVector diinTitle;
-      diinTitle.append(ByteVector::fromUInt(diinTag->title().size(), d->endianness == BigEndian));
-      diinTitle.append(ByteVector::fromCString(diinTag->title().toCString()));
-      setChildChunkData("DITI", diinTitle, DIINChunk);
-    }
-    else
-      setChildChunkData("DITI", ByteVector(), DIINChunk);
-
-    if(!diinTag->artist().isEmpty()) {
-      ByteVector diinArtist;
-      diinArtist.append(ByteVector::fromUInt(diinTag->artist().size(), d->endianness == BigEndian));
-      diinArtist.append(ByteVector::fromCString(diinTag->artist().toCString()));
-      setChildChunkData("DIAR", diinArtist, DIINChunk);
-    }
-    else
-      setChildChunkData("DIAR", ByteVector(), DIINChunk);
-  }
-
-  // Third: remove the duplicate ID3V2 chunk (inside PROP chunk) if any
-  if(d->duplicateID3V2chunkIndex>=0) {
-    setChildChunkData(d->duplicateID3V2chunkIndex, ByteVector(), PROPChunk);
-    d->duplicateID3V2chunkIndex = -1;
-  }
-
-  return true;
-}
-
-void DSDIFF::File::strip(TagTypes tags)
-{
-  if(tags & ID3v2) {
-    removeRootChunk("ID3 ");
-    removeRootChunk("id3 ");
-    d->hasID3v2 = false;
-    d->tag.set(ID3v2Index, new ID3v2::Tag);
-
-    /// TODO: needs to also account for ID3v2 tags under the PROP chunk
-  }
-  if(tags & DIIN) {
-    removeRootChunk("DITI");
-    removeRootChunk("DIAR");
-    d->hasDiin = false;
-    d->tag.set(DIINIndex, new DIIN::Tag);
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// private members
-////////////////////////////////////////////////////////////////////////////////
-
-void DSDIFF::File::removeRootChunk(unsigned int i)
-{
-    unsigned long long chunkSize = d->chunks[i].size + d->chunks[i].padding + 12;
-
-    d->size -= chunkSize;
-    insert(ByteVector::fromLongLong(d->size, d->endianness == BigEndian), 4, 8);
-
-    removeBlock(d->chunks[i].offset - 12, chunkSize);
-
-    // Update the internal offsets
-
-    for(unsigned long r = i + 1; r < d->chunks.size(); r++)
-      d->chunks[r].offset = d->chunks[r - 1].offset + 12
-        + d->chunks[r - 1].size + d->chunks[r - 1].padding;
-
-    d->chunks.erase(d->chunks.begin() + i);
-}
-
-void DSDIFF::File::removeRootChunk(const ByteVector &id)
-{
-  int i = chunkIndex(d->chunks, id);
-
-  if(i >= 0)
-    removeRootChunk(i);
-}
-
-void DSDIFF::File::setRootChunkData(unsigned int i, const ByteVector &data)
-{
-  if(data.isEmpty()) {
-    removeRootChunk(i);
-    return;
-  }
-
-  // Non null data: update chunk
-  // First we update the global size
-
-  d->size += ((data.size() + 1) & ~1) - (d->chunks[i].size + d->chunks[i].padding);
-  insert(ByteVector::fromLongLong(d->size, d->endianness == BigEndian), 4, 8);
-
-  // Now update the specific chunk
-
-  writeChunk(d->chunks[i].name,
-             data,
-             d->chunks[i].offset - 12,
-             d->chunks[i].size + d->chunks[i].padding + 12);
-
-  d->chunks[i].size = data.size();
-  d->chunks[i].padding = (data.size() & 0x01) ? 1 : 0;
-
-  // Finally update the internal offsets
-
-  updateRootChunksStructure(i + 1);
-}
-
-void DSDIFF::File::setRootChunkData(const ByteVector &name, const ByteVector &data)
-{
-  if(d->chunks.size() == 0) {
-    debug("DSDIFF::File::setPropChunkData - No valid chunks found.");
-    return;
-  }
-
-  int i = chunkIndex(d->chunks, name);
-
-  if(i >= 0) {
-    setRootChunkData(i, data);
-    return;
-  }
-
-  // Couldn't find an existing chunk, so let's create a new one.
-  i = d->chunks.size() - 1;
-  unsigned long offset = d->chunks[i].offset + d->chunks[i].size + d->chunks[i].padding;
-
-  // First we update the global size
-  d->size += (offset & 1) + ((data.size() + 1) & ~1) + 12;
-  insert(ByteVector::fromLongLong(d->size, d->endianness == BigEndian), 4, 8);
-
-  // Now add the chunk to the file
-  writeChunk(name,
-             data,
-             offset,
-             std::max<unsigned long long>(0, length() - offset),
-             (offset & 1) ? 1 : 0);
-
-  Chunk64 chunk;
-  chunk.name = name;
-  chunk.size = data.size();
-  chunk.offset = offset + 12;
-  chunk.padding = (data.size() & 0x01) ? 1 : 0;
-
-  d->chunks.push_back(chunk);
-}
-
-void DSDIFF::File::removeChildChunk(unsigned int i, unsigned int childChunkNum)
-{
-    ChunkList &childChunks = d->childChunks[childChunkNum];
-
-    // Update global size
-
-    unsigned long long removedChunkTotalSize = childChunks[i].size + childChunks[i].padding + 12;
-    d->size -= removedChunkTotalSize;
-    insert(ByteVector::fromLongLong(d->size, d->endianness == BigEndian), 4, 8);
-
-    // Update child chunk size
-
-    d->chunks[d->childChunkIndex[childChunkNum]].size -= removedChunkTotalSize;
-    insert(ByteVector::fromLongLong(d->chunks[d->childChunkIndex[childChunkNum]].size,
-                                    d->endianness == BigEndian),
-           d->chunks[d->childChunkIndex[childChunkNum]].offset - 8, 8);
-    // Remove the chunk
-
-    removeBlock(childChunks[i].offset - 12, removedChunkTotalSize);
-
-    // Update the internal offsets
-    // For child chunks
-
-    if((i + 1) < childChunks.size()) {
-      childChunks[i + 1].offset = childChunks[i].offset;
-      i++;
-      for(i++; i < childChunks.size(); i++)
-        childChunks[i].offset = childChunks[i - 1].offset + 12
-          + childChunks[i - 1].size + childChunks[i - 1].padding;
-    }
-
-    // And for root chunks
-
-    for(i = d->childChunkIndex[childChunkNum] + 1; i < d->chunks.size(); i++)
-      d->chunks[i].offset = d->chunks[i - 1].offset + 12
-        + d->chunks[i - 1].size + d->chunks[i - 1].padding;
-
-    childChunks.erase(childChunks.begin() + i);
-}
-
-void DSDIFF::File::setChildChunkData(unsigned int i,
-                                     const ByteVector &data,
-                                     unsigned int childChunkNum)
-{
-  ChunkList &childChunks = d->childChunks[childChunkNum];
-
-  if(data.isEmpty()) {
-    removeChildChunk(i, childChunkNum);
-    return;
-  }
-
-  // Non null data: update chunk
-  // First we update the global size
-
-  d->size += ((data.size() + 1) & ~1) - (childChunks[i].size + childChunks[i].padding);
-
-  insert(ByteVector::fromLongLong(d->size, d->endianness == BigEndian), 4, 8);
-
-  // And the PROP chunk size
-
-  d->chunks[d->childChunkIndex[childChunkNum]].size +=
-    ((data.size() + 1) & ~1) - (childChunks[i].size + childChunks[i].padding);
-  insert(ByteVector::fromLongLong(d->chunks[d->childChunkIndex[childChunkNum]].size,
-                                  d->endianness == BigEndian),
-         d->chunks[d->childChunkIndex[childChunkNum]].offset - 8, 8);
-
-  // Now update the specific chunk
-
-  writeChunk(childChunks[i].name,
-             data,
-             childChunks[i].offset - 12,
-             childChunks[i].size + childChunks[i].padding + 12);
-
-  childChunks[i].size = data.size();
-  childChunks[i].padding = (data.size() & 0x01) ? 1 : 0;
-
-  // Now update the internal offsets
-  // For child Chunks
-  for(i++; i < childChunks.size(); i++)
-    childChunks[i].offset = childChunks[i - 1].offset + 12
-                            + childChunks[i - 1].size + childChunks[i - 1].padding;
-
-  // And for root chunks
-  updateRootChunksStructure(d->childChunkIndex[childChunkNum] + 1);
-}
-
-void DSDIFF::File::setChildChunkData(const ByteVector &name,
-                                     const ByteVector &data,
-                                     unsigned int childChunkNum)
-{
-  ChunkList &childChunks = d->childChunks[childChunkNum];
-
-  if(childChunks.size() == 0) {
-    debug("DSDIFF::File::setPropChunkData - No valid chunks found.");
-    return;
-  }
-
-  for(unsigned int i = 0; i < childChunks.size(); i++) {
-    if(childChunks[i].name == name) {
-      setChildChunkData(i, data, childChunkNum);
-      return;
-    }
-  }
-
-  // Do not attempt to remove a non existing chunk
-
-  if(data.isEmpty())
-    return;
-
-  // Couldn't find an existing chunk, so let's create a new one.
-
-  unsigned int i = childChunks.size() - 1;
-  unsigned long offset = childChunks[i].offset + childChunks[i].size + childChunks[i].padding;
-
-  // First we update the global size
-
-  d->size += (offset & 1) + ((data.size() + 1) & ~1) + 12;
-  insert(ByteVector::fromLongLong(d->size, d->endianness == BigEndian), 4, 8);
-
-  // And the child chunk size
-
-  d->chunks[d->childChunkIndex[childChunkNum]].size += (offset & 1)
-    + ((data.size() + 1) & ~1) + 12;
-  insert(ByteVector::fromLongLong(d->chunks[d->childChunkIndex[childChunkNum]].size,
-                                  d->endianness == BigEndian),
-         d->chunks[d->childChunkIndex[childChunkNum]].offset - 8, 8);
-
-  // Now add the chunk to the file
-
-  unsigned long long nextRootChunkIdx = length();
-  if((d->childChunkIndex[childChunkNum] + 1) < static_cast<int>(d->chunks.size()))
-    nextRootChunkIdx = d->chunks[d->childChunkIndex[childChunkNum] + 1].offset - 12;
-
-  writeChunk(name, data, offset,
-             std::max<unsigned long long>(0, nextRootChunkIdx - offset),
-             (offset & 1) ? 1 : 0);
-
-  // For root chunks
-
-  updateRootChunksStructure(d->childChunkIndex[childChunkNum] + 1);
-
-  Chunk64 chunk;
-  chunk.name = name;
-  chunk.size = data.size();
-  chunk.offset = offset + 12;
-  chunk.padding = (data.size() & 0x01) ? 1 : 0;
-
-  childChunks.push_back(chunk);
-}
-
-void DSDIFF::File::updateRootChunksStructure(unsigned int startingChunk)
-{
-  for(unsigned int i = startingChunk; i < d->chunks.size(); i++)
-    d->chunks[i].offset = d->chunks[i - 1].offset + 12
-      + d->chunks[i - 1].size + d->chunks[i - 1].padding;
-
-  // Update childchunks structure as well
-
-  if(d->childChunkIndex[PROPChunk] >= static_cast<int>(startingChunk)) {
-    ChunkList &childChunksToUpdate = d->childChunks[PROPChunk];
-    if(childChunksToUpdate.size() > 0) {
-      childChunksToUpdate[0].offset = d->chunks[d->childChunkIndex[PROPChunk]].offset + 12;
-      for(unsigned int i = 1; i < childChunksToUpdate.size(); i++)
-        childChunksToUpdate[i].offset = childChunksToUpdate[i - 1].offset + 12
-          + childChunksToUpdate[i - 1].size + childChunksToUpdate[i - 1].padding;
-    }
-
-  }
-  if(d->childChunkIndex[DIINChunk] >= static_cast<int>(startingChunk)) {
-    ChunkList &childChunksToUpdate = d->childChunks[DIINChunk];
-    if(childChunksToUpdate.size() > 0) {
-      childChunksToUpdate[0].offset = d->chunks[d->childChunkIndex[DIINChunk]].offset + 12;
-      for(unsigned int i = 1; i < childChunksToUpdate.size(); i++)
-        childChunksToUpdate[i].offset = childChunksToUpdate[i - 1].offset + 12
-          + childChunksToUpdate[i - 1].size + childChunksToUpdate[i - 1].padding;
-    }
-  }
-}
-
-void DSDIFF::File::read(bool readProperties, Properties::ReadStyle propertiesStyle)
-{
-  bool bigEndian = (d->endianness == BigEndian);
-
-  d->type = readBlock(4);
-  d->size = readBlock(8).toLongLong(bigEndian);
-  d->format = readBlock(4);
-
-  // + 12: chunk header at least, fix for additional junk bytes
-
-  while(tell() + 12 <= length()) {
-    ByteVector chunkName = readBlock(4);
-    unsigned long long chunkSize = readBlock(8).toLongLong(bigEndian);
-
-    if(!isValidChunkID(chunkName)) {
-      debug("DSDIFF::File::read() -- Chunk '" + chunkName + "' has invalid ID");
-      setValid(false);
-      break;
-    }
-
-    if(static_cast<unsigned long long>(tell()) + chunkSize >
-       static_cast<unsigned long long>(length())) {
-      debug("DSDIFF::File::read() -- Chunk '" + chunkName
-            + "' has invalid size (larger than the file size)");
-      setValid(false);
-      break;
-    }
-
-    Chunk64 chunk;
-    chunk.name = chunkName;
-    chunk.size = chunkSize;
-    chunk.offset = tell();
-
-    seek(chunk.size, Current);
-
-    // Check padding
-
-    chunk.padding = 0;
-    long uPosNotPadded = tell();
-    if((uPosNotPadded & 0x01) != 0) {
-      ByteVector iByte = readBlock(1);
-      if((iByte.size() != 1) || (iByte[0] != 0))
-        // Not well formed, re-seek
-        seek(uPosNotPadded, Beginning);
-      else
-        chunk.padding = 1;
-    }
-    d->chunks.push_back(chunk);
-  }
-
-  // For DSD uncompressed
-  unsigned long long lengthDSDSamplesTimeChannels = 0;
-  // For computing bitrate
-  unsigned long long audioDataSizeinBytes = 0;
-  // For DST compressed frames
-  unsigned long dstNumFrames = 0;
-  // For DST compressed frames
-  unsigned short dstFrameRate = 0;
-
-  for(unsigned int i = 0; i < d->chunks.size(); i++) {
-    if(d->chunks[i].name == "DSD ") {
-      lengthDSDSamplesTimeChannels = d->chunks[i].size * 8;
-      audioDataSizeinBytes = d->chunks[i].size;
-    }
-    else if(d->chunks[i].name == "DST ") {
-      // Now decode the chunks inside the DST chunk to read the DST Frame Information one
-      long long dstChunkEnd = d->chunks[i].offset + d->chunks[i].size;
-      seek(d->chunks[i].offset);
-
-      audioDataSizeinBytes = d->chunks[i].size;
-
-      while(tell() + 12 <= dstChunkEnd) {
-        ByteVector dstChunkName = readBlock(4);
-        long long dstChunkSize = readBlock(8).toLongLong(bigEndian);
-
-        if(!isValidChunkID(dstChunkName)) {
-          debug("DSDIFF::File::read() -- DST Chunk '" + dstChunkName + "' has invalid ID");
-          setValid(false);
-          break;
-        }
-
-        if(static_cast<long long>(tell()) + dstChunkSize > dstChunkEnd) {
-          debug("DSDIFF::File::read() -- DST Chunk '" + dstChunkName
-                + "' has invalid size (larger than the DST chunk)");
-          setValid(false);
-          break;
-        }
-
-        if(dstChunkName == "FRTE") {
-          // Found the DST frame information chunk
-          dstNumFrames = readBlock(4).toUInt(bigEndian);
-          dstFrameRate = readBlock(2).toUShort(bigEndian);
-          // Found the wanted one, no need to look at the others
-          break;
-        }
-
-        seek(dstChunkSize, Current);
-
-        // Check padding
-        long uPosNotPadded = tell();
-        if((uPosNotPadded & 0x01) != 0) {
-          ByteVector iByte = readBlock(1);
-          if((iByte.size() != 1) || (iByte[0] != 0))
-            // Not well formed, re-seek
-            seek(uPosNotPadded, Beginning);
-        }
-      }
-    }
-    else if(d->chunks[i].name == "PROP") {
-      d->childChunkIndex[PROPChunk] = i;
-      // Now decodes the chunks inside the PROP chunk
-      long long propChunkEnd = d->chunks[i].offset + d->chunks[i].size;
-      // +4 to remove the 'SND ' marker at beginning of 'PROP' chunk
-      seek(d->chunks[i].offset + 4);
-      while(tell() + 12 <= propChunkEnd) {
-        ByteVector propChunkName = readBlock(4);
-        long long propChunkSize = readBlock(8).toLongLong(bigEndian);
-
-        if(!isValidChunkID(propChunkName)) {
-          debug("DSDIFF::File::read() -- PROP Chunk '" + propChunkName + "' has invalid ID");
-          setValid(false);
-          break;
-        }
-
-        if(static_cast<long long>(tell()) + propChunkSize > propChunkEnd) {
-          debug("DSDIFF::File::read() -- PROP Chunk '" + propChunkName
-                + "' has invalid size (larger than the PROP chunk)");
-          setValid(false);
-          break;
-        }
-
-        Chunk64 chunk;
-        chunk.name = propChunkName;
-        chunk.size = propChunkSize;
-        chunk.offset = tell();
-
-        seek(chunk.size, Current);
-
-        // Check padding
-        chunk.padding = 0;
-        long uPosNotPadded = tell();
-        if((uPosNotPadded & 0x01) != 0) {
-          ByteVector iByte = readBlock(1);
-          if((iByte.size() != 1) || (iByte[0] != 0))
-            // Not well formed, re-seek
-            seek(uPosNotPadded, Beginning);
-          else
-            chunk.padding = 1;
-        }
-        d->childChunks[PROPChunk].push_back(chunk);
-      }
-    }
-    else if(d->chunks[i].name == "DIIN") {
-      d->childChunkIndex[DIINChunk] = i;
-      d->hasDiin = true;
-
-      // Now decode the chunks inside the DIIN chunk
-
-      long long diinChunkEnd = d->chunks[i].offset + d->chunks[i].size;
-      seek(d->chunks[i].offset);
-
-      while(tell() + 12 <= diinChunkEnd) {
-        ByteVector diinChunkName = readBlock(4);
-        long long diinChunkSize = readBlock(8).toLongLong(bigEndian);
-
-        if(!isValidChunkID(diinChunkName)) {
-          debug("DSDIFF::File::read() -- DIIN Chunk '" + diinChunkName + "' has invalid ID");
-          setValid(false);
-          break;
-        }
-
-        if(static_cast<long long>(tell()) + diinChunkSize > diinChunkEnd) {
-          debug("DSDIFF::File::read() -- DIIN Chunk '" + diinChunkName
-                + "' has invalid size (larger than the DIIN chunk)");
-          setValid(false);
-          break;
-        }
-
-        Chunk64 chunk;
-        chunk.name = diinChunkName;
-        chunk.size = diinChunkSize;
-        chunk.offset = tell();
-
-        seek(chunk.size, Current);
-
-        // Check padding
-
-        chunk.padding = 0;
-        long uPosNotPadded = tell();
-
-        if((uPosNotPadded & 0x01) != 0) {
-          ByteVector iByte = readBlock(1);
-          if((iByte.size() != 1) || (iByte[0] != 0))
-            // Not well formed, re-seek
-            seek(uPosNotPadded, Beginning);
-          else
-            chunk.padding = 1;
-        }
-        d->childChunks[DIINChunk].push_back(chunk);
-      }
-    }
-    else if(d->chunks[i].name == "ID3 " || d->chunks[i].name == "id3 ") {
-      d->id3v2TagChunkID = d->chunks[i].name;
-      d->tag.set(ID3v2Index, new ID3v2::Tag(this, d->chunks[i].offset));
-      d->isID3InPropChunk = false;
-      d->hasID3v2 = true;
-    }
-  }
-
-  if(!isValid())
-    return;
-
-  if(d->childChunkIndex[PROPChunk] < 0) {
-    debug("DSDIFF::File::read() -- no PROP chunk found");
-    setValid(false);
-    return;
-  }
-
-  // Read properties
-
-  unsigned int sampleRate=0;
-  unsigned short channels=0;
-
-  for(unsigned int i = 0; i < d->childChunks[PROPChunk].size(); i++) {
-    if(d->childChunks[PROPChunk][i].name == "ID3 " ||
-       d->childChunks[PROPChunk][i].name == "id3 ") {
-      if(d->hasID3v2) {
-        d->duplicateID3V2chunkIndex = i;
-        // ID3V2 tag has already been found at root level
-        continue;
-      }
-      d->id3v2TagChunkID = d->childChunks[PROPChunk][i].name;
-      d->tag.set(ID3v2Index, new ID3v2::Tag(this, d->childChunks[PROPChunk][i].offset));
-      d->isID3InPropChunk = true;
-      d->hasID3v2 = true;
-    }
-    else if(d->childChunks[PROPChunk][i].name == "FS  ") {
-      // Sample rate
-      seek(d->childChunks[PROPChunk][i].offset);
-      sampleRate = readBlock(4).toUInt(0, 4, bigEndian);
-    }
-    else if(d->childChunks[PROPChunk][i].name == "CHNL") {
-      // Channels
-      seek(d->childChunks[PROPChunk][i].offset);
-      channels = readBlock(2).toShort(0, bigEndian);
-    }
-  }
-
-  // Read title & artist from DIIN chunk
-
-  d->tag.access<DSDIFF::DIIN::Tag>(DIINIndex, true);
-
-  if(d->hasDiin) {
-    for(unsigned int i = 0; i < d->childChunks[DIINChunk].size(); i++) {
-      if(d->childChunks[DIINChunk][i].name == "DITI") {
-        seek(d->childChunks[DIINChunk][i].offset);
-        unsigned int titleStrLength = readBlock(4).toUInt(0, 4, bigEndian);
-        if(titleStrLength <= d->childChunks[DIINChunk][i].size) {
-          ByteVector titleStr = readBlock(titleStrLength);
-          d->tag.access<DSDIFF::DIIN::Tag>(DIINIndex, false)->setTitle(titleStr);
-        }
-      }
-      else if(d->childChunks[DIINChunk][i].name == "DIAR") {
-        seek(d->childChunks[DIINChunk][i].offset);
-        unsigned int artistStrLength = readBlock(4).toUInt(0, 4, bigEndian);
-        if(artistStrLength <= d->childChunks[DIINChunk][i].size) {
-          ByteVector artistStr = readBlock(artistStrLength);
-          d->tag.access<DSDIFF::DIIN::Tag>(DIINIndex, false)->setArtist(artistStr);
-        }
-      }
-    }
-  }
-
-  if(readProperties) {
-    if(lengthDSDSamplesTimeChannels == 0) {
-      // DST compressed signal : need to compute length of DSD uncompressed frames
-      if(dstFrameRate > 0)
-        lengthDSDSamplesTimeChannels = (unsigned long long) dstNumFrames *
-                                       (unsigned long long) sampleRate /
-                                       (unsigned long long) dstFrameRate;
-      else
-        lengthDSDSamplesTimeChannels = 0;
-    }
-    else {
-      // In DSD uncompressed files, the read number of samples is the total for each channel
-      if(channels > 0)
-        lengthDSDSamplesTimeChannels /= channels;
-    }
-    int bitrate = 0;
-    if(lengthDSDSamplesTimeChannels > 0)
-      bitrate = (audioDataSizeinBytes * 8 * sampleRate) / lengthDSDSamplesTimeChannels / 1000;
-
-    d->properties = new Properties(sampleRate,
-                                   channels,
-                                   lengthDSDSamplesTimeChannels,
-                                   bitrate,
-                                   propertiesStyle);
-  }
-
-  if(!ID3v2Tag()) {
-    d->tag.access<ID3v2::Tag>(ID3v2Index, true);
-    // By default, ID3 chunk is at root level
-    d->isID3InPropChunk = false;
-    d->hasID3v2 = false;
-  }
-}
-
-void DSDIFF::File::writeChunk(const ByteVector &name, const ByteVector &data,
-                              unsigned long long offset, unsigned long replace,
-                              unsigned int leadingPadding)
-{
-  ByteVector combined;
-  if(leadingPadding)
-    combined.append(ByteVector(leadingPadding, '\x00'));
-
-  combined.append(name);
-  combined.append(ByteVector::fromLongLong(data.size(), d->endianness == BigEndian));
-  combined.append(data);
-  if((data.size() & 0x01) != 0)
-    combined.append('\x00');
-
-  insert(combined, offset, replace);
-}
-

3rdparty/taglib/dsdiff/dsdifffile.h

@@ -1,288 +0,0 @@
-/***************************************************************************
- copyright            : (C) 2016 by Damien Plisson, Audirvana
- email                : damien78@audirvana.com
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_DSDIFFFILE_H
-#define TAGLIB_DSDIFFFILE_H
-
-#include "rifffile.h"
-#include "id3v2tag.h"
-#include "dsdiffproperties.h"
-#include "dsdiffdiintag.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  //! An implementation of DSDIFF metadata
-
-  /*!
-   * This is implementation of DSDIFF metadata.
-   *
-   * This supports an ID3v2 tag as well as reading stream from the ID3 RIFF
-   * chunk as well as properties from the file.
-   * Description of the DSDIFF format is available
-   * at http://dsd-guide.com/sites/default/files/white-papers/DSDIFF_1.5_Spec.pdf
-   * DSDIFF standard does not explicitly specify the ID3V2 chunk
-   * It can be found at the root level, but also sometimes inside the PROP chunk
-   * In addition, title and artist info are stored as part of the standard
-   */
-
-  namespace DSDIFF {
-
-    //! An implementation of TagLib::File with DSDIFF specific methods
-
-    /*!
-     * This implements and provides an interface for DSDIFF files to the
-     * TagLib::Tag and TagLib::AudioProperties interfaces by way of implementing
-     * the abstract TagLib::File API as well as providing some additional
-     * information specific to DSDIFF files.
-     */
-
-    class TAGLIB_EXPORT File : public Strawberry_TagLib::TagLib::File
-    {
-    public:
-
-      /*!
-       * This set of flags is used for various operations and is suitable for
-       * being OR-ed together.
-       */
-      enum TagTypes {
-        //! Empty set.  Matches no tag types.
-        NoTags  = 0x0000,
-        //! Matches DIIN tags.
-        DIIN   = 0x0002,
-        //! Matches ID3v1 tags.
-        ID3v2   = 0x0002,
-        //! Matches all tag types.
-        AllTags = 0xffff
-      };
-
-      /*!
-       * Constructs an DSDIFF file from \a file.  If \a readProperties is true
-       * the file's audio properties will also be read.
-       *
-       * \note In the current implementation, \a propertiesStyle is ignored.
-       */
-      File(FileName file, bool readProperties = true,
-           Properties::ReadStyle propertiesStyle = Properties::Average);
-
-      /*!
-       * Constructs an DSDIFF file from \a stream.  If \a readProperties is true
-       * the file's audio properties will also be read.
-       *
-       * \note TagLib will *not* take ownership of the stream, the caller is
-       * responsible for deleting it after the File object.
-       *
-       * \note In the current implementation, \a propertiesStyle is ignored.
-       */
-      File(IOStream *stream, bool readProperties = true,
-           Properties::ReadStyle propertiesStyle = Properties::Average);
-
-      /*!
-       * Destroys this instance of the File.
-       */
-      virtual ~File();
-
-      /*!
-       * Returns a pointer to a tag that is the union of the ID3v2 and DIIN
-       * tags. The ID3v2 tag is given priority in reading the information -- if
-       * requested information exists in both the ID3v2 tag and the ID3v1 tag,
-       * the information from the ID3v2 tag will be returned.
-       *
-       * If you would like more granular control over the content of the tags,
-       * with the concession of generality, use the tag-type specific calls.
-       *
-       * \note As this tag is not implemented as an ID3v2 tag or a DIIN tag,
-       * but a union of the two this pointer may not be cast to the specific
-       * tag types.
-       *
-       * \see ID3v2Tag()
-       * \see DIINTag()
-       */
-      virtual Tag *tag() const;
-
-      /*!
-       * Returns the ID3V2 Tag for this file.
-       *
-       * \note This always returns a valid pointer regardless of whether or not
-       * the file on disk has an ID3v2 tag.  Use hasID3v2Tag() to check if the
-       * file on disk actually has an ID3v2 tag.
-       *
-       * \see hasID3v2Tag()
-       */
-      ID3v2::Tag *ID3v2Tag(bool create = false) const;
-
-      /*!
-       * Returns the DSDIFF DIIN Tag for this file
-       *
-       */
-      DSDIFF::DIIN::Tag *DIINTag(bool create = false) const;
-
-      /*!
-       * Implements the unified property interface -- export function.
-       * This method forwards to ID3v2::Tag::properties().
-       */
-      PropertyMap properties() const;
-
-      void removeUnsupportedProperties(const StringList &properties);
-
-      /*!
-       * Implements the unified property interface -- import function.
-       * This method forwards to ID3v2::Tag::setProperties().
-       */
-      PropertyMap setProperties(const PropertyMap &);
-
-      /*!
-       * Returns the AIFF::Properties for this file.  If no audio properties
-       * were read then this will return a null pointer.
-       */
-      virtual Properties *audioProperties() const;
-
-      /*!
-       * Save the file.  If at least one tag -- ID3v1 or DIIN -- exists this
-       * will duplicate its content into the other tag.  This returns true
-       * if saving was successful.
-       *
-       * If neither exists or if both tags are empty, this will strip the tags
-       * from the file.
-       *
-       * This is the same as calling save(AllTags);
-       *
-       * If you would like more granular control over the content of the tags,
-       * with the concession of generality, use paramaterized save call below.
-       *
-       * \see save(int tags)
-       */
-      virtual bool save();
-
-      /*!
-       * Save the file.  If \a strip is specified, it is possible to choose if
-       * tags not specified in \a tags should be stripped from the file or
-       * retained.  With \a version, it is possible to specify whether ID3v2.4
-       * or ID3v2.3 should be used.
-       */
-      bool save(TagTypes tags, StripTags strip = StripOthers, ID3v2::Version version = ID3v2::v4);
-
-      /*!
-       * This will strip the tags that match the OR-ed together TagTypes from the
-       * file.  By default it strips all tags.  It returns true if the tags are
-       * successfully stripped.
-       *
-       * \note This will update the file immediately.
-       */
-      void strip(TagTypes tags = AllTags);
-
-      /*!
-       * Returns whether or not the file on disk actually has an ID3v2 tag.
-       *
-       * \see ID3v2Tag()
-       */
-      bool hasID3v2Tag() const;
-
-      /*!
-       * Returns whether or not the file on disk actually has the DSDIFF
-       * title and artist tags.
-       *
-       * \see DIINTag()
-       */
-      bool hasDIINTag() const;
-
-      /*!
-       * Returns whether or not the given \a stream can be opened as a DSDIFF
-       * file.
-       *
-       * \note This method is designed to do a quick check.  The result may
-       * not necessarily be correct.
-       */
-       static bool isSupported(IOStream *stream);
-
-    protected:
-      enum Endianness { BigEndian, LittleEndian };
-
-      File(FileName file, Endianness endianness);
-      File(IOStream *stream, Endianness endianness);
-
-    private:
-      File(const File &);
-      File &operator=(const File &);
-
-      void removeRootChunk(const ByteVector &id);
-      void removeRootChunk(unsigned int chunk);
-      void removeChildChunk(unsigned int i, unsigned int chunk);
-
-      /*!
-       * Sets the data for the the specified chunk at root level to \a data.
-       *
-       * \warning This will update the file immediately.
-       */
-      void setRootChunkData(unsigned int i, const ByteVector &data);
-
-      /*!
-       * Sets the data for the root-level chunk \a name to \a data.
-       * If a root-level chunk with the given name already exists
-       * it will be overwritten, otherwise it will be
-       * created after the existing chunks.
-       *
-       * \warning This will update the file immediately.
-       */
-      void setRootChunkData(const ByteVector &name, const ByteVector &data);
-
-      /*!
-       * Sets the data for the the specified child chunk to \a data.
-       *
-       * If data is null, then remove the chunk
-       *
-       * \warning This will update the file immediately.
-       */
-      void setChildChunkData(unsigned int i, const ByteVector &data,
-                             unsigned int childChunkNum);
-
-      /*!
-       * Sets the data for the child chunk \a name to \a data.  If a chunk with
-       * the given name already exists it will be overwritten, otherwise it will
-       * be created after the existing chunks inside child chunk.
-       *
-       * If data is null, then remove the chunks with \a name name
-       *
-       * \warning This will update the file immediately.
-       */
-      void setChildChunkData(const ByteVector &name, const ByteVector &data,
-                             unsigned int childChunkNum);
-
-      void updateRootChunksStructure(unsigned int startingChunk);
-
-      void read(bool readProperties, Properties::ReadStyle propertiesStyle);
-      void writeChunk(const ByteVector &name, const ByteVector &data,
-                      unsigned long long offset, unsigned long replace = 0,
-                      unsigned int leadingPadding = 0);
-
-      class FilePrivate;
-      FilePrivate *d;
-    };
-  }
-}
-}
-
-#endif
-

3rdparty/taglib/dsdiff/dsdiffproperties.cpp

@@ -1,120 +0,0 @@
-/***************************************************************************
- copyright            : (C) 2016 by Damien Plisson, Audirvana
- email                : damien78@audirvana.com
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <tstring.h>
-#include <tdebug.h>
-
-#include "dsdiffproperties.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-class DSDIFF::Properties::PropertiesPrivate
-{
-public:
-  PropertiesPrivate() :
-  length(0),
-  bitrate(0),
-  sampleRate(0),
-  channels(0),
-  sampleWidth(0),
-  sampleCount(0)
-  {
-  }
-
-  int length;
-  int bitrate;
-  int sampleRate;
-  int channels;
-  int sampleWidth;
-  unsigned long long sampleCount;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// public members
-////////////////////////////////////////////////////////////////////////////////
-
-DSDIFF::Properties::Properties(const unsigned int sampleRate,
-                               const unsigned short channels,
-                               const unsigned long long samplesCount,
-                               const int bitrate,
-                               ReadStyle style) : AudioProperties(style)
-{
-  d = new PropertiesPrivate;
-
-  d->channels    = channels;
-  d->sampleCount = samplesCount;
-  d->sampleWidth = 1;
-  d->sampleRate  = sampleRate;
-  d->bitrate     = bitrate;
-  d->length      = d->sampleRate > 0
-    ? static_cast<int>((d->sampleCount * 1000.0) / d->sampleRate + 0.5)
-    : 0;
-}
-
-DSDIFF::Properties::~Properties()
-{
-  delete d;
-}
-
-int DSDIFF::Properties::length() const
-{
-  return lengthInSeconds();
-}
-
-int DSDIFF::Properties::lengthInSeconds() const
-{
-  return d->length / 1000;
-}
-
-int DSDIFF::Properties::lengthInMilliseconds() const
-{
-  return d->length;
-}
-
-int DSDIFF::Properties::bitrate() const
-{
-  return d->bitrate;
-}
-
-int DSDIFF::Properties::sampleRate() const
-{
-  return d->sampleRate;
-}
-
-int DSDIFF::Properties::channels() const
-{
-  return d->channels;
-}
-
-int DSDIFF::Properties::bitsPerSample() const
-{
-  return d->sampleWidth;
-}
-
-long long DSDIFF::Properties::sampleCount() const
-{
-  return d->sampleCount;
-}
-

3rdparty/taglib/dsdiff/dsdiffproperties.h

@@ -1,85 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2016 by Damien Plisson, Audirvana
-    email                : damien78@audirvana.com
-***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_DSDIFFPROPERTIES_H
-#define TAGLIB_DSDIFFPROPERTIES_H
-
-#include "audioproperties.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  namespace DSDIFF {
-
-    class File;
-
-    //! An implementation of audio property reading for DSDIFF
-
-    /*!
-     * This reads the data from an DSDIFF stream found in the AudioProperties
-     * API.
-     */
-
-    class TAGLIB_EXPORT Properties : public AudioProperties
-    {
-    public:
-      /*!
-       * Create an instance of DSDIFF::Properties with the data read from the
-       * ByteVector \a data.
-       */
-      Properties(const unsigned int sampleRate, const unsigned short channels,
-                 const unsigned long long samplesCount, const int bitrate,
-                 ReadStyle style);
-
-      /*!
-       * Destroys this DSDIFF::Properties instance.
-       */
-      virtual ~Properties();
-
-      // Reimplementations.
-
-      virtual int length() const;
-      virtual int lengthInSeconds() const;
-      virtual int lengthInMilliseconds() const;
-      virtual int bitrate() const;
-      virtual int sampleRate() const;
-      virtual int channels() const;
-
-      int bitsPerSample() const;
-      long long sampleCount() const;
-
-    private:
-      Properties(const Properties &);
-      Properties &operator=(const Properties &);
-
-      class PropertiesPrivate;
-      PropertiesPrivate *d;
-    };
-  }
-}
-}
-
-#endif
-

3rdparty/taglib/dsf/dsffile.cpp

@@ -1,243 +0,0 @@
-/***************************************************************************
- copyright            : (C) 2013 - 2018 by Stephen F. Booth
- email                : me@sbooth.org
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <tbytevector.h>
-#include <tdebug.h>
-#include <id3v2tag.h>
-#include <tstringlist.h>
-#include <tpropertymap.h>
-#include <tagutils.h>
-
-#include "dsffile.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-// The DSF specification is located at http://dsd-guide.com/sites/default/files/white-papers/DSFFileFormatSpec_E.pdf
-
-class DSF::File::FilePrivate
-{
-public:
-  FilePrivate() :
-  fileSize(0),
-  metadataOffset(0),
-  properties(nullptr),
-  tag(nullptr)
-  {
-  }
-
-  ~FilePrivate()
-  {
-    delete properties;
-    delete tag;
-  }
-
-  long long fileSize;
-  long long metadataOffset;
-  Properties *properties;
-  ID3v2::Tag *tag;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// static members
-////////////////////////////////////////////////////////////////////////////////
-
-bool DSF::File::isSupported(IOStream *stream)
-{
-    // A DSF file has to start with "DSD "
-    const ByteVector id = Utils::readHeader(stream, 4, false);
-    return id.startsWith("DSD ");
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// public members
-////////////////////////////////////////////////////////////////////////////////
-
-DSF::File::File(FileName file, bool readProperties,
-                Properties::ReadStyle propertiesStyle) :
-  Strawberry_TagLib::TagLib::File(file),
-  d(new FilePrivate())
-{
-  if(isOpen())
-    read(readProperties, propertiesStyle);
-}
-
-DSF::File::File(IOStream *stream, bool readProperties,
-                Properties::ReadStyle propertiesStyle) :
-  Strawberry_TagLib::TagLib::File(stream),
-  d(new FilePrivate())
-{
-  if(isOpen())
-    read(readProperties, propertiesStyle);
-}
-
-DSF::File::~File()
-{
-  delete d;
-}
-
-ID3v2::Tag *DSF::File::tag() const
-{
-  return d->tag;
-}
-
-PropertyMap DSF::File::properties() const
-{
-  return d->tag->properties();
-}
-
-PropertyMap DSF::File::setProperties(const PropertyMap &properties)
-{
-  return d->tag->setProperties(properties);
-}
-
-DSF::Properties *DSF::File::audioProperties() const
-{
-  return d->properties;
-}
-
-bool DSF::File::save()
-{
-  if(readOnly()) {
-    debug("DSF::File::save() -- File is read only.");
-    return false;
-  }
-
-  if(!isValid()) {
-    debug("DSF::File::save() -- Trying to save invalid file.");
-    return false;
-  }
-
-  // Three things must be updated: the file size, the tag data, and the metadata offset
-
-  if(d->tag->isEmpty()) {
-    long long newFileSize = d->metadataOffset ? d->metadataOffset : d->fileSize;
-
-    // Update the file size
-    if(d->fileSize != newFileSize) {
-      insert(ByteVector::fromLongLong(newFileSize, false), 12, 8);
-      d->fileSize = newFileSize;
-    }
-
-    // Update the metadata offset to 0 since there is no longer a tag
-    if(d->metadataOffset) {
-      insert(ByteVector::fromLongLong(0ULL, false), 20, 8);
-      d->metadataOffset = 0;
-    }
-
-    // Delete the old tag
-    truncate(newFileSize);
-  }
-  else {
-    ByteVector tagData = d->tag->render();
-
-    long long newMetadataOffset = d->metadataOffset ? d->metadataOffset : d->fileSize;
-    long long newFileSize = newMetadataOffset + tagData.size();
-    long long oldTagSize = d->fileSize - newMetadataOffset;
-
-    // Update the file size
-    if(d->fileSize != newFileSize) {
-      insert(ByteVector::fromLongLong(newFileSize, false), 12, 8);
-      d->fileSize = newFileSize;
-    }
-
-    // Update the metadata offset
-    if(d->metadataOffset != newMetadataOffset) {
-      insert(ByteVector::fromLongLong(newMetadataOffset, false), 20, 8);
-      d->metadataOffset = newMetadataOffset;
-    }
-
-    // Delete the old tag and write the new one
-    insert(tagData, newMetadataOffset, static_cast<size_t>(oldTagSize));
-  }
-
-  return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// private members
-////////////////////////////////////////////////////////////////////////////////
-
-
-void DSF::File::read(bool readProperties, Properties::ReadStyle propertiesStyle)
-{
-  // A DSF file consists of four chunks: DSD chunk, format chunk, data chunk, and metadata chunk
-  // The file format is not chunked in the sense of a RIFF File, though
-
-  // DSD chunk
-  ByteVector chunkName = readBlock(4);
-  if(chunkName != "DSD ") {
-    debug("DSF::File::read() -- Not a DSF file.");
-    setValid(false);
-    return;
-  }
-
-  long long chunkSize = readBlock(8).toLongLong(false);
-
-  // Integrity check
-  if(28 != chunkSize) {
-    debug("DSF::File::read() -- File is corrupted, wrong chunk size");
-    setValid(false);
-    return;
-  }
-
-  d->fileSize = readBlock(8).toLongLong(false);
-
-  // File is malformed or corrupted
-  if(d->fileSize != length()) {
-    debug("DSF::File::read() -- File is corrupted wrong length");
-    setValid(false);
-    return;
-  }
-
-  d->metadataOffset = readBlock(8).toLongLong(false);
-
-  // File is malformed or corrupted
-  if(d->metadataOffset > d->fileSize) {
-    debug("DSF::File::read() -- Invalid metadata offset.");
-    setValid(false);
-    return;
-  }
-
-  // Format chunk
-  chunkName = readBlock(4);
-  if(chunkName != "fmt ") {
-    debug("DSF::File::read() -- Missing 'fmt ' chunk.");
-    setValid(false);
-    return;
-  }
-
-  chunkSize = readBlock(8).toLongLong(false);
-
-  d->properties = new Properties(readBlock(chunkSize), propertiesStyle);
-
-  // Skip the data chunk
-
-  // A metadata offset of 0 indicates the absence of an ID3v2 tag
-  if(0 == d->metadataOffset)
-    d->tag = new ID3v2::Tag();
-  else
-    d->tag = new ID3v2::Tag(this, d->metadataOffset);
-}
-

3rdparty/taglib/dsf/dsffile.h

@@ -1,130 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2013 - 2018 by Stephen F. Booth
-    email                : me@sbooth.org
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_DSFFILE_H
-#define TAGLIB_DSFFILE_H
-
-#include "tfile.h"
-#include "id3v2tag.h"
-#include "dsfproperties.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  //! An implementation of DSF metadata
-
-  /*!
-   * This is implementation of DSF metadata.
-   *
-   * This supports an ID3v2 tag as well as properties from the file.
-   */
-
-  namespace DSF {
-
-    //! An implementation of Strawberry_TagLib::TagLib::File with DSF specific methods
-
-    /*!
-     * This implements and provides an interface for DSF files to the
-     * Strawberry_TagLib::TagLib::Tag and Strawberry_TagLib::TagLib::AudioProperties interfaces by way of implementing
-     * the abstract Strawberry_TagLib::TagLib::File API as well as providing some additional
-     * information specific to DSF files.
-     */
-
-    class TAGLIB_EXPORT File : public Strawberry_TagLib::TagLib::File
-    {
-    public:
-      /*!
-       * Constructs an DSF file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
-       */
-      File(FileName file, bool readProperties = true,
-           Properties::ReadStyle propertiesStyle = Properties::Average);
-
-      /*!
-       * Constructs an DSF file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
-       */
-      File(IOStream *stream, bool readProperties = true,
-           Properties::ReadStyle propertiesStyle = Properties::Average);
-
-      /*!
-       * Destroys this instance of the File.
-       */
-      virtual ~File();
-
-      /*!
-       * Returns the Tag for this file.
-       */
-      ID3v2::Tag *tag() const;
-
-      /*!
-       * Implements the unified property interface -- export function.
-       * This method forwards to ID3v2::Tag::properties().
-       */
-      PropertyMap properties() const;
-
-      /*!
-       * Implements the unified property interface -- import function.
-       * This method forwards to ID3v2::Tag::setProperties().
-       */
-      PropertyMap setProperties(const PropertyMap &);
-
-      /*!
-       * Returns the DSF::AudioProperties for this file.  If no audio properties
-       * were read then this will return a null pointer.
-       */
-      virtual Properties *audioProperties() const;
-
-      /*!
-       * Saves the file.
-       */
-      virtual bool save();
-
-      /*!
-       * Returns whether or not the given \a stream can be opened as a DSF
-       * file.
-       *
-       * \note This method is designed to do a quick check.  The result may
-       * not necessarily be correct.
-       */
-      static bool isSupported(IOStream *stream);
-
-    private:
-      File(const File &);
-      File &operator=(const File &);
-
-      void read(bool readProperties, Properties::ReadStyle propertiesStyle);
-
-      class FilePrivate;
-      FilePrivate *d;
-    };
-  }
-}
-}
-
-#endif
-

3rdparty/taglib/dsf/dsfproperties.cpp

@@ -1,161 +0,0 @@
-/***************************************************************************
- copyright            : (C) 2013 by Stephen F. Booth
- email                : me@sbooth.org
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <tstring.h>
-#include <tdebug.h>
-
-#include "dsfproperties.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-class DSF::Properties::PropertiesPrivate
-{
-public:
-  PropertiesPrivate() :
-  formatVersion(0),
-  formatID(0),
-  channelType(0),
-  channelNum(0),
-  samplingFrequency(0),
-  bitsPerSample(0),
-  sampleCount(0),
-  blockSizePerChannel(0),
-  bitrate(0),
-  length(0)
-  {
-  }
-
-  // Nomenclature is from DSF file format specification
-  unsigned int formatVersion;
-  unsigned int formatID;
-  unsigned int channelType;
-  unsigned int channelNum;
-  unsigned int samplingFrequency;
-  unsigned int bitsPerSample;
-  long long sampleCount;
-  unsigned int blockSizePerChannel;
-
-  // Computed
-  unsigned int bitrate;
-  unsigned int length;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// public members
-////////////////////////////////////////////////////////////////////////////////
-
-DSF::Properties::Properties(const ByteVector &data, ReadStyle style) : Strawberry_TagLib::TagLib::AudioProperties(style)
-{
-  d = new PropertiesPrivate;
-  read(data);
-}
-
-DSF::Properties::~Properties()
-{
-  delete d;
-}
-
-int DSF::Properties::length() const
-{
-  return lengthInSeconds();
-}
-
-int DSF::Properties::lengthInSeconds() const
-{
-  return d->length / 1000;
-}
-
-int DSF::Properties::lengthInMilliseconds() const
-{
-  return d->length;
-}
-
-int DSF::Properties::bitrate() const
-{
-  return d->bitrate;
-}
-
-int DSF::Properties::sampleRate() const
-{
-  return d->samplingFrequency;
-}
-
-int DSF::Properties::channels() const
-{
-  return d->channelNum;
-}
-
-// DSF specific
-int DSF::Properties::formatVersion() const
-{
-  return d->formatVersion;
-}
-
-int DSF::Properties::formatID() const
-{
-  return d->formatID;
-}
-
-int DSF::Properties::channelType() const
-{
-  return d->channelType;
-}
-
-int DSF::Properties::bitsPerSample() const
-{
-  return d->bitsPerSample;
-}
-
-long long DSF::Properties::sampleCount() const
-{
-  return d->sampleCount;
-}
-
-int DSF::Properties::blockSizePerChannel() const
-{
-  return d->blockSizePerChannel;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// private members
-////////////////////////////////////////////////////////////////////////////////
-
-void DSF::Properties::read(const ByteVector &data)
-{
-  d->formatVersion         = data.toUInt(0U,false);
-  d->formatID              = data.toUInt(4U,false);
-  d->channelType           = data.toUInt(8U,false);
-  d->channelNum            = data.toUInt(12U,false);
-  d->samplingFrequency     = data.toUInt(16U,false);
-  d->bitsPerSample         = data.toUInt(20U,false);
-  d->sampleCount           = data.toLongLong(24U,false);
-  d->blockSizePerChannel   = data.toUInt(32U,false);
-
-  d->bitrate
-  = static_cast<unsigned int>((d->samplingFrequency * d->bitsPerSample * d->channelNum) / 1000.0 + 0.5);
-  d->length
-  = d->samplingFrequency > 0 ? static_cast<unsigned int>(d->sampleCount * 1000.0 / d->samplingFrequency + 0.5) : 0;
-}
-

3rdparty/taglib/dsf/dsfproperties.h

@@ -1,94 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2013 by Stephen F. Booth
-    email                : me@sbooth.org
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_DSFPROPERTIES_H
-#define TAGLIB_DSFPROPERTIES_H
-
-#include "audioproperties.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  namespace DSF {
-
-    class File;
-
-    //! An implementation of audio property reading for DSF
-
-    /*!
-     * This reads the data from a DSF stream found in the AudioProperties
-     * API.
-     */
-
-    class TAGLIB_EXPORT Properties : public Strawberry_TagLib::TagLib::AudioProperties
-    {
-    public:
-      /*!
-       * Create an instance of DSF::AudioProperties with the data read from the
-       * ByteVector \a data.
-       */
-      Properties(const ByteVector &data, ReadStyle style);
-
-      /*!
-       * Destroys this DSF::AudioProperties instance.
-        */
-      virtual ~Properties();
-
-      // Reimplementations.
-
-      virtual int length() const;
-      virtual int lengthInSeconds() const;
-      virtual int lengthInMilliseconds() const;
-      virtual int bitrate() const;
-      virtual int sampleRate() const;
-      virtual int channels() const;
-
-      int formatVersion() const;
-      int formatID() const;
-
-      /*!
-       * Channel type values: 1 = mono, 2 = stereo, 3 = 3 channels, 
-       * 4 = quad, 5 = 4 channels, 6 = 5 channels, 7 = 5.1 channels
-       */
-      int channelType() const;
-      int bitsPerSample() const;
-      long long sampleCount() const;
-      int blockSizePerChannel() const;
-
-    private:
-      Properties(const Properties &);
-      Properties &operator=(const Properties &);
-
-      void read(const ByteVector &data);
-
-      class PropertiesPrivate;
-      PropertiesPrivate *d;
-    };
-  }
-}
-}
-
-#endif
-

3rdparty/taglib/fileref.cpp

@@ -1,491 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2002 - 2008 by Scott Wheeler
-    email                : wheeler@kde.org
-
-    copyright            : (C) 2010 by Alex Novichkov
-    email                : novichko@atnet.ru
-                           (added APE file support)
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <tfile.h>
-#include <tfilestream.h>
-#include <tstring.h>
-#include <tdebug.h>
-#include <trefcounter.h>
-
-#include "fileref.h"
-#include "asffile.h"
-#include "mpegfile.h"
-#include "vorbisfile.h"
-#include "flacfile.h"
-#include "oggflacfile.h"
-#include "mpcfile.h"
-#include "mp4file.h"
-#include "wavpackfile.h"
-#include "speexfile.h"
-#include "opusfile.h"
-#include "trueaudiofile.h"
-#include "aifffile.h"
-#include "wavfile.h"
-#include "apefile.h"
-#include "modfile.h"
-#include "s3mfile.h"
-#include "itfile.h"
-#include "xmfile.h"
-#include "dsffile.h"
-#include "dsdifffile.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-namespace
-{
-  typedef List<const FileRef::FileTypeResolver *> ResolverList;
-  ResolverList fileTypeResolvers;
-
-  // Detect the file type by user-defined resolvers.
-
-  File *detectByResolvers(FileName fileName, bool readAudioProperties,
-                          AudioProperties::ReadStyle audioPropertiesStyle)
-  {
-    ResolverList::ConstIterator it = fileTypeResolvers.begin();
-    for(; it != fileTypeResolvers.end(); ++it) {
-      File *file = (*it)->createFile(fileName, readAudioProperties, audioPropertiesStyle);
-      if(file)
-        return file;
-    }
-
-    return nullptr;
-  }
-
-  // Detect the file type based on the file extension.
-
-  File* detectByExtension(IOStream *stream, bool readAudioProperties,
-                          AudioProperties::ReadStyle audioPropertiesStyle)
-  {
-#ifdef _WIN32
-    const String s = stream->name().toString();
-#else
-    const String s(stream->name());
-#endif
-
-    String ext;
-    const int pos = s.rfind(".");
-    if(pos != -1)
-      ext = s.substr(pos + 1).upper();
-
-    // If this list is updated, the method defaultFileExtensions() should also be
-    // updated.  However at some point that list should be created at the same time
-    // that a default file type resolver is created.
-
-    if(ext.isEmpty())
-      return nullptr;
-
-    // .oga can be any audio in the Ogg container. So leave it to content-based detection.
-
-    if(ext == "MP3")
-      return new MPEG::File(stream, ID3v2::FrameFactory::instance(), readAudioProperties, audioPropertiesStyle);
-    if(ext == "OGG")
-      return new Ogg::Vorbis::File(stream, readAudioProperties, audioPropertiesStyle);
-    if(ext == "FLAC")
-      return new FLAC::File(stream, ID3v2::FrameFactory::instance(), readAudioProperties, audioPropertiesStyle);
-    if(ext == "MPC")
-      return new MPC::File(stream, readAudioProperties, audioPropertiesStyle);
-    if(ext == "WV")
-      return new WavPack::File(stream, readAudioProperties, audioPropertiesStyle);
-    if(ext == "SPX")
-      return new Ogg::Speex::File(stream, readAudioProperties, audioPropertiesStyle);
-    if(ext == "OPUS")
-      return new Ogg::Opus::File(stream, readAudioProperties, audioPropertiesStyle);
-    if(ext == "TTA")
-      return new TrueAudio::File(stream, readAudioProperties, audioPropertiesStyle);
-    if(ext == "M4A" || ext == "M4R" || ext == "M4B" || ext == "M4P" || ext == "MP4" || ext == "3G2" || ext == "M4V")
-      return new MP4::File(stream, readAudioProperties, audioPropertiesStyle);
-    if(ext == "WMA" || ext == "ASF")
-      return new ASF::File(stream, readAudioProperties, audioPropertiesStyle);
-    if(ext == "AIF" || ext == "AIFF" || ext == "AFC" || ext == "AIFC")
-      return new RIFF::AIFF::File(stream, readAudioProperties, audioPropertiesStyle);
-    if(ext == "WAV")
-      return new RIFF::WAV::File(stream, readAudioProperties, audioPropertiesStyle);
-    if(ext == "APE")
-      return new APE::File(stream, readAudioProperties, audioPropertiesStyle);
-    // module, nst and wow are possible but uncommon extensions
-    if(ext == "MOD" || ext == "MODULE" || ext == "NST" || ext == "WOW")
-      return new Mod::File(stream, readAudioProperties, audioPropertiesStyle);
-    if(ext == "S3M")
-      return new S3M::File(stream, readAudioProperties, audioPropertiesStyle);
-    if(ext == "IT")
-      return new IT::File(stream, readAudioProperties, audioPropertiesStyle);
-    if(ext == "XM")
-      return new XM::File(stream, readAudioProperties, audioPropertiesStyle);
-    if(ext == "DFF" || ext == "DSDIFF")
-      return new DSDIFF::File(stream, readAudioProperties, audioPropertiesStyle);
-    if(ext == "DSF")
-      return new DSF::File(stream, readAudioProperties, audioPropertiesStyle);
-
-    return nullptr;
-  }
-
-  // Detect the file type based on the actual content of the stream.
-
-  File *detectByContent(IOStream *stream, bool readAudioProperties,
-                        AudioProperties::ReadStyle audioPropertiesStyle)
-  {
-    File *file = 0;
-
-    if(MPEG::File::isSupported(stream))
-      file = new MPEG::File(stream, ID3v2::FrameFactory::instance(), readAudioProperties, audioPropertiesStyle);
-    else if(Ogg::Vorbis::File::isSupported(stream))
-      file = new Ogg::Vorbis::File(stream, readAudioProperties, audioPropertiesStyle);
-    else if(Ogg::FLAC::File::isSupported(stream))
-      file = new Ogg::FLAC::File(stream, readAudioProperties, audioPropertiesStyle);
-    else if(FLAC::File::isSupported(stream))
-      file = new FLAC::File(stream, ID3v2::FrameFactory::instance(), readAudioProperties, audioPropertiesStyle);
-    else if(MPC::File::isSupported(stream))
-      file = new MPC::File(stream, readAudioProperties, audioPropertiesStyle);
-    else if(WavPack::File::isSupported(stream))
-      file = new WavPack::File(stream, readAudioProperties, audioPropertiesStyle);
-    else if(Ogg::Speex::File::isSupported(stream))
-      file = new Ogg::Speex::File(stream, readAudioProperties, audioPropertiesStyle);
-    else if(Ogg::Opus::File::isSupported(stream))
-      file = new Ogg::Opus::File(stream, readAudioProperties, audioPropertiesStyle);
-    else if(TrueAudio::File::isSupported(stream))
-      file = new TrueAudio::File(stream, readAudioProperties, audioPropertiesStyle);
-    else if(MP4::File::isSupported(stream))
-      file = new MP4::File(stream, readAudioProperties, audioPropertiesStyle);
-    else if(ASF::File::isSupported(stream))
-      file = new ASF::File(stream, readAudioProperties, audioPropertiesStyle);
-    else if(RIFF::AIFF::File::isSupported(stream))
-      file = new RIFF::AIFF::File(stream, readAudioProperties, audioPropertiesStyle);
-    else if(RIFF::WAV::File::isSupported(stream))
-      file = new RIFF::WAV::File(stream, readAudioProperties, audioPropertiesStyle);
-    else if(APE::File::isSupported(stream))
-      file = new APE::File(stream, readAudioProperties, audioPropertiesStyle);
-    else if(DSDIFF::File::isSupported(stream))
-      file = new DSDIFF::File(stream, readAudioProperties, audioPropertiesStyle);
-    else if(DSF::File::isSupported(stream))
-      file = new DSF::File(stream, readAudioProperties, audioPropertiesStyle);
-
-    // isSupported() only does a quick check, so double check the file here.
-
-    if(file) {
-      if(file->isValid())
-        return file;
-      else
-        delete file;
-    }
-
-    return nullptr;
-  }
-
-  // Internal function that supports FileRef::create().
-  // This looks redundant, but necessary in order not to change the previous
-  // behavior of FileRef::create().
-
-  File* createInternal(FileName fileName, bool readAudioProperties,
-                       AudioProperties::ReadStyle audioPropertiesStyle)
-  {
-    File *file = detectByResolvers(fileName, readAudioProperties, audioPropertiesStyle);
-    if(file)
-      return file;
-
-#ifdef _WIN32
-    const String s = fileName.toString();
-#else
-    const String s(fileName);
-#endif
-
-    String ext;
-    const int pos = s.rfind(".");
-    if(pos != -1)
-      ext = s.substr(pos + 1).upper();
-
-    if(ext.isEmpty())
-      return nullptr;
-
-    if(ext == "MP3")
-      return new MPEG::File(fileName, ID3v2::FrameFactory::instance(), readAudioProperties, audioPropertiesStyle);
-    if(ext == "OGG")
-      return new Ogg::Vorbis::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "OGA") {
-      /* .oga can be any audio in the Ogg container. First try FLAC, then Vorbis. */
-      File *file = new Ogg::FLAC::File(fileName, readAudioProperties, audioPropertiesStyle);
-      if(file->isValid())
-        return file;
-      delete file;
-      return new Ogg::Vorbis::File(fileName, readAudioProperties, audioPropertiesStyle);
-    }
-    if(ext == "FLAC")
-      return new FLAC::File(fileName, ID3v2::FrameFactory::instance(), readAudioProperties, audioPropertiesStyle);
-    if(ext == "MPC")
-      return new MPC::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "WV")
-      return new WavPack::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "SPX")
-      return new Ogg::Speex::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "OPUS")
-      return new Ogg::Opus::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "TTA")
-      return new TrueAudio::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "M4A" || ext == "M4R" || ext == "M4B" || ext == "M4P" || ext == "MP4" || ext == "3G2" || ext == "M4V")
-      return new MP4::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "WMA" || ext == "ASF")
-      return new ASF::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "AIF" || ext == "AIFF" || ext == "AFC" || ext == "AIFC")
-      return new RIFF::AIFF::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "WAV")
-      return new RIFF::WAV::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "APE")
-      return new APE::File(fileName, readAudioProperties, audioPropertiesStyle);
-    // module, nst and wow are possible but uncommon extensions
-    if(ext == "MOD" || ext == "MODULE" || ext == "NST" || ext == "WOW")
-      return new Mod::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "S3M")
-      return new S3M::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "IT")
-      return new IT::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "XM")
-      return new XM::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "DFF" || ext == "DSDIFF")
-      return new DSDIFF::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "DSF")
-      return new DSF::File(fileName, readAudioProperties, audioPropertiesStyle);
-
-    return nullptr;
-  }
-}
-
-class FileRef::FileRefPrivate : public RefCounter
-{
-public:
-  FileRefPrivate() :
-    RefCounter(),
-    file(0),
-    stream(0) {}
-
-  ~FileRefPrivate() {
-    delete file;
-    delete stream;
-  }
-
-  File     *file;
-  IOStream *stream;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// public members
-////////////////////////////////////////////////////////////////////////////////
-
-FileRef::FileRef() :
-  d(new FileRefPrivate())
-{
-}
-
-FileRef::FileRef(FileName fileName, bool readAudioProperties,
-                 AudioProperties::ReadStyle audioPropertiesStyle) :
-  d(new FileRefPrivate())
-{
-  parse(fileName, readAudioProperties, audioPropertiesStyle);
-}
-
-FileRef::FileRef(IOStream* stream, bool readAudioProperties, AudioProperties::ReadStyle audioPropertiesStyle) :
-  d(new FileRefPrivate())
-{
-  parse(stream, readAudioProperties, audioPropertiesStyle);
-}
-
-FileRef::FileRef(File *file) :
-  d(new FileRefPrivate())
-{
-  d->file = file;
-}
-
-FileRef::FileRef(const FileRef &ref) :
-  d(ref.d)
-{
-  d->ref();
-}
-
-FileRef::~FileRef()
-{
-  if(d->deref())
-    delete d;
-}
-
-Tag *FileRef::tag() const
-{
-  if(isNull()) {
-    debug("FileRef::tag() - Called without a valid file.");
-    return nullptr;
-  }
-  return d->file->tag();
-}
-
-AudioProperties *FileRef::audioProperties() const
-{
-  if(isNull()) {
-    debug("FileRef::audioProperties() - Called without a valid file.");
-    return nullptr;
-  }
-  return d->file->audioProperties();
-}
-
-File *FileRef::file() const
-{
-  return d->file;
-}
-
-bool FileRef::save()
-{
-  if(isNull()) {
-    debug("FileRef::save() - Called without a valid file.");
-    return false;
-  }
-  return d->file->save();
-}
-
-const FileRef::FileTypeResolver *FileRef::addFileTypeResolver(const FileRef::FileTypeResolver *resolver) // static
-{
-  fileTypeResolvers.prepend(resolver);
-  return resolver;
-}
-
-StringList FileRef::defaultFileExtensions()
-{
-  StringList l;
-
-  l.append("ogg");
-  l.append("flac");
-  l.append("oga");
-  l.append("mp3");
-  l.append("mpc");
-  l.append("wv");
-  l.append("spx");
-  l.append("tta");
-  l.append("m4a");
-  l.append("m4r");
-  l.append("m4b");
-  l.append("m4p");
-  l.append("3g2");
-  l.append("mp4");
-  l.append("m4v");
-  l.append("wma");
-  l.append("asf");
-  l.append("aif");
-  l.append("aiff");
-  l.append("wav");
-  l.append("ape");
-  l.append("mod");
-  l.append("module"); // alias for "mod"
-  l.append("nst"); // alias for "mod"
-  l.append("wow"); // alias for "mod"
-  l.append("s3m");
-  l.append("it");
-  l.append("xm");
-  l.append("dsf");
-  l.append("dff");
-  l.append("dsdiff"); // alias for "dff"
-
-  return l;
-}
-
-bool FileRef::isNull() const
-{
-  return (!d->file || !d->file->isValid());
-}
-
-FileRef &FileRef::operator=(const FileRef &ref)
-{
-  FileRef(ref).swap(*this);
-  return *this;
-}
-
-void FileRef::swap(FileRef &ref)
-{
-  using std::swap;
-
-  swap(d, ref.d);
-}
-
-bool FileRef::operator==(const FileRef &ref) const
-{
-  return (ref.d->file == d->file);
-}
-
-bool FileRef::operator!=(const FileRef &ref) const
-{
-  return (ref.d->file != d->file);
-}
-
-File *FileRef::create(FileName fileName, bool readAudioProperties,
-                      AudioProperties::ReadStyle audioPropertiesStyle) // static
-{
-  return createInternal(fileName, readAudioProperties, audioPropertiesStyle);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// private members
-////////////////////////////////////////////////////////////////////////////////
-
-void FileRef::parse(FileName fileName, bool readAudioProperties,
-                    AudioProperties::ReadStyle audioPropertiesStyle)
-{
-  // Try user-defined resolvers.
-
-  d->file = detectByResolvers(fileName, readAudioProperties, audioPropertiesStyle);
-  if(d->file)
-    return;
-
-  // Try to resolve file types based on the file extension.
-
-  d->stream = new FileStream(fileName);
-  d->file = detectByExtension(d->stream, readAudioProperties, audioPropertiesStyle);
-  if(d->file)
-    return;
-
-  // At last, try to resolve file types based on the actual content.
-
-  d->file = detectByContent(d->stream, readAudioProperties, audioPropertiesStyle);
-  if(d->file)
-    return;
-
-  // Stream have to be closed here if failed to resolve file types.
-
-  delete d->stream;
-  d->stream = 0;
-}
-
-void FileRef::parse(IOStream *stream, bool readAudioProperties,
-                    AudioProperties::ReadStyle audioPropertiesStyle)
-{
-  // User-defined resolvers won't work with a stream.
-
-  // Try to resolve file types based on the file extension.
-
-  d->file = detectByExtension(stream, readAudioProperties, audioPropertiesStyle);
-  if(d->file)
-    return;
-
-  // At last, try to resolve file types based on the actual content of the file.
-
-  d->file = detectByContent(stream, readAudioProperties, audioPropertiesStyle);
-}

3rdparty/taglib/fileref.h

@@ -1,289 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2002 - 2008 by Scott Wheeler
-    email                : wheeler@kde.org
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_FILEREF_H
-#define TAGLIB_FILEREF_H
-
-#include "tfile.h"
-#include "tstringlist.h"
-
-#include "taglib_export.h"
-#include "audioproperties.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  class Tag;
-
-  //! This class provides a simple abstraction for creating and handling files
-
-  /*!
-   * FileRef exists to provide a minimal, generic and value-based wrapper around
-   * a File.  It is lightweight and implicitly shared, and as such suitable for
-   * pass-by-value use.  This hides some of the uglier details of TagLib::File
-   * and the non-generic portions of the concrete file implementations.
-   *
-   * This class is useful in a "simple usage" situation where it is desirable
-   * to be able to get and set some of the tag information that is similar
-   * across file types.
-   *
-   * Also note that it is probably a good idea to plug this into your mime
-   * type system rather than using the constructor that accepts a file name using
-   * the FileTypeResolver.
-   *
-   * \see FileTypeResolver
-   * \see addFileTypeResolver()
-   */
-
-  class TAGLIB_EXPORT FileRef
-  {
-  public:
-
-  //! A class for pluggable file type resolution.
-
-  /*!
-   * This class is used to add extend TagLib's very basic file name based file
-   * type resolution.
-   *
-   * This can be accomplished with:
-   *
-   * \code
-   *
-   * class MyFileTypeResolver : FileTypeResolver
-   * {
-   *   Strawberry_TagLib::TagLib::File *createFile(Strawberry_TagLib::TagLib::FileName *fileName, bool, AudioProperties::ReadStyle) const
-   *   {
-   *     if(someCheckForAnMP3File(fileName))
-   *       return new Strawberry_TagLib::TagLib::MPEG::File(fileName);
-   *     return 0;
-   *   }
-   * }
-   *
-   * FileRef::addFileTypeResolver(new MyFileTypeResolver);
-   *
-   * \endcode
-   *
-   * Naturally a less contrived example would be slightly more complex.  This
-   * can be used to plug in mime-type detection systems or to add new file types
-   * to TagLib.
-   */
-
-    class TAGLIB_EXPORT FileTypeResolver
-    {
-      TAGLIB_IGNORE_MISSING_DESTRUCTOR
-    public:
-      /*!
-       * This method must be overridden to provide an additional file type
-       * resolver.  If the resolver is able to determine the file type it should
-       * return a valid File object; if not it should return 0.
-       *
-       * \note The created file is then owned by the FileRef and should not be
-       * deleted.  Deletion will happen automatically when the FileRef passes
-       * out of scope.
-       */
-      virtual File *createFile(FileName fileName,
-                               bool readAudioProperties = true,
-                               AudioProperties::ReadStyle
-                               audioPropertiesStyle = AudioProperties::Average) const = 0;
-    };
-
-    /*!
-     * Creates a null FileRef.
-     */
-    FileRef();
-
-    /*!
-     * Create a FileRef from \a fileName.  If \a readAudioProperties is true then
-     * the audio properties will be read using \a audioPropertiesStyle.  If
-     * \a readAudioProperties is false then \a audioPropertiesStyle will be
-     * ignored.
-     *
-     * Also see the note in the class documentation about why you may not want to
-     * use this method in your application.
-     */
-    explicit FileRef(FileName fileName,
-                     bool readAudioProperties = true,
-                     AudioProperties::ReadStyle
-                     audioPropertiesStyle = AudioProperties::Average);
-
-    /*!
-     * Construct a FileRef from an opened \a IOStream.  If \a readAudioProperties
-     * is true then the audio properties will be read using \a audioPropertiesStyle.
-     * If \a readAudioProperties is false then \a audioPropertiesStyle will be
-     * ignored.
-     *
-     * Also see the note in the class documentation about why you may not want to
-     * use this method in your application.
-     *
-     * \note TagLib will *not* take ownership of the stream, the caller is
-     * responsible for deleting it after the File object.
-     */
-    explicit FileRef(IOStream* stream,
-                     bool readAudioProperties = true,
-                     AudioProperties::ReadStyle
-                     audioPropertiesStyle = AudioProperties::Average);
-
-    /*!
-     * Construct a FileRef using \a file.  The FileRef now takes ownership of the
-     * pointer and will delete the File when it passes out of scope.
-     */
-    explicit FileRef(File *file);
-
-    /*!
-     * Make a copy of \a ref.
-     */
-    FileRef(const FileRef &ref);
-
-    /*!
-     * Destroys this FileRef instance.
-     */
-    virtual ~FileRef();
-
-    /*!
-     * Returns a pointer to represented file's tag.
-     *
-     * \warning This pointer will become invalid when this FileRef and all
-     * copies pass out of scope.
-     *
-     * \warning Do not cast it to any subclasses of \class Tag.
-     * Use tag returning methods of appropriate subclasses of \class File instead.
-     *
-     * \see File::tag()
-     */
-    Tag *tag() const;
-
-    /*!
-     * Returns the audio properties for this FileRef.  If no audio properties
-     * were read then this will returns a null pointer.
-     */
-    AudioProperties *audioProperties() const;
-
-    /*!
-     * Returns a pointer to the file represented by this handler class.
-     *
-     * As a general rule this call should be avoided since if you need to work
-     * with file objects directly, you are probably better served instantiating
-     * the File subclasses (i.e. MPEG::File) manually and working with their APIs.
-     *
-     * This <i>handle</i> exists to provide a minimal, generic and value-based
-     * wrapper around a File.  Accessing the file directly generally indicates
-     * a moving away from this simplicity (and into things beyond the scope of
-     * FileRef).
-     *
-     * \warning This pointer will become invalid when this FileRef and all
-     * copies pass out of scope.
-     */
-    File *file() const;
-
-    /*!
-     * Saves the file.  Returns true on success.
-     */
-    bool save();
-
-    /*!
-     * Adds a FileTypeResolver to the list of those used by TagLib.  Each
-     * additional FileTypeResolver is added to the front of a list of resolvers
-     * that are tried.  If the FileTypeResolver returns zero the next resolver
-     * is tried.
-     *
-     * Returns a pointer to the added resolver (the same one that's passed in --
-     * this is mostly so that static initializers have something to use for
-     * assignment).
-     *
-     * \see FileTypeResolver
-     */
-    static const FileTypeResolver *addFileTypeResolver(const FileTypeResolver *resolver);
-
-    /*!
-     * As is mentioned elsewhere in this class's documentation, the default file
-     * type resolution code provided by TagLib only works by comparing file
-     * extensions.
-     *
-     * This method returns the list of file extensions that are used by default.
-     *
-     * The extensions are all returned in lowercase, though the comparison used
-     * by TagLib for resolution is case-insensitive.
-     *
-     * \note This does not account for any additional file type resolvers that
-     * are plugged in.  Also note that this is not intended to replace a proper
-     * mime-type resolution system, but is just here for reference.
-     *
-     * \see FileTypeResolver
-     */
-    static StringList defaultFileExtensions();
-
-    /*!
-     * Returns true if the file (and as such other pointers) are null.
-     */
-    bool isNull() const;
-
-    /*!
-     * Assign the file pointed to by \a ref to this FileRef.
-     */
-    FileRef &operator=(const FileRef &ref);
-
-    /*!
-     * Exchanges the content of the FileRef by the content of \a ref.
-     */
-    void swap(FileRef &ref);
-
-    /*!
-     * Returns true if this FileRef and \a ref point to the same File object.
-     */
-    bool operator==(const FileRef &ref) const;
-
-    /*!
-     * Returns true if this FileRef and \a ref do not point to the same File
-     * object.
-     */
-    bool operator!=(const FileRef &ref) const;
-
-    /*!
-     * A simple implementation of file type guessing.  If \a readAudioProperties
-     * is true then the audio properties will be read using
-     * \a audioPropertiesStyle.  If \a readAudioProperties is false then
-     * \a audioPropertiesStyle will be ignored.
-     *
-     * \note You generally shouldn't use this method, but instead the constructor
-     * directly.
-     *
-     * \deprecated
-     */
-    static File *create(FileName fileName,
-                        bool readAudioProperties = true,
-                        AudioProperties::ReadStyle audioPropertiesStyle = AudioProperties::Average);
-
-  private:
-    void parse(FileName fileName, bool readAudioProperties, AudioProperties::ReadStyle audioPropertiesStyle);
-    void parse(IOStream *stream, bool readAudioProperties, AudioProperties::ReadStyle audioPropertiesStyle);
-
-    class FileRefPrivate;
-    FileRefPrivate *d;
-  };
-
-}
-} // namespace Strawberry_TagLib::TagLib
-
-#endif

3rdparty/taglib/flac/flacfile.cpp

@@ -1,575 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2003-2004 by Allan Sandfeld Jensen
-    email                : kde@carewolf.org
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <tbytevector.h>
-#include <tstring.h>
-#include <tlist.h>
-#include <tdebug.h>
-#include <tagunion.h>
-#include <tpropertymap.h>
-#include <tagutils.h>
-
-#include <id3v2header.h>
-#include <id3v2tag.h>
-#include <id3v1tag.h>
-#include <xiphcomment.h>
-
-#include "flacpicture.h"
-#include "flacfile.h"
-#include "flacmetadatablock.h"
-#include "flacunknownmetadatablock.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-namespace
-{
-  typedef List<FLAC::MetadataBlock *> BlockList;
-  typedef BlockList::Iterator BlockIterator;
-  typedef BlockList::Iterator BlockConstIterator;
-
-  enum { FlacXiphIndex = 0, FlacID3v2Index = 1, FlacID3v1Index = 2 };
-
-  const long MinPaddingLength = 4096;
-  const long MaxPaddingLegnth = 1024 * 1024;
-
-  const char LastBlockFlag = '\x80';
-}
-
-class FLAC::File::FilePrivate
-{
-public:
-  explicit FilePrivate(const ID3v2::FrameFactory *frameFactory = ID3v2::FrameFactory::instance()) :
-    ID3v2FrameFactory(frameFactory),
-    ID3v2Location(-1),
-    ID3v2OriginalSize(0),
-    ID3v1Location(-1),
-    properties(0),
-    flacStart(0),
-    streamStart(0),
-    scanned(false)
-  {
-    blocks.setAutoDelete(true);
-  }
-
-  ~FilePrivate()
-  {
-    delete properties;
-  }
-
-  const ID3v2::FrameFactory *ID3v2FrameFactory;
-  long ID3v2Location;
-  long ID3v2OriginalSize;
-
-  long ID3v1Location;
-
-  TagUnion tag;
-
-  Properties *properties;
-  ByteVector xiphCommentData;
-  BlockList blocks;
-
-  long flacStart;
-  long streamStart;
-  bool scanned;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// static members
-////////////////////////////////////////////////////////////////////////////////
-
-bool FLAC::File::isSupported(IOStream *stream)
-{
-  // A FLAC file has an ID "fLaC" somewhere. An ID3v2 tag may precede.
-
-  const ByteVector buffer = Utils::readHeader(stream, bufferSize(), true);
-  return (buffer.find("fLaC") >= 0);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// public members
-////////////////////////////////////////////////////////////////////////////////
-
-FLAC::File::File(FileName file, bool readProperties, Properties::ReadStyle) :
-  Strawberry_TagLib::TagLib::File(file),
-  d(new FilePrivate())
-{
-  if(isOpen())
-    read(readProperties);
-}
-
-FLAC::File::File(FileName file, ID3v2::FrameFactory *frameFactory,
-                 bool readProperties, Properties::ReadStyle) :
-  Strawberry_TagLib::TagLib::File(file),
-  d(new FilePrivate(frameFactory))
-{
-  if(isOpen())
-    read(readProperties);
-}
-
-FLAC::File::File(IOStream *stream, ID3v2::FrameFactory *frameFactory,
-                 bool readProperties, Properties::ReadStyle) :
-  Strawberry_TagLib::TagLib::File(stream),
-  d(new FilePrivate(frameFactory))
-{
-  if(isOpen())
-    read(readProperties);
-}
-
-FLAC::File::~File()
-{
-  delete d;
-}
-
-Strawberry_TagLib::TagLib::Tag *FLAC::File::tag() const
-{
-  return &d->tag;
-}
-
-PropertyMap FLAC::File::properties() const
-{
-  return d->tag.properties();
-}
-
-void FLAC::File::removeUnsupportedProperties(const StringList &unsupported)
-{
-  d->tag.removeUnsupportedProperties(unsupported);
-}
-
-PropertyMap FLAC::File::setProperties(const PropertyMap &properties)
-{
-  return xiphComment(true)->setProperties(properties);
-}
-
-FLAC::Properties *FLAC::File::audioProperties() const
-{
-  return d->properties;
-}
-
-bool FLAC::File::save()
-{
-  if(readOnly()) {
-    debug("FLAC::File::save() - Cannot save to a read only file.");
-    return false;
-  }
-
-  if(!isValid()) {
-    debug("FLAC::File::save() -- Trying to save invalid file.");
-    return false;
-  }
-
-  // Create new vorbis comments
-  if(!hasXiphComment())
-    Tag::duplicate(&d->tag, xiphComment(true), false);
-
-  d->xiphCommentData = xiphComment()->render(false);
-
-  // Replace metadata blocks
-
-  for(BlockIterator it = d->blocks.begin(); it != d->blocks.end(); ++it) {
-    if((*it)->code() == MetadataBlock::VorbisComment) {
-      // Set the new Vorbis Comment block
-      delete *it;
-      d->blocks.erase(it);
-      break;
-    }
-  }
-
-  d->blocks.append(new UnknownMetadataBlock(MetadataBlock::VorbisComment, d->xiphCommentData));
-
-  // Render data for the metadata blocks
-
-  ByteVector data;
-  for(BlockConstIterator it = d->blocks.begin(); it != d->blocks.end(); ++it) {
-    ByteVector blockData = (*it)->render();
-    ByteVector blockHeader = ByteVector::fromUInt(blockData.size());
-    blockHeader[0] = (*it)->code();
-    data.append(blockHeader);
-    data.append(blockData);
-  }
-
-  // Compute the amount of padding, and append that to data.
-
-  long originalLength = d->streamStart - d->flacStart;
-  long paddingLength = originalLength - data.size() - 4;
-
-  if(paddingLength <= 0) {
-    paddingLength = MinPaddingLength;
-  }
-  else {
-    // Padding won't increase beyond 1% of the file size or 1MB.
-
-    long threshold = length() / 100;
-    threshold = std::max(threshold, MinPaddingLength);
-    threshold = std::min(threshold, MaxPaddingLegnth);
-
-    if(paddingLength > threshold)
-      paddingLength = MinPaddingLength;
-  }
-
-  ByteVector paddingHeader = ByteVector::fromUInt(paddingLength);
-  paddingHeader[0] = static_cast<char>(MetadataBlock::Padding | LastBlockFlag);
-  data.append(paddingHeader);
-  data.resize(static_cast<unsigned int>(data.size() + paddingLength));
-
-  // Write the data to the file
-
-  insert(data, d->flacStart, originalLength);
-
-  d->streamStart += (static_cast<long>(data.size()) - originalLength);
-
-  if(d->ID3v1Location >= 0)
-    d->ID3v1Location += (static_cast<long>(data.size()) - originalLength);
-
-  // Update ID3 tags
-
-  if(ID3v2Tag() && !ID3v2Tag()->isEmpty()) {
-
-    // ID3v2 tag is not empty. Update the old one or create a new one.
-
-    if(d->ID3v2Location < 0)
-      d->ID3v2Location = 0;
-
-    data = ID3v2Tag()->render();
-    insert(data, d->ID3v2Location, d->ID3v2OriginalSize);
-
-    d->flacStart   += (static_cast<long>(data.size()) - d->ID3v2OriginalSize);
-    d->streamStart += (static_cast<long>(data.size()) - d->ID3v2OriginalSize);
-
-    if(d->ID3v1Location >= 0)
-      d->ID3v1Location += (static_cast<long>(data.size()) - d->ID3v2OriginalSize);
-
-    d->ID3v2OriginalSize = data.size();
-  }
-  else {
-
-    // ID3v2 tag is empty. Remove the old one.
-
-    if(d->ID3v2Location >= 0) {
-      removeBlock(d->ID3v2Location, d->ID3v2OriginalSize);
-
-      d->flacStart   -= d->ID3v2OriginalSize;
-      d->streamStart -= d->ID3v2OriginalSize;
-
-      if(d->ID3v1Location >= 0)
-        d->ID3v1Location -= d->ID3v2OriginalSize;
-
-      d->ID3v2Location = -1;
-      d->ID3v2OriginalSize = 0;
-    }
-  }
-
-  if(ID3v1Tag() && !ID3v1Tag()->isEmpty()) {
-
-    // ID3v1 tag is not empty. Update the old one or create a new one.
-
-    if(d->ID3v1Location >= 0) {
-      seek(d->ID3v1Location);
-    }
-    else {
-      seek(0, End);
-      d->ID3v1Location = tell();
-    }
-
-    writeBlock(ID3v1Tag()->render());
-  }
-  else {
-
-    // ID3v1 tag is empty. Remove the old one.
-
-    if(d->ID3v1Location >= 0) {
-      truncate(d->ID3v1Location);
-      d->ID3v1Location = -1;
-    }
-  }
-
-  return true;
-}
-
-ID3v2::Tag *FLAC::File::ID3v2Tag(bool create)
-{
-  return d->tag.access<ID3v2::Tag>(FlacID3v2Index, create);
-}
-
-ID3v1::Tag *FLAC::File::ID3v1Tag(bool create)
-{
-  return d->tag.access<ID3v1::Tag>(FlacID3v1Index, create);
-}
-
-Ogg::XiphComment *FLAC::File::xiphComment(bool create)
-{
-  return d->tag.access<Ogg::XiphComment>(FlacXiphIndex, create);
-}
-
-void FLAC::File::setID3v2FrameFactory(const ID3v2::FrameFactory *factory)
-{
-  d->ID3v2FrameFactory = factory;
-}
-
-ByteVector FLAC::File::streamInfoData()
-{
-  debug("FLAC::File::streamInfoData() -- This function is obsolete. Returning an empty ByteVector.");
-  return ByteVector();
-}
-
-long FLAC::File::streamLength()
-{
-  debug("FLAC::File::streamLength() -- This function is obsolete. Returning zero.");
-  return 0;
-}
-
-List<FLAC::Picture *> FLAC::File::pictureList()
-{
-  List<Picture *> pictures;
-  for(BlockConstIterator it = d->blocks.begin(); it != d->blocks.end(); ++it) {
-    Picture *picture = dynamic_cast<Picture *>(*it);
-    if(picture) {
-      pictures.append(picture);
-    }
-  }
-  return pictures;
-}
-
-void FLAC::File::addPicture(Picture *picture)
-{
-  d->blocks.append(picture);
-}
-
-void FLAC::File::removePicture(Picture *picture, bool del)
-{
-  BlockIterator it = d->blocks.find(picture);
-  if(it != d->blocks.end())
-    d->blocks.erase(it);
-
-  if(del)
-    delete picture;
-}
-
-void FLAC::File::removePictures()
-{
-  for(BlockIterator it = d->blocks.begin(); it != d->blocks.end(); ) {
-    if(dynamic_cast<Picture *>(*it)) {
-      delete *it;
-      it = d->blocks.erase(it);
-    }
-    else {
-      ++it;
-    }
-  }
-}
-
-void FLAC::File::strip(int tags)
-{
-  if(tags & ID3v1)
-    d->tag.set(FlacID3v1Index, 0);
-
-  if(tags & ID3v2)
-    d->tag.set(FlacID3v2Index, 0);
-
-  if(tags & XiphComment) {
-    xiphComment()->removeAllFields();
-    xiphComment()->removeAllPictures();
-  }
-}
-
-bool FLAC::File::hasXiphComment() const
-{
-  return !d->xiphCommentData.isEmpty();
-}
-
-bool FLAC::File::hasID3v1Tag() const
-{
-  return (d->ID3v1Location >= 0);
-}
-
-bool FLAC::File::hasID3v2Tag() const
-{
-  return (d->ID3v2Location >= 0);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// private members
-////////////////////////////////////////////////////////////////////////////////
-
-void FLAC::File::read(bool readProperties)
-{
-  // Look for an ID3v2 tag
-
-  d->ID3v2Location = Utils::findID3v2(this);
-
-  if(d->ID3v2Location >= 0) {
-    d->tag.set(FlacID3v2Index, new ID3v2::Tag(this, d->ID3v2Location, d->ID3v2FrameFactory));
-    d->ID3v2OriginalSize = ID3v2Tag()->header()->completeTagSize();
-  }
-
-  // Look for an ID3v1 tag
-
-  d->ID3v1Location = Utils::findID3v1(this);
-
-  if(d->ID3v1Location >= 0)
-    d->tag.set(FlacID3v1Index, new ID3v1::Tag(this, d->ID3v1Location));
-
-  // Look for FLAC metadata, including vorbis comments
-
-  scan();
-
-  if(!isValid())
-    return;
-
-  if(!d->xiphCommentData.isEmpty())
-    d->tag.set(FlacXiphIndex, new Ogg::XiphComment(d->xiphCommentData));
-  else
-    d->tag.set(FlacXiphIndex, new Ogg::XiphComment());
-
-  if(readProperties) {
-
-    // First block should be the stream_info metadata
-
-    const ByteVector infoData = d->blocks.front()->render();
-
-    long streamLength;
-
-    if(d->ID3v1Location >= 0)
-      streamLength = d->ID3v1Location - d->streamStart;
-    else
-      streamLength = length() - d->streamStart;
-
-    d->properties = new Properties(infoData, streamLength);
-  }
-}
-
-void FLAC::File::scan()
-{
-  // Scan the metadata pages
-
-  if(d->scanned)
-    return;
-
-  if(!isValid())
-    return;
-
-  long nextBlockOffset;
-
-  if(d->ID3v2Location >= 0)
-    nextBlockOffset = find("fLaC", d->ID3v2Location + d->ID3v2OriginalSize);
-  else
-    nextBlockOffset = find("fLaC");
-
-  if(nextBlockOffset < 0) {
-    debug("FLAC::File::scan() -- FLAC stream not found");
-    setValid(false);
-    return;
-  }
-
-  nextBlockOffset += 4;
-  d->flacStart = nextBlockOffset;
-
-  while(true) {
-
-    seek(nextBlockOffset);
-    const ByteVector header = readBlock(4);
-
-    // Header format (from spec):
-    // <1> Last-metadata-block flag
-    // <7> BLOCK_TYPE
-    //    0 : STREAMINFO
-    //    1 : PADDING
-    //    ..
-    //    4 : VORBIS_COMMENT
-    //    ..
-    //    6 : PICTURE
-    //    ..
-    // <24> Length of metadata to follow
-
-    const char blockType = header[0] & ~LastBlockFlag;
-    const bool isLastBlock = (header[0] & LastBlockFlag) != 0;
-    const unsigned int blockLength = header.toUInt(1U, 3U);
-
-    // First block should be the stream_info metadata
-
-    if(d->blocks.isEmpty() && blockType != MetadataBlock::StreamInfo) {
-      debug("FLAC::File::scan() -- First block should be the stream_info metadata");
-      setValid(false);
-      return;
-    }
-
-    if(blockLength == 0
-      && blockType != MetadataBlock::Padding && blockType != MetadataBlock::SeekTable)
-    {
-      debug("FLAC::File::scan() -- Zero-sized metadata block found");
-      setValid(false);
-      return;
-    }
-
-    const ByteVector data = readBlock(blockLength);
-    if(data.size() != blockLength) {
-      debug("FLAC::File::scan() -- Failed to read a metadata block");
-      setValid(false);
-      return;
-    }
-
-    MetadataBlock *block = 0;
-
-    // Found the vorbis-comment
-    if(blockType == MetadataBlock::VorbisComment) {
-      if(d->xiphCommentData.isEmpty()) {
-        d->xiphCommentData = data;
-        block = new UnknownMetadataBlock(MetadataBlock::VorbisComment, data);
-      }
-      else {
-        debug("FLAC::File::scan() -- multiple Vorbis Comment blocks found, discarding");
-      }
-    }
-    else if(blockType == MetadataBlock::Picture) {
-      FLAC::Picture *picture = new FLAC::Picture();
-      if(picture->parse(data)) {
-        block = picture;
-      }
-      else {
-        debug("FLAC::File::scan() -- invalid picture found, discarding");
-        delete picture;
-      }
-    }
-    else if(blockType == MetadataBlock::Padding) {
-      // Skip all padding blocks.
-    }
-    else {
-      block = new UnknownMetadataBlock(blockType, data);
-    }
-
-    if(block)
-      d->blocks.append(block);
-
-    nextBlockOffset += blockLength + 4;
-
-    if(isLastBlock)
-      break;
-  }
-
-  // End of metadata, now comes the datastream
-
-  d->streamStart = nextBlockOffset;
-
-  d->scanned = true;
-}

3rdparty/taglib/flac/flacfile.h

@@ -1,345 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2003 by Allan Sandfeld Jensen
-    email                : kde@carewolf.org
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_FLACFILE_H
-#define TAGLIB_FLACFILE_H
-
-#include "taglib_export.h"
-#include "tfile.h"
-#include "tlist.h"
-#include "tag.h"
-
-#include "flacpicture.h"
-#include "flacproperties.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  class Tag;
-  namespace ID3v2 { class FrameFactory; class Tag; }
-  namespace ID3v1 { class Tag; }
-  namespace Ogg { class XiphComment; }
-
-  //! An implementation of FLAC metadata
-
-  /*!
-   * This is implementation of FLAC metadata for non-Ogg FLAC files.  At some
-   * point when Ogg / FLAC is more common there will be a similar implementation
-   * under the Ogg hierarchy.
-   *
-   * This supports ID3v1, ID3v2 and Xiph style comments as well as reading stream
-   * properties from the file.
-   */
-
-  namespace FLAC {
-
-    //! An implementation of TagLib::File with FLAC specific methods
-
-    /*!
-     * This implements and provides an interface for FLAC files to the
-     * TagLib::Tag and TagLib::AudioProperties interfaces by way of implementing
-     * the abstract TagLib::File API as well as providing some additional
-     * information specific to FLAC files.
-     */
-
-    class TAGLIB_EXPORT File : public Strawberry_TagLib::TagLib::File
-    {
-    public:
-      /*!
-       * This set of flags is used for various operations and is suitable for
-       * being OR-ed together.
-       */
-      enum TagTypes {
-        //! Empty set.  Matches no tag types.
-        NoTags      = 0x0000,
-        //! Matches Vorbis comments.
-        XiphComment = 0x0001,
-        //! Matches ID3v1 tags.
-        ID3v1       = 0x0002,
-        //! Matches ID3v2 tags.
-        ID3v2       = 0x0004,
-        //! Matches all tag types.
-        AllTags     = 0xffff
-      };
-
-      /*!
-       * Constructs a FLAC file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read.
-       *
-       * \note In the current implementation, \a propertiesStyle is ignored.
-       *
-       * \deprecated This constructor will be dropped in favor of the one below
-       * in a future version.
-       */
-      File(FileName file, bool readProperties = true,
-           Properties::ReadStyle propertiesStyle = Properties::Average);
-
-      /*!
-       * Constructs an FLAC file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read.
-       *
-       * If this file contains and ID3v2 tag the frames will be created using
-       * \a frameFactory.
-       *
-       * \note In the current implementation, \a propertiesStyle is ignored.
-       */
-      // BIC: merge with the above constructor
-      File(FileName file, ID3v2::FrameFactory *frameFactory,
-           bool readProperties = true,
-           Properties::ReadStyle propertiesStyle = Properties::Average);
-
-      /*!
-       * Constructs a FLAC file from \a stream.  If \a readProperties is true the
-       * file's audio properties will also be read.
-       *
-       * \note TagLib will *not* take ownership of the stream, the caller is
-       * responsible for deleting it after the File object.
-       *
-       * If this file contains and ID3v2 tag the frames will be created using
-       * \a frameFactory.
-       *
-       * \note In the current implementation, \a propertiesStyle is ignored.
-       */
-      // BIC: merge with the above constructor
-      File(IOStream *stream, ID3v2::FrameFactory *frameFactory,
-           bool readProperties = true,
-           Properties::ReadStyle propertiesStyle = Properties::Average);
-
-      /*!
-       * Destroys this instance of the File.
-       */
-      virtual ~File();
-
-      /*!
-       * Returns the Tag for this file.  This will be a union of XiphComment,
-       * ID3v1 and ID3v2 tags.
-       *
-       * \see ID3v2Tag()
-       * \see ID3v1Tag()
-       * \see XiphComment()
-       */
-      virtual Strawberry_TagLib::TagLib::Tag *tag() const;
-
-      /*!
-       * Implements the unified property interface -- export function.
-       * If the file contains more than one tag (e.g. XiphComment and ID3v1),
-       * only the first one (in the order XiphComment, ID3v2, ID3v1) will be
-       * converted to the PropertyMap.
-       */
-      PropertyMap properties() const;
-
-      void removeUnsupportedProperties(const StringList &);
-
-      /*!
-       * Implements the unified property interface -- import function.
-       * This always creates a Xiph comment, if none exists. The return value
-       * relates to the Xiph comment only.
-       * Ignores any changes to ID3v1 or ID3v2 comments since they are not allowed
-       * in the FLAC specification.
-       */
-      PropertyMap setProperties(const PropertyMap &);
-
-      /*!
-       * Returns the FLAC::Properties for this file.  If no audio properties
-       * were read then this will return a null pointer.
-       */
-      virtual Properties *audioProperties() const;
-
-      /*!
-       * Save the file.  This will primarily save the XiphComment, but
-       * will also keep any old ID3-tags up to date. If the file
-       * has no XiphComment, one will be constructed from the ID3-tags.
-       *
-       * This returns true if the save was successful.
-       */
-      virtual bool save();
-
-      /*!
-       * Returns a pointer to the ID3v2 tag of the file.
-       *
-       * If \a create is false (the default) this returns a null pointer
-       * if there is no valid ID3v2 tag.  If \a create is true it will create
-       * an ID3v2 tag if one does not exist and returns a valid pointer.
-       *
-       * \note This may return a valid pointer regardless of whether or not the
-       * file on disk has an ID3v2 tag.  Use hasID3v2Tag() to check if the file
-       * on disk actually has an ID3v2 tag.
-       *
-       * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
-       * deleted by the user.  It will be deleted when the file (object) is
-       * destroyed.
-       *
-       * \see hasID3v2Tag()
-       */
-      ID3v2::Tag *ID3v2Tag(bool create = false);
-
-      /*!
-       * Returns a pointer to the ID3v1 tag of the file.
-       *
-       * If \a create is false (the default) this returns a null pointer
-       * if there is no valid APE tag.  If \a create is true it will create
-       * an APE tag if one does not exist and returns a valid pointer.
-       *
-       * \note This may return a valid pointer regardless of whether or not the
-       * file on disk has an ID3v1 tag.  Use hasID3v1Tag() to check if the file
-       * on disk actually has an ID3v1 tag.
-       *
-       * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
-       * deleted by the user.  It will be deleted when the file (object) is
-       * destroyed.
-       *
-       * \see hasID3v1Tag()
-       */
-      ID3v1::Tag *ID3v1Tag(bool create = false);
-
-      /*!
-       * Returns a pointer to the XiphComment for the file.
-       *
-       * If \a create is false (the default) this returns a null pointer
-       * if there is no valid XiphComment.  If \a create is true it will create
-       * a XiphComment if one does not exist and returns a valid pointer.
-       *
-       * \note This may return a valid pointer regardless of whether or not the
-       * file on disk has a XiphComment.  Use hasXiphComment() to check if the
-       * file on disk actually has a XiphComment.
-       *
-       * \note The Tag <b>is still</b> owned by the FLAC::File and should not be
-       * deleted by the user.  It will be deleted when the file (object) is
-       * destroyed.
-       *
-       * \see hasXiphComment()
-       */
-      Ogg::XiphComment *xiphComment(bool create = false);
-
-      /*!
-       * Set the ID3v2::FrameFactory to something other than the default.  This
-       * can be used to specify the way that ID3v2 frames will be interpreted
-       * when
-       *
-       * \see ID3v2FrameFactory
-       * \deprecated This value should be passed in via the constructor
-       */
-      TAGLIB_DEPRECATED void setID3v2FrameFactory(const ID3v2::FrameFactory *factory);
-
-      /*!
-       * Returns the block of data used by FLAC::Properties for parsing the
-       * stream properties.
-       *
-       * \deprecated Always returns an empty vector.
-       */
-      TAGLIB_DEPRECATED ByteVector streamInfoData(); // BIC: remove
-
-      /*!
-       * Returns the length of the audio-stream, used by FLAC::Properties for
-       * calculating the bitrate.
-       *
-       * \deprecated Always returns zero.
-       */
-      TAGLIB_DEPRECATED long streamLength();  // BIC: remove
-
-      /*!
-       * Returns a list of pictures attached to the FLAC file.
-       */
-      List<Picture *> pictureList();
-
-      /*!
-       * Removes an attached picture. If \a del is true the picture's memory
-       * will be freed; if it is false, it must be deleted by the user.
-       */
-      void removePicture(Picture *picture, bool del = true);
-
-      /*!
-       * Remove all attached images.
-       */
-      void removePictures();
-
-      /*!
-       * Add a new picture to the file. The file takes ownership of the
-       * picture and will handle freeing its memory.
-       *
-       * \note The file will be saved only after calling save().
-       */
-      void addPicture(Picture *picture);
-
-      /*!
-       * This will remove the tags that match the OR-ed together TagTypes from
-       * the file.  By default it removes all tags.
-       *
-       * \warning This will also invalidate pointers to the tags as their memory
-       * will be freed.
-       *
-       * \note In order to make the removal permanent save() still needs to be
-       * called.
-       *
-       * \note This won't remove the Vorbis comment block completely.  The
-       * vendor ID will be preserved.
-       */
-      void strip(int tags = AllTags);
-
-      /*!
-       * Returns whether or not the file on disk actually has a XiphComment.
-       *
-       * \see xiphComment()
-       */
-      bool hasXiphComment() const;
-
-      /*!
-       * Returns whether or not the file on disk actually has an ID3v1 tag.
-       *
-       * \see ID3v1Tag()
-       */
-      bool hasID3v1Tag() const;
-
-      /*!
-       * Returns whether or not the file on disk actually has an ID3v2 tag.
-       *
-       * \see ID3v2Tag()
-       */
-      bool hasID3v2Tag() const;
-
-      /*!
-       * Returns whether or not the given \a stream can be opened as a FLAC
-       * file.
-       *
-       * \note This method is designed to do a quick check.  The result may
-       * not necessarily be correct.
-       */
-      static bool isSupported(IOStream *stream);
-
-    private:
-      File(const File &);
-      File &operator=(const File &);
-
-      void read(bool readProperties);
-      void scan();
-
-      class FilePrivate;
-      FilePrivate *d;
-    };
-  }
-}
-}
-
-#endif

3rdparty/taglib/flac/flacmetadatablock.cpp

@@ -1,47 +0,0 @@
-/**************************************************************************
-    copyright            : (C) 2010 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
- **************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <taglib.h>
-#include <tdebug.h>
-#include "flacmetadatablock.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-class FLAC::MetadataBlock::MetadataBlockPrivate
-{
-public:
-  MetadataBlockPrivate() {}
-
-};
-
-FLAC::MetadataBlock::MetadataBlock()
-{
-  d = 0;
-}
-
-FLAC::MetadataBlock::~MetadataBlock()
-{
-}
-

3rdparty/taglib/flac/flacmetadatablock.h

@@ -1,77 +0,0 @@
-/**************************************************************************
-    copyright            : (C) 2010 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
- **************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_FLACMETADATABLOCK_H
-#define TAGLIB_FLACMETADATABLOCK_H
-
-#include "tlist.h"
-#include "tbytevector.h"
-#include "taglib_export.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  namespace FLAC {
-
-    class TAGLIB_EXPORT MetadataBlock
-    {
-    public:
-      MetadataBlock();
-      virtual ~MetadataBlock();
-
-      enum BlockType {
-        StreamInfo = 0,
-        Padding,
-        Application,
-        SeekTable,
-        VorbisComment,
-        CueSheet,
-        Picture
-      };
-
-      /*!
-       * Returns the FLAC metadata block type.
-       */
-      virtual int code() const = 0;
-
-      /*!
-       * Render the content of the block.
-       */
-      virtual ByteVector render() const = 0;
-
-    private:
-      MetadataBlock(const MetadataBlock &item);
-      MetadataBlock &operator=(const MetadataBlock &item);
-
-      class MetadataBlockPrivate;
-      MetadataBlockPrivate *d;
-    };
-
-  }
-
-}
-}
-
-#endif

3rdparty/taglib/flac/flacpicture.cpp

@@ -1,217 +0,0 @@
-/**************************************************************************
-    copyright            : (C) 2010 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
- **************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <taglib.h>
-#include <tdebug.h>
-#include "flacpicture.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-class FLAC::Picture::PicturePrivate
-{
-public:
-  PicturePrivate() :
-    type(FLAC::Picture::Other),
-    width(0),
-    height(0),
-    colorDepth(0),
-    numColors(0)
-    {}
-
-  Type type;
-  String mimeType;
-  String description;
-  int width;
-  int height;
-  int colorDepth;
-  int numColors;
-  ByteVector data;
-};
-
-FLAC::Picture::Picture() :
-  d(new PicturePrivate())
-{
-}
-
-FLAC::Picture::Picture(const ByteVector &data) :
-  d(new PicturePrivate())
-{
-  parse(data);
-}
-
-FLAC::Picture::~Picture()
-{
-  delete d;
-}
-
-int FLAC::Picture::code() const
-{
-  return FLAC::MetadataBlock::Picture;
-}
-
-bool FLAC::Picture::parse(const ByteVector &data)
-{
-  if(data.size() < 32) {
-    debug("A picture block must contain at least 5 bytes.");
-    return false;
-  }
-
-  unsigned int pos = 0;
-  d->type = FLAC::Picture::Type(data.toUInt(pos));
-  pos += 4;
-  unsigned int mimeTypeLength = data.toUInt(pos);
-  pos += 4;
-  if(pos + mimeTypeLength + 24 > data.size()) {
-    debug("Invalid picture block.");
-    return false;
-  }
-  d->mimeType = String(data.mid(pos, mimeTypeLength), String::UTF8);
-  pos += mimeTypeLength;
-  unsigned int descriptionLength = data.toUInt(pos);
-  pos += 4;
-  if(pos + descriptionLength + 20 > data.size()) {
-    debug("Invalid picture block.");
-    return false;
-  }
-  d->description = String(data.mid(pos, descriptionLength), String::UTF8);
-  pos += descriptionLength;
-  d->width = data.toUInt(pos);
-  pos += 4;
-  d->height = data.toUInt(pos);
-  pos += 4;
-  d->colorDepth = data.toUInt(pos);
-  pos += 4;
-  d->numColors = data.toUInt(pos);
-  pos += 4;
-  unsigned int dataLength = data.toUInt(pos);
-  pos += 4;
-  if(pos + dataLength > data.size()) {
-    debug("Invalid picture block.");
-    return false;
-  }
-  d->data = data.mid(pos, dataLength);
-
-  return true;
-}
-
-ByteVector FLAC::Picture::render() const
-{
-  ByteVector result;
-  result.append(ByteVector::fromUInt(d->type));
-  ByteVector mimeTypeData = d->mimeType.data(String::UTF8);
-  result.append(ByteVector::fromUInt(mimeTypeData.size()));
-  result.append(mimeTypeData);
-  ByteVector descriptionData = d->description.data(String::UTF8);
-  result.append(ByteVector::fromUInt(descriptionData.size()));
-  result.append(descriptionData);
-  result.append(ByteVector::fromUInt(d->width));
-  result.append(ByteVector::fromUInt(d->height));
-  result.append(ByteVector::fromUInt(d->colorDepth));
-  result.append(ByteVector::fromUInt(d->numColors));
-  result.append(ByteVector::fromUInt(d->data.size()));
-  result.append(d->data);
-  return result;
-}
-
-FLAC::Picture::Type FLAC::Picture::type() const
-{
-  return d->type;
-}
-
-void FLAC::Picture::setType(FLAC::Picture::Type type)
-{
-  d->type = type;
-}
-
-String FLAC::Picture::mimeType() const
-{
-  return d->mimeType;
-}
-
-void FLAC::Picture::setMimeType(const String &mimeType)
-{
-  d->mimeType = mimeType;
-}
-
-String FLAC::Picture::description() const
-{
-  return d->description;
-}
-
-void FLAC::Picture::setDescription(const String &description)
-{
-  d->description = description;
-}
-
-int FLAC::Picture::width() const
-{
-  return d->width;
-}
-
-void FLAC::Picture::setWidth(int width)
-{
-  d->width = width;
-}
-
-int FLAC::Picture::height() const
-{
-  return d->height;
-}
-
-void FLAC::Picture::setHeight(int height)
-{
-  d->height = height;
-}
-
-int FLAC::Picture::colorDepth() const
-{
-  return d->colorDepth;
-}
-
-void FLAC::Picture::setColorDepth(int colorDepth)
-{
-  d->colorDepth = colorDepth;
-}
-
-int FLAC::Picture::numColors() const
-{
-  return d->numColors;
-}
-
-void FLAC::Picture::setNumColors(int numColors)
-{
-  d->numColors = numColors;
-}
-
-ByteVector FLAC::Picture::data() const
-{
-  return d->data;
-}
-
-void FLAC::Picture::setData(const ByteVector &data)
-{
-  d->data = data;
-}
-

3rdparty/taglib/flac/flacpicture.h

@@ -1,210 +0,0 @@
-/**************************************************************************
-    copyright            : (C) 2010 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
- **************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_FLACPICTURE_H
-#define TAGLIB_FLACPICTURE_H
-
-#include "tlist.h"
-#include "tstring.h"
-#include "tbytevector.h"
-#include "taglib_export.h"
-#include "flacmetadatablock.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  namespace FLAC {
-
-    class TAGLIB_EXPORT Picture : public MetadataBlock
-    {
-    public:
-
-      /*!
-       * This describes the function or content of the picture.
-       */
-      enum Type {
-        //! A type not enumerated below
-        Other              = 0x00,
-        //! 32x32 PNG image that should be used as the file icon
-        FileIcon           = 0x01,
-        //! File icon of a different size or format
-        OtherFileIcon      = 0x02,
-        //! Front cover image of the album
-        FrontCover         = 0x03,
-        //! Back cover image of the album
-        BackCover          = 0x04,
-        //! Inside leaflet page of the album
-        LeafletPage        = 0x05,
-        //! Image from the album itself
-        Media              = 0x06,
-        //! Picture of the lead artist or soloist
-        LeadArtist         = 0x07,
-        //! Picture of the artist or performer
-        Artist             = 0x08,
-        //! Picture of the conductor
-        Conductor          = 0x09,
-        //! Picture of the band or orchestra
-        Band               = 0x0A,
-        //! Picture of the composer
-        Composer           = 0x0B,
-        //! Picture of the lyricist or text writer
-        Lyricist           = 0x0C,
-        //! Picture of the recording location or studio
-        RecordingLocation  = 0x0D,
-        //! Picture of the artists during recording
-        DuringRecording    = 0x0E,
-        //! Picture of the artists during performance
-        DuringPerformance  = 0x0F,
-        //! Picture from a movie or video related to the track
-        MovieScreenCapture = 0x10,
-        //! Picture of a large, coloured fish
-        ColouredFish       = 0x11,
-        //! Illustration related to the track
-        Illustration       = 0x12,
-        //! Logo of the band or performer
-        BandLogo           = 0x13,
-        //! Logo of the publisher (record company)
-        PublisherLogo      = 0x14
-      };
-
-      Picture();
-      Picture(const ByteVector &data);
-      ~Picture();
-
-      /*!
-       * Returns the type of the image.
-       */
-      Type type() const;
-
-      /*!
-       * Sets the type of the image.
-       */
-      void setType(Type type);
-
-      /*!
-       * Returns the mime type of the image.  This should in most cases be
-       * "image/png" or "image/jpeg".
-       */
-      String mimeType() const;
-
-      /*!
-       * Sets the mime type of the image.  This should in most cases be
-       * "image/png" or "image/jpeg".
-       */
-      void setMimeType(const String &m);
-
-      /*!
-       * Returns a text description of the image.
-       */
-
-      String description() const;
-
-      /*!
-       * Sets a textual description of the image to \a desc.
-       */
-
-      void setDescription(const String &desc);
-
-      /*!
-       * Returns the width of the image.
-       */
-      int width() const;
-
-      /*!
-       * Sets the width of the image.
-       */
-      void setWidth(int w);
-
-      /*!
-       * Returns the height of the image.
-       */
-      int height() const;
-
-      /*!
-       * Sets the height of the image.
-       */
-      void setHeight(int h);
-
-      /*!
-       * Returns the color depth (in bits-per-pixel) of the image.
-       */
-      int colorDepth() const;
-
-      /*!
-       * Sets the color depth (in bits-per-pixel) of the image.
-       */
-      void setColorDepth(int depth);
-
-      /*!
-       * Returns the number of colors used on the image..
-       */
-      int numColors() const;
-
-      /*!
-       * Sets the number of colors used on the image (for indexed images).
-       */
-      void setNumColors(int numColors);
-
-      /*!
-       * Returns the image data.
-       */
-      ByteVector data() const;
-
-      /*!
-       * Sets the image data.
-       */
-      void setData(const ByteVector &data);
-
-      /*!
-       * Returns the FLAC metadata block type.
-       */
-      int code() const;
-
-      /*!
-       * Render the content to the FLAC picture block format.
-       */
-      ByteVector render() const;
-
-      /*!
-       * Parse the picture data in the FLAC picture block format.
-       */
-      bool parse(const ByteVector &rawData);
-
-    private:
-      Picture(const Picture &item);
-      Picture &operator=(const Picture &item);
-
-      class PicturePrivate;
-      PicturePrivate *d;
-    };
-
-    typedef List<Picture> PictureList;
-
-  }
-
-}
-}
-
-#endif

3rdparty/taglib/flac/flacproperties.cpp

@@ -1,176 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2003 by Allan Sandfeld Jensen
-    email                : kde@carewolf.org
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <tstring.h>
-#include <tdebug.h>
-
-#include "flacproperties.h"
-#include "flacfile.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-class FLAC::Properties::PropertiesPrivate
-{
-public:
-  PropertiesPrivate() :
-    length(0),
-    bitrate(0),
-    sampleRate(0),
-    bitsPerSample(0),
-    channels(0),
-    sampleFrames(0) {}
-
-  int length;
-  int bitrate;
-  int sampleRate;
-  int bitsPerSample;
-  int channels;
-  unsigned long long sampleFrames;
-  ByteVector signature;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// public members
-////////////////////////////////////////////////////////////////////////////////
-
-FLAC::Properties::Properties(ByteVector data, long streamLength, ReadStyle style) :
-  AudioProperties(style),
-  d(new PropertiesPrivate())
-{
-  read(data, streamLength);
-}
-
-FLAC::Properties::Properties(File *, ReadStyle style) :
-  AudioProperties(style),
-  d(new PropertiesPrivate())
-{
-  debug("FLAC::Properties::Properties() - This constructor is no longer used.");
-}
-
-FLAC::Properties::~Properties()
-{
-  delete d;
-}
-
-int FLAC::Properties::length() const
-{
-  return lengthInSeconds();
-}
-
-int FLAC::Properties::lengthInSeconds() const
-{
-  return d->length / 1000;
-}
-
-int FLAC::Properties::lengthInMilliseconds() const
-{
-  return d->length;
-}
-
-int FLAC::Properties::bitrate() const
-{
-  return d->bitrate;
-}
-
-int FLAC::Properties::sampleRate() const
-{
-  return d->sampleRate;
-}
-
-int FLAC::Properties::bitsPerSample() const
-{
-  return d->bitsPerSample;
-}
-
-int FLAC::Properties::sampleWidth() const
-{
-  return bitsPerSample();
-}
-
-int FLAC::Properties::channels() const
-{
-  return d->channels;
-}
-
-unsigned long long FLAC::Properties::sampleFrames() const
-{
-  return d->sampleFrames;
-}
-
-ByteVector FLAC::Properties::signature() const
-{
-  return d->signature;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// private members
-////////////////////////////////////////////////////////////////////////////////
-
-void FLAC::Properties::read(const ByteVector &data, long streamLength)
-{
-  if(data.size() < 18) {
-    debug("FLAC::Properties::read() - FLAC properties must contain at least 18 bytes.");
-    return;
-  }
-
-  unsigned int pos = 0;
-
-  // Minimum block size (in samples)
-  pos += 2;
-
-  // Maximum block size (in samples)
-  pos += 2;
-
-  // Minimum frame size (in bytes)
-  pos += 3;
-
-  // Maximum frame size (in bytes)
-  pos += 3;
-
-  const unsigned int flags = data.toUInt(pos, true);
-  pos += 4;
-
-  d->sampleRate    = flags >> 12;
-  d->channels      = ((flags >> 9) &  7) + 1;
-  d->bitsPerSample = ((flags >> 4) & 31) + 1;
-
-  // The last 4 bits are the most significant 4 bits for the 36 bit
-  // stream length in samples. (Audio files measured in days)
-
-  const unsigned long long hi = flags & 0xf;
-  const unsigned long long lo = data.toUInt(pos, true);
-  pos += 4;
-
-  d->sampleFrames = (hi << 32) | lo;
-
-  if(d->sampleFrames > 0 && d->sampleRate > 0) {
-    const double length = d->sampleFrames * 1000.0 / d->sampleRate;
-    d->length  = static_cast<int>(length + 0.5);
-    d->bitrate = static_cast<int>(streamLength * 8.0 / length + 0.5);
-  }
-
-  if(data.size() >= pos + 16)
-    d->signature = data.mid(pos, 16);
-}

3rdparty/taglib/flac/flacproperties.h

@@ -1,150 +0,0 @@
-/***************************************************************************
-    copyright            : (C) 2003 by Allan Sandfeld Jensen
-    email                : kde@carewolf.org
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_FLACPROPERTIES_H
-#define TAGLIB_FLACPROPERTIES_H
-
-#include "taglib_export.h"
-#include "audioproperties.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  namespace FLAC {
-
-    class File;
-
-    //! An implementation of audio property reading for FLAC
-
-    /*!
-     * This reads the data from an FLAC stream found in the AudioProperties
-     * API.
-     */
-
-    class TAGLIB_EXPORT Properties : public AudioProperties
-    {
-    public:
-      /*!
-       * Create an instance of FLAC::Properties with the data read from the
-       * ByteVector \a data.
-       */
-       // BIC: switch to const reference
-      Properties(ByteVector data, long streamLength, ReadStyle style = Average);
-
-      /*!
-       * Create an instance of FLAC::Properties with the data read from the
-       * FLAC::File \a file.
-       */
-       // BIC: remove
-      Properties(File *file, ReadStyle style = Average);
-
-      /*!
-       * Destroys this FLAC::Properties instance.
-       */
-      virtual ~Properties();
-
-      /*!
-       * Returns the length of the file in seconds.  The length is rounded down to
-       * the nearest whole second.
-       *
-       * \note This method is just an alias of lengthInSeconds().
-       *
-       * \deprecated
-       */
-      TAGLIB_DEPRECATED virtual int length() const;
-
-      /*!
-       * Returns the length of the file in seconds.  The length is rounded down to
-       * the nearest whole second.
-       *
-       * \see lengthInMilliseconds()
-       */
-      // BIC: make virtual
-      int lengthInSeconds() const;
-
-      /*!
-       * Returns the length of the file in milliseconds.
-       *
-       * \see lengthInSeconds()
-       */
-      // BIC: make virtual
-      int lengthInMilliseconds() const;
-
-      /*!
-       * Returns the average bit rate of the file in kb/s.
-       */
-      virtual int bitrate() const;
-
-      /*!
-       * Returns the sample rate in Hz.
-       */
-      virtual int sampleRate() const;
-
-      /*!
-       * Returns the number of audio channels.
-       */
-      virtual int channels() const;
-
-      /*!
-       * Returns the number of bits per audio sample as read from the FLAC
-       * identification header.
-       */
-      int bitsPerSample() const;
-
-      /*!
-       * Returns the sample width as read from the FLAC identification
-       * header.
-       *
-       * \note This method is just an alias of bitsPerSample().
-       *
-       * \deprecated
-       */
-      TAGLIB_DEPRECATED int sampleWidth() const;
-
-      /*!
-       * Return the number of sample frames.
-       */
-      unsigned long long sampleFrames() const;
-
-      /*!
-       * Returns the MD5 signature of the uncompressed audio stream as read
-       * from the stream info header.
-       */
-      ByteVector signature() const;
-
-    private:
-      Properties(const Properties &);
-      Properties &operator=(const Properties &);
-
-      void read(const ByteVector &data, long streamLength);
-
-      class PropertiesPrivate;
-      PropertiesPrivate *d;
-    };
-  }
-}
-}
-
-#endif

3rdparty/taglib/flac/flacunknownmetadatablock.cpp

@@ -1,78 +0,0 @@
-/**************************************************************************
-    copyright            : (C) 2010 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
- **************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#include <taglib.h>
-#include <tdebug.h>
-#include <tstring.h>
-#include "flacunknownmetadatablock.h"
-
-using namespace Strawberry_TagLib::TagLib;
-
-class FLAC::UnknownMetadataBlock::UnknownMetadataBlockPrivate
-{
-public:
-  UnknownMetadataBlockPrivate() : code(0) {}
-
-  int code;
-  ByteVector data;
-};
-
-FLAC::UnknownMetadataBlock::UnknownMetadataBlock(int code, const ByteVector &data) :
-  d(new UnknownMetadataBlockPrivate())
-{
-  d->code = code;
-  d->data = data;
-}
-
-FLAC::UnknownMetadataBlock::~UnknownMetadataBlock()
-{
-  delete d;
-}
-
-int FLAC::UnknownMetadataBlock::code() const
-{
-  return d->code;
-}
-
-void FLAC::UnknownMetadataBlock::setCode(int code)
-{
-  d->code = code;
-}
-
-ByteVector FLAC::UnknownMetadataBlock::data() const
-{
-  return d->data;
-}
-
-void FLAC::UnknownMetadataBlock::setData(const ByteVector &data)
-{
-  d->data = data;
-}
-
-ByteVector FLAC::UnknownMetadataBlock::render() const
-{
-  return d->data;
-}
-

3rdparty/taglib/flac/flacunknownmetadatablock.h

@@ -1,83 +0,0 @@
-/**************************************************************************
-    copyright            : (C) 2010 by Lukáš Lalinský
-    email                : lalinsky@gmail.com
- **************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_FLACUNKNOWNMETADATABLOCK_H
-#define TAGLIB_FLACUNKNOWNMETADATABLOCK_H
-
-#include "tlist.h"
-#include "tbytevector.h"
-#include "taglib_export.h"
-#include "flacmetadatablock.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  namespace FLAC {
-
-    class TAGLIB_EXPORT UnknownMetadataBlock : public MetadataBlock
-    {
-    public:
-      UnknownMetadataBlock(int blockType, const ByteVector &data);
-      ~UnknownMetadataBlock();
-
-      /*!
-       * Returns the FLAC metadata block type.
-       */
-      int code() const;
-
-      /*!
-       * Sets the FLAC metadata block type.
-       */
-      void setCode(int code);
-
-      /*!
-       * Returns the FLAC metadata block type.
-       */
-      ByteVector data() const;
-
-      /*!
-       * Sets the FLAC metadata block type.
-       */
-      void setData(const ByteVector &data);
-
-      /*!
-       * Render the content of the block.
-       */
-      ByteVector render() const;
-
-    private:
-      UnknownMetadataBlock(const MetadataBlock &item);
-      UnknownMetadataBlock &operator=(const MetadataBlock &item);
-
-      class UnknownMetadataBlockPrivate;
-      UnknownMetadataBlockPrivate *d;
-    };
-
-  }
-
-}
-}
-
-#endif

3rdparty/taglib/it/itfile.cpp

@@ -1,335 +0,0 @@
-/***************************************************************************
-    copyright           : (C) 2011 by Mathias Panzenböck
-    email               : grosser.meister.morti@gmx.net
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-
-#include "tstringlist.h"
-#include "itfile.h"
-#include "tdebug.h"
-#include "modfileprivate.h"
-#include "tpropertymap.h"
-
-using namespace Strawberry_TagLib::TagLib;
-using namespace IT;
-
-class IT::File::FilePrivate
-{
-public:
-  explicit FilePrivate(AudioProperties::ReadStyle propertiesStyle)
-    : tag(), properties(propertiesStyle)
-  {
-  }
-
-  Mod::Tag       tag;
-  IT::Properties properties;
-};
-
-IT::File::File(FileName file, bool readProperties,
-               AudioProperties::ReadStyle propertiesStyle) :
-  Mod::FileBase(file),
-  d(new FilePrivate(propertiesStyle))
-{
-  if(isOpen())
-    read(readProperties);
-}
-
-IT::File::File(IOStream *stream, bool readProperties,
-               AudioProperties::ReadStyle propertiesStyle) :
-  Mod::FileBase(stream),
-  d(new FilePrivate(propertiesStyle))
-{
-  if(isOpen())
-    read(readProperties);
-}
-
-IT::File::~File()
-{
-  delete d;
-}
-
-Mod::Tag *IT::File::tag() const
-{
-  return &d->tag;
-}
-
-PropertyMap IT::File::properties() const
-{
-  return d->tag.properties();
-}
-
-PropertyMap IT::File::setProperties(const PropertyMap &properties)
-{
-  return d->tag.setProperties(properties);
-}
-
-IT::Properties *IT::File::audioProperties() const
-{
-  return &d->properties;
-}
-
-bool IT::File::save()
-{
-  if(readOnly())
-  {
-    debug("IT::File::save() - Cannot save to a read only file.");
-    return false;
-  }
-  seek(4);
-  writeString(d->tag.title(), 25);
-  writeByte(0);
-
-  seek(2, Current);
-
-  unsigned short length = 0;
-  unsigned short instrumentCount = 0;
-  unsigned short sampleCount = 0;
-
-  if(!readU16L(length) || !readU16L(instrumentCount) || !readU16L(sampleCount))
-    return false;
-
-  seek(15, Current);
-
-  // write comment as instrument and sample names:
-  StringList lines = d->tag.comment().split("\n");
-  for(unsigned short i = 0; i < instrumentCount; ++ i) {
-    seek(192L + length + ((long)i << 2));
-    unsigned long instrumentOffset = 0;
-    if(!readU32L(instrumentOffset))
-      return false;
-
-    seek(instrumentOffset + 32);
-
-    if(i < lines.size())
-      writeString(lines[i], 25);
-    else
-      writeString(String(), 25);
-    writeByte(0);
-  }
-
-  for(unsigned short i = 0; i < sampleCount; ++ i) {
-    seek(192L + length + ((long)instrumentCount << 2) + ((long)i << 2));
-    unsigned long sampleOffset = 0;
-    if(!readU32L(sampleOffset))
-      return false;
-
-    seek(sampleOffset + 20);
-
-    if((unsigned int)(i + instrumentCount) < lines.size())
-      writeString(lines[i + instrumentCount], 25);
-    else
-      writeString(String(), 25);
-    writeByte(0);
-  }
-
-  // write rest as message:
-  StringList messageLines;
-  for(unsigned int i = instrumentCount + sampleCount; i < lines.size(); ++ i)
-    messageLines.append(lines[i]);
-  ByteVector message = messageLines.toString("\r").data(String::Latin1);
-
-  // it's actually not really stated if the message needs a
-  // terminating NUL but it does not hurt to add one:
-  if(message.size() > 7999)
-    message.resize(7999);
-  message.append((char)0);
-
-  unsigned short special = 0;
-  unsigned short messageLength = 0;
-  unsigned long  messageOffset = 0;
-
-  seek(46);
-  if(!readU16L(special))
-    return false;
-
-  unsigned long fileSize = File::length();
-  if(special & Properties::MessageAttached) {
-    seek(54);
-    if(!readU16L(messageLength) || !readU32L(messageOffset))
-      return false;
-
-    if(messageLength == 0)
-      messageOffset = fileSize;
-  }
-  else
-  {
-    messageOffset = fileSize;
-    seek(46);
-    writeU16L(special | 0x1);
-  }
-
-  if(messageOffset + messageLength >= fileSize) {
-    // append new message
-    seek(54);
-    writeU16L(message.size());
-    writeU32L(messageOffset);
-    seek(messageOffset);
-    writeBlock(message);
-    truncate(messageOffset + message.size());
-  }
-  else {
-    // Only overwrite existing message.
-    // I'd need to parse (understand!) the whole file for more.
-    // Although I could just move the message to the end of file
-    // and let the existing one be, but that would waste space.
-    message.resize(messageLength, 0);
-    seek(messageOffset);
-    writeBlock(message);
-  }
-  return true;
-}
-
-void IT::File::read(bool)
-{
-  if(!isOpen())
-    return;
-
-  seek(0);
-  READ_ASSERT(readBlock(4) == "IMPM");
-  READ_STRING(d->tag.setTitle, 26);
-
-  seek(2, Current);
-
-  READ_U16L_AS(length);
-  READ_U16L_AS(instrumentCount);
-  READ_U16L_AS(sampleCount);
-
-  d->properties.setInstrumentCount(instrumentCount);
-  d->properties.setSampleCount(sampleCount);
-  READ_U16L(d->properties.setPatternCount);
-  READ_U16L(d->properties.setVersion);
-  READ_U16L(d->properties.setCompatibleVersion);
-  READ_U16L(d->properties.setFlags);
-  READ_U16L_AS(special);
-  d->properties.setSpecial(special);
-  READ_BYTE(d->properties.setGlobalVolume);
-  READ_BYTE(d->properties.setMixVolume);
-  READ_BYTE(d->properties.setBpmSpeed);
-  READ_BYTE(d->properties.setTempo);
-  READ_BYTE(d->properties.setPanningSeparation);
-  READ_BYTE(d->properties.setPitchWheelDepth);
-
-  // IT supports some kind of comment tag. Still, the
-  // sample/instrument names are abused as comments so
-  // I just add all together.
-  String message;
-  if(special & Properties::MessageAttached) {
-    READ_U16L_AS(messageLength);
-    READ_U32L_AS(messageOffset);
-    seek(messageOffset);
-    ByteVector messageBytes = readBlock(messageLength);
-    READ_ASSERT(messageBytes.size() == messageLength);
-    int index = messageBytes.find((char) 0);
-    if(index > -1)
-      messageBytes.resize(index, 0);
-    messageBytes.replace('\r', '\n');
-    message = messageBytes;
-  }
-
-  seek(64);
-
-  ByteVector pannings = readBlock(64);
-  ByteVector volumes  = readBlock(64);
-  READ_ASSERT(pannings.size() == 64 && volumes.size() == 64);
-  int channels = 0;
-  for(int i = 0; i < 64; ++ i) {
-    // Strictly speaking an IT file has always 64 channels, but
-    // I don't count disabled and muted channels.
-    // But this always gives 64 channels for all my files anyway.
-    // Strangely VLC does report other values. I wonder how VLC
-    // gets it's values.
-    if((unsigned char) pannings[i] < 128 && volumes[i] > 0)
-        ++channels;
-  }
-  d->properties.setChannels(channels);
-
-  // real length might be shorter because of skips and terminator
-  unsigned short realLength = 0;
-  for(unsigned short i = 0; i < length; ++ i) {
-    READ_BYTE_AS(order);
-    if(order == 255) break;
-    if(order != 254) ++ realLength;
-  }
-  d->properties.setLengthInPatterns(realLength);
-
-  StringList comment;
-  // Note: I found files that have nil characters somewhere
-  //       in the instrument/sample names and more characters
-  //       afterwards. The spec does not mention such a case.
-  //       Currently I just discard anything after a nil, but
-  //       e.g. VLC seems to interpret a nil as a space. I
-  //       don't know what is the proper behaviour.
-  for(unsigned short i = 0; i < instrumentCount; ++ i) {
-    seek(192L + length + ((long)i << 2));
-    READ_U32L_AS(instrumentOffset);
-    seek(instrumentOffset);
-
-    ByteVector instrumentMagic = readBlock(4);
-    READ_ASSERT(instrumentMagic == "IMPI");
-
-    READ_STRING_AS(dosFileName, 13);
-
-    seek(15, Current);
-
-    READ_STRING_AS(instrumentName, 26);
-    comment.append(instrumentName);
-  }
-
-  for(unsigned short i = 0; i < sampleCount; ++ i) {
-    seek(192L + length + ((long)instrumentCount << 2) + ((long)i << 2));
-    READ_U32L_AS(sampleOffset);
-
-    seek(sampleOffset);
-
-    ByteVector sampleMagic = readBlock(4);
-    READ_ASSERT(sampleMagic == "IMPS");
-
-    READ_STRING_AS(dosFileName, 13);
-    READ_BYTE_AS(globalVolume);
-    READ_BYTE_AS(sampleFlags);
-    READ_BYTE_AS(sampleVolume);
-    READ_STRING_AS(sampleName, 26);
-    /*
-    READ_BYTE_AS(sampleCvt);
-    READ_BYTE_AS(samplePanning);
-    READ_U32L_AS(sampleLength);
-    READ_U32L_AS(loopStart);
-    READ_U32L_AS(loopStop);
-    READ_U32L_AS(c5speed);
-    READ_U32L_AS(sustainLoopStart);
-    READ_U32L_AS(sustainLoopEnd);
-    READ_U32L_AS(sampleDataOffset);
-    READ_BYTE_AS(vibratoSpeed);
-    READ_BYTE_AS(vibratoDepth);
-    READ_BYTE_AS(vibratoRate);
-    READ_BYTE_AS(vibratoType);
-    */
-
-    comment.append(sampleName);
-  }
-
-  if(message.size() > 0)
-    comment.append(message);
-  d->tag.setComment(comment.toString("\n"));
-  d->tag.setTrackerName("Impulse Tracker");
-}

3rdparty/taglib/it/itfile.h

@@ -1,111 +0,0 @@
-/***************************************************************************
-    copyright           : (C) 2011 by Mathias Panzenböck
-    email               : grosser.meister.morti@gmx.net
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it  under the terms of the GNU Lesser General Public License version  *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,            *
- *   MA  02110-1301  USA                                                   *
- ***************************************************************************/
-
-#ifndef TAGLIB_ITFILE_H
-#define TAGLIB_ITFILE_H
-
-#include "tfile.h"
-#include "audioproperties.h"
-#include "taglib_export.h"
-#include "modfilebase.h"
-#include "modtag.h"
-#include "itproperties.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  namespace IT {
-
-    class TAGLIB_EXPORT File : public Mod::FileBase {
-      public:
-        /*!
-         * Constructs a Impulse Tracker file from \a file.
-         *
-         * \note In the current implementation, both \a readProperties and
-         * \a propertiesStyle are ignored.  The audio properties are always
-         * read.
-         */
-        File(FileName file, bool readProperties = true,
-             AudioProperties::ReadStyle propertiesStyle =
-             AudioProperties::Average);
-
-        /*!
-         * Constructs a Impulse Tracker file from \a stream.
-         *
-         * \note In the current implementation, both \a readProperties and
-         * \a propertiesStyle are ignored.  The audio properties are always
-         * read.
-         *
-         * \note TagLib will *not* take ownership of the stream, the caller is
-         * responsible for deleting it after the File object.
-         */
-        File(IOStream *stream, bool readProperties = true,
-             AudioProperties::ReadStyle propertiesStyle =
-             AudioProperties::Average);
-
-        /*!
-         * Destroys this instance of the File.
-         */
-        virtual ~File();
-
-        Mod::Tag *tag() const;
-
-        /*!
-         * Forwards to Mod::Tag::properties().
-         * BIC: will be removed once File::toDict() is made virtual
-         */
-        PropertyMap properties() const;
-
-        /*!
-         * Forwards to Mod::Tag::setProperties().
-         * BIC: will be removed once File::setProperties() is made virtual
-         */
-        PropertyMap setProperties(const PropertyMap &);
-
-        /*!
-         * Returns the IT::Properties for this file. If no audio properties
-         * were read then this will return a null pointer.
-         */
-        IT::Properties *audioProperties() const;
-
-        /*!
-         * Save the file.
-         * This is the same as calling save(AllTags);
-         *
-         * \note Saving Impulse Tracker tags is not supported.
-         */
-        bool save();
-
-
-      private:
-        File(const File &);
-        File &operator=(const File &);
-
-        void read(bool readProperties);
-
-        class FilePrivate;
-        FilePrivate *d;
-    };
-  }
-}
-}
-
-#endif

3rdparty/taglib/it/itproperties.cpp

@@ -1,260 +0,0 @@
-/***************************************************************************
-    copyright           :(C) 2011 by Mathias Panzenböck
-    email               : grosser.meister.morti@gmx.net
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-
-#include "itproperties.h"
-
-using namespace Strawberry_TagLib::TagLib;
-using namespace IT;
-
-class IT::Properties::PropertiesPrivate
-{
-public:
-  PropertiesPrivate() :
-    channels(0),
-    lengthInPatterns(0),
-    instrumentCount(0),
-    sampleCount(0),
-    patternCount(0),
-    version(0),
-    compatibleVersion(0),
-    flags(0),
-    special(0),
-    globalVolume(0),
-    mixVolume(0),
-    tempo(0),
-    bpmSpeed(0),
-    panningSeparation(0),
-    pitchWheelDepth(0)
-  {
-  }
-
-  int            channels;
-  unsigned short lengthInPatterns;
-  unsigned short instrumentCount;
-  unsigned short sampleCount;
-  unsigned short patternCount;
-  unsigned short version;
-  unsigned short compatibleVersion;
-  unsigned short flags;
-  unsigned short special;
-  unsigned char  globalVolume;
-  unsigned char  mixVolume;
-  unsigned char  tempo;
-  unsigned char  bpmSpeed;
-  unsigned char  panningSeparation;
-  unsigned char  pitchWheelDepth;
-};
-
-IT::Properties::Properties(AudioProperties::ReadStyle propertiesStyle) :
-  AudioProperties(propertiesStyle),
-  d(new PropertiesPrivate())
-{
-}
-
-IT::Properties::~Properties()
-{
-  delete d;
-}
-
-int IT::Properties::length() const
-{
-  return 0;
-}
-
-int IT::Properties::lengthInSeconds() const
-{
-  return 0;
-}
-
-int IT::Properties::lengthInMilliseconds() const
-{
-  return 0;
-}
-
-int IT::Properties::bitrate() const
-{
-  return 0;
-}
-
-int IT::Properties::sampleRate() const
-{
-  return 0;
-}
-
-int IT::Properties::channels() const
-{
-  return d->channels;
-}
-
-unsigned short IT::Properties::lengthInPatterns() const
-{
-  return d->lengthInPatterns;
-}
-
-bool IT::Properties::stereo() const
-{
-  return d->flags & Stereo;
-}
-
-unsigned short IT::Properties::instrumentCount() const
-{
-  return d->instrumentCount;
-}
-
-unsigned short IT::Properties::sampleCount() const
-{
-  return d->sampleCount;
-}
-
-unsigned short IT::Properties::patternCount() const
-{
-  return d->patternCount;
-}
-
-unsigned short IT::Properties::version() const
-{
-  return d->version;
-}
-
-unsigned short IT::Properties::compatibleVersion() const
-{
-  return d->compatibleVersion;
-}
-
-unsigned short IT::Properties::flags() const
-{
-  return d->flags;
-}
-
-unsigned short IT::Properties::special() const
-{
-  return d->special;
-}
-
-unsigned char IT::Properties::globalVolume() const
-{
-  return d->globalVolume;
-}
-
-unsigned char IT::Properties::mixVolume() const
-{
-  return d->mixVolume;
-}
-
-unsigned char IT::Properties::tempo() const
-{
-  return d->tempo;
-}
-
-unsigned char IT::Properties::bpmSpeed() const
-{
-  return d->bpmSpeed;
-}
-
-unsigned char IT::Properties::panningSeparation() const
-{
-  return d->panningSeparation;
-}
-
-unsigned char IT::Properties::pitchWheelDepth() const
-{
-  return d->pitchWheelDepth;
-}
-
-void IT::Properties::setChannels(int channels)
-{
-  d->channels = channels;
-}
-
-void IT::Properties::setLengthInPatterns(unsigned short lengthInPatterns)
-{
-  d->lengthInPatterns = lengthInPatterns;
-}
-
-void IT::Properties::setInstrumentCount(unsigned short instrumentCount)
-{
-  d->instrumentCount = instrumentCount;
-}
-
-void IT::Properties::setSampleCount(unsigned short sampleCount)
-{
-  d->sampleCount = sampleCount;
-}
-
-void IT::Properties::setPatternCount(unsigned short patternCount)
-{
-  d->patternCount = patternCount;
-}
-
-void IT::Properties::setFlags(unsigned short flags)
-{
-  d->flags = flags;
-}
-
-void IT::Properties::setSpecial(unsigned short special)
-{
-  d->special = special;
-}
-
-void IT::Properties::setCompatibleVersion(unsigned short compatibleVersion)
-{
-  d->compatibleVersion = compatibleVersion;
-}
-
-void IT::Properties::setVersion(unsigned short version)
-{
-  d->version = version;
-}
-
-void IT::Properties::setGlobalVolume(unsigned char globalVolume)
-{
-  d->globalVolume = globalVolume;
-}
-
-void IT::Properties::setMixVolume(unsigned char mixVolume)
-{
-  d->mixVolume = mixVolume;
-}
-
-void IT::Properties::setTempo(unsigned char tempo)
-{
-  d->tempo = tempo;
-}
-
-void IT::Properties::setBpmSpeed(unsigned char bpmSpeed)
-{
-  d->bpmSpeed = bpmSpeed;
-}
-
-void IT::Properties::setPanningSeparation(unsigned char panningSeparation)
-{
-  d->panningSeparation = panningSeparation;
-}
-
-void IT::Properties::setPitchWheelDepth(unsigned char pitchWheelDepth)
-{
-  d->pitchWheelDepth = pitchWheelDepth;
-}

3rdparty/taglib/it/itproperties.h

@@ -1,109 +0,0 @@
-/***************************************************************************
-    copyright           : (C) 2011 by Mathias Panzenböck
-    email               : grosser.meister.morti@gmx.net
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_ITPROPERTIES_H
-#define TAGLIB_ITPROPERTIES_H
-
-#include "taglib.h"
-#include "audioproperties.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-  namespace IT {
-    class TAGLIB_EXPORT Properties : public AudioProperties {
-      friend class File;
-    public:
-      /*! Flag bits. */
-      enum {
-        Stereo                  =   1,
-        Vol0MixOptimizations    =   2,
-        UseInstruments          =   4,
-        LinearSlides            =   8,
-        OldEffects              =  16,
-        LinkEffects             =  32,
-        UseMidiPitchController  =  64,
-        RequestEmbeddedMidiConf = 128
-      };
-
-      /*! Special bits. */
-      enum {
-        MessageAttached  = 1,
-        MidiConfEmbedded = 8
-      };
-
-      Properties(AudioProperties::ReadStyle propertiesStyle);
-      virtual ~Properties();
-
-      int length()               const;
-      int lengthInSeconds()      const;
-      int lengthInMilliseconds() const;
-      int bitrate()              const;
-      int sampleRate()           const;
-      int channels()             const;
-
-      unsigned short lengthInPatterns()  const;
-      bool           stereo()            const;
-      unsigned short instrumentCount()   const;
-      unsigned short sampleCount()       const;
-      unsigned short patternCount()      const;
-      unsigned short version()           const;
-      unsigned short compatibleVersion() const;
-      unsigned short flags()             const;
-      unsigned short special()           const;
-      unsigned char  globalVolume()      const;
-      unsigned char  mixVolume()         const;
-      unsigned char  tempo()             const;
-      unsigned char  bpmSpeed()          const;
-      unsigned char  panningSeparation() const;
-      unsigned char  pitchWheelDepth()   const;
-
-      void setChannels(int channels);
-      void setLengthInPatterns(unsigned short lengthInPatterns);
-      void setInstrumentCount(unsigned short instrumentCount);
-      void setSampleCount (unsigned short sampleCount);
-      void setPatternCount(unsigned short patternCount);
-      void setVersion     (unsigned short version);
-      void setCompatibleVersion(unsigned short compatibleVersion);
-      void setFlags       (unsigned short flags);
-      void setSpecial     (unsigned short special);
-      void setGlobalVolume(unsigned char globalVolume);
-      void setMixVolume   (unsigned char mixVolume);
-      void setTempo       (unsigned char tempo);
-      void setBpmSpeed    (unsigned char bpmSpeed);
-      void setPanningSeparation(unsigned char panningSeparation);
-      void setPitchWheelDepth  (unsigned char pitchWheelDepth);
-
-    private:
-      Properties(const Properties&);
-      Properties &operator=(const Properties&);
-
-      class PropertiesPrivate;
-      PropertiesPrivate *d;
-    };
-  }
-}
-}
-
-#endif

3rdparty/taglib/mod/modfile.cpp

@@ -1,192 +0,0 @@
-/***************************************************************************
-    copyright           : (C) 2011 by Mathias Panzenböck
-    email               : grosser.meister.morti@gmx.net
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-
-#include "modfile.h"
-#include "tstringlist.h"
-#include "tdebug.h"
-#include "modfileprivate.h"
-#include "tpropertymap.h"
-
-using namespace Strawberry_TagLib::TagLib;
-using namespace Mod;
-
-class Mod::File::FilePrivate
-{
-public:
-  explicit FilePrivate(AudioProperties::ReadStyle propertiesStyle)
-    : properties(propertiesStyle)
-  {
-  }
-
-  Mod::Tag        tag;
-  Mod::Properties properties;
-};
-
-Mod::File::File(FileName file, bool readProperties,
-                AudioProperties::ReadStyle propertiesStyle) :
-  Mod::FileBase(file),
-  d(new FilePrivate(propertiesStyle))
-{
-  if(isOpen())
-    read(readProperties);
-}
-
-Mod::File::File(IOStream *stream, bool readProperties,
-                AudioProperties::ReadStyle propertiesStyle) :
-  Mod::FileBase(stream),
-  d(new FilePrivate(propertiesStyle))
-{
-  if(isOpen())
-    read(readProperties);
-}
-
-Mod::File::~File()
-{
-  delete d;
-}
-
-Mod::Tag *Mod::File::tag() const
-{
-  return &d->tag;
-}
-
-Mod::Properties *Mod::File::audioProperties() const
-{
-  return &d->properties;
-}
-
-PropertyMap Mod::File::properties() const
-{
-  return d->tag.properties();
-}
-
-PropertyMap Mod::File::setProperties(const PropertyMap &properties)
-{
-  return d->tag.setProperties(properties);
-}
-
-bool Mod::File::save()
-{
-  if(readOnly()) {
-    debug("Mod::File::save() - Cannot save to a read only file.");
-    return false;
-  }
-  seek(0);
-  writeString(d->tag.title(), 20);
-  StringList lines = d->tag.comment().split("\n");
-  unsigned int n = std::min(lines.size(), d->properties.instrumentCount());
-  for(unsigned int i = 0; i < n; ++ i) {
-    writeString(lines[i], 22);
-    seek(8, Current);
-  }
-
-  for(unsigned int i = n; i < d->properties.instrumentCount(); ++ i) {
-    writeString(String(), 22);
-    seek(8, Current);
-  }
-  return true;
-}
-
-void Mod::File::read(bool)
-{
-  if(!isOpen())
-    return;
-
-  seek(1080);
-  ByteVector modId = readBlock(4);
-  READ_ASSERT(modId.size() == 4);
-
-  int          channels    =  4;
-  unsigned int instruments = 31;
-  if(modId == "M.K." || modId == "M!K!" || modId == "M&K!" || modId == "N.T.") {
-    d->tag.setTrackerName("ProTracker");
-    channels = 4;
-  }
-  else if(modId.startsWith("FLT") || modId.startsWith("TDZ")) {
-    d->tag.setTrackerName("StarTrekker");
-    char digit = modId[3];
-    READ_ASSERT(digit >= '0' && digit <= '9');
-    channels = digit - '0';
-  }
-  else if(modId.endsWith("CHN")) {
-    d->tag.setTrackerName("StarTrekker");
-    char digit = modId[0];
-    READ_ASSERT(digit >= '0' && digit <= '9');
-    channels = digit - '0';
-  }
-  else if(modId == "CD81" || modId == "OKTA") {
-    d->tag.setTrackerName("Atari Oktalyzer");
-    channels = 8;
-  }
-  else if(modId.endsWith("CH") || modId.endsWith("CN")) {
-    d->tag.setTrackerName("TakeTracker");
-    char digit = modId[0];
-    READ_ASSERT(digit >= '0' && digit <= '9');
-    channels = (digit - '0') * 10;
-    digit = modId[1];
-    READ_ASSERT(digit >= '0' && digit <= '9');
-    channels += digit - '0';
-  }
-  else {
-    // Not sure if this is correct. I'd need a file
-    // created with NoiseTracker to check this.
-    d->tag.setTrackerName("NoiseTracker"); // probably
-    channels    =  4;
-    instruments = 15;
-  }
-  d->properties.setChannels(channels);
-  d->properties.setInstrumentCount(instruments);
-
-  seek(0);
-  READ_STRING(d->tag.setTitle, 20);
-
-  StringList comment;
-  for(unsigned int i = 0; i < instruments; ++ i) {
-    READ_STRING_AS(instrumentName, 22);
-    // value in words, * 2 (<< 1) for bytes:
-    READ_U16B_AS(sampleLength);
-
-    READ_BYTE_AS(fineTuneByte);
-    int fineTune = fineTuneByte & 0xF;
-    // > 7 means negative value
-    if(fineTune > 7) fineTune -= 16;
-
-    READ_BYTE_AS(volume);
-    if(volume > 64) volume = 64;
-    // volume in decibels: 20 * log10(volume / 64)
-
-    // value in words, * 2 (<< 1) for bytes:
-    READ_U16B_AS(repeatStart);
-    // value in words, * 2 (<< 1) for bytes:
-    READ_U16B_AS(repatLength);
-
-    comment.append(instrumentName);
-  }
-
-  READ_BYTE(d->properties.setLengthInPatterns);
-
-  d->tag.setComment(comment.toString("\n"));
-}

3rdparty/taglib/mod/modfile.h

@@ -1,116 +0,0 @@
-/***************************************************************************
-    copyright           : (C) 2011 by Mathias Panzenböck
-    email               : grosser.meister.morti@gmx.net
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_MODFILE_H
-#define TAGLIB_MODFILE_H
-
-#include "tfile.h"
-#include "audioproperties.h"
-#include "taglib_export.h"
-#include "modfilebase.h"
-#include "modtag.h"
-#include "modproperties.h"
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  namespace Mod {
-
-    class TAGLIB_EXPORT File : public Strawberry_TagLib::TagLib::Mod::FileBase
-    {
-    public:
-      /*!
-       * Constructs a Protracker file from \a file.
-       *
-       * \note In the current implementation, both \a readProperties and
-       * \a propertiesStyle are ignored.  The audio properties are always
-       * read.
-       */
-      File(FileName file, bool readProperties = true,
-           AudioProperties::ReadStyle propertiesStyle =
-           AudioProperties::Average);
-
-      /*!
-       * Constructs a Protracker file from \a stream.
-       *
-       * \note In the current implementation, both \a readProperties and
-       * \a propertiesStyle are ignored.  The audio properties are always
-       * read.
-       *
-       * \note TagLib will *not* take ownership of the stream, the caller is
-       * responsible for deleting it after the File object.
-       */
-      File(IOStream *stream, bool readProperties = true,
-           AudioProperties::ReadStyle propertiesStyle =
-           AudioProperties::Average);
-
-      /*!
-       * Destroys this instance of the File.
-       */
-      virtual ~File();
-
-      Mod::Tag *tag() const;
-
-      /*!
-       * Implements the unified property interface -- export function.
-       * Forwards to Mod::Tag::properties().
-       */
-      PropertyMap properties() const;
-
-      /*!
-       * Implements the unified property interface -- import function.
-       * Forwards to Mod::Tag::setProperties().
-       */
-      PropertyMap setProperties(const PropertyMap &);
-      /*!
-       * Returns the Mod::Properties for this file. If no audio properties
-       * were read then this will return a null pointer.
-       */
-      Mod::Properties *audioProperties() const;
-
-      /*!
-       * Save the file.
-       * This is the same as calling save(AllTags);
-       *
-       * \note Saving Protracker tags is not supported.
-       */
-      bool save();
-
-    private:
-      File(const File &);
-      File &operator=(const File &);
-
-      void read(bool readProperties);
-
-      class FilePrivate;
-      FilePrivate *d;
-    };
-
-  }
-
-}
-}
-
-#endif

3rdparty/taglib/mod/modfilebase.cpp

@@ -1,125 +0,0 @@
-/***************************************************************************
-    copyright           : (C) 2011 by Mathias Panzenböck
-    email               : grosser.meister.morti@gmx.net
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-
-#include "tdebug.h"
-#include "modfilebase.h"
-
-using namespace Strawberry_TagLib::TagLib;
-using namespace Mod;
-
-Mod::FileBase::FileBase(FileName file) : Strawberry_TagLib::TagLib::File(file)
-{
-}
-
-Mod::FileBase::FileBase(IOStream *stream) : Strawberry_TagLib::TagLib::File(stream)
-{
-}
-
-void Mod::FileBase::writeString(const String &s, unsigned long size, char padding)
-{
-  ByteVector data(s.data(String::Latin1));
-  data.resize(size, padding);
-  writeBlock(data);
-}
-
-bool Mod::FileBase::readString(String &s, unsigned long size)
-{
-  ByteVector data(readBlock(size));
-  if(data.size() < size) return false;
-  int index = data.find((char) 0);
-  if(index > -1)
-  {
-    data.resize(index);
-  }
-  data.replace('\xff', ' ');
-
-  s = data;
-  return true;
-}
-
-void Mod::FileBase::writeByte(unsigned char byte)
-{
-  ByteVector data(1, byte);
-  writeBlock(data);
-}
-
-void Mod::FileBase::writeU16L(unsigned short number)
-{
-  writeBlock(ByteVector::fromShort(number, false));
-}
-
-void Mod::FileBase::writeU32L(unsigned long number)
-{
-  writeBlock(ByteVector::fromUInt(number, false));
-}
-
-void Mod::FileBase::writeU16B(unsigned short number)
-{
-  writeBlock(ByteVector::fromShort(number, true));
-}
-
-void Mod::FileBase::writeU32B(unsigned long number)
-{
-  writeBlock(ByteVector::fromUInt(number, true));
-}
-
-bool Mod::FileBase::readByte(unsigned char &byte)
-{
-  ByteVector data(readBlock(1));
-  if(data.size() < 1) return false;
-  byte = data[0];
-  return true;
-}
-
-bool Mod::FileBase::readU16L(unsigned short &number)
-{
-  ByteVector data(readBlock(2));
-  if(data.size() < 2) return false;
-  number = data.toUShort(false);
-  return true;
-}
-
-bool Mod::FileBase::readU32L(unsigned long &number) {
-  ByteVector data(readBlock(4));
-  if(data.size() < 4) return false;
-  number = data.toUInt(false);
-  return true;
-}
-
-bool Mod::FileBase::readU16B(unsigned short &number)
-{
-  ByteVector data(readBlock(2));
-  if(data.size() < 2) return false;
-  number = data.toUShort(true);
-  return true;
-}
-
-bool Mod::FileBase::readU32B(unsigned long &number) {
-  ByteVector data(readBlock(4));
-  if(data.size() < 4) return false;
-  number = data.toUInt(true);
-  return true;
-}

3rdparty/taglib/mod/modfilebase.h

@@ -1,68 +0,0 @@
-/***************************************************************************
-    copyright           : (C) 2011 by Mathias Panzenböck
-    email               : grosser.meister.morti@gmx.net
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU Lesser General Public License version   *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
- *   02110-1301  USA                                                       *
- *                                                                         *
- *   Alternatively, this file is available under the Mozilla Public        *
- *   License Version 1.1.  You may obtain a copy of the License at         *
- *   http://www.mozilla.org/MPL/                                           *
- ***************************************************************************/
-
-#ifndef TAGLIB_MODFILEBASE_H
-#define TAGLIB_MODFILEBASE_H
-
-#include "taglib.h"
-#include "tfile.h"
-#include "tstring.h"
-#include "tlist.h"
-#include "taglib_export.h"
-
-#include <algorithm>
-
-namespace Strawberry_TagLib {
-namespace TagLib {
-
-  namespace Mod {
-
-    class TAGLIB_EXPORT FileBase : public Strawberry_TagLib::TagLib::File
-    {
-    protected:
-      FileBase(FileName file);
-      FileBase(IOStream *stream);
-
-      void writeString(const String &s, unsigned long size, char padding = 0);
-      void writeByte(unsigned char byte);
-      void writeU16L(unsigned short number);
-      void writeU32L(unsigned long number);
-      void writeU16B(unsigned short number);
-      void writeU32B(unsigned long number);
-
-      bool readString(String &s, unsigned long size);
-      bool readByte(unsigned char &byte);
-      bool readU16L(unsigned short &number);
-      bool readU32L(unsigned long &number);
-      bool readU16B(unsigned short &number);
-      bool readU32B(unsigned long &number);
-    };
-
-  }
-
-}
-}
-
-#endif

3rdparty/taglib/mod/modfileprivate.h

@@ -1,67 +0,0 @@
-/***************************************************************************
-    copyright           : (C) 2011 by Mathias Panzenböck
-    email               : grosser.meister.morti@gmx.net
- ***************************************************************************/
-
-/***************************************************************************
- *   This library is free software; you can redistribute it and/or modify  *
- *   it  under the terms of the GNU Lesser General Public License version  *
- *   2.1 as published by the Free Software Foundation.                     *
- *                                                                         *
- *   This library is distributed in the hope that it will be useful, but   *
- *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
- *   Lesser General Public License for more details.                       *
- *                                                                         *
- *   You should have received a copy of the GNU Lesser General Public      *
- *   License along with this library; if not, write to the Free Software   *
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,            *
- *   MA  02110-1301  USA                                                   *
- ***************************************************************************/
-
-#ifndef TAGLIB_MODFILEPRIVATE_H
-#define TAGLIB_MODFILEPRIVATE_H
-
-// some helper-macros only used internally by (s3m|it|xm)file.cpp
-#define READ_ASSERT(cond) \
-  if(!(cond)) \
-  { \
-    setValid(false); \
-    return; \
-  }
-
-#define READ(setter,type,read) \
-  { \
-    type number; \
-    READ_ASSERT(read(number)); \
-    setter(number); \
-  }
-
-#define READ_BYTE(setter) READ(setter,unsigned char,readByte)
-#define READ_U16L(setter) READ(setter,unsigned short,readU16L)
-#define READ_U32L(setter) READ(setter,unsigned long,readU32L)
-#define READ_U16B(setter) READ(setter,unsigned short,readU16B)
-#define READ_U32B(setter) READ(setter,unsigned long,readU32B)
-
-#define READ_STRING(setter,size) \
-  { \
-    String s; \
-    READ_ASSERT(readString(s, size)); \
-    setter(s); \
-  }
-
-#define READ_AS(type,name,read) \
-  type name = 0; \
-  READ_ASSERT(read(name));
-
-#define READ_BYTE_AS(name) READ_AS(unsigned char,name,readByte)
-#define READ_U16L_AS(name) READ_AS(unsigned short,name,readU16L)
-#define READ_U32L_AS(name) READ_AS(unsigned long,name,readU32L)
-#define READ_U16B_AS(name) READ_AS(unsigned short,name,readU16B)
-#define READ_U32B_AS(name) READ_AS(unsigned long,name,readU32B)
-
-#define READ_STRING_AS(name,size) \
-  String name; \
-  READ_ASSERT(readString(name, size));
-
-#endif