Attempt to create Metal Renderer

Also bump the version to match the Dolphin version.

CSafe.pch

@@ -0,0 +1,3 @@
+#ifdef __cplusplus
+#include "Source/PCH/pch.h"
+#endif

Compatibility/Audio/AudioCommon.cpp

@@ -9,9 +9,11 @@
 #include "Common/Common.h"
 #include "Common/FileUtil.h"
 #include "Common/Logging/Log.h"
+#include "Core/Config/MainSettings.h"
 #include "Core/ConfigManager.h"
 
 // This shouldn't be a global, at least not here.
+extern std::unique_ptr<SoundStream> g_sound_stream;
 std::unique_ptr<SoundStream> g_sound_stream;
 
 static bool s_audio_dump_start = false;
@@ -22,34 +24,42 @@ namespace AudioCommon
     static const int AUDIO_VOLUME_MIN = 0;
     static const int AUDIO_VOLUME_MAX = 100;
     
-    void InitSoundStream()
+    void InitSoundStream(Core::System& system)
     {
         g_sound_stream = std::make_unique<OpenEmuAudioStream>();
         
         if (!g_sound_stream->Init())
         {
-            WARN_LOG(AUDIO, "Could not initialize backend");
+            WARN_LOG_FMT(AUDIO, "Could not initialize backend");
             g_sound_stream = std::make_unique<NullSound>();
         }
         
-        UpdateSoundStream();
-        SetSoundStreamRunning(true);
-        
-        if (SConfig::GetInstance().m_DumpAudio && !s_audio_dump_start)
-            StartAudioDump();
+        UpdateSoundStream(system);
+        SetSoundStreamRunning(system, true);
     }
     
-    void ShutdownSoundStream()
+    void PostInitSoundStream(Core::System& system)
     {
-        INFO_LOG(AUDIO, "Shutting down sound stream");
+        // This needs to be called after AudioInterface::Init and SerialInterface::Init (for GBA devices)
+        // where input sample rates are set
+        UpdateSoundStream(system);
+        SetSoundStreamRunning(system, true);
         
-        if (SConfig::GetInstance().m_DumpAudio && s_audio_dump_start)
-            StopAudioDump();
+        if (Config::Get(Config::MAIN_DUMP_AUDIO) && !s_audio_dump_start)
+            StartAudioDump(system);
+    }
+
+    void ShutdownSoundStream(Core::System& system)
+    {
+        INFO_LOG_FMT(AUDIO, "Shutting down sound stream");
         
-        SetSoundStreamRunning(false);
+        if (Config::Get(Config::MAIN_DUMP_AUDIO) && s_audio_dump_start)
+            StopAudioDump(system);
+        
+        SetSoundStreamRunning(system, false);
         g_sound_stream.reset();
         
-        INFO_LOG(AUDIO, "Done shutting down sound stream");
+        INFO_LOG_FMT(AUDIO, "Done shutting down sound stream");
     }
     
     std::string GetDefaultSoundBackend()
@@ -88,16 +98,16 @@ DPL2Quality GetDefaultDPL2Quality()
         return false;
     }
     
-    void UpdateSoundStream()
+    void UpdateSoundStream(Core::System& system)
     {
         if (g_sound_stream)
         {
-            int volume = SConfig::GetInstance().m_IsMuted ? 0 : SConfig::GetInstance().m_Volume;
+            int volume = Config::Get(Config::MAIN_AUDIO_MUTED) ? 0 : Config::Get(Config::MAIN_AUDIO_VOLUME);
             g_sound_stream->SetVolume(volume);
         }
     }
     
-    void SetSoundStreamRunning(bool running)
+    void SetSoundStreamRunning(Core::System& system, bool running)
     {
         if (!g_sound_stream)
             return;
@@ -109,20 +119,20 @@ DPL2Quality GetDefaultDPL2Quality()
         if (g_sound_stream->SetRunning(running))
             return;
         if (running)
-            ERROR_LOG(AUDIO, "Error starting stream.");
+            ERROR_LOG_FMT(AUDIO, "Error starting stream.");
         else
-            ERROR_LOG(AUDIO, "Error stopping stream.");
+            ERROR_LOG_FMT(AUDIO, "Error stopping stream.");
     }
     
-    void SendAIBuffer(const short* samples, unsigned int num_samples)
+    void SendAIBuffer(Core::System& system, const short* samples, unsigned int num_samples)
     {
         if (!g_sound_stream)
             return;
         
-        if (SConfig::GetInstance().m_DumpAudio && !s_audio_dump_start)
-            StartAudioDump();
-        else if (!SConfig::GetInstance().m_DumpAudio && s_audio_dump_start)
-            StopAudioDump();
+        if (Config::Get(Config::MAIN_DUMP_AUDIO) && !s_audio_dump_start)
+            StartAudioDump(system);
+        else if (!Config::Get(Config::MAIN_DUMP_AUDIO) && s_audio_dump_start)
+            StopAudioDump(system);
         
         Mixer* pMixer = g_sound_stream->GetMixer();
         
@@ -130,11 +140,9 @@ DPL2Quality GetDefaultDPL2Quality()
         {
             pMixer->PushSamples(samples, num_samples);
         }
-        
-        g_sound_stream->Update();
     }
     
-    void StartAudioDump()
+    void StartAudioDump(Core::System& system)
     {
         std::string audio_file_name_dtk = File::GetUserPath(D_DUMPAUDIO_IDX) + "dtkdump.wav";
         std::string audio_file_name_dsp = File::GetUserPath(D_DUMPAUDIO_IDX) + "dspdump.wav";
@@ -145,7 +153,7 @@ DPL2Quality GetDefaultDPL2Quality()
         s_audio_dump_start = true;
     }
     
-    void StopAudioDump()
+    void StopAudioDump(Core::System& system)
     {
         if (!g_sound_stream)
             return;
@@ -154,30 +162,32 @@ DPL2Quality GetDefaultDPL2Quality()
         s_audio_dump_start = false;
     }
     
-    void IncreaseVolume(unsigned short offset)
+    void IncreaseVolume(Core::System& system, unsigned short offset)
     {
-        SConfig::GetInstance().m_IsMuted = false;
-        int& currentVolume = SConfig::GetInstance().m_Volume;
+        Config::SetBaseOrCurrent(Config::MAIN_AUDIO_MUTED, false);
+        int currentVolume = Config::Get(Config::MAIN_AUDIO_VOLUME);
         currentVolume += offset;
         if (currentVolume > AUDIO_VOLUME_MAX)
             currentVolume = AUDIO_VOLUME_MAX;
-        UpdateSoundStream();
+        Config::SetBaseOrCurrent(Config::MAIN_AUDIO_VOLUME, currentVolume);
+        UpdateSoundStream(system);
     }
     
-    void DecreaseVolume(unsigned short offset)
+    void DecreaseVolume(Core::System& system, unsigned short offset)
     {
-        SConfig::GetInstance().m_IsMuted = false;
-        int& currentVolume = SConfig::GetInstance().m_Volume;
+        Config::SetBaseOrCurrent(Config::MAIN_AUDIO_MUTED, false);
+        int currentVolume = Config::Get(Config::MAIN_AUDIO_VOLUME);
         currentVolume -= offset;
         if (currentVolume < AUDIO_VOLUME_MIN)
             currentVolume = AUDIO_VOLUME_MIN;
-        UpdateSoundStream();
+        Config::SetBaseOrCurrent(Config::MAIN_AUDIO_VOLUME, currentVolume);
+        UpdateSoundStream(system);
     }
     
-    void ToggleMuteVolume()
+    void ToggleMuteVolume(Core::System& system)
     {
-        bool& isMuted = SConfig::GetInstance().m_IsMuted;
-        isMuted = !isMuted;
-        UpdateSoundStream();
+          bool isMuted = Config::Get(Config::MAIN_AUDIO_MUTED);
+          Config::SetBaseOrCurrent(Config::MAIN_AUDIO_MUTED, !isMuted);
+          UpdateSoundStream(system);
     }
 }  // namespace AudioCommon

Compatibility/Common/CPUDetect.cpp

@@ -0,0 +1,29 @@
+// Copyright (c) 2022, OpenEmu Team
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of the OpenEmu Team nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY OpenEmu Team ''AS IS'' AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL OpenEmu Team BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifdef __x86_64__
+#include "../../dolphin/Source/Core/Common/x64CPUDetect.cpp"
+#elif defined(__arm64__)
+#include "../../dolphin/Source/Core/Common/ArmCPUDetect.cpp"
+#endif

Compatibility/Common/FPURoundMode.cpp

@@ -0,0 +1,27 @@
+// Copyright (c) 2022, OpenEmu Team
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of the OpenEmu Team nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY OpenEmu Team ''AS IS'' AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL OpenEmu Team BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifdef __x86_64__
+#include "../../dolphin/Source/Core/Common/x64FPURoundMode.cpp"
+#endif

Compatibility/Common/FileUtil.cpp

@@ -0,0 +1,959 @@
+// Copyright 2008 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "Common/FileUtil.h"
+
+#include <algorithm>
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <fcntl.h>
+#include <filesystem>
+#include <fstream>
+#include <limits.h>
+#include <stack>
+#include <string>
+#include <sys/stat.h>
+#include <system_error>
+#include <thread>
+#include <vector>
+
+#include "Common/Assert.h"
+#include "Common/Common.h"
+#include "Common/CommonFuncs.h"
+#include "Common/CommonPaths.h"
+#include "Common/CommonTypes.h"
+#ifdef __APPLE__
+#include "Common/DynamicLibrary.h"
+#endif
+#include "Common/IOFile.h"
+#include "Common/Logging/Log.h"
+#include "Common/StringUtil.h"
+
+#ifdef _WIN32
+#include <Windows.h>
+#include <Shlwapi.h>
+#include <commdlg.h>  // for GetSaveFileName
+#include <direct.h>   // getcwd
+#include <io.h>
+#include <objbase.h>  // guid stuff
+#include <shellapi.h>
+#else
+#include <dirent.h>
+#include <errno.h>
+#include <libgen.h>
+#include <stdlib.h>
+#include <unistd.h>
+#endif
+
+#ifdef OpenEmu
+#include "DolphinGameCore.h"
+#endif
+
+#if defined(__APPLE__)
+#include <CoreFoundation/CFBundle.h>
+#include <CoreFoundation/CFString.h>
+#include <CoreFoundation/CFURL.h>
+#include <mach-o/dyld.h>
+#include <sys/param.h>
+#endif
+
+#ifdef ANDROID
+#include "jni/AndroidCommon/AndroidCommon.h"
+#endif
+
+namespace fs = std::filesystem;
+
+namespace File
+{
+#ifdef ANDROID
+static std::string s_android_sys_directory;
+#endif
+
+#ifdef __APPLE__
+static Common::DynamicLibrary s_security_framework;
+
+using DolSecTranslocateIsTranslocatedURL = Boolean (*)(CFURLRef path, bool* isTranslocated,
+                                                       CFErrorRef* __nullable error);
+using DolSecTranslocateCreateOriginalPathForURL = CFURLRef
+__nullable (*)(CFURLRef translocatedPath, CFErrorRef* __nullable error);
+
+static DolSecTranslocateIsTranslocatedURL s_is_translocated_url;
+static DolSecTranslocateCreateOriginalPathForURL s_create_orig_path;
+#endif
+
+FileInfo::FileInfo(const std::string& path) : FileInfo(path.c_str())
+{
+}
+
+FileInfo::FileInfo(const char* path)
+{
+#ifdef ANDROID
+  if (IsPathAndroidContent(path))
+  {
+    const jlong result = GetAndroidContentSizeAndIsDirectory(path);
+    m_status.type((result == -2) ? fs::file_type::directory : fs::file_type::regular);
+    m_size = (result >= 0) ? result : 0;
+    m_exists = result != -1;
+  }
+  else
+#endif
+  {
+    const auto fs_path = StringToPath(path);
+    std::error_code error;
+    m_status = fs::status(fs_path, error);
+    m_size = fs::file_size(fs_path, error);
+    if (error)
+      m_size = 0;
+    m_exists = fs::exists(m_status);
+  }
+}
+
+bool FileInfo::Exists() const
+{
+  return m_exists;
+}
+
+bool FileInfo::IsDirectory() const
+{
+  return fs::is_directory(m_status);
+}
+
+bool FileInfo::IsFile() const
+{
+  return Exists() ? !fs::is_directory(m_status) : false;
+}
+
+u64 FileInfo::GetSize() const
+{
+  if (!IsFile())
+    return 0;
+  return m_size;
+}
+
+// Returns true if the path exists
+bool Exists(const std::string& path)
+{
+  return FileInfo(path).Exists();
+}
+
+// Returns true if the path exists and is a directory
+bool IsDirectory(const std::string& path)
+{
+  return FileInfo(path).IsDirectory();
+}
+
+// Returns true if the path exists and is a file
+bool IsFile(const std::string& path)
+{
+  return FileInfo(path).IsFile();
+}
+
+// Deletes a given filename, return true on success
+// Doesn't supports deleting a directory
+bool Delete(const std::string& filename, IfAbsentBehavior behavior)
+{
+  DEBUG_LOG_FMT(COMMON, "{}: file {}", __func__, filename);
+
+#ifdef ANDROID
+  if (filename.starts_with("content://"))
+  {
+    const bool success = DeleteAndroidContent(filename);
+    if (!success)
+      WARN_LOG_FMT(COMMON, "{} failed on {}", __func__, filename);
+    return success;
+  }
+#endif
+
+  auto native_path = StringToPath(filename);
+  std::error_code error;
+  auto status = fs::status(native_path, error);
+
+  // Return true because we care about the file not being there, not the actual delete.
+  if (!fs::exists(status))
+  {
+    if (behavior == IfAbsentBehavior::ConsoleWarning)
+    {
+      WARN_LOG_FMT(COMMON, "{}: {} does not exist", __func__, filename);
+    }
+    return true;
+  }
+
+  // fs::remove can only delete an empty directory. Legacy dolphin behavior is just to bail.
+  if (fs::is_directory(status))
+  {
+    WARN_LOG_FMT(COMMON, "{} failed: {} is a directory", __func__, filename);
+    return false;
+  }
+
+  if (!fs::remove(native_path, error))
+  {
+    WARN_LOG_FMT(COMMON, "{}: failed on {}: {}", __func__, filename, error.message());
+    return false;
+  }
+
+  return true;
+}
+
+bool CreateDir(const std::string& path)
+{
+  DEBUG_LOG_FMT(COMMON, "{}: directory {}", __func__, path);
+
+  std::error_code error;
+  auto native_path = StringToPath(path);
+  bool success = fs::create_directory(native_path, error);
+  // If the path was not created, check if it was a pre-existing directory
+  std::error_code error_ignored;
+  if (!success && fs::is_directory(native_path, error_ignored))
+    success = true;
+  if (!success)
+    ERROR_LOG_FMT(COMMON, "{}: failed on {}: {}", __func__, path, error.message());
+  return success;
+}
+
+bool CreateDirs(std::string_view path)
+{
+  DEBUG_LOG_FMT(COMMON, "{}: directory {}", __func__, path);
+
+  std::error_code error;
+  auto native_path = StringToPath(path);
+  bool success = fs::create_directories(native_path, error);
+  // If the path was not created, check if it was a pre-existing directory
+  std::error_code error_ignored;
+  if (!success && fs::is_directory(native_path, error_ignored))
+    success = true;
+  if (!success)
+    ERROR_LOG_FMT(COMMON, "{}: failed on {}: {}", __func__, path, error.message());
+  return success;
+}
+
+bool CreateFullPath(std::string_view fullPath)
+{
+  DEBUG_LOG_FMT(COMMON, "{}: path {}", __func__, fullPath);
+
+  std::error_code error;
+  auto native_path = StringToPath(fullPath).parent_path();
+  bool success = fs::create_directories(native_path, error);
+  // If the path was not created, check if it was a pre-existing directory
+  std::error_code error_ignored;
+  if (!success && fs::is_directory(native_path, error_ignored))
+    success = true;
+  if (!success)
+    ERROR_LOG_FMT(COMMON, "{}: failed on {}: {}", __func__, fullPath, error.message());
+  return success;
+}
+
+// Deletes a directory filename, returns true on success
+bool DeleteDir(const std::string& filename, IfAbsentBehavior behavior)
+{
+  DEBUG_LOG_FMT(COMMON, "{}: directory {}", __func__, filename);
+
+  auto native_path = StringToPath(filename);
+  std::error_code error;
+  auto status = fs::status(native_path, error);
+
+  // Return true because we care about the directory not being there, not the actual delete.
+  if (!fs::exists(status))
+  {
+    if (behavior == IfAbsentBehavior::ConsoleWarning)
+    {
+      WARN_LOG_FMT(COMMON, "{}: {} does not exist", __func__, filename);
+    }
+    return true;
+  }
+
+  // check if a directory
+  if (!fs::is_directory(status))
+  {
+    ERROR_LOG_FMT(COMMON, "{}: Not a directory {}", __func__, filename);
+    return false;
+  }
+
+  if (!fs::remove(native_path, error))
+  {
+    WARN_LOG_FMT(COMMON, "{}: failed on {}: {}", __func__, filename, error.message());
+    return false;
+  }
+
+  return true;
+}
+
+// renames file srcFilename to destFilename, returns true on success
+bool Rename(const std::string& srcFilename, const std::string& destFilename)
+{
+  DEBUG_LOG_FMT(COMMON, "{}: {} --> {}", __func__, srcFilename, destFilename);
+  std::error_code error;
+  std::filesystem::rename(StringToPath(srcFilename), StringToPath(destFilename), error);
+  if (error)
+  {
+    ERROR_LOG_FMT(COMMON, "{} failed: {} --> {}: {}", __func__, srcFilename, destFilename,
+                  error.message());
+  }
+  return !error;
+}
+
+#ifndef _WIN32
+static void FSyncPath(const char* path)
+{
+  int fd = open(path, O_RDONLY);
+  if (fd != -1)
+  {
+    fsync(fd);
+    close(fd);
+  }
+}
+#endif
+
+bool RenameSync(const std::string& srcFilename, const std::string& destFilename)
+{
+  if (!Rename(srcFilename, destFilename))
+    return false;
+#ifdef _WIN32
+  int fd = -1;
+  // XXX is this really needed?
+  errno_t err = _wsopen_s(&fd, UTF8ToWString(srcFilename).c_str(), _O_RDONLY, _SH_DENYNO,
+                          _S_IREAD | _S_IWRITE);
+  if (!err && fd >= 0)
+  {
+    if (_commit(fd) != 0)
+      ERROR_LOG_FMT(COMMON, "{} sync failed on {}: {}", __func__, srcFilename, err);
+    close(fd);
+  }
+#else
+  char* path = strdup(srcFilename.c_str());
+  FSyncPath(path);
+  FSyncPath(dirname(path));
+  free(path);
+  path = strdup(destFilename.c_str());
+  FSyncPath(dirname(path));
+  free(path);
+#endif
+  return true;
+}
+
+bool CopyRegularFile(std::string_view source_path, std::string_view destination_path)
+{
+  DEBUG_LOG_FMT(COMMON, "{}: {} --> {}", __func__, source_path, destination_path);
+
+  auto src_path = StringToPath(source_path);
+  auto dst_path = StringToPath(destination_path);
+  std::error_code error;
+  bool copied = fs::copy_file(src_path, dst_path, fs::copy_options::overwrite_existing, error);
+  if (!copied)
+  {
+    ERROR_LOG_FMT(COMMON, "{}: failed {} --> {}: {}", __func__, source_path, destination_path,
+                  error.message());
+  }
+  return copied;
+}
+
+// Returns the size of a file (or returns 0 if the path isn't a file that exists)
+u64 GetSize(const std::string& path)
+{
+  return FileInfo(path).GetSize();
+}
+
+// Overloaded GetSize, accepts FILE*
+u64 GetSize(FILE* f)
+{
+  // can't use off_t here because it can be 32-bit
+  const u64 pos = ftello(f);
+  if (fseeko(f, 0, SEEK_END) != 0)
+  {
+    ERROR_LOG_FMT(COMMON, "GetSize: seek failed {}: {}", fmt::ptr(f), LastStrerrorString());
+    return 0;
+  }
+
+  const u64 size = ftello(f);
+  if ((size != pos) && (fseeko(f, pos, SEEK_SET) != 0))
+  {
+    ERROR_LOG_FMT(COMMON, "GetSize: seek failed {}: {}", fmt::ptr(f), LastStrerrorString());
+    return 0;
+  }
+
+  return size;
+}
+
+// creates an empty file filename, returns true on success
+bool CreateEmptyFile(const std::string& filename)
+{
+  DEBUG_LOG_FMT(COMMON, "CreateEmptyFile: {}", filename);
+
+  if (!File::IOFile(filename, "wb"))
+  {
+    ERROR_LOG_FMT(COMMON, "CreateEmptyFile: failed {}: {}", filename, LastStrerrorString());
+    return false;
+  }
+
+  return true;
+}
+
+#ifdef ANDROID
+static FSTEntry ScanDirectoryTreeAndroidContent(std::string directory, bool recursive)
+{
+  FSTEntry parent_entry;
+  parent_entry.physicalName = directory;
+  parent_entry.isDirectory = true;
+  parent_entry.size = 0;
+
+  for (const auto& child_name : GetAndroidContentChildNames(directory))
+  {
+    const auto physical_name = directory + DIR_SEP + child_name;
+    const FileInfo file_info(physical_name);
+    FSTEntry entry;
+
+    entry.isDirectory = file_info.IsDirectory();
+    if (entry.isDirectory)
+    {
+      if (recursive)
+        entry = ScanDirectoryTreeAndroidContent(physical_name, true);
+      else
+        entry.size = 0;
+      parent_entry.size += entry.size;
+    }
+    else
+    {
+      entry.size = file_info.GetSize();
+    }
+    entry.virtualName = child_name;
+    entry.physicalName = physical_name;
+
+    ++parent_entry.size;
+    parent_entry.children.push_back(entry);
+  }
+
+  return parent_entry;
+}
+#endif
+
+// Recursive or non-recursive list of files and directories under directory.
+FSTEntry ScanDirectoryTree(std::string directory, bool recursive)
+{
+  DEBUG_LOG_FMT(COMMON, "{}: directory {}", __func__, directory);
+
+#ifdef ANDROID
+  if (IsPathAndroidContent(directory))
+    return ScanDirectoryTreeAndroidContent(directory, recursive);
+#endif
+
+  auto path_to_physical_name = [](const fs::path& path) {
+#ifdef _WIN32
+    // TODO Ideally this would not be needed - dolphin really should not have code directly mucking
+    // about with directory separators (for host paths - emulated paths may require it) and instead
+    // use fs::path to interact with them.
+    auto wpath = path.wstring();
+    std::replace(wpath.begin(), wpath.end(), L'\\', L'/');
+    return WStringToUTF8(wpath);
+#else
+    return PathToString(path);
+#endif
+  };
+
+  auto dirent_to_fstent = [&](const fs::directory_entry& entry) {
+    return FSTEntry{
+        .isDirectory = entry.is_directory(),
+        .size = entry.is_directory() ? 0 : entry.file_size(),
+        .physicalName = path_to_physical_name(entry.path()),
+        .virtualName = PathToString(entry.path().filename()),
+    };
+  };
+
+  auto calc_dir_size = [](FSTEntry* dir) {
+    dir->size += dir->children.size();
+    for (auto& child : dir->children)
+      if (child.isDirectory)
+        dir->size += child.size;
+  };
+
+  const auto directory_path = StringToPath(directory);
+
+  FSTEntry parent_entry;
+  parent_entry.physicalName = path_to_physical_name(directory_path);
+  parent_entry.isDirectory = fs::is_directory(directory_path);
+  parent_entry.size = 0;
+
+  std::error_code error;
+  if (recursive)
+  {
+    int prev_depth = 0;
+    std::stack<FSTEntry*> dir_fsts;
+    dir_fsts.push(&parent_entry);
+    for (auto it = fs::recursive_directory_iterator(directory_path, error);
+         it != fs::recursive_directory_iterator(); it.increment(error))
+    {
+      const int cur_depth = it.depth();
+      if (cur_depth > prev_depth)
+      {
+        dir_fsts.push(&dir_fsts.top()->children.back());
+      }
+      else if (cur_depth < prev_depth)
+      {
+        while (dir_fsts.size() - 1 != cur_depth)
+        {
+          calc_dir_size(dir_fsts.top());
+          dir_fsts.pop();
+        }
+      }
+      dir_fsts.top()->children.emplace_back(dirent_to_fstent(*it));
+      prev_depth = cur_depth;
+    }
+    while (dir_fsts.size())
+    {
+      calc_dir_size(dir_fsts.top());
+      dir_fsts.pop();
+    }
+  }
+  else
+  {
+    for (auto it = fs::directory_iterator(directory_path, error); it != fs::directory_iterator();
+         it.increment(error))
+    {
+      parent_entry.children.emplace_back(dirent_to_fstent(*it));
+    }
+    calc_dir_size(&parent_entry);
+  }
+
+  if (error)
+  {
+    // NOTE Possibly partial file list still returned
+    ERROR_LOG_FMT(COMMON, "{} error on {}: {}", __func__, directory, error.message());
+  }
+
+  return parent_entry;
+}
+
+// Deletes the given directory and anything under it. Returns true on success.
+bool DeleteDirRecursively(const std::string& directory)
+{
+  DEBUG_LOG_FMT(COMMON, "{}: {}", __func__, directory);
+
+  std::error_code error;
+  const std::uintmax_t num_removed = std::filesystem::remove_all(StringToPath(directory), error);
+  const bool success = num_removed != 0 && !error;
+  if (!success)
+    ERROR_LOG_FMT(COMMON, "{}: {} failed {}", __func__, directory, error.message());
+  return success;
+}
+
+bool Copy(std::string_view source_path, std::string_view dest_path, bool overwrite_existing)
+{
+  DEBUG_LOG_FMT(COMMON, "{}: {} --> {} ({})", __func__, source_path, dest_path,
+                overwrite_existing ? "overwrite" : "preserve");
+
+  auto src_path = StringToPath(source_path);
+  auto dst_path = StringToPath(dest_path);
+  std::error_code error;
+  auto options = fs::copy_options::recursive;
+  if (overwrite_existing)
+    options |= fs::copy_options::overwrite_existing;
+  fs::copy(src_path, dst_path, options, error);
+  if (error)
+  {
+    std::error_code error_ignored;
+    if (fs::equivalent(src_path, dst_path, error_ignored))
+      return true;
+
+    ERROR_LOG_FMT(COMMON, "{}: failed {} --> {} ({}): {}", __func__, source_path, dest_path,
+                  overwrite_existing ? "overwrite" : "preserve", error.message());
+    return false;
+  }
+  return true;
+}
+
+static bool MoveWithOverwrite(const std::filesystem::path& src, const std::filesystem::path& dst,
+                              std::error_code& error)
+{
+  fs::rename(src, dst, error);
+  if (!error)
+    return true;
+
+  // rename failed, try fallbacks
+
+  if (!fs::is_directory(src))
+  {
+    // src is not a directory (ie, probably a file), try to copy file + delete
+    if (!fs::copy_file(src, dst, fs::copy_options::overwrite_existing, error))
+      return false;
+    if (!fs::remove(src, error))
+      return false;
+    return true;
+  }
+
+  // src is a directory, recurse into it and try to move all sub-elements one by one
+  // this usually happens because the target is a non-empty directory
+  for (fs::directory_iterator it(src, error); it != fs::directory_iterator(); it.increment(error))
+  {
+    if (error)
+      return false;
+    if (!MoveWithOverwrite(it->path(), dst / it->path().filename(), error))
+      return false;
+  }
+  if (error)
+    return false;
+
+  // all sub-elements moved, remove top directory
+  if (!fs::remove(src, error))
+    return false;
+
+  return true;
+}
+
+bool MoveWithOverwrite(std::string_view source_path, std::string_view dest_path)
+{
+  DEBUG_LOG_FMT(COMMON, "{}: {} --> {}", __func__, source_path, dest_path);
+  auto src_path = StringToPath(source_path);
+  auto dst_path = StringToPath(dest_path);
+  std::error_code error;
+  if (!MoveWithOverwrite(src_path, dst_path, error))
+  {
+    ERROR_LOG_FMT(COMMON, "{}: failed {} --> {}: {}", __func__, source_path, dest_path,
+                  error.message());
+  }
+  return true;
+}
+
+// Returns the current directory
+std::string GetCurrentDir()
+{
+  std::error_code error;
+  auto directory = PathToString(fs::current_path(error));
+  if (error)
+  {
+    ERROR_LOG_FMT(COMMON, "{} failed: {}", __func__, error.message());
+    return {};
+  }
+  return directory;
+}
+
+// Sets the current directory to the given directory
+bool SetCurrentDir(const std::string& directory)
+{
+  std::error_code error;
+  fs::current_path(StringToPath(directory), error);
+  if (error)
+  {
+    ERROR_LOG_FMT(COMMON, "{} failed: {}", __func__, error.message());
+    return false;
+  }
+  return true;
+}
+
+std::string CreateTempDir()
+{
+#ifdef _WIN32
+  TCHAR temp[MAX_PATH];
+  if (!GetTempPath(MAX_PATH, temp))
+    return "";
+
+  GUID guid;
+  if (FAILED(CoCreateGuid(&guid)))
+  {
+    return "";
+  }
+  OLECHAR tguid[40]{};
+  if (!StringFromGUID2(guid, tguid, _countof(tguid)))
+  {
+    return "";
+  }
+  std::string dir = TStrToUTF8(temp) + "/" + TStrToUTF8(tguid);
+  if (!CreateDir(dir))
+    return "";
+  dir = ReplaceAll(dir, "\\", DIR_SEP);
+  return dir;
+#else
+  const char* base = getenv("TMPDIR") ?: "/tmp";
+  std::string path = std::string(base) + "/DolphinWii.XXXXXX";
+  if (!mkdtemp(&path[0]))
+    return "";
+  return path;
+#endif
+}
+
+std::string GetTempFilenameForAtomicWrite(std::string path)
+{
+  std::error_code error;
+  auto absolute_path = fs::absolute(StringToPath(path), error);
+  if (!error)
+    path = PathToString(absolute_path);
+  return std::move(path) + ".xxx";
+}
+
+#if defined(__APPLE__)
+std::string GetBundleDirectory()
+{
+      //OpenEmu
+      GET_CURRENT_OR_RETURN("");
+    
+      return [current getBundlePath];
+}
+#endif
+
+std::string GetExePath()
+{
+#ifdef _WIN32
+  auto exe_path = GetModuleName(nullptr);
+  if (!exe_path)
+    return {};
+  std::error_code error;
+  auto exe_path_absolute = fs::absolute(exe_path.value(), error);
+  if (error)
+    return {};
+  return PathToString(exe_path_absolute);
+#elif defined(__APPLE__)
+  return GetBundleDirectory();
+#else
+  char dolphin_exe_path[PATH_MAX];
+  ssize_t len = ::readlink("/proc/self/exe", dolphin_exe_path, sizeof(dolphin_exe_path));
+  if (len == -1 || len == sizeof(dolphin_exe_path))
+  {
+    len = 0;
+  }
+  dolphin_exe_path[len] = '\0';
+  return dolphin_exe_path;
+#endif
+}
+
+std::string GetExeDirectory()
+{
+  return PathToString(StringToPath(GetExePath()).parent_path());
+}
+
+static std::string CreateSysDirectoryPath()
+{
+#if defined(_WIN32) || defined(LINUX_LOCAL_DEV)
+#define SYSDATA_DIR "Sys"
+#elif defined __APPLE__
+    //openemu
+ #define SYSDATA_DIR "Sys"
+#else
+#ifdef DATA_DIR
+#define SYSDATA_DIR DATA_DIR "sys"
+#else
+#define SYSDATA_DIR "sys"
+#endif
+#endif
+
+#if defined(__APPLE__)
+  const std::string sys_directory = GetBundleDirectory() + DIR_SEP SYSDATA_DIR DIR_SEP;
+#elif defined(_WIN32) || defined(LINUX_LOCAL_DEV)
+  const std::string sys_directory = GetExeDirectory() + DIR_SEP SYSDATA_DIR DIR_SEP;
+#elif defined ANDROID
+  const std::string sys_directory = s_android_sys_directory + DIR_SEP;
+  ASSERT_MSG(COMMON, !s_android_sys_directory.empty(), "Sys directory has not been set");
+#else
+  const std::string sys_directory = SYSDATA_DIR DIR_SEP;
+#endif
+
+  INFO_LOG_FMT(COMMON, "CreateSysDirectoryPath: Setting to {}", sys_directory);
+  return sys_directory;
+}
+
+const std::string& GetSysDirectory()
+{
+  static const std::string sys_directory = CreateSysDirectoryPath();
+  return sys_directory;
+}
+
+#ifdef ANDROID
+void SetSysDirectory(const std::string& path)
+{
+  INFO_LOG_FMT(COMMON, "Setting Sys directory to {}", path);
+  ASSERT_MSG(COMMON, s_android_sys_directory.empty(), "Sys directory already set to {}",
+             s_android_sys_directory);
+  s_android_sys_directory = path;
+}
+#endif
+
+static std::string s_user_paths[NUM_PATH_INDICES];
+static void RebuildUserDirectories(unsigned int dir_index)
+{
+  switch (dir_index)
+  {
+  case D_USER_IDX:
+    s_user_paths[D_GCUSER_IDX] = s_user_paths[D_USER_IDX] + GC_USER_DIR DIR_SEP;
+    s_user_paths[D_WIIROOT_IDX] = s_user_paths[D_USER_IDX] + WII_USER_DIR DIR_SEP;
+    s_user_paths[D_CONFIG_IDX] = s_user_paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
+    s_user_paths[D_GAMESETTINGS_IDX] = s_user_paths[D_USER_IDX] + GAMESETTINGS_DIR DIR_SEP;
+    s_user_paths[D_MAPS_IDX] = s_user_paths[D_USER_IDX] + MAPS_DIR DIR_SEP;
+    s_user_paths[D_CACHE_IDX] = s_user_paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
+    s_user_paths[D_COVERCACHE_IDX] = s_user_paths[D_CACHE_IDX] + COVERCACHE_DIR DIR_SEP;
+    s_user_paths[D_REDUMPCACHE_IDX] = s_user_paths[D_CACHE_IDX] + REDUMPCACHE_DIR DIR_SEP;
+    s_user_paths[D_SHADERCACHE_IDX] = s_user_paths[D_CACHE_IDX] + SHADERCACHE_DIR DIR_SEP;
+    s_user_paths[D_SHADERS_IDX] = s_user_paths[D_USER_IDX] + SHADERS_DIR DIR_SEP;
+    s_user_paths[D_STATESAVES_IDX] = s_user_paths[D_USER_IDX] + STATESAVES_DIR DIR_SEP;
+    s_user_paths[D_SCREENSHOTS_IDX] = s_user_paths[D_USER_IDX] + SCREENSHOTS_DIR DIR_SEP;
+    s_user_paths[D_LOAD_IDX] = s_user_paths[D_USER_IDX] + LOAD_DIR DIR_SEP;
+    s_user_paths[D_HIRESTEXTURES_IDX] = s_user_paths[D_LOAD_IDX] + HIRES_TEXTURES_DIR DIR_SEP;
+    s_user_paths[D_RIIVOLUTION_IDX] = s_user_paths[D_LOAD_IDX] + RIIVOLUTION_DIR DIR_SEP;
+    s_user_paths[D_DUMP_IDX] = s_user_paths[D_USER_IDX] + DUMP_DIR DIR_SEP;
+    s_user_paths[D_DUMPFRAMES_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_FRAMES_DIR DIR_SEP;
+    s_user_paths[D_DUMPOBJECTS_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_OBJECTS_DIR DIR_SEP;
+    s_user_paths[D_DUMPAUDIO_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_AUDIO_DIR DIR_SEP;
+    s_user_paths[D_DUMPTEXTURES_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_TEXTURES_DIR DIR_SEP;
+    s_user_paths[D_DUMPDSP_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_DSP_DIR DIR_SEP;
+    s_user_paths[D_DUMPSSL_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_SSL_DIR DIR_SEP;
+    s_user_paths[D_LOGS_IDX] = s_user_paths[D_USER_IDX] + LOGS_DIR DIR_SEP;
+    s_user_paths[D_MAILLOGS_IDX] = s_user_paths[D_LOGS_IDX] + MAIL_LOGS_DIR DIR_SEP;
+    s_user_paths[D_THEMES_IDX] = s_user_paths[D_USER_IDX] + THEMES_DIR DIR_SEP;
+    s_user_paths[D_STYLES_IDX] = s_user_paths[D_USER_IDX] + STYLES_DIR DIR_SEP;
+    s_user_paths[D_PIPES_IDX] = s_user_paths[D_USER_IDX] + PIPES_DIR DIR_SEP;
+    s_user_paths[D_WFSROOT_IDX] = s_user_paths[D_USER_IDX] + WFSROOT_DIR DIR_SEP;
+    s_user_paths[D_BACKUP_IDX] = s_user_paths[D_USER_IDX] + BACKUP_DIR DIR_SEP;
+    s_user_paths[D_RESOURCEPACK_IDX] = s_user_paths[D_USER_IDX] + RESOURCEPACK_DIR DIR_SEP;
+    s_user_paths[D_DYNAMICINPUT_IDX] = s_user_paths[D_LOAD_IDX] + DYNAMICINPUT_DIR DIR_SEP;
+    s_user_paths[D_GRAPHICSMOD_IDX] = s_user_paths[D_LOAD_IDX] + GRAPHICSMOD_DIR DIR_SEP;
+    s_user_paths[D_WIISDCARDSYNCFOLDER_IDX] = s_user_paths[D_LOAD_IDX] + WIISDSYNC_DIR DIR_SEP;
+    s_user_paths[F_DOLPHINCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + DOLPHIN_CONFIG;
+    s_user_paths[F_GCPADCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + GCPAD_CONFIG;
+    s_user_paths[F_WIIPADCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + WIIPAD_CONFIG;
+    s_user_paths[F_GCKEYBOARDCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + GCKEYBOARD_CONFIG;
+    s_user_paths[F_GFXCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + GFX_CONFIG;
+    s_user_paths[F_DEBUGGERCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + DEBUGGER_CONFIG;
+    s_user_paths[F_LOGGERCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + LOGGER_CONFIG;
+    s_user_paths[F_DUALSHOCKUDPCLIENTCONFIG_IDX] =
+        s_user_paths[D_CONFIG_IDX] + DUALSHOCKUDPCLIENT_CONFIG;
+    s_user_paths[F_FREELOOKCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + FREELOOK_CONFIG;
+    s_user_paths[F_MAINLOG_IDX] = s_user_paths[D_LOGS_IDX] + MAIN_LOG;
+    s_user_paths[F_MEM1DUMP_IDX] = s_user_paths[D_DUMP_IDX] + MEM1_DUMP;
+    s_user_paths[F_MEM2DUMP_IDX] = s_user_paths[D_DUMP_IDX] + MEM2_DUMP;
+    s_user_paths[F_ARAMDUMP_IDX] = s_user_paths[D_DUMP_IDX] + ARAM_DUMP;
+    s_user_paths[F_FAKEVMEMDUMP_IDX] = s_user_paths[D_DUMP_IDX] + FAKEVMEM_DUMP;
+    s_user_paths[F_GCSRAM_IDX] = s_user_paths[D_GCUSER_IDX] + GC_SRAM;
+    s_user_paths[F_WIISDCARDIMAGE_IDX] = s_user_paths[D_LOAD_IDX] + WII_SD_CARD_IMAGE;
+
+    s_user_paths[D_MEMORYWATCHER_IDX] = s_user_paths[D_USER_IDX] + MEMORYWATCHER_DIR DIR_SEP;
+    s_user_paths[F_MEMORYWATCHERLOCATIONS_IDX] =
+        s_user_paths[D_MEMORYWATCHER_IDX] + MEMORYWATCHER_LOCATIONS;
+    s_user_paths[F_MEMORYWATCHERSOCKET_IDX] =
+        s_user_paths[D_MEMORYWATCHER_IDX] + MEMORYWATCHER_SOCKET;
+
+    s_user_paths[D_GBAUSER_IDX] = s_user_paths[D_USER_IDX] + GBA_USER_DIR DIR_SEP;
+    s_user_paths[D_GBASAVES_IDX] = s_user_paths[D_GBAUSER_IDX] + GBASAVES_DIR DIR_SEP;
+    s_user_paths[F_GBABIOS_IDX] = s_user_paths[D_GBAUSER_IDX] + GBA_BIOS;
+
+    // The shader cache has moved to the cache directory, so remove the old one.
+    // TODO: remove that someday.
+    File::DeleteDirRecursively(s_user_paths[D_USER_IDX] + SHADERCACHE_LEGACY_DIR DIR_SEP);
+    break;
+
+  case D_CONFIG_IDX:
+    s_user_paths[F_DOLPHINCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + DOLPHIN_CONFIG;
+    s_user_paths[F_GCPADCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + GCPAD_CONFIG;
+    s_user_paths[F_GCKEYBOARDCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + GCKEYBOARD_CONFIG;
+    s_user_paths[F_WIIPADCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + WIIPAD_CONFIG;
+    s_user_paths[F_GFXCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + GFX_CONFIG;
+    s_user_paths[F_DEBUGGERCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + DEBUGGER_CONFIG;
+    s_user_paths[F_LOGGERCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + LOGGER_CONFIG;
+    s_user_paths[F_DUALSHOCKUDPCLIENTCONFIG_IDX] =
+        s_user_paths[D_CONFIG_IDX] + DUALSHOCKUDPCLIENT_CONFIG;
+    s_user_paths[F_FREELOOKCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + FREELOOK_CONFIG;
+    break;
+
+  case D_CACHE_IDX:
+    s_user_paths[D_COVERCACHE_IDX] = s_user_paths[D_CACHE_IDX] + COVERCACHE_DIR DIR_SEP;
+    s_user_paths[D_REDUMPCACHE_IDX] = s_user_paths[D_CACHE_IDX] + REDUMPCACHE_DIR DIR_SEP;
+    s_user_paths[D_SHADERCACHE_IDX] = s_user_paths[D_CACHE_IDX] + SHADERCACHE_DIR DIR_SEP;
+    break;
+
+  case D_GCUSER_IDX:
+    s_user_paths[F_GCSRAM_IDX] = s_user_paths[D_GCUSER_IDX] + GC_SRAM;
+    break;
+
+  case D_DUMP_IDX:
+    s_user_paths[D_DUMPFRAMES_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_FRAMES_DIR DIR_SEP;
+    s_user_paths[D_DUMPOBJECTS_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_OBJECTS_DIR DIR_SEP;
+    s_user_paths[D_DUMPAUDIO_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_AUDIO_DIR DIR_SEP;
+    s_user_paths[D_DUMPTEXTURES_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_TEXTURES_DIR DIR_SEP;
+    s_user_paths[D_DUMPDSP_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_DSP_DIR DIR_SEP;
+    s_user_paths[D_DUMPSSL_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_SSL_DIR DIR_SEP;
+    s_user_paths[F_MEM1DUMP_IDX] = s_user_paths[D_DUMP_IDX] + MEM1_DUMP;
+    s_user_paths[F_MEM2DUMP_IDX] = s_user_paths[D_DUMP_IDX] + MEM2_DUMP;
+    s_user_paths[F_ARAMDUMP_IDX] = s_user_paths[D_DUMP_IDX] + ARAM_DUMP;
+    s_user_paths[F_FAKEVMEMDUMP_IDX] = s_user_paths[D_DUMP_IDX] + FAKEVMEM_DUMP;
+    break;
+
+  case D_LOGS_IDX:
+    s_user_paths[D_MAILLOGS_IDX] = s_user_paths[D_LOGS_IDX] + MAIL_LOGS_DIR DIR_SEP;
+    s_user_paths[F_MAINLOG_IDX] = s_user_paths[D_LOGS_IDX] + MAIN_LOG;
+    break;
+
+  case D_LOAD_IDX:
+    s_user_paths[D_HIRESTEXTURES_IDX] = s_user_paths[D_LOAD_IDX] + HIRES_TEXTURES_DIR DIR_SEP;
+    s_user_paths[D_RIIVOLUTION_IDX] = s_user_paths[D_LOAD_IDX] + RIIVOLUTION_DIR DIR_SEP;
+    s_user_paths[D_DYNAMICINPUT_IDX] = s_user_paths[D_LOAD_IDX] + DYNAMICINPUT_DIR DIR_SEP;
+    s_user_paths[D_GRAPHICSMOD_IDX] = s_user_paths[D_LOAD_IDX] + GRAPHICSMOD_DIR DIR_SEP;
+    break;
+  }
+}
+
+// Gets a set user directory path
+// Don't call prior to setting the base user directory
+const std::string& GetUserPath(unsigned int dir_index)
+{
+  return s_user_paths[dir_index];
+}
+
+// Sets a user directory path
+// Rebuilds internal directory structure to compensate for the new directory
+void SetUserPath(unsigned int dir_index, std::string path)
+{
+  if (path.empty())
+    return;
+
+#ifdef _WIN32
+  // On Windows, replace all '\' with '/' since we assume the latter in various places in the
+  // codebase.
+  for (char& c : path)
+  {
+    if (c == '\\')
+      c = '/';
+  }
+#endif
+
+  // Directories should end with a separator, files should not.
+  while (path.ends_with('/'))
+    path.pop_back();
+  if (path.empty())
+    return;
+  const bool is_directory = dir_index < FIRST_FILE_USER_PATH_IDX;
+  if (is_directory)
+    path.push_back('/');
+
+  s_user_paths[dir_index] = std::move(path);
+  RebuildUserDirectories(dir_index);
+}
+
+std::string GetThemeDir(const std::string& theme_name)
+{
+  std::string dir = File::GetUserPath(D_THEMES_IDX) + theme_name + "/";
+  if (Exists(dir))
+    return dir;
+
+  // If the theme doesn't exist in the user dir, load from shared directory
+  dir = GetSysDirectory() + THEMES_DIR "/" + theme_name + "/";
+  if (Exists(dir))
+    return dir;
+
+  // If the theme doesn't exist at all, load the default theme
+  return GetSysDirectory() + THEMES_DIR "/" DEFAULT_THEME_DIR "/";
+}
+
+bool WriteStringToFile(const std::string& filename, std::string_view str)
+{
+  return File::IOFile(filename, "wb").WriteBytes(str.data(), str.size());
+}
+
+bool ReadFileToString(const std::string& filename, std::string& str)
+{
+  File::IOFile file(filename, "rb");
+
+  if (!file)
+    return false;
+
+  str.resize(file.GetSize());
+  return file.ReadArray(str.data(), str.size());
+}
+
+}  // namespace File

Compatibility/Common/Layer.cpp

@@ -37,13 +37,13 @@ Layer::~Layer()
   Save();
 }
 
-bool Layer::Exists(const ConfigLocation& location) const
+bool Layer::Exists(const Location& location) const
 {
   const auto iter = m_map.find(location);
   return iter != m_map.end() && iter->second.has_value();
 }
 
-bool Layer::DeleteKey(const ConfigLocation& location)
+bool Layer::DeleteKey(const Location& location)
 {
   m_is_dirty = true;
   bool had_value = false;
@@ -68,19 +68,21 @@ void Layer::DeleteAllKeys()
 
 Section Layer::GetSection(System system, const std::string& section)
 {
-  return Section{m_map.lower_bound(ConfigLocation{system, section, ""}),
-                 m_map.lower_bound(ConfigLocation{system, section + '\001', ""})};
+  return Section{m_map.lower_bound(Location{system, section, ""}),
+                 m_map.lower_bound(Location{system, section + '\001', ""})};
 }
 
 ConstSection Layer::GetSection(System system, const std::string& section) const
 {
-  return ConstSection{m_map.lower_bound(ConfigLocation{system, section, ""}),
-                      m_map.lower_bound(ConfigLocation{system, section + '\001', ""})};
+  return ConstSection{m_map.lower_bound(Location{system, section, ""}),
+                      m_map.lower_bound(Location{system, section + '\001', ""})};
 }
 
 void Layer::Load()
 {
-    return;
+  if (m_loader)
+    m_loader->Load(this);
+  m_is_dirty = false;
 }
 
 void Layer::Save()

Compatibility/Core/ConfigManager.cpp

@@ -1,6 +1,3 @@
-//// Copyright 2008 Dolphin Emulator Project
-//// Licensed under GPLv2+
-//// Refer to the license.txt file included.
 // Copyright 2008 Dolphin Emulator Project
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
@@ -19,7 +16,6 @@
 #include "AudioCommon/AudioCommon.h"
 
 #include "Common/Assert.h"
-#include "Common/CDUtils.h"
 #include "Common/CommonPaths.h"
 #include "Common/CommonTypes.h"
 #include "Common/Config/Config.h"
@@ -31,12 +27,13 @@
 #include "Common/StringUtil.h"
 #include "Common/scmrev.h"
 
-#include "Core/Analytics.h"
 #include "Core/Boot/Boot.h"
 #include "Core/CommonTitles.h"
+#include "Core/Config/MainSettings.h"
 #include "Core/Config/SYSCONFSettings.h"
 #include "Core/ConfigLoaders/GameConfigLoader.h"
 #include "Core/Core.h"
+#include "Core/System.h"
 #include "Core/FifoPlayer/FifoDataFile.h"
 #include "Core/HLE/HLE.h"
 #include "Core/HW/DVD/DVDInterface.h"
@@ -83,574 +80,14 @@ SConfig::~SConfig()
 
 void SConfig::SaveSettings()
 {
-  NOTICE_LOG(BOOT, "Saving settings to %s", File::GetUserPath(F_DOLPHINCONFIG_IDX).c_str());
-  IniFile ini;
-  ini.Load(File::GetUserPath(F_DOLPHINCONFIG_IDX));  // load first to not kill unknown stuff
-
-  SaveGeneralSettings(ini);
-  SaveInterfaceSettings(ini);
-  SaveGameListSettings(ini);
-  SaveCoreSettings(ini);
-  SaveMovieSettings(ini);
-  SaveDSPSettings(ini);
-  SaveInputSettings(ini);
-  SaveFifoPlayerSettings(ini);
-  SaveAnalyticsSettings(ini);
-  SaveNetworkSettings(ini);
-  SaveBluetoothPassthroughSettings(ini);
-  SaveUSBPassthroughSettings(ini);
-  SaveAutoUpdateSettings(ini);
-  SaveJitDebugSettings(ini);
-
-  ini.Save(File::GetUserPath(F_DOLPHINCONFIG_IDX));
-
+  NOTICE_LOG_FMT(BOOT, "Saving settings to {}", File::GetUserPath(F_DOLPHINCONFIG_IDX));
   Config::Save();
 }
 
-void SConfig::SaveGeneralSettings(IniFile& ini)
-{
-  IniFile::Section* general = ini.GetOrCreateSection("General");
-
-  // General
-  general->Set("ShowLag", m_ShowLag);
-  general->Set("ShowFrameCount", m_ShowFrameCount);
-
-  // ISO folders
-  // Clear removed folders
-  int oldPaths;
-  int numPaths = (int)m_ISOFolder.size();
-  general->Get("ISOPaths", &oldPaths, 0);
-  for (int i = numPaths; i < oldPaths; i++)
-  {
-    ini.DeleteKey("General", fmt::format("ISOPath{}", i));
-  }
-
-  general->Set("ISOPaths", numPaths);
-  for (int i = 0; i < numPaths; i++)
-  {
-    general->Set(fmt::format("ISOPath{}", i), m_ISOFolder[i]);
-  }
-
-  general->Set("RecursiveISOPaths", m_RecursiveISOFolder);
-  general->Set("WirelessMac", m_WirelessMac);
-
-#ifdef USE_GDBSTUB
-#ifndef _WIN32
-  general->Set("GDBSocket", gdb_socket);
-#endif
-  general->Set("GDBPort", iGDBPort);
-#endif
-}
-
-void SConfig::SaveInterfaceSettings(IniFile& ini)
-{
-  IniFile::Section* interface = ini.GetOrCreateSection("Interface");
-
-  interface->Set("ConfirmStop", bConfirmStop);
-  interface->Set("UsePanicHandlers", bUsePanicHandlers);
-  interface->Set("OnScreenDisplayMessages", bOnScreenDisplayMessages);
-  interface->Set("HideCursor", bHideCursor);
-  interface->Set("LanguageCode", m_InterfaceLanguage);
-  interface->Set("ExtendedFPSInfo", m_InterfaceExtendedFPSInfo);
-  interface->Set("ShowActiveTitle", m_show_active_title);
-  interface->Set("UseBuiltinTitleDatabase", m_use_builtin_title_database);
-  interface->Set("ThemeName", theme_name);
-  interface->Set("PauseOnFocusLost", m_PauseOnFocusLost);
-  interface->Set("DebugModeEnabled", bEnableDebugging);
-}
-
-void SConfig::SaveGameListSettings(IniFile& ini)
-{
-  IniFile::Section* gamelist = ini.GetOrCreateSection("GameList");
-
-  gamelist->Set("ListDrives", m_ListDrives);
-  gamelist->Set("ListWad", m_ListWad);
-  gamelist->Set("ListElfDol", m_ListElfDol);
-  gamelist->Set("ListWii", m_ListWii);
-  gamelist->Set("ListGC", m_ListGC);
-  gamelist->Set("ListJap", m_ListJap);
-  gamelist->Set("ListPal", m_ListPal);
-  gamelist->Set("ListUsa", m_ListUsa);
-  gamelist->Set("ListAustralia", m_ListAustralia);
-  gamelist->Set("ListFrance", m_ListFrance);
-  gamelist->Set("ListGermany", m_ListGermany);
-  gamelist->Set("ListItaly", m_ListItaly);
-  gamelist->Set("ListKorea", m_ListKorea);
-  gamelist->Set("ListNetherlands", m_ListNetherlands);
-  gamelist->Set("ListRussia", m_ListRussia);
-  gamelist->Set("ListSpain", m_ListSpain);
-  gamelist->Set("ListTaiwan", m_ListTaiwan);
-  gamelist->Set("ListWorld", m_ListWorld);
-  gamelist->Set("ListUnknown", m_ListUnknown);
-  gamelist->Set("ListSort", m_ListSort);
-  gamelist->Set("ListSortSecondary", m_ListSort2);
-
-  gamelist->Set("ColumnPlatform", m_showSystemColumn);
-  gamelist->Set("ColumnBanner", m_showBannerColumn);
-  gamelist->Set("ColumnDescription", m_showDescriptionColumn);
-  gamelist->Set("ColumnTitle", m_showTitleColumn);
-  gamelist->Set("ColumnNotes", m_showMakerColumn);
-  gamelist->Set("ColumnFileName", m_showFileNameColumn);
-  gamelist->Set("ColumnID", m_showIDColumn);
-  gamelist->Set("ColumnRegion", m_showRegionColumn);
-  gamelist->Set("ColumnSize", m_showSizeColumn);
-  gamelist->Set("ColumnTags", m_showTagsColumn);
-}
-
-void SConfig::SaveCoreSettings(IniFile& ini)
-{
-  IniFile::Section* core = ini.GetOrCreateSection("Core");
-
-  core->Set("SkipIPL", bHLE_BS2);
-  core->Set("TimingVariance", iTimingVariance);
-  core->Set("CPUCore", cpu_core);
-  core->Set("Fastmem", bFastmem);
-  core->Set("CPUThread", bCPUThread);
-  core->Set("DSPHLE", bDSPHLE);
-  core->Set("SyncOnSkipIdle", bSyncGPUOnSkipIdleHack);
-  core->Set("SyncGPU", bSyncGPU);
-  core->Set("SyncGpuMaxDistance", iSyncGpuMaxDistance);
-  core->Set("SyncGpuMinDistance", iSyncGpuMinDistance);
-  core->Set("SyncGpuOverclock", fSyncGpuOverclock);
-  core->Set("FPRF", bFPRF);
-  core->Set("AccurateNaNs", bAccurateNaNs);
-  core->Set("EnableCheats", bEnableCheats);
-  core->Set("SelectedLanguage", SelectedLanguage);
-  core->Set("OverrideRegionSettings", bOverrideRegionSettings);
-  core->Set("DPL2Decoder", bDPL2Decoder);
-  core->Set("AudioLatency", iLatency);
-  core->Set("AudioStretch", m_audio_stretch);
-  core->Set("AudioStretchMaxLatency", m_audio_stretch_max_latency);
-  core->Set("AgpCartAPath", m_strGbaCartA);
-  core->Set("AgpCartBPath", m_strGbaCartB);
-  core->Set("SlotA", m_EXIDevice[0]);
-  core->Set("SlotB", m_EXIDevice[1]);
-  core->Set("SerialPort1", m_EXIDevice[2]);
-  core->Set("BBA_MAC", m_bba_mac);
-  for (int i = 0; i < SerialInterface::MAX_SI_CHANNELS; ++i)
-  {
-    core->Set(fmt::format("SIDevice{}", i), m_SIDevice[i]);
-    core->Set(fmt::format("AdapterRumble{}", i), m_AdapterRumble[i]);
-    core->Set(fmt::format("SimulateKonga{}", i), m_AdapterKonga[i]);
-  }
-  core->Set("WiiSDCard", m_WiiSDCard);
-  core->Set("WiiKeyboard", m_WiiKeyboard);
-  core->Set("WiimoteContinuousScanning", m_WiimoteContinuousScanning);
-  core->Set("WiimoteEnableSpeaker", m_WiimoteEnableSpeaker);
-  core->Set("RunCompareServer", bRunCompareServer);
-  core->Set("RunCompareClient", bRunCompareClient);
-  core->Set("MMU", bMMU);
-  core->Set("EmulationSpeed", m_EmulationSpeed);
-  core->Set("Overclock", m_OCFactor);
-  core->Set("OverclockEnable", m_OCEnable);
-  core->Set("GFXBackend", m_strVideoBackend);
-  core->Set("GPUDeterminismMode", m_strGPUDeterminismMode);
-  core->Set("PerfMapDir", m_perfDir);
-  core->Set("EnableCustomRTC", bEnableCustomRTC);
-  core->Set("CustomRTCValue", m_customRTCValue);
-}
-
-void SConfig::SaveMovieSettings(IniFile& ini)
-{
-  IniFile::Section* movie = ini.GetOrCreateSection("Movie");
-
-  movie->Set("PauseMovie", m_PauseMovie);
-  movie->Set("Author", m_strMovieAuthor);
-  movie->Set("DumpFrames", m_DumpFrames);
-  movie->Set("DumpFramesSilent", m_DumpFramesSilent);
-  movie->Set("ShowInputDisplay", m_ShowInputDisplay);
-  movie->Set("ShowRTC", m_ShowRTC);
-}
-
-void SConfig::SaveDSPSettings(IniFile& ini)
-{
-  IniFile::Section* dsp = ini.GetOrCreateSection("DSP");
-
-  dsp->Set("EnableJIT", m_DSPEnableJIT);
-  dsp->Set("DumpAudio", m_DumpAudio);
-  dsp->Set("DumpAudioSilent", m_DumpAudioSilent);
-  dsp->Set("DumpUCode", m_DumpUCode);
-  dsp->Set("Backend", sBackend);
-  dsp->Set("Volume", m_Volume);
-  dsp->Set("CaptureLog", m_DSPCaptureLog);
-
-#ifdef _WIN32
-  dsp->Set("WASAPIDevice", sWASAPIDevice);
-#endif
-}
-
-void SConfig::SaveInputSettings(IniFile& ini)
-{
-  IniFile::Section* input = ini.GetOrCreateSection("Input");
-
-  input->Set("BackgroundInput", m_BackgroundInput);
-}
-
-void SConfig::SaveFifoPlayerSettings(IniFile& ini)
-{
-  IniFile::Section* fifoplayer = ini.GetOrCreateSection("FifoPlayer");
-
-  fifoplayer->Set("LoopReplay", bLoopFifoReplay);
-}
-
-void SConfig::SaveNetworkSettings(IniFile& ini)
-{
-  IniFile::Section* network = ini.GetOrCreateSection("Network");
-
-  network->Set("SSLDumpRead", m_SSLDumpRead);
-  network->Set("SSLDumpWrite", m_SSLDumpWrite);
-  network->Set("SSLVerifyCertificates", m_SSLVerifyCert);
-  network->Set("SSLDumpRootCA", m_SSLDumpRootCA);
-  network->Set("SSLDumpPeerCert", m_SSLDumpPeerCert);
-}
-
-void SConfig::SaveAnalyticsSettings(IniFile& ini)
-{
-  IniFile::Section* analytics = ini.GetOrCreateSection("Analytics");
-
-  analytics->Set("ID", m_analytics_id);
-  analytics->Set("Enabled", m_analytics_enabled);
-  analytics->Set("PermissionAsked", m_analytics_permission_asked);
-}
-
-void SConfig::SaveBluetoothPassthroughSettings(IniFile& ini)
-{
-  IniFile::Section* section = ini.GetOrCreateSection("BluetoothPassthrough");
-
-  section->Set("Enabled", m_bt_passthrough_enabled);
-  section->Set("VID", m_bt_passthrough_vid);
-  section->Set("PID", m_bt_passthrough_pid);
-  section->Set("LinkKeys", m_bt_passthrough_link_keys);
-}
-
-void SConfig::SaveUSBPassthroughSettings(IniFile& ini)
-{
-  IniFile::Section* section = ini.GetOrCreateSection("USBPassthrough");
-
-  std::ostringstream oss;
-  for (const auto& device : m_usb_passthrough_devices)
-    oss << fmt::format("{:04x}:{:04x}", device.first, device.second) << ',';
-  std::string devices_string = oss.str();
-  if (!devices_string.empty())
-    devices_string.pop_back();
-
-  section->Set("Devices", devices_string);
-}
-
-void SConfig::SaveAutoUpdateSettings(IniFile& ini)
-{
-  IniFile::Section* section = ini.GetOrCreateSection("AutoUpdate");
-
-  section->Set("UpdateTrack", m_auto_update_track);
-  section->Set("HashOverride", m_auto_update_hash_override);
-}
-
-void SConfig::SaveJitDebugSettings(IniFile& ini)
-{
-  IniFile::Section* section = ini.GetOrCreateSection("Debug");
-
-  section->Set("JitOff", bJITOff);
-  section->Set("JitLoadStoreOff", bJITLoadStoreOff);
-  section->Set("JitLoadStoreFloatingOff", bJITLoadStoreFloatingOff);
-  section->Set("JitLoadStorePairedOff", bJITLoadStorePairedOff);
-  section->Set("JitFloatingPointOff", bJITFloatingPointOff);
-  section->Set("JitIntegerOff", bJITIntegerOff);
-  section->Set("JitPairedOff", bJITPairedOff);
-  section->Set("JitSystemRegistersOff", bJITSystemRegistersOff);
-  section->Set("JitBranchOff", bJITBranchOff);
-}
-
 void SConfig::LoadSettings()
 {
+  INFO_LOG_FMT(BOOT, "Loading Settings from {}", File::GetUserPath(F_DOLPHINCONFIG_IDX));
   Config::Load();
-
-  INFO_LOG(BOOT, "Loading Settings from %s", File::GetUserPath(F_DOLPHINCONFIG_IDX).c_str());
-  IniFile ini;
-  ini.Load(File::GetUserPath(F_DOLPHINCONFIG_IDX));
-
-  LoadGeneralSettings(ini);
-  LoadInterfaceSettings(ini);
-  LoadGameListSettings(ini);
-  LoadCoreSettings(ini);
-  LoadMovieSettings(ini);
-  LoadDSPSettings(ini);
-  LoadInputSettings(ini);
-  LoadFifoPlayerSettings(ini);
-  LoadNetworkSettings(ini);
-  LoadAnalyticsSettings(ini);
-  LoadBluetoothPassthroughSettings(ini);
-  LoadUSBPassthroughSettings(ini);
-  LoadAutoUpdateSettings(ini);
-  LoadJitDebugSettings(ini);
-}
-
-void SConfig::LoadGeneralSettings(IniFile& ini)
-{
-  IniFile::Section* general = ini.GetOrCreateSection("General");
-
-  general->Get("ShowLag", &m_ShowLag, false);
-  general->Get("ShowFrameCount", &m_ShowFrameCount, false);
-#ifdef USE_GDBSTUB
-#ifndef _WIN32
-  general->Get("GDBSocket", &gdb_socket, "");
-#endif
-  general->Get("GDBPort", &(iGDBPort), -1);
-#endif
-
-  m_ISOFolder.clear();
-  int numISOPaths;
-
-  if (general->Get("ISOPaths", &numISOPaths, 0))
-  {
-    for (int i = 0; i < numISOPaths; i++)
-    {
-      std::string tmpPath;
-      general->Get(fmt::format("ISOPath{}", i), &tmpPath, "");
-      m_ISOFolder.push_back(std::move(tmpPath));
-    }
-  }
-
-  general->Get("RecursiveISOPaths", &m_RecursiveISOFolder, false);
-  general->Get("WirelessMac", &m_WirelessMac);
-}
-
-void SConfig::LoadInterfaceSettings(IniFile& ini)
-{
-  IniFile::Section* interface = ini.GetOrCreateSection("Interface");
-
-  interface->Get("ConfirmStop", &bConfirmStop, true);
-  interface->Get("UsePanicHandlers", &bUsePanicHandlers, true);
-  interface->Get("OnScreenDisplayMessages", &bOnScreenDisplayMessages, true);
-  interface->Get("HideCursor", &bHideCursor, false);
-  interface->Get("LanguageCode", &m_InterfaceLanguage, "");
-  interface->Get("ExtendedFPSInfo", &m_InterfaceExtendedFPSInfo, false);
-  interface->Get("ShowActiveTitle", &m_show_active_title, true);
-  interface->Get("UseBuiltinTitleDatabase", &m_use_builtin_title_database, true);
-  interface->Get("ThemeName", &theme_name, DEFAULT_THEME_DIR);
-  interface->Get("PauseOnFocusLost", &m_PauseOnFocusLost, false);
-  interface->Get("DebugModeEnabled", &bEnableDebugging, false);
-}
-
-void SConfig::LoadGameListSettings(IniFile& ini)
-{
-  IniFile::Section* gamelist = ini.GetOrCreateSection("GameList");
-
-  gamelist->Get("ListDrives", &m_ListDrives, false);
-  gamelist->Get("ListWad", &m_ListWad, true);
-  gamelist->Get("ListElfDol", &m_ListElfDol, true);
-  gamelist->Get("ListWii", &m_ListWii, true);
-  gamelist->Get("ListGC", &m_ListGC, true);
-  gamelist->Get("ListJap", &m_ListJap, true);
-  gamelist->Get("ListPal", &m_ListPal, true);
-  gamelist->Get("ListUsa", &m_ListUsa, true);
-
-  gamelist->Get("ListAustralia", &m_ListAustralia, true);
-  gamelist->Get("ListFrance", &m_ListFrance, true);
-  gamelist->Get("ListGermany", &m_ListGermany, true);
-  gamelist->Get("ListItaly", &m_ListItaly, true);
-  gamelist->Get("ListKorea", &m_ListKorea, true);
-  gamelist->Get("ListNetherlands", &m_ListNetherlands, true);
-  gamelist->Get("ListRussia", &m_ListRussia, true);
-  gamelist->Get("ListSpain", &m_ListSpain, true);
-  gamelist->Get("ListTaiwan", &m_ListTaiwan, true);
-  gamelist->Get("ListWorld", &m_ListWorld, true);
-  gamelist->Get("ListUnknown", &m_ListUnknown, true);
-  gamelist->Get("ListSort", &m_ListSort, 3);
-  gamelist->Get("ListSortSecondary", &m_ListSort2, 0);
-
-  // Gamelist columns toggles
-  gamelist->Get("ColumnPlatform", &m_showSystemColumn, true);
-  gamelist->Get("ColumnDescription", &m_showDescriptionColumn, false);
-  gamelist->Get("ColumnBanner", &m_showBannerColumn, true);
-  gamelist->Get("ColumnTitle", &m_showTitleColumn, true);
-  gamelist->Get("ColumnNotes", &m_showMakerColumn, true);
-  gamelist->Get("ColumnFileName", &m_showFileNameColumn, false);
-  gamelist->Get("ColumnID", &m_showIDColumn, false);
-  gamelist->Get("ColumnRegion", &m_showRegionColumn, true);
-  gamelist->Get("ColumnSize", &m_showSizeColumn, true);
-  gamelist->Get("ColumnTags", &m_showTagsColumn, false);
-}
-
-void SConfig::LoadCoreSettings(IniFile& ini)
-{
-  IniFile::Section* core = ini.GetOrCreateSection("Core");
-
-  core->Get("SkipIPL", &bHLE_BS2, true);
-#ifdef _M_X86
-  core->Get("CPUCore", &cpu_core, PowerPC::CPUCore::JIT64);
-#elif _M_ARM_64
-  core->Get("CPUCore", &cpu_core, PowerPC::CPUCore::JITARM64);
-#else
-  core->Get("CPUCore", &cpu_core, PowerPC::CPUCore::Interpreter);
-#endif
-  core->Get("JITFollowBranch", &bJITFollowBranch, true);
-  core->Get("Fastmem", &bFastmem, true);
-  core->Get("DSPHLE", &bDSPHLE, true);
-  core->Get("TimingVariance", &iTimingVariance, 40);
-  core->Get("CPUThread", &bCPUThread, true);
-  core->Get("SyncOnSkipIdle", &bSyncGPUOnSkipIdleHack, true);
-  core->Get("EnableCheats", &bEnableCheats, false);
-  core->Get("SelectedLanguage", &SelectedLanguage, 0);
-  core->Get("OverrideRegionSettings", &bOverrideRegionSettings, false);
-  core->Get("DPL2Decoder", &bDPL2Decoder, false);
-  core->Get("AudioLatency", &iLatency, 20);
-  core->Get("AudioStretch", &m_audio_stretch, false);
-  core->Get("AudioStretchMaxLatency", &m_audio_stretch_max_latency, 80);
-  core->Get("AgpCartAPath", &m_strGbaCartA);
-  core->Get("AgpCartBPath", &m_strGbaCartB);
-  core->Get("SlotA", (int*)&m_EXIDevice[0], ExpansionInterface::EXIDEVICE_MEMORYCARDFOLDER);
-  core->Get("SlotB", (int*)&m_EXIDevice[1], ExpansionInterface::EXIDEVICE_NONE);
-  core->Get("SerialPort1", (int*)&m_EXIDevice[2], ExpansionInterface::EXIDEVICE_NONE);
-  core->Get("BBA_MAC", &m_bba_mac);
-  for (size_t i = 0; i < std::size(m_SIDevice); ++i)
-  {
-    //OpenEmu make all devices GCpads
-    core->Get(fmt::format("SIDevice{}", i), &m_SIDevice[i], SerialInterface::SIDEVICE_GC_CONTROLLER);
-      
-    core->Get(fmt::format("AdapterRumble{}", i), &m_AdapterRumble[i], true);
-    core->Get(fmt::format("SimulateKonga{}", i), &m_AdapterKonga[i], false);
-  }
-  core->Get("WiiSDCard", &m_WiiSDCard, false);
-  core->Get("WiiKeyboard", &m_WiiKeyboard, false);
-  core->Get("WiimoteContinuousScanning", &m_WiimoteContinuousScanning, false);
-  core->Get("WiimoteEnableSpeaker", &m_WiimoteEnableSpeaker, false);
-  core->Get("RunCompareServer", &bRunCompareServer, false);
-  core->Get("RunCompareClient", &bRunCompareClient, false);
-  core->Get("MMU", &bMMU, bMMU);
-  core->Get("BBDumpPort", &iBBDumpPort, -1);
-  core->Get("SyncGPU", &bSyncGPU, false);
-  core->Get("SyncGpuMaxDistance", &iSyncGpuMaxDistance, 200000);
-  core->Get("SyncGpuMinDistance", &iSyncGpuMinDistance, -200000);
-  core->Get("SyncGpuOverclock", &fSyncGpuOverclock, 1.0f);
-  core->Get("FastDiscSpeed", &bFastDiscSpeed, false);
-  core->Get("LowDCBZHack", &bLowDCBZHack, false);
-  core->Get("FPRF", &bFPRF, false);
-  core->Get("AccurateNaNs", &bAccurateNaNs, false);
-  core->Get("EmulationSpeed", &m_EmulationSpeed, 1.0f);
-  core->Get("Overclock", &m_OCFactor, 1.0f);
-  core->Get("OverclockEnable", &m_OCEnable, false);
-  core->Get("GFXBackend", &m_strVideoBackend, "");
-  core->Get("GPUDeterminismMode", &m_strGPUDeterminismMode, "auto");
-  core->Get("PerfMapDir", &m_perfDir, "");
-  core->Get("EnableCustomRTC", &bEnableCustomRTC, false);
-  // Default to seconds between 1.1.1970 and 1.1.2000
-  core->Get("CustomRTCValue", &m_customRTCValue, 946684800);
-}
-
-void SConfig::LoadMovieSettings(IniFile& ini)
-{
-  IniFile::Section* movie = ini.GetOrCreateSection("Movie");
-
-  movie->Get("PauseMovie", &m_PauseMovie, false);
-  movie->Get("Author", &m_strMovieAuthor, "");
-  movie->Get("DumpFrames", &m_DumpFrames, false);
-  movie->Get("DumpFramesSilent", &m_DumpFramesSilent, false);
-  movie->Get("ShowInputDisplay", &m_ShowInputDisplay, false);
-  movie->Get("ShowRTC", &m_ShowRTC, false);
-}
-
-void SConfig::LoadDSPSettings(IniFile& ini)
-{
-  IniFile::Section* dsp = ini.GetOrCreateSection("DSP");
-
-  dsp->Get("EnableJIT", &m_DSPEnableJIT, true);
-  dsp->Get("DumpAudio", &m_DumpAudio, false);
-  dsp->Get("DumpAudioSilent", &m_DumpAudioSilent, false);
-  dsp->Get("DumpUCode", &m_DumpUCode, false);
-  dsp->Get("Backend", &sBackend, AudioCommon::GetDefaultSoundBackend());
-  dsp->Get("Volume", &m_Volume, 100);
-  dsp->Get("CaptureLog", &m_DSPCaptureLog, false);
-
-#ifdef _WIN32
-  dsp->Get("WASAPIDevice", &sWASAPIDevice, "default");
-#endif
-
-  m_IsMuted = false;
-}
-
-void SConfig::LoadInputSettings(IniFile& ini)
-{
-  IniFile::Section* input = ini.GetOrCreateSection("Input");
-
-  input->Get("BackgroundInput", &m_BackgroundInput, false);
-}
-
-void SConfig::LoadFifoPlayerSettings(IniFile& ini)
-{
-  IniFile::Section* fifoplayer = ini.GetOrCreateSection("FifoPlayer");
-
-  fifoplayer->Get("LoopReplay", &bLoopFifoReplay, true);
-}
-
-void SConfig::LoadNetworkSettings(IniFile& ini)
-{
-  IniFile::Section* network = ini.GetOrCreateSection("Network");
-
-  network->Get("SSLDumpRead", &m_SSLDumpRead, false);
-  network->Get("SSLDumpWrite", &m_SSLDumpWrite, false);
-  network->Get("SSLVerifyCertificates", &m_SSLVerifyCert, true);
-  network->Get("SSLDumpRootCA", &m_SSLDumpRootCA, false);
-  network->Get("SSLDumpPeerCert", &m_SSLDumpPeerCert, false);
-}
-
-void SConfig::LoadAnalyticsSettings(IniFile& ini)
-{
-  IniFile::Section* analytics = ini.GetOrCreateSection("Analytics");
-
-  analytics->Get("ID", &m_analytics_id, "");
-  analytics->Get("Enabled", &m_analytics_enabled, false);
-  analytics->Get("PermissionAsked", &m_analytics_permission_asked, false);
-}
-
-void SConfig::LoadBluetoothPassthroughSettings(IniFile& ini)
-{
-  IniFile::Section* section = ini.GetOrCreateSection("BluetoothPassthrough");
-
-  section->Get("Enabled", &m_bt_passthrough_enabled, false);
-  section->Get("VID", &m_bt_passthrough_vid, -1);
-  section->Get("PID", &m_bt_passthrough_pid, -1);
-  section->Get("LinkKeys", &m_bt_passthrough_link_keys, "");
-}
-
-void SConfig::LoadUSBPassthroughSettings(IniFile& ini)
-{
-  IniFile::Section* section = ini.GetOrCreateSection("USBPassthrough");
-  m_usb_passthrough_devices.clear();
-  std::string devices_string;
-  section->Get("Devices", &devices_string, "");
-  for (const auto& pair : SplitString(devices_string, ','))
-  {
-    const auto index = pair.find(':');
-    if (index == std::string::npos)
-      continue;
-
-    const u16 vid = static_cast<u16>(strtol(pair.substr(0, index).c_str(), nullptr, 16));
-    const u16 pid = static_cast<u16>(strtol(pair.substr(index + 1).c_str(), nullptr, 16));
-    if (vid && pid)
-      m_usb_passthrough_devices.emplace(vid, pid);
-  }
-}
-
-void SConfig::LoadAutoUpdateSettings(IniFile& ini)
-{
-  IniFile::Section* section = ini.GetOrCreateSection("AutoUpdate");
-
-  section->Get("UpdateTrack", &m_auto_update_track, SCM_UPDATE_TRACK_STR);
-  section->Get("HashOverride", &m_auto_update_hash_override, "");
-}
-
-void SConfig::LoadJitDebugSettings(IniFile& ini)
-{
-  IniFile::Section* section = ini.GetOrCreateSection("Debug");
-  section->Get("JitOff", &bJITOff, false);
-  section->Get("JitLoadStoreOff", &bJITLoadStoreOff, false);
-  section->Get("JitLoadStoreFloatingOff", &bJITLoadStoreFloatingOff, false);
-  section->Get("JitLoadStorePairedOff", &bJITLoadStorePairedOff, false);
-  section->Get("JitFloatingPointOff", &bJITFloatingPointOff, false);
-  section->Get("JitIntegerOff", &bJITIntegerOff, false);
-  section->Get("JitPairedOff", &bJITPairedOff, false);
-  section->Get("JitSystemRegistersOff", &bJITSystemRegistersOff, false);
-  section->Get("JitBranchOff", &bJITBranchOff, false);
 }
 
 void SConfig::ResetRunningGameMetadata()
@@ -721,153 +158,45 @@ void SConfig::SetRunningGameMetadata(const std::string& game_id, const std::stri
 
   if (game_id == "00000000")
   {
+    m_title_name.clear();
     m_title_description.clear();
     return;
   }
 
   const Core::TitleDatabase title_database;
   const DiscIO::Language language = GetLanguageAdjustedForRegion(bWii, region);
+  m_title_name = title_database.GetTitleName(m_gametdb_id, language);
   m_title_description = title_database.Describe(m_gametdb_id, language);
-  NOTICE_LOG(CORE, "Active title: %s", m_title_description.c_str());
+  NOTICE_LOG_FMT(CORE, "Active title: {}", m_title_description);
   Host_TitleChanged();
+  if (Core::IsRunning())
+  {
+    Core::UpdateTitle();
+  }
 
   Config::AddLayer(ConfigLoaders::GenerateGlobalGameConfigLoader(game_id, revision));
   Config::AddLayer(ConfigLoaders::GenerateLocalGameConfigLoader(game_id, revision));
-
-  if (Core::IsRunning())
-  {
-    // TODO: have a callback mechanism for title changes?
-    if (!g_symbolDB.IsEmpty())
-    {
-      g_symbolDB.Clear();
-      Host_NotifyMapLoaded();
-    }
-    CBoot::LoadMapFromFilename();
-    HLE::Reload();
-    PatchEngine::Reload();
-    HiresTexture::Update();
-    DolphinAnalytics::Instance().ReportGameStart();
-  }
 }
 
 void SConfig::LoadDefaults()
 {
-  bEnableDebugging = false;
   bAutomaticStart = false;
   bBootToPause = false;
 
-#ifdef USE_GDBSTUB
-  iGDBPort = -1;
-#ifndef _WIN32
-  gdb_socket = "";
-#endif
-#endif
-
-  cpu_core = PowerPC::DefaultCPUCore();
-  iTimingVariance = 40;
-  bCPUThread = false;
-  bSyncGPUOnSkipIdleHack = true;
-  bRunCompareServer = false;
-  bDSPHLE = true;
-  bFastmem = true;
-  bFPRF = false;
-  bAccurateNaNs = false;
-  bMMU = false;
-  bLowDCBZHack = false;
-  iBBDumpPort = -1;
-  bSyncGPU = false;
-  bFastDiscSpeed = false;
-  bEnableMemcardSdWriting = true;
-  SelectedLanguage = 0;
-  bOverrideRegionSettings = false;
   bWii = false;
-  bDPL2Decoder = false;
-  iLatency = 20;
-  m_audio_stretch = false;
-  m_audio_stretch_max_latency = 80;
-  bUsePanicHandlers = true;
-  bOnScreenDisplayMessages = true;
-
-  m_analytics_id = "";
-  m_analytics_enabled = false;
-  m_analytics_permission_asked = false;
-
-  bLoopFifoReplay = true;
-
-  bJITOff = false;  // debugger only settings
-  bJITLoadStoreOff = false;
-  bJITLoadStoreFloatingOff = false;
-  bJITLoadStorePairedOff = false;
-  bJITFloatingPointOff = false;
-  bJITIntegerOff = false;
-  bJITPairedOff = false;
-  bJITSystemRegistersOff = false;
-  bJITBranchOff = false;
 
   ResetRunningGameMetadata();
 }
 
-bool SConfig::IsUSBDeviceWhitelisted(const std::pair<u16, u16> vid_pid) const
-{
-  return m_usb_passthrough_devices.find(vid_pid) != m_usb_passthrough_devices.end();
-}
-
-// The reason we need this function is because some memory card code
-// expects to get a non-NTSC-K region even if we're emulating an NTSC-K Wii.
-DiscIO::Region SConfig::ToGameCubeRegion(DiscIO::Region region)
-{
-  if (region != DiscIO::Region::NTSC_K)
-    return region;
-
-  // GameCube has no NTSC-K region. No choice of replacement value is completely
-  // non-arbitrary, but let's go with NTSC-J since Korean GameCubes are NTSC-J.
-  return DiscIO::Region::NTSC_J;
-}
-
-const char* SConfig::GetDirectoryForRegion(DiscIO::Region region)
-{
-  if (region == DiscIO::Region::Unknown)
-    region = ToGameCubeRegion(GetFallbackRegion());
-
-  switch (region)
-  {
-  case DiscIO::Region::NTSC_J:
-    return JAP_DIR;
-
-  case DiscIO::Region::NTSC_U:
-    return USA_DIR;
-
-  case DiscIO::Region::PAL:
-    return EUR_DIR;
-
-  case DiscIO::Region::NTSC_K:
-    ASSERT_MSG(BOOT, false, "NTSC-K is not a valid GameCube region");
-    return JAP_DIR;  // See ToGameCubeRegion
-
-  default:
-    ASSERT_MSG(BOOT, false, "Default case should not be reached");
-    return EUR_DIR;
-  }
-}
-
-std::string SConfig::GetBootROMPath(const std::string& region_directory) const
-{
-  const std::string path =
-      File::GetUserPath(D_GCUSER_IDX) + DIR_SEP + region_directory + DIR_SEP GC_IPL;
-  if (!File::Exists(path))
-    return File::GetSysDirectory() + GC_SYS_DIR + DIR_SEP + region_directory + DIR_SEP GC_IPL;
-  return path;
-}
-
 struct SetGameMetadata
 {
   SetGameMetadata(SConfig* config_, DiscIO::Region* region_) : config(config_), region(region_) {}
   bool operator()(const BootParameters::Disc& disc) const
   {
-    config->SetRunningGameMetadata(*disc.volume, disc.volume->GetGamePartition());
+    *region = disc.volume->GetRegion();
     config->bWii = disc.volume->GetVolumeType() == DiscIO::Platform::WiiDisc;
     config->m_disc_booted_from_game_list = true;
-    *region = disc.volume->GetRegion();
+    config->SetRunningGameMetadata(*disc.volume, disc.volume->GetGamePartition());
     return true;
   }
 
@@ -876,12 +205,14 @@ struct SetGameMetadata
     if (!executable.reader->IsValid())
       return false;
 
-    config->bWii = executable.reader->IsWii();
-
     *region = DiscIO::Region::Unknown;
+    config->bWii = executable.reader->IsWii();
 
     // Strip the .elf/.dol file extension and directories before the name
     SplitPath(executable.path, nullptr, &config->m_debugger_game_id, nullptr);
+
+    Host_TitleChanged();
+
     return true;
   }
 
@@ -889,19 +220,20 @@ struct SetGameMetadata
   {
     if (!wad.GetTMD().IsValid())
     {
-      PanicAlertT("This WAD is not valid.");
+      PanicAlertFmtT("This WAD is not valid.");
       return false;
     }
     if (!IOS::ES::IsChannel(wad.GetTMD().GetTitleId()))
     {
-      PanicAlertT("This WAD is not bootable.");
+      PanicAlertFmtT("This WAD is not bootable.");
       return false;
     }
 
     const IOS::ES::TMDReader& tmd = wad.GetTMD();
-    config->SetRunningGameMetadata(tmd, DiscIO::Platform::WiiWAD);
-    config->bWii = true;
     *region = tmd.GetRegion();
+    config->bWii = true;
+    config->SetRunningGameMetadata(tmd, DiscIO::Platform::WiiWAD);
+
     return true;
   }
 
@@ -911,19 +243,23 @@ struct SetGameMetadata
     const IOS::ES::TMDReader tmd = ios.GetES()->FindInstalledTMD(nand_title.id);
     if (!tmd.IsValid() || !IOS::ES::IsChannel(nand_title.id))
     {
-      PanicAlertT("This title cannot be booted.");
+      PanicAlertFmtT("This title cannot be booted.");
       return false;
     }
-    config->SetRunningGameMetadata(tmd, DiscIO::Platform::WiiWAD);
-    config->bWii = true;
+
     *region = tmd.GetRegion();
+    config->bWii = true;
+    config->SetRunningGameMetadata(tmd, DiscIO::Platform::WiiWAD);
+
     return true;
   }
 
   bool operator()(const BootParameters::IPL& ipl) const
   {
-    config->bWii = false;
     *region = ipl.region;
+    config->bWii = false;
+    Host_TitleChanged();
+
     return true;
   }
 
@@ -933,8 +269,10 @@ struct SetGameMetadata
     if (!dff_file)
       return false;
 
-    config->bWii = dff_file->GetIsWii();
     *region = DiscIO::Region::NTSC_U;
+    config->bWii = dff_file->GetIsWii();
+    Host_TitleChanged();
+
     return true;
   }
 
@@ -951,40 +289,23 @@ bool SConfig::SetPathsAndGameMetadata(const BootParameters& boot)
     return false;
 
   if (m_region == DiscIO::Region::Unknown)
-    m_region = GetFallbackRegion();
+    m_region = Config::Get(Config::MAIN_FALLBACK_REGION);
 
   // Set up paths
-  const std::string region_dir = GetDirectoryForRegion(ToGameCubeRegion(m_region));
+  const std::string region_dir = Config::GetDirectoryForRegion(Config::ToGameCubeRegion(m_region));
   m_strSRAM = File::GetUserPath(F_GCSRAM_IDX);
-  m_strBootROM = GetBootROMPath(region_dir);
+  m_strBootROM = Config::GetBootROMPath(region_dir);
 
   return true;
 }
 
-DiscIO::Region SConfig::GetFallbackRegion()
-{
-  // Fall back to the system menu region, if possible.
-  IOS::HLE::Kernel ios;
-  const IOS::ES::TMDReader system_menu_tmd = ios.GetES()->FindInstalledTMD(Titles::SYSTEM_MENU);
-  if (system_menu_tmd.IsValid())
-  {
-    const DiscIO::Region region = system_menu_tmd.GetRegion();
-    if (region != DiscIO::Region::Unknown)
-      return region;
-  }
-
-  // Fall back to PAL.
-  return DiscIO::Region::PAL;
-}
-
 DiscIO::Language SConfig::GetCurrentLanguage(bool wii) const
 {
-  int language_value;
+  DiscIO::Language language;
   if (wii)
-    language_value = Config::Get(Config::SYSCONF_LANGUAGE);
+    language = static_cast<DiscIO::Language>(Config::Get(Config::SYSCONF_LANGUAGE));
   else
-    language_value = SConfig::GetInstance().SelectedLanguage + 1;
-  DiscIO::Language language = static_cast<DiscIO::Language>(language_value);
+    language = DiscIO::FromGameCubeLanguage(Config::Get(Config::MAIN_GC_LANGUAGE));
 
   // Get rid of invalid values (probably doesn't matter, but might as well do it)
   if (language > DiscIO::Language::Unknown || language < DiscIO::Language::Japanese)
@@ -1002,7 +323,7 @@ DiscIO::Language SConfig::GetLanguageAdjustedForRegion(bool wii, DiscIO::Region
   if (!wii && region == DiscIO::Region::NTSC_J && language == DiscIO::Language::English)
     return DiscIO::Language::Japanese;  // English and Japanese both use the value 0 in GC SRAM
 
-  if (!bOverrideRegionSettings)
+  if (!Config::Get(Config::MAIN_OVERRIDE_REGION_SETTINGS))
   {
     if (region == DiscIO::Region::NTSC_J)
       return DiscIO::Language::Japanese;
@@ -1067,7 +388,18 @@ IniFile SConfig::LoadGameIni(const std::string& id, std::optional<u16> revision)
   return game_ini;
 }
 
-bool SConfig::ShouldUseDPL2Decoder() const
+void SConfig::OnNewTitleLoad(const Core::CPUThreadGuard &guard)
 {
-  return bDPL2Decoder && !bDSPHLE;
+  if (!Core::IsRunning())
+    return;
+
+  if (!g_symbolDB.IsEmpty())
+  {
+    g_symbolDB.Clear();
+    Host_NotifyMapLoaded();
+  }
+  CBoot::LoadMapFromFilename(guard);
+  HLE::Reload(Core::System::GetInstance());
+  PatchEngine::Reload();
+  HiresTexture::Update();
 }

Compatibility/Core/FileUtil.cpp

@@ -1,919 +0,0 @@
-
-
-
-// Copyright 2008 Dolphin Emulator Project
-// Licensed under GPLv2+
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <cstddef>
-#include <cstdio>
-#include <cstring>
-#include <fcntl.h>
-#include <fstream>
-#include <limits.h>
-#include <string>
-#include <sys/stat.h>
-#include <vector>
-
-#include "Common/Assert.h"
-#include "Common/Common.h"
-#include "Common/CommonFuncs.h"
-#include "Common/CommonPaths.h"
-#include "Common/CommonTypes.h"
-#include "Common/File.h"
-#include "Common/FileUtil.h"
-#include "Common/Logging/Log.h"
-
-#ifdef _WIN32
-#include <windows.h>
-#include <Shlwapi.h>
-#include <commdlg.h>  // for GetSaveFileName
-#include <direct.h>   // getcwd
-#include <io.h>
-#include <objbase.h>  // guid stuff
-#include <shellapi.h>
-#else
-#include <dirent.h>
-#include <errno.h>
-#include <libgen.h>
-#include <stdlib.h>
-#include <unistd.h>
-#endif
-
-#ifdef OpenEmu
-#include "DolphinGameCore.h"
-#endif
-
-#if defined(__APPLE__)
-#include <CoreFoundation/CFBundle.h>
-#include <CoreFoundation/CFString.h>
-#include <CoreFoundation/CFURL.h>
-#include <mach-o/dyld.h>
-#include <sys/param.h>
-#endif
-
-#ifndef S_ISDIR
-#define S_ISDIR(m) (((m)&S_IFMT) == S_IFDIR)
-#endif
-
-// This namespace has various generic functions related to files and paths.
-// The code still needs a ton of cleanup.
-// REMEMBER: strdup considered harmful!
-namespace File
-{
-#ifdef ANDROID
-static std::string s_android_sys_directory;
-#endif
-
-#ifdef _WIN32
-FileInfo::FileInfo(const std::string& path)
-{
-  m_exists = _tstat64(UTF8ToTStr(path).c_str(), &m_stat) == 0;
-}
-
-FileInfo::FileInfo(const char* path) : FileInfo(std::string(path))
-{
-}
-#else
-FileInfo::FileInfo(const std::string& path) : FileInfo(path.c_str())
-{
-}
-
-FileInfo::FileInfo(const char* path)
-{
-  m_exists = stat(path, &m_stat) == 0;
-}
-#endif
-
-FileInfo::FileInfo(int fd)
-{
-  m_exists = fstat(fd, &m_stat);
-}
-
-bool FileInfo::Exists() const
-{
-  return m_exists;
-}
-
-bool FileInfo::IsDirectory() const
-{
-  return m_exists ? S_ISDIR(m_stat.st_mode) : false;
-}
-
-bool FileInfo::IsFile() const
-{
-  return m_exists ? !S_ISDIR(m_stat.st_mode) : false;
-}
-
-u64 FileInfo::GetSize() const
-{
-  return IsFile() ? m_stat.st_size : 0;
-}
-
-// Returns true if the path exists
-bool Exists(const std::string& path)
-{
-  return FileInfo(path).Exists();
-}
-
-// Returns true if the path exists and is a directory
-bool IsDirectory(const std::string& path)
-{
-#ifdef _WIN32
-  return PathIsDirectory(UTF8ToUTF16(path).c_str());
-#else
-  return FileInfo(path).IsDirectory();
-#endif
-}
-
-// Returns true if the path exists and is a file
-bool IsFile(const std::string& path)
-{
-  return FileInfo(path).IsFile();
-}
-
-// Deletes a given filename, return true on success
-// Doesn't supports deleting a directory
-bool Delete(const std::string& filename)
-{
-  INFO_LOG(COMMON, "Delete: file %s", filename.c_str());
-
-  const FileInfo file_info(filename);
-
-  // Return true because we care about the file no
-  // being there, not the actual delete.
-  if (!file_info.Exists())
-  {
-    WARN_LOG(COMMON, "Delete: %s does not exist", filename.c_str());
-    return true;
-  }
-
-  // We can't delete a directory
-  if (file_info.IsDirectory())
-  {
-    WARN_LOG(COMMON, "Delete failed: %s is a directory", filename.c_str());
-    return false;
-  }
-
-#ifdef _WIN32
-  if (!DeleteFile(UTF8ToTStr(filename).c_str()))
-  {
-    WARN_LOG(COMMON, "Delete: DeleteFile failed on %s: %s", filename.c_str(),
-             GetLastErrorString().c_str());
-    return false;
-  }
-#else
-  if (unlink(filename.c_str()) == -1)
-  {
-    WARN_LOG(COMMON, "Delete: unlink failed on %s: %s", filename.c_str(),
-             LastStrerrorString().c_str());
-    return false;
-  }
-#endif
-
-  return true;
-}
-
-// Returns true if successful, or path already exists.
-bool CreateDir(const std::string& path)
-{
-  INFO_LOG(COMMON, "CreateDir: directory %s", path.c_str());
-#ifdef _WIN32
-  if (::CreateDirectory(UTF8ToTStr(path).c_str(), nullptr))
-    return true;
-  DWORD error = GetLastError();
-  if (error == ERROR_ALREADY_EXISTS)
-  {
-    WARN_LOG(COMMON, "CreateDir: CreateDirectory failed on %s: already exists", path.c_str());
-    return true;
-  }
-  ERROR_LOG(COMMON, "CreateDir: CreateDirectory failed on %s: %i", path.c_str(), error);
-  return false;
-#else
-  if (mkdir(path.c_str(), 0755) == 0)
-    return true;
-
-  int err = errno;
-
-  if (err == EEXIST)
-  {
-    WARN_LOG(COMMON, "CreateDir: mkdir failed on %s: already exists", path.c_str());
-    return true;
-  }
-
-  ERROR_LOG(COMMON, "CreateDir: mkdir failed on %s: %s", path.c_str(), strerror(err));
-  return false;
-#endif
-}
-
-// Creates the full path of fullPath returns true on success
-bool CreateFullPath(const std::string& fullPath)
-{
-  int panicCounter = 100;
-  INFO_LOG(COMMON, "CreateFullPath: path %s", fullPath.c_str());
-
-  if (Exists(fullPath))
-  {
-    INFO_LOG(COMMON, "CreateFullPath: path exists %s", fullPath.c_str());
-    return true;
-  }
-
-  size_t position = 0;
-  while (true)
-  {
-    // Find next sub path
-    position = fullPath.find(DIR_SEP_CHR, position);
-
-    // we're done, yay!
-    if (position == fullPath.npos)
-      return true;
-
-    // Include the '/' so the first call is CreateDir("/") rather than CreateDir("")
-    std::string const subPath(fullPath.substr(0, position + 1));
-    if (!IsDirectory(subPath))
-      File::CreateDir(subPath);
-
-    // A safety check
-    panicCounter--;
-    if (panicCounter <= 0)
-    {
-      ERROR_LOG(COMMON, "CreateFullPath: directory structure is too deep");
-      return false;
-    }
-    position++;
-  }
-}
-
-// Deletes a directory filename, returns true on success
-bool DeleteDir(const std::string& filename)
-{
-  INFO_LOG(COMMON, "DeleteDir: directory %s", filename.c_str());
-
-  // check if a directory
-  if (!IsDirectory(filename))
-  {
-    ERROR_LOG(COMMON, "DeleteDir: Not a directory %s", filename.c_str());
-    return false;
-  }
-
-#ifdef _WIN32
-  if (::RemoveDirectory(UTF8ToTStr(filename).c_str()))
-    return true;
-  ERROR_LOG(COMMON, "DeleteDir: RemoveDirectory failed on %s: %s", filename.c_str(),
-            GetLastErrorString().c_str());
-#else
-  if (rmdir(filename.c_str()) == 0)
-    return true;
-  ERROR_LOG(COMMON, "DeleteDir: rmdir failed on %s: %s", filename.c_str(),
-            LastStrerrorString().c_str());
-#endif
-
-  return false;
-}
-
-// renames file srcFilename to destFilename, returns true on success
-bool Rename(const std::string& srcFilename, const std::string& destFilename)
-{
-  INFO_LOG(COMMON, "Rename: %s --> %s", srcFilename.c_str(), destFilename.c_str());
-#ifdef _WIN32
-  auto sf = UTF8ToTStr(srcFilename);
-  auto df = UTF8ToTStr(destFilename);
-  // The Internet seems torn about whether ReplaceFile is atomic or not.
-  // Hopefully it's atomic enough...
-  if (ReplaceFile(df.c_str(), sf.c_str(), nullptr, REPLACEFILE_IGNORE_MERGE_ERRORS, nullptr,
-                  nullptr))
-    return true;
-  // Might have failed because the destination doesn't exist.
-  if (GetLastError() == ERROR_FILE_NOT_FOUND)
-  {
-    if (MoveFile(sf.c_str(), df.c_str()))
-      return true;
-  }
-  ERROR_LOG(COMMON, "Rename: MoveFile failed on %s --> %s: %s", srcFilename.c_str(),
-            destFilename.c_str(), GetLastErrorString().c_str());
-#else
-  if (rename(srcFilename.c_str(), destFilename.c_str()) == 0)
-    return true;
-  ERROR_LOG(COMMON, "Rename: rename failed on %s --> %s: %s", srcFilename.c_str(),
-            destFilename.c_str(), LastStrerrorString().c_str());
-#endif
-  return false;
-}
-
-#ifndef _WIN32
-static void FSyncPath(const char* path)
-{
-  int fd = open(path, O_RDONLY);
-  if (fd != -1)
-  {
-    fsync(fd);
-    close(fd);
-  }
-}
-#endif
-
-bool RenameSync(const std::string& srcFilename, const std::string& destFilename)
-{
-  if (!Rename(srcFilename, destFilename))
-    return false;
-#ifdef _WIN32
-  int fd = _topen(UTF8ToTStr(srcFilename).c_str(), _O_RDONLY);
-  if (fd != -1)
-  {
-    _commit(fd);
-    close(fd);
-  }
-#else
-  char* path = strdup(srcFilename.c_str());
-  FSyncPath(path);
-  FSyncPath(dirname(path));
-  free(path);
-  path = strdup(destFilename.c_str());
-  FSyncPath(dirname(path));
-  free(path);
-#endif
-  return true;
-}
-
-// copies file source_path to destination_path, returns true on success
-bool Copy(const std::string& source_path, const std::string& destination_path)
-{
-  INFO_LOG(COMMON, "Copy: %s --> %s", source_path.c_str(), destination_path.c_str());
-#ifdef _WIN32
-  if (CopyFile(UTF8ToTStr(source_path).c_str(), UTF8ToTStr(destination_path).c_str(), FALSE))
-    return true;
-
-  ERROR_LOG(COMMON, "Copy: failed %s --> %s: %s", source_path.c_str(), destination_path.c_str(),
-            GetLastErrorString().c_str());
-  return false;
-#else
-  std::ifstream source{source_path, std::ios::binary};
-  std::ofstream destination{destination_path, std::ios::binary};
-  destination << source.rdbuf();
-  return source.good() && destination.good();
-#endif
-}
-
-// Returns the size of a file (or returns 0 if the path isn't a file that exists)
-u64 GetSize(const std::string& path)
-{
-  return FileInfo(path).GetSize();
-}
-
-// Overloaded GetSize, accepts file descriptor
-u64 GetSize(const int fd)
-{
-  return FileInfo(fd).GetSize();
-}
-
-// Overloaded GetSize, accepts FILE*
-u64 GetSize(FILE* f)
-{
-  // can't use off_t here because it can be 32-bit
-  u64 pos = ftello(f);
-  if (fseeko(f, 0, SEEK_END) != 0)
-  {
-    ERROR_LOG(COMMON, "GetSize: seek failed %p: %s", f, LastStrerrorString().c_str());
-    return 0;
-  }
-
-  u64 size = ftello(f);
-  if ((size != pos) && (fseeko(f, pos, SEEK_SET) != 0))
-  {
-    ERROR_LOG(COMMON, "GetSize: seek failed %p: %s", f, LastStrerrorString().c_str());
-    return 0;
-  }
-
-  return size;
-}
-
-// creates an empty file filename, returns true on success
-bool CreateEmptyFile(const std::string& filename)
-{
-  INFO_LOG(COMMON, "CreateEmptyFile: %s", filename.c_str());
-
-  if (!File::IOFile(filename, "wb"))
-  {
-    ERROR_LOG(COMMON, "CreateEmptyFile: failed %s: %s", filename.c_str(),
-              LastStrerrorString().c_str());
-    return false;
-  }
-
-  return true;
-}
-
-// Recursive or non-recursive list of files and directories under directory.
-FSTEntry ScanDirectoryTree(const std::string& directory, bool recursive)
-{
-  INFO_LOG(COMMON, "ScanDirectoryTree: directory %s", directory.c_str());
-  FSTEntry parent_entry;
-  parent_entry.physicalName = directory;
-  parent_entry.isDirectory = true;
-  parent_entry.size = 0;
-#ifdef _WIN32
-  // Find the first file in the directory.
-  WIN32_FIND_DATA ffd;
-
-  HANDLE hFind = FindFirstFile(UTF8ToTStr(directory + "\\*").c_str(), &ffd);
-  if (hFind == INVALID_HANDLE_VALUE)
-  {
-    FindClose(hFind);
-    return parent_entry;
-  }
-  // Windows loop
-  do
-  {
-    const std::string virtual_name(TStrToUTF8(ffd.cFileName));
-#else
-  DIR* dirp = opendir(directory.c_str());
-  if (!dirp)
-    return parent_entry;
-
-  // non Windows loop
-  while (dirent* result = readdir(dirp))
-  {
-    const std::string virtual_name(result->d_name);
-#endif
-    if (virtual_name == "." || virtual_name == "..")
-      continue;
-    auto physical_name = directory + DIR_SEP + virtual_name;
-    FSTEntry entry;
-    const FileInfo file_info(physical_name);
-    entry.isDirectory = file_info.IsDirectory();
-    if (entry.isDirectory)
-    {
-      if (recursive)
-        entry = ScanDirectoryTree(physical_name, true);
-      else
-        entry.size = 0;
-      parent_entry.size += entry.size;
-    }
-    else
-    {
-      entry.size = file_info.GetSize();
-    }
-    entry.virtualName = virtual_name;
-    entry.physicalName = physical_name;
-
-    ++parent_entry.size;
-    // Push into the tree
-    parent_entry.children.push_back(entry);
-#ifdef _WIN32
-  } while (FindNextFile(hFind, &ffd) != 0);
-  FindClose(hFind);
-#else
-  }
-  closedir(dirp);
-#endif
-
-  return parent_entry;
-}
-
-// Deletes the given directory and anything under it. Returns true on success.
-bool DeleteDirRecursively(const std::string& directory)
-{
-  INFO_LOG(COMMON, "DeleteDirRecursively: %s", directory.c_str());
-  bool success = true;
-
-#ifdef _WIN32
-  // Find the first file in the directory.
-  WIN32_FIND_DATA ffd;
-  HANDLE hFind = FindFirstFile(UTF8ToTStr(directory + "\\*").c_str(), &ffd);
-
-  if (hFind == INVALID_HANDLE_VALUE)
-  {
-    FindClose(hFind);
-    return false;
-  }
-
-  // Windows loop
-  do
-  {
-    const std::string virtualName(TStrToUTF8(ffd.cFileName));
-#else
-  DIR* dirp = opendir(directory.c_str());
-  if (!dirp)
-    return false;
-
-  // non Windows loop
-  while (dirent* result = readdir(dirp))
-  {
-    const std::string virtualName = result->d_name;
-#endif
-
-    // check for "." and ".."
-    if (((virtualName[0] == '.') && (virtualName[1] == '\0')) ||
-        ((virtualName[0] == '.') && (virtualName[1] == '.') && (virtualName[2] == '\0')))
-      continue;
-
-    std::string newPath = directory + DIR_SEP_CHR + virtualName;
-    if (IsDirectory(newPath))
-    {
-      if (!DeleteDirRecursively(newPath))
-      {
-        success = false;
-        break;
-      }
-    }
-    else
-    {
-      if (!File::Delete(newPath))
-      {
-        success = false;
-        break;
-      }
-    }
-
-#ifdef _WIN32
-  } while (FindNextFile(hFind, &ffd) != 0);
-  FindClose(hFind);
-#else
-  }
-  closedir(dirp);
-#endif
-  if (success)
-    File::DeleteDir(directory);
-
-  return success;
-}
-
-// Create directory and copy contents (does not overwrite existing files)
-void CopyDir(const std::string& source_path, const std::string& dest_path, bool destructive)
-{
-  if (source_path == dest_path)
-    return;
-  if (!Exists(source_path))
-    return;
-  if (!Exists(dest_path))
-    File::CreateFullPath(dest_path);
-
-#ifdef _WIN32
-  WIN32_FIND_DATA ffd;
-  HANDLE hFind = FindFirstFile(UTF8ToTStr(source_path + "\\*").c_str(), &ffd);
-
-  if (hFind == INVALID_HANDLE_VALUE)
-  {
-    FindClose(hFind);
-    return;
-  }
-
-  do
-  {
-    const std::string virtualName(TStrToUTF8(ffd.cFileName));
-#else
-  DIR* dirp = opendir(source_path.c_str());
-  if (!dirp)
-    return;
-
-  while (dirent* result = readdir(dirp))
-  {
-    const std::string virtualName(result->d_name);
-#endif
-    // check for "." and ".."
-    if (virtualName == "." || virtualName == "..")
-      continue;
-
-    std::string source = source_path + DIR_SEP + virtualName;
-    std::string dest = dest_path + DIR_SEP + virtualName;
-    if (IsDirectory(source))
-    {
-      if (!Exists(dest))
-        File::CreateFullPath(dest + DIR_SEP);
-      CopyDir(source, dest, destructive);
-    }
-    else if (!destructive && !Exists(dest))
-    {
-      Copy(source, dest);
-    }
-    else if (destructive)
-    {
-      Rename(source, dest);
-    }
-#ifdef _WIN32
-  } while (FindNextFile(hFind, &ffd) != 0);
-  FindClose(hFind);
-#else
-  }
-  closedir(dirp);
-#endif
-}
-
-// Returns the current directory
-std::string GetCurrentDir()
-{
-  // Get the current working directory (getcwd uses malloc)
-  char* dir = __getcwd(nullptr, 0);
-  if (!dir)
-  {
-    ERROR_LOG(COMMON, "GetCurrentDirectory failed: %s", LastStrerrorString().c_str());
-    return nullptr;
-  }
-  std::string strDir = dir;
-  free(dir);
-  return strDir;
-}
-
-// Sets the current directory to the given directory
-bool SetCurrentDir(const std::string& directory)
-{
-  return __chdir(directory.c_str()) == 0;
-}
-
-std::string CreateTempDir()
-{
-#ifdef _WIN32
-  TCHAR temp[MAX_PATH];
-  if (!GetTempPath(MAX_PATH, temp))
-    return "";
-
-  GUID guid;
-  CoCreateGuid(&guid);
-  TCHAR tguid[40];
-  StringFromGUID2(guid, tguid, 39);
-  tguid[39] = 0;
-  std::string dir = TStrToUTF8(temp) + "/" + TStrToUTF8(tguid);
-  if (!CreateDir(dir))
-    return "";
-  dir = ReplaceAll(dir, "\\", DIR_SEP);
-  return dir;
-#else
-  const char* base = getenv("TMPDIR") ?: "/tmp";
-  std::string path = std::string(base) + "/DolphinWii.XXXXXX";
-  if (!mkdtemp(&path[0]))
-    return "";
-  return path;
-#endif
-}
-
-std::string GetTempFilenameForAtomicWrite(std::string path)
-{
-#ifdef _WIN32
-  std::unique_ptr<TCHAR[], decltype(&std::free)> absbuf{
-      _tfullpath(nullptr, UTF8ToTStr(path).c_str(), 0), std::free};
-  if (absbuf != nullptr)
-  {
-    path = TStrToUTF8(absbuf.get());
-  }
-#else
-  char absbuf[PATH_MAX];
-  if (realpath(path.c_str(), absbuf) != nullptr)
-    path = absbuf;
-#endif
-  return std::move(path) + ".xxx";
-}
-
-#if defined(__APPLE__)
-std::string GetBundleDirectory()
-{
-  //OpenEmu
-  GET_CURRENT_OR_RETURN();
-
-  return [current getBundlePath];
-}
-#endif
-
-std::string GetExePath()
-{
-  static const std::string dolphin_path = [] {
-    std::string result;
-#ifdef _WIN32
-    auto dolphin_exe_path = GetModuleName(nullptr);
-    if (dolphin_exe_path)
-    {
-      std::unique_ptr<TCHAR[], decltype(&std::free)> dolphin_exe_expanded_path{
-          _tfullpath(nullptr, dolphin_exe_path->c_str(), 0), std::free};
-      if (dolphin_exe_expanded_path)
-      {
-        result = TStrToUTF8(dolphin_exe_expanded_path.get());
-      }
-      else
-      {
-        result = TStrToUTF8(*dolphin_exe_path);
-      }
-    }
-#elif defined(__APPLE__)
-    result = GetBundleDirectory();
-    result = result.substr(0, result.find_last_of("Dolphin.app/Contents/MacOS") + 1);
-#else
-    char dolphin_exe_path[PATH_MAX];
-    ssize_t len = ::readlink("/proc/self/exe", dolphin_exe_path, sizeof(dolphin_exe_path));
-    if (len == -1 || len == sizeof(dolphin_exe_path))
-    {
-      len = 0;
-    }
-    dolphin_exe_path[len] = '\0';
-    result = dolphin_exe_path;
-#endif
-    return result;
-  }();
-  return dolphin_path;
-}
-
-std::string GetExeDirectory()
-{
-  std::string exe_path = GetExePath();
-#ifdef _WIN32
-  return exe_path.substr(0, exe_path.rfind('\\'));
-#else
-  return exe_path.substr(0, exe_path.rfind('/'));
-#endif
-}
-
-std::string GetSysDirectory()
-{
-  std::string sysDir;
-
-#if defined(_WIN32) || defined(LINUX_LOCAL_DEV)
-#define SYSDATA_DIR "Sys"
-#elif defined __APPLE__
-    //openemu
-#define SYSDATA_DIR "Sys"
-#else
-#ifdef DATA_DIR
-#define SYSDATA_DIR DATA_DIR "sys"
-#else
-#define SYSDATA_DIR "sys"
-#endif
-#endif
-
-#if defined(__APPLE__)
-  sysDir = GetBundleDirectory() + DIR_SEP + SYSDATA_DIR;
-#elif defined(_WIN32) || defined(LINUX_LOCAL_DEV)
-  sysDir = GetExeDirectory() + DIR_SEP + SYSDATA_DIR;
-#elif defined ANDROID
-  sysDir = s_android_sys_directory;
-  ASSERT_MSG(COMMON, !sysDir.empty(), "Sys directory has not been set");
-#else
-  sysDir = SYSDATA_DIR;
-#endif
-  sysDir += DIR_SEP;
-
-  INFO_LOG(COMMON, "GetSysDirectory: Setting to %s:", sysDir.c_str());
-  return sysDir;
-}
-
-#ifdef ANDROID
-void SetSysDirectory(const std::string& path)
-{
-  INFO_LOG(COMMON, "Setting Sys directory to %s", path.c_str());
-  s_android_sys_directory = path;
-}
-#endif
-
-static std::string s_user_paths[NUM_PATH_INDICES];
-static void RebuildUserDirectories(unsigned int dir_index)
-{
-  switch (dir_index)
-  {
-  case D_USER_IDX:
-    s_user_paths[D_GCUSER_IDX] = s_user_paths[D_USER_IDX] + GC_USER_DIR DIR_SEP;
-    s_user_paths[D_WIIROOT_IDX] = s_user_paths[D_USER_IDX] + WII_USER_DIR;
-    s_user_paths[D_CONFIG_IDX] = s_user_paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
-    s_user_paths[D_GAMESETTINGS_IDX] = s_user_paths[D_USER_IDX] + GAMESETTINGS_DIR DIR_SEP;
-    s_user_paths[D_MAPS_IDX] = s_user_paths[D_USER_IDX] + MAPS_DIR DIR_SEP;
-    s_user_paths[D_CACHE_IDX] = s_user_paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
-    s_user_paths[D_COVERCACHE_IDX] = s_user_paths[D_CACHE_IDX] + COVERCACHE_DIR DIR_SEP;
-    s_user_paths[D_REDUMPCACHE_IDX] = s_user_paths[D_CACHE_IDX] + REDUMPCACHE_DIR DIR_SEP;
-    s_user_paths[D_SHADERCACHE_IDX] = s_user_paths[D_CACHE_IDX] + SHADERCACHE_DIR DIR_SEP;
-    s_user_paths[D_SHADERS_IDX] = s_user_paths[D_USER_IDX] + SHADERS_DIR DIR_SEP;
-    s_user_paths[D_STATESAVES_IDX] = s_user_paths[D_USER_IDX] + STATESAVES_DIR DIR_SEP;
-    s_user_paths[D_SCREENSHOTS_IDX] = s_user_paths[D_USER_IDX] + SCREENSHOTS_DIR DIR_SEP;
-    s_user_paths[D_LOAD_IDX] = s_user_paths[D_USER_IDX] + LOAD_DIR DIR_SEP;
-    s_user_paths[D_HIRESTEXTURES_IDX] = s_user_paths[D_LOAD_IDX] + HIRES_TEXTURES_DIR DIR_SEP;
-    s_user_paths[D_DUMP_IDX] = s_user_paths[D_USER_IDX] + DUMP_DIR DIR_SEP;
-    s_user_paths[D_DUMPFRAMES_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_FRAMES_DIR DIR_SEP;
-    s_user_paths[D_DUMPOBJECTS_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_OBJECTS_DIR DIR_SEP;
-    s_user_paths[D_DUMPAUDIO_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_AUDIO_DIR DIR_SEP;
-    s_user_paths[D_DUMPTEXTURES_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_TEXTURES_DIR DIR_SEP;
-    s_user_paths[D_DUMPDSP_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_DSP_DIR DIR_SEP;
-    s_user_paths[D_DUMPSSL_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_SSL_DIR DIR_SEP;
-    s_user_paths[D_LOGS_IDX] = s_user_paths[D_USER_IDX] + LOGS_DIR DIR_SEP;
-    s_user_paths[D_MAILLOGS_IDX] = s_user_paths[D_LOGS_IDX] + MAIL_LOGS_DIR DIR_SEP;
-    s_user_paths[D_THEMES_IDX] = s_user_paths[D_USER_IDX] + THEMES_DIR DIR_SEP;
-    s_user_paths[D_STYLES_IDX] = s_user_paths[D_USER_IDX] + STYLES_DIR DIR_SEP;
-    s_user_paths[D_PIPES_IDX] = s_user_paths[D_USER_IDX] + PIPES_DIR DIR_SEP;
-    s_user_paths[D_WFSROOT_IDX] = s_user_paths[D_USER_IDX] + WFSROOT_DIR DIR_SEP;
-    s_user_paths[D_BACKUP_IDX] = s_user_paths[D_USER_IDX] + BACKUP_DIR DIR_SEP;
-    s_user_paths[D_RESOURCEPACK_IDX] = s_user_paths[D_USER_IDX] + RESOURCEPACK_DIR DIR_SEP;
-    s_user_paths[F_DOLPHINCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + DOLPHIN_CONFIG;
-    s_user_paths[F_GCPADCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + GCPAD_CONFIG;
-    s_user_paths[F_WIIPADCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + WIIPAD_CONFIG;
-    s_user_paths[F_GCKEYBOARDCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + GCKEYBOARD_CONFIG;
-    s_user_paths[F_GFXCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + GFX_CONFIG;
-    s_user_paths[F_DEBUGGERCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + DEBUGGER_CONFIG;
-    s_user_paths[F_LOGGERCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + LOGGER_CONFIG;
-    s_user_paths[F_DUALSHOCKUDPCLIENTCONFIG_IDX] =
-        s_user_paths[D_CONFIG_IDX] + DUALSHOCKUDPCLIENT_CONFIG;
-    s_user_paths[F_MAINLOG_IDX] = s_user_paths[D_LOGS_IDX] + MAIN_LOG;
-    s_user_paths[F_MEM1DUMP_IDX] = s_user_paths[D_DUMP_IDX] + MEM1_DUMP;
-    s_user_paths[F_MEM2DUMP_IDX] = s_user_paths[D_DUMP_IDX] + MEM2_DUMP;
-    s_user_paths[F_ARAMDUMP_IDX] = s_user_paths[D_DUMP_IDX] + ARAM_DUMP;
-    s_user_paths[F_FAKEVMEMDUMP_IDX] = s_user_paths[D_DUMP_IDX] + FAKEVMEM_DUMP;
-    s_user_paths[F_GCSRAM_IDX] = s_user_paths[D_GCUSER_IDX] + GC_SRAM;
-    s_user_paths[F_WIISDCARD_IDX] = s_user_paths[D_WIIROOT_IDX] + DIR_SEP WII_SDCARD;
-
-    s_user_paths[D_MEMORYWATCHER_IDX] = s_user_paths[D_USER_IDX] + MEMORYWATCHER_DIR DIR_SEP;
-    s_user_paths[F_MEMORYWATCHERLOCATIONS_IDX] =
-        s_user_paths[D_MEMORYWATCHER_IDX] + MEMORYWATCHER_LOCATIONS;
-    s_user_paths[F_MEMORYWATCHERSOCKET_IDX] =
-        s_user_paths[D_MEMORYWATCHER_IDX] + MEMORYWATCHER_SOCKET;
-
-    // The shader cache has moved to the cache directory, so remove the old one.
-    // TODO: remove that someday.
-    File::DeleteDirRecursively(s_user_paths[D_USER_IDX] + SHADERCACHE_LEGACY_DIR DIR_SEP);
-    break;
-
-  case D_CONFIG_IDX:
-    s_user_paths[F_DOLPHINCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + DOLPHIN_CONFIG;
-    s_user_paths[F_GCPADCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + GCPAD_CONFIG;
-    s_user_paths[F_WIIPADCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + WIIPAD_CONFIG;
-    s_user_paths[F_GFXCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + GFX_CONFIG;
-    s_user_paths[F_DEBUGGERCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + DEBUGGER_CONFIG;
-    s_user_paths[F_LOGGERCONFIG_IDX] = s_user_paths[D_CONFIG_IDX] + LOGGER_CONFIG;
-    break;
-
-  case D_CACHE_IDX:
-    s_user_paths[D_COVERCACHE_IDX] = s_user_paths[D_CACHE_IDX] + COVERCACHE_DIR DIR_SEP;
-    s_user_paths[D_REDUMPCACHE_IDX] = s_user_paths[D_CACHE_IDX] + REDUMPCACHE_DIR DIR_SEP;
-    s_user_paths[D_SHADERCACHE_IDX] = s_user_paths[D_CACHE_IDX] + SHADERCACHE_DIR DIR_SEP;
-    break;
-
-  case D_GCUSER_IDX:
-    s_user_paths[F_GCSRAM_IDX] = s_user_paths[D_GCUSER_IDX] + GC_SRAM;
-    break;
-
-  case D_DUMP_IDX:
-    s_user_paths[D_DUMPFRAMES_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_FRAMES_DIR DIR_SEP;
-    s_user_paths[D_DUMPOBJECTS_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_OBJECTS_DIR DIR_SEP;
-    s_user_paths[D_DUMPAUDIO_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_AUDIO_DIR DIR_SEP;
-    s_user_paths[D_DUMPTEXTURES_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_TEXTURES_DIR DIR_SEP;
-    s_user_paths[D_DUMPDSP_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_DSP_DIR DIR_SEP;
-    s_user_paths[D_DUMPSSL_IDX] = s_user_paths[D_DUMP_IDX] + DUMP_SSL_DIR DIR_SEP;
-    s_user_paths[F_MEM1DUMP_IDX] = s_user_paths[D_DUMP_IDX] + MEM1_DUMP;
-    s_user_paths[F_MEM2DUMP_IDX] = s_user_paths[D_DUMP_IDX] + MEM2_DUMP;
-    s_user_paths[F_ARAMDUMP_IDX] = s_user_paths[D_DUMP_IDX] + ARAM_DUMP;
-    s_user_paths[F_FAKEVMEMDUMP_IDX] = s_user_paths[D_DUMP_IDX] + FAKEVMEM_DUMP;
-    break;
-
-  case D_LOGS_IDX:
-    s_user_paths[D_MAILLOGS_IDX] = s_user_paths[D_LOGS_IDX] + MAIL_LOGS_DIR DIR_SEP;
-    s_user_paths[F_MAINLOG_IDX] = s_user_paths[D_LOGS_IDX] + MAIN_LOG;
-    break;
-
-  case D_LOAD_IDX:
-    s_user_paths[D_HIRESTEXTURES_IDX] = s_user_paths[D_LOAD_IDX] + HIRES_TEXTURES_DIR DIR_SEP;
-    break;
-  }
-}
-
-// Gets a set user directory path
-// Don't call prior to setting the base user directory
-const std::string& GetUserPath(unsigned int dir_index)
-{
-  return s_user_paths[dir_index];
-}
-
-// Sets a user directory path
-// Rebuilds internal directory structure to compensate for the new directory
-void SetUserPath(unsigned int dir_index, const std::string& path)
-{
-  if (path.empty())
-    return;
-
-  s_user_paths[dir_index] = path;
-  RebuildUserDirectories(dir_index);
-}
-
-std::string GetThemeDir(const std::string& theme_name)
-{
-  std::string dir = File::GetUserPath(D_THEMES_IDX) + theme_name + "/";
-  if (Exists(dir))
-    return dir;
-
-  // If the theme doesn't exist in the user dir, load from shared directory
-  dir = GetSysDirectory() + THEMES_DIR "/" + theme_name + "/";
-  if (Exists(dir))
-    return dir;
-
-  // If the theme doesn't exist at all, load the default theme
-  return GetSysDirectory() + THEMES_DIR "/" DEFAULT_THEME_DIR "/";
-}
-
-bool WriteStringToFile(const std::string& filename, std::string_view str)
-{
-  return File::IOFile(filename, "wb").WriteBytes(str.data(), str.size());
-}
-
-bool ReadFileToString(const std::string& filename, std::string& str)
-{
-  File::IOFile file(filename, "rb");
-
-  if (!file)
-    return false;
-
-  str.resize(file.GetSize());
-  return file.ReadArray(str.data(), str.size());
-}
-
-}  // namespace File

Compatibility/Core/GraphicsSettings.cpp

@@ -0,0 +1,157 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "Core/Config/GraphicsSettings.h"
+
+#include <string>
+
+#include "Common/Config/Config.h"
+#include "VideoCommon/VideoConfig.h"
+
+namespace Config
+{
+// Configuration Information
+
+// Graphics.Hardware
+
+const Info<bool> GFX_VSYNC{{System::GFX, "Hardware", "VSync"}, false};
+const Info<int> GFX_ADAPTER{{System::GFX, "Hardware", "Adapter"}, 0};
+
+// Graphics.Settings
+
+const Info<bool> GFX_WIDESCREEN_HACK{{System::GFX, "Settings", "wideScreenHack"}, false};
+//OpenEmu change apect to stretch
+const Info<AspectMode> GFX_ASPECT_RATIO{{System::GFX, "Settings", "AspectRatio"}, AspectMode::Stretch};
+const Info<AspectMode> GFX_SUGGESTED_ASPECT_RATIO{{System::GFX, "Settings", "SuggestedAspectRatio"},
+                                                  AspectMode::Auto};
+const Info<bool> GFX_CROP{{System::GFX, "Settings", "Crop"}, false};
+const Info<int> GFX_SAFE_TEXTURE_CACHE_COLOR_SAMPLES{
+    {System::GFX, "Settings", "SafeTextureCacheColorSamples"}, 128};
+const Info<bool> GFX_SHOW_FPS{{System::GFX, "Settings", "ShowFPS"}, false};
+const Info<bool> GFX_SHOW_NETPLAY_PING{{System::GFX, "Settings", "ShowNetPlayPing"}, false};
+const Info<bool> GFX_SHOW_NETPLAY_MESSAGES{{System::GFX, "Settings", "ShowNetPlayMessages"}, false};
+const Info<bool> GFX_LOG_RENDER_TIME_TO_FILE{{System::GFX, "Settings", "LogRenderTimeToFile"},
+                                             false};
+const Info<bool> GFX_OVERLAY_STATS{{System::GFX, "Settings", "OverlayStats"}, false};
+const Info<bool> GFX_OVERLAY_PROJ_STATS{{System::GFX, "Settings", "OverlayProjStats"}, false};
+const Info<bool> GFX_DUMP_TEXTURES{{System::GFX, "Settings", "DumpTextures"}, false};
+const Info<bool> GFX_DUMP_MIP_TEXTURES{{System::GFX, "Settings", "DumpMipTextures"}, true};
+const Info<bool> GFX_DUMP_BASE_TEXTURES{{System::GFX, "Settings", "DumpBaseTextures"}, true};
+const Info<bool> GFX_HIRES_TEXTURES{{System::GFX, "Settings", "HiresTextures"}, false};
+const Info<bool> GFX_CACHE_HIRES_TEXTURES{{System::GFX, "Settings", "CacheHiresTextures"}, false};
+const Info<bool> GFX_DUMP_EFB_TARGET{{System::GFX, "Settings", "DumpEFBTarget"}, false};
+const Info<bool> GFX_DUMP_XFB_TARGET{{System::GFX, "Settings", "DumpXFBTarget"}, false};
+const Info<bool> GFX_DUMP_FRAMES_AS_IMAGES{{System::GFX, "Settings", "DumpFramesAsImages"}, false};
+const Info<bool> GFX_USE_FFV1{{System::GFX, "Settings", "UseFFV1"}, false};
+const Info<std::string> GFX_DUMP_FORMAT{{System::GFX, "Settings", "DumpFormat"}, "avi"};
+const Info<std::string> GFX_DUMP_CODEC{{System::GFX, "Settings", "DumpCodec"}, ""};
+const Info<std::string> GFX_DUMP_ENCODER{{System::GFX, "Settings", "DumpEncoder"}, ""};
+const Info<std::string> GFX_DUMP_PATH{{System::GFX, "Settings", "DumpPath"}, ""};
+const Info<int> GFX_BITRATE_KBPS{{System::GFX, "Settings", "BitrateKbps"}, 25000};
+const Info<bool> GFX_INTERNAL_RESOLUTION_FRAME_DUMPS{
+    {System::GFX, "Settings", "InternalResolutionFrameDumps"}, false};
+const Info<bool> GFX_ENABLE_GPU_TEXTURE_DECODING{
+    {System::GFX, "Settings", "EnableGPUTextureDecoding"}, false};
+const Info<bool> GFX_ENABLE_PIXEL_LIGHTING{{System::GFX, "Settings", "EnablePixelLighting"}, false};
+const Info<bool> GFX_FAST_DEPTH_CALC{{System::GFX, "Settings", "FastDepthCalc"}, true};
+const Info<u32> GFX_MSAA{{System::GFX, "Settings", "MSAA"}, 1};
+const Info<bool> GFX_SSAA{{System::GFX, "Settings", "SSAA"}, false};
+const Info<int> GFX_EFB_SCALE{{System::GFX, "Settings", "InternalResolution"}, 1};
+const Info<int> GFX_MAX_EFB_SCALE{{System::GFX, "Settings", "MaxInternalResolution"}, 8};
+const Info<bool> GFX_TEXFMT_OVERLAY_ENABLE{{System::GFX, "Settings", "TexFmtOverlayEnable"}, false};
+const Info<bool> GFX_TEXFMT_OVERLAY_CENTER{{System::GFX, "Settings", "TexFmtOverlayCenter"}, false};
+const Info<bool> GFX_ENABLE_WIREFRAME{{System::GFX, "Settings", "WireFrame"}, false};
+const Info<bool> GFX_DISABLE_FOG{{System::GFX, "Settings", "DisableFog"}, false};
+const Info<bool> GFX_BORDERLESS_FULLSCREEN{{System::GFX, "Settings", "BorderlessFullscreen"},
+                                           false};
+const Info<bool> GFX_ENABLE_VALIDATION_LAYER{{System::GFX, "Settings", "EnableValidationLayer"},
+                                             false};
+
+#if defined(ANDROID)
+const Info<bool> GFX_BACKEND_MULTITHREADING{{System::GFX, "Settings", "BackendMultithreading"},
+                                            false};
+const Info<int> GFX_COMMAND_BUFFER_EXECUTE_INTERVAL{
+    {System::GFX, "Settings", "CommandBufferExecuteInterval"}, 0};
+#else
+const Info<bool> GFX_BACKEND_MULTITHREADING{{System::GFX, "Settings", "BackendMultithreading"},
+                                            true};
+const Info<int> GFX_COMMAND_BUFFER_EXECUTE_INTERVAL{
+    {System::GFX, "Settings", "CommandBufferExecuteInterval"}, 100};
+#endif
+
+//////OpenEmu change ShaderCache True, WaitForShaders false, Compiler and Precompiler thread -1
+const Info<bool> GFX_SHADER_CACHE{{System::GFX, "Settings", "ShaderCache"}, true};
+const Info<bool> GFX_WAIT_FOR_SHADERS_BEFORE_STARTING{
+    {System::GFX, "Settings", "WaitForShadersBeforeStarting"}, false};
+const Info<ShaderCompilationMode> GFX_SHADER_COMPILATION_MODE{
+    {System::GFX, "Settings", "ShaderCompilationMode"}, ShaderCompilationMode::Synchronous};
+const Info<int> GFX_SHADER_COMPILER_THREADS{{System::GFX, "Settings", "ShaderCompilerThreads"}, -1};
+const Info<int> GFX_SHADER_PRECOMPILER_THREADS{
+    {System::GFX, "Settings", "ShaderPrecompilerThreads"}, -1};
+const Info<bool> GFX_SAVE_TEXTURE_CACHE_TO_STATE{
+    {System::GFX, "Settings", "SaveTextureCacheToState"}, true};
+
+const Info<bool> GFX_SW_ZCOMPLOC{{System::GFX, "Settings", "SWZComploc"}, true};
+const Info<bool> GFX_SW_ZFREEZE{{System::GFX, "Settings", "SWZFreeze"}, true};
+const Info<bool> GFX_SW_DUMP_OBJECTS{{System::GFX, "Settings", "SWDumpObjects"}, false};
+const Info<bool> GFX_SW_DUMP_TEV_STAGES{{System::GFX, "Settings", "SWDumpTevStages"}, false};
+const Info<bool> GFX_SW_DUMP_TEV_TEX_FETCHES{{System::GFX, "Settings", "SWDumpTevTexFetches"},
+                                             false};
+const Info<int> GFX_SW_DRAW_START{{System::GFX, "Settings", "SWDrawStart"}, 0};
+const Info<int> GFX_SW_DRAW_END{{System::GFX, "Settings", "SWDrawEnd"}, 100000};
+
+const Info<bool> GFX_PREFER_GLES{{System::GFX, "Settings", "PreferGLES"}, false};
+
+// Graphics.Enhancements
+
+const Info<bool> GFX_ENHANCE_FORCE_FILTERING{{System::GFX, "Enhancements", "ForceFiltering"},
+                                             false};
+const Info<int> GFX_ENHANCE_MAX_ANISOTROPY{{System::GFX, "Enhancements", "MaxAnisotropy"}, 0};
+const Info<std::string> GFX_ENHANCE_POST_SHADER{
+    {System::GFX, "Enhancements", "PostProcessingShader"}, ""};
+const Info<bool> GFX_ENHANCE_FORCE_TRUE_COLOR{{System::GFX, "Enhancements", "ForceTrueColor"},
+                                              true};
+const Info<bool> GFX_ENHANCE_DISABLE_COPY_FILTER{{System::GFX, "Enhancements", "DisableCopyFilter"},
+                                                 true};
+const Info<bool> GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION{
+    {System::GFX, "Enhancements", "ArbitraryMipmapDetection"}, true};
+const Info<float> GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION_THRESHOLD{
+    {System::GFX, "Enhancements", "ArbitraryMipmapDetectionThreshold"}, 14.0f};
+
+// Graphics.Stereoscopy
+
+const Info<StereoMode> GFX_STEREO_MODE{{System::GFX, "Stereoscopy", "StereoMode"}, StereoMode::Off};
+const Info<int> GFX_STEREO_DEPTH{{System::GFX, "Stereoscopy", "StereoDepth"}, 20};
+const Info<int> GFX_STEREO_CONVERGENCE_PERCENTAGE{
+    {System::GFX, "Stereoscopy", "StereoConvergencePercentage"}, 100};
+const Info<bool> GFX_STEREO_SWAP_EYES{{System::GFX, "Stereoscopy", "StereoSwapEyes"}, false};
+const Info<int> GFX_STEREO_CONVERGENCE{{System::GFX, "Stereoscopy", "StereoConvergence"}, 20};
+const Info<bool> GFX_STEREO_EFB_MONO_DEPTH{{System::GFX, "Stereoscopy", "StereoEFBMonoDepth"},
+                                           false};
+const Info<int> GFX_STEREO_DEPTH_PERCENTAGE{{System::GFX, "Stereoscopy", "StereoDepthPercentage"},
+                                            100};
+
+// Graphics.Hacks
+
+const Info<bool> GFX_HACK_EFB_ACCESS_ENABLE{{System::GFX, "Hacks", "EFBAccessEnable"}, true};
+const Info<bool> GFX_HACK_EFB_DEFER_INVALIDATION{
+    {System::GFX, "Hacks", "EFBAccessDeferInvalidation"}, false};
+const Info<int> GFX_HACK_EFB_ACCESS_TILE_SIZE{{System::GFX, "Hacks", "EFBAccessTileSize"}, 64};
+const Info<bool> GFX_HACK_BBOX_ENABLE{{System::GFX, "Hacks", "BBoxEnable"}, false};
+const Info<bool> GFX_HACK_FORCE_PROGRESSIVE{{System::GFX, "Hacks", "ForceProgressive"}, true};
+const Info<bool> GFX_HACK_SKIP_EFB_COPY_TO_RAM{{System::GFX, "Hacks", "EFBToTextureEnable"}, true};
+const Info<bool> GFX_HACK_SKIP_XFB_COPY_TO_RAM{{System::GFX, "Hacks", "XFBToTextureEnable"}, true};
+const Info<bool> GFX_HACK_DISABLE_COPY_TO_VRAM{{System::GFX, "Hacks", "DisableCopyToVRAM"}, false};
+const Info<bool> GFX_HACK_DEFER_EFB_COPIES{{System::GFX, "Hacks", "DeferEFBCopies"}, true};
+const Info<bool> GFX_HACK_IMMEDIATE_XFB{{System::GFX, "Hacks", "ImmediateXFBEnable"}, false};
+const Info<bool> GFX_HACK_SKIP_DUPLICATE_XFBS{{System::GFX, "Hacks", "SkipDuplicateXFBs"}, true};
+const Info<bool> GFX_HACK_COPY_EFB_SCALED{{System::GFX, "Hacks", "EFBScaledCopy"}, true};
+const Info<bool> GFX_HACK_EFB_EMULATE_FORMAT_CHANGES{
+    {System::GFX, "Hacks", "EFBEmulateFormatChanges"}, false};
+const Info<bool> GFX_HACK_VERTEX_ROUDING{{System::GFX, "Hacks", "VertexRounding"}, false};
+
+// Graphics.GameSpecific
+
+const Info<bool> GFX_PERF_QUERIES_ENABLE{{System::GFX, "GameSpecific", "PerfQueriesEnable"}, false};
+}  // namespace Config

Compatibility/Core/JitARCH.cpp

@@ -0,0 +1,59 @@
+// Copyright (c) 2022, OpenEmu Team
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of the OpenEmu Team nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY OpenEmu Team ''AS IS'' AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL OpenEmu Team BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifdef __x86_64__
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64/Jit.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64/Jit64_Tables.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64/Jit_Branch.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64/Jit_FloatingPoint.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64/Jit_Integer.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64/Jit_LoadStore.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64/Jit_LoadStoreFloating.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64/Jit_LoadStorePaired.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64/Jit_Paired.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64/Jit_SystemRegisters.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64/JitAsm.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64Common/BlockCache.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64Common/ConstantPool.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64Common/EmuCodeBlock.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64Common/FarCodeCache.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64Common/Jit64AsmCommon.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/Jit64Common/TrampolineCache.cpp"
+#elif defined(__arm64__)
+#include "../../dolphin/Source/Core/Core/PowerPC/JitArm64/Jit_Util.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/JitArm64/Jit.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/JitArm64/JitArm64_Branch.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/JitArm64/JitArm64_FloatingPoint.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/JitArm64/JitArm64_Integer.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/JitArm64/JitArm64_LoadStore.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/JitArm64/JitArm64_LoadStoreFloating.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/JitArm64/JitArm64_LoadStorePaired.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/JitArm64/JitArm64_Paired.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/JitArm64/JitArm64_RegCache.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/JitArm64/JitArm64_SystemRegisters.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/JitArm64/JitArm64_Tables.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/JitArm64/JitArm64Cache.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/JitArm64/JitAsm.cpp"
+#include "../../dolphin/Source/Core/Core/PowerPC/JitArm64/JitArm64_BackPatch.cpp"
+#endif

Compatibility/Input/ControllerInterface.cpp

@@ -4,17 +4,47 @@
 
 #include "InputCommon/ControllerInterface/ControllerInterface.h"
 
+//OpenEmu undefine the OSX settings
 #ifdef CIFACE_USE_OSX
 #undef CIFACE_USE_OSX
 #endif
 
+//OpenEmu include OE input header
+#include "OpenEmuInput.h"
+
 #include <algorithm>
 
 #include "Common/Logging/Log.h"
+#include "Core/HW/WiimoteReal/WiimoteReal.h"
 
-#include "OpenEmuInput.h"
+#ifdef CIFACE_USE_WIN32
+#include "InputCommon/ControllerInterface/Win32/Win32.h"
+#endif
+#ifdef CIFACE_USE_XLIB
+#include "InputCommon/ControllerInterface/Xlib/XInput2.h"
+#endif
+#ifdef CIFACE_USE_OSX
+#include "InputCommon/ControllerInterface/OSX/OSX.h"
+#include "InputCommon/ControllerInterface/Quartz/Quartz.h"
+#endif
+#ifdef CIFACE_USE_SDL
+#include "InputCommon/ControllerInterface/SDL/SDL.h"
+#endif
+#ifdef CIFACE_USE_ANDROID
+#include "InputCommon/ControllerInterface/Android/Android.h"
+#endif
+#ifdef CIFACE_USE_EVDEV
+#include "InputCommon/ControllerInterface/evdev/evdev.h"
+#endif
+#ifdef CIFACE_USE_PIPES
+#include "InputCommon/ControllerInterface/Pipes/Pipes.h"
+#endif
+#ifdef CIFACE_USE_DUALSHOCKUDPCLIENT
+#include "InputCommon/ControllerInterface/DualShockUDPClient/DualShockUDPClient.h"
+#endif
 
 ControllerInterface g_controller_interface;
+static bool m_is_populating_devices = false;
 
 void ControllerInterface::Initialize(const WindowSystemInfo& wsi)
 {
@@ -28,27 +58,124 @@ void ControllerInterface::Initialize(const WindowSystemInfo& wsi)
 
   m_is_populating_devices = true;
 
-  Input::Openemu_Input_Init();
+#ifdef CIFACE_USE_WIN32
+  ciface::Win32::Init(wsi.render_window);
+#endif
+#ifdef CIFACE_USE_XLIB
+// nothing needed
+#endif
+#ifdef CIFACE_USE_OSX
+  if (m_wsi.type == WindowSystemType::MacOS)
+    ciface::OSX::Init(wsi.render_window);
+// nothing needed for Quartz
+#endif
+#ifdef CIFACE_USE_SDL
+  ciface::SDL::Init();
+#endif
+#ifdef CIFACE_USE_ANDROID
+// nothing needed
+#endif
+#ifdef CIFACE_USE_EVDEV
+  ciface::evdev::Init();
+#endif
+#ifdef CIFACE_USE_PIPES
+// nothing needed
+#endif
+#ifdef CIFACE_USE_DUALSHOCKUDPCLIENT
+  m_input_backends.emplace_back(ciface::DualShockUDPClient::CreateInputBackend(this));
+#endif
+
+    //OpenEmu initalize OpenEmu Input
+    Input::Openemu_Input_Init();
     
   RefreshDevices();
     
+    //OpenEmu set populating devices to false
     m_is_populating_devices = false;
 }
 
-void ControllerInterface::ChangeWindow(void* hwnd)
+static thread_local ciface::InputChannel tls_input_channel = ciface::InputChannel::Host;
+
+void ControllerInterface::SetCurrentInputChannel(ciface::InputChannel input_channel)
+{
+  tls_input_channel = input_channel;
+}
+
+ciface::InputChannel ControllerInterface::GetCurrentInputChannel()
+{
+  return tls_input_channel;
+}
+
+void ControllerInterface::PlatformPopulateDevices(std::function<void()> callback)
 {
   if (!m_is_init)
     return;
 
-  m_wsi.render_surface = hwnd;
+  std::lock_guard lk_population(m_devices_population_mutex);
+
+  m_populating_devices_counter.fetch_add(1);
+
+  callback();
+
+  if (m_populating_devices_counter.fetch_sub(1) == 1)
+    InvokeDevicesChangedCallbacks();
+}
+
+void ControllerInterface::ChangeWindow(void* hwnd, WindowChangeReason reason)
+{
+  if (!m_is_init)
+    return;
+
+  // This shouldn't use render_surface so no need to update it.
+  m_wsi.render_window = hwnd;
   RefreshDevices();
 }
 
-void ControllerInterface::RefreshDevices()
+void ControllerInterface::RefreshDevices(RefreshReason reason)
 {
   if (!m_is_init)
     return;
 
+  //OpenEmu comment out this section so we can maintain our controller input
+//  {
+//    std::lock_guard lk(m_devices_mutex);
+//    m_devices.clear();
+//  }
+
+  m_is_populating_devices = true;
+
+  // Make sure shared_ptr<Device> objects are released before repopulating.
+  InvokeDevicesChangedCallbacks();
+
+#ifdef CIFACE_USE_WIN32
+  ciface::Win32::PopulateDevices(m_wsi.render_window);
+#endif
+#ifdef CIFACE_USE_XLIB
+  if (m_wsi.type == WindowSystemType::X11)
+    ciface::XInput2::PopulateDevices(m_wsi.render_window);
+#endif
+#ifdef CIFACE_USE_OSX
+  if (m_wsi.type == WindowSystemType::MacOS)
+  {
+    ciface::OSX::PopulateDevices(m_wsi.render_window);
+    ciface::Quartz::PopulateDevices(m_wsi.render_window);
+  }
+#endif
+#ifdef CIFACE_USE_SDL
+  ciface::SDL::PopulateDevices();
+#endif
+#ifdef CIFACE_USE_ANDROID
+  ciface::Android::PopulateDevices();
+#endif
+#ifdef CIFACE_USE_EVDEV
+  ciface::evdev::PopulateDevices();
+#endif
+#ifdef CIFACE_USE_PIPES
+  ciface::Pipes::PopulateDevices();
+#endif
+
+  WiimoteReal::ProcessWiimotePool();
+
   m_is_populating_devices = false;
   InvokeDevicesChangedCallbacks();
 }
@@ -63,7 +190,7 @@ void ControllerInterface::Shutdown()
   m_is_init = false;
 
   {
-    std::lock_guard<std::mutex> lk(m_devices_mutex);
+    std::lock_guard lk(m_devices_mutex);
 
     for (const auto& d : m_devices)
     {
@@ -79,16 +206,35 @@ void ControllerInterface::Shutdown()
   // BEFORE we shutdown the backends.
   InvokeDevicesChangedCallbacks();
 
+#ifdef CIFACE_USE_WIN32
+  ciface::Win32::DeInit();
+#endif
+#ifdef CIFACE_USE_XLIB
+// nothing needed
+#endif
+#ifdef CIFACE_USE_OSX
+  ciface::OSX::DeInit();
+  ciface::Quartz::DeInit();
+#endif
+#ifdef CIFACE_USE_SDL
+  ciface::SDL::DeInit();
+#endif
+#ifdef CIFACE_USE_ANDROID
+// nothing needed
+#endif
+#ifdef CIFACE_USE_EVDEV
+  ciface::evdev::Shutdown();
+#endif
 }
 
-void ControllerInterface::AddDevice(std::shared_ptr<ciface::Core::Device> device)
+bool ControllerInterface::AddDevice(std::shared_ptr<ciface::Core::Device> device)
 {
   // If we are shutdown (or in process of shutting down) ignore this request:
   if (!m_is_init)
-    return;
+    return false;
 
   {
-    std::lock_guard<std::mutex> lk(m_devices_mutex);
+    std::lock_guard lk(m_devices_mutex);
 
     const auto is_id_in_use = [&device, this](int id) {
       return std::any_of(m_devices.begin(), m_devices.end(), [&device, &id](const auto& d) {
@@ -113,22 +259,23 @@ void ControllerInterface::AddDevice(std::shared_ptr<ciface::Core::Device> device
       device->SetId(id);
     }
 
-    NOTICE_LOG(SERIALINTERFACE, "Added device: %s", device->GetQualifiedName().c_str());
+    NOTICE_LOG_FMT(CONTROLLERINTERFACE, "Added device: {}", device->GetQualifiedName());
     m_devices.emplace_back(std::move(device));
   }
 
   if (!m_is_populating_devices)
     InvokeDevicesChangedCallbacks();
+  return true;
 }
 
-void ControllerInterface::RemoveDevice(std::function<bool(const ciface::Core::Device*)> callback)
+void ControllerInterface::RemoveDevice(std::function<bool(const ciface::Core::Device*)> callback, bool force_devices_release)
 {
   {
-    std::lock_guard<std::mutex> lk(m_devices_mutex);
+    std::lock_guard lk(m_devices_mutex);
     auto it = std::remove_if(m_devices.begin(), m_devices.end(), [&callback](const auto& dev) {
       if (callback(dev.get()))
       {
-        NOTICE_LOG(SERIALINTERFACE, "Removed device: %s", dev->GetQualifiedName().c_str());
+        NOTICE_LOG_FMT(SERIALINTERFACE, "Removed device: {}", dev->GetQualifiedName());
         return true;
       }
       return false;
@@ -146,12 +293,27 @@ void ControllerInterface::UpdateInput()
   // Don't block the UI or CPU thread (to avoid a short but noticeable frame drop)
   if (m_devices_mutex.try_lock())
   {
-    std::lock_guard<std::mutex> lk(m_devices_mutex, std::adopt_lock);
+    std::lock_guard lk(m_devices_mutex, std::adopt_lock);
     for (const auto& d : m_devices)
       d->UpdateInput();
   }
 }
 
+void ControllerInterface::SetAspectRatioAdjustment(float value)
+{
+  m_aspect_ratio_adjustment = value;
+}
+
+Common::Vec2 ControllerInterface::GetWindowInputScale() const
+{
+  const auto ar = m_aspect_ratio_adjustment.load();
+
+  if (ar > 1)
+    return {1.f, ar};
+  else
+    return {1 / ar, 1.f};
+}
+
 // Register a callback to be called when a device is added or removed (as from the input backends'
 // hotplug thread), or when devices are refreshed
 // Returns a handle for later removing the callback.

Compatibility/Input/InputConfig.cpp

@@ -26,10 +26,10 @@ InputConfig::InputConfig(const std::string& ini_name, const std::string& gui_nam
 
 InputConfig::~InputConfig() = default;
 
-bool InputConfig::LoadConfig(bool isGC)
+bool InputConfig::LoadConfig(InputClass type)
 {
-    //OpenEmu Stub
-    return false;
+        //OpenEmu Stub
+        return false;
 }
 
 void InputConfig::SaveConfig()
@@ -45,7 +45,7 @@ void InputConfig::SaveConfig()
   inifile.Save(ini_filename);
 }
 
-ControllerEmu::EmulatedController* InputConfig::GetController(int index)
+ControllerEmu::EmulatedController* InputConfig::GetController(int index) const
 {
   return m_controllers.at(index).get();
 }
@@ -60,9 +60,9 @@ bool InputConfig::ControllersNeedToBeCreated() const
   return m_controllers.empty();
 }
 
-std::size_t InputConfig::GetControllerCount() const
+int InputConfig::GetControllerCount() const
 {
-  return m_controllers.size();
+  return static_cast<int>(m_controllers.size());
 }
 
 void InputConfig::RegisterHotplugCallback()

Compatibility/Input/OpenEmuController.h

@@ -1,46 +1,35 @@
-
-
 typedef struct
 {
     int openemuButton;
-    unsigned dolphinButton;
     int value;
 } keymap;
 
 typedef struct
 {
-    float Xaxis;
-    float Yaxis;
-} axismap;
-
-typedef struct
-{
-    keymap gc_pad_keymap[20] = {
-        {OEGCButtonUp, OEDolJoypadUp, 0},
-        {OEGCButtonDown,OEDolJoypadDown, 0},
-        {OEGCButtonLeft, OEDolJoypadLeft, 0},
-        {OEGCButtonRight, OEDolJoypadRight, 0},
-        {OEGCAnalogUp, OEGCAnalog, 0},
-        {OEGCAnalogDown, OEGCAnalog, 0},
-        {OEGCAnalogLeft, OEGCAnalog, 0},
-        {OEGCAnalogRight, OEGCAnalog, 0},
-        {OEGCAnalogCUp, OEGCAnalogC, 0},
-        {OEGCAnalogCDown, OEGCAnalogC, 0},
-        {OEGCAnalogCLeft, OEGCAnalogC, 0},
-        {OEGCAnalogCRight, OEGCAnalogC, 0},
-        {OEGCButtonA, OEDolJoypadA, 0},
-        {OEGCButtonB, OEDolJoypadB, 0},
-        {OEGCButtonX, OEDolJoypadX, 0},
-        {OEGCButtonY, OEDolJoypadY, 0},
-        {OEGCButtonL, OEDolJoypadL, 0},
-        {OEGCButtonR, OEDolJoypadR, 0},
-        {OEGCButtonZ, OEDolJoypadR2, 0},
-        {OEGCButtonStart, OEDolJoypadStart, 0},
+    keymap gc_pad_keymap[22] = {
+        {OEGCButtonUp, 0},
+        {OEGCButtonDown, 0},
+        {OEGCButtonLeft, 0},
+        {OEGCButtonRight, 0},
+        {OEGCAnalogUp, 0},
+        {OEGCAnalogDown, 0},
+        {OEGCAnalogLeft, 0},
+        {OEGCAnalogRight,  0},
+        {OEGCAnalogCUp,  0},
+        {OEGCAnalogCDown, 0},
+        {OEGCAnalogCLeft, 0},
+        {OEGCAnalogCRight,  0},
+        {OEGCButtonA,  0},
+        {OEGCButtonB, 0},
+        {OEGCButtonX, 0},
+        {OEGCButtonY, 0},
+        {OEGCButtonL, 0},
+        {OEGCButtonR, 0},
+        {OEGCButtonZ, 0},
+        {OEGCButtonStart, 0},
+        {OEGCDigitalL, 0},
+        {OEGCDigitalR, 0},
     };
-    
-//    axismap gc_pad_Analog;
-//    axismap gc_pad_AnalogC;
-    axismap gc_pad_Trigger;
 } gc_pad;
 
 
@@ -50,96 +39,72 @@ void init_Callback();
 
 static gc_pad GameCubePads[4];
 
-//
-//static unsigned connected_wiimote_type[MAX_BBMOTES];
-//static int current_mote_id;
-//static InputConfig s_config(WIIMOTE_INI_NAME, _trans("Wii Remote"), "Wiimote");
+typedef struct
+{
+    keymap wiimote_keymap[54] = {
+        {OEWiiMoteButtonLeft, 0},
+        {OEWiiMoteButtonRight, 0},
+        {OEWiiMoteButtonDown, 0},
+        {OEWiiMoteButtonUp, 0},
+        {OEWiiMoteButtonA, 0},
+        {OEWiiMoteButtonB, 0},
+        {OEWiiMoteButton1, 0},
+        {OEWiiMoteButton2, 0},
+        {OEWiiMoteButtonPlus, 0},
+        {OEWiiMoteButtonMinus, 0},
+        {OEWiiMoteButtonHome, 0},
+        {OEWiiMoteTiltForward, 0},
+        {OEWiiMoteTiltBackward, 0},
+        {OEWiiMoteTiltLeft, 0},
+        {OEWiiMoteTiltRight, 0},
+        {OEWiiMoteShake, 0},
+        {OEWiiMoteSwingUp, 0},
+        {OEWiiMoteSwingDown, 0},
+        {OEWiiMoteSwingLeft, 0},
+        {OEWiiMoteSwingRight, 0},
+        {OEWiiMoteSwingForward, 0},
+        {OEWiiMoteSwingBackward, 0},
+        {OEWiiNunchukAnalogUp, 0},
+        {OEWiiNunchukAnalogDown, 0},
+        {OEWiiNunchukAnalogLeft, 0},
+        {OEWiiNunchukAnalogRight, 0},
+        {OEWiiNunchukButtonC, 0},
+        {OEWiiNunchukButtonZ, 0},
+        {OEWiiNunchukShake, 0},
+        {OEWiiClassicButtonUp, 0},
+        {OEWiiClassicButtonDown, 0},
+        {OEWiiClassicButtonLeft, 0},
+        {OEWiiClassicButtonRight, 0},
+        {OEWiiClassicAnalogLUp, 0},
+        {OEWiiClassicAnalogLDown, 0},
+        {OEWiiClassicAnalogLLeft, 0},
+        {OEWiiClassicAnalogLRight, 0},
+        {OEWiiClassicAnalogRUp, 0},
+        {OEWiiClassicAnalogRDown, 0},
+        {OEWiiClassicAnalogRLeft, 0},
+        {OEWiiClassicAnalogRRight, 0},
+        {OEWiiClassicButtonA, 0},
+        {OEWiiClassicButtonB, 0},
+        {OEWiiClassicButtonX, 0},
+        {OEWiiClassicButtonY, 0},
+        {OEWiiClassicButtonL, 0},
+        {OEWiiClassicButtonR, 0},
+        {OEWiiClassicButtonZl, 0},
+        {OEWiiClassicButtonZr, 0},
+        {OEWiiClassicButtonStart, 0},
+        {OEWiiClassicButtonSelect, 0},
+        {OEWiiClassicButtonHome, 0},
+        {OEWiimoteSideways, 0},
+        {OEWiimoteUpright, 0},
+    };
+    
+    OEWiiConType wiimoteType;
+    ControlState dx, dy;
+} wii_remote;
 
-//
-//typedef struct
-//{
-//    keymap wiimote_keymap[12] = {
-//        {OEWiiMoteButtonLeft, OEDolJoypadLeft, 0},
-//        {OEWiiMoteButtonRight, OEDolJoypadRight, 0},
-//        {OEWiiMoteButtonDown, OEDolJoypadDown, 0},
-//        {OEWiiMoteButtonUp, OEDolJoypadUp, 0},
-//        {OEWiiMoteButtonPlus, OEDolJoypadStart, 0},
-//        {OEWiiMoteButton2, OEDolJoypadY, 0},
-//        {OEWiiMoteButton1, OEDolJoypadX, 0},
-//        {OEWiiMoteButtonB, OEDolJoypadB, 0},
-//        {OEWiiMoteButtonA, OEDolJoypadA, 0},
-//        {OEWiiMoteButtonMinus, OEDolJoypadSelect, 0},
-//        {OEWiiMoteButtonHome, OEDolJoypadR3, 0},
-//        {OEWiiMoteShake, OEDolJoypadR2, 0},
-//    };
-//
-//    keymap sideways_keymap[12] = {
-//        {OEWiiMoteButtonLeft, OEDolJoypadUp, 0},
-//        {OEWiiMoteButtonRight, OEDolJoypadDown, 0},
-//        {OEWiiMoteButtonDown, OEDolJoypadLeft, 0},
-//        {OEWiiMoteButtonUp, OEDolJoypadRight, 0},
-//        {OEWiiMoteButtonPlus, OEDolJoypadStart, 0},
-//        {OEWiiMoteButton2, OEDolJoypadB, 0},
-//        {OEWiiMoteButton1, OEDolJoypadA, 0},
-//        {OEWiiMoteButtonB, OEDolJoypadY, 0},
-//        {OEWiiMoteButtonA, OEDolJoypadX, 0},
-//        {OEWiiMoteButtonMinus, OEDolJoypadSelect, 0},
-//        {OEWiiMoteButtonHome, OEDolJoypadR3, 0},
-//        {OEWiiMoteShake, OEDolJoypadR2, 0},
-//};
-//
-//    axismap wiimote_tilt_LR;
-//    axismap wiimote_tilt_FB;
-//
-//    keymap nunchuk_keymap[3] = {
-//        {OEWiiNunchukButtonC, OEDolJoypadL, 0},
-//        {OEWiiNunchukButtonZ, OEDolJoypadR, 0},
-//        {OEWiiNunchukShake, OEDolJoypadL3, 0},
-//    };
-//
-//    axismap nunchuck_Analog;
-//
-//    keymap classic_keymap[15] = {
-//        {OEWiiClassicButtonRight, WiimoteEmu::Classic::PAD_RIGHT, 0},
-//        {OEWiiClassicButtonDown, WiimoteEmu::Classic::PAD_DOWN, 0},
-//        {OEWiiClassicButtonL, WiimoteEmu::Classic::TRIGGER_L, 0},
-//        {OEWiiClassicButtonSelect, WiimoteEmu::Classic::BUTTON_MINUS, 0},
-//        {OEWiiClassicButtonHome, WiimoteEmu::Classic::BUTTON_HOME, 0},
-//        {OEWiiClassicButtonStart, WiimoteEmu::Classic::BUTTON_PLUS, 0},
-//        {OEWiiClassicButtonR, WiimoteEmu::Classic::TRIGGER_R, 0},
-//        {OEWiiClassicButtonZl, WiimoteEmu::Classic::BUTTON_ZL, 0},
-//        {OEWiiClassicButtonB, WiimoteEmu::Classic::BUTTON_B, 0},
-//        {OEWiiClassicButtonY, WiimoteEmu::Classic::BUTTON_Y, 0},
-//        {OEWiiClassicButtonX, WiimoteEmu::Classic::BUTTON_X, 0},
-//        {OEWiiClassicButtonA, WiimoteEmu::Classic::BUTTON_A, 0},
-//        {OEWiiClassicButtonZr, WiimoteEmu::Classic::BUTTON_ZR, 0},
-//        {OEWiiClassicButtonLeft, WiimoteEmu::Classic::PAD_LEFT, 0},
-//        {OEWiiClassicButtonUp, WiimoteEmu::Classic::PAD_UP, 0},
-//    };
-//
-//    axismap classic_AnalogLeft;
-//    axismap classic_AnalogRight;
-//    axismap classic_TriggerLeft;
-//    axismap classic_TriggerRight;
-//
-//    int extension;
-//    ControlState dx, dy;
-//
-//} wii_remote;
+void setWiiButton(int pad_num, int button , int value);
+void setWiiAxis(int pad_num, int button , float value);
+
+static wii_remote WiiRemotes[4];
 
-// static gc_pad GameCubePads[4];
-// static wii_remote WiiRemotes[4];
-// static int want_extension[4];
 
-//void setWiiButton(int pad_num, int button , int value);
-//void setWiimoteButton(int pad_num, int button , int value);
-//void setWiiClassicButton(int pad_num, int button , int value);
-//void setWiiNunchukButton(int pad_num, int button , int value);
-//
-//void setWiiAxis(int pad_num, int button , float value);
-//void setWiimoteAxis(int pad_num, int button , float value);
-//void setWiiClassicAxis(int pad_num, int button , float value);
-//void setWiiNunchukAxis(int pad_num, int button , float value);
-//void setWiiIR(int pad_num, float x , float y);
-//
-//int getWiiExtension (int pad_num);

Compatibility/Input/OpenEmuController.mm

@@ -4,6 +4,8 @@
 #include "OpenEmuController.h"
 
 #include "Core/ConfigManager.h"
+#include "Common/Config/Config.h"
+#include "Core/Config/MainSettings.h"
 
 void input_poll_f()
 {
@@ -14,14 +16,13 @@ void input_poll_f()
 
 int16_t input_state_f(unsigned port, unsigned device, unsigned index, unsigned button)
 {
-    if (SConfig::GetInstance().bWii && !SConfig::GetInstance().m_bt_passthrough_enabled)
+    if (SConfig::GetInstance().bWii && !Config::Get(Config::MAIN_BLUETOOTH_PASSTHROUGH_ENABLED))
     {
         //This is where we must translate the OpenEmu frontend keys presses stored in the keymap to bitmasks for Dolphin.
-        return 0;
+        return WiiRemotes[port].wiimote_keymap[button].value;
     } else {
-         return GameCubePads[port].gc_pad_keymap[button].value;
+        return GameCubePads[port].gc_pad_keymap[button].value;
     }
-    
 };
 
 void init_Callback() {
@@ -52,3 +53,36 @@ void setGameCubeAxis(int pad_num, int button , float value)
     }
     GameCubePads[pad_num].gc_pad_keymap[button].value = value;
 }
+
+void setWiiButton(int pad_num, int button , int value) {
+    WiiRemotes[pad_num].wiimote_keymap[button].value = value;
+}
+
+void setWiiAxis(int pad_num, int button , float value)
+{
+    switch (button)
+    {
+        
+        case OEWiiMoteTiltLeft:
+        case OEWiiMoteTiltForward:
+            value *= -180;
+            break;
+        case OEWiiMoteTiltRight:
+        case OEWiiMoteTiltBackward:
+            value *= 180;
+            break;
+            
+        case OEWiiNunchukAnalogUp:
+        case OEWiiNunchukAnalogLeft:
+        case OEWiiClassicAnalogLUp:
+        case OEWiiClassicAnalogLLeft:
+        case OEWiiClassicAnalogRUp:
+        case OEWiiClassicAnalogRLeft:
+            value *= -0x8000;
+            break;
+        default:
+            value *= 0x7FFF;
+            break;
+    }
+    WiiRemotes[pad_num].wiimote_keymap[button].value = value;
+}

Compatibility/Input/OpenEmuInput.cpp

@@ -5,6 +5,9 @@
 #include "Common/Common.h"
 #include "Common/CommonTypes.h"
 #include "Common/IniFile.h"
+#include "Common/Config/Config.h"
+#include "Core/Config/MainSettings.h"
+#include "Core/Config/WiimoteSettings.h"
 #include "Core/ConfigManager.h"
 #include "Core/HW/GCKeyboard.h"
 #include "Core/HW/GCPad.h"
@@ -23,18 +26,17 @@
 #include "InputCommon/ControllerEmu/ControlGroup/Attachments.h"
 #include "InputCommon/ControllerEmu/Setting/NumericSetting.h"
 #include "InputCommon/ControllerInterface/ControllerInterface.h"
+#include "InputCommon/GCAdapter.h"
 #include "InputCommon/GCPadStatus.h"
 #include "InputCommon/InputConfig.h"
 
 #include "DolHost.h"
 
-extern WindowSystemInfo wsi;
-
 static Input::openemu_input_state_t input_cb;
 static Input::openemu_input_poll_t poll_cb;
 static const std::string source = "OpenEmu";
 static unsigned input_types[4];
-
+static bool init_wiimotes = false;
 
     static std::string GetDeviceName(unsigned device)
     {
@@ -46,6 +48,13 @@ static unsigned input_types[4];
                 return "Analog";
             case OEDolDevPointer:
                 return "Pointer";
+            case OEDolDevLightGun:
+                return "LightGun";
+            case OEDolDevKeyboard:
+                return "Keyboard";
+            case OEDolDevMouse:
+                return "Mouse";
+            
         }
         return "Unknown";
     }
@@ -146,6 +155,7 @@ static unsigned input_types[4];
         switch (device)
         {
             case OEDolDevJoy:
+                //GC
                 AddButton(OEGCButtonB, "B");
                 AddButton(OEGCButtonY, "Y");
                 AddButton(OEGCButtonStart, "Start");
@@ -155,22 +165,85 @@ static unsigned input_types[4];
                 AddButton(OEGCButtonRight, "Right");
                 AddButton(OEGCButtonA, "A");
                 AddButton(OEGCButtonX, "X");
-                AddButton(OEGCButtonL, "L");
-                AddButton(OEGCButtonR, "R");
+                AddButton(OEGCDigitalL, "L");
+                AddButton(OEGCDigitalR, "R");
                 AddButton(OEGCButtonZ, "Z");
+                //Wiimote
+                AddButton(OEWiiMoteButtonUp, "Up");
+                AddButton(OEWiiMoteButtonDown, "Down");
+                AddButton(OEWiiMoteButtonLeft, "Left");
+                AddButton(OEWiiMoteButtonRight, "Right");
+                AddButton(OEWiiMoteButtonA, "A");
+                AddButton(OEWiiMoteButtonB, "B");
+                AddButton(OEWiiMoteButton1, "1");
+                AddButton(OEWiiMoteButton2, "2");
+                AddButton(OEWiiMoteButtonPlus, "+");
+                AddButton(OEWiiMoteButtonMinus, "-");
+                AddButton(OEWiiMoteButtonHome, "Home");
+                AddButton(OEWiiMoteShake, "wmShake");
+                //Special Buttons
+                AddButton(OEWiimoteSideways, "Sideways");
+                AddButton(OEWiimoteUpright, "Upright");
+                //Nunchuk
+                AddButton(OEWiiNunchukButtonC, "C");
+                AddButton(OEWiiNunchukButtonZ, "Z");
+                AddButton(OEWiiNunchukShake, "ncShake");
+                //Classic
+                AddButton(OEWiiClassicButtonUp, "Up");
+                AddButton(OEWiiClassicButtonDown, "Down");
+                AddButton(OEWiiClassicButtonLeft, "Left");
+                AddButton(OEWiiClassicButtonRight, "Right");
+                AddButton(OEWiiClassicButtonA, "A");
+                AddButton(OEWiiClassicButtonB, "B");
+                AddButton(OEWiiClassicButtonX, "X");
+                AddButton(OEWiiClassicButtonY, "Y");
+                AddButton(OEWiiClassicButtonL, "L");
+                AddButton(OEWiiClassicButtonR, "R");
+                AddButton(OEWiiClassicButtonZl, "Zl");
+                AddButton(OEWiiClassicButtonZr, "Zr");
+                AddButton(OEWiiClassicButtonStart, "Start");
+                AddButton(OEWiiClassicButtonSelect, "Select");
+                AddButton(OEWiiClassicButtonHome, "Home");
                 return;
                 
             case OEDolDevAnalog:
-                AddAxis(OEGCAnalogLeft, -0x8000, "X0-", OEGCAnalog);
-                AddAxis(OEGCAnalogRight, 0x7FFF, "X0+", OEGCAnalog);
-                AddAxis(OEGCAnalogUp, -0x8000, "Y0-", OEGCAnalog);
-                AddAxis(OEGCAnalogDown, 0x7FFF, "Y0+", OEGCAnalog);
-                AddAxis(OEGCAnalogCLeft, -0x8000, "X1-", OEGCAnalogC);
-                AddAxis(OEGCAnalogCRight, 0x7FFF, "X1+", OEGCAnalogC);
-                AddAxis(OEGCAnalogCUp, -0x8000, "Y1-", OEGCAnalogC);
-                AddAxis(OEGCAnalogCDown, 0x7FFF, "Y1+", OEGCAnalogC);
-                AddAxis(OEDolJoypadL2, 0x7FFF, "Trigger0+", OEGCAnalogTrigger);
-                AddAxis(OEDolJoypadR2, 0x7FFF, "Trigger1+", OEGCAnalogTrigger);
+                AddAxis(OEGCAnalogLeft, -0x8000, "X0-", 0);
+                AddAxis(OEGCAnalogRight, 0x7FFF, "X0+", 0);
+                AddAxis(OEGCAnalogUp, -0x8000, "Y0-", 0);
+                AddAxis(OEGCAnalogDown, 0x7FFF, "Y0+", 0 );
+                AddAxis(OEGCAnalogCLeft, -0x8000, "X1-", 1);
+                AddAxis(OEGCAnalogCRight, 0x7FFF, "X1+", 1);
+                AddAxis(OEGCAnalogCUp, -0x8000, "Y1-", 1);
+                AddAxis(OEGCAnalogCDown, 0x7FFF, "Y1+", 1);
+                AddAxis(OEGCButtonL, 0x7FFF, "LTrigger0+");
+                AddAxis(OEGCButtonR, 0x7FFF, "RTrigger1+");
+                //Wiimote
+                AddAxis(OEWiiMoteTiltForward, -180, "TiltY0-", 2);
+                AddAxis(OEWiiMoteTiltBackward, 180, "TiltY0+", 2 );
+                AddAxis(OEWiiMoteTiltLeft, -180, "TiltX0-", 2);
+                AddAxis(OEWiiMoteTiltRight, 180, "TiltX0+", 2);
+                AddAxis(OEWiiMoteSwingUp,-0x8000, "SwingY0-", 3);
+                AddAxis(OEWiiMoteSwingDown,0x7FFF, "SwingY0+", 3);
+                AddAxis(OEWiiMoteSwingLeft,-0x8000, "SwingX0-", 3);
+                AddAxis(OEWiiMoteSwingRight,0x7FFF, "SwingX0+", 3);
+                AddAxis(OEWiiMoteSwingForward, -0x8000, "SwingZ0-", 3);
+                AddAxis(OEWiiMoteSwingBackward,0x7FFF, "SwingZ0+", 3);
+                //Nunchuk
+                AddAxis(OEWiiNunchukAnalogUp, -0x8000, "ncY0-", 4);
+                AddAxis(OEWiiNunchukAnalogDown,0x7FFF, "ncY0+", 4);
+                AddAxis(OEWiiNunchukAnalogLeft,-0x8000, "ncX0-", 4);
+                AddAxis(OEWiiNunchukAnalogRight,0x7FFF, "ncX0+", 4);
+                //Classic
+                AddAxis(OEWiiClassicAnalogLUp, -0x8000, "ccY0-", 5);
+                AddAxis(OEWiiClassicAnalogLDown,0x7FFF, "ccY0+", 5);
+                AddAxis(OEWiiClassicAnalogLLeft,-0x8000, "ccX0-", 5);
+                AddAxis(OEWiiClassicAnalogLRight,0x7FFF, "ccX0+", 5);
+                AddAxis(OEWiiClassicAnalogRUp,-0x8000, "ccY1-", 6);
+                AddAxis(OEWiiClassicAnalogRDown,0x7FFF, "ccY1+", 6);
+                AddAxis(OEWiiClassicAnalogRLeft,-0x8000, "ccX1-", 6);
+                AddAxis(OEWiiClassicAnalogRRight,0x7FFF, "ccX1+", 6);
+                AddAxis(OEWiiClassicButtonL, 0x7FFF, "ccLTrigger0+");
+                AddAxis(OEWiiClassicButtonR, 0x7FFF, "ccRTrigger1+");
                 return;
         }
     }
@@ -195,6 +268,7 @@ static unsigned input_types[4];
 
     void Input::Openemu_Input_Init()
     {
+        
         g_controller_interface.Initialize(DolHost::GetInstance()->GetWSI());
 
         g_controller_interface.AddDevice(std::make_shared<OEDevice>(OEDolDevKeyboard, 0));
@@ -202,11 +276,18 @@ static unsigned input_types[4];
         Pad::Initialize();
         Keyboard::Initialize();
         
+        if (SConfig::GetInstance().bWii && !Config::Get(Config::MAIN_BLUETOOTH_PASSTHROUGH_ENABLED))
+          {
+            init_wiimotes = true;
+            Wiimote::Initialize(Wiimote::InitializeMode::DO_NOT_WAIT_FOR_WIIMOTES);
+          }
     }
 
     void Shutdown()
     {
+        Wiimote::ResetAllWiimotes();
         Wiimote::Shutdown();
+        init_wiimotes = false;
         Keyboard::Shutdown();
         Pad::Shutdown();
         g_controller_interface.Shutdown();
@@ -232,65 +313,233 @@ void Input::openemu_set_input_poll(Input::openemu_input_poll_t cb)
         poll_cb = cb;
     }
 
-    void Input::openemu_set_controller_port_device(unsigned port, unsigned device)
-    {
-        if (port > 3)
-            return;
+void Input::openemu_set_controller_port_device(unsigned port, unsigned device)
+{
+    if (port > 4)
+        return;
 
-        input_types[port] = device;
+    input_types[port] = device;
 
-        std::string devJoypad = GetQualifiedName(port, OEDolDevJoy);
-        std::string devAnalog = GetQualifiedName(port, OEDolDevAnalog);
-        std::string devPointer = GetQualifiedName(port, OEDolDevPointer);
+    std::string devJoypad = GetQualifiedName(port, OEDolDevJoy);
+    std::string devAnalog = GetQualifiedName(port, OEDolDevAnalog);
+    std::string devMouse = GetQualifiedName(port, OEDolDevMouse);
+    std::string devPointer = GetQualifiedName(port, OEDolDevPointer);
 
-        RemoveDevicesForPort(port);
-        if ((device & 0xff) != OEDolDevNone)
-            AddDevicesForPort(port);
+    RemoveDevicesForPort(port);
+    if ((device & 0xff) != OEDolDevNone)
+        AddDevicesForPort(port);
 
 
-            GCPad* gcPad = (GCPad*)Pad::GetConfig()->GetController(port);
-            // load an empty inifile section, clears everything
-            IniFile::Section sec;
-            gcPad->LoadConfig(&sec);
-            gcPad->SetDefaultDevice(devJoypad);
+        GCPad* gcPad = (GCPad*)Pad::GetConfig()->GetController(port);
+        // load an empty inifile section, clears everything
+        IniFile::Section sec;
+        gcPad->LoadConfig(&sec);
+        gcPad->SetDefaultDevice(devJoypad);
 
-            ControllerEmu::ControlGroup* gcButtons = gcPad->GetGroup(PadGroup::Buttons);
-            ControllerEmu::ControlGroup* gcMainStick = gcPad->GetGroup(PadGroup::MainStick);
-            ControllerEmu::ControlGroup* gcCStick = gcPad->GetGroup(PadGroup::CStick);
-            ControllerEmu::ControlGroup* gcDPad = gcPad->GetGroup(PadGroup::DPad);
-            ControllerEmu::ControlGroup* gcTriggers = gcPad->GetGroup(PadGroup::Triggers);
-            ControllerEmu::ControlGroup* gcRumble = gcPad->GetGroup(PadGroup::Rumble);
-//#if 0
-//            ControllerEmu::ControlGroup* gcMic = gcPad->GetGroup(PadGroup::Mic);
-//            ControllerEmu::ControlGroup* gcOptions = gcPad->GetGroup(PadGroup::Options);
-//#endif
+        ControllerEmu::ControlGroup* gcButtons = gcPad->GetGroup(PadGroup::Buttons);
+        ControllerEmu::ControlGroup* gcMainStick = gcPad->GetGroup(PadGroup::MainStick);
+        ControllerEmu::ControlGroup* gcCStick = gcPad->GetGroup(PadGroup::CStick);
+        ControllerEmu::ControlGroup* gcDPad = gcPad->GetGroup(PadGroup::DPad);
+        ControllerEmu::ControlGroup* gcTriggers = gcPad->GetGroup(PadGroup::Triggers);
+        ControllerEmu::ControlGroup* gcRumble = gcPad->GetGroup(PadGroup::Rumble);
+#if 0
+            ControllerEmu::ControlGroup* gcMic = gcPad->GetGroup(PadGroup::Mic);
+            ControllerEmu::ControlGroup* gcOptions = gcPad->GetGroup(PadGroup::Options);
+#endif
 
-            gcButtons->SetControlExpression(0, "A");                              // A
-            gcButtons->SetControlExpression(1, "B");                              // B
-            gcButtons->SetControlExpression(2, "X");                              // X
-            gcButtons->SetControlExpression(3, "Y");                              // Y
-            gcButtons->SetControlExpression(4, "Z");                              // Z
-            gcButtons->SetControlExpression(5, "Start");                          // Start
-            gcMainStick->SetControlExpression(0, "`" + devAnalog + ":Y0-`");      // Up
-            gcMainStick->SetControlExpression(1, "`" + devAnalog + ":Y0+`");      // Down
-            gcMainStick->SetControlExpression(2, "`" + devAnalog + ":X0-`");      // Left
-            gcMainStick->SetControlExpression(3, "`" + devAnalog + ":X0+`");      // Right
-            gcCStick->SetControlExpression(0, "`" + devAnalog + ":Y1-`");         // Up
-            gcCStick->SetControlExpression(1, "`" + devAnalog + ":Y1+`");         // Down
-            gcCStick->SetControlExpression(2, "`" + devAnalog + ":X1-`");         // Left
-            gcCStick->SetControlExpression(3, "`" + devAnalog + ":X1+`");         // Right
-            gcDPad->SetControlExpression(0, "Up");                                // Up
-            gcDPad->SetControlExpression(1, "Down");                              // Down
-            gcDPad->SetControlExpression(2, "Left");                              // Left
-            gcDPad->SetControlExpression(3, "Right");                             // Right
-            gcTriggers->SetControlExpression(0, "L");                            // L-trigger
-            gcTriggers->SetControlExpression(1, "R");                            // R-trigger
-            gcTriggers->SetControlExpression(2, "`" + devAnalog + ":Trigger0+`"); // L-trigger Analog
-            gcTriggers->SetControlExpression(3, "`" + devAnalog + ":Trigger1+`"); // R-trigger Analog
-            gcRumble->SetControlExpression(0, "Rumble");
+        gcButtons->SetControlExpression(0, "A");                              // A
+        gcButtons->SetControlExpression(1, "B");                              // B
+        gcButtons->SetControlExpression(2, "X");                              // X
+        gcButtons->SetControlExpression(3, "Y");                              // Y
+        gcButtons->SetControlExpression(4, "Z");                              // Z
+        gcButtons->SetControlExpression(5, "Start");                          // Start
+        gcMainStick->SetControlExpression(0, "`" + devAnalog + ":Y0-`");      // Up
+        gcMainStick->SetControlExpression(1, "`" + devAnalog + ":Y0+`");      // Down
+        gcMainStick->SetControlExpression(2, "`" + devAnalog + ":X0-`");      // Left
+        gcMainStick->SetControlExpression(3, "`" + devAnalog + ":X0+`");      // Right
+        gcCStick->SetControlExpression(0, "`" + devAnalog + ":Y1-`");         // Up
+        gcCStick->SetControlExpression(1, "`" + devAnalog + ":Y1+`");         // Down
+        gcCStick->SetControlExpression(2, "`" + devAnalog + ":X1-`");         // Left
+        gcCStick->SetControlExpression(3, "`" + devAnalog + ":X1+`");         // Right
+        gcDPad->SetControlExpression(0, "Up");                                // Up
+        gcDPad->SetControlExpression(1, "Down");                              // Down
+        gcDPad->SetControlExpression(2, "Left");                              // Left
+        gcDPad->SetControlExpression(3, "Right");                             // Right
+        gcTriggers->SetControlExpression(0, "L");                            // L-trigger
+        gcTriggers->SetControlExpression(1, "R");                            // R-trigger
+        gcTriggers->SetControlExpression(2, "`" + devAnalog + ":LTrigger0+`"); // L-trigger Analog
+        gcTriggers->SetControlExpression(3, "`" + devAnalog + ":RTrigger1+`"); // R-trigger Analog
+        gcRumble->SetControlExpression(0, "Rumble");
 
-            gcPad->UpdateReferences(g_controller_interface);
-            Pad::GetConfig()->SaveConfig();
+        gcPad->UpdateReferences(g_controller_interface);
+        Pad::GetConfig()->SaveConfig();
 
-//        all_descs.push_back({ 0 });
-    }
+    if (SConfig::GetInstance().bWii && !Config::Get(Config::MAIN_BLUETOOTH_PASSTHROUGH_ENABLED))
+      {
+        WiimoteEmu::Wiimote* wm = (WiimoteEmu::Wiimote*)Wiimote::GetConfig()->GetController(port);
+        // load an empty inifile section, clears everything
+        IniFile::Section sec;
+        wm->LoadConfig(&sec);
+        wm->SetDefaultDevice(devJoypad);
+          
+    using namespace WiimoteEmu;
+        if (device == OEWiimoteCC || device == OEWiimoteCC_Pro)
+        {
+          ControllerEmu::ControlGroup* ccButtons = wm->GetClassicGroup(ClassicGroup::Buttons);
+          ControllerEmu::ControlGroup* ccTriggers = wm->GetClassicGroup(ClassicGroup::Triggers);
+          ControllerEmu::ControlGroup* ccDpad = wm->GetClassicGroup(ClassicGroup::DPad);
+          ControllerEmu::ControlGroup* ccLeftStick = wm->GetClassicGroup(ClassicGroup::LeftStick);
+          ControllerEmu::ControlGroup* ccRightStick = wm->GetClassicGroup(ClassicGroup::RightStick);
+
+          ccButtons->SetControlExpression(0, "A");                                // A
+          ccButtons->SetControlExpression(1, "B");                                // B
+          ccButtons->SetControlExpression(2, "X");                                // X
+          ccButtons->SetControlExpression(3, "Y");                                // Y
+          ccButtons->SetControlExpression(4, "Zl");                               // ZL
+          ccButtons->SetControlExpression(5, "Zr");                               // ZR
+          ccButtons->SetControlExpression(6, "-");                                // -
+          ccButtons->SetControlExpression(7, "+");                                // +
+          ccButtons->SetControlExpression(8, "Home");                             // Home
+          ccTriggers->SetControlExpression(0, "L");                               // L-trigger
+          ccTriggers->SetControlExpression(1, "R");                               // R-trigger
+          ccTriggers->SetControlExpression(2, "`" + devAnalog + "ccLTrigger0+`"); // L-trigger Analog
+          ccTriggers->SetControlExpression(3, "`" + devAnalog + "ccRTrigger1+`"); // R-trigger Analog
+          ccDpad->SetControlExpression(0, "Up");                                  // Up
+          ccDpad->SetControlExpression(1, "Down");                                // Down
+          ccDpad->SetControlExpression(2, "Left");                                // Left
+          ccDpad->SetControlExpression(3, "Right");                               // Right
+          ccLeftStick->SetControlExpression(0, "`" + devAnalog + ":ccY0-`");      // Up
+          ccLeftStick->SetControlExpression(1, "`" + devAnalog + ":ccY0+`");      // Down
+          ccLeftStick->SetControlExpression(2, "`" + devAnalog + ":ccX0-`");      // Left
+          ccLeftStick->SetControlExpression(3, "`" + devAnalog + ":ccX0+`");      // Right
+          ccRightStick->SetControlExpression(0, "`" + devAnalog + ":ccY1-`");     // Up
+          ccRightStick->SetControlExpression(1, "`" + devAnalog + ":ccY1+`");     // Down
+          ccRightStick->SetControlExpression(2, "`" + devAnalog + ":ccX1-`");     // Left
+          ccRightStick->SetControlExpression(3, "`" + devAnalog + ":ccX1+`");     // Right
+        }
+        else //if (device != OEWiiMoteReal)
+        {
+          ControllerEmu::ControlGroup* wmButtons = wm->GetWiimoteGroup(WiimoteGroup::Buttons);
+          ControllerEmu::ControlGroup* wmDPad = wm->GetWiimoteGroup(WiimoteGroup::DPad);
+          ControllerEmu::ControlGroup* wmIR = wm->GetWiimoteGroup(WiimoteGroup::Point);
+          ControllerEmu::ControlGroup* wmShake = wm->GetWiimoteGroup(WiimoteGroup::Shake);
+          ControllerEmu::ControlGroup* wmTilt = wm->GetWiimoteGroup(WiimoteGroup::Tilt);
+          ControllerEmu::ControlGroup* wmHotkeys = wm->GetWiimoteGroup(WiimoteGroup::Hotkeys);
+    #if 0
+          ControllerEmu::ControlGroup* wmSwing = wm->GetWiimoteGroup(WiimoteGroup::Swing);
+         
+    #endif
+
+          wmButtons->SetControlExpression(0, "A | `" + devMouse + ":Left`");   // A
+          wmButtons->SetControlExpression(1, "B | `" + devMouse + ":Right`");  // B
+
+          if (device == OEWiimoteNC)
+          {
+            ControllerEmu::ControlGroup* ncButtons = wm->GetNunchukGroup(NunchukGroup::Buttons);
+            ControllerEmu::ControlGroup* ncStick = wm->GetNunchukGroup(NunchukGroup::Stick);
+            ControllerEmu::ControlGroup* ncShake = wm->GetNunchukGroup(NunchukGroup::Shake);
+    #if 0
+            ControllerEmu::ControlGroup* ncTilt = wm->GetNunchukGroup(NunchukGroup::Tilt);
+            ControllerEmu::ControlGroup* ncSwing = wm->GetNunchukGroup(NunchukGroup::Swing);
+    #endif
+
+            ncButtons->SetControlExpression(0, "C");                        // C
+            ncButtons->SetControlExpression(1, "Z");                        // Z
+            ncStick->SetControlExpression(0, "`" + devAnalog + ":ccY0-`");  // Up
+            ncStick->SetControlExpression(1, "`" + devAnalog + ":ccY0+`");  // Down
+            ncStick->SetControlExpression(2, "`" + devAnalog + ":ccX0-`");  // Left
+            ncStick->SetControlExpression(3, "`" + devAnalog + ":ccX0+`");  // Right
+            ncShake->SetControlExpression(0, "ncShake");                    // X
+            ncShake->SetControlExpression(1, "ncShake");                    // Y
+            ncShake->SetControlExpression(2, "ncShake");                    // Z
+
+            wmButtons->SetControlExpression(2, "1");                        // 1
+            wmButtons->SetControlExpression(3, "2");                        // 2
+            wmButtons->SetControlExpression(4, "-");                        // -
+            wmButtons->SetControlExpression(5, "+");                        // +
+          }
+          else
+          {
+            wmButtons->SetControlExpression(2, "1");                        // 1
+            wmButtons->SetControlExpression(3, "2");                        // 2
+            wmButtons->SetControlExpression(4, "-");                        // -
+            wmButtons->SetControlExpression(5, "+");                        // +
+          }
+
+          wmButtons->SetControlExpression(6, "Home");                      // Home
+          wmDPad->SetControlExpression(0, "Up");                           // Up
+          wmDPad->SetControlExpression(1, "Down");                         // Down
+          wmDPad->SetControlExpression(2, "Left");                         // Left
+          wmDPad->SetControlExpression(3, "Right");                        // Right
+          wmIR->SetControlExpression(0, "`" + devPointer + ":Y0-`");       // Up
+          wmIR->SetControlExpression(1, "`" + devPointer + ":Y0+`");       // Down
+          wmIR->SetControlExpression(2, "`" + devPointer + ":X0-`");       // Left
+          wmIR->SetControlExpression(3, "`" + devPointer + ":X0+`");       // Right
+          wmShake->SetControlExpression(0, "wmShake");                     // X
+          wmShake->SetControlExpression(1, "wmShake");                     // Y
+          wmShake->SetControlExpression(2, "wmShake");                     // Z
+          wmTilt->SetControlExpression(0, "`" + devAnalog + ":TiltY0-`");  // Forward
+          wmTilt->SetControlExpression(1, "`" + devAnalog + ":TiltY0+`");  // Backward
+          wmTilt->SetControlExpression(2, "`" + devAnalog + ":TiltX0-`");  // Left
+          wmTilt->SetControlExpression(3, "`" + devAnalog + ":TiltX0+`");  // Right
+            
+    #if 0
+          wmHotkeys->SetControlExpression(0, "Sideways");                  // Sideways Toggle
+          wmHotkeys->SetControlExpression(1, "Upright");                   // Upright Toggle
+          wmHotkeys->SetControlExpression(2, "Sideways");                  // Sideways Hold
+          wmHotkeys->SetControlExpression(3, "Upright");                   // Upright Hold
+    #endif
+        }
+
+        ControllerEmu::ControlGroup* wmRumble = wm->GetWiimoteGroup(WiimoteGroup::Rumble);
+        ControllerEmu::ControlGroup* wmOptions = wm->GetWiimoteGroup(WiimoteGroup::Options);
+        ControllerEmu::Attachments* wmExtension =
+            (ControllerEmu::Attachments*)wm->GetWiimoteGroup(WiimoteGroup::Attachments);
+
+        static_cast<ControllerEmu::NumericSetting<double>*>(wmOptions->numeric_settings[0].get())
+            ->SetValue(0);  // Speaker Pan [-100, 100]
+        static_cast<ControllerEmu::NumericSetting<double>*>(wmOptions->numeric_settings[1].get())
+            ->SetValue(95);  // Battery [0, 100]
+        static_cast<ControllerEmu::NumericSetting<bool>*>(wmOptions->numeric_settings[2].get())
+            ->SetValue(false);  // Upright Wiimote
+        static_cast<ControllerEmu::NumericSetting<bool>*>(wmOptions->numeric_settings[3].get())
+            ->SetValue(false);  // Sideways Wiimote
+        wmRumble->SetControlExpression(0, "Rumble");
+        switch (device)
+        {
+        case OEWiimote:
+          wmExtension->SetSelectedAttachment(ExtensionNumber::NONE);
+          Config::SetCurrent(Config::GetInfoForWiimoteSource(port), WiimoteSource::Emulated);
+          break;
+
+        case OEWiimoteSW:
+          wmExtension->SetSelectedAttachment(ExtensionNumber::NONE);
+          static_cast<ControllerEmu::NumericSetting<bool>*>(wmOptions->numeric_settings[2].get())
+              ->SetValue(true);  // Sideways Wiimote
+          Config::SetCurrent(Config::GetInfoForWiimoteSource(port), WiimoteSource::Emulated);
+          break;
+
+        case OEWiimoteNC:
+          wmExtension->SetSelectedAttachment(ExtensionNumber::NUNCHUK);
+          Config::SetCurrent(Config::GetInfoForWiimoteSource(port), WiimoteSource::Emulated);
+          break;
+
+        case OEWiimoteCC:
+        case OEWiimoteCC_Pro:
+          wmExtension->SetSelectedAttachment(ExtensionNumber::CLASSIC);
+          Config::SetCurrent(Config::GetInfoForWiimoteSource(port), WiimoteSource::Emulated);
+          break;
+
+        case OEWiiMoteReal:
+          //desc = Libretro::Input::descEmpty;
+          Config::SetCurrent(Config::GetInfoForWiimoteSource(port), WiimoteSource::Real);
+
+        default:
+          //desc = Libretro::Input::descGC;
+          Config::SetCurrent(Config::GetInfoForWiimoteSource(port), WiimoteSource::None);
+          break;
+        }
+        wm->UpdateReferences(g_controller_interface);
+        ::Wiimote::GetConfig()->SaveConfig();
+      }
+}

Compatibility/Input/OpenEmuInput.h

@@ -1,3 +1,42 @@
+//Dolphins Internal Controll expression Reference
+
+//Wiimote
+//m_buttons->SetControlExpression(0, "A");
+//m_buttons->SetControlExpression(1, "B");
+//m_buttons->SetControlExpression(2, "`1`");
+//m_buttons->SetControlExpression(3, "`2`");
+//m_buttons->SetControlExpression(4, "-");
+//m_buttons->SetControlExpression(5, "+");
+//m_buttons->SetControlExpression(6, "Home");
+//m_dpad->SetControlExpression(0, "UP");
+//m_dpad->SetControlExpression(1, "DOWN");
+//m_dpad->SetControlExpression(2, "LEFT");
+//m_dpad->SetControlExpression(3, "RIGHT");
+//m_ir->SetControlExpression(0, "Cursor Y-");
+//m_ir->SetControlExpression(1, "Cursor Y+");
+//m_ir->SetControlExpression(2, "Cursor X-");
+//m_ir->SetControlExpression(3, "Cursor X+");
+//Tilt:
+//m_imu_gyroscope->SetControlExpression(0, "Tilt Backward");
+//m_imu_gyroscope->SetControlExpression(1, "Tilt Forward");
+//m_imu_gyroscope->SetControlExpression(2, "Tilt Left");
+//m_imu_gyroscope->SetControlExpression(3, "Tilt Right");
+//m_imu_gyroscope->SetControlExpression(3, "Tilt Modifier");
+//Swing:
+//m_imu_accelerometer->SetControlExpression(0, "Accel Up");
+//m_imu_accelerometer->SetControlExpression(1, "Accel Down");
+//m_imu_accelerometer->SetControlExpression(2, "Accel Left");
+//m_imu_accelerometer->SetControlExpression(3, "Accel Right");
+//m_imu_accelerometer->SetControlExpression(4, "Accel Forward");
+//m_imu_accelerometer->SetControlExpression(5, "Accel Backward");
+//Gyro:
+//m_imu_gyroscope->SetControlExpression(0, "Gyro Pitch Up");
+//m_imu_gyroscope->SetControlExpression(1, "Gyro Pitch Down");
+//m_imu_gyroscope->SetControlExpression(2, "Gyro Roll Left");
+//m_imu_gyroscope->SetControlExpression(3, "Gyro Roll Right");
+//m_imu_gyroscope->SetControlExpression(4, "Gyro Yaw Left");
+//m_imu_gyroscope->SetControlExpression(5, "Gyro Yaw Right");
+
 typedef enum _OEDolDev
 {
     OEDolDevNone,
@@ -9,80 +48,24 @@ typedef enum _OEDolDev
     OEDolDevPointer
 } OEDolDevs;
 
-typedef enum _OEDolJoyControls
+typedef enum _OEGCDigital
 {
-    OEDolJoypadB,
-    OEDolJoypadY,
-    OEDolJoypadSelect,
-    OEDolJoypadStart,
-    OEDolJoypadUp,
-    OEDolJoypadDown,
-    OEDolJoypadLeft,
-    OEDolJoypadRight,
-    OEDolJoypadA,
-    OEDolJoypadX,
-    OEDolJoypadL,
-    OEDolJoypadR,
-    OEDolJoypadL2,
-    OEDolJoypadR2,
-    OEDolJoypadL3,
-    OEDolJoypadR3
-} OEDolJoyControls;
+    OEGCDigitalL = 21,
+    OEGCDigitalR
+} OEGCDigital;
 
-typedef enum _OEGCAnalogControls
-{
-    OEGCAnalog,
-    OEGCAnalogC,
-    OEGCAnalogTrigger
-} OEGCAnalogContols;
-
-typedef enum _OEDolAnalogAxis
-{
-    OEDolAnalogX,
-    OEDolAnalogY
-} OEDolAnalogAxis;
-
-typedef enum _OEGCAxis
-{
-    OEGCAnalogX,
-    OEGCAnalogY,
-    OEGCAnalogCX,
-    OEGCAnalogCY,
-    OEGCAxisCount
-} OEGCAxis;
-
-typedef enum _OEWiimote
+typedef enum _OEWiiConType
 {
     OEWiimote = 1,
     OEWiimoteSW,
     OEWiimoteNC,
     OEWiimoteCC,
+    OEWiimoteCC_Pro,
     OEWiiMoteReal
-} OEWiiController;
+} OEWiiConType;
 
 namespace Input
 {
-    struct openemu_controller_description
-    {
-        const char *desc;
-        unsigned id;
-    };
-    
-    struct openemu_controller_info
-    {
-        const struct openemu_controller_description *types;
-        unsigned num_types;
-    };
-    
-    struct openemu_input_descriptor
-    {
-        unsigned port;
-        unsigned device;
-        unsigned index;
-        unsigned id;
-        const char *description;
-    };
-    
     typedef int16_t (*openemu_input_state_t)(unsigned port, unsigned device, unsigned index, unsigned id);
     typedef void (*openemu_input_poll_t)();
     
@@ -93,5 +76,4 @@ namespace Input
     void Openemu_Input_Init();
     void OpenEmu_Input_Update();
     void ResetControllers();
-
 }

Compatibility/Video/FramebufferManager.cpp

@@ -1,693 +0,0 @@
-// Copyright 2009 Dolphin Emulator Project
-// Licensed under GPLv2+
-// Refer to the license.txt file included.
-
-#include "VideoBackends/OGL/FramebufferManager.h"
-
-#include <memory>
-#include <sstream>
-#include <vector>
-
-#include "Common/Common.h"
-#include "Common/CommonTypes.h"
-#include "Common/GL/GLInterfaceBase.h"
-#include "Common/Logging/Log.h"
-#include "Common/MsgHandler.h"
-
-#include "Core/HW/Memmap.h"
-
-#include "VideoBackends/OGL/Render.h"
-#include "VideoBackends/OGL/SamplerCache.h"
-#include "VideoBackends/OGL/TextureConverter.h"
-
-#include "VideoCommon/OnScreenDisplay.h"
-#include "VideoCommon/VertexShaderGen.h"
-#include "VideoCommon/VideoBackendBase.h"
-
-namespace OGL
-{
-int FramebufferManager::m_targetWidth;
-int FramebufferManager::m_targetHeight;
-int FramebufferManager::m_msaaSamples;
-bool FramebufferManager::m_enable_stencil_buffer;
-
-GLenum FramebufferManager::m_textureType;
-std::vector<GLuint> FramebufferManager::m_efbFramebuffer;
-GLuint FramebufferManager::m_xfbFramebuffer;
-GLuint FramebufferManager::m_efbColor;
-GLuint FramebufferManager::m_efbDepth;
-GLuint FramebufferManager::m_efbColorSwap;  // for hot swap when reinterpreting EFB pixel formats
-
-// Only used in MSAA mode.
-std::vector<GLuint> FramebufferManager::m_resolvedFramebuffer;
-GLuint FramebufferManager::m_resolvedColorTexture;
-GLuint FramebufferManager::m_resolvedDepthTexture;
-
-// reinterpret pixel format
-SHADER FramebufferManager::m_pixel_format_shaders[2];
-
-// EFB pokes
-GLuint FramebufferManager::m_EfbPokes_VBO;
-GLuint FramebufferManager::m_EfbPokes_VAO;
-SHADER FramebufferManager::m_EfbPokes;
-
-GLuint FramebufferManager::CreateTexture(GLenum texture_type, GLenum internal_format,
-                                         GLenum pixel_format, GLenum data_type)
-{
-  GLuint texture;
-  glGenTextures(1, &texture);
-  glBindTexture(texture_type, texture);
-  if (texture_type == GL_TEXTURE_2D_ARRAY)
-  {
-    glTexParameteri(texture_type, GL_TEXTURE_MAX_LEVEL, 0);
-    glTexImage3D(texture_type, 0, internal_format, m_targetWidth, m_targetHeight, m_EFBLayers, 0,
-                 pixel_format, data_type, nullptr);
-  }
-  else if (texture_type == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
-  {
-    if (g_ogl_config.bSupports3DTextureStorageMultisample)
-      glTexStorage3DMultisample(texture_type, m_msaaSamples, internal_format, m_targetWidth,
-                                m_targetHeight, m_EFBLayers, false);
-    else
-      glTexImage3DMultisample(texture_type, m_msaaSamples, internal_format, m_targetWidth,
-                              m_targetHeight, m_EFBLayers, false);
-  }
-  else if (texture_type == GL_TEXTURE_2D_MULTISAMPLE)
-  {
-    if (g_ogl_config.bSupports2DTextureStorageMultisample)
-      glTexStorage2DMultisample(texture_type, m_msaaSamples, internal_format, m_targetWidth,
-                                m_targetHeight, false);
-    else
-      glTexImage2DMultisample(texture_type, m_msaaSamples, internal_format, m_targetWidth,
-                              m_targetHeight, false);
-  }
-  else
-  {
-    PanicAlert("Unhandled texture type %d", texture_type);
-  }
-  glBindTexture(texture_type, 0);
-  return texture;
-}
-
-void FramebufferManager::BindLayeredTexture(GLuint texture, const std::vector<GLuint>& framebuffers,
-                                            GLenum attachment, GLenum texture_type)
-{
-  glBindFramebuffer(GL_FRAMEBUFFER, framebuffers[0]);
-  FramebufferTexture(GL_FRAMEBUFFER, attachment, texture_type, texture, 0);
-  // Bind all the other layers as separate FBOs for blitting.
-  for (unsigned int i = 1; i < m_EFBLayers; i++)
-  {
-    glBindFramebuffer(GL_FRAMEBUFFER, framebuffers[i]);
-    glFramebufferTextureLayer(GL_FRAMEBUFFER, attachment, texture, 0, i);
-  }
-}
-
-bool FramebufferManager::HasStencilBuffer()
-{
-  return m_enable_stencil_buffer;
-}
-
-FramebufferManager::FramebufferManager(int targetWidth, int targetHeight, int msaaSamples,
-                                       bool enable_stencil_buffer)
-{
-  m_xfbFramebuffer = g_Config.iRenderFBO;
-  m_efbColor = 0;
-  m_efbDepth = 0;
-  m_efbColorSwap = 0;
-  m_resolvedColorTexture = 0;
-  m_resolvedDepthTexture = 0;
-
-  m_targetWidth = targetWidth;
-  m_targetHeight = targetHeight;
-  m_msaaSamples = msaaSamples;
-  m_enable_stencil_buffer = enable_stencil_buffer;
-
-  // The EFB can be set to different pixel formats by the game through the
-  // BPMEM_ZCOMPARE register (which should probably have a different name).
-  // They are:
-  // - 24-bit RGB (8-bit components) with 24-bit Z
-  // - 24-bit RGBA (6-bit components) with 24-bit Z
-  // - Multisampled 16-bit RGB (5-6-5 format) with 16-bit Z
-  // We only use one EFB format here: 32-bit ARGB with 24-bit Z.
-  // Multisampling depends on user settings.
-  // The distinction becomes important for certain operations, i.e. the
-  // alpha channel should be ignored if the EFB does not have one.
-
-  glActiveTexture(GL_TEXTURE9);
-
-  m_EFBLayers = (g_ActiveConfig.iStereoMode > 0) ? 2 : 1;
-  m_efbFramebuffer.resize(m_EFBLayers);
-  m_resolvedFramebuffer.resize(m_EFBLayers);
-
-  GLenum depth_internal_format = GL_DEPTH_COMPONENT32F;
-  GLenum depth_pixel_format = GL_DEPTH_COMPONENT;
-  GLenum depth_data_type = GL_FLOAT;
-  if (m_enable_stencil_buffer)
-  {
-    depth_internal_format = GL_DEPTH32F_STENCIL8;
-    depth_pixel_format = GL_DEPTH_STENCIL;
-    depth_data_type = GL_FLOAT_32_UNSIGNED_INT_24_8_REV;
-  }
-
-  if (m_msaaSamples <= 1)
-  {
-    m_textureType = GL_TEXTURE_2D_ARRAY;
-  }
-  else
-  {
-    // Only use a layered multisample texture if needed. Some drivers
-    // slow down significantly with single-layered multisample textures.
-    if (m_EFBLayers > 1)
-      m_textureType = GL_TEXTURE_2D_MULTISAMPLE_ARRAY;
-    else
-      m_textureType = GL_TEXTURE_2D_MULTISAMPLE;
-
-    // Although we are able to access the multisampled texture directly, we don't do it everywhere.
-    // The old way is to "resolve" this multisampled texture by copying it into a non-sampled
-    // texture.
-    // This would lead to an unneeded copy of the EFB, so we are going to avoid it.
-    // But as this job isn't done right now, we do need that texture for resolving:
-    GLenum resolvedType = GL_TEXTURE_2D_ARRAY;
-
-    m_resolvedColorTexture = CreateTexture(resolvedType, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE);
-    m_resolvedDepthTexture =
-        CreateTexture(resolvedType, depth_internal_format, depth_pixel_format, depth_data_type);
-
-    // Bind resolved textures to resolved framebuffer.
-    glGenFramebuffers(m_EFBLayers, m_resolvedFramebuffer.data());
-    BindLayeredTexture(m_resolvedColorTexture, m_resolvedFramebuffer, GL_COLOR_ATTACHMENT0,
-                       resolvedType);
-    BindLayeredTexture(m_resolvedDepthTexture, m_resolvedFramebuffer, GL_DEPTH_ATTACHMENT,
-                       resolvedType);
-    if (m_enable_stencil_buffer)
-      BindLayeredTexture(m_resolvedDepthTexture, m_resolvedFramebuffer, GL_STENCIL_ATTACHMENT,
-                         resolvedType);
-  }
-
-  m_efbColor = CreateTexture(m_textureType, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE);
-  m_efbDepth =
-      CreateTexture(m_textureType, depth_internal_format, depth_pixel_format, depth_data_type);
-  m_efbColorSwap = CreateTexture(m_textureType, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE);
-
-  // Create XFB framebuffer; targets will be created elsewhere.
-  glGenFramebuffers(1, &m_xfbFramebuffer);
-
-  // Bind target textures to EFB framebuffer.
-  glGenFramebuffers(m_EFBLayers, m_efbFramebuffer.data());
-  BindLayeredTexture(m_efbColor, m_efbFramebuffer, GL_COLOR_ATTACHMENT0, m_textureType);
-  BindLayeredTexture(m_efbDepth, m_efbFramebuffer, GL_DEPTH_ATTACHMENT, m_textureType);
-  if (m_enable_stencil_buffer)
-    BindLayeredTexture(m_efbDepth, m_efbFramebuffer, GL_STENCIL_ATTACHMENT, m_textureType);
-
-  // EFB framebuffer is currently bound, make sure to clear it before use.
-  glViewport(0, 0, m_targetWidth, m_targetHeight);
-  glScissor(0, 0, m_targetWidth, m_targetHeight);
-  glClearColor(0.f, 0.f, 0.f, 0.f);
-  glClearDepthf(1.0f);
-  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-  if (m_enable_stencil_buffer)
-  {
-    glClearStencil(0);
-    glClear(GL_STENCIL_BUFFER_BIT);
-  }
-
-  // reinterpret pixel format
-  const char* vs = m_EFBLayers > 1 ? "void main(void) {\n"
-                                     "	vec2 rawpos = vec2(gl_VertexID&1, gl_VertexID&2);\n"
-                                     "	gl_Position = vec4(rawpos*2.0-1.0, 0.0, 1.0);\n"
-                                     "}\n" :
-                                     "flat out int layer;\n"
-                                     "void main(void) {\n"
-                                     "	layer = 0;\n"
-                                     "	vec2 rawpos = vec2(gl_VertexID&1, gl_VertexID&2);\n"
-                                     "	gl_Position = vec4(rawpos*2.0-1.0, 0.0, 1.0);\n"
-                                     "}\n";
-
-  // The way to sample the EFB is based on the on the current configuration.
-  // As we use the same sampling way for both interpreting shaders, the sampling
-  // shader are generated first:
-  std::string sampler;
-  if (m_msaaSamples <= 1)
-  {
-    // non-msaa, so just fetch the pixel
-    sampler = "SAMPLER_BINDING(9) uniform sampler2DArray samp9;\n"
-              "vec4 sampleEFB(ivec3 pos) {\n"
-              "	return texelFetch(samp9, pos, 0);\n"
-              "}\n";
-  }
-  else if (g_ActiveConfig.backend_info.bSupportsSSAA)
-  {
-    // msaa + sample shading available, so just fetch the sample
-    // This will lead to sample shading, but it's the only way to not loose
-    // the values of each sample.
-    if (m_EFBLayers > 1)
-    {
-      sampler = "SAMPLER_BINDING(9) uniform sampler2DMSArray samp9;\n"
-                "vec4 sampleEFB(ivec3 pos) {\n"
-                "	return texelFetch(samp9, pos, gl_SampleID);\n"
-                "}\n";
-    }
-    else
-    {
-      sampler = "SAMPLER_BINDING(9) uniform sampler2DMS samp9;\n"
-                "vec4 sampleEFB(ivec3 pos) {\n"
-                "	return texelFetch(samp9, pos.xy, gl_SampleID);\n"
-                "}\n";
-    }
-  }
-  else
-  {
-    // msaa without sample shading: calculate the mean value of the pixel
-    std::stringstream samples;
-    samples << m_msaaSamples;
-    if (m_EFBLayers > 1)
-    {
-      sampler = "SAMPLER_BINDING(9) uniform sampler2DMSArray samp9;\n"
-                "vec4 sampleEFB(ivec3 pos) {\n"
-                "	vec4 color = vec4(0.0, 0.0, 0.0, 0.0);\n"
-                "	for(int i=0; i<" +
-                samples.str() + "; i++)\n"
-                                "		color += texelFetch(samp9, pos, i);\n"
-                                "	return color / " +
-                samples.str() + ";\n"
-                                "}\n";
-    }
-    else
-    {
-      sampler = "SAMPLER_BINDING(9) uniform sampler2DMS samp9;\n"
-                "vec4 sampleEFB(ivec3 pos) {\n"
-                "	vec4 color = vec4(0.0, 0.0, 0.0, 0.0);\n"
-                "	for(int i=0; i<" +
-                samples.str() + "; i++)\n"
-                                "		color += texelFetch(samp9, pos.xy, i);\n"
-                                "	return color / " +
-                samples.str() + ";\n"
-                                "}\n";
-    }
-  }
-
-  std::string ps_rgba6_to_rgb8 =
-      sampler + "flat in int layer;\n"
-                "out vec4 ocol0;\n"
-                "void main()\n"
-                "{\n"
-                "	ivec4 src6 = ivec4(round(sampleEFB(ivec3(gl_FragCoord.xy, layer)) * 63.f));\n"
-                "	ivec4 dst8;\n"
-                "	dst8.r = (src6.r << 2) | (src6.g >> 4);\n"
-                "	dst8.g = ((src6.g & 0xF) << 4) | (src6.b >> 2);\n"
-                "	dst8.b = ((src6.b & 0x3) << 6) | src6.a;\n"
-                "	dst8.a = 255;\n"
-                "	ocol0 = float4(dst8) / 255.f;\n"
-                "}";
-
-  std::string ps_rgb8_to_rgba6 =
-      sampler + "flat in int layer;\n"
-                "out vec4 ocol0;\n"
-                "void main()\n"
-                "{\n"
-                "	ivec4 src8 = ivec4(round(sampleEFB(ivec3(gl_FragCoord.xy, layer)) * 255.f));\n"
-                "	ivec4 dst6;\n"
-                "	dst6.r = src8.r >> 2;\n"
-                "	dst6.g = ((src8.r & 0x3) << 4) | (src8.g >> 4);\n"
-                "	dst6.b = ((src8.g & 0xF) << 2) | (src8.b >> 6);\n"
-                "	dst6.a = src8.b & 0x3F;\n"
-                "	ocol0 = float4(dst6) / 63.f;\n"
-                "}";
-
-  std::stringstream vertices, layers;
-  vertices << m_EFBLayers * 3;
-  layers << m_EFBLayers;
-  std::string gs = "layout(triangles) in;\n"
-                   "layout(triangle_strip, max_vertices = " +
-                   vertices.str() + ") out;\n"
-                                    "flat out int layer;\n"
-                                    "void main()\n"
-                                    "{\n"
-                                    "	for (int j = 0; j < " +
-                   layers.str() + "; ++j) {\n"
-                                  "		for (int i = 0; i < 3; ++i) {\n"
-                                  "			layer = j;\n"
-                                  "			gl_Layer = j;\n"
-                                  "			gl_Position = gl_in[i].gl_Position;\n"
-                                  "			EmitVertex();\n"
-                                  "		}\n"
-                                  "		EndPrimitive();\n"
-                                  "	}\n"
-                                  "}\n";
-
-  ProgramShaderCache::CompileShader(m_pixel_format_shaders[0], vs, ps_rgb8_to_rgba6,
-                                    (m_EFBLayers > 1) ? gs : "");
-  ProgramShaderCache::CompileShader(m_pixel_format_shaders[1], vs, ps_rgba6_to_rgb8,
-                                    (m_EFBLayers > 1) ? gs : "");
-
-  ProgramShaderCache::CompileShader(
-      m_EfbPokes,
-      StringFromFormat("in vec2 rawpos;\n"
-                       "in vec4 rawcolor0;\n"  // color
-                       "in int rawcolor1;\n"   // depth
-                       "out vec4 v_c;\n"
-                       "out float v_z;\n"
-                       "void main(void) {\n"
-                       "	gl_Position = vec4(((rawpos + 0.5) / vec2(640.0, 528.0) * 2.0 - 1.0) * "
-                       "vec2(1.0, -1.0), 0.0, 1.0);\n"
-                       "	gl_PointSize = %d.0 / 640.0;\n"
-                       "	v_c = rawcolor0.bgra;\n"
-                       "	v_z = float(rawcolor1 & 0xFFFFFF) / 16777216.0;\n"
-                       "}\n",
-                       m_targetWidth),
-
-      StringFromFormat("in vec4 %s_c;\n"
-                       "in float %s_z;\n"
-                       "out vec4 ocol0;\n"
-                       "void main(void) {\n"
-                       "	ocol0 = %s_c;\n"
-                       "	gl_FragDepth = %s_z;\n"
-                       "}\n",
-                       m_EFBLayers > 1 ? "g" : "v", m_EFBLayers > 1 ? "g" : "v",
-                       m_EFBLayers > 1 ? "g" : "v", m_EFBLayers > 1 ? "g" : "v"),
-
-      m_EFBLayers > 1 ? StringFromFormat("layout(points) in;\n"
-                                         "layout(points, max_vertices = %d) out;\n"
-                                         "in vec4 v_c[1];\n"
-                                         "in float v_z[1];\n"
-                                         "out vec4 g_c;\n"
-                                         "out float g_z;\n"
-                                         "void main()\n"
-                                         "{\n"
-                                         "	for (int j = 0; j < %d; ++j) {\n"
-                                         "		gl_Layer = j;\n"
-                                         "		gl_Position = gl_in[0].gl_Position;\n"
-                                         "		gl_PointSize = %d.0 / 640.0;\n"
-                                         "		g_c = v_c[0];\n"
-                                         "		g_z = v_z[0];\n"
-                                         "		EmitVertex();\n"
-                                         "		EndPrimitive();\n"
-                                         "	}\n"
-                                         "}\n",
-                                         m_EFBLayers, m_EFBLayers, m_targetWidth) :
-                        "");
-  glGenBuffers(1, &m_EfbPokes_VBO);
-  glGenVertexArrays(1, &m_EfbPokes_VAO);
-  glBindBuffer(GL_ARRAY_BUFFER, m_EfbPokes_VBO);
-  glBindVertexArray(m_EfbPokes_VAO);
-  glEnableVertexAttribArray(SHADER_POSITION_ATTRIB);
-  glVertexAttribPointer(SHADER_POSITION_ATTRIB, 2, GL_UNSIGNED_SHORT, 0, sizeof(EfbPokeData),
-                        (void*)offsetof(EfbPokeData, x));
-  glEnableVertexAttribArray(SHADER_COLOR0_ATTRIB);
-  glVertexAttribPointer(SHADER_COLOR0_ATTRIB, 4, GL_UNSIGNED_BYTE, 1, sizeof(EfbPokeData),
-                        (void*)offsetof(EfbPokeData, data));
-  glEnableVertexAttribArray(SHADER_COLOR1_ATTRIB);
-  glVertexAttribIPointer(SHADER_COLOR1_ATTRIB, 1, GL_INT, sizeof(EfbPokeData),
-                         (void*)offsetof(EfbPokeData, data));
-
-  if (GLInterface->GetMode() == GLInterfaceMode::MODE_OPENGL)
-    glEnable(GL_PROGRAM_POINT_SIZE);
-}
-
-FramebufferManager::~FramebufferManager()
-{
-    glBindFramebuffer(GL_FRAMEBUFFER, g_Config.iRenderFBO);
-
-  GLuint glObj[3];
-
-  // Note: OpenGL deletion functions silently ignore parameters of "0".
-
-  glDeleteFramebuffers(m_EFBLayers, m_efbFramebuffer.data());
-  glDeleteFramebuffers(m_EFBLayers, m_resolvedFramebuffer.data());
-
-  // Required, as these are static class members
-  m_efbFramebuffer.clear();
-  m_resolvedFramebuffer.clear();
-
-  glDeleteFramebuffers(1, &m_xfbFramebuffer);
-  m_xfbFramebuffer = g_Config.iRenderFBO;
-
-  glObj[0] = m_resolvedColorTexture;
-  glObj[1] = m_resolvedDepthTexture;
-  glDeleteTextures(2, glObj);
-  m_resolvedColorTexture = 0;
-  m_resolvedDepthTexture = 0;
-
-  glObj[0] = m_efbColor;
-  glObj[1] = m_efbDepth;
-  glObj[2] = m_efbColorSwap;
-  glDeleteTextures(3, glObj);
-  m_efbColor = 0;
-  m_efbDepth = 0;
-  m_efbColorSwap = 0;
-
-  // reinterpret pixel format
-  m_pixel_format_shaders[0].Destroy();
-  m_pixel_format_shaders[1].Destroy();
-
-  // EFB pokes
-  glDeleteBuffers(1, &m_EfbPokes_VBO);
-  glDeleteVertexArrays(1, &m_EfbPokes_VAO);
-  m_EfbPokes_VBO = 0;
-  m_EfbPokes_VAO = 0;
-  m_EfbPokes.Destroy();
-}
-
-GLuint FramebufferManager::GetEFBColorTexture(const EFBRectangle& sourceRc)
-{
-  if (m_msaaSamples <= 1)
-  {
-    return m_efbColor;
-  }
-  else
-  {
-    // Transfer the EFB to a resolved texture. EXT_framebuffer_blit is
-    // required.
-
-    TargetRectangle targetRc = g_renderer->ConvertEFBRectangle(sourceRc);
-    targetRc.ClampUL(0, 0, m_targetWidth, m_targetHeight);
-
-    // Resolve.
-    for (unsigned int i = 0; i < m_EFBLayers; i++)
-    {
-      glBindFramebuffer(GL_READ_FRAMEBUFFER, m_efbFramebuffer[i]);
-      glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_resolvedFramebuffer[i]);
-      glBlitFramebuffer(targetRc.left, targetRc.top, targetRc.right, targetRc.bottom, targetRc.left,
-                        targetRc.top, targetRc.right, targetRc.bottom, GL_COLOR_BUFFER_BIT,
-                        GL_NEAREST);
-    }
-
-    // Return to EFB.
-    glBindFramebuffer(GL_FRAMEBUFFER, m_efbFramebuffer[0]);
-
-    return m_resolvedColorTexture;
-  }
-}
-
-GLuint FramebufferManager::GetEFBDepthTexture(const EFBRectangle& sourceRc)
-{
-  if (m_msaaSamples <= 1)
-  {
-    return m_efbDepth;
-  }
-  else
-  {
-    // Transfer the EFB to a resolved texture.
-
-    TargetRectangle targetRc = g_renderer->ConvertEFBRectangle(sourceRc);
-    targetRc.ClampUL(0, 0, m_targetWidth, m_targetHeight);
-
-    // Resolve.
-    for (unsigned int i = 0; i < m_EFBLayers; i++)
-    {
-      glBindFramebuffer(GL_READ_FRAMEBUFFER, m_efbFramebuffer[i]);
-      glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_resolvedFramebuffer[i]);
-      glBlitFramebuffer(targetRc.left, targetRc.top, targetRc.right, targetRc.bottom, targetRc.left,
-                        targetRc.top, targetRc.right, targetRc.bottom, GL_DEPTH_BUFFER_BIT,
-                        GL_NEAREST);
-    }
-
-    // Return to EFB.
-    glBindFramebuffer(GL_FRAMEBUFFER, m_efbFramebuffer[0]);
-
-    return m_resolvedDepthTexture;
-  }
-}
-
-void FramebufferManager::ResolveEFBStencilTexture()
-{
-  if (m_msaaSamples <= 1)
-    return;
-
-  // Resolve.
-  for (unsigned int i = 0; i < m_EFBLayers; i++)
-  {
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, m_efbFramebuffer[i]);
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_resolvedFramebuffer[i]);
-    glBlitFramebuffer(0, 0, m_targetWidth, m_targetHeight, 0, 0, m_targetWidth, m_targetHeight,
-                      GL_STENCIL_BUFFER_BIT, GL_NEAREST);
-  }
-
-  // Return to EFB.
-  glBindFramebuffer(GL_FRAMEBUFFER, m_efbFramebuffer[0]);
-}
-
-void FramebufferManager::CopyToRealXFB(u32 xfbAddr, u32 fbStride, u32 fbHeight,
-                                       const EFBRectangle& sourceRc, float Gamma)
-{
-  u8* xfb_in_ram = Memory::GetPointer(xfbAddr);
-  if (!xfb_in_ram)
-  {
-    WARN_LOG(VIDEO, "Tried to copy to invalid XFB address");
-    return;
-  }
-
-  TargetRectangle targetRc = g_renderer->ConvertEFBRectangle(sourceRc);
-  TextureConverter::EncodeToRamYUYV(ResolveAndGetRenderTarget(sourceRc), targetRc, xfb_in_ram,
-                                    sourceRc.GetWidth(), fbStride, fbHeight);
-}
-
-GLuint FramebufferManager::GetResolvedFramebuffer()
-{
-  if (m_msaaSamples <= 1)
-    return m_efbFramebuffer[0];
-  return m_resolvedFramebuffer[0];
-}
-
-void FramebufferManager::SetFramebuffer(GLuint fb)
-{
-  glBindFramebuffer(GL_FRAMEBUFFER, fb != 0 ? fb : GetEFBFramebuffer());
-}
-
-void FramebufferManager::FramebufferTexture(GLenum target, GLenum attachment, GLenum textarget,
-                                            GLuint texture, GLint level)
-{
-  if (textarget == GL_TEXTURE_2D_ARRAY || textarget == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
-  {
-    if (m_EFBLayers > 1)
-      glFramebufferTexture(target, attachment, texture, level);
-    else
-      glFramebufferTextureLayer(target, attachment, texture, level, 0);
-  }
-  else
-  {
-    glFramebufferTexture2D(target, attachment, textarget, texture, level);
-  }
-}
-
-// Apply AA if enabled
-GLuint FramebufferManager::ResolveAndGetRenderTarget(const EFBRectangle& source_rect)
-{
-  return GetEFBColorTexture(source_rect);
-}
-
-GLuint FramebufferManager::ResolveAndGetDepthTarget(const EFBRectangle& source_rect)
-{
-  return GetEFBDepthTexture(source_rect);
-}
-
-void FramebufferManager::ReinterpretPixelData(unsigned int convtype)
-{
-  g_renderer->ResetAPIState();
-
-  OpenGL_BindAttributelessVAO();
-
-  GLuint src_texture = 0;
-
-  // We aren't allowed to render and sample the same texture in one draw call,
-  // so we have to create a new texture and overwrite it completely.
-  // To not allocate one big texture every time, we've allocated two on
-  // initialization and just swap them here:
-  src_texture = m_efbColor;
-  m_efbColor = m_efbColorSwap;
-  m_efbColorSwap = src_texture;
-  FramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_textureType, m_efbColor, 0);
-
-  glViewport(0, 0, m_targetWidth, m_targetHeight);
-  glActiveTexture(GL_TEXTURE9);
-  glBindTexture(m_textureType, src_texture);
-  g_sampler_cache->BindNearestSampler(9);
-
-  m_pixel_format_shaders[convtype ? 1 : 0].Bind();
-  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-  glBindTexture(m_textureType, 0);
-
-  g_renderer->RestoreAPIState();
-}
-
-XFBSource::~XFBSource()
-{
-  glDeleteTextures(1, &texture);
-}
-
-void XFBSource::DecodeToTexture(u32 xfbAddr, u32 fbWidth, u32 fbHeight)
-{
-  TextureConverter::DecodeToTexture(xfbAddr, fbWidth, fbHeight, texture);
-}
-
-void XFBSource::CopyEFB(float Gamma)
-{
-  g_renderer->ResetAPIState();
-
-  // Copy EFB data to XFB and restore render target again
-  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, FramebufferManager::GetXFBFramebuffer());
-
-  for (int i = 0; i < m_layers; i++)
-  {
-    // Bind EFB and texture layer
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, FramebufferManager::GetEFBFramebuffer(i));
-    glFramebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texture, 0, i);
-
-    glBlitFramebuffer(0, 0, texWidth, texHeight, 0, 0, texWidth, texHeight, GL_COLOR_BUFFER_BIT,
-                      GL_NEAREST);
-  }
-
-  // Return to EFB.
-  FramebufferManager::SetFramebuffer(0);
-
-  g_renderer->RestoreAPIState();
-}
-
-std::unique_ptr<XFBSourceBase> FramebufferManager::CreateXFBSource(unsigned int target_width,
-                                                                   unsigned int target_height,
-                                                                   unsigned int layers)
-{
-  GLuint texture;
-
-  glGenTextures(1, &texture);
-
-  glActiveTexture(GL_TEXTURE9);
-  glBindTexture(GL_TEXTURE_2D_ARRAY, texture);
-  glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, 0);
-  glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, target_width, target_height, layers, 0, GL_RGBA,
-               GL_UNSIGNED_BYTE, nullptr);
-
-  return std::make_unique<XFBSource>(texture, layers);
-}
-
-std::pair<u32, u32> FramebufferManager::GetTargetSize() const
-{
-  return std::make_pair(m_targetWidth, m_targetHeight);
-}
-
-void FramebufferManager::PokeEFB(EFBAccessType type, const EfbPokeData* points, size_t num_points)
-{
-  g_renderer->ResetAPIState();
-
-  if (type == EFBAccessType::PokeZ)
-  {
-    glDepthMask(GL_TRUE);
-    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
-    glEnable(GL_DEPTH_TEST);
-    glDepthFunc(GL_ALWAYS);
-  }
-
-  glBindVertexArray(m_EfbPokes_VAO);
-  glBindBuffer(GL_ARRAY_BUFFER, m_EfbPokes_VBO);
-  glBufferData(GL_ARRAY_BUFFER, sizeof(EfbPokeData) * num_points, points, GL_STREAM_DRAW);
-  m_EfbPokes.Bind();
-  glViewport(0, 0, m_targetWidth, m_targetHeight);
-  glDrawArrays(GL_POINTS, 0, (GLsizei)num_points);
-
-  g_renderer->RestoreAPIState();
-
-  // TODO: Could just update the EFB cache with the new value
-  ClearEFBCache();
-}
-
-}  // namespace OGL

Compatibility/Video/MTLGfx.mm

@@ -0,0 +1,524 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "VideoBackends/Metal/MTLGfx.h"
+
+#include "VideoBackends/Metal/MTLBoundingBox.h"
+#include "VideoBackends/Metal/MTLObjectCache.h"
+#include "VideoBackends/Metal/MTLPipeline.h"
+#include "VideoBackends/Metal/MTLStateTracker.h"
+#include "VideoBackends/Metal/MTLTexture.h"
+#include "VideoBackends/Metal/MTLUtil.h"
+#include "VideoBackends/Metal/MTLVertexFormat.h"
+#include "VideoBackends/Metal/MTLVertexManager.h"
+
+#include "VideoCommon/FramebufferManager.h"
+#include "VideoCommon/Present.h"
+#include "VideoCommon/VideoBackendBase.h"
+
+#import "DolphinGameCore.h"
+
+#include <fstream>
+
+Metal::Gfx::Gfx(MRCOwned<CAMetalLayer*> layer) : m_layer(std::move(layer))
+{
+  UpdateActiveConfig();
+  [m_layer setDisplaySyncEnabled:g_ActiveConfig.bVSyncActive];
+
+  SetupSurface();
+  g_state_tracker->FlushEncoders();
+}
+
+Metal::Gfx::~Gfx() = default;
+
+bool Metal::Gfx::IsHeadless() const
+{
+  return m_layer == nullptr;
+}
+
+// MARK: Texture Creation
+
+std::unique_ptr<AbstractTexture> Metal::Gfx::CreateTexture(const TextureConfig& config,
+                                                           std::string_view name)
+{
+  @autoreleasepool
+  {
+    MRCOwned<MTLTextureDescriptor*> desc = MRCTransfer([MTLTextureDescriptor new]);
+    [desc setTextureType:config.samples > 1 ? MTLTextureType2DMultisampleArray :
+                                              MTLTextureType2DArray];
+    [desc setPixelFormat:Util::FromAbstract(config.format)];
+    [desc setWidth:config.width];
+    [desc setHeight:config.height];
+    [desc setMipmapLevelCount:config.levels];
+    [desc setArrayLength:config.layers];
+    [desc setSampleCount:config.samples];
+    [desc setStorageMode:MTLStorageModePrivate];
+    MTLTextureUsage usage = MTLTextureUsageShaderRead;
+    if (config.IsRenderTarget())
+      usage |= MTLTextureUsageRenderTarget;
+    if (config.IsComputeImage())
+      usage |= MTLTextureUsageShaderWrite;
+    [desc setUsage:usage];
+    id<MTLTexture> texture = [g_device newTextureWithDescriptor:desc];
+    if (!texture)
+      return nullptr;
+
+    if (name.empty())
+      [texture setLabel:[NSString stringWithFormat:@"Texture %d", m_texture_counter++]];
+    else
+      [texture setLabel:MRCTransfer([[NSString alloc] initWithBytes:name.data()
+                                                             length:name.size()
+                                                           encoding:NSUTF8StringEncoding])];
+    return std::make_unique<Texture>(MRCTransfer(texture), config);
+  }
+}
+
+std::unique_ptr<AbstractStagingTexture>
+Metal::Gfx::CreateStagingTexture(StagingTextureType type, const TextureConfig& config)
+{
+  @autoreleasepool
+  {
+    const size_t stride = config.GetStride();
+    const size_t buffer_size = stride * static_cast<size_t>(config.height);
+
+    MTLResourceOptions options = MTLStorageModeShared;
+    if (type == StagingTextureType::Upload)
+      options |= MTLResourceCPUCacheModeWriteCombined;
+
+    id<MTLBuffer> buffer = [g_device newBufferWithLength:buffer_size options:options];
+    if (!buffer)
+      return nullptr;
+    [buffer
+        setLabel:[NSString stringWithFormat:@"Staging Texture %d", m_staging_texture_counter++]];
+    return std::make_unique<StagingTexture>(MRCTransfer(buffer), type, config);
+  }
+}
+
+std::unique_ptr<AbstractFramebuffer>
+Metal::Gfx::CreateFramebuffer(AbstractTexture* color_attachment, AbstractTexture* depth_attachment)
+{
+  AbstractTexture* const either_attachment = color_attachment ? color_attachment : depth_attachment;
+  return std::make_unique<Framebuffer>(
+      color_attachment, depth_attachment, either_attachment->GetWidth(),
+      either_attachment->GetHeight(), either_attachment->GetLayers(),
+      either_attachment->GetSamples());
+}
+
+// MARK: Pipeline Creation
+
+std::unique_ptr<AbstractShader> Metal::Gfx::CreateShaderFromSource(ShaderStage stage,
+                                                                   std::string_view source,
+                                                                   std::string_view name)
+{
+  std::optional<std::string> msl = Util::TranslateShaderToMSL(stage, source);
+  if (!msl.has_value())
+  {
+    PanicAlertFmt("Failed to convert shader {} to MSL", name);
+    return nullptr;
+  }
+
+  return CreateShaderFromMSL(stage, std::move(*msl), source, name);
+}
+
+std::unique_ptr<AbstractShader> Metal::Gfx::CreateShaderFromBinary(ShaderStage stage,
+                                                                   const void* data, size_t length,
+                                                                   std::string_view name)
+{
+  return CreateShaderFromMSL(stage, std::string(static_cast<const char*>(data), length), {}, name);
+}
+
+// clang-format off
+
+static const char* StageFilename(ShaderStage stage)
+{
+  switch (stage)
+  {
+  case ShaderStage::Vertex:   return "vs";
+  case ShaderStage::Geometry: return "gs";
+  case ShaderStage::Pixel:    return "ps";
+  case ShaderStage::Compute:  return "cs";
+  }
+}
+
+static NSString* GenericShaderName(ShaderStage stage)
+{
+  switch (stage)
+  {
+  case ShaderStage::Vertex:   return @"Vertex shader %d";
+  case ShaderStage::Geometry: return @"Geometry shader %d";
+  case ShaderStage::Pixel:    return @"Pixel shader %d";
+  case ShaderStage::Compute:  return @"Compute shader %d";
+  }
+}
+
+// clang-format on
+
+std::unique_ptr<AbstractShader> Metal::Gfx::CreateShaderFromMSL(ShaderStage stage, std::string msl,
+                                                                std::string_view glsl,
+                                                                std::string_view name)
+{
+  @autoreleasepool
+  {
+    NSError* err = nullptr;
+    auto DumpBadShader = [&](std::string_view msg) {
+      static int counter = 0;
+      std::string filename = VideoBackendBase::BadShaderFilename(StageFilename(stage), counter++);
+      std::ofstream stream(filename);
+      if (stream.good())
+      {
+        stream << msl << std::endl;
+        stream << "/*" << std::endl;
+        stream << msg << std::endl;
+        stream << "Error:" << std::endl;
+        stream << [[err localizedDescription] UTF8String] << std::endl;
+        if (!glsl.empty())
+        {
+          stream << "Original GLSL:" << std::endl;
+          stream << glsl << std::endl;
+        }
+        else
+        {
+          stream << "Shader was created with cached MSL so no GLSL is available." << std::endl;
+        }
+      }
+
+      stream << std::endl;
+      stream << "Dolphin Version: " << Common::GetScmRevStr() << std::endl;
+      stream << "Video Backend: " << g_video_backend->GetDisplayName() << std::endl;
+      stream << "*/" << std::endl;
+      stream.close();
+
+      PanicAlertFmt("{} (written to {})\n", msg, filename);
+    };
+
+    auto lib = MRCTransfer([g_device newLibraryWithSource:[NSString stringWithUTF8String:msl.data()]
+                                                  options:nil
+                                                    error:&err]);
+    if (err)
+    {
+      DumpBadShader(fmt::format("Failed to compile {}", name));
+      return nullptr;
+    }
+    auto fn = MRCTransfer([lib newFunctionWithName:@"main0"]);
+    if (!fn)
+    {
+      DumpBadShader(fmt::format("Shader {} is missing its main0 function", name));
+      return nullptr;
+    }
+    if (!name.empty())
+      [fn setLabel:MRCTransfer([[NSString alloc] initWithBytes:name.data()
+                                                        length:name.size()
+                                                      encoding:NSUTF8StringEncoding])];
+    else
+      [fn setLabel:[NSString stringWithFormat:GenericShaderName(stage),
+                                              m_shader_counter[static_cast<u32>(stage)]++]];
+    [lib setLabel:[fn label]];
+    if (stage == ShaderStage::Compute)
+    {
+      MTLComputePipelineReflection* reflection = nullptr;
+      auto desc = [MTLComputePipelineDescriptor new];
+      [desc setComputeFunction:fn];
+      [desc setLabel:[fn label]];
+      MRCOwned<id<MTLComputePipelineState>> pipeline =
+          MRCTransfer([g_device newComputePipelineStateWithDescriptor:desc
+                                                              options:MTLPipelineOptionArgumentInfo
+                                                           reflection:&reflection
+                                                                error:&err]);
+      if (err)
+      {
+        DumpBadShader(fmt::format("Failed to compile compute pipeline {}", name));
+        return nullptr;
+      }
+      return std::make_unique<ComputePipeline>(stage, reflection, std::move(msl), std::move(fn),
+                                               std::move(pipeline));
+    }
+    return std::make_unique<Shader>(stage, std::move(msl), std::move(fn));
+  }
+}
+
+std::unique_ptr<NativeVertexFormat>
+Metal::Gfx::CreateNativeVertexFormat(const PortableVertexDeclaration& vtx_decl)
+{
+  @autoreleasepool
+  {
+    return std::make_unique<VertexFormat>(vtx_decl);
+  }
+}
+
+std::unique_ptr<AbstractPipeline> Metal::Gfx::CreatePipeline(const AbstractPipelineConfig& config,
+                                                             const void* cache_data,
+                                                             size_t cache_data_length)
+{
+  return g_object_cache->CreatePipeline(config);
+}
+
+void Metal::Gfx::Flush()
+{
+  @autoreleasepool
+  {
+    g_state_tracker->FlushEncoders();
+  }
+}
+
+void Metal::Gfx::WaitForGPUIdle()
+{
+  @autoreleasepool
+  {
+    g_state_tracker->FlushEncoders();
+    g_state_tracker->WaitForFlushedEncoders();
+  }
+}
+
+void Metal::Gfx::OnConfigChanged(u32 bits)
+{
+  AbstractGfx::OnConfigChanged(bits);
+
+  if (bits & CONFIG_CHANGE_BIT_VSYNC)
+    [m_layer setDisplaySyncEnabled:g_ActiveConfig.bVSyncActive];
+
+  if (bits & CONFIG_CHANGE_BIT_ANISOTROPY)
+  {
+    g_object_cache->ReloadSamplers();
+    g_state_tracker->ReloadSamplers();
+  }
+}
+
+void Metal::Gfx::ClearRegion(const MathUtil::Rectangle<int>& target_rc, bool color_enable,
+                             bool alpha_enable, bool z_enable, u32 color, u32 z)
+{
+  u32 framebuffer_width = m_current_framebuffer->GetWidth();
+  u32 framebuffer_height = m_current_framebuffer->GetHeight();
+  // All Metal render passes are fullscreen, so we can only run a fast clear if the target is too
+  if (target_rc == MathUtil::Rectangle<int>(0, 0, framebuffer_width, framebuffer_height))
+  {
+    // Determine whether the EFB has an alpha channel. If it doesn't, we can clear the alpha
+    // channel to 0xFF. This hopefully allows us to use the fast path in most cases.
+    if (bpmem.zcontrol.pixel_format == PixelFormat::RGB565_Z16 ||
+        bpmem.zcontrol.pixel_format == PixelFormat::RGB8_Z24 ||
+        bpmem.zcontrol.pixel_format == PixelFormat::Z24)
+    {
+      // Force alpha writes, and clear the alpha channel. This is different from the other backends,
+      // where the existing values of the alpha channel are preserved.
+      alpha_enable = true;
+      color &= 0x00FFFFFF;
+    }
+
+    bool c_ok = (color_enable && alpha_enable) ||
+                g_state_tracker->GetCurrentFramebuffer()->GetColorFormat() ==
+                    AbstractTextureFormat::Undefined;
+    bool z_ok = z_enable || g_state_tracker->GetCurrentFramebuffer()->GetDepthFormat() ==
+                                AbstractTextureFormat::Undefined;
+    if (c_ok && z_ok)
+    {
+      @autoreleasepool
+      {
+        // clang-format off
+        MTLClearColor clear_color = MTLClearColorMake(
+            static_cast<double>((color >> 16) & 0xFF) / 255.0,
+            static_cast<double>((color >>  8) & 0xFF) / 255.0,
+            static_cast<double>((color >>  0) & 0xFF) / 255.0,
+            static_cast<double>((color >> 24) & 0xFF) / 255.0);
+        // clang-format on
+        float z_normalized = static_cast<float>(z & 0xFFFFFF) / 16777216.0f;
+        if (!g_Config.backend_info.bSupportsReversedDepthRange)
+          z_normalized = 1.f - z_normalized;
+        g_state_tracker->BeginClearRenderPass(clear_color, z_normalized);
+        return;
+      }
+    }
+  }
+
+  g_state_tracker->EnableEncoderLabel(false);
+  AbstractGfx::ClearRegion(target_rc, color_enable, alpha_enable, z_enable, color, z);
+  g_state_tracker->EnableEncoderLabel(true);
+}
+
+void Metal::Gfx::SetPipeline(const AbstractPipeline* pipeline)
+{
+  g_state_tracker->SetPipeline(static_cast<const Pipeline*>(pipeline));
+}
+
+void Metal::Gfx::SetFramebuffer(AbstractFramebuffer* framebuffer)
+{
+  // Shouldn't be bound as a texture.
+  if (AbstractTexture* color = framebuffer->GetColorAttachment())
+    g_state_tracker->UnbindTexture(static_cast<Texture*>(color)->GetMTLTexture());
+  if (AbstractTexture* depth = framebuffer->GetDepthAttachment())
+    g_state_tracker->UnbindTexture(static_cast<Texture*>(depth)->GetMTLTexture());
+
+  m_current_framebuffer = framebuffer;
+  g_state_tracker->SetCurrentFramebuffer(static_cast<Framebuffer*>(framebuffer));
+}
+
+void Metal::Gfx::SetAndDiscardFramebuffer(AbstractFramebuffer* framebuffer)
+{
+  @autoreleasepool
+  {
+    SetFramebuffer(framebuffer);
+    g_state_tracker->BeginRenderPass(MTLLoadActionDontCare);
+  }
+}
+
+void Metal::Gfx::SetAndClearFramebuffer(AbstractFramebuffer* framebuffer,
+                                        const ClearColor& color_value, float depth_value)
+{
+  @autoreleasepool
+  {
+    SetFramebuffer(framebuffer);
+    MTLClearColor color =
+        MTLClearColorMake(color_value[0], color_value[1], color_value[2], color_value[3]);
+    g_state_tracker->BeginClearRenderPass(color, depth_value);
+  }
+}
+
+void Metal::Gfx::SetScissorRect(const MathUtil::Rectangle<int>& rc)
+{
+  g_state_tracker->SetScissor(rc);
+}
+
+void Metal::Gfx::SetTexture(u32 index, const AbstractTexture* texture)
+{
+  g_state_tracker->SetTexture(
+      index, texture ? static_cast<const Texture*>(texture)->GetMTLTexture() : nullptr);
+}
+
+void Metal::Gfx::SetSamplerState(u32 index, const SamplerState& state)
+{
+  g_state_tracker->SetSampler(index, state);
+}
+
+void Metal::Gfx::SetComputeImageTexture(AbstractTexture* texture, bool read, bool write)
+{
+  g_state_tracker->SetComputeTexture(static_cast<const Texture*>(texture));
+}
+
+void Metal::Gfx::UnbindTexture(const AbstractTexture* texture)
+{
+  g_state_tracker->UnbindTexture(static_cast<const Texture*>(texture)->GetMTLTexture());
+}
+
+void Metal::Gfx::SetViewport(float x, float y, float width, float height, float near_depth,
+                             float far_depth)
+{
+  g_state_tracker->SetViewport(x, y, width, height, near_depth, far_depth);
+}
+
+void Metal::Gfx::Draw(u32 base_vertex, u32 num_vertices)
+{
+  @autoreleasepool
+  {
+    g_state_tracker->Draw(base_vertex, num_vertices);
+  }
+}
+
+void Metal::Gfx::DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex)
+{
+  @autoreleasepool
+  {
+    g_state_tracker->DrawIndexed(base_index, num_indices, base_vertex);
+  }
+}
+
+void Metal::Gfx::DispatchComputeShader(const AbstractShader* shader,  //
+                                       u32 groupsize_x, u32 groupsize_y, u32 groupsize_z,
+                                       u32 groups_x, u32 groups_y, u32 groups_z)
+{
+  @autoreleasepool
+  {
+    g_state_tracker->SetPipeline(static_cast<const ComputePipeline*>(shader));
+    g_state_tracker->DispatchComputeShader(groupsize_x, groupsize_y, groupsize_z,  //
+                                           groups_x, groups_y, groups_z);
+  }
+}
+
+void Metal::Gfx::BindBackbuffer(const ClearColor& clear_color)
+{
+  @autoreleasepool
+  {
+    CheckForSurfaceChange();
+    CheckForSurfaceResize();
+    m_drawable = MRCRetain([m_layer nextDrawable]);
+    m_bb_texture->SetMTLTexture(MRCRetain([m_drawable texture]));
+    SetAndClearFramebuffer(m_backbuffer.get(), clear_color);
+  }
+}
+
+void Metal::Gfx::PresentBackbuffer()
+{
+  @autoreleasepool
+  {
+    g_state_tracker->EndRenderPass();
+    if (m_drawable)
+    {
+      //OpenEmu Blit to GameCoore Texture for Rendering
+      id<MTLBlitCommandEncoder> blitCommandEncoder = [g_state_tracker->GetRenderCmdBuf() blitCommandEncoder];
+      
+      if (@available(macOS 10.15, *)) {
+        [blitCommandEncoder copyFromTexture:[m_drawable texture] toTexture:id<MTLTexture>([_current metalTexture])];
+      } else {
+        // Fallback on earlier versions
+        // TODO:  Add pre 10.15 metal blit
+      }
+      
+      [blitCommandEncoder endEncoding];
+    
+      // PresentDrawable refuses to allow Dolphin to present faster than the display's refresh rate
+      // when windowed (or fullscreen with vsync enabled, but that's more understandable).
+      // On the other hand, it helps Xcode's GPU captures start and stop on frame boundaries
+      // which is convenient.  Put it here as a default-off config, which we can override in Xcode.
+      // It also seems to improve frame pacing, so enable it by default with vsync
+      if (g_ActiveConfig.iUsePresentDrawable == TriState::On ||
+          (g_ActiveConfig.iUsePresentDrawable == TriState::Auto && g_ActiveConfig.bVSyncActive))
+        [g_state_tracker->GetRenderCmdBuf() presentDrawable:m_drawable];
+      else
+        [g_state_tracker->GetRenderCmdBuf()
+            addScheduledHandler:[drawable = std::move(m_drawable)](id) { [drawable present]; }];
+      m_bb_texture->SetMTLTexture(nullptr);
+      m_drawable = nullptr;
+    }
+    g_state_tracker->FlushEncoders();
+  }
+}
+
+void Metal::Gfx::CheckForSurfaceChange()
+{
+  if (!g_presenter->SurfaceChangedTestAndClear())
+    return;
+  m_layer = MRCRetain(static_cast<CAMetalLayer*>(g_presenter->GetNewSurfaceHandle()));
+  SetupSurface();
+}
+
+void Metal::Gfx::CheckForSurfaceResize()
+{
+  if (!g_presenter->SurfaceResizedTestAndClear())
+    return;
+  SetupSurface();
+}
+
+void Metal::Gfx::SetupSurface()
+{
+  auto info = GetSurfaceInfo();
+
+  [m_layer setDrawableSize:{static_cast<double>(info.width), static_cast<double>(info.height)}];
+
+  TextureConfig cfg(info.width, info.height, 1, 1, 1, info.format,
+                    AbstractTextureFlag_RenderTarget);
+  m_bb_texture = std::make_unique<Texture>(nullptr, cfg);
+  m_backbuffer = std::make_unique<Framebuffer>(m_bb_texture.get(), nullptr,  //
+                                               info.width, info.height, 1, 1);
+
+  if (g_presenter)
+    g_presenter->SetBackbuffer(info);
+}
+
+SurfaceInfo Metal::Gfx::GetSurfaceInfo() const
+{
+  if (!m_layer)  // Headless
+    return {};
+
+  CGSize size = [m_layer bounds].size;
+  const float scale = [m_layer contentsScale];
+
+  return {static_cast<u32>(size.width * scale), static_cast<u32>(size.height * scale), scale,
+          Util::ToAbstract([m_layer pixelFormat])};
+}

Compatibility/Video/MTLMain.mm

@@ -0,0 +1,160 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "VideoBackends/Metal/VideoBackend.h"
+
+// This must be included before we use any TARGET_OS_* macros.
+#include <TargetConditionals.h>
+
+#if TARGET_OS_OSX
+#include <AppKit/AppKit.h>
+#endif
+
+#include <Metal/Metal.h>
+#include <QuartzCore/QuartzCore.h>
+
+#include "Common/Common.h"
+#include "Common/MsgHandler.h"
+
+#include "VideoBackends/Metal/MTLBoundingBox.h"
+#include "VideoBackends/Metal/MTLGfx.h"
+#include "VideoBackends/Metal/MTLObjectCache.h"
+#include "VideoBackends/Metal/MTLPerfQuery.h"
+#include "VideoBackends/Metal/MTLStateTracker.h"
+#include "VideoBackends/Metal/MTLUtil.h"
+#include "VideoBackends/Metal/MTLVertexManager.h"
+
+#include "VideoCommon/AbstractGfx.h"
+#include "VideoCommon/FramebufferManager.h"
+#include "VideoCommon/VideoCommon.h"
+#include "VideoCommon/VideoConfig.h"
+
+#import "DolphinGameCore.h"
+
+std::string Metal::VideoBackend::GetName() const
+{
+  return NAME;
+}
+
+std::string Metal::VideoBackend::GetDisplayName() const
+{
+  // i18n: Apple's Metal graphics API (https://developer.apple.com/metal/)
+  return _trans("Metal");
+}
+
+std::optional<std::string> Metal::VideoBackend::GetWarningMessage() const
+{
+//  if (Util::GetAdapterList().empty())
+//  {
+//    return _trans("No Metal-compatible GPUs were found.  "
+//                  "Use the OpenGL backend or upgrade your computer/GPU");
+//  }
+
+  return std::nullopt;
+}
+
+static bool WindowSystemTypeSupportsMetal(WindowSystemType type)
+{
+//  switch (type)
+//  {
+//  case WindowSystemType::MacOS:
+//  case WindowSystemType::Headless:
+    return true;
+//  default:
+//    return false;
+//  }
+}
+
+bool Metal::VideoBackend::Initialize(const WindowSystemInfo& wsi)
+{
+  @autoreleasepool
+  {
+    const bool surface_ok = wsi.type == WindowSystemType::Headless || wsi.render_surface;
+    if (!WindowSystemTypeSupportsMetal(wsi.type) || !surface_ok)
+    {
+      PanicAlertFmt("Bad WindowSystemInfo for Metal renderer.");
+      return false;
+    }
+
+    Util::PopulateBackendInfo(&g_Config);
+    std::vector<MRCOwned<id<MTLDevice>>> adapters;
+    adapters.push_back(MRCTransfer([_current metalDevice]));
+    Util::PopulateBackendInfoAdapters(&g_Config, adapters);
+    if (!adapters.empty())
+    {
+      // Use the selected adapter, or the first to fill features.
+      size_t index = static_cast<size_t>(g_Config.iAdapter);
+      if (index >= adapters.size())
+        index = 0;
+      Util::PopulateBackendInfoFeatures(&g_Config, adapters[index]);
+    }
+
+    // Since we haven't called InitializeShared yet, iAdapter may be out of range,
+    // so we have to check it ourselves.
+    size_t selected_adapter_index = static_cast<size_t>(g_Config.iAdapter);
+    if (selected_adapter_index >= adapters.size())
+    {
+      WARN_LOG_FMT(VIDEO, "Metal adapter index out of range, selecting default adapter.");
+      selected_adapter_index = 0;
+    }
+    MRCOwned<id<MTLDevice>> adapter = MRCOwned<id<MTLDevice>>(MRCRetain([_current metalDevice]));
+    Util::PopulateBackendInfoFeatures(&g_Config, adapter);
+
+    UpdateActiveConfig();
+
+    MRCOwned<CAMetalLayer*> layer = MRCRetain(static_cast<CAMetalLayer*>(wsi.render_surface));
+    //MRCOwned<CAMetalLayer*> layer = MRCRetain([CAMetalLayer layer]);
+    layer.Get().framebufferOnly=NO;
+    [layer setDevice:adapter];
+    
+    if (Util::ToAbstract([layer pixelFormat]) == AbstractTextureFormat::Undefined)
+      [layer setPixelFormat:MTLPixelFormatBGRA8Unorm];
+
+    ObjectCache::Initialize(std::move(adapter));
+    g_state_tracker = std::make_unique<StateTracker>();
+
+    return InitializeShared(
+        std::make_unique<Metal::Gfx>(std::move(layer)), std::make_unique<Metal::VertexManager>(),
+        std::make_unique<Metal::PerfQuery>(), std::make_unique<Metal::BoundingBox>());
+  }
+}
+
+void Metal::VideoBackend::Shutdown()
+{
+  ShutdownShared();
+
+  g_state_tracker.reset();
+  ObjectCache::Shutdown();
+}
+
+void Metal::VideoBackend::InitBackendInfo()
+{
+  @autoreleasepool
+  {
+    Util::PopulateBackendInfo(&g_Config);
+    std::vector<MRCOwned<id<MTLDevice>>> adapters;
+    adapters.push_back(MRCTransfer([_current metalDevice]));
+    Util::PopulateBackendInfoAdapters(&g_Config, adapters);
+    if (!adapters.empty())
+    {
+      // Use the selected adapter, or the first to fill features.
+      size_t index = static_cast<size_t>(g_Config.iAdapter);
+      if (index >= adapters.size())
+        index = 0;
+      Util::PopulateBackendInfoFeatures(&g_Config, adapters[index]);
+    }
+  }
+}
+
+void Metal::VideoBackend::PrepareWindow(WindowSystemInfo& wsi)
+{
+//#if TARGET_OS_OSX
+//  if (wsi.type != WindowSystemType::MacOS)
+//    return;
+//  NSView* view = static_cast<NSView*>(wsi.render_surface);
+  CAMetalLayer* layer = [CAMetalLayer layer];
+//  [view setWantsLayer:YES];
+//  [view setLayer:layer];
+  wsi.render_surface = layer;
+//#endif
+}

Compatibility/Video/OGLGfx.cpp

@@ -0,0 +1,731 @@
+// Copyright 2023 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "VideoBackends/OGL/OGLGfx.h"
+
+#include "Common/GL/GLContext.h"
+#include "Common/GL/GLExtensions/GLExtensions.h"
+#include "Common/Logging/LogManager.h"
+
+#include "Core/Config/GraphicsSettings.h"
+
+#include "VideoBackends/OGL/OGLConfig.h"
+#include "VideoBackends/OGL/OGLPipeline.h"
+#include "VideoBackends/OGL/OGLShader.h"
+#include "VideoBackends/OGL/OGLTexture.h"
+#include "VideoBackends/OGL/ProgramShaderCache.h"
+#include "VideoBackends/OGL/SamplerCache.h"
+
+#include "VideoCommon/AsyncShaderCompiler.h"
+#include "VideoCommon/DriverDetails.h"
+#include "VideoCommon/OnScreenDisplay.h"
+#include "VideoCommon/Present.h"
+#include "VideoCommon/VideoConfig.h"
+
+#include <string_view>
+
+namespace OGL
+{
+VideoConfig g_ogl_config;
+
+static void APIENTRY ErrorCallback(GLenum source, GLenum type, GLuint id, GLenum severity,
+                                   GLsizei length, const char* message, const void* userParam)
+{
+  const char* s_source;
+  const char* s_type;
+
+  // Performance - DualCore driver performance warning:
+  // DualCore application thread syncing with server thread
+  if (id == 0x200b0)
+    return;
+
+  switch (source)
+  {
+  case GL_DEBUG_SOURCE_API_ARB:
+    s_source = "API";
+    break;
+  case GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB:
+    s_source = "Window System";
+    break;
+  case GL_DEBUG_SOURCE_SHADER_COMPILER_ARB:
+    s_source = "Shader Compiler";
+    break;
+  case GL_DEBUG_SOURCE_THIRD_PARTY_ARB:
+    s_source = "Third Party";
+    break;
+  case GL_DEBUG_SOURCE_APPLICATION_ARB:
+    s_source = "Application";
+    break;
+  case GL_DEBUG_SOURCE_OTHER_ARB:
+    s_source = "Other";
+    break;
+  default:
+    s_source = "Unknown";
+    break;
+  }
+  switch (type)
+  {
+  case GL_DEBUG_TYPE_ERROR_ARB:
+    s_type = "Error";
+    break;
+  case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB:
+    s_type = "Deprecated";
+    break;
+  case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB:
+    s_type = "Undefined";
+    break;
+  case GL_DEBUG_TYPE_PORTABILITY_ARB:
+    s_type = "Portability";
+    break;
+  case GL_DEBUG_TYPE_PERFORMANCE_ARB:
+    s_type = "Performance";
+    break;
+  case GL_DEBUG_TYPE_OTHER_ARB:
+    s_type = "Other";
+    break;
+  default:
+    s_type = "Unknown";
+    break;
+  }
+  switch (severity)
+  {
+  case GL_DEBUG_SEVERITY_HIGH_ARB:
+    ERROR_LOG_FMT(HOST_GPU, "id: {:x}, source: {}, type: {} - {}", id, s_source, s_type, message);
+    break;
+  case GL_DEBUG_SEVERITY_MEDIUM_ARB:
+    WARN_LOG_FMT(HOST_GPU, "id: {:x}, source: {}, type: {} - {}", id, s_source, s_type, message);
+    break;
+  case GL_DEBUG_SEVERITY_LOW_ARB:
+    DEBUG_LOG_FMT(HOST_GPU, "id: {:x}, source: {}, type: {} - {}", id, s_source, s_type, message);
+    break;
+  case GL_DEBUG_SEVERITY_NOTIFICATION:
+    DEBUG_LOG_FMT(HOST_GPU, "id: {:x}, source: {}, type: {} - {}", id, s_source, s_type, message);
+    break;
+  default:
+    ERROR_LOG_FMT(HOST_GPU, "id: {:x}, source: {}, type: {} - {}", id, s_source, s_type, message);
+    break;
+  }
+}
+
+// Two small Fallbacks to avoid GL_ARB_ES2_compatibility
+static void APIENTRY DepthRangef(GLfloat neardepth, GLfloat fardepth)
+{
+  glDepthRange(neardepth, fardepth);
+}
+static void APIENTRY ClearDepthf(GLfloat depthval)
+{
+  glClearDepth(depthval);
+}
+
+OGLGfx::OGLGfx(std::unique_ptr<GLContext> main_gl_context, float backbuffer_scale)
+    : m_main_gl_context(std::move(main_gl_context)),
+      m_current_rasterization_state(RenderState::GetInvalidRasterizationState()),
+      m_current_depth_state(RenderState::GetInvalidDepthState()),
+      m_current_blend_state(RenderState::GetInvalidBlendingState()),
+      m_backbuffer_scale(backbuffer_scale)
+{
+  // Create the window framebuffer.
+  if (!m_main_gl_context->IsHeadless())
+  {
+    m_system_framebuffer = std::make_unique<OGLFramebuffer>(
+        nullptr, nullptr, AbstractTextureFormat::RGBA8, AbstractTextureFormat::Undefined,
+        std::max(m_main_gl_context->GetBackBufferWidth(), 1u),
+                                                            std::max(m_main_gl_context->GetBackBufferHeight(), 1u), 1, 1, g_Config.iRenderFBO);
+    m_current_framebuffer = m_system_framebuffer.get();
+  }
+
+  if (!m_main_gl_context->IsGLES())
+  {
+    // OpenGL 3 doesn't provide GLES like float functions for depth.
+    // They are in core in OpenGL 4.1, so almost every driver should support them.
+    // But for the oldest ones, we provide fallbacks to the old double functions.
+    if (!GLExtensions::Supports("GL_ARB_ES2_compatibility"))
+    {
+      glDepthRangef = DepthRangef;
+      glClearDepthf = ClearDepthf;
+    }
+  }
+
+  if (!PopulateConfig(m_main_gl_context.get()))
+  {
+    // Not all needed extensions are supported, so we have to stop here.
+    // Else some of the next calls might crash.
+    return;
+  }
+  InitDriverInfo();
+
+  // Setup Debug logging
+  if (g_ogl_config.bSupportsDebug)
+  {
+    if (GLExtensions::Supports("GL_KHR_debug"))
+    {
+      glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, true);
+      glDebugMessageCallback(ErrorCallback, nullptr);
+    }
+    else
+    {
+      glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, true);
+      glDebugMessageCallbackARB(ErrorCallback, nullptr);
+    }
+    if (Common::Log::LogManager::GetInstance()->IsEnabled(Common::Log::LogType::HOST_GPU,
+                                                          Common::Log::LogLevel::LERROR))
+    {
+      glEnable(GL_DEBUG_OUTPUT);
+    }
+    else
+    {
+      glDisable(GL_DEBUG_OUTPUT);
+    }
+  }
+
+  // Handle VSync on/off
+  if (!DriverDetails::HasBug(DriverDetails::BUG_BROKEN_VSYNC))
+    m_main_gl_context->SwapInterval(g_ActiveConfig.bVSyncActive);
+
+  if (g_ActiveConfig.backend_info.bSupportsClipControl)
+    glClipControl(GL_LOWER_LEFT, GL_ZERO_TO_ONE);
+
+  if (g_ActiveConfig.backend_info.bSupportsDepthClamp)
+  {
+    glEnable(GL_CLIP_DISTANCE0);
+    glEnable(GL_CLIP_DISTANCE1);
+    glEnable(GL_DEPTH_CLAMP);
+  }
+
+  glPixelStorei(GL_UNPACK_ALIGNMENT, 4);  // 4-byte pixel alignment
+
+  glGenFramebuffers(1, &m_shared_read_framebuffer);
+  glGenFramebuffers(1, &m_shared_draw_framebuffer);
+
+  if (g_ActiveConfig.backend_info.bSupportsPrimitiveRestart)
+    GLUtil::EnablePrimitiveRestart(m_main_gl_context.get());
+
+  UpdateActiveConfig();
+}
+
+OGLGfx::~OGLGfx()
+{
+  glDeleteFramebuffers(1, &m_shared_draw_framebuffer);
+  glDeleteFramebuffers(1, &m_shared_read_framebuffer);
+}
+
+bool OGLGfx::IsHeadless() const
+{
+  return m_main_gl_context->IsHeadless();
+}
+
+std::unique_ptr<AbstractTexture> OGLGfx::CreateTexture(const TextureConfig& config,
+                                                       std::string_view name)
+{
+  return std::make_unique<OGLTexture>(config, name);
+}
+
+std::unique_ptr<AbstractStagingTexture> OGLGfx::CreateStagingTexture(StagingTextureType type,
+                                                                     const TextureConfig& config)
+{
+  return OGLStagingTexture::Create(type, config);
+}
+
+std::unique_ptr<AbstractFramebuffer> OGLGfx::CreateFramebuffer(AbstractTexture* color_attachment,
+                                                               AbstractTexture* depth_attachment)
+{
+  return OGLFramebuffer::Create(static_cast<OGLTexture*>(color_attachment),
+                                static_cast<OGLTexture*>(depth_attachment));
+}
+
+std::unique_ptr<AbstractShader>
+OGLGfx::CreateShaderFromSource(ShaderStage stage, std::string_view source, std::string_view name)
+{
+  return OGLShader::CreateFromSource(stage, source, name);
+}
+
+std::unique_ptr<AbstractShader>
+OGLGfx::CreateShaderFromBinary(ShaderStage stage, const void* data, size_t length,
+                               [[maybe_unused]] std::string_view name)
+{
+  return nullptr;
+}
+
+std::unique_ptr<AbstractPipeline> OGLGfx::CreatePipeline(const AbstractPipelineConfig& config,
+                                                         const void* cache_data,
+                                                         size_t cache_data_length)
+{
+  return OGLPipeline::Create(config, cache_data, cache_data_length);
+}
+
+void OGLGfx::SetScissorRect(const MathUtil::Rectangle<int>& rc)
+{
+  glScissor(rc.left, rc.top, rc.GetWidth(), rc.GetHeight());
+}
+
+void OGLGfx::SetViewport(float x, float y, float width, float height, float near_depth,
+                         float far_depth)
+{
+  if (g_ogl_config.bSupportViewportFloat)
+  {
+    glViewportIndexedf(0, x, y, width, height);
+  }
+  else
+  {
+    auto iceilf = [](float f) { return static_cast<GLint>(std::ceil(f)); };
+    glViewport(iceilf(x), iceilf(y), iceilf(width), iceilf(height));
+  }
+
+  glDepthRangef(near_depth, far_depth);
+}
+
+void OGLGfx::Draw(u32 base_vertex, u32 num_vertices)
+{
+  glDrawArrays(static_cast<const OGLPipeline*>(m_current_pipeline)->GetGLPrimitive(), base_vertex,
+               num_vertices);
+}
+
+void OGLGfx::DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex)
+{
+  if (g_ogl_config.bSupportsGLBaseVertex)
+  {
+    glDrawElementsBaseVertex(static_cast<const OGLPipeline*>(m_current_pipeline)->GetGLPrimitive(),
+                             num_indices, GL_UNSIGNED_SHORT,
+                             static_cast<u16*>(nullptr) + base_index, base_vertex);
+  }
+  else
+  {
+    glDrawElements(static_cast<const OGLPipeline*>(m_current_pipeline)->GetGLPrimitive(),
+                   num_indices, GL_UNSIGNED_SHORT, static_cast<u16*>(nullptr) + base_index);
+  }
+}
+
+void OGLGfx::DispatchComputeShader(const AbstractShader* shader, u32 groupsize_x, u32 groupsize_y,
+                                   u32 groupsize_z, u32 groups_x, u32 groups_y, u32 groups_z)
+{
+  glUseProgram(static_cast<const OGLShader*>(shader)->GetGLComputeProgramID());
+  glDispatchCompute(groups_x, groups_y, groups_z);
+
+  // We messed up the program binding, so restore it.
+  ProgramShaderCache::InvalidateLastProgram();
+  if (m_current_pipeline)
+    static_cast<const OGLPipeline*>(m_current_pipeline)->GetProgram()->shader.Bind();
+
+  // Barrier to texture can be used for reads.
+  if (m_bound_image_texture)
+    glMemoryBarrier(GL_TEXTURE_UPDATE_BARRIER_BIT);
+}
+
+void OGLGfx::SelectLeftBuffer()
+{
+  glDrawBuffer(GL_BACK_LEFT);
+}
+
+void OGLGfx::SelectRightBuffer()
+{
+  glDrawBuffer(GL_BACK_RIGHT);
+}
+
+void OGLGfx::SelectMainBuffer()
+{
+  glDrawBuffer(GL_BACK);
+}
+
+void OGLGfx::SetFramebuffer(AbstractFramebuffer* framebuffer)
+{
+  if (m_current_framebuffer == framebuffer)
+    return;
+
+  glBindFramebuffer(GL_FRAMEBUFFER, static_cast<OGLFramebuffer*>(framebuffer)->GetFBO());
+  m_current_framebuffer = framebuffer;
+}
+
+void OGLGfx::SetAndDiscardFramebuffer(AbstractFramebuffer* framebuffer)
+{
+  // EXT_discard_framebuffer could be used here to save bandwidth on tilers.
+  SetFramebuffer(framebuffer);
+}
+
+void OGLGfx::SetAndClearFramebuffer(AbstractFramebuffer* framebuffer, const ClearColor& color_value,
+                                    float depth_value)
+{
+  SetFramebuffer(framebuffer);
+
+  glDisable(GL_SCISSOR_TEST);
+  GLbitfield clear_mask = 0;
+  if (framebuffer->HasColorBuffer())
+  {
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    glClearColor(color_value[0], color_value[1], color_value[2], color_value[3]);
+    clear_mask |= GL_COLOR_BUFFER_BIT;
+  }
+  if (framebuffer->HasDepthBuffer())
+  {
+    glDepthMask(GL_TRUE);
+    glClearDepthf(depth_value);
+    clear_mask |= GL_DEPTH_BUFFER_BIT;
+  }
+  glClear(clear_mask);
+  glEnable(GL_SCISSOR_TEST);
+
+  // Restore color/depth mask.
+  if (framebuffer->HasColorBuffer())
+  {
+    glColorMask(m_current_blend_state.colorupdate, m_current_blend_state.colorupdate,
+                m_current_blend_state.colorupdate, m_current_blend_state.alphaupdate);
+  }
+  if (framebuffer->HasDepthBuffer())
+    glDepthMask(m_current_depth_state.updateenable);
+}
+
+void OGLGfx::ClearRegion(const MathUtil::Rectangle<int>& target_rc, bool colorEnable,
+                         bool alphaEnable, bool zEnable, u32 color, u32 z)
+{
+  u32 clear_mask = 0;
+  if (colorEnable || alphaEnable)
+  {
+    glColorMask(colorEnable, colorEnable, colorEnable, alphaEnable);
+    glClearColor(float((color >> 16) & 0xFF) / 255.0f, float((color >> 8) & 0xFF) / 255.0f,
+                 float((color >> 0) & 0xFF) / 255.0f, float((color >> 24) & 0xFF) / 255.0f);
+    clear_mask = GL_COLOR_BUFFER_BIT;
+  }
+  if (zEnable)
+  {
+    glDepthMask(zEnable ? GL_TRUE : GL_FALSE);
+    glClearDepthf(float(z & 0xFFFFFF) / 16777216.0f);
+    clear_mask |= GL_DEPTH_BUFFER_BIT;
+  }
+
+  // Update rect for clearing the picture
+  // glColorMask/glDepthMask/glScissor affect glClear (glViewport does not)
+  g_gfx->SetScissorRect(target_rc);
+
+  glClear(clear_mask);
+
+  // Restore color/depth mask.
+  if (colorEnable || alphaEnable)
+  {
+    glColorMask(m_current_blend_state.colorupdate, m_current_blend_state.colorupdate,
+                m_current_blend_state.colorupdate, m_current_blend_state.alphaupdate);
+  }
+  if (zEnable)
+    glDepthMask(m_current_depth_state.updateenable);
+}
+
+void OGLGfx::BindBackbuffer(const ClearColor& clear_color)
+{
+  CheckForSurfaceChange();
+  CheckForSurfaceResize();
+  SetAndClearFramebuffer(m_system_framebuffer.get(), clear_color);
+}
+
+void OGLGfx::PresentBackbuffer()
+{
+  if (g_ogl_config.bSupportsDebug)
+  {
+    if (Common::Log::LogManager::GetInstance()->IsEnabled(Common::Log::LogType::HOST_GPU,
+                                                          Common::Log::LogLevel::LERROR))
+    {
+      glEnable(GL_DEBUG_OUTPUT);
+    }
+    else
+    {
+      glDisable(GL_DEBUG_OUTPUT);
+    }
+  }
+
+  // Swap the back and front buffers, presenting the image.
+  m_main_gl_context->Swap();
+}
+
+void OGLGfx::OnConfigChanged(u32 bits)
+{
+  AbstractGfx::OnConfigChanged(bits);
+
+  if (bits & CONFIG_CHANGE_BIT_VSYNC && !DriverDetails::HasBug(DriverDetails::BUG_BROKEN_VSYNC))
+    m_main_gl_context->SwapInterval(g_ActiveConfig.bVSyncActive);
+
+  if (bits & CONFIG_CHANGE_BIT_ANISOTROPY)
+    g_sampler_cache->Clear();
+}
+
+void OGLGfx::Flush()
+{
+  // ensure all commands are sent to the GPU.
+  // Otherwise the driver could batch several frames together.
+  glFlush();
+}
+
+void OGLGfx::WaitForGPUIdle()
+{
+  glFinish();
+}
+
+void OGLGfx::CheckForSurfaceChange()
+{
+  if (!g_presenter->SurfaceChangedTestAndClear())
+    return;
+
+  m_main_gl_context->UpdateSurface(g_presenter->GetNewSurfaceHandle());
+
+  u32 width = m_main_gl_context->GetBackBufferWidth();
+  u32 height = m_main_gl_context->GetBackBufferHeight();
+
+  // With a surface change, the window likely has new dimensions.
+  g_presenter->SetBackbuffer(width, height);
+  m_system_framebuffer->UpdateDimensions(width, height);
+}
+
+void OGLGfx::CheckForSurfaceResize()
+{
+  if (!g_presenter->SurfaceResizedTestAndClear())
+    return;
+
+  m_main_gl_context->Update();
+  u32 width = m_main_gl_context->GetBackBufferWidth();
+  u32 height = m_main_gl_context->GetBackBufferHeight();
+  g_presenter->SetBackbuffer(width, height);
+  m_system_framebuffer->UpdateDimensions(width, height);
+}
+
+void OGLGfx::BeginUtilityDrawing()
+{
+  AbstractGfx::BeginUtilityDrawing();
+  if (g_ActiveConfig.backend_info.bSupportsDepthClamp)
+  {
+    glDisable(GL_CLIP_DISTANCE0);
+    glDisable(GL_CLIP_DISTANCE1);
+  }
+}
+
+void OGLGfx::EndUtilityDrawing()
+{
+  AbstractGfx::EndUtilityDrawing();
+  if (g_ActiveConfig.backend_info.bSupportsDepthClamp)
+  {
+    glEnable(GL_CLIP_DISTANCE0);
+    glEnable(GL_CLIP_DISTANCE1);
+  }
+}
+
+void OGLGfx::ApplyRasterizationState(const RasterizationState state)
+{
+  if (m_current_rasterization_state == state)
+    return;
+
+  // none, ccw, cw, ccw
+  if (state.cullmode != CullMode::None)
+  {
+    // TODO: GX_CULL_ALL not supported, yet!
+    glEnable(GL_CULL_FACE);
+    glFrontFace(state.cullmode == CullMode::Front ? GL_CCW : GL_CW);
+  }
+  else
+  {
+    glDisable(GL_CULL_FACE);
+  }
+
+  m_current_rasterization_state = state;
+}
+
+void OGLGfx::ApplyDepthState(const DepthState state)
+{
+  if (m_current_depth_state == state)
+    return;
+
+  const GLenum glCmpFuncs[8] = {GL_NEVER,   GL_LESS,     GL_EQUAL,  GL_LEQUAL,
+                                GL_GREATER, GL_NOTEQUAL, GL_GEQUAL, GL_ALWAYS};
+
+  if (state.testenable)
+  {
+    glEnable(GL_DEPTH_TEST);
+    glDepthMask(state.updateenable ? GL_TRUE : GL_FALSE);
+    glDepthFunc(glCmpFuncs[u32(state.func.Value())]);
+  }
+  else
+  {
+    // if the test is disabled write is disabled too
+    // TODO: When PE performance metrics are being emulated via occlusion queries, we should
+    // (probably?) enable depth test with depth function ALWAYS here
+    glDisable(GL_DEPTH_TEST);
+    glDepthMask(GL_FALSE);
+  }
+
+  m_current_depth_state = state;
+}
+
+void OGLGfx::ApplyBlendingState(const BlendingState state)
+{
+  if (m_current_blend_state == state)
+    return;
+
+  bool useDualSource = state.usedualsrc;
+
+  const GLenum src_factors[8] = {GL_ZERO,
+                                 GL_ONE,
+                                 GL_DST_COLOR,
+                                 GL_ONE_MINUS_DST_COLOR,
+                                 useDualSource ? GL_SRC1_ALPHA : (GLenum)GL_SRC_ALPHA,
+                                 useDualSource ? GL_ONE_MINUS_SRC1_ALPHA :
+                                                 (GLenum)GL_ONE_MINUS_SRC_ALPHA,
+                                 GL_DST_ALPHA,
+                                 GL_ONE_MINUS_DST_ALPHA};
+  const GLenum dst_factors[8] = {GL_ZERO,
+                                 GL_ONE,
+                                 GL_SRC_COLOR,
+                                 GL_ONE_MINUS_SRC_COLOR,
+                                 useDualSource ? GL_SRC1_ALPHA : (GLenum)GL_SRC_ALPHA,
+                                 useDualSource ? GL_ONE_MINUS_SRC1_ALPHA :
+                                                 (GLenum)GL_ONE_MINUS_SRC_ALPHA,
+                                 GL_DST_ALPHA,
+                                 GL_ONE_MINUS_DST_ALPHA};
+
+  if (state.blendenable)
+    glEnable(GL_BLEND);
+  else
+    glDisable(GL_BLEND);
+
+  // Always call glBlendEquationSeparate and glBlendFuncSeparate, even when
+  // GL_BLEND is disabled, as a workaround for some bugs (possibly graphics
+  // driver issues?). See https://bugs.dolphin-emu.org/issues/10120 : "Sonic
+  // Adventure 2 Battle: graphics crash when loading first Dark level"
+  GLenum equation = state.subtract ? GL_FUNC_REVERSE_SUBTRACT : GL_FUNC_ADD;
+  GLenum equationAlpha = state.subtractAlpha ? GL_FUNC_REVERSE_SUBTRACT : GL_FUNC_ADD;
+  glBlendEquationSeparate(equation, equationAlpha);
+  glBlendFuncSeparate(src_factors[u32(state.srcfactor.Value())],
+                      dst_factors[u32(state.dstfactor.Value())],
+                      src_factors[u32(state.srcfactoralpha.Value())],
+                      dst_factors[u32(state.dstfactoralpha.Value())]);
+
+  const GLenum logic_op_codes[16] = {
+      GL_CLEAR,         GL_AND,         GL_AND_REVERSE, GL_COPY,  GL_AND_INVERTED, GL_NOOP,
+      GL_XOR,           GL_OR,          GL_NOR,         GL_EQUIV, GL_INVERT,       GL_OR_REVERSE,
+      GL_COPY_INVERTED, GL_OR_INVERTED, GL_NAND,        GL_SET};
+
+  // Logic ops aren't available in GLES3
+  if (!IsGLES())
+  {
+    if (state.logicopenable)
+    {
+      glEnable(GL_COLOR_LOGIC_OP);
+      glLogicOp(logic_op_codes[u32(state.logicmode.Value())]);
+    }
+    else
+    {
+      glDisable(GL_COLOR_LOGIC_OP);
+    }
+  }
+
+  glColorMask(state.colorupdate, state.colorupdate, state.colorupdate, state.alphaupdate);
+  m_current_blend_state = state;
+}
+
+void OGLGfx::SetPipeline(const AbstractPipeline* pipeline)
+{
+  if (m_current_pipeline == pipeline)
+    return;
+
+  if (pipeline)
+  {
+    ApplyRasterizationState(static_cast<const OGLPipeline*>(pipeline)->GetRasterizationState());
+    ApplyDepthState(static_cast<const OGLPipeline*>(pipeline)->GetDepthState());
+    ApplyBlendingState(static_cast<const OGLPipeline*>(pipeline)->GetBlendingState());
+    ProgramShaderCache::BindVertexFormat(
+        static_cast<const OGLPipeline*>(pipeline)->GetVertexFormat());
+    static_cast<const OGLPipeline*>(pipeline)->GetProgram()->shader.Bind();
+  }
+  else
+  {
+    ProgramShaderCache::InvalidateLastProgram();
+    glUseProgram(0);
+  }
+  m_current_pipeline = pipeline;
+}
+
+void OGLGfx::SetTexture(u32 index, const AbstractTexture* texture)
+{
+  const OGLTexture* gl_texture = static_cast<const OGLTexture*>(texture);
+  if (m_bound_textures[index] == gl_texture)
+    return;
+
+  glActiveTexture(GL_TEXTURE0 + index);
+  if (gl_texture)
+    glBindTexture(gl_texture->GetGLTarget(), gl_texture->GetGLTextureId());
+  else
+    glBindTexture(GL_TEXTURE_2D_ARRAY, 0);
+  m_bound_textures[index] = gl_texture;
+}
+
+void OGLGfx::SetSamplerState(u32 index, const SamplerState& state)
+{
+  g_sampler_cache->SetSamplerState(index, state);
+}
+
+void OGLGfx::SetComputeImageTexture(AbstractTexture* texture, bool read, bool write)
+{
+  if (m_bound_image_texture == texture)
+    return;
+
+  if (texture)
+  {
+    const GLenum access = read ? (write ? GL_READ_WRITE : GL_READ_ONLY) : GL_WRITE_ONLY;
+    glBindImageTexture(0, static_cast<OGLTexture*>(texture)->GetGLTextureId(), 0, GL_TRUE, 0,
+                       access, static_cast<OGLTexture*>(texture)->GetGLFormatForImageTexture());
+  }
+  else
+  {
+    glBindImageTexture(0, 0, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
+  }
+
+  m_bound_image_texture = texture;
+}
+
+void OGLGfx::UnbindTexture(const AbstractTexture* texture)
+{
+  for (size_t i = 0; i < m_bound_textures.size(); i++)
+  {
+    if (m_bound_textures[i] != texture)
+      continue;
+
+    glActiveTexture(static_cast<GLenum>(GL_TEXTURE0 + i));
+    glBindTexture(GL_TEXTURE_2D_ARRAY, 0);
+    m_bound_textures[i] = nullptr;
+  }
+
+  if (m_bound_image_texture == texture)
+  {
+    glBindImageTexture(0, 0, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
+    m_bound_image_texture = nullptr;
+  }
+}
+
+std::unique_ptr<VideoCommon::AsyncShaderCompiler> OGLGfx::CreateAsyncShaderCompiler()
+{
+  return std::make_unique<SharedContextAsyncShaderCompiler>();
+}
+
+bool OGLGfx::IsGLES() const
+{
+  return m_main_gl_context->IsGLES();
+}
+
+void OGLGfx::BindSharedReadFramebuffer()
+{
+  glBindFramebuffer(GL_READ_FRAMEBUFFER, m_shared_read_framebuffer);
+}
+
+void OGLGfx::BindSharedDrawFramebuffer()
+{
+  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_shared_draw_framebuffer);
+}
+
+void OGLGfx::RestoreFramebufferBinding()
+{
+  glBindFramebuffer(
+      GL_FRAMEBUFFER,
+      m_current_framebuffer ? static_cast<OGLFramebuffer*>(m_current_framebuffer)->GetFBO() : 0);
+}
+
+SurfaceInfo OGLGfx::GetSurfaceInfo() const
+{
+  return {std::max(m_main_gl_context->GetBackBufferWidth(), 1u),
+          std::max(m_main_gl_context->GetBackBufferHeight(), 1u), m_backbuffer_scale,
+          AbstractTextureFormat::RGBA8};
+}
+
+}  // namespace OGL

Compatibility/VideoCommon/TextureDecoderARCH.cpp

@@ -0,0 +1,27 @@
+// Copyright (c) 2022, OpenEmu Team
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of the OpenEmu Team nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY OpenEmu Team ''AS IS'' AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL OpenEmu Team BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifdef __x86_64__
+#include "../../dolphin/Source/Core/VideoCommon/TextureDecoder_x64.cpp"
+#endif

Compatibility/VideoCommon/VertexLoaderARCH.cpp

@@ -0,0 +1,29 @@
+// Copyright (c) 2022, OpenEmu Team
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of the OpenEmu Team nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY OpenEmu Team ''AS IS'' AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL OpenEmu Team BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifdef __x86_64__
+#include "../../dolphin/Source/Core/VideoCommon/VertexLoaderX64.cpp"
+#elif defined(__arm64__)
+#include "../../dolphin/Source/Core/VideoCommon/VertexLoaderARM64.cpp"
+#endif

Compatibility/VideoCommon/VideoConfig.h

@@ -1,3 +1,5 @@
+//// Copyright 2008 Dolphin Emulator Project
+//// Licensed under GPLv2+
 // Copyright 2008 Dolphin Emulator Project
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
@@ -14,8 +16,11 @@
 #include <vector>
 
 #include "Common/CommonTypes.h"
+#include "VideoCommon/GraphicsModSystem/Config/GraphicsModGroup.h"
 #include "VideoCommon/VideoCommon.h"
 
+enum class APIType;
+
 // Log in two categories, and save three other options in the same byte
 #define CONF_LOG 1
 #define CONF_PRIMLOG 2
@@ -26,221 +31,304 @@ constexpr int EFB_SCALE_AUTO_INTEGRAL = 0;
 
 enum class AspectMode : int
 {
-    Auto,
-    AnalogWide,
-    Analog,
-    Stretch,
+  Auto,
+  AnalogWide,
+  Analog,
+  Stretch,
 };
 
 enum class StereoMode : int
 {
-    Off,
-    SBS,
-    TAB,
-    Anaglyph,
-    QuadBuffer,
-    Passive,
-    Nvidia3DVision,
+  Off,
+  SBS,
+  TAB,
+  Anaglyph,
+  QuadBuffer,
+  Passive
 };
 
 enum class ShaderCompilationMode : int
 {
-    Synchronous,
-    SynchronousUberShaders,
-    AsynchronousUberShaders,
-    AsynchronousSkipRendering
+  Synchronous,
+  SynchronousUberShaders,
+  AsynchronousUberShaders,
+  AsynchronousSkipRendering
+};
+
+enum class TextureFilteringMode : int
+{
+  Default,
+  Nearest,
+  Linear,
+};
+
+enum class TriState : int
+{
+  Off,
+  On,
+  Auto
+};
+
+// Bitmask containing information about which configuration has changed for the backend.
+enum ConfigChangeBits : u32
+{
+  CONFIG_CHANGE_BIT_HOST_CONFIG = (1 << 0),
+  CONFIG_CHANGE_BIT_MULTISAMPLES = (1 << 1),
+  CONFIG_CHANGE_BIT_STEREO_MODE = (1 << 2),
+  CONFIG_CHANGE_BIT_TARGET_SIZE = (1 << 3),
+  CONFIG_CHANGE_BIT_ANISOTROPY = (1 << 4),
+  CONFIG_CHANGE_BIT_FORCE_TEXTURE_FILTERING = (1 << 5),
+  CONFIG_CHANGE_BIT_VSYNC = (1 << 6),
+  CONFIG_CHANGE_BIT_BBOX = (1 << 7),
+  CONFIG_CHANGE_BIT_ASPECT_RATIO = (1 << 8),
+  CONFIG_CHANGE_BIT_POST_PROCESSING_SHADER = (1 << 9),
 };
 
 // NEVER inherit from this class.
 struct VideoConfig final
 {
-    VideoConfig();
-    void Refresh();
-    void VerifyValidity();
-    
-    // General
-    bool bVSync;
-    bool bVSyncActive;
-    bool bWidescreenHack;
-    AspectMode aspect_mode;
-    AspectMode suggested_aspect_mode;
-    bool bCrop;  // Aspect ratio controls.
-    bool bShaderCache;
-    
-    // Enhancements
-    u32 iMultisamples;
-    bool bSSAA;
-    int iEFBScale;
-    bool bForceFiltering;
-    int iMaxAnisotropy;
-    std::string sPostProcessingShader;
-    bool bForceTrueColor;
-    bool bDisableCopyFilter;
-    bool bArbitraryMipmapDetection;
-    float fArbitraryMipmapDetectionThreshold;
-    
-    // Information
-    bool bShowFPS;
-    bool bShowNetPlayPing;
-    bool bShowNetPlayMessages;
-    bool bOverlayStats;
-    bool bOverlayProjStats;
-    bool bTexFmtOverlayEnable;
-    bool bTexFmtOverlayCenter;
-    bool bLogRenderTimeToFile;
-    
-    // Render
-    bool bWireFrame;
-    bool bDisableFog;
-    
-    //  OE render buffer
-        int iRenderFBO = 0;
-    
-    // Utility
-    bool bDumpTextures;
-    bool bHiresTextures;
-    bool bCacheHiresTextures;
-    bool bDumpEFBTarget;
-    bool bDumpXFBTarget;
-    bool bDumpFramesAsImages;
-    bool bUseFFV1;
-    std::string sDumpCodec;
-    std::string sDumpEncoder;
-    std::string sDumpFormat;
-    std::string sDumpPath;
-    bool bInternalResolutionFrameDumps;
-    bool bFreeLook;
-    bool bBorderlessFullscreen;
-    bool bEnableGPUTextureDecoding;
-    int iBitrateKbps;
-    
-    // Hacks
-    bool bEFBAccessEnable;
-    bool bEFBAccessDeferInvalidation;
-    bool bPerfQueriesEnable;
-    bool bBBoxEnable;
-    bool bForceProgressive;
-    
-    bool bEFBEmulateFormatChanges;
-    bool bSkipEFBCopyToRam;
-    bool bSkipXFBCopyToRam;
-    bool bDisableCopyToVRAM;
-    bool bDeferEFBCopies;
-    bool bImmediateXFB;
-    bool bCopyEFBScaled;
-    int iSafeTextureCache_ColorSamples;
-    float fAspectRatioHackW, fAspectRatioHackH;
-    bool bEnablePixelLighting;
-    bool bFastDepthCalc;
-    bool bVertexRounding;
-    int iEFBAccessTileSize;
-    int iLog;           // CONF_ bits
-    int iSaveTargetId;  // TODO: Should be dropped
-    
-    // Stereoscopy
-    StereoMode stereo_mode;
-    int iStereoDepth;
-    int iStereoConvergence;
-    int iStereoConvergencePercentage;
-    bool bStereoSwapEyes;
-    bool bStereoEFBMonoDepth;
-    int iStereoDepthPercentage;
-    
-    // D3D only config, mostly to be merged into the above
-    int iAdapter;
-    
-    // VideoSW Debugging
-    int drawStart;
-    int drawEnd;
-    bool bZComploc;
-    bool bZFreeze;
-    bool bDumpObjects;
-    bool bDumpTevStages;
-    bool bDumpTevTextureFetches;
-    
-    // Enable API validation layers, currently only supported with Vulkan.
-    bool bEnableValidationLayer;
-    
-    // Multithreaded submission, currently only supported with Vulkan.
-    bool bBackendMultithreading;
-    
-    // Early command buffer execution interval in number of draws.
-    // Currently only supported with Vulkan.
-    int iCommandBufferExecuteInterval;
-    
-    // Shader compilation settings.
-    bool bWaitForShadersBeforeStarting;
-    ShaderCompilationMode iShaderCompilationMode;
-    
-    // Number of shader compiler threads.
-    // 0 disables background compilation.
-    // -1 uses an automatic number based on the CPU threads.
-    int iShaderCompilerThreads;
-    int iShaderPrecompilerThreads;
-    
-    // Static config per API
-    // TODO: Move this out of VideoConfig
-    struct
-    {
-        APIType api_type;
-        
-        std::vector<std::string> Adapters;  // for D3D
-        std::vector<u32> AAModes;
-        
-        // TODO: merge AdapterName and Adapters array
-        std::string AdapterName;  // for OpenGL
-        
-        u32 MaxTextureSize;
-        bool bUsesLowerLeftOrigin;
-        
-        bool bSupportsExclusiveFullscreen;
-        bool bSupportsDualSourceBlend;
-        bool bSupportsPrimitiveRestart;
-        bool bSupportsOversizedViewports;
-        bool bSupportsGeometryShaders;
-        bool bSupportsComputeShaders;
-        bool bSupports3DVision;
-        bool bSupportsEarlyZ;         // needed by PixelShaderGen, so must stay in VideoCommon
-        bool bSupportsBindingLayout;  // Needed by ShaderGen, so must stay in VideoCommon
-        bool bSupportsBBox;
-        bool bSupportsGSInstancing;  // Needed by GeometryShaderGen, so must stay in VideoCommon
-        bool bSupportsPostProcessing;
-        bool bSupportsPaletteConversion;
-        bool bSupportsClipControl;  // Needed by VertexShaderGen, so must stay in VideoCommon
-        bool bSupportsSSAA;
-        bool bSupportsFragmentStoresAndAtomics;  // a.k.a. OpenGL SSBOs a.k.a. Direct3D UAVs
-        bool bSupportsDepthClamp;  // Needed by VertexShaderGen, so must stay in VideoCommon
-        bool bSupportsReversedDepthRange;
-        bool bSupportsLogicOp;
-        bool bSupportsMultithreading;
-        bool bSupportsGPUTextureDecoding;
-        bool bSupportsST3CTextures;
-        bool bSupportsCopyToVram;
-        bool bSupportsBitfield;                // Needed by UberShaders, so must stay in VideoCommon
-        bool bSupportsDynamicSamplerIndexing;  // Needed by UberShaders, so must stay in VideoCommon
-        bool bSupportsBPTCTextures;
-        bool bSupportsFramebufferFetch;  // Used as an alternative to dual-source blend on GLES
-        bool bSupportsBackgroundCompiling;
-        bool bSupportsLargePoints;
-        bool bSupportsPartialDepthCopies;
-        bool bSupportsShaderBinaries;
-        bool bSupportsPipelineCacheData;
-    } backend_info;
-    
-    // Utility
-    bool MultisamplingEnabled() const { return iMultisamples > 1; }
-    bool ExclusiveFullscreenEnabled() const
-    {
-        return backend_info.bSupportsExclusiveFullscreen && !bBorderlessFullscreen;
-    }
-    bool UseGPUTextureDecoding() const
-    {
-        return backend_info.bSupportsGPUTextureDecoding && bEnableGPUTextureDecoding;
-    }
-    bool UseVertexRounding() const { return bVertexRounding && iEFBScale != 1; }
-    bool UsingUberShaders() const;
-    u32 GetShaderCompilerThreads() const;
-    u32 GetShaderPrecompilerThreads() const;
+  VideoConfig() = default;
+  void Refresh();
+  void VerifyValidity();
+
+  // General
+  bool bVSync = false;
+  bool bVSyncActive = false;
+  bool bWidescreenHack = false;
+  AspectMode aspect_mode{};
+  AspectMode suggested_aspect_mode{};
+  bool bCrop = false;  // Aspect ratio controls.
+  bool bShaderCache = false;
+
+  // Enhancements
+  u32 iMultisamples = 0;
+  bool bSSAA = false;
+  int iEFBScale = 0;
+  TextureFilteringMode texture_filtering_mode = TextureFilteringMode::Default;
+  int iMaxAnisotropy = 0;
+  std::string sPostProcessingShader;
+  bool bForceTrueColor = false;
+  bool bDisableCopyFilter = false;
+  bool bArbitraryMipmapDetection = false;
+  float fArbitraryMipmapDetectionThreshold = 0;
+
+  // Information
+  bool bShowFPS = false;
+  bool bShowFTimes = false;
+  bool bShowVPS = false;
+  bool bShowVTimes = false;
+  bool bShowGraphs = false;
+  bool bShowSpeed = false;
+  bool bShowSpeedColors = false;
+  int iPerfSampleUSec = 0;
+  bool bShowNetPlayPing = false;
+  bool bShowNetPlayMessages = false;
+  bool bOverlayStats = false;
+  bool bOverlayProjStats = false;
+  bool bOverlayScissorStats = false;
+  bool bTexFmtOverlayEnable = false;
+  bool bTexFmtOverlayCenter = false;
+  bool bLogRenderTimeToFile = false;
+
+  // Render
+  bool bWireFrame;
+  bool bDisableFog;
+
+  //  OpenEmu render buffer
+  int iRenderFBO = 0;
+
+  // Utility
+  bool bDumpTextures = false;
+  bool bDumpMipmapTextures = false;
+  bool bDumpBaseTextures = false;
+  bool bHiresTextures = false;
+  bool bCacheHiresTextures = false;
+  bool bDumpEFBTarget = false;
+  bool bDumpXFBTarget = false;
+  bool bDumpFramesAsImages = false;
+  bool bUseFFV1 = false;
+  std::string sDumpCodec;
+  std::string sDumpPixelFormat;
+  std::string sDumpEncoder;
+  std::string sDumpFormat;
+  std::string sDumpPath;
+  bool bInternalResolutionFrameDumps = false;
+  bool bBorderlessFullscreen = false;
+  bool bEnableGPUTextureDecoding = false;
+  bool bPreferVSForLinePointExpansion = false;
+  int iBitrateKbps = 0;
+  bool bGraphicMods = false;
+  std::optional<GraphicsModGroupConfig> graphics_mod_config;
+
+  // Hacks
+  bool bEFBAccessEnable = false;
+  bool bEFBAccessDeferInvalidation = false;
+  bool bPerfQueriesEnable = false;
+  bool bBBoxEnable = false;
+  bool bForceProgressive = false;
+  bool bCPUCull = false;
+
+  bool bEFBEmulateFormatChanges = false;
+  bool bSkipEFBCopyToRam = false;
+  bool bSkipXFBCopyToRam = false;
+  bool bDisableCopyToVRAM = false;
+  bool bDeferEFBCopies = false;
+  bool bImmediateXFB = false;
+  bool bSkipPresentingDuplicateXFBs = false;
+  bool bCopyEFBScaled = false;
+  int iSafeTextureCache_ColorSamples = 0;
+  float fAspectRatioHackW = 1;  // Initial value needed for the first frame
+  float fAspectRatioHackH = 1;
+  bool bEnablePixelLighting = false;
+  bool bFastDepthCalc = false;
+  bool bVertexRounding = false;
+  bool bVISkip = false;
+  int iEFBAccessTileSize = 0;
+  int iSaveTargetId = 0;  // TODO: Should be dropped
+  u32 iMissingColorValue = 0;
+  bool bFastTextureSampling = false;
+#ifdef __APPLE__
+  bool bNoMipmapping = false;  // Used by macOS fifoci to work around an M1 bug
+#endif
+
+  // Stereoscopy
+  StereoMode stereo_mode{};
+  int iStereoDepth = 0;
+  int iStereoConvergence = 0;
+  int iStereoConvergencePercentage = 0;
+  bool bStereoSwapEyes = false;
+  bool bStereoEFBMonoDepth = false;
+  int iStereoDepthPercentage = 0;
+
+  // D3D only config, mostly to be merged into the above
+  int iAdapter = 0;
+
+  // Metal only config
+  TriState iManuallyUploadBuffers = TriState::Auto;
+  TriState iUsePresentDrawable = TriState::Auto;
+
+  // Enable API validation layers, currently only supported with Vulkan.
+  bool bEnableValidationLayer = false;
+
+  // Multithreaded submission, currently only supported with Vulkan.
+  bool bBackendMultithreading = true;
+
+  // Early command buffer execution interval in number of draws.
+  // Currently only supported with Vulkan.
+  int iCommandBufferExecuteInterval = 0;
+
+  // Shader compilation settings.
+  bool bWaitForShadersBeforeStarting = false;
+  ShaderCompilationMode iShaderCompilationMode{};
+
+  // Number of shader compiler threads.
+  // 0 disables background compilation.
+  // -1 uses an automatic number based on the CPU threads.
+  int iShaderCompilerThreads = 0;
+  int iShaderPrecompilerThreads = 0;
+
+  // Static config per API
+  // TODO: Move this out of VideoConfig
+  struct
+  {
+    APIType api_type = APIType::Nothing;
+    std::string DisplayName;
+
+    std::vector<std::string> Adapters;  // for D3D
+    std::vector<u32> AAModes;
+
+    // TODO: merge AdapterName and Adapters array
+    std::string AdapterName;  // for OpenGL
+
+    u32 MaxTextureSize = 16384;
+    bool bUsesLowerLeftOrigin = false;
+    bool bUsesExplictQuadBuffering = false;
+
+    bool bSupportsExclusiveFullscreen = false;
+    bool bSupportsDualSourceBlend = false;
+    bool bSupportsPrimitiveRestart = false;
+    bool bSupportsGeometryShaders = false;
+    bool bSupportsComputeShaders = false;
+    bool bSupports3DVision = false;
+    bool bSupportsEarlyZ = false;         // needed by PixelShaderGen, so must stay in VideoCommon
+    bool bSupportsBindingLayout = false;  // Needed by ShaderGen, so must stay in VideoCommon
+    bool bSupportsBBox = false;
+    bool bSupportsGSInstancing = false;  // Needed by GeometryShaderGen, so must stay in VideoCommon
+    bool bSupportsPostProcessing = false;
+    bool bSupportsPaletteConversion = false;
+    bool bSupportsClipControl = false;  // Needed by VertexShaderGen, so must stay in VideoCommon
+    bool bSupportsSSAA = false;
+    bool bSupportsFragmentStoresAndAtomics = false;  // a.k.a. OpenGL SSBOs a.k.a. Direct3D UAVs
+    bool bSupportsDepthClamp = false;  // Needed by VertexShaderGen, so must stay in VideoCommon
+    bool bSupportsReversedDepthRange = false;
+    bool bSupportsLogicOp = false;
+    bool bSupportsMultithreading = false;
+    bool bSupportsGPUTextureDecoding = false;
+    bool bSupportsST3CTextures = false;
+    bool bSupportsCopyToVram = false;
+    bool bSupportsBitfield = false;  // Needed by UberShaders, so must stay in VideoCommon
+    // Needed by UberShaders, so must stay in VideoCommon
+    bool bSupportsDynamicSamplerIndexing = false;
+    bool bSupportsBPTCTextures = false;
+    bool bSupportsFramebufferFetch = false;  // Used as an alternative to dual-source blend on GLES
+    bool bSupportsBackgroundCompiling = false;
+    bool bSupportsLargePoints = false;
+    bool bSupportsPartialDepthCopies = false;
+    bool bSupportsDepthReadback = false;
+    bool bSupportsShaderBinaries = false;
+    bool bSupportsPipelineCacheData = false;
+    bool bSupportsCoarseDerivatives = false;
+    bool bSupportsTextureQueryLevels = false;
+    bool bSupportsLodBiasInSampler = false;
+    bool bSupportsSettingObjectNames = false;
+    bool bSupportsPartialMultisampleResolve = false;
+    bool bSupportsDynamicVertexLoader = false;
+    bool bSupportsVSLinePointExpand = false;
+    bool bSupportsGLLayerInFS = true;
+  } backend_info;
+
+  // Utility
+  bool UseVSForLinePointExpand() const
+  {
+    if (!backend_info.bSupportsVSLinePointExpand)
+      return false;
+    if (!backend_info.bSupportsGeometryShaders)
+      return true;
+    return bPreferVSForLinePointExpansion;
+  }
+  bool MultisamplingEnabled() const { return iMultisamples > 1; }
+  bool ExclusiveFullscreenEnabled() const
+  {
+    return backend_info.bSupportsExclusiveFullscreen && !bBorderlessFullscreen;
+  }
+  bool UseGPUTextureDecoding() const
+  {
+    return backend_info.bSupportsGPUTextureDecoding && bEnableGPUTextureDecoding;
+  }
+  bool UseVertexRounding() const { return bVertexRounding && iEFBScale != 1; }
+  bool ManualTextureSamplingWithCustomTextureSizes() const
+  {
+    // If manual texture sampling is disabled, we don't need to do anything.
+    if (bFastTextureSampling)
+      return false;
+    // Hi-res textures break the wrapping logic used by manual texture sampling, as a texture's
+    // size won't match the size the game sets.
+    if (bHiresTextures)
+      return true;
+    // Hi-res EFB copies (but not native-resolution EFB copies at higher internal resolutions)
+    // also result in different texture sizes that need special handling.
+    if (iEFBScale != 1 && bCopyEFBScaled)
+      return true;
+    // Stereoscopic 3D changes the number of layers some textures have (EFB copies have 2 layers,
+    // while game textures still have 1), meaning bounds checks need to be added.
+    if (stereo_mode != StereoMode::Off)
+      return true;
+    // Otherwise, manual texture sampling can use the sizes games specify directly.
+    return false;
+  }
+  bool UsingUberShaders() const;
+  u32 GetShaderCompilerThreads() const;
+  u32 GetShaderPrecompilerThreads() const;
 };
 
 extern VideoConfig g_Config;

Compatibility/libusb/config.h

@@ -1,5 +1,5 @@
 /* Default visibility */
-#define DEFAULT_VISIBILITY __attribute__((visibility("default")))
+#define DEFAULT_VISIBILITY __attribute__((visibility("hidden")))
 
 /* Start with debug message logging enabled */
 #undef ENABLE_DEBUG_LOGGING

Compatibility/lzma/config.h

@@ -0,0 +1,505 @@
+/* Define if building universal (internal helper macro) */
+/* #undef AC_APPLE_UNIVERSAL_BUILD */
+
+/* How many MiB of RAM to assume if the real amount cannot be determined. */
+#define ASSUME_RAM 128
+
+/* Define to 1 if translation of program messages to the user's native
+   language is requested. */
+/* #undef #define ENABLE_NLS 1 */
+
+/* Define to 1 if bswap_16 is available. */
+#define HAVE_BSWAP_16 1
+
+/* Define to 1 if bswap_32 is available. */
+#define HAVE_BSWAP_32 1
+
+/* Define to 1 if bswap_64 is available. */
+#define HAVE_BSWAP_64 1
+
+/* Define to 1 if you have the <byteswap.h> header file. */
+/* #undef HAVE_BYTESWAP_H 1 */
+
+/* Define to 1 if Capsicum is available. */
+/* #undef HAVE_CAPSICUM */
+
+/* Define to 1 if the system has the type `CC_SHA256_CTX'. */
+/* #undef HAVE_CC_SHA256_CTX */
+
+/* Define to 1 if you have the `CC_SHA256_Init' function. */
+/* #undef HAVE_CC_SHA256_INIT */
+
+/* Define to 1 if you have the Mac OS X function CFLocaleCopyCurrent in the
+   CoreFoundation framework. */
+/* #undef HAVE_CFLOCALECOPYCURRENT */
+
+/* Define to 1 if you have the Mac OS X function CFPreferencesCopyAppValue in
+   the CoreFoundation framework. */
+/* #undef HAVE_CFPREFERENCESCOPYAPPVALUE */
+
+/* Define to 1 if crc32 integrity check is enabled. */
+#define HAVE_CHECK_CRC32 1
+
+/* Define to 1 if crc64 integrity check is enabled. */
+#define HAVE_CHECK_CRC64 1
+
+/* Define to 1 if sha256 integrity check is enabled. */
+#define HAVE_CHECK_SHA256 1
+
+/* Define to 1 if you have the `clock_gettime' function. */
+#define HAVE_CLOCK_GETTIME 1
+
+/* Define to 1 if you have the <CommonCrypto/CommonDigest.h> header file. */
+/* #undef HAVE_COMMONCRYPTO_COMMONDIGEST_H */
+
+/* Define if the GNU dcgettext() function is already present or preinstalled.
+   */
+#define HAVE_DCGETTEXT 1
+
+/* Define to 1 if you have the declaration of `CLOCK_MONOTONIC', and to 0 if
+   you don't. */
+#define HAVE_DECL_CLOCK_MONOTONIC 1
+
+/* Define to 1 if you have the declaration of `program_invocation_name', and
+   to 0 if you don't. */
+/* undef HAVE_DECL_PROGRAM_INVOCATION_NAME 1 */
+
+/* Define to 1 if any of HAVE_DECODER_foo have been defined. */
+#define HAVE_DECODERS 1
+
+/* Define to 1 if arm decoder is enabled. */
+// #define HAVE_DECODER_ARM 1
+
+/* Define to 1 if armthumb decoder is enabled. */
+// #define HAVE_DECODER_ARMTHUMB 1
+
+/* Define to 1 if delta decoder is enabled. */
+#define HAVE_DECODER_DELTA 1
+
+/* Define to 1 if ia64 decoder is enabled. */
+// #define HAVE_DECODER_IA64 1
+
+/* Define to 1 if lzma1 decoder is enabled. */
+#define HAVE_DECODER_LZMA1 1
+
+/* Define to 1 if lzma2 decoder is enabled. */
+#define HAVE_DECODER_LZMA2 1
+
+/* Define to 1 if powerpc decoder is enabled. */
+// #define HAVE_DECODER_POWERPC 1
+
+/* Define to 1 if sparc decoder is enabled. */
+// #define HAVE_DECODER_SPARC 1
+
+/* Define to 1 if x86 decoder is enabled. */
+// #define HAVE_DECODER_X86 1
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if any of HAVE_ENCODER_foo have been defined. */
+#define HAVE_ENCODERS 1
+
+/* Define to 1 if arm encoder is enabled. */
+// #define HAVE_ENCODER_ARM 1
+
+/* Define to 1 if armthumb encoder is enabled. */
+// #define HAVE_ENCODER_ARMTHUMB 1
+
+/* Define to 1 if delta encoder is enabled. */
+#define HAVE_ENCODER_DELTA 1
+
+/* Define to 1 if ia64 encoder is enabled. */
+// #define HAVE_ENCODER_IA64 1
+
+/* Define to 1 if lzma1 encoder is enabled. */
+#define HAVE_ENCODER_LZMA1 1
+
+/* Define to 1 if lzma2 encoder is enabled. */
+#define HAVE_ENCODER_LZMA2 1
+
+/* Define to 1 if powerpc encoder is enabled. */
+// #define HAVE_ENCODER_POWERPC 1
+
+/* Define to 1 if sparc encoder is enabled. */
+// #define HAVE_ENCODER_SPARC 1
+
+/* Define to 1 if x86 encoder is enabled. */
+// #define HAVE_ENCODER_X86 1
+
+/* Define to 1 if you have the <fcntl.h> header file. */
+#define HAVE_FCNTL_H 1
+
+/* Define to 1 if you have the `futimens' function. */
+#define HAVE_FUTIMENS 1
+
+/* Define to 1 if you have the `futimes' function. */
+/* #undef HAVE_FUTIMES */
+
+/* Define to 1 if you have the `futimesat' function. */
+/* #undef HAVE_FUTIMESAT */
+
+/* Define to 1 if you have the <getopt.h> header file. */
+#define HAVE_GETOPT_H 1
+
+/* Define to 1 if you have the `getopt_long' function. */
+#define HAVE_GETOPT_LONG 1
+
+/* Define if the GNU gettext() function is already present or preinstalled. */
+/* #undef HAVE_GETTEXT 1 */
+
+/* Define if you have the iconv() function and it works. */
+/* #undef HAVE_ICONV */
+
+#ifdef _M_X86
+/* Define to 1 if you have the <immintrin.h> header file. */
+#define HAVE_IMMINTRIN_H 1
+#endif
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the <limits.h> header file. */
+#define HAVE_LIMITS_H 1
+
+/* Define to 1 if mbrtowc and mbstate_t are properly declared. */
+#define HAVE_MBRTOWC 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 to enable bt2 match finder. */
+#define HAVE_MF_BT2 1
+
+/* Define to 1 to enable bt3 match finder. */
+#define HAVE_MF_BT3 1
+
+/* Define to 1 to enable bt4 match finder. */
+#define HAVE_MF_BT4 1
+
+/* Define to 1 to enable hc3 match finder. */
+#define HAVE_MF_HC3 1
+
+/* Define to 1 to enable hc4 match finder. */
+#define HAVE_MF_HC4 1
+
+/* Define to 1 if getopt.h declares extern int optreset. */
+/* #undef HAVE_OPTRESET */
+
+/* Define to 1 if you have the `posix_fadvise' function. */
+#define HAVE_POSIX_FADVISE 1
+
+/* Define to 1 if you have the `pthread_condattr_setclock' function. */
+//#define HAVE_PTHREAD_CONDATTR_SETCLOCK 1
+
+/* Have PTHREAD_PRIO_INHERIT. */
+#define HAVE_PTHREAD_PRIO_INHERIT 1
+
+/* Define to 1 if you have the `SHA256Init' function. */
+/* #undef HAVE_SHA256INIT */
+
+/* Define to 1 if the system has the type `SHA256_CTX'. */
+/* #undef HAVE_SHA256_CTX */
+
+/* Define to 1 if you have the <sha256.h> header file. */
+/* #undef HAVE_SHA256_H */
+
+/* Define to 1 if you have the `SHA256_Init' function. */
+/* #undef HAVE_SHA256_INIT */
+
+/* Define to 1 if the system has the type `SHA2_CTX'. */
+/* #undef HAVE_SHA2_CTX */
+
+/* Define to 1 if you have the <sha2.h> header file. */
+/* #undef HAVE_SHA2_H */
+
+/* Define to 1 if optimizing for size. */
+/* #undef HAVE_SMALL */
+
+/* Define to 1 if stdbool.h conforms to C99. */
+#define HAVE_STDBOOL_H 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+/* #undef HAVE_STRINGS_H 1 */
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if `st_atimensec' is a member of `struct stat'. */
+/* #undef HAVE_STRUCT_STAT_ST_ATIMENSEC */
+
+/* Define to 1 if `st_atimespec.tv_nsec' is a member of `struct stat'. */
+/* #undef HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC */
+
+/* Define to 1 if `st_atim.st__tim.tv_nsec' is a member of `struct stat'. */
+/* #undef HAVE_STRUCT_STAT_ST_ATIM_ST__TIM_TV_NSEC */
+
+/* Define to 1 if `st_atim.tv_nsec' is a member of `struct stat'. */
+#define HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC 1
+
+/* Define to 1 if `st_uatime' is a member of `struct stat'. */
+/* #undef HAVE_STRUCT_STAT_ST_UATIME */
+
+/* Define to 1 if you have the <sys/byteorder.h> header file. */
+/* #undef HAVE_SYS_BYTEORDER_H */
+
+/* Define to 1 if you have the <sys/capsicum.h> header file. */
+/* #undef HAVE_SYS_CAPSICUM_H */
+
+/* Define to 1 if you have the <sys/endian.h> header file. */
+/* #undef HAVE_SYS_ENDIAN_H */
+
+/* Define to 1 if you have the <sys/param.h> header file. */
+#define HAVE_SYS_PARAM_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/time.h> header file. */
+/* #undef HAVE_SYS_TIME_H 1 */
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if the system has the type `uintptr_t'. */
+#define HAVE_UINTPTR_T 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to 1 if you have the `utime' function. */
+/* #undef HAVE_UTIME */
+
+/* Define to 1 if you have the `utimes' function. */
+/* #undef HAVE_UTIMES */
+
+/* Define to 1 or 0, depending whether the compiler supports simple visibility
+   declarations. */
+#define HAVE_VISIBILITY 0
+
+/* Define to 1 if you have the `wcwidth' function. */
+#define HAVE_WCWIDTH 1
+
+/* Define to 1 if the system has the type `_Bool'. */
+#define HAVE__BOOL 1
+
+/* Define to 1 if you have the `_futime' function. */
+/* #undef HAVE__FUTIME */
+
+/* Define to 1 if _mm_movemask_epi8 is available. */
+#define HAVE__MM_MOVEMASK_EPI8 1
+
+/* Define to the sub-directory where libtool stores uninstalled libraries. */
+#define LT_OBJDIR ".libs/"
+
+#ifndef _WIN32
+/* Define to 1 when using POSIX threads (pthreads). */
+#define MYTHREAD_POSIX 1
+#else
+/* Define to 1 when using Windows Vista compatible threads. This uses features
+   that are not available on Windows XP. */
+#define MYTHREAD_VISTA
+#endif
+
+/* Define to 1 when using Windows 95 (and thus XP) compatible threads. This
+   avoids use of features that were added in Windows Vista. */
+/* #undef MYTHREAD_WIN95 */
+
+/* Define to 1 to disable debugging code. */
+#define NDEBUG 1
+
+/* Name of package */
+#define PACKAGE "xz"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "lasse.collin@tukaani.org"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "XZ Utils"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "XZ Utils 5.2.4"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "xz"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL "https://tukaani.org/xz/"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "5.2.4"
+
+/* Define to necessary symbol if this constant uses a non-standard name on
+   your system. */
+/* #undef PTHREAD_CREATE_JOINABLE */
+
+/* The size of `size_t', as computed by sizeof. */
+#define SIZEOF_SIZE_T 8
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Define to 1 if the number of available CPU cores can be detected with
+   cpuset(2). */
+/* #undef TUKLIB_CPUCORES_CPUSET */
+
+/* Define to 1 if the number of available CPU cores can be detected with
+   pstat_getdynamic(). */
+/* #undef TUKLIB_CPUCORES_PSTAT_GETDYNAMIC */
+
+/* Define to 1 if the number of available CPU cores can be detected with
+   sched_getaffinity() */
+/* #undef TUKLIB_CPUCORES_SCHED_GETAFFINITY */
+
+/* Define to 1 if the number of available CPU cores can be detected with
+   sysconf(_SC_NPROCESSORS_ONLN) or sysconf(_SC_NPROC_ONLN). */
+/* #undef TUKLIB_CPUCORES_SYSCONF */
+
+/* Define to 1 if the number of available CPU cores can be detected with
+   sysctl(). */
+/* #undef TUKLIB_CPUCORES_SYSCTL */
+
+#ifdef _M_X86
+/* Define to 1 if the system supports fast unaligned access to 16-bit and
+   32-bit integers. */
+#define TUKLIB_FAST_UNALIGNED_ACCESS 1
+#endif
+
+/* Define to 1 if the amount of physical memory can be detected with
+   _system_configuration.physmem. */
+/* #undef TUKLIB_PHYSMEM_AIX */
+
+/* Define to 1 if the amount of physical memory can be detected with
+   getinvent_r(). */
+/* #undef TUKLIB_PHYSMEM_GETINVENT_R */
+
+/* Define to 1 if the amount of physical memory can be detected with
+   getsysinfo(). */
+/* #undef TUKLIB_PHYSMEM_GETSYSINFO */
+
+/* Define to 1 if the amount of physical memory can be detected with
+   pstat_getstatic(). */
+/* #undef TUKLIB_PHYSMEM_PSTAT_GETSTATIC */
+
+/* Define to 1 if the amount of physical memory can be detected with
+   sysconf(_SC_PAGESIZE) and sysconf(_SC_PHYS_PAGES). */
+#define TUKLIB_PHYSMEM_SYSCONF 1
+
+/* Define to 1 if the amount of physical memory can be detected with sysctl().
+   */
+/* #undef TUKLIB_PHYSMEM_SYSCTL */
+
+/* Define to 1 if the amount of physical memory can be detected with Linux
+   sysinfo(). */
+/* #undef TUKLIB_PHYSMEM_SYSINFO */
+
+/* Enable extensions on AIX 3, Interix.  */
+#ifndef _ALL_SOURCE
+# define _ALL_SOURCE 1
+#endif
+/* Enable GNU extensions on systems that have them.  */
+#ifndef _GNU_SOURCE
+# define _GNU_SOURCE 1
+#endif
+/* Enable threading extensions on Solaris.  */
+#ifndef _POSIX_PTHREAD_SEMANTICS
+# define _POSIX_PTHREAD_SEMANTICS 1
+#endif
+/* Enable extensions on HP NonStop.  */
+#ifndef _TANDEM_SOURCE
+# define _TANDEM_SOURCE 1
+#endif
+/* Enable general extensions on Solaris.  */
+#ifndef __EXTENSIONS__
+# define __EXTENSIONS__ 1
+#endif
+
+
+/* Version number of package */
+#define VERSION "5.2.4"
+
+/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
+   significant byte first (like Motorola and SPARC, unlike Intel). */
+#if defined AC_APPLE_UNIVERSAL_BUILD
+# if defined __BIG_ENDIAN__
+#  define WORDS_BIGENDIAN 1
+# endif
+#else
+# ifndef WORDS_BIGENDIAN
+/* #  undef WORDS_BIGENDIAN */
+# endif
+#endif
+
+/* Enable large inode numbers on Mac OS X 10.5.  */
+#ifndef _DARWIN_USE_64_BIT_INODE
+# define _DARWIN_USE_64_BIT_INODE 1
+#endif
+
+/* Number of bits in a file offset, on hosts where this is settable. */
+/* #undef _FILE_OFFSET_BITS */
+
+/* Define for large files, on AIX-style hosts. */
+/* #undef _LARGE_FILES */
+
+/* Define to 1 if on MINIX. */
+/* #undef _MINIX */
+
+/* Define to 2 if the system does not provide POSIX.1 features except with
+   this defined. */
+/* #undef _POSIX_1_SOURCE */
+
+/* Define to 1 if you need to in order for `stat' and other things to work. */
+/* #undef _POSIX_SOURCE */
+
+/* Define for Solaris 2.5.1 so the uint32_t typedef from <sys/synch.h>,
+   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
+   #define below would cause a syntax error. */
+/* #undef _UINT32_T */
+
+/* Define for Solaris 2.5.1 so the uint64_t typedef from <sys/synch.h>,
+   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
+   #define below would cause a syntax error. */
+/* #undef _UINT64_T */
+
+/* Define for Solaris 2.5.1 so the uint8_t typedef from <sys/synch.h>,
+   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
+   #define below would cause a syntax error. */
+/* #undef _UINT8_T */
+
+/* Define to rpl_ if the getopt replacement functions and variables should be
+   used. */
+/* #undef __GETOPT_PREFIX */
+
+/* Define to the type of a signed integer type of width exactly 32 bits if
+   such a type exists and the standard includes do not define it. */
+/* #undef int32_t */
+
+/* Define to the type of a signed integer type of width exactly 64 bits if
+   such a type exists and the standard includes do not define it. */
+/* #undef int64_t */
+
+/* Define to the type of an unsigned integer type of width exactly 16 bits if
+   such a type exists and the standard includes do not define it. */
+/* #undef uint16_t */
+
+/* Define to the type of an unsigned integer type of width exactly 32 bits if
+   such a type exists and the standard includes do not define it. */
+/* #undef uint32_t */
+
+/* Define to the type of an unsigned integer type of width exactly 64 bits if
+   such a type exists and the standard includes do not define it. */
+/* #undef uint64_t */
+
+/* Define to the type of an unsigned integer type of width exactly 8 bits if
+   such a type exists and the standard includes do not define it. */
+/* #undef uint8_t */
+
+/* Define to the type of an unsigned integer type wide enough to hold a
+   pointer, if such a type exists, and if the system does not define it. */
+/* #undef uintptr_t */

DolHost.h

@@ -32,7 +32,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "Core/ActionReplay.h"
 #include "Core/ARDecrypt.h"
 
-#include "InputCommon/ControllerInterface/Device.h"
+#include "InputCommon/ControllerInterface/CoreDevice.h"
 
 #include "DolphinNoGUI/Platform.h"
 
@@ -58,6 +58,9 @@ public:
     void SetAxis(int button, float value, int player);
     void SetIR(int player, float x, float y);
 
+    void processSpecialKeys (int button , int player);
+    void setWiimoteSideways (int player);
+    void setWiimoteUpright (int player);
     void changeWiimoteExtension(int extension, int player);
 
     void toggleAudioMute();
@@ -65,6 +68,7 @@ public:
     void volumeUp();
     void SetVolume(float value);
     void DisplayMessage(std::string message);
+    float GetFrameInterval();
 
     bool SaveState(std::string saveStateFile);
     bool LoadState(std::string saveStateFile);
@@ -101,9 +105,12 @@ public:
 
     bool        _onBoot = true;
     bool        _wiiWAD;
-    bool        _wiiChangeExtension[4] = { false, false, false, false };
     int         _wiiMoteType;
-
+    
+    bool _wiiChangeExtension[4] = { false, false, false, false };
+    bool _wmSideways[4] = { false, false, false, false };
+    bool _wmUpright[4] = { false, false, false, false };
+    
     std::string autoSaveStateFile;
 
     void SetUpPlayerInputs();

DolHost.mm

@@ -44,11 +44,14 @@
 #include "Common/Thread.h"
 #include "Common/Version.h"
 
-#include "Core/Analytics.h"
+#include "Core/DolphinAnalytics.h"
 #include "Core/Boot/Boot.h"
 #include "Core/BootManager.h"
+#include "Core/Config/MainSettings.h"
+#include "Core/Config/WiimoteSettings.h"
 #include "Core/ConfigManager.h"
 #include "Core/Core.h"
+#include "Core/System.h"
 #include "Core/Host.h"
 #include "Core/HW/CPU.h"
 #include "Core/HW/Wiimote.h"
@@ -77,6 +80,9 @@
 #include "VideoCommon/OnScreenDisplay.h"
 #include "VideoBackends/OGL/ProgramShaderCache.h"
 
+#include "Core/Config/MainSettings.h"
+#include "Core/ConfigManager.h"
+
 DolHost* DolHost::m_instance = nullptr;
 static Common::Event updateMainFrameEvent;
 static Common::Flag s_running{true};
@@ -84,8 +90,8 @@ static Common::Flag s_running{true};
 static Common::Flag s_shutdown_requested{false};
 static Common::Flag s_tried_graceful_shutdown{false};
 
-static std::unique_ptr<Platform> s_platform;
-
+WindowSystemInfo wsi(WindowSystemType::Headless, nullptr, nullptr, nullptr);
+ 
 DolHost* DolHost::GetInstance()
 {
     if (DolHost::m_instance == nullptr)
@@ -110,46 +116,47 @@ void DolHost::Init(std::string supportDirectoryPath, std::string cpath)
     UICommon::Init();
     
     // Database Settings
-    SConfig::GetInstance().m_use_builtin_title_database = true;
+    Config::SetBase(Config::MAIN_USE_BUILT_IN_TITLE_DATABASE, true);
     
     //Setup the CPU Settings
-    SConfig::GetInstance().bMMU = true;
-    // SConfig::GetInstance().bSkipIdle = true;
-    SConfig::GetInstance().bEnableCheats = true;
+    Config::SetBase(Config::MAIN_MMU, true);
+    Config::SetBase(Config::MAIN_ENABLE_CHEATS, true);
     SConfig::GetInstance().bBootToPause = false;
     
     //Debug Settings
-    SConfig::GetInstance().bEnableDebugging = false;
+    Config::SetBase(Config::MAIN_ENABLE_DEBUGGING, false);
 #ifdef DEBUG
-    SConfig::GetInstance().bOnScreenDisplayMessages = true;
+    Config::SetBase(Config::MAIN_OSD_MESSAGES, true);
 #else
-    SConfig::GetInstance().bOnScreenDisplayMessages = false;
+    Config::SetBase(Config::MAIN_OSD_MESSAGES, false);
 #endif
-    SConfig::GetInstance().m_ShowFrameCount = false;
+    Config::SetBase(Config::MAIN_SHOW_FRAME_COUNT, false);
     
     //Video
-    SConfig::GetInstance().m_strVideoBackend = "OGL";
-    VideoBackendBase::ActivateBackend(SConfig::GetInstance().m_strVideoBackend);
+    Config::SetBase(Config::MAIN_GFX_BACKEND, "MTL");
+    VideoBackendBase::ActivateBackend(Config::Get(Config::MAIN_GFX_BACKEND));
     
     //Set the Sound
-    SConfig::GetInstance().bDSPHLE = true;
-    SConfig::GetInstance().bDSPThread = true;
-    SConfig::GetInstance().m_Volume = 0;
+    Config::SetBase(Config::MAIN_DSP_HLE, true);
+    Config::SetBase(Config::MAIN_DSP_THREAD, true);
+    Config::SetBase(Config::MAIN_AUDIO_VOLUME, 0);
     
     //Split CPU thread from GPU
-    SConfig::GetInstance().bCPUThread = false;
+    Config::SetBase(Config::MAIN_CPU_THREAD, true);
     
     //Analitics
-    SConfig::GetInstance().m_analytics_permission_asked = true;
-    SConfig::GetInstance().m_analytics_enabled =  false;
-    //DolphinAnalytics::Instance()->ReloadConfig();
+    Config::SetBase(Config::MAIN_ANALYTICS_PERMISSION_ASKED, true);
+    Config::SetBase(Config::MAIN_ANALYTICS_ENABLED, false);
+    DolphinAnalytics::Instance().ReloadConfig();
     
     //Save them now
     SConfig::GetInstance().SaveSettings();
     
-    
     //Choose Wiimote Type
-    _wiiMoteType = WIIMOTE_SRC_EMU; // WIIMOTE_SRC_EMU, WIIMOTE_SRC_HYBRID or WIIMOTE_SRC_REAL
+    Config::SetCurrent(Config::GetInfoForWiimoteSource(0), WiimoteSource::Emulated);
+    Config::SetCurrent(Config::GetInfoForWiimoteSource(1), WiimoteSource::Emulated);
+    Config::SetCurrent(Config::GetInfoForWiimoteSource(2), WiimoteSource::Emulated);
+    Config::SetCurrent(Config::GetInfoForWiimoteSource(3), WiimoteSource::Emulated);
     
     //Get game info from file path
     GetGameInfo();
@@ -168,8 +175,6 @@ void DolHost::Init(std::string supportDirectoryPath, std::string cpath)
         
         //SConfig::GetInstance().m_strMemoryCardA = _memCardA;
         //SConfig::GetInstance().m_strMemoryCardB = _memCardB;
-        
-        
     }
     else
     {
@@ -189,22 +194,20 @@ void DolHost::Init(std::string supportDirectoryPath, std::string cpath)
        // SConfig::GetInstance().m_enable_signature_checks = false;
         
         // Disable wiimote continuous scanning
-        SConfig::GetInstance().m_WiimoteContinuousScanning = false;
+        Config::SetBase(Config::MAIN_WIIMOTE_CONTINUOUS_SCANNING, false);
         
         //Set the Wiimote type
-        WiimoteReal::ChangeWiimoteSource(0, _wiiMoteType);
-        WiimoteReal::ChangeWiimoteSource(1, _wiiMoteType);
-        WiimoteReal::ChangeWiimoteSource(2, _wiiMoteType);
-        WiimoteReal::ChangeWiimoteSource(3, _wiiMoteType);
+//        WiimoteReal::ChangeWiimoteSource(0, _wiiMoteType);
+//        WiimoteReal::ChangeWiimoteSource(1, _wiiMoteType);
+//        WiimoteReal::ChangeWiimoteSource(2, _wiiMoteType);
+//        WiimoteReal::ChangeWiimoteSource(3, _wiiMoteType);
     }
 }
 
 # pragma mark - Execution
 bool DolHost::LoadFileAtPath()
 {
-     s_platform = Platform::CreateHeadlessPlatform();
-    
-    Core::SetOnStateChangedCallback([](Core::State state) {
+    Core::AddOnStateChangedCallback([](Core::State state) {
         if (state == Core::State::Uninitialized)
             s_running.Clear();
     });
@@ -215,9 +218,8 @@ bool DolHost::LoadFileAtPath()
     //        WiiUtils::InstallWAD(_gamePath);
     //    //    else
     //    //        WiiUtils::DoDiscUpdate(nil, _gameRegionName);
-    
-    
-    if (!BootManager::BootCore(BootParameters::GenerateFromFile(_gamePath), s_platform->GetWindowSystemInfo()))
+
+    if (!BootManager::BootCore(BootParameters::GenerateFromFile(_gamePath), wsi))
         return false;
    
     // Initialize Input
@@ -248,7 +250,7 @@ void DolHost::Pause(bool flag)
 void DolHost::RequestStop()
 {
     Core::SetState(Core::State::Running);
-    ProcessorInterface::PowerButton_Tap();
+    Core::System::GetInstance().GetProcessorInterface().PowerButton_Tap();
     
     Core::Stop();
     while (CPU::GetState() != CPU::State::PowerDown)
@@ -260,14 +262,14 @@ void DolHost::RequestStop()
 
 void DolHost::Reset()
 {
-    ProcessorInterface::ResetButton_Tap();
+    Core::System::GetInstance().GetProcessorInterface().ResetButton_Tap();
 }
 
 void DolHost::UpdateFrame()
 {
-    Core::HostDispatchJobs();
+    //Core::HostDispatchJobs();
     
- //  Input::OpenEmu_Input_Update();
+    //Input::OpenEmu_Input_Update();
     
     if(_onBoot) _onBoot = false;
 }
@@ -284,11 +286,6 @@ bool DolHost::CoreRunning()
 void DolHost::SetPresentationFBO(int RenderFBO)
 {
     g_Config.iRenderFBO = RenderFBO;
-    g_Config.bCrop = false;
-    g_Config.bWidescreenHack = false;
-    g_Config.bHiresTextures = false;
-    g_Config.bSSAA = false;
-    g_Config.iEFBScale = 2;
 }
 
 void DolHost::SetBackBufferSize(int width, int height) {
@@ -299,8 +296,8 @@ void DolHost::SetBackBufferSize(int width, int height) {
 # pragma mark - Audio 
 void DolHost::SetVolume(float value)
 {
-    SConfig::GetInstance().m_Volume = value * 100;
-    AudioCommon::UpdateSoundStream();
+    Config::SetBaseOrCurrent(Config::MAIN_AUDIO_VOLUME, value * 100);
+    AudioCommon::UpdateSoundStream(Core::System::GetInstance());
 }
 
 # pragma mark - Save states
@@ -324,13 +321,13 @@ bool DolHost::LoadState(std::string saveStateFile)
     {
         // We have to set the wiimote type, cause the gamesave may
         //    have used a different type
-        WiimoteReal::ChangeWiimoteSource(0 , _wiiMoteType);
-        WiimoteReal::ChangeWiimoteSource(1 , _wiiMoteType);
-        WiimoteReal::ChangeWiimoteSource(2 , _wiiMoteType);
-        WiimoteReal::ChangeWiimoteSource(3 , _wiiMoteType);
-        
-        if( _wiiMoteType != WIIMOTE_SRC_EMU)
-            WiimoteReal::Refresh();
+//        WiimoteReal::ChangeWiimoteSource(0 , _wiiMoteType);
+//        WiimoteReal::ChangeWiimoteSource(1 , _wiiMoteType);
+//        WiimoteReal::ChangeWiimoteSource(2 , _wiiMoteType);
+//        WiimoteReal::ChangeWiimoteSource(3 , _wiiMoteType);
+//        
+//        if( _wiiMoteType != WIIMOTE_SRC_EMU)
+//            WiimoteReal::Refresh();
     }
     return true;
 }
@@ -341,7 +338,7 @@ void DolHost::SetCheat(std::string code, std::string type, bool enabled)
     gcode.codes.clear();
     gcode.enabled = enabled;
     arcode.ops.clear();
-    arcode.active = enabled;
+    arcode.enabled = enabled;
     
     Gecko::GeckoCode::Code gcodecode;
     uint32_t cmd_addr, cmd_value;
@@ -455,7 +452,7 @@ void DolHost::SetCheat(std::string code, std::string type, bool enabled)
         }
         if(exists)
         {
-            acompare.active = enabled;
+            acompare.enabled = enabled;
             // If it exists, enable it, and we don't need to look at the rest of the codes
             break;
         }
@@ -464,7 +461,9 @@ void DolHost::SetCheat(std::string code, std::string type, bool enabled)
     if(!exists)
         arcodes.push_back(arcode);
     
-    ActionReplay::RunAllActive();
+    // TODO: move to a better place
+    Core::CPUThreadGuard guard;
+    ActionReplay::RunAllActive(guard);
 }
 
 # pragma mark - Controls
@@ -475,58 +474,55 @@ void DolHost::DisplayMessage(std::string message)
 void DolHost::setButtonState(int button, int state, int player)
 {
     player -= 1;
-    
     if (_gameType == DiscIO::Platform::GameCubeDisc) {
         setGameCubeButton(player, button, state);
+    } else {
+        setWiiButton(player, button, state);
     }
-    else
-    {
-      //  setWiiButton(player, button, state);
-    }
-    
-//    if (button == OEWiiChangeExtension)
-//    {
-//        //set the Extension change state and return.  The next key pressed
-//        //  while the Change Extension key is held will determine the Extension added
-//        _wiiChangeExtension[player] = state;
-//        return;
-//    }
-    
-//    if ( _wiiChangeExtension[player] && state == 1)
-//    {
-//        if ( button <= OEWiiMoteSwingBackward ) {
-//            changeWiimoteExtension(WiimoteEmu::EXT_NONE, player);
-//            Core::DisplayMessage("Extenstion Removed", 1500);
-//        } else if (button <= OEWiiNunchuckButtonZ ) {
-//            changeWiimoteExtension(WiimoteEmu::EXT_NUNCHUK, player);
-//            Core::DisplayMessage("Nunchuk Connected", 1500);
-//        } else if (button <= OEWiiClassicButtonHome ) {
-//            changeWiimoteExtension(WiimoteEmu::EXT_CLASSIC, player);
-//            Core::DisplayMessage("Classic Controller Connected", 1500);
-//        }
-//    }
 }
 
 void DolHost::SetAxis(int button, float value, int player)
 {
     player -= 1;
-    
     if (_gameType == DiscIO::Platform::GameCubeDisc) {
         setGameCubeAxis(player, button, value);
+        if (button == OEGCButtonR || button == OEGCButtonL) {
+            int digVal = 0;
+            if (value == 1) digVal = 1;
+            setGameCubeButton(player, button + 5, digVal);
+        }
+    } else {
+        setWiiAxis(player, button, value);
     }
-    else
-    {
-      //  setWiiAxis(player, button, value);
+}
+
+void DolHost::processSpecialKeys (int button , int player)
+{
+    player -= 1;
+    button += 1;
+    
+    if (button == OEWiimoteSideways) {
+        _wmSideways[player] = !_wmSideways[player];
+        setWiimoteSideways(player);
+    } else if (button == OEWiimoteUpright) {
+        _wmUpright[player] = !_wmUpright[player];
+       setWiimoteUpright(player);
     }
 }
+void DolHost::setWiimoteSideways (int player)
+{
+    static_cast<ControllerEmu::NumericSetting<bool>*>(Wiimote::GetWiimoteGroup(player, WiimoteEmu::WiimoteGroup::Options)->numeric_settings[3].get())->SetValue(_wmSideways[player]);
+}
+
+void DolHost::setWiimoteUpright (int player)
+{
+    static_cast<ControllerEmu::NumericSetting<bool>*>(Wiimote::GetWiimoteGroup(player, WiimoteEmu::WiimoteGroup::Options)->numeric_settings[2].get())->SetValue(_wmUpright[player]);
+}
 
 void DolHost::changeWiimoteExtension(int extension, int player)
 {
-    //Player has already been adjusted befor call
-//    auto* ce_extension = static_cast<ControllerEmu::Extension*>(Wiimote::GetWiimoteGroup(player, WiimoteEmu::WiimoteGroup::Extension));
-//    ce_extension->switch_extension = extension;
-//
-//    WiiRemotes[player].extension = extension;
+    player -= 1;
+    static_cast<ControllerEmu::Attachments*>(Wiimote::GetWiimoteGroup(player, WiimoteEmu::WiimoteGroup::Attachments))->SetSelectedAttachment(extension);
 }
 
 void DolHost::SetIR(int player, float x, float y)
@@ -549,6 +545,11 @@ void DolHost::GetGameInfo()
     _gameType = pVolume->GetVolumeType();
 }
 
+float DolHost::GetFrameInterval()
+{
+    return DiscIO::IsNTSC(SConfig::GetInstance().m_region)  ? (60.0f / 1.001f) : 50.0f;
+}
+
 std::string DolHost::GetNameOfRegion(DiscIO::Region region)
 {
     switch (region)
@@ -603,33 +604,13 @@ std::string DolHost::GetDirOfCountry(DiscIO::Country country)
 
 WindowSystemInfo DolHost::GetWSI()
 {
-    return s_platform->GetWindowSystemInfo();
+    return wsi;
 }
 
 # pragma mark - Dolphin Host callbacks
 void Host_NotifyMapLoaded() {}
 void Host_RefreshDSPDebuggerWindow() {}
-void Host_Message(HostMessageID id) {
-    if  ( id == HostMessageID::WMUserCreate ) {
-#ifdef DEBUG
-        //We have to set FPS display here or it doesn't work
-        g_Config.bShowFPS = true;
-        Core::SetState(Core::State::Running);
-#endif
-        
-        // Set the aspect to stretch
-        g_Config.aspect_mode = AspectMode::Stretch;
-        
-        // Core is up,  lets enable Hybric Ubershaders
-        g_Config.iShaderCompilationMode = ShaderCompilationMode::AsynchronousUberShaders;
-        g_Config.bWaitForShadersBeforeStarting = false;
-        
-        //Set the threads to auto (-1)
-        g_Config.iShaderCompilerThreads = -1;
-        g_Config.iShaderPrecompilerThreads = -1;
-        
-    }
-}
+void Host_Message(HostMessageID id) {}
 void* Host_GetRenderHandle() { return (void *)-1; }
 void Host_UpdateTitle(const std::string&) {}
 void Host_UpdateDisasmDialog() {}
@@ -638,15 +619,30 @@ void Host_RequestRenderWindowSize(int width, int height){}
 void Host_SetStartupDebuggingParameters()
 {
     SConfig& StartUp = SConfig::GetInstance();
-    StartUp.bEnableDebugging = false;
     StartUp.bBootToPause = false;
 }
 
+std::vector<std::string> Host_GetPreferredLocales()
+{
+  return {};
+}
+
 bool Host_UINeedsControllerState(){ return false; }
 bool Host_UIBlocksControllerState() { return false; }
 bool Host_RendererHasFocus() { return true; }
+bool Host_RendererHasFullFocus() { return true; }
 bool Host_RendererIsFullscreen() { return false; }
 void Host_ShowVideoConfig(void*, const std::string&) {}
 void Host_YieldToUI() {}
 void Host_TitleChanged() {}
 void Host_UpdateProgressDialog(const char* caption, int position, int total) {}
+
+void Host_UpdateDiscordClientID(const std::string& client_id) {}
+bool Host_UpdateDiscordPresenceRaw(const std::string& details, const std::string& state,
+                                   const std::string& large_image_key,
+                                   const std::string& large_image_text,
+                                   const std::string& small_image_key,
+                                   const std::string& small_image_text,
+                                   const int64_t start_timestamp,
+                                   const int64_t end_timestamp, const int party_size,
+                                   const int party_max) { return false; }

DolphinGameCore.mm

@@ -99,7 +99,6 @@ extern std::unique_ptr<SoundStream> g_sound_stream;
     {
         _dolphinCoreModule = @"gc";
         _isWii = false;
-        _frameInterval = 60;
         _dolphinCoreAspect = OEIntSizeMake(4, 3);
         _dolphinCoreScreen = OEIntSizeMake(640, 480);
     }
@@ -107,7 +106,6 @@ extern std::unique_ptr<SoundStream> g_sound_stream;
     {
         _dolphinCoreModule = @"Wii";
         _isWii = true;
-        _frameInterval = 60;
         _dolphinCoreAspect = OEIntSizeMake(16,9);
         _dolphinCoreScreen = OEIntSizeMake(854, 480);
     }
@@ -144,7 +142,9 @@ extern std::unique_ptr<SoundStream> g_sound_stream;
 
         if(dol_host->LoadFileAtPath())
             _isInitialized = true;
-
+        
+        _frameInterval = dol_host->GetFrameInterval();
+        
     }
     [super startEmulation];
 
@@ -182,7 +182,7 @@ extern std::unique_ptr<SoundStream> g_sound_stream;
 # pragma mark - Video
 - (OEGameCoreRendering)gameCoreRendering
 {
-    return OEGameCoreRenderingOpenGL3Video;
+    return OEGameCoreRenderingMetal2Video;
 }
 
 - (BOOL)hasAlternateRenderingThread
@@ -226,7 +226,7 @@ extern std::unique_ptr<SoundStream> g_sound_stream;
 
 - (GLenum)pixelType
 {
-    return GL_UNSIGNED_BYTE;
+    return GL_UNSIGNED_INT_8_8_8_8_REV;
 }
 
 - (GLenum)internalPixelFormat
@@ -342,13 +342,17 @@ extern std::unique_ptr<SoundStream> g_sound_stream;
 {
     if(_isInitialized)
     {
-        dol_host->setButtonState(button, 1, (int)player);
+        if (button > OEWiiButtonCount) {
+            dol_host->processSpecialKeys(button , (int)player);
+        } else {
+            dol_host->setButtonState(button, 1, (int)player);
+        }
     }
 }
 
 - (oneway void)didReleaseWiiButton:(OEWiiButton)button forPlayer:(NSUInteger)player
 {
-    if(_isInitialized)
+    if(_isInitialized && button != OEWiimoteSideways && button != OEWiimoteUpright)
     {
         dol_host->setButtonState(button, 0, (int)player);
     }

Externals/ffmpeg/include/libavcodec/avfft.h

@@ -1,118 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_AVFFT_H
-#define AVCODEC_AVFFT_H
-
-/**
- * @file
- * @ingroup lavc_fft
- * FFT functions
- */
-
-/**
- * @defgroup lavc_fft FFT functions
- * @ingroup lavc_misc
- *
- * @{
- */
-
-typedef float FFTSample;
-
-typedef struct FFTComplex {
-    FFTSample re, im;
-} FFTComplex;
-
-typedef struct FFTContext FFTContext;
-
-/**
- * Set up a complex FFT.
- * @param nbits           log2 of the length of the input array
- * @param inverse         if 0 perform the forward transform, if 1 perform the inverse
- */
-FFTContext *av_fft_init(int nbits, int inverse);
-
-/**
- * Do the permutation needed BEFORE calling ff_fft_calc().
- */
-void av_fft_permute(FFTContext *s, FFTComplex *z);
-
-/**
- * Do a complex FFT with the parameters defined in av_fft_init(). The
- * input data must be permuted before. No 1.0/sqrt(n) normalization is done.
- */
-void av_fft_calc(FFTContext *s, FFTComplex *z);
-
-void av_fft_end(FFTContext *s);
-
-FFTContext *av_mdct_init(int nbits, int inverse, double scale);
-void av_imdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input);
-void av_imdct_half(FFTContext *s, FFTSample *output, const FFTSample *input);
-void av_mdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input);
-void av_mdct_end(FFTContext *s);
-
-/* Real Discrete Fourier Transform */
-
-enum RDFTransformType {
-    DFT_R2C,
-    IDFT_C2R,
-    IDFT_R2C,
-    DFT_C2R,
-};
-
-typedef struct RDFTContext RDFTContext;
-
-/**
- * Set up a real FFT.
- * @param nbits           log2 of the length of the input array
- * @param trans           the type of transform
- */
-RDFTContext *av_rdft_init(int nbits, enum RDFTransformType trans);
-void av_rdft_calc(RDFTContext *s, FFTSample *data);
-void av_rdft_end(RDFTContext *s);
-
-/* Discrete Cosine Transform */
-
-typedef struct DCTContext DCTContext;
-
-enum DCTTransformType {
-    DCT_II = 0,
-    DCT_III,
-    DCT_I,
-    DST_I,
-};
-
-/**
- * Set up DCT.
- *
- * @param nbits           size of the input array:
- *                        (1 << nbits)     for DCT-II, DCT-III and DST-I
- *                        (1 << nbits) + 1 for DCT-I
- * @param type            the type of transform
- *
- * @note the first element of the input of DST-I is ignored
- */
-DCTContext *av_dct_init(int nbits, enum DCTTransformType type);
-void av_dct_calc(DCTContext *s, FFTSample *data);
-void av_dct_end (DCTContext *s);
-
-/**
- * @}
- */
-
-#endif /* AVCODEC_AVFFT_H */

Externals/ffmpeg/include/libavcodec/dv_profile.h

@@ -1,92 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_DV_PROFILE_H
-#define AVCODEC_DV_PROFILE_H
-
-#include <stdint.h>
-
-#include "libavutil/pixfmt.h"
-#include "libavutil/rational.h"
-#include "avcodec.h"
-
-/* minimum number of bytes to read from a DV stream in order to
- * determine the profile */
-#define DV_PROFILE_BYTES (6 * 80) /* 6 DIF blocks */
-
-
-/*
- * AVDVProfile is used to express the differences between various
- * DV flavors. For now it's primarily used for differentiating
- * 525/60 and 625/50, but the plans are to use it for various
- * DV specs as well (e.g. SMPTE314M vs. IEC 61834).
- */
-typedef struct AVDVProfile {
-    int              dsf;                   /* value of the dsf in the DV header */
-    int              video_stype;           /* stype for VAUX source pack */
-    int              frame_size;            /* total size of one frame in bytes */
-    int              difseg_size;           /* number of DIF segments per DIF channel */
-    int              n_difchan;             /* number of DIF channels per frame */
-    AVRational       time_base;             /* 1/framerate */
-    int              ltc_divisor;           /* FPS from the LTS standpoint */
-    int              height;                /* picture height in pixels */
-    int              width;                 /* picture width in pixels */
-    AVRational       sar[2];                /* sample aspect ratios for 4:3 and 16:9 */
-    enum AVPixelFormat pix_fmt;             /* picture pixel format */
-    int              bpm;                   /* blocks per macroblock */
-    const uint8_t   *block_sizes;           /* AC block sizes, in bits */
-    int              audio_stride;          /* size of audio_shuffle table */
-    int              audio_min_samples[3];  /* min amount of audio samples */
-                                            /* for 48kHz, 44.1kHz and 32kHz */
-    int              audio_samples_dist[5]; /* how many samples are supposed to be */
-                                            /* in each frame in a 5 frames window */
-    const uint8_t  (*audio_shuffle)[9];     /* PCM shuffling table */
-} AVDVProfile;
-
-#if FF_API_DV_FRAME_PROFILE
-/**
- * @deprecated use av_dv_frame_profile()
- */
-attribute_deprecated
-const AVDVProfile* avpriv_dv_frame_profile2(AVCodecContext* codec, const AVDVProfile *sys,
-                                            const uint8_t* frame, unsigned buf_size);
-#endif
-
-/**
- * Get a DV profile for the provided compressed frame.
- *
- * @param sys the profile used for the previous frame, may be NULL
- * @param frame the compressed data buffer
- * @param buf_size size of the buffer in bytes
- * @return the DV profile for the supplied data or NULL on failure
- */
-const AVDVProfile *av_dv_frame_profile(const AVDVProfile *sys,
-                                       const uint8_t *frame, unsigned buf_size);
-
-/**
- * Get a DV profile for the provided stream parameters.
- */
-const AVDVProfile *av_dv_codec_profile(int width, int height, enum AVPixelFormat pix_fmt);
-
-/**
- * Get a DV profile for the provided stream parameters.
- * The frame rate is used as a best-effort parameter.
- */
-const AVDVProfile *av_dv_codec_profile2(int width, int height, enum AVPixelFormat pix_fmt, AVRational frame_rate);
-
-#endif /* AVCODEC_DV_PROFILE_H */

Externals/ffmpeg/include/libavcodec/dxva2.h

@@ -1,93 +0,0 @@
-/*
- * DXVA2 HW acceleration
- *
- * copyright (c) 2009 Laurent Aimar
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_DXVA_H
-#define AVCODEC_DXVA_H
-
-/**
- * @file
- * @ingroup lavc_codec_hwaccel_dxva2
- * Public libavcodec DXVA2 header.
- */
-
-#if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600
-#undef _WIN32_WINNT
-#define _WIN32_WINNT 0x0600
-#endif
-
-#include <stdint.h>
-#include <d3d9.h>
-#include <dxva2api.h>
-
-/**
- * @defgroup lavc_codec_hwaccel_dxva2 DXVA2
- * @ingroup lavc_codec_hwaccel
- *
- * @{
- */
-
-#define FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG 1 ///< Work around for DXVA2 and old UVD/UVD+ ATI video cards
-#define FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO    2 ///< Work around for DXVA2 and old Intel GPUs with ClearVideo interface
-
-/**
- * This structure is used to provides the necessary configurations and data
- * to the DXVA2 FFmpeg HWAccel implementation.
- *
- * The application must make it available as AVCodecContext.hwaccel_context.
- */
-struct dxva_context {
-    /**
-     * DXVA2 decoder object
-     */
-    IDirectXVideoDecoder *decoder;
-
-    /**
-     * DXVA2 configuration used to create the decoder
-     */
-    const DXVA2_ConfigPictureDecode *cfg;
-
-    /**
-     * The number of surface in the surface array
-     */
-    unsigned surface_count;
-
-    /**
-     * The array of Direct3D surfaces used to create the decoder
-     */
-    LPDIRECT3DSURFACE9 *surface;
-
-    /**
-     * A bit field configuring the workarounds needed for using the decoder
-     */
-    uint64_t workaround;
-
-    /**
-     * Private to the FFmpeg AVHWAccel implementation
-     */
-    unsigned report_id;
-};
-
-/**
- * @}
- */
-
-#endif /* AVCODEC_DXVA_H */

Externals/ffmpeg/include/libavcodec/old_codec_ids.h

@@ -1,397 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_OLD_CODEC_IDS_H
-#define AVCODEC_OLD_CODEC_IDS_H
-
-/*
- * This header exists to prevent new codec IDs from being accidentally added to
- * the deprecated list.
- * Do not include it directly. It will be removed on next major bump
- *
- * Do not add new items to this list. Use the AVCodecID enum instead.
- */
-
-    CODEC_ID_NONE = AV_CODEC_ID_NONE,
-
-    /* video codecs */
-    CODEC_ID_MPEG1VIDEO,
-    CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding
-#if FF_API_XVMC
-    CODEC_ID_MPEG2VIDEO_XVMC,
-#endif
-    CODEC_ID_H261,
-    CODEC_ID_H263,
-    CODEC_ID_RV10,
-    CODEC_ID_RV20,
-    CODEC_ID_MJPEG,
-    CODEC_ID_MJPEGB,
-    CODEC_ID_LJPEG,
-    CODEC_ID_SP5X,
-    CODEC_ID_JPEGLS,
-    CODEC_ID_MPEG4,
-    CODEC_ID_RAWVIDEO,
-    CODEC_ID_MSMPEG4V1,
-    CODEC_ID_MSMPEG4V2,
-    CODEC_ID_MSMPEG4V3,
-    CODEC_ID_WMV1,
-    CODEC_ID_WMV2,
-    CODEC_ID_H263P,
-    CODEC_ID_H263I,
-    CODEC_ID_FLV1,
-    CODEC_ID_SVQ1,
-    CODEC_ID_SVQ3,
-    CODEC_ID_DVVIDEO,
-    CODEC_ID_HUFFYUV,
-    CODEC_ID_CYUV,
-    CODEC_ID_H264,
-    CODEC_ID_INDEO3,
-    CODEC_ID_VP3,
-    CODEC_ID_THEORA,
-    CODEC_ID_ASV1,
-    CODEC_ID_ASV2,
-    CODEC_ID_FFV1,
-    CODEC_ID_4XM,
-    CODEC_ID_VCR1,
-    CODEC_ID_CLJR,
-    CODEC_ID_MDEC,
-    CODEC_ID_ROQ,
-    CODEC_ID_INTERPLAY_VIDEO,
-    CODEC_ID_XAN_WC3,
-    CODEC_ID_XAN_WC4,
-    CODEC_ID_RPZA,
-    CODEC_ID_CINEPAK,
-    CODEC_ID_WS_VQA,
-    CODEC_ID_MSRLE,
-    CODEC_ID_MSVIDEO1,
-    CODEC_ID_IDCIN,
-    CODEC_ID_8BPS,
-    CODEC_ID_SMC,
-    CODEC_ID_FLIC,
-    CODEC_ID_TRUEMOTION1,
-    CODEC_ID_VMDVIDEO,
-    CODEC_ID_MSZH,
-    CODEC_ID_ZLIB,
-    CODEC_ID_QTRLE,
-    CODEC_ID_TSCC,
-    CODEC_ID_ULTI,
-    CODEC_ID_QDRAW,
-    CODEC_ID_VIXL,
-    CODEC_ID_QPEG,
-    CODEC_ID_PNG,
-    CODEC_ID_PPM,
-    CODEC_ID_PBM,
-    CODEC_ID_PGM,
-    CODEC_ID_PGMYUV,
-    CODEC_ID_PAM,
-    CODEC_ID_FFVHUFF,
-    CODEC_ID_RV30,
-    CODEC_ID_RV40,
-    CODEC_ID_VC1,
-    CODEC_ID_WMV3,
-    CODEC_ID_LOCO,
-    CODEC_ID_WNV1,
-    CODEC_ID_AASC,
-    CODEC_ID_INDEO2,
-    CODEC_ID_FRAPS,
-    CODEC_ID_TRUEMOTION2,
-    CODEC_ID_BMP,
-    CODEC_ID_CSCD,
-    CODEC_ID_MMVIDEO,
-    CODEC_ID_ZMBV,
-    CODEC_ID_AVS,
-    CODEC_ID_SMACKVIDEO,
-    CODEC_ID_NUV,
-    CODEC_ID_KMVC,
-    CODEC_ID_FLASHSV,
-    CODEC_ID_CAVS,
-    CODEC_ID_JPEG2000,
-    CODEC_ID_VMNC,
-    CODEC_ID_VP5,
-    CODEC_ID_VP6,
-    CODEC_ID_VP6F,
-    CODEC_ID_TARGA,
-    CODEC_ID_DSICINVIDEO,
-    CODEC_ID_TIERTEXSEQVIDEO,
-    CODEC_ID_TIFF,
-    CODEC_ID_GIF,
-    CODEC_ID_DXA,
-    CODEC_ID_DNXHD,
-    CODEC_ID_THP,
-    CODEC_ID_SGI,
-    CODEC_ID_C93,
-    CODEC_ID_BETHSOFTVID,
-    CODEC_ID_PTX,
-    CODEC_ID_TXD,
-    CODEC_ID_VP6A,
-    CODEC_ID_AMV,
-    CODEC_ID_VB,
-    CODEC_ID_PCX,
-    CODEC_ID_SUNRAST,
-    CODEC_ID_INDEO4,
-    CODEC_ID_INDEO5,
-    CODEC_ID_MIMIC,
-    CODEC_ID_RL2,
-    CODEC_ID_ESCAPE124,
-    CODEC_ID_DIRAC,
-    CODEC_ID_BFI,
-    CODEC_ID_CMV,
-    CODEC_ID_MOTIONPIXELS,
-    CODEC_ID_TGV,
-    CODEC_ID_TGQ,
-    CODEC_ID_TQI,
-    CODEC_ID_AURA,
-    CODEC_ID_AURA2,
-    CODEC_ID_V210X,
-    CODEC_ID_TMV,
-    CODEC_ID_V210,
-    CODEC_ID_DPX,
-    CODEC_ID_MAD,
-    CODEC_ID_FRWU,
-    CODEC_ID_FLASHSV2,
-    CODEC_ID_CDGRAPHICS,
-    CODEC_ID_R210,
-    CODEC_ID_ANM,
-    CODEC_ID_BINKVIDEO,
-    CODEC_ID_IFF_ILBM,
-    CODEC_ID_IFF_BYTERUN1,
-    CODEC_ID_KGV1,
-    CODEC_ID_YOP,
-    CODEC_ID_VP8,
-    CODEC_ID_PICTOR,
-    CODEC_ID_ANSI,
-    CODEC_ID_A64_MULTI,
-    CODEC_ID_A64_MULTI5,
-    CODEC_ID_R10K,
-    CODEC_ID_MXPEG,
-    CODEC_ID_LAGARITH,
-    CODEC_ID_PRORES,
-    CODEC_ID_JV,
-    CODEC_ID_DFA,
-    CODEC_ID_WMV3IMAGE,
-    CODEC_ID_VC1IMAGE,
-    CODEC_ID_UTVIDEO,
-    CODEC_ID_BMV_VIDEO,
-    CODEC_ID_VBLE,
-    CODEC_ID_DXTORY,
-    CODEC_ID_V410,
-    CODEC_ID_XWD,
-    CODEC_ID_CDXL,
-    CODEC_ID_XBM,
-    CODEC_ID_ZEROCODEC,
-    CODEC_ID_MSS1,
-    CODEC_ID_MSA1,
-    CODEC_ID_TSCC2,
-    CODEC_ID_MTS2,
-    CODEC_ID_CLLC,
-    CODEC_ID_Y41P       = MKBETAG('Y','4','1','P'),
-    CODEC_ID_ESCAPE130  = MKBETAG('E','1','3','0'),
-    CODEC_ID_EXR        = MKBETAG('0','E','X','R'),
-    CODEC_ID_AVRP       = MKBETAG('A','V','R','P'),
-
-    CODEC_ID_G2M        = MKBETAG( 0 ,'G','2','M'),
-    CODEC_ID_AVUI       = MKBETAG('A','V','U','I'),
-    CODEC_ID_AYUV       = MKBETAG('A','Y','U','V'),
-    CODEC_ID_V308       = MKBETAG('V','3','0','8'),
-    CODEC_ID_V408       = MKBETAG('V','4','0','8'),
-    CODEC_ID_YUV4       = MKBETAG('Y','U','V','4'),
-    CODEC_ID_SANM       = MKBETAG('S','A','N','M'),
-    CODEC_ID_PAF_VIDEO  = MKBETAG('P','A','F','V'),
-    CODEC_ID_SNOW       = AV_CODEC_ID_SNOW,
-
-    /* various PCM "codecs" */
-    CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio codecs
-    CODEC_ID_PCM_S16LE = 0x10000,
-    CODEC_ID_PCM_S16BE,
-    CODEC_ID_PCM_U16LE,
-    CODEC_ID_PCM_U16BE,
-    CODEC_ID_PCM_S8,
-    CODEC_ID_PCM_U8,
-    CODEC_ID_PCM_MULAW,
-    CODEC_ID_PCM_ALAW,
-    CODEC_ID_PCM_S32LE,
-    CODEC_ID_PCM_S32BE,
-    CODEC_ID_PCM_U32LE,
-    CODEC_ID_PCM_U32BE,
-    CODEC_ID_PCM_S24LE,
-    CODEC_ID_PCM_S24BE,
-    CODEC_ID_PCM_U24LE,
-    CODEC_ID_PCM_U24BE,
-    CODEC_ID_PCM_S24DAUD,
-    CODEC_ID_PCM_ZORK,
-    CODEC_ID_PCM_S16LE_PLANAR,
-    CODEC_ID_PCM_DVD,
-    CODEC_ID_PCM_F32BE,
-    CODEC_ID_PCM_F32LE,
-    CODEC_ID_PCM_F64BE,
-    CODEC_ID_PCM_F64LE,
-    CODEC_ID_PCM_BLURAY,
-    CODEC_ID_PCM_LXF,
-    CODEC_ID_S302M,
-    CODEC_ID_PCM_S8_PLANAR,
-
-    /* various ADPCM codecs */
-    CODEC_ID_ADPCM_IMA_QT = 0x11000,
-    CODEC_ID_ADPCM_IMA_WAV,
-    CODEC_ID_ADPCM_IMA_DK3,
-    CODEC_ID_ADPCM_IMA_DK4,
-    CODEC_ID_ADPCM_IMA_WS,
-    CODEC_ID_ADPCM_IMA_SMJPEG,
-    CODEC_ID_ADPCM_MS,
-    CODEC_ID_ADPCM_4XM,
-    CODEC_ID_ADPCM_XA,
-    CODEC_ID_ADPCM_ADX,
-    CODEC_ID_ADPCM_EA,
-    CODEC_ID_ADPCM_G726,
-    CODEC_ID_ADPCM_CT,
-    CODEC_ID_ADPCM_SWF,
-    CODEC_ID_ADPCM_YAMAHA,
-    CODEC_ID_ADPCM_SBPRO_4,
-    CODEC_ID_ADPCM_SBPRO_3,
-    CODEC_ID_ADPCM_SBPRO_2,
-    CODEC_ID_ADPCM_THP,
-    CODEC_ID_ADPCM_IMA_AMV,
-    CODEC_ID_ADPCM_EA_R1,
-    CODEC_ID_ADPCM_EA_R3,
-    CODEC_ID_ADPCM_EA_R2,
-    CODEC_ID_ADPCM_IMA_EA_SEAD,
-    CODEC_ID_ADPCM_IMA_EA_EACS,
-    CODEC_ID_ADPCM_EA_XAS,
-    CODEC_ID_ADPCM_EA_MAXIS_XA,
-    CODEC_ID_ADPCM_IMA_ISS,
-    CODEC_ID_ADPCM_G722,
-    CODEC_ID_ADPCM_IMA_APC,
-    CODEC_ID_VIMA       = MKBETAG('V','I','M','A'),
-
-    /* AMR */
-    CODEC_ID_AMR_NB = 0x12000,
-    CODEC_ID_AMR_WB,
-
-    /* RealAudio codecs*/
-    CODEC_ID_RA_144 = 0x13000,
-    CODEC_ID_RA_288,
-
-    /* various DPCM codecs */
-    CODEC_ID_ROQ_DPCM = 0x14000,
-    CODEC_ID_INTERPLAY_DPCM,
-    CODEC_ID_XAN_DPCM,
-    CODEC_ID_SOL_DPCM,
-
-    /* audio codecs */
-    CODEC_ID_MP2 = 0x15000,
-    CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3
-    CODEC_ID_AAC,
-    CODEC_ID_AC3,
-    CODEC_ID_DTS,
-    CODEC_ID_VORBIS,
-    CODEC_ID_DVAUDIO,
-    CODEC_ID_WMAV1,
-    CODEC_ID_WMAV2,
-    CODEC_ID_MACE3,
-    CODEC_ID_MACE6,
-    CODEC_ID_VMDAUDIO,
-    CODEC_ID_FLAC,
-    CODEC_ID_MP3ADU,
-    CODEC_ID_MP3ON4,
-    CODEC_ID_SHORTEN,
-    CODEC_ID_ALAC,
-    CODEC_ID_WESTWOOD_SND1,
-    CODEC_ID_GSM, ///< as in Berlin toast format
-    CODEC_ID_QDM2,
-    CODEC_ID_COOK,
-    CODEC_ID_TRUESPEECH,
-    CODEC_ID_TTA,
-    CODEC_ID_SMACKAUDIO,
-    CODEC_ID_QCELP,
-    CODEC_ID_WAVPACK,
-    CODEC_ID_DSICINAUDIO,
-    CODEC_ID_IMC,
-    CODEC_ID_MUSEPACK7,
-    CODEC_ID_MLP,
-    CODEC_ID_GSM_MS, /* as found in WAV */
-    CODEC_ID_ATRAC3,
-    CODEC_ID_VOXWARE,
-    CODEC_ID_APE,
-    CODEC_ID_NELLYMOSER,
-    CODEC_ID_MUSEPACK8,
-    CODEC_ID_SPEEX,
-    CODEC_ID_WMAVOICE,
-    CODEC_ID_WMAPRO,
-    CODEC_ID_WMALOSSLESS,
-    CODEC_ID_ATRAC3P,
-    CODEC_ID_EAC3,
-    CODEC_ID_SIPR,
-    CODEC_ID_MP1,
-    CODEC_ID_TWINVQ,
-    CODEC_ID_TRUEHD,
-    CODEC_ID_MP4ALS,
-    CODEC_ID_ATRAC1,
-    CODEC_ID_BINKAUDIO_RDFT,
-    CODEC_ID_BINKAUDIO_DCT,
-    CODEC_ID_AAC_LATM,
-    CODEC_ID_QDMC,
-    CODEC_ID_CELT,
-    CODEC_ID_G723_1,
-    CODEC_ID_G729,
-    CODEC_ID_8SVX_EXP,
-    CODEC_ID_8SVX_FIB,
-    CODEC_ID_BMV_AUDIO,
-    CODEC_ID_RALF,
-    CODEC_ID_IAC,
-    CODEC_ID_ILBC,
-    CODEC_ID_FFWAVESYNTH = MKBETAG('F','F','W','S'),
-    CODEC_ID_SONIC       = MKBETAG('S','O','N','C'),
-    CODEC_ID_SONIC_LS    = MKBETAG('S','O','N','L'),
-    CODEC_ID_PAF_AUDIO   = MKBETAG('P','A','F','A'),
-    CODEC_ID_OPUS        = MKBETAG('O','P','U','S'),
-
-    /* subtitle codecs */
-    CODEC_ID_FIRST_SUBTITLE = 0x17000,          ///< A dummy ID pointing at the start of subtitle codecs.
-    CODEC_ID_DVD_SUBTITLE = 0x17000,
-    CODEC_ID_DVB_SUBTITLE,
-    CODEC_ID_TEXT,  ///< raw UTF-8 text
-    CODEC_ID_XSUB,
-    CODEC_ID_SSA,
-    CODEC_ID_MOV_TEXT,
-    CODEC_ID_HDMV_PGS_SUBTITLE,
-    CODEC_ID_DVB_TELETEXT,
-    CODEC_ID_SRT,
-    CODEC_ID_MICRODVD   = MKBETAG('m','D','V','D'),
-    CODEC_ID_EIA_608    = MKBETAG('c','6','0','8'),
-    CODEC_ID_JACOSUB    = MKBETAG('J','S','U','B'),
-    CODEC_ID_SAMI       = MKBETAG('S','A','M','I'),
-    CODEC_ID_REALTEXT   = MKBETAG('R','T','X','T'),
-    CODEC_ID_SUBVIEWER  = MKBETAG('S','u','b','V'),
-
-    /* other specific kind of codecs (generally used for attachments) */
-    CODEC_ID_FIRST_UNKNOWN = 0x18000,           ///< A dummy ID pointing at the start of various fake codecs.
-    CODEC_ID_TTF = 0x18000,
-    CODEC_ID_BINTEXT    = MKBETAG('B','T','X','T'),
-    CODEC_ID_XBIN       = MKBETAG('X','B','I','N'),
-    CODEC_ID_IDF        = MKBETAG( 0 ,'I','D','F'),
-    CODEC_ID_OTF        = MKBETAG( 0 ,'O','T','F'),
-
-    CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like CODEC_ID_NONE) but lavf should attempt to identify it
-
-    CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS
-                                * stream (only used by libavformat) */
-    CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems
-                                * stream (only used by libavformat) */
-    CODEC_ID_FFMETADATA = 0x21000,   ///< Dummy codec for streams containing only metadata information.
-
-#endif /* AVCODEC_OLD_CODEC_IDS_H */

Externals/ffmpeg/include/libavcodec/vaapi.h

@@ -1,173 +0,0 @@
-/*
- * Video Acceleration API (shared data between FFmpeg and the video player)
- * HW decode acceleration for MPEG-2, MPEG-4, H.264 and VC-1
- *
- * Copyright (C) 2008-2009 Splitted-Desktop Systems
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_VAAPI_H
-#define AVCODEC_VAAPI_H
-
-/**
- * @file
- * @ingroup lavc_codec_hwaccel_vaapi
- * Public libavcodec VA API header.
- */
-
-#include <stdint.h>
-
-/**
- * @defgroup lavc_codec_hwaccel_vaapi VA API Decoding
- * @ingroup lavc_codec_hwaccel
- * @{
- */
-
-/**
- * This structure is used to share data between the FFmpeg library and
- * the client video application.
- * This shall be zero-allocated and available as
- * AVCodecContext.hwaccel_context. All user members can be set once
- * during initialization or through each AVCodecContext.get_buffer()
- * function call. In any case, they must be valid prior to calling
- * decoding functions.
- */
-struct vaapi_context {
-    /**
-     * Window system dependent data
-     *
-     * - encoding: unused
-     * - decoding: Set by user
-     */
-    void *display;
-
-    /**
-     * Configuration ID
-     *
-     * - encoding: unused
-     * - decoding: Set by user
-     */
-    uint32_t config_id;
-
-    /**
-     * Context ID (video decode pipeline)
-     *
-     * - encoding: unused
-     * - decoding: Set by user
-     */
-    uint32_t context_id;
-
-    /**
-     * VAPictureParameterBuffer ID
-     *
-     * - encoding: unused
-     * - decoding: Set by libavcodec
-     */
-    uint32_t pic_param_buf_id;
-
-    /**
-     * VAIQMatrixBuffer ID
-     *
-     * - encoding: unused
-     * - decoding: Set by libavcodec
-     */
-    uint32_t iq_matrix_buf_id;
-
-    /**
-     * VABitPlaneBuffer ID (for VC-1 decoding)
-     *
-     * - encoding: unused
-     * - decoding: Set by libavcodec
-     */
-    uint32_t bitplane_buf_id;
-
-    /**
-     * Slice parameter/data buffer IDs
-     *
-     * - encoding: unused
-     * - decoding: Set by libavcodec
-     */
-    uint32_t *slice_buf_ids;
-
-    /**
-     * Number of effective slice buffer IDs to send to the HW
-     *
-     * - encoding: unused
-     * - decoding: Set by libavcodec
-     */
-    unsigned int n_slice_buf_ids;
-
-    /**
-     * Size of pre-allocated slice_buf_ids
-     *
-     * - encoding: unused
-     * - decoding: Set by libavcodec
-     */
-    unsigned int slice_buf_ids_alloc;
-
-    /**
-     * Pointer to VASliceParameterBuffers
-     *
-     * - encoding: unused
-     * - decoding: Set by libavcodec
-     */
-    void *slice_params;
-
-    /**
-     * Size of a VASliceParameterBuffer element
-     *
-     * - encoding: unused
-     * - decoding: Set by libavcodec
-     */
-    unsigned int slice_param_size;
-
-    /**
-     * Size of pre-allocated slice_params
-     *
-     * - encoding: unused
-     * - decoding: Set by libavcodec
-     */
-    unsigned int slice_params_alloc;
-
-    /**
-     * Number of slices currently filled in
-     *
-     * - encoding: unused
-     * - decoding: Set by libavcodec
-     */
-    unsigned int slice_count;
-
-    /**
-     * Pointer to slice data buffer base
-     * - encoding: unused
-     * - decoding: Set by libavcodec
-     */
-    const uint8_t *slice_data;
-
-    /**
-     * Current size of slice data
-     *
-     * - encoding: unused
-     * - decoding: Set by libavcodec
-     */
-    uint32_t slice_data_size;
-};
-
-/* @} */
-
-#endif /* AVCODEC_VAAPI_H */

Externals/ffmpeg/include/libavcodec/vda.h

@@ -1,213 +0,0 @@
-/*
- * VDA HW acceleration
- *
- * copyright (c) 2011 Sebastien Zwickert
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_VDA_H
-#define AVCODEC_VDA_H
-
-/**
- * @file
- * @ingroup lavc_codec_hwaccel_vda
- * Public libavcodec VDA header.
- */
-
-#include "libavcodec/avcodec.h"
-
-#include <stdint.h>
-
-// emmintrin.h is unable to compile with -std=c99 -Werror=missing-prototypes
-// http://openradar.appspot.com/8026390
-#undef __GNUC_STDC_INLINE__
-
-#define Picture QuickdrawPicture
-#include <VideoDecodeAcceleration/VDADecoder.h>
-#undef Picture
-
-#include "libavcodec/version.h"
-
-// extra flags not defined in VDADecoder.h
-enum {
-    kVDADecodeInfo_Asynchronous = 1UL << 0,
-    kVDADecodeInfo_FrameDropped = 1UL << 1
-};
-
-/**
- * @defgroup lavc_codec_hwaccel_vda VDA
- * @ingroup lavc_codec_hwaccel
- *
- * @{
- */
-
-/**
- * This structure is used to provide the necessary configurations and data
- * to the VDA FFmpeg HWAccel implementation.
- *
- * The application must make it available as AVCodecContext.hwaccel_context.
- */
-struct vda_context {
-    /**
-     * VDA decoder object.
-     *
-     * - encoding: unused
-     * - decoding: Set/Unset by libavcodec.
-     */
-    VDADecoder          decoder;
-
-    /**
-     * The Core Video pixel buffer that contains the current image data.
-     *
-     * encoding: unused
-     * decoding: Set by libavcodec. Unset by user.
-     */
-    CVPixelBufferRef    cv_buffer;
-
-    /**
-     * Use the hardware decoder in synchronous mode.
-     *
-     * encoding: unused
-     * decoding: Set by user.
-     */
-    int                 use_sync_decoding;
-
-    /**
-     * The frame width.
-     *
-     * - encoding: unused
-     * - decoding: Set/Unset by user.
-     */
-    int                 width;
-
-    /**
-     * The frame height.
-     *
-     * - encoding: unused
-     * - decoding: Set/Unset by user.
-     */
-    int                 height;
-
-    /**
-     * The frame format.
-     *
-     * - encoding: unused
-     * - decoding: Set/Unset by user.
-     */
-    int                 format;
-
-    /**
-     * The pixel format for output image buffers.
-     *
-     * - encoding: unused
-     * - decoding: Set/Unset by user.
-     */
-    OSType              cv_pix_fmt_type;
-
-    /**
-     * unused
-     */
-    uint8_t             *priv_bitstream;
-
-    /**
-     * unused
-     */
-    int                 priv_bitstream_size;
-
-    /**
-     * unused
-     */
-    int                 priv_allocated_size;
-
-    /**
-     * Use av_buffer to manage buffer.
-     * When the flag is set, the CVPixelBuffers returned by the decoder will
-     * be released automatically, so you have to retain them if necessary.
-     * Not setting this flag may cause memory leak.
-     *
-     * encoding: unused
-     * decoding: Set by user.
-     */
-    int                 use_ref_buffer;
-};
-
-/** Create the video decoder. */
-int ff_vda_create_decoder(struct vda_context *vda_ctx,
-                          uint8_t *extradata,
-                          int extradata_size);
-
-/** Destroy the video decoder. */
-int ff_vda_destroy_decoder(struct vda_context *vda_ctx);
-
-/**
- * This struct holds all the information that needs to be passed
- * between the caller and libavcodec for initializing VDA decoding.
- * Its size is not a part of the public ABI, it must be allocated with
- * av_vda_alloc_context() and freed with av_free().
- */
-typedef struct AVVDAContext {
-    /**
-     * VDA decoder object. Created and freed by the caller.
-     */
-    VDADecoder decoder;
-
-    /**
-     * The output callback that must be passed to VDADecoderCreate.
-     * Set by av_vda_alloc_context().
-     */
-    VDADecoderOutputCallback output_callback;
-} AVVDAContext;
-
-/**
- * Allocate and initialize a VDA context.
- *
- * This function should be called from the get_format() callback when the caller
- * selects the AV_PIX_FMT_VDA format. The caller must then create the decoder
- * object (using the output callback provided by libavcodec) that will be used
- * for VDA-accelerated decoding.
- *
- * When decoding with VDA is finished, the caller must destroy the decoder
- * object and free the VDA context using av_free().
- *
- * @return the newly allocated context or NULL on failure
- */
-AVVDAContext *av_vda_alloc_context(void);
-
-/**
- * This is a convenience function that creates and sets up the VDA context using
- * an internal implementation.
- *
- * @param avctx the corresponding codec context
- *
- * @return >= 0 on success, a negative AVERROR code on failure
- */
-int av_vda_default_init(AVCodecContext *avctx);
-
-/**
- * This function must be called to free the VDA context initialized with
- * av_vda_default_init().
- *
- * @param avctx the corresponding codec context
- */
-void av_vda_default_free(AVCodecContext *avctx);
-
-/**
- * @}
- */
-
-#endif /* AVCODEC_VDA_H */

Externals/ffmpeg/include/libavcodec/vdpau.h

@@ -1,255 +0,0 @@
-/*
- * The Video Decode and Presentation API for UNIX (VDPAU) is used for
- * hardware-accelerated decoding of MPEG-1/2, H.264 and VC-1.
- *
- * Copyright (C) 2008 NVIDIA
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_VDPAU_H
-#define AVCODEC_VDPAU_H
-
-/**
- * @file
- * @ingroup lavc_codec_hwaccel_vdpau
- * Public libavcodec VDPAU header.
- */
-
-
-/**
- * @defgroup lavc_codec_hwaccel_vdpau VDPAU Decoder and Renderer
- * @ingroup lavc_codec_hwaccel
- *
- * VDPAU hardware acceleration has two modules
- * - VDPAU decoding
- * - VDPAU presentation
- *
- * The VDPAU decoding module parses all headers using FFmpeg
- * parsing mechanisms and uses VDPAU for the actual decoding.
- *
- * As per the current implementation, the actual decoding
- * and rendering (API calls) are done as part of the VDPAU
- * presentation (vo_vdpau.c) module.
- *
- * @{
- */
-
-#include <vdpau/vdpau.h>
-#include <vdpau/vdpau_x11.h>
-#include "libavutil/avconfig.h"
-#include "libavutil/attributes.h"
-
-#include "avcodec.h"
-#include "version.h"
-
-#if FF_API_BUFS_VDPAU
-union AVVDPAUPictureInfo {
-    VdpPictureInfoH264        h264;
-    VdpPictureInfoMPEG1Or2    mpeg;
-    VdpPictureInfoVC1          vc1;
-    VdpPictureInfoMPEG4Part2 mpeg4;
-};
-#endif
-
-struct AVCodecContext;
-struct AVFrame;
-
-typedef int (*AVVDPAU_Render2)(struct AVCodecContext *, struct AVFrame *,
-                               const VdpPictureInfo *, uint32_t,
-                               const VdpBitstreamBuffer *);
-
-/**
- * This structure is used to share data between the libavcodec library and
- * the client video application.
- * The user shall allocate the structure via the av_alloc_vdpau_hwaccel
- * function and make it available as
- * AVCodecContext.hwaccel_context. Members can be set by the user once
- * during initialization or through each AVCodecContext.get_buffer()
- * function call. In any case, they must be valid prior to calling
- * decoding functions.
- *
- * The size of this structure is not a part of the public ABI and must not
- * be used outside of libavcodec. Use av_vdpau_alloc_context() to allocate an
- * AVVDPAUContext.
- */
-typedef struct AVVDPAUContext {
-    /**
-     * VDPAU decoder handle
-     *
-     * Set by user.
-     */
-    VdpDecoder decoder;
-
-    /**
-     * VDPAU decoder render callback
-     *
-     * Set by the user.
-     */
-    VdpDecoderRender *render;
-
-#if FF_API_BUFS_VDPAU
-    /**
-     * VDPAU picture information
-     *
-     * Set by libavcodec.
-     */
-    attribute_deprecated
-    union AVVDPAUPictureInfo info;
-
-    /**
-     * Allocated size of the bitstream_buffers table.
-     *
-     * Set by libavcodec.
-     */
-    attribute_deprecated
-    int bitstream_buffers_allocated;
-
-    /**
-     * Useful bitstream buffers in the bitstream buffers table.
-     *
-     * Set by libavcodec.
-     */
-    attribute_deprecated
-    int bitstream_buffers_used;
-
-   /**
-     * Table of bitstream buffers.
-     * The user is responsible for freeing this buffer using av_freep().
-     *
-     * Set by libavcodec.
-     */
-    attribute_deprecated
-    VdpBitstreamBuffer *bitstream_buffers;
-#endif
-    AVVDPAU_Render2 render2;
-} AVVDPAUContext;
-
-/**
- * @brief allocation function for AVVDPAUContext
- *
- * Allows extending the struct without breaking API/ABI
- */
-AVVDPAUContext *av_alloc_vdpaucontext(void);
-
-AVVDPAU_Render2 av_vdpau_hwaccel_get_render2(const AVVDPAUContext *);
-void av_vdpau_hwaccel_set_render2(AVVDPAUContext *, AVVDPAU_Render2);
-
-/**
- * Associate a VDPAU device with a codec context for hardware acceleration.
- * This function is meant to be called from the get_format() codec callback,
- * or earlier. It can also be called after avcodec_flush_buffers() to change
- * the underlying VDPAU device mid-stream (e.g. to recover from non-transparent
- * display preemption).
- *
- * @note get_format() must return AV_PIX_FMT_VDPAU if this function completes
- * successfully.
- *
- * @param avctx decoding context whose get_format() callback is invoked
- * @param device VDPAU device handle to use for hardware acceleration
- * @param get_proc_address VDPAU device driver
- * @param flags zero of more OR'd AV_HWACCEL_FLAG_* flags
- *
- * @return 0 on success, an AVERROR code on failure.
- */
-int av_vdpau_bind_context(AVCodecContext *avctx, VdpDevice device,
-                          VdpGetProcAddress *get_proc_address, unsigned flags);
-
-/**
- * Gets the parameters to create an adequate VDPAU video surface for the codec
- * context using VDPAU hardware decoding acceleration.
- *
- * @note Behavior is undefined if the context was not successfully bound to a
- * VDPAU device using av_vdpau_bind_context().
- *
- * @param avctx the codec context being used for decoding the stream
- * @param type storage space for the VDPAU video surface chroma type
- *              (or NULL to ignore)
- * @param width storage space for the VDPAU video surface pixel width
- *              (or NULL to ignore)
- * @param height storage space for the VDPAU video surface pixel height
- *              (or NULL to ignore)
- *
- * @return 0 on success, a negative AVERROR code on failure.
- */
-int av_vdpau_get_surface_parameters(AVCodecContext *avctx, VdpChromaType *type,
-                                    uint32_t *width, uint32_t *height);
-
-/**
- * Allocate an AVVDPAUContext.
- *
- * @return Newly-allocated AVVDPAUContext or NULL on failure.
- */
-AVVDPAUContext *av_vdpau_alloc_context(void);
-
-/**
- * Get a decoder profile that should be used for initializing a VDPAU decoder.
- * Should be called from the AVCodecContext.get_format() callback.
- *
- * @param avctx the codec context being used for decoding the stream
- * @param profile a pointer into which the result will be written on success.
- *                The contents of profile are undefined if this function returns
- *                an error.
- *
- * @return 0 on success (non-negative), a negative AVERROR on failure.
- */
-int av_vdpau_get_profile(AVCodecContext *avctx, VdpDecoderProfile *profile);
-
-#if FF_API_CAP_VDPAU
-/** @brief The videoSurface is used for rendering. */
-#define FF_VDPAU_STATE_USED_FOR_RENDER 1
-
-/**
- * @brief The videoSurface is needed for reference/prediction.
- * The codec manipulates this.
- */
-#define FF_VDPAU_STATE_USED_FOR_REFERENCE 2
-
-/**
- * @brief This structure is used as a callback between the FFmpeg
- * decoder (vd_) and presentation (vo_) module.
- * This is used for defining a video frame containing surface,
- * picture parameter, bitstream information etc which are passed
- * between the FFmpeg decoder and its clients.
- */
-struct vdpau_render_state {
-    VdpVideoSurface surface; ///< Used as rendered surface, never changed.
-
-    int state; ///< Holds FF_VDPAU_STATE_* values.
-
-#if AV_HAVE_INCOMPATIBLE_LIBAV_ABI
-    /** picture parameter information for all supported codecs */
-    union AVVDPAUPictureInfo info;
-#endif
-
-    /** Describe size/location of the compressed video data.
-        Set to 0 when freeing bitstream_buffers. */
-    int bitstream_buffers_allocated;
-    int bitstream_buffers_used;
-    /** The user is responsible for freeing this buffer using av_freep(). */
-    VdpBitstreamBuffer *bitstream_buffers;
-
-#if !AV_HAVE_INCOMPATIBLE_LIBAV_ABI
-    /** picture parameter information for all supported codecs */
-    union AVVDPAUPictureInfo info;
-#endif
-};
-#endif
-
-/* @}*/
-
-#endif /* AVCODEC_VDPAU_H */

Externals/ffmpeg/include/libavcodec/version.h

@@ -1,188 +0,0 @@
-/*
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_VERSION_H
-#define AVCODEC_VERSION_H
-
-/**
- * @file
- * @ingroup libavc
- * Libavcodec version macros.
- */
-
-#include "libavutil/version.h"
-
-#define LIBAVCODEC_VERSION_MAJOR 56
-#define LIBAVCODEC_VERSION_MINOR  20
-#define LIBAVCODEC_VERSION_MICRO 100
-
-#define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
-                                               LIBAVCODEC_VERSION_MINOR, \
-                                               LIBAVCODEC_VERSION_MICRO)
-#define LIBAVCODEC_VERSION      AV_VERSION(LIBAVCODEC_VERSION_MAJOR,    \
-                                           LIBAVCODEC_VERSION_MINOR,    \
-                                           LIBAVCODEC_VERSION_MICRO)
-#define LIBAVCODEC_BUILD        LIBAVCODEC_VERSION_INT
-
-#define LIBAVCODEC_IDENT        "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION)
-
-/**
- * FF_API_* defines may be placed below to indicate public API that will be
- * dropped at a future version bump. The defines themselves are not part of
- * the public API and may change, break or disappear at any time.
- */
-
-#ifndef FF_API_REQUEST_CHANNELS
-#define FF_API_REQUEST_CHANNELS (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_OLD_DECODE_AUDIO
-#define FF_API_OLD_DECODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_OLD_ENCODE_AUDIO
-#define FF_API_OLD_ENCODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_OLD_ENCODE_VIDEO
-#define FF_API_OLD_ENCODE_VIDEO (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_CODEC_ID
-#define FF_API_CODEC_ID          (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_AUDIO_CONVERT
-#define FF_API_AUDIO_CONVERT     (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_AVCODEC_RESAMPLE
-#define FF_API_AVCODEC_RESAMPLE  FF_API_AUDIO_CONVERT
-#endif
-#ifndef FF_API_DEINTERLACE
-#define FF_API_DEINTERLACE       (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_DESTRUCT_PACKET
-#define FF_API_DESTRUCT_PACKET   (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_GET_BUFFER
-#define FF_API_GET_BUFFER        (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_MISSING_SAMPLE
-#define FF_API_MISSING_SAMPLE    (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_LOWRES
-#define FF_API_LOWRES            (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_CAP_VDPAU
-#define FF_API_CAP_VDPAU         (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_BUFS_VDPAU
-#define FF_API_BUFS_VDPAU        (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_VOXWARE
-#define FF_API_VOXWARE           (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_SET_DIMENSIONS
-#define FF_API_SET_DIMENSIONS    (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_DEBUG_MV
-#define FF_API_DEBUG_MV          (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_AC_VLC
-#define FF_API_AC_VLC            (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_OLD_MSMPEG4
-#define FF_API_OLD_MSMPEG4       (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_ASPECT_EXTENDED
-#define FF_API_ASPECT_EXTENDED   (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_THREAD_OPAQUE
-#define FF_API_THREAD_OPAQUE     (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_CODEC_PKT
-#define FF_API_CODEC_PKT         (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_ARCH_ALPHA
-#define FF_API_ARCH_ALPHA        (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_XVMC
-#define FF_API_XVMC              (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_ERROR_RATE
-#define FF_API_ERROR_RATE        (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_QSCALE_TYPE
-#define FF_API_QSCALE_TYPE       (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_MB_TYPE
-#define FF_API_MB_TYPE           (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_MAX_BFRAMES
-#define FF_API_MAX_BFRAMES       (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_NEG_LINESIZES
-#define FF_API_NEG_LINESIZES     (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_EMU_EDGE
-#define FF_API_EMU_EDGE          (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_ARCH_SH4
-#define FF_API_ARCH_SH4          (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_ARCH_SPARC
-#define FF_API_ARCH_SPARC        (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_UNUSED_MEMBERS
-#define FF_API_UNUSED_MEMBERS    (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_IDCT_XVIDMMX
-#define FF_API_IDCT_XVIDMMX      (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_INPUT_PRESERVED
-#define FF_API_INPUT_PRESERVED   (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_NORMALIZE_AQP
-#define FF_API_NORMALIZE_AQP     (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_GMC
-#define FF_API_GMC               (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_MV0
-#define FF_API_MV0               (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_CODEC_NAME
-#define FF_API_CODEC_NAME        (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_AFD
-#define FF_API_AFD               (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_VISMV
-/* XXX: don't forget to drop the -vismv documentation */
-#define FF_API_VISMV             (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_DV_FRAME_PROFILE
-#define FF_API_DV_FRAME_PROFILE  (LIBAVCODEC_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_AUDIOENC_DELAY
-#define FF_API_AUDIOENC_DELAY    (LIBAVCODEC_VERSION_MAJOR < 58)
-#endif
-#ifndef FF_API_AVCTX_TIMEBASE
-#define FF_API_AVCTX_TIMEBASE    (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-#ifndef FF_API_MPV_OPT
-#define FF_API_MPV_OPT           (LIBAVCODEC_VERSION_MAJOR < 59)
-#endif
-
-#endif /* AVCODEC_VERSION_H */

Externals/ffmpeg/include/libavcodec/vorbis_parser.h

@@ -1,77 +0,0 @@
-/*
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * A public API for Vorbis parsing
- *
- * Determines the duration for each packet.
- */
-
-#ifndef AVCODEC_VORBIS_PARSE_H
-#define AVCODEC_VORBIS_PARSE_H
-
-#include <stdint.h>
-
-typedef struct AVVorbisParseContext AVVorbisParseContext;
-
-/**
- * Allocate and initialize the Vorbis parser using headers in the extradata.
- *
- * @param avctx codec context
- * @param s     Vorbis parser context
- */
-AVVorbisParseContext *av_vorbis_parse_init(const uint8_t *extradata,
-                                           int extradata_size);
-
-/**
- * Free the parser and everything associated with it.
- */
-void av_vorbis_parse_free(AVVorbisParseContext **s);
-
-#define VORBIS_FLAG_HEADER  0x00000001
-#define VORBIS_FLAG_COMMENT 0x00000002
-
-/**
- * Get the duration for a Vorbis packet.
- *
- * If @p flags is @c NULL,
- * special frames are considered invalid.
- *
- * @param s        Vorbis parser context
- * @param buf      buffer containing a Vorbis frame
- * @param buf_size size of the buffer
- * @param flags    flags for special frames
- */
-int av_vorbis_parse_frame_flags(AVVorbisParseContext *s, const uint8_t *buf,
-                                int buf_size, int *flags);
-
-/**
- * Get the duration for a Vorbis packet.
- *
- * @param s        Vorbis parser context
- * @param buf      buffer containing a Vorbis frame
- * @param buf_size size of the buffer
- */
-int av_vorbis_parse_frame(AVVorbisParseContext *s, const uint8_t *buf,
-                          int buf_size);
-
-void av_vorbis_parse_reset(AVVorbisParseContext *s);
-
-#endif /* AVCODEC_VORBIS_PARSE_H */

Externals/ffmpeg/include/libavcodec/xvmc.h

@@ -1,170 +0,0 @@
-/*
- * Copyright (C) 2003 Ivan Kalvachev
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVCODEC_XVMC_H
-#define AVCODEC_XVMC_H
-
-/**
- * @file
- * @ingroup lavc_codec_hwaccel_xvmc
- * Public libavcodec XvMC header.
- */
-
-#include <X11/extensions/XvMC.h>
-
-#include "libavutil/attributes.h"
-#include "version.h"
-#include "avcodec.h"
-
-/**
- * @defgroup lavc_codec_hwaccel_xvmc XvMC
- * @ingroup lavc_codec_hwaccel
- *
- * @{
- */
-
-#define AV_XVMC_ID                    0x1DC711C0  /**< special value to ensure that regular pixel routines haven't corrupted the struct
-                                                       the number is 1337 speak for the letters IDCT MCo (motion compensation) */
-
-attribute_deprecated struct xvmc_pix_fmt {
-    /** The field contains the special constant value AV_XVMC_ID.
-        It is used as a test that the application correctly uses the API,
-        and that there is no corruption caused by pixel routines.
-        - application - set during initialization
-        - libavcodec  - unchanged
-    */
-    int             xvmc_id;
-
-    /** Pointer to the block array allocated by XvMCCreateBlocks().
-        The array has to be freed by XvMCDestroyBlocks().
-        Each group of 64 values represents one data block of differential
-        pixel information (in MoCo mode) or coefficients for IDCT.
-        - application - set the pointer during initialization
-        - libavcodec  - fills coefficients/pixel data into the array
-    */
-    short*          data_blocks;
-
-    /** Pointer to the macroblock description array allocated by
-        XvMCCreateMacroBlocks() and freed by XvMCDestroyMacroBlocks().
-        - application - set the pointer during initialization
-        - libavcodec  - fills description data into the array
-    */
-    XvMCMacroBlock* mv_blocks;
-
-    /** Number of macroblock descriptions that can be stored in the mv_blocks
-        array.
-        - application - set during initialization
-        - libavcodec  - unchanged
-    */
-    int             allocated_mv_blocks;
-
-    /** Number of blocks that can be stored at once in the data_blocks array.
-        - application - set during initialization
-        - libavcodec  - unchanged
-    */
-    int             allocated_data_blocks;
-
-    /** Indicate that the hardware would interpret data_blocks as IDCT
-        coefficients and perform IDCT on them.
-        - application - set during initialization
-        - libavcodec  - unchanged
-    */
-    int             idct;
-
-    /** In MoCo mode it indicates that intra macroblocks are assumed to be in
-        unsigned format; same as the XVMC_INTRA_UNSIGNED flag.
-        - application - set during initialization
-        - libavcodec  - unchanged
-    */
-    int             unsigned_intra;
-
-    /** Pointer to the surface allocated by XvMCCreateSurface().
-        It has to be freed by XvMCDestroySurface() on application exit.
-        It identifies the frame and its state on the video hardware.
-        - application - set during initialization
-        - libavcodec  - unchanged
-    */
-    XvMCSurface*    p_surface;
-
-/** Set by the decoder before calling ff_draw_horiz_band(),
-    needed by the XvMCRenderSurface function. */
-//@{
-    /** Pointer to the surface used as past reference
-        - application - unchanged
-        - libavcodec  - set
-    */
-    XvMCSurface*    p_past_surface;
-
-    /** Pointer to the surface used as future reference
-        - application - unchanged
-        - libavcodec  - set
-    */
-    XvMCSurface*    p_future_surface;
-
-    /** top/bottom field or frame
-        - application - unchanged
-        - libavcodec  - set
-    */
-    unsigned int    picture_structure;
-
-    /** XVMC_SECOND_FIELD - 1st or 2nd field in the sequence
-        - application - unchanged
-        - libavcodec  - set
-    */
-    unsigned int    flags;
-//}@
-
-    /** Number of macroblock descriptions in the mv_blocks array
-        that have already been passed to the hardware.
-        - application - zeroes it on get_buffer().
-                        A successful ff_draw_horiz_band() may increment it
-                        with filled_mb_block_num or zero both.
-        - libavcodec  - unchanged
-    */
-    int             start_mv_blocks_num;
-
-    /** Number of new macroblock descriptions in the mv_blocks array (after
-        start_mv_blocks_num) that are filled by libavcodec and have to be
-        passed to the hardware.
-        - application - zeroes it on get_buffer() or after successful
-                        ff_draw_horiz_band().
-        - libavcodec  - increment with one of each stored MB
-    */
-    int             filled_mv_blocks_num;
-
-    /** Number of the next free data block; one data block consists of
-        64 short values in the data_blocks array.
-        All blocks before this one have already been claimed by placing their
-        position into the corresponding block description structure field,
-        that are part of the mv_blocks array.
-        - application - zeroes it on get_buffer().
-                        A successful ff_draw_horiz_band() may zero it together
-                        with start_mb_blocks_num.
-        - libavcodec  - each decoded macroblock increases it by the number
-                        of coded blocks it contains.
-    */
-    int             next_free_data_block_num;
-};
-
-/**
- * @}
- */
-
-#endif /* AVCODEC_XVMC_H */

Externals/ffmpeg/include/libavdevice/avdevice.h

@@ -1,509 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVDEVICE_AVDEVICE_H
-#define AVDEVICE_AVDEVICE_H
-
-#include "version.h"
-
-/**
- * @file
- * @ingroup lavd
- * Main libavdevice API header
- */
-
-/**
- * @defgroup lavd Special devices muxing/demuxing library
- * @{
- * Libavdevice is a complementary library to @ref libavf "libavformat". It
- * provides various "special" platform-specific muxers and demuxers, e.g. for
- * grabbing devices, audio capture and playback etc. As a consequence, the
- * (de)muxers in libavdevice are of the AVFMT_NOFILE type (they use their own
- * I/O functions). The filename passed to avformat_open_input() often does not
- * refer to an actually existing file, but has some special device-specific
- * meaning - e.g. for x11grab it is the display name.
- *
- * To use libavdevice, simply call avdevice_register_all() to register all
- * compiled muxers and demuxers. They all use standard libavformat API.
- * @}
- */
-
-#include "libavutil/log.h"
-#include "libavutil/opt.h"
-#include "libavutil/dict.h"
-#include "libavformat/avformat.h"
-
-/**
- * Return the LIBAVDEVICE_VERSION_INT constant.
- */
-unsigned avdevice_version(void);
-
-/**
- * Return the libavdevice build-time configuration.
- */
-const char *avdevice_configuration(void);
-
-/**
- * Return the libavdevice license.
- */
-const char *avdevice_license(void);
-
-/**
- * Initialize libavdevice and register all the input and output devices.
- * @warning This function is not thread safe.
- */
-void avdevice_register_all(void);
-
-/**
- * Audio input devices iterator.
- *
- * If d is NULL, returns the first registered input audio/video device,
- * if d is non-NULL, returns the next registered input audio/video device after d
- * or NULL if d is the last one.
- */
-AVInputFormat *av_input_audio_device_next(AVInputFormat  *d);
-
-/**
- * Video input devices iterator.
- *
- * If d is NULL, returns the first registered input audio/video device,
- * if d is non-NULL, returns the next registered input audio/video device after d
- * or NULL if d is the last one.
- */
-AVInputFormat *av_input_video_device_next(AVInputFormat  *d);
-
-/**
- * Audio output devices iterator.
- *
- * If d is NULL, returns the first registered output audio/video device,
- * if d is non-NULL, returns the next registered output audio/video device after d
- * or NULL if d is the last one.
- */
-AVOutputFormat *av_output_audio_device_next(AVOutputFormat *d);
-
-/**
- * Video output devices iterator.
- *
- * If d is NULL, returns the first registered output audio/video device,
- * if d is non-NULL, returns the next registered output audio/video device after d
- * or NULL if d is the last one.
- */
-AVOutputFormat *av_output_video_device_next(AVOutputFormat *d);
-
-typedef struct AVDeviceRect {
-    int x;      /**< x coordinate of top left corner */
-    int y;      /**< y coordinate of top left corner */
-    int width;  /**< width */
-    int height; /**< height */
-} AVDeviceRect;
-
-/**
- * Message types used by avdevice_app_to_dev_control_message().
- */
-enum AVAppToDevMessageType {
-    /**
-     * Dummy message.
-     */
-    AV_APP_TO_DEV_NONE = MKBETAG('N','O','N','E'),
-
-    /**
-     * Window size change message.
-     *
-     * Message is sent to the device every time the application changes the size
-     * of the window device renders to.
-     * Message should also be sent right after window is created.
-     *
-     * data: AVDeviceRect: new window size.
-     */
-    AV_APP_TO_DEV_WINDOW_SIZE = MKBETAG('G','E','O','M'),
-
-    /**
-     * Repaint request message.
-     *
-     * Message is sent to the device when window has to be repainted.
-     *
-     * data: AVDeviceRect: area required to be repainted.
-     *       NULL: whole area is required to be repainted.
-     */
-    AV_APP_TO_DEV_WINDOW_REPAINT = MKBETAG('R','E','P','A'),
-
-    /**
-     * Request pause/play.
-     *
-     * Application requests pause/unpause playback.
-     * Mostly usable with devices that have internal buffer.
-     * By default devices are not paused.
-     *
-     * data: NULL
-     */
-    AV_APP_TO_DEV_PAUSE        = MKBETAG('P', 'A', 'U', ' '),
-    AV_APP_TO_DEV_PLAY         = MKBETAG('P', 'L', 'A', 'Y'),
-    AV_APP_TO_DEV_TOGGLE_PAUSE = MKBETAG('P', 'A', 'U', 'T'),
-
-    /**
-     * Volume control message.
-     *
-     * Set volume level. It may be device-dependent if volume
-     * is changed per stream or system wide. Per stream volume
-     * change is expected when possible.
-     *
-     * data: double: new volume with range of 0.0 - 1.0.
-     */
-    AV_APP_TO_DEV_SET_VOLUME = MKBETAG('S', 'V', 'O', 'L'),
-
-    /**
-     * Mute control messages.
-     *
-     * Change mute state. It may be device-dependent if mute status
-     * is changed per stream or system wide. Per stream mute status
-     * change is expected when possible.
-     *
-     * data: NULL.
-     */
-    AV_APP_TO_DEV_MUTE        = MKBETAG(' ', 'M', 'U', 'T'),
-    AV_APP_TO_DEV_UNMUTE      = MKBETAG('U', 'M', 'U', 'T'),
-    AV_APP_TO_DEV_TOGGLE_MUTE = MKBETAG('T', 'M', 'U', 'T'),
-
-    /**
-     * Get volume/mute messages.
-     *
-     * Force the device to send AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED or
-     * AV_DEV_TO_APP_MUTE_STATE_CHANGED command respectively.
-     *
-     * data: NULL.
-     */
-    AV_APP_TO_DEV_GET_VOLUME = MKBETAG('G', 'V', 'O', 'L'),
-    AV_APP_TO_DEV_GET_MUTE   = MKBETAG('G', 'M', 'U', 'T'),
-};
-
-/**
- * Message types used by avdevice_dev_to_app_control_message().
- */
-enum AVDevToAppMessageType {
-    /**
-     * Dummy message.
-     */
-    AV_DEV_TO_APP_NONE = MKBETAG('N','O','N','E'),
-
-    /**
-     * Create window buffer message.
-     *
-     * Device requests to create a window buffer. Exact meaning is device-
-     * and application-dependent. Message is sent before rendering first
-     * frame and all one-shot initializations should be done here.
-     * Application is allowed to ignore preferred window buffer size.
-     *
-     * @note: Application is obligated to inform about window buffer size
-     *        with AV_APP_TO_DEV_WINDOW_SIZE message.
-     *
-     * data: AVDeviceRect: preferred size of the window buffer.
-     *       NULL: no preferred size of the window buffer.
-     */
-    AV_DEV_TO_APP_CREATE_WINDOW_BUFFER = MKBETAG('B','C','R','E'),
-
-    /**
-     * Prepare window buffer message.
-     *
-     * Device requests to prepare a window buffer for rendering.
-     * Exact meaning is device- and application-dependent.
-     * Message is sent before rendering of each frame.
-     *
-     * data: NULL.
-     */
-    AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER = MKBETAG('B','P','R','E'),
-
-    /**
-     * Display window buffer message.
-     *
-     * Device requests to display a window buffer.
-     * Message is sent when new frame is ready to be displayed.
-     * Usually buffers need to be swapped in handler of this message.
-     *
-     * data: NULL.
-     */
-    AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER = MKBETAG('B','D','I','S'),
-
-    /**
-     * Destroy window buffer message.
-     *
-     * Device requests to destroy a window buffer.
-     * Message is sent when device is about to be destroyed and window
-     * buffer is not required anymore.
-     *
-     * data: NULL.
-     */
-    AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER = MKBETAG('B','D','E','S'),
-
-    /**
-     * Buffer fullness status messages.
-     *
-     * Device signals buffer overflow/underflow.
-     *
-     * data: NULL.
-     */
-    AV_DEV_TO_APP_BUFFER_OVERFLOW = MKBETAG('B','O','F','L'),
-    AV_DEV_TO_APP_BUFFER_UNDERFLOW = MKBETAG('B','U','F','L'),
-
-    /**
-     * Buffer readable/writable.
-     *
-     * Device informs that buffer is readable/writable.
-     * When possible, device informs how many bytes can be read/write.
-     *
-     * @warning Device may not inform when number of bytes than can be read/write changes.
-     *
-     * data: int64_t: amount of bytes available to read/write.
-     *       NULL: amount of bytes available to read/write is not known.
-     */
-    AV_DEV_TO_APP_BUFFER_READABLE = MKBETAG('B','R','D',' '),
-    AV_DEV_TO_APP_BUFFER_WRITABLE = MKBETAG('B','W','R',' '),
-
-    /**
-     * Mute state change message.
-     *
-     * Device informs that mute state has changed.
-     *
-     * data: int: 0 for not muted state, non-zero for muted state.
-     */
-    AV_DEV_TO_APP_MUTE_STATE_CHANGED = MKBETAG('C','M','U','T'),
-
-    /**
-     * Volume level change message.
-     *
-     * Device informs that volume level has changed.
-     *
-     * data: double: new volume with range of 0.0 - 1.0.
-     */
-    AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED = MKBETAG('C','V','O','L'),
-};
-
-/**
- * Send control message from application to device.
- *
- * @param s         device context.
- * @param type      message type.
- * @param data      message data. Exact type depends on message type.
- * @param data_size size of message data.
- * @return >= 0 on success, negative on error.
- *         AVERROR(ENOSYS) when device doesn't implement handler of the message.
- */
-int avdevice_app_to_dev_control_message(struct AVFormatContext *s,
-                                        enum AVAppToDevMessageType type,
-                                        void *data, size_t data_size);
-
-/**
- * Send control message from device to application.
- *
- * @param s         device context.
- * @param type      message type.
- * @param data      message data. Can be NULL.
- * @param data_size size of message data.
- * @return >= 0 on success, negative on error.
- *         AVERROR(ENOSYS) when application doesn't implement handler of the message.
- */
-int avdevice_dev_to_app_control_message(struct AVFormatContext *s,
-                                        enum AVDevToAppMessageType type,
-                                        void *data, size_t data_size);
-
-/**
- * Following API allows user to probe device capabilities (supported codecs,
- * pixel formats, sample formats, resolutions, channel counts, etc).
- * It is build on top op AVOption API.
- * Queried capabilities allows to set up converters of video or audio
- * parameters that fit to the device.
- *
- * List of capabilities that can be queried:
- *  - Capabilities valid for both audio and video devices:
- *    - codec:          supported audio/video codecs.
- *                      type: AV_OPT_TYPE_INT (AVCodecID value)
- *  - Capabilities valid for audio devices:
- *    - sample_format:  supported sample formats.
- *                      type: AV_OPT_TYPE_INT (AVSampleFormat value)
- *    - sample_rate:    supported sample rates.
- *                      type: AV_OPT_TYPE_INT
- *    - channels:       supported number of channels.
- *                      type: AV_OPT_TYPE_INT
- *    - channel_layout: supported channel layouts.
- *                      type: AV_OPT_TYPE_INT64
- *  - Capabilities valid for video devices:
- *    - pixel_format:   supported pixel formats.
- *                      type: AV_OPT_TYPE_INT (AVPixelFormat value)
- *    - window_size:    supported window sizes (describes size of the window size presented to the user).
- *                      type: AV_OPT_TYPE_IMAGE_SIZE
- *    - frame_size:     supported frame sizes (describes size of provided video frames).
- *                      type: AV_OPT_TYPE_IMAGE_SIZE
- *    - fps:            supported fps values
- *                      type: AV_OPT_TYPE_RATIONAL
- *
- * Value of the capability may be set by user using av_opt_set() function
- * and AVDeviceCapabilitiesQuery object. Following queries will
- * limit results to the values matching already set capabilities.
- * For example, setting a codec may impact number of formats or fps values
- * returned during next query. Setting invalid value may limit results to zero.
- *
- * Example of the usage basing on opengl output device:
- *
- * @code
- *  AVFormatContext *oc = NULL;
- *  AVDeviceCapabilitiesQuery *caps = NULL;
- *  AVOptionRanges *ranges;
- *  int ret;
- *
- *  if ((ret = avformat_alloc_output_context2(&oc, NULL, "opengl", NULL)) < 0)
- *      goto fail;
- *  if (avdevice_capabilities_create(&caps, oc, NULL) < 0)
- *      goto fail;
- *
- *  //query codecs
- *  if (av_opt_query_ranges(&ranges, caps, "codec", AV_OPT_MULTI_COMPONENT_RANGE)) < 0)
- *      goto fail;
- *  //pick codec here and set it
- *  av_opt_set(caps, "codec", AV_CODEC_ID_RAWVIDEO, 0);
- *
- *  //query format
- *  if (av_opt_query_ranges(&ranges, caps, "pixel_format", AV_OPT_MULTI_COMPONENT_RANGE)) < 0)
- *      goto fail;
- *  //pick format here and set it
- *  av_opt_set(caps, "pixel_format", AV_PIX_FMT_YUV420P, 0);
- *
- *  //query and set more capabilities
- *
- * fail:
- *  //clean up code
- *  avdevice_capabilities_free(&query, oc);
- *  avformat_free_context(oc);
- * @endcode
- */
-
-/**
- * Structure describes device capabilities.
- *
- * It is used by devices in conjunction with av_device_capabilities AVOption table
- * to implement capabilities probing API based on AVOption API. Should not be used directly.
- */
-typedef struct AVDeviceCapabilitiesQuery {
-    const AVClass *av_class;
-    AVFormatContext *device_context;
-    enum AVCodecID codec;
-    enum AVSampleFormat sample_format;
-    enum AVPixelFormat pixel_format;
-    int sample_rate;
-    int channels;
-    int64_t channel_layout;
-    int window_width;
-    int window_height;
-    int frame_width;
-    int frame_height;
-    AVRational fps;
-} AVDeviceCapabilitiesQuery;
-
-/**
- * AVOption table used by devices to implement device capabilities API. Should not be used by a user.
- */
-extern const AVOption av_device_capabilities[];
-
-/**
- * Initialize capabilities probing API based on AVOption API.
- *
- * avdevice_capabilities_free() must be called when query capabilities API is
- * not used anymore.
- *
- * @param[out] caps      Device capabilities data. Pointer to a NULL pointer must be passed.
- * @param s              Context of the device.
- * @param device_options An AVDictionary filled with device-private options.
- *                       On return this parameter will be destroyed and replaced with a dict
- *                       containing options that were not found. May be NULL.
- *                       The same options must be passed later to avformat_write_header() for output
- *                       devices or avformat_open_input() for input devices, or at any other place
- *                       that affects device-private options.
- *
- * @return >= 0 on success, negative otherwise.
- */
-int avdevice_capabilities_create(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s,
-                                 AVDictionary **device_options);
-
-/**
- * Free resources created by avdevice_capabilities_create()
- *
- * @param caps Device capabilities data to be freed.
- * @param s    Context of the device.
- */
-void avdevice_capabilities_free(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s);
-
-/**
- * Structure describes basic parameters of the device.
- */
-typedef struct AVDeviceInfo {
-    char *device_name;                   /**< device name, format depends on device */
-    char *device_description;            /**< human friendly name */
-} AVDeviceInfo;
-
-/**
- * List of devices.
- */
-typedef struct AVDeviceInfoList {
-    AVDeviceInfo **devices;              /**< list of autodetected devices */
-    int nb_devices;                      /**< number of autodetected devices */
-    int default_device;                  /**< index of default device or -1 if no default */
-} AVDeviceInfoList;
-
-/**
- * List devices.
- *
- * Returns available device names and their parameters.
- *
- * @note: Some devices may accept system-dependent device names that cannot be
- *        autodetected. The list returned by this function cannot be assumed to
- *        be always completed.
- *
- * @param s                device context.
- * @param[out] device_list list of autodetected devices.
- * @return count of autodetected devices, negative on error.
- */
-int avdevice_list_devices(struct AVFormatContext *s, AVDeviceInfoList **device_list);
-
-/**
- * Convenient function to free result of avdevice_list_devices().
- *
- * @param devices device list to be freed.
- */
-void avdevice_free_list_devices(AVDeviceInfoList **device_list);
-
-/**
- * List devices.
- *
- * Returns available device names and their parameters.
- * These are convinient wrappers for avdevice_list_devices().
- * Device context is allocated and deallocated internally.
- *
- * @param device           device format. May be NULL if device name is set.
- * @param device_name      device name. May be NULL if device format is set.
- * @param device_options   An AVDictionary filled with device-private options. May be NULL.
- *                         The same options must be passed later to avformat_write_header() for output
- *                         devices or avformat_open_input() for input devices, or at any other place
- *                         that affects device-private options.
- * @param[out] device_list list of autodetected devices
- * @return count of autodetected devices, negative on error.
- * @note device argument takes precedence over device_name when both are set.
- */
-int avdevice_list_input_sources(struct AVInputFormat *device, const char *device_name,
-                                AVDictionary *device_options, AVDeviceInfoList **device_list);
-int avdevice_list_output_sinks(struct AVOutputFormat *device, const char *device_name,
-                               AVDictionary *device_options, AVDeviceInfoList **device_list);
-
-#endif /* AVDEVICE_AVDEVICE_H */

Externals/ffmpeg/include/libavdevice/version.h

@@ -1,50 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVDEVICE_VERSION_H
-#define AVDEVICE_VERSION_H
-
-/**
- * @file
- * @ingroup lavd
- * Libavdevice version macros
- */
-
-#include "libavutil/version.h"
-
-#define LIBAVDEVICE_VERSION_MAJOR 56
-#define LIBAVDEVICE_VERSION_MINOR  4
-#define LIBAVDEVICE_VERSION_MICRO 100
-
-#define LIBAVDEVICE_VERSION_INT AV_VERSION_INT(LIBAVDEVICE_VERSION_MAJOR, \
-                                               LIBAVDEVICE_VERSION_MINOR, \
-                                               LIBAVDEVICE_VERSION_MICRO)
-#define LIBAVDEVICE_VERSION     AV_VERSION(LIBAVDEVICE_VERSION_MAJOR, \
-                                           LIBAVDEVICE_VERSION_MINOR, \
-                                           LIBAVDEVICE_VERSION_MICRO)
-#define LIBAVDEVICE_BUILD       LIBAVDEVICE_VERSION_INT
-
-#define LIBAVDEVICE_IDENT       "Lavd" AV_STRINGIFY(LIBAVDEVICE_VERSION)
-
-/**
- * FF_API_* defines may be placed below to indicate public API that will be
- * dropped at a future version bump. The defines themselves are not part of
- * the public API and may change, break or disappear at any time.
- */
-
-#endif /* AVDEVICE_VERSION_H */

Externals/ffmpeg/include/libavformat/avio.h

@@ -1,528 +0,0 @@
-/*
- * copyright (c) 2001 Fabrice Bellard
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-#ifndef AVFORMAT_AVIO_H
-#define AVFORMAT_AVIO_H
-
-/**
- * @file
- * @ingroup lavf_io
- * Buffered I/O operations
- */
-
-#include <stdint.h>
-
-#include "libavutil/common.h"
-#include "libavutil/dict.h"
-#include "libavutil/log.h"
-
-#include "libavformat/version.h"
-
-
-#define AVIO_SEEKABLE_NORMAL 0x0001 /**< Seeking works like for a local file */
-
-/**
- * Callback for checking whether to abort blocking functions.
- * AVERROR_EXIT is returned in this case by the interrupted
- * function. During blocking operations, callback is called with
- * opaque as parameter. If the callback returns 1, the
- * blocking operation will be aborted.
- *
- * No members can be added to this struct without a major bump, if
- * new elements have been added after this struct in AVFormatContext
- * or AVIOContext.
- */
-typedef struct AVIOInterruptCB {
-    int (*callback)(void*);
-    void *opaque;
-} AVIOInterruptCB;
-
-/**
- * Bytestream IO Context.
- * New fields can be added to the end with minor version bumps.
- * Removal, reordering and changes to existing fields require a major
- * version bump.
- * sizeof(AVIOContext) must not be used outside libav*.
- *
- * @note None of the function pointers in AVIOContext should be called
- *       directly, they should only be set by the client application
- *       when implementing custom I/O. Normally these are set to the
- *       function pointers specified in avio_alloc_context()
- */
-typedef struct AVIOContext {
-    /**
-     * A class for private options.
-     *
-     * If this AVIOContext is created by avio_open2(), av_class is set and
-     * passes the options down to protocols.
-     *
-     * If this AVIOContext is manually allocated, then av_class may be set by
-     * the caller.
-     *
-     * warning -- this field can be NULL, be sure to not pass this AVIOContext
-     * to any av_opt_* functions in that case.
-     */
-    const AVClass *av_class;
-    unsigned char *buffer;  /**< Start of the buffer. */
-    int buffer_size;        /**< Maximum buffer size */
-    unsigned char *buf_ptr; /**< Current position in the buffer */
-    unsigned char *buf_end; /**< End of the data, may be less than
-                                 buffer+buffer_size if the read function returned
-                                 less data than requested, e.g. for streams where
-                                 no more data has been received yet. */
-    void *opaque;           /**< A private pointer, passed to the read/write/seek/...
-                                 functions. */
-    int (*read_packet)(void *opaque, uint8_t *buf, int buf_size);
-    int (*write_packet)(void *opaque, uint8_t *buf, int buf_size);
-    int64_t (*seek)(void *opaque, int64_t offset, int whence);
-    int64_t pos;            /**< position in the file of the current buffer */
-    int must_flush;         /**< true if the next seek should flush */
-    int eof_reached;        /**< true if eof reached */
-    int write_flag;         /**< true if open for writing */
-    int max_packet_size;
-    unsigned long checksum;
-    unsigned char *checksum_ptr;
-    unsigned long (*update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size);
-    int error;              /**< contains the error code or 0 if no error happened */
-    /**
-     * Pause or resume playback for network streaming protocols - e.g. MMS.
-     */
-    int (*read_pause)(void *opaque, int pause);
-    /**
-     * Seek to a given timestamp in stream with the specified stream_index.
-     * Needed for some network streaming protocols which don't support seeking
-     * to byte position.
-     */
-    int64_t (*read_seek)(void *opaque, int stream_index,
-                         int64_t timestamp, int flags);
-    /**
-     * A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
-     */
-    int seekable;
-
-    /**
-     * max filesize, used to limit allocations
-     * This field is internal to libavformat and access from outside is not allowed.
-     */
-    int64_t maxsize;
-
-    /**
-     * avio_read and avio_write should if possible be satisfied directly
-     * instead of going through a buffer, and avio_seek will always
-     * call the underlying seek function directly.
-     */
-    int direct;
-
-    /**
-     * Bytes read statistic
-     * This field is internal to libavformat and access from outside is not allowed.
-     */
-    int64_t bytes_read;
-
-    /**
-     * seek statistic
-     * This field is internal to libavformat and access from outside is not allowed.
-     */
-    int seek_count;
-
-    /**
-     * writeout statistic
-     * This field is internal to libavformat and access from outside is not allowed.
-     */
-    int writeout_count;
-
-    /**
-     * Original buffer size
-     * used internally after probing and ensure seekback to reset the buffer size
-     * This field is internal to libavformat and access from outside is not allowed.
-     */
-    int orig_buffer_size;
-} AVIOContext;
-
-/* unbuffered I/O */
-
-/**
- * Return the name of the protocol that will handle the passed URL.
- *
- * NULL is returned if no protocol could be found for the given URL.
- *
- * @return Name of the protocol or NULL.
- */
-const char *avio_find_protocol_name(const char *url);
-
-/**
- * Return AVIO_FLAG_* access flags corresponding to the access permissions
- * of the resource in url, or a negative value corresponding to an
- * AVERROR code in case of failure. The returned access flags are
- * masked by the value in flags.
- *
- * @note This function is intrinsically unsafe, in the sense that the
- * checked resource may change its existence or permission status from
- * one call to another. Thus you should not trust the returned value,
- * unless you are sure that no other processes are accessing the
- * checked resource.
- */
-int avio_check(const char *url, int flags);
-
-/**
- * Allocate and initialize an AVIOContext for buffered I/O. It must be later
- * freed with av_free().
- *
- * @param buffer Memory block for input/output operations via AVIOContext.
- *        The buffer must be allocated with av_malloc() and friends.
- *        It may be freed and replaced with a new buffer by libavformat.
- *        AVIOContext.buffer holds the buffer currently in use,
- *        which must be later freed with av_free().
- * @param buffer_size The buffer size is very important for performance.
- *        For protocols with fixed blocksize it should be set to this blocksize.
- *        For others a typical size is a cache page, e.g. 4kb.
- * @param write_flag Set to 1 if the buffer should be writable, 0 otherwise.
- * @param opaque An opaque pointer to user-specific data.
- * @param read_packet  A function for refilling the buffer, may be NULL.
- * @param write_packet A function for writing the buffer contents, may be NULL.
- *        The function may not change the input buffers content.
- * @param seek A function for seeking to specified byte position, may be NULL.
- *
- * @return Allocated AVIOContext or NULL on failure.
- */
-AVIOContext *avio_alloc_context(
-                  unsigned char *buffer,
-                  int buffer_size,
-                  int write_flag,
-                  void *opaque,
-                  int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
-                  int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
-                  int64_t (*seek)(void *opaque, int64_t offset, int whence));
-
-void avio_w8(AVIOContext *s, int b);
-void avio_write(AVIOContext *s, const unsigned char *buf, int size);
-void avio_wl64(AVIOContext *s, uint64_t val);
-void avio_wb64(AVIOContext *s, uint64_t val);
-void avio_wl32(AVIOContext *s, unsigned int val);
-void avio_wb32(AVIOContext *s, unsigned int val);
-void avio_wl24(AVIOContext *s, unsigned int val);
-void avio_wb24(AVIOContext *s, unsigned int val);
-void avio_wl16(AVIOContext *s, unsigned int val);
-void avio_wb16(AVIOContext *s, unsigned int val);
-
-/**
- * Write a NULL-terminated string.
- * @return number of bytes written.
- */
-int avio_put_str(AVIOContext *s, const char *str);
-
-/**
- * Convert an UTF-8 string to UTF-16LE and write it.
- * @return number of bytes written.
- */
-int avio_put_str16le(AVIOContext *s, const char *str);
-
-/**
- * Passing this as the "whence" parameter to a seek function causes it to
- * return the filesize without seeking anywhere. Supporting this is optional.
- * If it is not supported then the seek function will return <0.
- */
-#define AVSEEK_SIZE 0x10000
-
-/**
- * Oring this flag as into the "whence" parameter to a seek function causes it to
- * seek by any means (like reopening and linear reading) or other normally unreasonable
- * means that can be extremely slow.
- * This may be ignored by the seek code.
- */
-#define AVSEEK_FORCE 0x20000
-
-/**
- * fseek() equivalent for AVIOContext.
- * @return new position or AVERROR.
- */
-int64_t avio_seek(AVIOContext *s, int64_t offset, int whence);
-
-/**
- * Skip given number of bytes forward
- * @return new position or AVERROR.
- */
-int64_t avio_skip(AVIOContext *s, int64_t offset);
-
-/**
- * ftell() equivalent for AVIOContext.
- * @return position or AVERROR.
- */
-static av_always_inline int64_t avio_tell(AVIOContext *s)
-{
-    return avio_seek(s, 0, SEEK_CUR);
-}
-
-/**
- * Get the filesize.
- * @return filesize or AVERROR
- */
-int64_t avio_size(AVIOContext *s);
-
-/**
- * feof() equivalent for AVIOContext.
- * @return non zero if and only if end of file
- */
-int avio_feof(AVIOContext *s);
-#if FF_API_URL_FEOF
-/**
- * @deprecated use avio_feof()
- */
-attribute_deprecated
-int url_feof(AVIOContext *s);
-#endif
-
-/** @warning currently size is limited */
-int avio_printf(AVIOContext *s, const char *fmt, ...) av_printf_format(2, 3);
-
-/**
- * Force flushing of buffered data.
- *
- * For write streams, force the buffered data to be immediately written to the output,
- * without to wait to fill the internal buffer.
- *
- * For read streams, discard all currently buffered data, and advance the
- * reported file position to that of the underlying stream. This does not
- * read new data, and does not perform any seeks.
- */
-void avio_flush(AVIOContext *s);
-
-/**
- * Read size bytes from AVIOContext into buf.
- * @return number of bytes read or AVERROR
- */
-int avio_read(AVIOContext *s, unsigned char *buf, int size);
-
-/**
- * @name Functions for reading from AVIOContext
- * @{
- *
- * @note return 0 if EOF, so you cannot use it if EOF handling is
- *       necessary
- */
-int          avio_r8  (AVIOContext *s);
-unsigned int avio_rl16(AVIOContext *s);
-unsigned int avio_rl24(AVIOContext *s);
-unsigned int avio_rl32(AVIOContext *s);
-uint64_t     avio_rl64(AVIOContext *s);
-unsigned int avio_rb16(AVIOContext *s);
-unsigned int avio_rb24(AVIOContext *s);
-unsigned int avio_rb32(AVIOContext *s);
-uint64_t     avio_rb64(AVIOContext *s);
-/**
- * @}
- */
-
-/**
- * Read a string from pb into buf. The reading will terminate when either
- * a NULL character was encountered, maxlen bytes have been read, or nothing
- * more can be read from pb. The result is guaranteed to be NULL-terminated, it
- * will be truncated if buf is too small.
- * Note that the string is not interpreted or validated in any way, it
- * might get truncated in the middle of a sequence for multi-byte encodings.
- *
- * @return number of bytes read (is always <= maxlen).
- * If reading ends on EOF or error, the return value will be one more than
- * bytes actually read.
- */
-int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen);
-
-/**
- * Read a UTF-16 string from pb and convert it to UTF-8.
- * The reading will terminate when either a null or invalid character was
- * encountered or maxlen bytes have been read.
- * @return number of bytes read (is always <= maxlen)
- */
-int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen);
-int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen);
-
-
-/**
- * @name URL open modes
- * The flags argument to avio_open must be one of the following
- * constants, optionally ORed with other flags.
- * @{
- */
-#define AVIO_FLAG_READ  1                                      /**< read-only */
-#define AVIO_FLAG_WRITE 2                                      /**< write-only */
-#define AVIO_FLAG_READ_WRITE (AVIO_FLAG_READ|AVIO_FLAG_WRITE)  /**< read-write pseudo flag */
-/**
- * @}
- */
-
-/**
- * Use non-blocking mode.
- * If this flag is set, operations on the context will return
- * AVERROR(EAGAIN) if they can not be performed immediately.
- * If this flag is not set, operations on the context will never return
- * AVERROR(EAGAIN).
- * Note that this flag does not affect the opening/connecting of the
- * context. Connecting a protocol will always block if necessary (e.g. on
- * network protocols) but never hang (e.g. on busy devices).
- * Warning: non-blocking protocols is work-in-progress; this flag may be
- * silently ignored.
- */
-#define AVIO_FLAG_NONBLOCK 8
-
-/**
- * Use direct mode.
- * avio_read and avio_write should if possible be satisfied directly
- * instead of going through a buffer, and avio_seek will always
- * call the underlying seek function directly.
- */
-#define AVIO_FLAG_DIRECT 0x8000
-
-/**
- * Create and initialize a AVIOContext for accessing the
- * resource indicated by url.
- * @note When the resource indicated by url has been opened in
- * read+write mode, the AVIOContext can be used only for writing.
- *
- * @param s Used to return the pointer to the created AVIOContext.
- * In case of failure the pointed to value is set to NULL.
- * @param url resource to access
- * @param flags flags which control how the resource indicated by url
- * is to be opened
- * @return >= 0 in case of success, a negative value corresponding to an
- * AVERROR code in case of failure
- */
-int avio_open(AVIOContext **s, const char *url, int flags);
-
-/**
- * Create and initialize a AVIOContext for accessing the
- * resource indicated by url.
- * @note When the resource indicated by url has been opened in
- * read+write mode, the AVIOContext can be used only for writing.
- *
- * @param s Used to return the pointer to the created AVIOContext.
- * In case of failure the pointed to value is set to NULL.
- * @param url resource to access
- * @param flags flags which control how the resource indicated by url
- * is to be opened
- * @param int_cb an interrupt callback to be used at the protocols level
- * @param options  A dictionary filled with protocol-private options. On return
- * this parameter will be destroyed and replaced with a dict containing options
- * that were not found. May be NULL.
- * @return >= 0 in case of success, a negative value corresponding to an
- * AVERROR code in case of failure
- */
-int avio_open2(AVIOContext **s, const char *url, int flags,
-               const AVIOInterruptCB *int_cb, AVDictionary **options);
-
-/**
- * Close the resource accessed by the AVIOContext s and free it.
- * This function can only be used if s was opened by avio_open().
- *
- * The internal buffer is automatically flushed before closing the
- * resource.
- *
- * @return 0 on success, an AVERROR < 0 on error.
- * @see avio_closep
- */
-int avio_close(AVIOContext *s);
-
-/**
- * Close the resource accessed by the AVIOContext *s, free it
- * and set the pointer pointing to it to NULL.
- * This function can only be used if s was opened by avio_open().
- *
- * The internal buffer is automatically flushed before closing the
- * resource.
- *
- * @return 0 on success, an AVERROR < 0 on error.
- * @see avio_close
- */
-int avio_closep(AVIOContext **s);
-
-
-/**
- * Open a write only memory stream.
- *
- * @param s new IO context
- * @return zero if no error.
- */
-int avio_open_dyn_buf(AVIOContext **s);
-
-/**
- * Return the written size and a pointer to the buffer. The buffer
- * must be freed with av_free().
- * Padding of FF_INPUT_BUFFER_PADDING_SIZE is added to the buffer.
- *
- * @param s IO context
- * @param pbuffer pointer to a byte buffer
- * @return the length of the byte buffer
- */
-int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
-
-/**
- * Iterate through names of available protocols.
- *
- * @param opaque A private pointer representing current protocol.
- *        It must be a pointer to NULL on first iteration and will
- *        be updated by successive calls to avio_enum_protocols.
- * @param output If set to 1, iterate over output protocols,
- *               otherwise over input protocols.
- *
- * @return A static string containing the name of current protocol or NULL
- */
-const char *avio_enum_protocols(void **opaque, int output);
-
-/**
- * Pause and resume playing - only meaningful if using a network streaming
- * protocol (e.g. MMS).
- *
- * @param h     IO context from which to call the read_pause function pointer
- * @param pause 1 for pause, 0 for resume
- */
-int     avio_pause(AVIOContext *h, int pause);
-
-/**
- * Seek to a given timestamp relative to some component stream.
- * Only meaningful if using a network streaming protocol (e.g. MMS.).
- *
- * @param h IO context from which to call the seek function pointers
- * @param stream_index The stream index that the timestamp is relative to.
- *        If stream_index is (-1) the timestamp should be in AV_TIME_BASE
- *        units from the beginning of the presentation.
- *        If a stream_index >= 0 is used and the protocol does not support
- *        seeking based on component streams, the call will fail.
- * @param timestamp timestamp in AVStream.time_base units
- *        or if there is no stream specified then in AV_TIME_BASE units.
- * @param flags Optional combination of AVSEEK_FLAG_BACKWARD, AVSEEK_FLAG_BYTE
- *        and AVSEEK_FLAG_ANY. The protocol may silently ignore
- *        AVSEEK_FLAG_BACKWARD and AVSEEK_FLAG_ANY, but AVSEEK_FLAG_BYTE will
- *        fail if used and not supported.
- * @return >= 0 on success
- * @see AVInputFormat::read_seek
- */
-int64_t avio_seek_time(AVIOContext *h, int stream_index,
-                       int64_t timestamp, int flags);
-
-/* Avoid a warning. The header can not be included because it breaks c++. */
-struct AVBPrint;
-
-/**
- * Read contents of h into print buffer, up to max_size bytes, or up to EOF.
- *
- * @return 0 for success (max_size bytes read or EOF reached), negative error
- * code otherwise
- */
-int avio_read_to_bprint(AVIOContext *h, struct AVBPrint *pb, size_t max_size);
-
-#endif /* AVFORMAT_AVIO_H */

Externals/ffmpeg/include/libavformat/version.h

@@ -1,67 +0,0 @@
-/*
- * Version macros.
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVFORMAT_VERSION_H
-#define AVFORMAT_VERSION_H
-
-/**
- * @file
- * @ingroup libavf
- * Libavformat version macros
- */
-
-#include "libavutil/version.h"
-
-#define LIBAVFORMAT_VERSION_MAJOR 56
-#define LIBAVFORMAT_VERSION_MINOR  19
-#define LIBAVFORMAT_VERSION_MICRO 100
-
-#define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
-                                               LIBAVFORMAT_VERSION_MINOR, \
-                                               LIBAVFORMAT_VERSION_MICRO)
-#define LIBAVFORMAT_VERSION     AV_VERSION(LIBAVFORMAT_VERSION_MAJOR,   \
-                                           LIBAVFORMAT_VERSION_MINOR,   \
-                                           LIBAVFORMAT_VERSION_MICRO)
-#define LIBAVFORMAT_BUILD       LIBAVFORMAT_VERSION_INT
-
-#define LIBAVFORMAT_IDENT       "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION)
-
-/**
- * FF_API_* defines may be placed below to indicate public API that will be
- * dropped at a future version bump. The defines themselves are not part of
- * the public API and may change, break or disappear at any time.
- */
-#ifndef FF_API_LAVF_BITEXACT
-#define FF_API_LAVF_BITEXACT            (LIBAVFORMAT_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_LAVF_FRAC
-#define FF_API_LAVF_FRAC                (LIBAVFORMAT_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_LAVF_CODEC_TB
-#define FF_API_LAVF_CODEC_TB            (LIBAVFORMAT_VERSION_MAJOR < 57)
-#endif
-#ifndef FF_API_URL_FEOF
-#define FF_API_URL_FEOF                 (LIBAVFORMAT_VERSION_MAJOR < 57)
-#endif
-
-#ifndef FF_API_R_FRAME_RATE
-#define FF_API_R_FRAME_RATE            1
-#endif
-#endif /* AVFORMAT_VERSION_H */

Externals/ffmpeg/include/libavutil/adler32.h

@@ -1,55 +0,0 @@
-/*
- * copyright (c) 2006 Mans Rullgard
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_ADLER32_H
-#define AVUTIL_ADLER32_H
-
-#include <stdint.h>
-#include "attributes.h"
-
-/**
- * @file
- * Public header for libavutil Adler32 hasher
- *
- * @defgroup lavu_adler32 Adler32
- * @ingroup lavu_crypto
- * @{
- */
-
-/**
- * Calculate the Adler32 checksum of a buffer.
- *
- * Passing the return value to a subsequent av_adler32_update() call
- * allows the checksum of multiple buffers to be calculated as though
- * they were concatenated.
- *
- * @param adler initial checksum value
- * @param buf   pointer to input buffer
- * @param len   size of input buffer
- * @return      updated checksum
- */
-unsigned long av_adler32_update(unsigned long adler, const uint8_t *buf,
-                                unsigned int len) av_pure;
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_ADLER32_H */

Externals/ffmpeg/include/libavutil/aes.h

@@ -1,65 +0,0 @@
-/*
- * copyright (c) 2007 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_AES_H
-#define AVUTIL_AES_H
-
-#include <stdint.h>
-
-#include "attributes.h"
-#include "version.h"
-
-/**
- * @defgroup lavu_aes AES
- * @ingroup lavu_crypto
- * @{
- */
-
-extern const int av_aes_size;
-
-struct AVAES;
-
-/**
- * Allocate an AVAES context.
- */
-struct AVAES *av_aes_alloc(void);
-
-/**
- * Initialize an AVAES context.
- * @param key_bits 128, 192 or 256
- * @param decrypt 0 for encryption, 1 for decryption
- */
-int av_aes_init(struct AVAES *a, const uint8_t *key, int key_bits, int decrypt);
-
-/**
- * Encrypt or decrypt a buffer using a previously initialized context.
- * @param count number of 16 byte blocks
- * @param dst destination array, can be equal to src
- * @param src source array, can be equal to dst
- * @param iv initialization vector for CBC mode, if NULL then ECB will be used
- * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_aes_crypt(struct AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_AES_H */

Externals/ffmpeg/include/libavutil/attributes.h

@@ -1,160 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * Macro definitions for various function/variable attributes
- */
-
-#ifndef AVUTIL_ATTRIBUTES_H
-#define AVUTIL_ATTRIBUTES_H
-
-#ifdef __GNUC__
-#    define AV_GCC_VERSION_AT_LEAST(x,y) (__GNUC__ > x || __GNUC__ == x && __GNUC_MINOR__ >= y)
-#else
-#    define AV_GCC_VERSION_AT_LEAST(x,y) 0
-#endif
-
-#ifndef av_always_inline
-#if AV_GCC_VERSION_AT_LEAST(3,1)
-#    define av_always_inline __attribute__((always_inline)) inline
-#elif defined(_MSC_VER)
-#    define av_always_inline __forceinline
-#else
-#    define av_always_inline inline
-#endif
-#endif
-
-#ifndef av_extern_inline
-#if defined(__ICL) && __ICL >= 1210 || defined(__GNUC_STDC_INLINE__)
-#    define av_extern_inline extern inline
-#else
-#    define av_extern_inline inline
-#endif
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(3,1)
-#    define av_noinline __attribute__((noinline))
-#elif defined(_MSC_VER)
-#    define av_noinline __declspec(noinline)
-#else
-#    define av_noinline
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(3,1)
-#    define av_pure __attribute__((pure))
-#else
-#    define av_pure
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(2,6)
-#    define av_const __attribute__((const))
-#else
-#    define av_const
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(4,3)
-#    define av_cold __attribute__((cold))
-#else
-#    define av_cold
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(4,1) && !defined(__llvm__)
-#    define av_flatten __attribute__((flatten))
-#else
-#    define av_flatten
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(3,1)
-#    define attribute_deprecated __attribute__((deprecated))
-#elif defined(_MSC_VER)
-#    define attribute_deprecated __declspec(deprecated)
-#else
-#    define attribute_deprecated
-#endif
-
-/**
- * Disable warnings about deprecated features
- * This is useful for sections of code kept for backward compatibility and
- * scheduled for removal.
- */
-#ifndef AV_NOWARN_DEPRECATED
-#if AV_GCC_VERSION_AT_LEAST(4,6)
-#    define AV_NOWARN_DEPRECATED(code) \
-        _Pragma("GCC diagnostic push") \
-        _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") \
-        code \
-        _Pragma("GCC diagnostic pop")
-#elif defined(_MSC_VER)
-#    define AV_NOWARN_DEPRECATED(code) \
-        __pragma(warning(push)) \
-        __pragma(warning(disable : 4996)) \
-        code; \
-        __pragma(warning(pop))
-#else
-#    define AV_NOWARN_DEPRECATED(code) code
-#endif
-#endif
-
-
-#if defined(__GNUC__)
-#    define av_unused __attribute__((unused))
-#else
-#    define av_unused
-#endif
-
-/**
- * Mark a variable as used and prevent the compiler from optimizing it
- * away.  This is useful for variables accessed only from inline
- * assembler without the compiler being aware.
- */
-#if AV_GCC_VERSION_AT_LEAST(3,1)
-#    define av_used __attribute__((used))
-#else
-#    define av_used
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(3,3)
-#   define av_alias __attribute__((may_alias))
-#else
-#   define av_alias
-#endif
-
-#if defined(__GNUC__) && !defined(__INTEL_COMPILER) && !defined(__clang__)
-#    define av_uninit(x) x=x
-#else
-#    define av_uninit(x) x
-#endif
-
-#ifdef __GNUC__
-#    define av_builtin_constant_p __builtin_constant_p
-#    define av_printf_format(fmtpos, attrpos) __attribute__((__format__(__printf__, fmtpos, attrpos)))
-#else
-#    define av_builtin_constant_p(x) 0
-#    define av_printf_format(fmtpos, attrpos)
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(2,5)
-#    define av_noreturn __attribute__((noreturn))
-#else
-#    define av_noreturn
-#endif
-
-#endif /* AVUTIL_ATTRIBUTES_H */

Externals/ffmpeg/include/libavutil/audio_fifo.h

@@ -1,153 +0,0 @@
-/*
- * Audio FIFO
- * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * Audio FIFO Buffer
- */
-
-#ifndef AVUTIL_AUDIO_FIFO_H
-#define AVUTIL_AUDIO_FIFO_H
-
-#include "avutil.h"
-#include "fifo.h"
-#include "samplefmt.h"
-
-/**
- * @addtogroup lavu_audio
- * @{
- *
- * @defgroup lavu_audiofifo Audio FIFO Buffer
- * @{
- */
-
-/**
- * Context for an Audio FIFO Buffer.
- *
- * - Operates at the sample level rather than the byte level.
- * - Supports multiple channels with either planar or packed sample format.
- * - Automatic reallocation when writing to a full buffer.
- */
-typedef struct AVAudioFifo AVAudioFifo;
-
-/**
- * Free an AVAudioFifo.
- *
- * @param af  AVAudioFifo to free
- */
-void av_audio_fifo_free(AVAudioFifo *af);
-
-/**
- * Allocate an AVAudioFifo.
- *
- * @param sample_fmt  sample format
- * @param channels    number of channels
- * @param nb_samples  initial allocation size, in samples
- * @return            newly allocated AVAudioFifo, or NULL on error
- */
-AVAudioFifo *av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels,
-                                 int nb_samples);
-
-/**
- * Reallocate an AVAudioFifo.
- *
- * @param af          AVAudioFifo to reallocate
- * @param nb_samples  new allocation size, in samples
- * @return            0 if OK, or negative AVERROR code on failure
- */
-int av_audio_fifo_realloc(AVAudioFifo *af, int nb_samples);
-
-/**
- * Write data to an AVAudioFifo.
- *
- * The AVAudioFifo will be reallocated automatically if the available space
- * is less than nb_samples.
- *
- * @see enum AVSampleFormat
- * The documentation for AVSampleFormat describes the data layout.
- *
- * @param af          AVAudioFifo to write to
- * @param data        audio data plane pointers
- * @param nb_samples  number of samples to write
- * @return            number of samples actually written, or negative AVERROR
- *                    code on failure. If successful, the number of samples
- *                    actually written will always be nb_samples.
- */
-int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples);
-
-/**
- * Read data from an AVAudioFifo.
- *
- * @see enum AVSampleFormat
- * The documentation for AVSampleFormat describes the data layout.
- *
- * @param af          AVAudioFifo to read from
- * @param data        audio data plane pointers
- * @param nb_samples  number of samples to read
- * @return            number of samples actually read, or negative AVERROR code
- *                    on failure. The number of samples actually read will not
- *                    be greater than nb_samples, and will only be less than
- *                    nb_samples if av_audio_fifo_size is less than nb_samples.
- */
-int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples);
-
-/**
- * Drain data from an AVAudioFifo.
- *
- * Removes the data without reading it.
- *
- * @param af          AVAudioFifo to drain
- * @param nb_samples  number of samples to drain
- * @return            0 if OK, or negative AVERROR code on failure
- */
-int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples);
-
-/**
- * Reset the AVAudioFifo buffer.
- *
- * This empties all data in the buffer.
- *
- * @param af  AVAudioFifo to reset
- */
-void av_audio_fifo_reset(AVAudioFifo *af);
-
-/**
- * Get the current number of samples in the AVAudioFifo available for reading.
- *
- * @param af  the AVAudioFifo to query
- * @return    number of samples available for reading
- */
-int av_audio_fifo_size(AVAudioFifo *af);
-
-/**
- * Get the current number of samples in the AVAudioFifo available for writing.
- *
- * @param af  the AVAudioFifo to query
- * @return    number of samples available for writing
- */
-int av_audio_fifo_space(AVAudioFifo *af);
-
-/**
- * @}
- * @}
- */
-
-#endif /* AVUTIL_AUDIO_FIFO_H */

Externals/ffmpeg/include/libavutil/audioconvert.h

@@ -1,6 +0,0 @@
-
-#include "version.h"
-
-#if FF_API_AUDIOCONVERT
-#include "channel_layout.h"
-#endif

Externals/ffmpeg/include/libavutil/avassert.h

@@ -1,66 +0,0 @@
-/*
- * copyright (c) 2010 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * simple assert() macros that are a bit more flexible than ISO C assert().
- * @author Michael Niedermayer <michaelni@gmx.at>
- */
-
-#ifndef AVUTIL_AVASSERT_H
-#define AVUTIL_AVASSERT_H
-
-#include <stdlib.h>
-#include "avutil.h"
-#include "log.h"
-
-/**
- * assert() equivalent, that is always enabled.
- */
-#define av_assert0(cond) do {                                           \
-    if (!(cond)) {                                                      \
-        av_log(NULL, AV_LOG_PANIC, "Assertion %s failed at %s:%d\n",    \
-               AV_STRINGIFY(cond), __FILE__, __LINE__);                 \
-        abort();                                                        \
-    }                                                                   \
-} while (0)
-
-
-/**
- * assert() equivalent, that does not lie in speed critical code.
- * These asserts() thus can be enabled without fearing speedloss.
- */
-#if defined(ASSERT_LEVEL) && ASSERT_LEVEL > 0
-#define av_assert1(cond) av_assert0(cond)
-#else
-#define av_assert1(cond) ((void)0)
-#endif
-
-
-/**
- * assert() equivalent, that does lie in speed critical code.
- */
-#if defined(ASSERT_LEVEL) && ASSERT_LEVEL > 1
-#define av_assert2(cond) av_assert0(cond)
-#else
-#define av_assert2(cond) ((void)0)
-#endif
-
-#endif /* AVUTIL_AVASSERT_H */

Externals/ffmpeg/include/libavutil/avconfig.h

@@ -1,7 +0,0 @@
-/* Generated by ffconf */
-#ifndef AVUTIL_AVCONFIG_H
-#define AVUTIL_AVCONFIG_H
-#define AV_HAVE_BIGENDIAN 0
-#define AV_HAVE_FAST_UNALIGNED 1
-#define AV_HAVE_INCOMPATIBLE_LIBAV_ABI 0
-#endif /* AVUTIL_AVCONFIG_H */

Externals/ffmpeg/include/libavutil/avstring.h

@@ -1,371 +0,0 @@
-/*
- * Copyright (c) 2007 Mans Rullgard
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_AVSTRING_H
-#define AVUTIL_AVSTRING_H
-
-#include <stddef.h>
-#include <stdint.h>
-#include "attributes.h"
-
-/**
- * @addtogroup lavu_string
- * @{
- */
-
-/**
- * Return non-zero if pfx is a prefix of str. If it is, *ptr is set to
- * the address of the first character in str after the prefix.
- *
- * @param str input string
- * @param pfx prefix to test
- * @param ptr updated if the prefix is matched inside str
- * @return non-zero if the prefix matches, zero otherwise
- */
-int av_strstart(const char *str, const char *pfx, const char **ptr);
-
-/**
- * Return non-zero if pfx is a prefix of str independent of case. If
- * it is, *ptr is set to the address of the first character in str
- * after the prefix.
- *
- * @param str input string
- * @param pfx prefix to test
- * @param ptr updated if the prefix is matched inside str
- * @return non-zero if the prefix matches, zero otherwise
- */
-int av_stristart(const char *str, const char *pfx, const char **ptr);
-
-/**
- * Locate the first case-independent occurrence in the string haystack
- * of the string needle.  A zero-length string needle is considered to
- * match at the start of haystack.
- *
- * This function is a case-insensitive version of the standard strstr().
- *
- * @param haystack string to search in
- * @param needle   string to search for
- * @return         pointer to the located match within haystack
- *                 or a null pointer if no match
- */
-char *av_stristr(const char *haystack, const char *needle);
-
-/**
- * Locate the first occurrence of the string needle in the string haystack
- * where not more than hay_length characters are searched. A zero-length
- * string needle is considered to match at the start of haystack.
- *
- * This function is a length-limited version of the standard strstr().
- *
- * @param haystack   string to search in
- * @param needle     string to search for
- * @param hay_length length of string to search in
- * @return           pointer to the located match within haystack
- *                   or a null pointer if no match
- */
-char *av_strnstr(const char *haystack, const char *needle, size_t hay_length);
-
-/**
- * Copy the string src to dst, but no more than size - 1 bytes, and
- * null-terminate dst.
- *
- * This function is the same as BSD strlcpy().
- *
- * @param dst destination buffer
- * @param src source string
- * @param size size of destination buffer
- * @return the length of src
- *
- * @warning since the return value is the length of src, src absolutely
- * _must_ be a properly 0-terminated string, otherwise this will read beyond
- * the end of the buffer and possibly crash.
- */
-size_t av_strlcpy(char *dst, const char *src, size_t size);
-
-/**
- * Append the string src to the string dst, but to a total length of
- * no more than size - 1 bytes, and null-terminate dst.
- *
- * This function is similar to BSD strlcat(), but differs when
- * size <= strlen(dst).
- *
- * @param dst destination buffer
- * @param src source string
- * @param size size of destination buffer
- * @return the total length of src and dst
- *
- * @warning since the return value use the length of src and dst, these
- * absolutely _must_ be a properly 0-terminated strings, otherwise this
- * will read beyond the end of the buffer and possibly crash.
- */
-size_t av_strlcat(char *dst, const char *src, size_t size);
-
-/**
- * Append output to a string, according to a format. Never write out of
- * the destination buffer, and always put a terminating 0 within
- * the buffer.
- * @param dst destination buffer (string to which the output is
- *  appended)
- * @param size total size of the destination buffer
- * @param fmt printf-compatible format string, specifying how the
- *  following parameters are used
- * @return the length of the string that would have been generated
- *  if enough space had been available
- */
-size_t av_strlcatf(char *dst, size_t size, const char *fmt, ...) av_printf_format(3, 4);
-
-/**
- * Get the count of continuous non zero chars starting from the beginning.
- *
- * @param len maximum number of characters to check in the string, that
- *            is the maximum value which is returned by the function
- */
-static inline size_t av_strnlen(const char *s, size_t len)
-{
-    size_t i;
-    for (i = 0; i < len && s[i]; i++)
-        ;
-    return i;
-}
-
-/**
- * Print arguments following specified format into a large enough auto
- * allocated buffer. It is similar to GNU asprintf().
- * @param fmt printf-compatible format string, specifying how the
- *            following parameters are used.
- * @return the allocated string
- * @note You have to free the string yourself with av_free().
- */
-char *av_asprintf(const char *fmt, ...) av_printf_format(1, 2);
-
-/**
- * Convert a number to a av_malloced string.
- */
-char *av_d2str(double d);
-
-/**
- * Unescape the given string until a non escaped terminating char,
- * and return the token corresponding to the unescaped string.
- *
- * The normal \ and ' escaping is supported. Leading and trailing
- * whitespaces are removed, unless they are escaped with '\' or are
- * enclosed between ''.
- *
- * @param buf the buffer to parse, buf will be updated to point to the
- * terminating char
- * @param term a 0-terminated list of terminating chars
- * @return the malloced unescaped string, which must be av_freed by
- * the user, NULL in case of allocation failure
- */
-char *av_get_token(const char **buf, const char *term);
-
-/**
- * Split the string into several tokens which can be accessed by
- * successive calls to av_strtok().
- *
- * A token is defined as a sequence of characters not belonging to the
- * set specified in delim.
- *
- * On the first call to av_strtok(), s should point to the string to
- * parse, and the value of saveptr is ignored. In subsequent calls, s
- * should be NULL, and saveptr should be unchanged since the previous
- * call.
- *
- * This function is similar to strtok_r() defined in POSIX.1.
- *
- * @param s the string to parse, may be NULL
- * @param delim 0-terminated list of token delimiters, must be non-NULL
- * @param saveptr user-provided pointer which points to stored
- * information necessary for av_strtok() to continue scanning the same
- * string. saveptr is updated to point to the next character after the
- * first delimiter found, or to NULL if the string was terminated
- * @return the found token, or NULL when no token is found
- */
-char *av_strtok(char *s, const char *delim, char **saveptr);
-
-/**
- * Locale-independent conversion of ASCII isdigit.
- */
-av_const int av_isdigit(int c);
-
-/**
- * Locale-independent conversion of ASCII isgraph.
- */
-av_const int av_isgraph(int c);
-
-/**
- * Locale-independent conversion of ASCII isspace.
- */
-av_const int av_isspace(int c);
-
-/**
- * Locale-independent conversion of ASCII characters to uppercase.
- */
-static inline av_const int av_toupper(int c)
-{
-    if (c >= 'a' && c <= 'z')
-        c ^= 0x20;
-    return c;
-}
-
-/**
- * Locale-independent conversion of ASCII characters to lowercase.
- */
-static inline av_const int av_tolower(int c)
-{
-    if (c >= 'A' && c <= 'Z')
-        c ^= 0x20;
-    return c;
-}
-
-/**
- * Locale-independent conversion of ASCII isxdigit.
- */
-av_const int av_isxdigit(int c);
-
-/**
- * Locale-independent case-insensitive compare.
- * @note This means only ASCII-range characters are case-insensitive
- */
-int av_strcasecmp(const char *a, const char *b);
-
-/**
- * Locale-independent case-insensitive compare.
- * @note This means only ASCII-range characters are case-insensitive
- */
-int av_strncasecmp(const char *a, const char *b, size_t n);
-
-
-/**
- * Thread safe basename.
- * @param path the path, on DOS both \ and / are considered separators.
- * @return pointer to the basename substring.
- */
-const char *av_basename(const char *path);
-
-/**
- * Thread safe dirname.
- * @param path the path, on DOS both \ and / are considered separators.
- * @return the path with the separator replaced by the string terminator or ".".
- * @note the function may change the input string.
- */
-const char *av_dirname(char *path);
-
-/**
- * Match instances of a name in a comma-separated list of names.
- * @param name  Name to look for.
- * @param names List of names.
- * @return 1 on match, 0 otherwise.
- */
-int av_match_name(const char *name, const char *names);
-
-enum AVEscapeMode {
-    AV_ESCAPE_MODE_AUTO,      ///< Use auto-selected escaping mode.
-    AV_ESCAPE_MODE_BACKSLASH, ///< Use backslash escaping.
-    AV_ESCAPE_MODE_QUOTE,     ///< Use single-quote escaping.
-};
-
-/**
- * Consider spaces special and escape them even in the middle of the
- * string.
- *
- * This is equivalent to adding the whitespace characters to the special
- * characters lists, except it is guaranteed to use the exact same list
- * of whitespace characters as the rest of libavutil.
- */
-#define AV_ESCAPE_FLAG_WHITESPACE 0x01
-
-/**
- * Escape only specified special characters.
- * Without this flag, escape also any characters that may be considered
- * special by av_get_token(), such as the single quote.
- */
-#define AV_ESCAPE_FLAG_STRICT 0x02
-
-/**
- * Escape string in src, and put the escaped string in an allocated
- * string in *dst, which must be freed with av_free().
- *
- * @param dst           pointer where an allocated string is put
- * @param src           string to escape, must be non-NULL
- * @param special_chars string containing the special characters which
- *                      need to be escaped, can be NULL
- * @param mode          escape mode to employ, see AV_ESCAPE_MODE_* macros.
- *                      Any unknown value for mode will be considered equivalent to
- *                      AV_ESCAPE_MODE_BACKSLASH, but this behaviour can change without
- *                      notice.
- * @param flags         flags which control how to escape, see AV_ESCAPE_FLAG_ macros
- * @return the length of the allocated string, or a negative error code in case of error
- * @see av_bprint_escape()
- */
-int av_escape(char **dst, const char *src, const char *special_chars,
-              enum AVEscapeMode mode, int flags);
-
-#define AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES          1 ///< accept codepoints over 0x10FFFF
-#define AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS             2 ///< accept non-characters - 0xFFFE and 0xFFFF
-#define AV_UTF8_FLAG_ACCEPT_SURROGATES                 4 ///< accept UTF-16 surrogates codes
-#define AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES 8 ///< exclude control codes not accepted by XML
-
-#define AV_UTF8_FLAG_ACCEPT_ALL \
-    AV_UTF8_FLAG_ACCEPT_INVALID_BIG_CODES|AV_UTF8_FLAG_ACCEPT_NON_CHARACTERS|AV_UTF8_FLAG_ACCEPT_SURROGATES
-
-/**
- * Read and decode a single UTF-8 code point (character) from the
- * buffer in *buf, and update *buf to point to the next byte to
- * decode.
- *
- * In case of an invalid byte sequence, the pointer will be updated to
- * the next byte after the invalid sequence and the function will
- * return an error code.
- *
- * Depending on the specified flags, the function will also fail in
- * case the decoded code point does not belong to a valid range.
- *
- * @note For speed-relevant code a carefully implemented use of
- * GET_UTF8() may be preferred.
- *
- * @param codep   pointer used to return the parsed code in case of success.
- *                The value in *codep is set even in case the range check fails.
- * @param bufp    pointer to the address the first byte of the sequence
- *                to decode, updated by the function to point to the
- *                byte next after the decoded sequence
- * @param buf_end pointer to the end of the buffer, points to the next
- *                byte past the last in the buffer. This is used to
- *                avoid buffer overreads (in case of an unfinished
- *                UTF-8 sequence towards the end of the buffer).
- * @param flags   a collection of AV_UTF8_FLAG_* flags
- * @return >= 0 in case a sequence was successfully read, a negative
- * value in case of invalid sequence
- */
-int av_utf8_decode(int32_t *codep, const uint8_t **bufp, const uint8_t *buf_end,
-                   unsigned int flags);
-
-/**
- * Check if a name is in a list.
- * @returns 0 if not found, or the 1 based index where it has been found in the
- *            list.
- */
-int av_match_list(const char *name, const char *list, char separator);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_AVSTRING_H */

Externals/ffmpeg/include/libavutil/avutil.h

@@ -1,344 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_AVUTIL_H
-#define AVUTIL_AVUTIL_H
-
-/**
- * @file
- * external API header
- */
-
-/**
- * @mainpage
- *
- * @section ffmpeg_intro Introduction
- *
- * This document describes the usage of the different libraries
- * provided by FFmpeg.
- *
- * @li @ref libavc "libavcodec" encoding/decoding library
- * @li @ref lavfi "libavfilter" graph-based frame editing library
- * @li @ref libavf "libavformat" I/O and muxing/demuxing library
- * @li @ref lavd "libavdevice" special devices muxing/demuxing library
- * @li @ref lavu "libavutil" common utility library
- * @li @ref lswr "libswresample" audio resampling, format conversion and mixing
- * @li @ref lpp  "libpostproc" post processing library
- * @li @ref libsws "libswscale" color conversion and scaling library
- *
- * @section ffmpeg_versioning Versioning and compatibility
- *
- * Each of the FFmpeg libraries contains a version.h header, which defines a
- * major, minor and micro version number with the
- * <em>LIBRARYNAME_VERSION_{MAJOR,MINOR,MICRO}</em> macros. The major version
- * number is incremented with backward incompatible changes - e.g. removing
- * parts of the public API, reordering public struct members, etc. The minor
- * version number is incremented for backward compatible API changes or major
- * new features - e.g. adding a new public function or a new decoder. The micro
- * version number is incremented for smaller changes that a calling program
- * might still want to check for - e.g. changing behavior in a previously
- * unspecified situation.
- *
- * FFmpeg guarantees backward API and ABI compatibility for each library as long
- * as its major version number is unchanged. This means that no public symbols
- * will be removed or renamed. Types and names of the public struct members and
- * values of public macros and enums will remain the same (unless they were
- * explicitly declared as not part of the public API). Documented behavior will
- * not change.
- *
- * In other words, any correct program that works with a given FFmpeg snapshot
- * should work just as well without any changes with any later snapshot with the
- * same major versions. This applies to both rebuilding the program against new
- * FFmpeg versions or to replacing the dynamic FFmpeg libraries that a program
- * links against.
- *
- * However, new public symbols may be added and new members may be appended to
- * public structs whose size is not part of public ABI (most public structs in
- * FFmpeg). New macros and enum values may be added. Behavior in undocumented
- * situations may change slightly (and be documented). All those are accompanied
- * by an entry in doc/APIchanges and incrementing either the minor or micro
- * version number.
- */
-
-/**
- * @defgroup lavu Common utility functions
- *
- * @brief
- * libavutil contains the code shared across all the other FFmpeg
- * libraries
- *
- * @note In order to use the functions provided by avutil you must include
- * the specific header.
- *
- * @{
- *
- * @defgroup lavu_crypto Crypto and Hashing
- *
- * @{
- * @}
- *
- * @defgroup lavu_math Maths
- * @{
- *
- * @}
- *
- * @defgroup lavu_string String Manipulation
- *
- * @{
- *
- * @}
- *
- * @defgroup lavu_mem Memory Management
- *
- * @{
- *
- * @}
- *
- * @defgroup lavu_data Data Structures
- * @{
- *
- * @}
- *
- * @defgroup lavu_audio Audio related
- *
- * @{
- *
- * @}
- *
- * @defgroup lavu_error Error Codes
- *
- * @{
- *
- * @}
- *
- * @defgroup lavu_log Logging Facility
- *
- * @{
- *
- * @}
- *
- * @defgroup lavu_misc Other
- *
- * @{
- *
- * @defgroup lavu_internal Internal
- *
- * Not exported functions, for internal usage only
- *
- * @{
- *
- * @}
- *
- * @defgroup preproc_misc Preprocessor String Macros
- *
- * @{
- *
- * @}
- *
- * @defgroup version_utils Library Version Macros
- *
- * @{
- *
- * @}
- */
-
-
-/**
- * @addtogroup lavu_ver
- * @{
- */
-
-/**
- * Return the LIBAVUTIL_VERSION_INT constant.
- */
-unsigned avutil_version(void);
-
-/**
- * Return the libavutil build-time configuration.
- */
-const char *avutil_configuration(void);
-
-/**
- * Return the libavutil license.
- */
-const char *avutil_license(void);
-
-/**
- * @}
- */
-
-/**
- * @addtogroup lavu_media Media Type
- * @brief Media Type
- */
-
-enum AVMediaType {
-    AVMEDIA_TYPE_UNKNOWN = -1,  ///< Usually treated as AVMEDIA_TYPE_DATA
-    AVMEDIA_TYPE_VIDEO,
-    AVMEDIA_TYPE_AUDIO,
-    AVMEDIA_TYPE_DATA,          ///< Opaque data information usually continuous
-    AVMEDIA_TYPE_SUBTITLE,
-    AVMEDIA_TYPE_ATTACHMENT,    ///< Opaque data information usually sparse
-    AVMEDIA_TYPE_NB
-};
-
-/**
- * Return a string describing the media_type enum, NULL if media_type
- * is unknown.
- */
-const char *av_get_media_type_string(enum AVMediaType media_type);
-
-/**
- * @defgroup lavu_const Constants
- * @{
- *
- * @defgroup lavu_enc Encoding specific
- *
- * @note those definition should move to avcodec
- * @{
- */
-
-#define FF_LAMBDA_SHIFT 7
-#define FF_LAMBDA_SCALE (1<<FF_LAMBDA_SHIFT)
-#define FF_QP2LAMBDA 118 ///< factor to convert from H.263 QP to lambda
-#define FF_LAMBDA_MAX (256*128-1)
-
-#define FF_QUALITY_SCALE FF_LAMBDA_SCALE //FIXME maybe remove
-
-/**
- * @}
- * @defgroup lavu_time Timestamp specific
- *
- * FFmpeg internal timebase and timestamp definitions
- *
- * @{
- */
-
-/**
- * @brief Undefined timestamp value
- *
- * Usually reported by demuxer that work on containers that do not provide
- * either pts or dts.
- */
-
-#define AV_NOPTS_VALUE          ((int64_t)UINT64_C(0x8000000000000000))
-
-/**
- * Internal time base represented as integer
- */
-
-#define AV_TIME_BASE            1000000
-
-/**
- * Internal time base represented as fractional value
- */
-
-#define AV_TIME_BASE_Q          (AVRational){1, AV_TIME_BASE}
-
-/**
- * @}
- * @}
- * @defgroup lavu_picture Image related
- *
- * AVPicture types, pixel formats and basic image planes manipulation.
- *
- * @{
- */
-
-enum AVPictureType {
-    AV_PICTURE_TYPE_NONE = 0, ///< Undefined
-    AV_PICTURE_TYPE_I,     ///< Intra
-    AV_PICTURE_TYPE_P,     ///< Predicted
-    AV_PICTURE_TYPE_B,     ///< Bi-dir predicted
-    AV_PICTURE_TYPE_S,     ///< S(GMC)-VOP MPEG4
-    AV_PICTURE_TYPE_SI,    ///< Switching Intra
-    AV_PICTURE_TYPE_SP,    ///< Switching Predicted
-    AV_PICTURE_TYPE_BI,    ///< BI type
-};
-
-/**
- * Return a single letter to describe the given picture type
- * pict_type.
- *
- * @param[in] pict_type the picture type @return a single character
- * representing the picture type, '?' if pict_type is unknown
- */
-char av_get_picture_type_char(enum AVPictureType pict_type);
-
-/**
- * @}
- */
-
-#include "common.h"
-#include "error.h"
-#include "rational.h"
-#include "version.h"
-#include "macros.h"
-#include "mathematics.h"
-#include "log.h"
-#include "pixfmt.h"
-
-/**
- * Return x default pointer in case p is NULL.
- */
-static inline void *av_x_if_null(const void *p, const void *x)
-{
-    return (void *)(intptr_t)(p ? p : x);
-}
-
-/**
- * Compute the length of an integer list.
- *
- * @param elsize  size in bytes of each list element (only 1, 2, 4 or 8)
- * @param term    list terminator (usually 0 or -1)
- * @param list    pointer to the list
- * @return  length of the list, in elements, not counting the terminator
- */
-unsigned av_int_list_length_for_size(unsigned elsize,
-                                     const void *list, uint64_t term) av_pure;
-
-/**
- * Compute the length of an integer list.
- *
- * @param term  list terminator (usually 0 or -1)
- * @param list  pointer to the list
- * @return  length of the list, in elements, not counting the terminator
- */
-#define av_int_list_length(list, term) \
-    av_int_list_length_for_size(sizeof(*(list)), list, term)
-
-/**
- * Open a file using a UTF-8 filename.
- * The API of this function matches POSIX fopen(), errors are returned through
- * errno.
- */
-FILE *av_fopen_utf8(const char *path, const char *mode);
-
-/**
- * Return the fractional representation of the internal time base.
- */
-AVRational av_get_time_base_q(void);
-
-/**
- * @}
- * @}
- */
-
-#endif /* AVUTIL_AVUTIL_H */

Externals/ffmpeg/include/libavutil/base64.h

@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2006 Ryan Martell. (rdm4@martellventures.com)
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_BASE64_H
-#define AVUTIL_BASE64_H
-
-#include <stdint.h>
-
-/**
- * @defgroup lavu_base64 Base64
- * @ingroup lavu_crypto
- * @{
- */
-
-
-/**
- * Decode a base64-encoded string.
- *
- * @param out      buffer for decoded data
- * @param in       null-terminated input string
- * @param out_size size in bytes of the out buffer, must be at
- *                 least 3/4 of the length of in
- * @return         number of bytes written, or a negative value in case of
- *                 invalid input
- */
-int av_base64_decode(uint8_t *out, const char *in, int out_size);
-
-/**
- * Encode data to base64 and null-terminate.
- *
- * @param out      buffer for encoded data
- * @param out_size size in bytes of the out buffer (including the
- *                 null terminator), must be at least AV_BASE64_SIZE(in_size)
- * @param in       input buffer containing the data to encode
- * @param in_size  size in bytes of the in buffer
- * @return         out or NULL in case of error
- */
-char *av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size);
-
-/**
- * Calculate the output size needed to base64-encode x bytes to a
- * null-terminated string.
- */
-#define AV_BASE64_SIZE(x)  (((x)+2) / 3 * 4 + 1)
-
- /**
-  * @}
-  */
-
-#endif /* AVUTIL_BASE64_H */

Externals/ffmpeg/include/libavutil/blowfish.h

@@ -1,77 +0,0 @@
-/*
- * Blowfish algorithm
- * Copyright (c) 2012 Samuel Pitoiset
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_BLOWFISH_H
-#define AVUTIL_BLOWFISH_H
-
-#include <stdint.h>
-
-/**
- * @defgroup lavu_blowfish Blowfish
- * @ingroup lavu_crypto
- * @{
- */
-
-#define AV_BF_ROUNDS 16
-
-typedef struct AVBlowfish {
-    uint32_t p[AV_BF_ROUNDS + 2];
-    uint32_t s[4][256];
-} AVBlowfish;
-
-/**
- * Initialize an AVBlowfish context.
- *
- * @param ctx an AVBlowfish context
- * @param key a key
- * @param key_len length of the key
- */
-void av_blowfish_init(struct AVBlowfish *ctx, const uint8_t *key, int key_len);
-
-/**
- * Encrypt or decrypt a buffer using a previously initialized context.
- *
- * @param ctx an AVBlowfish context
- * @param xl left four bytes halves of input to be encrypted
- * @param xr right four bytes halves of input to be encrypted
- * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_blowfish_crypt_ecb(struct AVBlowfish *ctx, uint32_t *xl, uint32_t *xr,
-                           int decrypt);
-
-/**
- * Encrypt or decrypt a buffer using a previously initialized context.
- *
- * @param ctx an AVBlowfish context
- * @param dst destination array, can be equal to src
- * @param src source array, can be equal to dst
- * @param count number of 8 byte blocks
- * @param iv initialization vector for CBC mode, if NULL ECB will be used
- * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_blowfish_crypt(struct AVBlowfish *ctx, uint8_t *dst, const uint8_t *src,
-                       int count, uint8_t *iv, int decrypt);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_BLOWFISH_H */

Externals/ffmpeg/include/libavutil/bprint.h

@@ -1,219 +0,0 @@
-/*
- * Copyright (c) 2012 Nicolas George
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_BPRINT_H
-#define AVUTIL_BPRINT_H
-
-#include <stdarg.h>
-
-#include "attributes.h"
-#include "avstring.h"
-
-/**
- * Define a structure with extra padding to a fixed size
- * This helps ensuring binary compatibility with future versions.
- */
-
-#define FF_PAD_STRUCTURE(name, size, ...) \
-struct ff_pad_helper_##name { __VA_ARGS__ }; \
-typedef struct name { \
-    __VA_ARGS__ \
-    char reserved_padding[size - sizeof(struct ff_pad_helper_##name)]; \
-} name;
-
-/**
- * Buffer to print data progressively
- *
- * The string buffer grows as necessary and is always 0-terminated.
- * The content of the string is never accessed, and thus is
- * encoding-agnostic and can even hold binary data.
- *
- * Small buffers are kept in the structure itself, and thus require no
- * memory allocation at all (unless the contents of the buffer is needed
- * after the structure goes out of scope). This is almost as lightweight as
- * declaring a local "char buf[512]".
- *
- * The length of the string can go beyond the allocated size: the buffer is
- * then truncated, but the functions still keep account of the actual total
- * length.
- *
- * In other words, buf->len can be greater than buf->size and records the
- * total length of what would have been to the buffer if there had been
- * enough memory.
- *
- * Append operations do not need to be tested for failure: if a memory
- * allocation fails, data stop being appended to the buffer, but the length
- * is still updated. This situation can be tested with
- * av_bprint_is_complete().
- *
- * The size_max field determines several possible behaviours:
- *
- * size_max = -1 (= UINT_MAX) or any large value will let the buffer be
- * reallocated as necessary, with an amortized linear cost.
- *
- * size_max = 0 prevents writing anything to the buffer: only the total
- * length is computed. The write operations can then possibly be repeated in
- * a buffer with exactly the necessary size
- * (using size_init = size_max = len + 1).
- *
- * size_max = 1 is automatically replaced by the exact size available in the
- * structure itself, thus ensuring no dynamic memory allocation. The
- * internal buffer is large enough to hold a reasonable paragraph of text,
- * such as the current paragraph.
- */
-
-FF_PAD_STRUCTURE(AVBPrint, 1024,
-    char *str;         /**< string so far */
-    unsigned len;      /**< length so far */
-    unsigned size;     /**< allocated memory */
-    unsigned size_max; /**< maximum allocated memory */
-    char reserved_internal_buffer[1];
-)
-
-/**
- * Convenience macros for special values for av_bprint_init() size_max
- * parameter.
- */
-#define AV_BPRINT_SIZE_UNLIMITED  ((unsigned)-1)
-#define AV_BPRINT_SIZE_AUTOMATIC  1
-#define AV_BPRINT_SIZE_COUNT_ONLY 0
-
-/**
- * Init a print buffer.
- *
- * @param buf        buffer to init
- * @param size_init  initial size (including the final 0)
- * @param size_max   maximum size;
- *                   0 means do not write anything, just count the length;
- *                   1 is replaced by the maximum value for automatic storage;
- *                   any large value means that the internal buffer will be
- *                   reallocated as needed up to that limit; -1 is converted to
- *                   UINT_MAX, the largest limit possible.
- *                   Check also AV_BPRINT_SIZE_* macros.
- */
-void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max);
-
-/**
- * Init a print buffer using a pre-existing buffer.
- *
- * The buffer will not be reallocated.
- *
- * @param buf     buffer structure to init
- * @param buffer  byte buffer to use for the string data
- * @param size    size of buffer
- */
-void av_bprint_init_for_buffer(AVBPrint *buf, char *buffer, unsigned size);
-
-/**
- * Append a formatted string to a print buffer.
- */
-void av_bprintf(AVBPrint *buf, const char *fmt, ...) av_printf_format(2, 3);
-
-/**
- * Append a formatted string to a print buffer.
- */
-void av_vbprintf(AVBPrint *buf, const char *fmt, va_list vl_arg);
-
-/**
- * Append char c n times to a print buffer.
- */
-void av_bprint_chars(AVBPrint *buf, char c, unsigned n);
-
-/**
- * Append data to a print buffer.
- *
- * param buf  bprint buffer to use
- * param data pointer to data
- * param size size of data
- */
-void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size);
-
-struct tm;
-/**
- * Append a formatted date and time to a print buffer.
- *
- * param buf  bprint buffer to use
- * param fmt  date and time format string, see strftime()
- * param tm   broken-down time structure to translate
- *
- * @note due to poor design of the standard strftime function, it may
- * produce poor results if the format string expands to a very long text and
- * the bprint buffer is near the limit stated by the size_max option.
- */
-void av_bprint_strftime(AVBPrint *buf, const char *fmt, const struct tm *tm);
-
-/**
- * Allocate bytes in the buffer for external use.
- *
- * @param[in]  buf          buffer structure
- * @param[in]  size         required size
- * @param[out] mem          pointer to the memory area
- * @param[out] actual_size  size of the memory area after allocation;
- *                          can be larger or smaller than size
- */
-void av_bprint_get_buffer(AVBPrint *buf, unsigned size,
-                          unsigned char **mem, unsigned *actual_size);
-
-/**
- * Reset the string to "" but keep internal allocated data.
- */
-void av_bprint_clear(AVBPrint *buf);
-
-/**
- * Test if the print buffer is complete (not truncated).
- *
- * It may have been truncated due to a memory allocation failure
- * or the size_max limit (compare size and size_max if necessary).
- */
-static inline int av_bprint_is_complete(const AVBPrint *buf)
-{
-    return buf->len < buf->size;
-}
-
-/**
- * Finalize a print buffer.
- *
- * The print buffer can no longer be used afterwards,
- * but the len and size fields are still valid.
- *
- * @arg[out] ret_str  if not NULL, used to return a permanent copy of the
- *                    buffer contents, or NULL if memory allocation fails;
- *                    if NULL, the buffer is discarded and freed
- * @return  0 for success or error code (probably AVERROR(ENOMEM))
- */
-int av_bprint_finalize(AVBPrint *buf, char **ret_str);
-
-/**
- * Escape the content in src and append it to dstbuf.
- *
- * @param dstbuf        already inited destination bprint buffer
- * @param src           string containing the text to escape
- * @param special_chars string containing the special characters which
- *                      need to be escaped, can be NULL
- * @param mode          escape mode to employ, see AV_ESCAPE_MODE_* macros.
- *                      Any unknown value for mode will be considered equivalent to
- *                      AV_ESCAPE_MODE_BACKSLASH, but this behaviour can change without
- *                      notice.
- * @param flags         flags which control how to escape, see AV_ESCAPE_FLAG_* macros
- */
-void av_bprint_escape(AVBPrint *dstbuf, const char *src, const char *special_chars,
-                      enum AVEscapeMode mode, int flags);
-
-#endif /* AVUTIL_BPRINT_H */

Externals/ffmpeg/include/libavutil/bswap.h

@@ -1,109 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * byte swapping routines
- */
-
-#ifndef AVUTIL_BSWAP_H
-#define AVUTIL_BSWAP_H
-
-#include <stdint.h>
-#include "libavutil/avconfig.h"
-#include "attributes.h"
-
-#ifdef HAVE_AV_CONFIG_H
-
-#include "config.h"
-
-#if   ARCH_AARCH64
-#   include "aarch64/bswap.h"
-#elif ARCH_ARM
-#   include "arm/bswap.h"
-#elif ARCH_AVR32
-#   include "avr32/bswap.h"
-#elif ARCH_SH4
-#   include "sh4/bswap.h"
-#elif ARCH_X86
-#   include "x86/bswap.h"
-#endif
-
-#endif /* HAVE_AV_CONFIG_H */
-
-#define AV_BSWAP16C(x) (((x) << 8 & 0xff00)  | ((x) >> 8 & 0x00ff))
-#define AV_BSWAP32C(x) (AV_BSWAP16C(x) << 16 | AV_BSWAP16C((x) >> 16))
-#define AV_BSWAP64C(x) (AV_BSWAP32C(x) << 32 | AV_BSWAP32C((x) >> 32))
-
-#define AV_BSWAPC(s, x) AV_BSWAP##s##C(x)
-
-#ifndef av_bswap16
-static av_always_inline av_const uint16_t av_bswap16(uint16_t x)
-{
-    x= (x>>8) | (x<<8);
-    return x;
-}
-#endif
-
-#ifndef av_bswap32
-static av_always_inline av_const uint32_t av_bswap32(uint32_t x)
-{
-    return AV_BSWAP32C(x);
-}
-#endif
-
-#ifndef av_bswap64
-static inline uint64_t av_const av_bswap64(uint64_t x)
-{
-    return (uint64_t)av_bswap32(x) << 32 | av_bswap32(x >> 32);
-}
-#endif
-
-// be2ne ... big-endian to native-endian
-// le2ne ... little-endian to native-endian
-
-#if AV_HAVE_BIGENDIAN
-#define av_be2ne16(x) (x)
-#define av_be2ne32(x) (x)
-#define av_be2ne64(x) (x)
-#define av_le2ne16(x) av_bswap16(x)
-#define av_le2ne32(x) av_bswap32(x)
-#define av_le2ne64(x) av_bswap64(x)
-#define AV_BE2NEC(s, x) (x)
-#define AV_LE2NEC(s, x) AV_BSWAPC(s, x)
-#else
-#define av_be2ne16(x) av_bswap16(x)
-#define av_be2ne32(x) av_bswap32(x)
-#define av_be2ne64(x) av_bswap64(x)
-#define av_le2ne16(x) (x)
-#define av_le2ne32(x) (x)
-#define av_le2ne64(x) (x)
-#define AV_BE2NEC(s, x) AV_BSWAPC(s, x)
-#define AV_LE2NEC(s, x) (x)
-#endif
-
-#define AV_BE2NE16C(x) AV_BE2NEC(16, x)
-#define AV_BE2NE32C(x) AV_BE2NEC(32, x)
-#define AV_BE2NE64C(x) AV_BE2NEC(64, x)
-#define AV_LE2NE16C(x) AV_LE2NEC(16, x)
-#define AV_LE2NE32C(x) AV_LE2NEC(32, x)
-#define AV_LE2NE64C(x) AV_LE2NEC(64, x)
-
-#endif /* AVUTIL_BSWAP_H */

Externals/ffmpeg/include/libavutil/buffer.h

@@ -1,274 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @ingroup lavu_buffer
- * refcounted data buffer API
- */
-
-#ifndef AVUTIL_BUFFER_H
-#define AVUTIL_BUFFER_H
-
-#include <stdint.h>
-
-/**
- * @defgroup lavu_buffer AVBuffer
- * @ingroup lavu_data
- *
- * @{
- * AVBuffer is an API for reference-counted data buffers.
- *
- * There are two core objects in this API -- AVBuffer and AVBufferRef. AVBuffer
- * represents the data buffer itself; it is opaque and not meant to be accessed
- * by the caller directly, but only through AVBufferRef. However, the caller may
- * e.g. compare two AVBuffer pointers to check whether two different references
- * are describing the same data buffer. AVBufferRef represents a single
- * reference to an AVBuffer and it is the object that may be manipulated by the
- * caller directly.
- *
- * There are two functions provided for creating a new AVBuffer with a single
- * reference -- av_buffer_alloc() to just allocate a new buffer, and
- * av_buffer_create() to wrap an existing array in an AVBuffer. From an existing
- * reference, additional references may be created with av_buffer_ref().
- * Use av_buffer_unref() to free a reference (this will automatically free the
- * data once all the references are freed).
- *
- * The convention throughout this API and the rest of FFmpeg is such that the
- * buffer is considered writable if there exists only one reference to it (and
- * it has not been marked as read-only). The av_buffer_is_writable() function is
- * provided to check whether this is true and av_buffer_make_writable() will
- * automatically create a new writable buffer when necessary.
- * Of course nothing prevents the calling code from violating this convention,
- * however that is safe only when all the existing references are under its
- * control.
- *
- * @note Referencing and unreferencing the buffers is thread-safe and thus
- * may be done from multiple threads simultaneously without any need for
- * additional locking.
- *
- * @note Two different references to the same buffer can point to different
- * parts of the buffer (i.e. their AVBufferRef.data will not be equal).
- */
-
-/**
- * A reference counted buffer type. It is opaque and is meant to be used through
- * references (AVBufferRef).
- */
-typedef struct AVBuffer AVBuffer;
-
-/**
- * A reference to a data buffer.
- *
- * The size of this struct is not a part of the public ABI and it is not meant
- * to be allocated directly.
- */
-typedef struct AVBufferRef {
-    AVBuffer *buffer;
-
-    /**
-     * The data buffer. It is considered writable if and only if
-     * this is the only reference to the buffer, in which case
-     * av_buffer_is_writable() returns 1.
-     */
-    uint8_t *data;
-    /**
-     * Size of data in bytes.
-     */
-    int      size;
-} AVBufferRef;
-
-/**
- * Allocate an AVBuffer of the given size using av_malloc().
- *
- * @return an AVBufferRef of given size or NULL when out of memory
- */
-AVBufferRef *av_buffer_alloc(int size);
-
-/**
- * Same as av_buffer_alloc(), except the returned buffer will be initialized
- * to zero.
- */
-AVBufferRef *av_buffer_allocz(int size);
-
-/**
- * Always treat the buffer as read-only, even when it has only one
- * reference.
- */
-#define AV_BUFFER_FLAG_READONLY (1 << 0)
-
-/**
- * Create an AVBuffer from an existing array.
- *
- * If this function is successful, data is owned by the AVBuffer. The caller may
- * only access data through the returned AVBufferRef and references derived from
- * it.
- * If this function fails, data is left untouched.
- * @param data   data array
- * @param size   size of data in bytes
- * @param free   a callback for freeing this buffer's data
- * @param opaque parameter to be got for processing or passed to free
- * @param flags  a combination of AV_BUFFER_FLAG_*
- *
- * @return an AVBufferRef referring to data on success, NULL on failure.
- */
-AVBufferRef *av_buffer_create(uint8_t *data, int size,
-                              void (*free)(void *opaque, uint8_t *data),
-                              void *opaque, int flags);
-
-/**
- * Default free callback, which calls av_free() on the buffer data.
- * This function is meant to be passed to av_buffer_create(), not called
- * directly.
- */
-void av_buffer_default_free(void *opaque, uint8_t *data);
-
-/**
- * Create a new reference to an AVBuffer.
- *
- * @return a new AVBufferRef referring to the same AVBuffer as buf or NULL on
- * failure.
- */
-AVBufferRef *av_buffer_ref(AVBufferRef *buf);
-
-/**
- * Free a given reference and automatically free the buffer if there are no more
- * references to it.
- *
- * @param buf the reference to be freed. The pointer is set to NULL on return.
- */
-void av_buffer_unref(AVBufferRef **buf);
-
-/**
- * @return 1 if the caller may write to the data referred to by buf (which is
- * true if and only if buf is the only reference to the underlying AVBuffer).
- * Return 0 otherwise.
- * A positive answer is valid until av_buffer_ref() is called on buf.
- */
-int av_buffer_is_writable(const AVBufferRef *buf);
-
-/**
- * @return the opaque parameter set by av_buffer_create.
- */
-void *av_buffer_get_opaque(const AVBufferRef *buf);
-
-int av_buffer_get_ref_count(const AVBufferRef *buf);
-
-/**
- * Create a writable reference from a given buffer reference, avoiding data copy
- * if possible.
- *
- * @param buf buffer reference to make writable. On success, buf is either left
- *            untouched, or it is unreferenced and a new writable AVBufferRef is
- *            written in its place. On failure, buf is left untouched.
- * @return 0 on success, a negative AVERROR on failure.
- */
-int av_buffer_make_writable(AVBufferRef **buf);
-
-/**
- * Reallocate a given buffer.
- *
- * @param buf  a buffer reference to reallocate. On success, buf will be
- *             unreferenced and a new reference with the required size will be
- *             written in its place. On failure buf will be left untouched. *buf
- *             may be NULL, then a new buffer is allocated.
- * @param size required new buffer size.
- * @return 0 on success, a negative AVERROR on failure.
- *
- * @note the buffer is actually reallocated with av_realloc() only if it was
- * initially allocated through av_buffer_realloc(NULL) and there is only one
- * reference to it (i.e. the one passed to this function). In all other cases
- * a new buffer is allocated and the data is copied.
- */
-int av_buffer_realloc(AVBufferRef **buf, int size);
-
-/**
- * @}
- */
-
-/**
- * @defgroup lavu_bufferpool AVBufferPool
- * @ingroup lavu_data
- *
- * @{
- * AVBufferPool is an API for a lock-free thread-safe pool of AVBuffers.
- *
- * Frequently allocating and freeing large buffers may be slow. AVBufferPool is
- * meant to solve this in cases when the caller needs a set of buffers of the
- * same size (the most obvious use case being buffers for raw video or audio
- * frames).
- *
- * At the beginning, the user must call av_buffer_pool_init() to create the
- * buffer pool. Then whenever a buffer is needed, call av_buffer_pool_get() to
- * get a reference to a new buffer, similar to av_buffer_alloc(). This new
- * reference works in all aspects the same way as the one created by
- * av_buffer_alloc(). However, when the last reference to this buffer is
- * unreferenced, it is returned to the pool instead of being freed and will be
- * reused for subsequent av_buffer_pool_get() calls.
- *
- * When the caller is done with the pool and no longer needs to allocate any new
- * buffers, av_buffer_pool_uninit() must be called to mark the pool as freeable.
- * Once all the buffers are released, it will automatically be freed.
- *
- * Allocating and releasing buffers with this API is thread-safe as long as
- * either the default alloc callback is used, or the user-supplied one is
- * thread-safe.
- */
-
-/**
- * The buffer pool. This structure is opaque and not meant to be accessed
- * directly. It is allocated with av_buffer_pool_init() and freed with
- * av_buffer_pool_uninit().
- */
-typedef struct AVBufferPool AVBufferPool;
-
-/**
- * Allocate and initialize a buffer pool.
- *
- * @param size size of each buffer in this pool
- * @param alloc a function that will be used to allocate new buffers when the
- * pool is empty. May be NULL, then the default allocator will be used
- * (av_buffer_alloc()).
- * @return newly created buffer pool on success, NULL on error.
- */
-AVBufferPool *av_buffer_pool_init(int size, AVBufferRef* (*alloc)(int size));
-
-/**
- * Mark the pool as being available for freeing. It will actually be freed only
- * once all the allocated buffers associated with the pool are released. Thus it
- * is safe to call this function while some of the allocated buffers are still
- * in use.
- *
- * @param pool pointer to the pool to be freed. It will be set to NULL.
- * @see av_buffer_pool_can_uninit()
- */
-void av_buffer_pool_uninit(AVBufferPool **pool);
-
-/**
- * Allocate a new AVBuffer, reusing an old buffer from the pool when available.
- * This function may be called simultaneously from multiple threads.
- *
- * @return a reference to the new buffer on success, NULL on error.
- */
-AVBufferRef *av_buffer_pool_get(AVBufferPool *pool);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_BUFFER_H */

Externals/ffmpeg/include/libavutil/camellia.h

@@ -1,70 +0,0 @@
-/*
- * An implementation of the CAMELLIA algorithm as mentioned in RFC3713
- * Copyright (c) 2014 Supraja Meedinti
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_CAMELLIA_H
-#define AVUTIL_CAMELLIA_H
-
-#include <stdint.h>
-
-
-/**
-  * @file
-  * @brief Public header for libavutil CAMELLIA algorithm
-  * @defgroup lavu_camellia CAMELLIA
-  * @ingroup lavu_crypto
-  * @{
-  */
-
-extern const int av_camellia_size;
-
-struct AVCAMELLIA;
-
-/**
-  * Allocate an AVCAMELLIA context
-  * To free the struct: av_free(ptr)
-  */
-struct AVCAMELLIA *av_camellia_alloc(void);
-
-/**
-  * Initialize an AVCAMELLIA context.
-  *
-  * @param ctx an AVCAMELLIA context
-  * @param key a key of 16, 24, 32 bytes used for encryption/decryption
-  * @param key_bits number of keybits: possible are 128, 192, 256
- */
-int av_camellia_init(struct AVCAMELLIA *ctx, const uint8_t *key, int key_bits);
-
-/**
-  * Encrypt or decrypt a buffer using a previously initialized context
-  *
-  * @param ctx an AVCAMELLIA context
-  * @param dst destination array, can be equal to src
-  * @param src source array, can be equal to dst
-  * @param count number of 16 byte blocks
-  * @paran iv initialization vector for CBC mode, NULL for ECB mode
-  * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_camellia_crypt(struct AVCAMELLIA *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t* iv, int decrypt);
-
-/**
- * @}
- */
-#endif /* AVUTIL_CAMELLIA_H */

Externals/ffmpeg/include/libavutil/cast5.h

@@ -1,79 +0,0 @@
-/*
- * An implementation of the CAST128 algorithm as mentioned in RFC2144
- * Copyright (c) 2014 Supraja Meedinti
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_CAST5_H
-#define AVUTIL_CAST5_H
-
-#include <stdint.h>
-
-
-/**
-  * @file
-  * @brief Public header for libavutil CAST5 algorithm
-  * @defgroup lavu_cast5 CAST5
-  * @ingroup lavu_crypto
-  * @{
-  */
-
-extern const int av_cast5_size;
-
-struct AVCAST5;
-
-/**
-  * Allocate an AVCAST5 context
-  * To free the struct: av_free(ptr)
-  */
-struct AVCAST5 *av_cast5_alloc(void);
-/**
-  * Initialize an AVCAST5 context.
-  *
-  * @param ctx an AVCAST5 context
-  * @param key a key of 5,6,...16 bytes used for encryption/decryption
-  * @param key_bits number of keybits: possible are 40,48,...,128
- */
-int av_cast5_init(struct AVCAST5 *ctx, const uint8_t *key, int key_bits);
-
-/**
-  * Encrypt or decrypt a buffer using a previously initialized context, ECB mode only
-  *
-  * @param ctx an AVCAST5 context
-  * @param dst destination array, can be equal to src
-  * @param src source array, can be equal to dst
-  * @param count number of 8 byte blocks
-  * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_cast5_crypt(struct AVCAST5 *ctx, uint8_t *dst, const uint8_t *src, int count, int decrypt);
-
-/**
-  * Encrypt or decrypt a buffer using a previously initialized context
-  *
-  * @param ctx an AVCAST5 context
-  * @param dst destination array, can be equal to src
-  * @param src source array, can be equal to dst
-  * @param count number of 8 byte blocks
-  * @param iv initialization vector for CBC mode, NULL for ECB mode
-  * @param decrypt 0 for encryption, 1 for decryption
- */
-void av_cast5_crypt2(struct AVCAST5 *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt);
-/**
- * @}
- */
-#endif /* AVUTIL_CAST5_H */

Externals/ffmpeg/include/libavutil/channel_layout.h

@@ -1,222 +0,0 @@
-/*
- * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- * Copyright (c) 2008 Peter Ross
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_CHANNEL_LAYOUT_H
-#define AVUTIL_CHANNEL_LAYOUT_H
-
-#include <stdint.h>
-
-/**
- * @file
- * audio channel layout utility functions
- */
-
-/**
- * @addtogroup lavu_audio
- * @{
- */
-
-/**
- * @defgroup channel_masks Audio channel masks
- *
- * A channel layout is a 64-bits integer with a bit set for every channel.
- * The number of bits set must be equal to the number of channels.
- * The value 0 means that the channel layout is not known.
- * @note this data structure is not powerful enough to handle channels
- * combinations that have the same channel multiple times, such as
- * dual-mono.
- *
- * @{
- */
-#define AV_CH_FRONT_LEFT             0x00000001
-#define AV_CH_FRONT_RIGHT            0x00000002
-#define AV_CH_FRONT_CENTER           0x00000004
-#define AV_CH_LOW_FREQUENCY          0x00000008
-#define AV_CH_BACK_LEFT              0x00000010
-#define AV_CH_BACK_RIGHT             0x00000020
-#define AV_CH_FRONT_LEFT_OF_CENTER   0x00000040
-#define AV_CH_FRONT_RIGHT_OF_CENTER  0x00000080
-#define AV_CH_BACK_CENTER            0x00000100
-#define AV_CH_SIDE_LEFT              0x00000200
-#define AV_CH_SIDE_RIGHT             0x00000400
-#define AV_CH_TOP_CENTER             0x00000800
-#define AV_CH_TOP_FRONT_LEFT         0x00001000
-#define AV_CH_TOP_FRONT_CENTER       0x00002000
-#define AV_CH_TOP_FRONT_RIGHT        0x00004000
-#define AV_CH_TOP_BACK_LEFT          0x00008000
-#define AV_CH_TOP_BACK_CENTER        0x00010000
-#define AV_CH_TOP_BACK_RIGHT         0x00020000
-#define AV_CH_STEREO_LEFT            0x20000000  ///< Stereo downmix.
-#define AV_CH_STEREO_RIGHT           0x40000000  ///< See AV_CH_STEREO_LEFT.
-#define AV_CH_WIDE_LEFT              0x0000000080000000ULL
-#define AV_CH_WIDE_RIGHT             0x0000000100000000ULL
-#define AV_CH_SURROUND_DIRECT_LEFT   0x0000000200000000ULL
-#define AV_CH_SURROUND_DIRECT_RIGHT  0x0000000400000000ULL
-#define AV_CH_LOW_FREQUENCY_2        0x0000000800000000ULL
-
-/** Channel mask value used for AVCodecContext.request_channel_layout
-    to indicate that the user requests the channel order of the decoder output
-    to be the native codec channel order. */
-#define AV_CH_LAYOUT_NATIVE          0x8000000000000000ULL
-
-/**
- * @}
- * @defgroup channel_mask_c Audio channel layouts
- * @{
- * */
-#define AV_CH_LAYOUT_MONO              (AV_CH_FRONT_CENTER)
-#define AV_CH_LAYOUT_STEREO            (AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT)
-#define AV_CH_LAYOUT_2POINT1           (AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_2_1               (AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_SURROUND          (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER)
-#define AV_CH_LAYOUT_3POINT1           (AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_4POINT0           (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_4POINT1           (AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_2_2               (AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT)
-#define AV_CH_LAYOUT_QUAD              (AV_CH_LAYOUT_STEREO|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
-#define AV_CH_LAYOUT_5POINT0           (AV_CH_LAYOUT_SURROUND|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT)
-#define AV_CH_LAYOUT_5POINT1           (AV_CH_LAYOUT_5POINT0|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_5POINT0_BACK      (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
-#define AV_CH_LAYOUT_5POINT1_BACK      (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_6POINT0           (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_6POINT0_FRONT     (AV_CH_LAYOUT_2_2|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
-#define AV_CH_LAYOUT_HEXAGONAL         (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_6POINT1           (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_6POINT1_BACK      (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_6POINT1_FRONT     (AV_CH_LAYOUT_6POINT0_FRONT|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_7POINT0           (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
-#define AV_CH_LAYOUT_7POINT0_FRONT     (AV_CH_LAYOUT_5POINT0|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
-#define AV_CH_LAYOUT_7POINT1           (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
-#define AV_CH_LAYOUT_7POINT1_WIDE      (AV_CH_LAYOUT_5POINT1|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
-#define AV_CH_LAYOUT_7POINT1_WIDE_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
-#define AV_CH_LAYOUT_OCTAGONAL         (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_CENTER|AV_CH_BACK_RIGHT)
-#define AV_CH_LAYOUT_STEREO_DOWNMIX    (AV_CH_STEREO_LEFT|AV_CH_STEREO_RIGHT)
-
-enum AVMatrixEncoding {
-    AV_MATRIX_ENCODING_NONE,
-    AV_MATRIX_ENCODING_DOLBY,
-    AV_MATRIX_ENCODING_DPLII,
-    AV_MATRIX_ENCODING_DPLIIX,
-    AV_MATRIX_ENCODING_DPLIIZ,
-    AV_MATRIX_ENCODING_DOLBYEX,
-    AV_MATRIX_ENCODING_DOLBYHEADPHONE,
-    AV_MATRIX_ENCODING_NB
-};
-
-/**
- * Return a channel layout id that matches name, or 0 if no match is found.
- *
- * name can be one or several of the following notations,
- * separated by '+' or '|':
- * - the name of an usual channel layout (mono, stereo, 4.0, quad, 5.0,
- *   5.0(side), 5.1, 5.1(side), 7.1, 7.1(wide), downmix);
- * - the name of a single channel (FL, FR, FC, LFE, BL, BR, FLC, FRC, BC,
- *   SL, SR, TC, TFL, TFC, TFR, TBL, TBC, TBR, DL, DR);
- * - a number of channels, in decimal, optionally followed by 'c', yielding
- *   the default channel layout for that number of channels (@see
- *   av_get_default_channel_layout);
- * - a channel layout mask, in hexadecimal starting with "0x" (see the
- *   AV_CH_* macros).
- *
- * @warning Starting from the next major bump the trailing character
- * 'c' to specify a number of channels will be required, while a
- * channel layout mask could also be specified as a decimal number
- * (if and only if not followed by "c").
- *
- * Example: "stereo+FC" = "2c+FC" = "2c+1c" = "0x7"
- */
-uint64_t av_get_channel_layout(const char *name);
-
-/**
- * Return a description of a channel layout.
- * If nb_channels is <= 0, it is guessed from the channel_layout.
- *
- * @param buf put here the string containing the channel layout
- * @param buf_size size in bytes of the buffer
- */
-void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout);
-
-struct AVBPrint;
-/**
- * Append a description of a channel layout to a bprint buffer.
- */
-void av_bprint_channel_layout(struct AVBPrint *bp, int nb_channels, uint64_t channel_layout);
-
-/**
- * Return the number of channels in the channel layout.
- */
-int av_get_channel_layout_nb_channels(uint64_t channel_layout);
-
-/**
- * Return default channel layout for a given number of channels.
- */
-int64_t av_get_default_channel_layout(int nb_channels);
-
-/**
- * Get the index of a channel in channel_layout.
- *
- * @param channel a channel layout describing exactly one channel which must be
- *                present in channel_layout.
- *
- * @return index of channel in channel_layout on success, a negative AVERROR
- *         on error.
- */
-int av_get_channel_layout_channel_index(uint64_t channel_layout,
-                                        uint64_t channel);
-
-/**
- * Get the channel with the given index in channel_layout.
- */
-uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index);
-
-/**
- * Get the name of a given channel.
- *
- * @return channel name on success, NULL on error.
- */
-const char *av_get_channel_name(uint64_t channel);
-
-/**
- * Get the description of a given channel.
- *
- * @param channel  a channel layout with a single channel
- * @return  channel description on success, NULL on error
- */
-const char *av_get_channel_description(uint64_t channel);
-
-/**
- * Get the value and name of a standard channel layout.
- *
- * @param[in]  index   index in an internal list, starting at 0
- * @param[out] layout  channel layout mask
- * @param[out] name    name of the layout
- * @return  0  if the layout exists,
- *          <0 if index is beyond the limits
- */
-int av_get_standard_channel_layout(unsigned index, uint64_t *layout,
-                                   const char **name);
-
-/**
- * @}
- * @}
- */
-
-#endif /* AVUTIL_CHANNEL_LAYOUT_H */

Externals/ffmpeg/include/libavutil/common.h

@@ -1,469 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * common internal and external API header
- */
-
-#ifndef AVUTIL_COMMON_H
-#define AVUTIL_COMMON_H
-
-#if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS) && !defined(UINT64_C)
-#error missing -D__STDC_CONSTANT_MACROS / #define __STDC_CONSTANT_MACROS
-#endif
-
-#include <errno.h>
-#include <inttypes.h>
-#include <limits.h>
-#include <math.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "attributes.h"
-#include "version.h"
-#include "libavutil/avconfig.h"
-
-#if AV_HAVE_BIGENDIAN
-#   define AV_NE(be, le) (be)
-#else
-#   define AV_NE(be, le) (le)
-#endif
-
-//rounded division & shift
-#define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))
-/* assume b>0 */
-#define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
-/* assume a>0 and b>0 */
-#define FF_CEIL_RSHIFT(a,b) (!av_builtin_constant_p(b) ? -((-(a)) >> (b)) \
-                                                       : ((a) + (1<<(b)) - 1) >> (b))
-#define FFUDIV(a,b) (((a)>0 ?(a):(a)-(b)+1) / (b))
-#define FFUMOD(a,b) ((a)-(b)*FFUDIV(a,b))
-#define FFABS(a) ((a) >= 0 ? (a) : (-(a)))
-#define FFSIGN(a) ((a) > 0 ? 1 : -1)
-
-#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
-#define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c)
-#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
-#define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c)
-
-#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
-#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0]))
-#define FFALIGN(x, a) (((x)+(a)-1)&~((a)-1))
-
-/* misc math functions */
-
-/**
- * Reverse the order of the bits of an 8-bits unsigned integer.
- */
-#if FF_API_AV_REVERSE
-extern attribute_deprecated const uint8_t av_reverse[256];
-#endif
-
-#ifdef HAVE_AV_CONFIG_H
-#   include "config.h"
-#   include "intmath.h"
-#endif
-
-/* Pull in unguarded fallback defines at the end of this file. */
-#include "common.h"
-
-#ifndef av_log2
-av_const int av_log2(unsigned v);
-#endif
-
-#ifndef av_log2_16bit
-av_const int av_log2_16bit(unsigned v);
-#endif
-
-/**
- * Clip a signed integer value into the amin-amax range.
- * @param a value to clip
- * @param amin minimum value of the clip range
- * @param amax maximum value of the clip range
- * @return clipped value
- */
-static av_always_inline av_const int av_clip_c(int a, int amin, int amax)
-{
-#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
-    if (amin > amax) abort();
-#endif
-    if      (a < amin) return amin;
-    else if (a > amax) return amax;
-    else               return a;
-}
-
-/**
- * Clip a signed 64bit integer value into the amin-amax range.
- * @param a value to clip
- * @param amin minimum value of the clip range
- * @param amax maximum value of the clip range
- * @return clipped value
- */
-static av_always_inline av_const int64_t av_clip64_c(int64_t a, int64_t amin, int64_t amax)
-{
-#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
-    if (amin > amax) abort();
-#endif
-    if      (a < amin) return amin;
-    else if (a > amax) return amax;
-    else               return a;
-}
-
-/**
- * Clip a signed integer value into the 0-255 range.
- * @param a value to clip
- * @return clipped value
- */
-static av_always_inline av_const uint8_t av_clip_uint8_c(int a)
-{
-    if (a&(~0xFF)) return (-a)>>31;
-    else           return a;
-}
-
-/**
- * Clip a signed integer value into the -128,127 range.
- * @param a value to clip
- * @return clipped value
- */
-static av_always_inline av_const int8_t av_clip_int8_c(int a)
-{
-    if ((a+0x80) & ~0xFF) return (a>>31) ^ 0x7F;
-    else                  return a;
-}
-
-/**
- * Clip a signed integer value into the 0-65535 range.
- * @param a value to clip
- * @return clipped value
- */
-static av_always_inline av_const uint16_t av_clip_uint16_c(int a)
-{
-    if (a&(~0xFFFF)) return (-a)>>31;
-    else             return a;
-}
-
-/**
- * Clip a signed integer value into the -32768,32767 range.
- * @param a value to clip
- * @return clipped value
- */
-static av_always_inline av_const int16_t av_clip_int16_c(int a)
-{
-    if ((a+0x8000) & ~0xFFFF) return (a>>31) ^ 0x7FFF;
-    else                      return a;
-}
-
-/**
- * Clip a signed 64-bit integer value into the -2147483648,2147483647 range.
- * @param a value to clip
- * @return clipped value
- */
-static av_always_inline av_const int32_t av_clipl_int32_c(int64_t a)
-{
-    if ((a+0x80000000u) & ~UINT64_C(0xFFFFFFFF)) return (int32_t)((a>>63) ^ 0x7FFFFFFF);
-    else                                         return (int32_t)a;
-}
-
-/**
- * Clip a signed integer to an unsigned power of two range.
- * @param  a value to clip
- * @param  p bit position to clip at
- * @return clipped value
- */
-static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p)
-{
-    if (a & ~((1<<p) - 1)) return -a >> 31 & ((1<<p) - 1);
-    else                   return  a;
-}
-
-/**
- * Add two signed 32-bit values with saturation.
- *
- * @param  a one value
- * @param  b another value
- * @return sum with signed saturation
- */
-static av_always_inline int av_sat_add32_c(int a, int b)
-{
-    return av_clipl_int32((int64_t)a + b);
-}
-
-/**
- * Add a doubled value to another value with saturation at both stages.
- *
- * @param  a first value
- * @param  b value doubled and added to a
- * @return sum with signed saturation
- */
-static av_always_inline int av_sat_dadd32_c(int a, int b)
-{
-    return av_sat_add32(a, av_sat_add32(b, b));
-}
-
-/**
- * Clip a float value into the amin-amax range.
- * @param a value to clip
- * @param amin minimum value of the clip range
- * @param amax maximum value of the clip range
- * @return clipped value
- */
-static av_always_inline av_const float av_clipf_c(float a, float amin, float amax)
-{
-#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
-    if (amin > amax) abort();
-#endif
-    if      (a < amin) return amin;
-    else if (a > amax) return amax;
-    else               return a;
-}
-
-/**
- * Clip a double value into the amin-amax range.
- * @param a value to clip
- * @param amin minimum value of the clip range
- * @param amax maximum value of the clip range
- * @return clipped value
- */
-static av_always_inline av_const double av_clipd_c(double a, double amin, double amax)
-{
-#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
-    if (amin > amax) abort();
-#endif
-    if      (a < amin) return amin;
-    else if (a > amax) return amax;
-    else               return a;
-}
-
-/** Compute ceil(log2(x)).
- * @param x value used to compute ceil(log2(x))
- * @return computed ceiling of log2(x)
- */
-static av_always_inline av_const int av_ceil_log2_c(int x)
-{
-    return av_log2((x - 1) << 1);
-}
-
-/**
- * Count number of bits set to one in x
- * @param x value to count bits of
- * @return the number of bits set to one in x
- */
-static av_always_inline av_const int av_popcount_c(uint32_t x)
-{
-    x -= (x >> 1) & 0x55555555;
-    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
-    x = (x + (x >> 4)) & 0x0F0F0F0F;
-    x += x >> 8;
-    return (x + (x >> 16)) & 0x3F;
-}
-
-/**
- * Count number of bits set to one in x
- * @param x value to count bits of
- * @return the number of bits set to one in x
- */
-static av_always_inline av_const int av_popcount64_c(uint64_t x)
-{
-    return av_popcount((uint32_t)x) + av_popcount((uint32_t)(x >> 32));
-}
-
-#define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
-#define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
-
-/**
- * Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
- *
- * @param val      Output value, must be an lvalue of type uint32_t.
- * @param GET_BYTE Expression reading one byte from the input.
- *                 Evaluated up to 7 times (4 for the currently
- *                 assigned Unicode range).  With a memory buffer
- *                 input, this could be *ptr++.
- * @param ERROR    Expression to be evaluated on invalid input,
- *                 typically a goto statement.
- *
- * @warning ERROR should not contain a loop control statement which
- * could interact with the internal while loop, and should force an
- * exit from the macro code (e.g. through a goto or a return) in order
- * to prevent undefined results.
- */
-#define GET_UTF8(val, GET_BYTE, ERROR)\
-    val= GET_BYTE;\
-    {\
-        uint32_t top = (val & 128) >> 1;\
-        if ((val & 0xc0) == 0x80 || val >= 0xFE)\
-            ERROR\
-        while (val & top) {\
-            int tmp= GET_BYTE - 128;\
-            if(tmp>>6)\
-                ERROR\
-            val= (val<<6) + tmp;\
-            top <<= 5;\
-        }\
-        val &= (top << 1) - 1;\
-    }
-
-/**
- * Convert a UTF-16 character (2 or 4 bytes) to its 32-bit UCS-4 encoded form.
- *
- * @param val       Output value, must be an lvalue of type uint32_t.
- * @param GET_16BIT Expression returning two bytes of UTF-16 data converted
- *                  to native byte order.  Evaluated one or two times.
- * @param ERROR     Expression to be evaluated on invalid input,
- *                  typically a goto statement.
- */
-#define GET_UTF16(val, GET_16BIT, ERROR)\
-    val = GET_16BIT;\
-    {\
-        unsigned int hi = val - 0xD800;\
-        if (hi < 0x800) {\
-            val = GET_16BIT - 0xDC00;\
-            if (val > 0x3FFU || hi > 0x3FFU)\
-                ERROR\
-            val += (hi<<10) + 0x10000;\
-        }\
-    }\
-
-/**
- * @def PUT_UTF8(val, tmp, PUT_BYTE)
- * Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long).
- * @param val is an input-only argument and should be of type uint32_t. It holds
- * a UCS-4 encoded Unicode character that is to be converted to UTF-8. If
- * val is given as a function it is executed only once.
- * @param tmp is a temporary variable and should be of type uint8_t. It
- * represents an intermediate value during conversion that is to be
- * output by PUT_BYTE.
- * @param PUT_BYTE writes the converted UTF-8 bytes to any proper destination.
- * It could be a function or a statement, and uses tmp as the input byte.
- * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be
- * executed up to 4 times for values in the valid UTF-8 range and up to
- * 7 times in the general case, depending on the length of the converted
- * Unicode character.
- */
-#define PUT_UTF8(val, tmp, PUT_BYTE)\
-    {\
-        int bytes, shift;\
-        uint32_t in = val;\
-        if (in < 0x80) {\
-            tmp = in;\
-            PUT_BYTE\
-        } else {\
-            bytes = (av_log2(in) + 4) / 5;\
-            shift = (bytes - 1) * 6;\
-            tmp = (256 - (256 >> bytes)) | (in >> shift);\
-            PUT_BYTE\
-            while (shift >= 6) {\
-                shift -= 6;\
-                tmp = 0x80 | ((in >> shift) & 0x3f);\
-                PUT_BYTE\
-            }\
-        }\
-    }
-
-/**
- * @def PUT_UTF16(val, tmp, PUT_16BIT)
- * Convert a 32-bit Unicode character to its UTF-16 encoded form (2 or 4 bytes).
- * @param val is an input-only argument and should be of type uint32_t. It holds
- * a UCS-4 encoded Unicode character that is to be converted to UTF-16. If
- * val is given as a function it is executed only once.
- * @param tmp is a temporary variable and should be of type uint16_t. It
- * represents an intermediate value during conversion that is to be
- * output by PUT_16BIT.
- * @param PUT_16BIT writes the converted UTF-16 data to any proper destination
- * in desired endianness. It could be a function or a statement, and uses tmp
- * as the input byte.  For example, PUT_BYTE could be "*output++ = tmp;"
- * PUT_BYTE will be executed 1 or 2 times depending on input character.
- */
-#define PUT_UTF16(val, tmp, PUT_16BIT)\
-    {\
-        uint32_t in = val;\
-        if (in < 0x10000) {\
-            tmp = in;\
-            PUT_16BIT\
-        } else {\
-            tmp = 0xD800 | ((in - 0x10000) >> 10);\
-            PUT_16BIT\
-            tmp = 0xDC00 | ((in - 0x10000) & 0x3FF);\
-            PUT_16BIT\
-        }\
-    }\
-
-
-
-#include "mem.h"
-
-#ifdef HAVE_AV_CONFIG_H
-#    include "internal.h"
-#endif /* HAVE_AV_CONFIG_H */
-
-#endif /* AVUTIL_COMMON_H */
-
-/*
- * The following definitions are outside the multiple inclusion guard
- * to ensure they are immediately available in intmath.h.
- */
-
-#ifndef av_ceil_log2
-#   define av_ceil_log2     av_ceil_log2_c
-#endif
-#ifndef av_clip
-#   define av_clip          av_clip_c
-#endif
-#ifndef av_clip64
-#   define av_clip64        av_clip64_c
-#endif
-#ifndef av_clip_uint8
-#   define av_clip_uint8    av_clip_uint8_c
-#endif
-#ifndef av_clip_int8
-#   define av_clip_int8     av_clip_int8_c
-#endif
-#ifndef av_clip_uint16
-#   define av_clip_uint16   av_clip_uint16_c
-#endif
-#ifndef av_clip_int16
-#   define av_clip_int16    av_clip_int16_c
-#endif
-#ifndef av_clipl_int32
-#   define av_clipl_int32   av_clipl_int32_c
-#endif
-#ifndef av_clip_uintp2
-#   define av_clip_uintp2   av_clip_uintp2_c
-#endif
-#ifndef av_sat_add32
-#   define av_sat_add32     av_sat_add32_c
-#endif
-#ifndef av_sat_dadd32
-#   define av_sat_dadd32    av_sat_dadd32_c
-#endif
-#ifndef av_clipf
-#   define av_clipf         av_clipf_c
-#endif
-#ifndef av_clipd
-#   define av_clipd         av_clipd_c
-#endif
-#ifndef av_popcount
-#   define av_popcount      av_popcount_c
-#endif
-#ifndef av_popcount64
-#   define av_popcount64    av_popcount64_c
-#endif

Externals/ffmpeg/include/libavutil/cpu.h

@@ -1,116 +0,0 @@
-/*
- * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_CPU_H
-#define AVUTIL_CPU_H
-
-#include "attributes.h"
-
-#define AV_CPU_FLAG_FORCE    0x80000000 /* force usage of selected flags (OR) */
-
-    /* lower 16 bits - CPU features */
-#define AV_CPU_FLAG_MMX          0x0001 ///< standard MMX
-#define AV_CPU_FLAG_MMXEXT       0x0002 ///< SSE integer functions or AMD MMX ext
-#define AV_CPU_FLAG_MMX2         0x0002 ///< SSE integer functions or AMD MMX ext
-#define AV_CPU_FLAG_3DNOW        0x0004 ///< AMD 3DNOW
-#define AV_CPU_FLAG_SSE          0x0008 ///< SSE functions
-#define AV_CPU_FLAG_SSE2         0x0010 ///< PIV SSE2 functions
-#define AV_CPU_FLAG_SSE2SLOW 0x40000000 ///< SSE2 supported, but usually not faster
-                                        ///< than regular MMX/SSE (e.g. Core1)
-#define AV_CPU_FLAG_3DNOWEXT     0x0020 ///< AMD 3DNowExt
-#define AV_CPU_FLAG_SSE3         0x0040 ///< Prescott SSE3 functions
-#define AV_CPU_FLAG_SSE3SLOW 0x20000000 ///< SSE3 supported, but usually not faster
-                                        ///< than regular MMX/SSE (e.g. Core1)
-#define AV_CPU_FLAG_SSSE3        0x0080 ///< Conroe SSSE3 functions
-#define AV_CPU_FLAG_ATOM     0x10000000 ///< Atom processor, some SSSE3 instructions are slower
-#define AV_CPU_FLAG_SSE4         0x0100 ///< Penryn SSE4.1 functions
-#define AV_CPU_FLAG_SSE42        0x0200 ///< Nehalem SSE4.2 functions
-#define AV_CPU_FLAG_AVX          0x4000 ///< AVX functions: requires OS support even if YMM registers aren't used
-#define AV_CPU_FLAG_XOP          0x0400 ///< Bulldozer XOP functions
-#define AV_CPU_FLAG_FMA4         0x0800 ///< Bulldozer FMA4 functions
-// #if LIBAVUTIL_VERSION_MAJOR <52
-#define AV_CPU_FLAG_CMOV      0x1001000 ///< supports cmov instruction
-// #else
-// #define AV_CPU_FLAG_CMOV         0x1000 ///< supports cmov instruction
-// #endif
-#define AV_CPU_FLAG_AVX2         0x8000 ///< AVX2 functions: requires OS support even if YMM registers aren't used
-#define AV_CPU_FLAG_FMA3        0x10000 ///< Haswell FMA3 functions
-#define AV_CPU_FLAG_BMI1        0x20000 ///< Bit Manipulation Instruction Set 1
-#define AV_CPU_FLAG_BMI2        0x40000 ///< Bit Manipulation Instruction Set 2
-
-#define AV_CPU_FLAG_ALTIVEC      0x0001 ///< standard
-
-#define AV_CPU_FLAG_ARMV5TE      (1 << 0)
-#define AV_CPU_FLAG_ARMV6        (1 << 1)
-#define AV_CPU_FLAG_ARMV6T2      (1 << 2)
-#define AV_CPU_FLAG_VFP          (1 << 3)
-#define AV_CPU_FLAG_VFPV3        (1 << 4)
-#define AV_CPU_FLAG_NEON         (1 << 5)
-#define AV_CPU_FLAG_ARMV8        (1 << 6)
-#define AV_CPU_FLAG_SETEND       (1 <<16)
-
-/**
- * Return the flags which specify extensions supported by the CPU.
- * The returned value is affected by av_force_cpu_flags() if that was used
- * before. So av_get_cpu_flags() can easily be used in a application to
- * detect the enabled cpu flags.
- */
-int av_get_cpu_flags(void);
-
-/**
- * Disables cpu detection and forces the specified flags.
- * -1 is a special case that disables forcing of specific flags.
- */
-void av_force_cpu_flags(int flags);
-
-/**
- * Set a mask on flags returned by av_get_cpu_flags().
- * This function is mainly useful for testing.
- * Please use av_force_cpu_flags() and av_get_cpu_flags() instead which are more flexible
- *
- * @warning this function is not thread safe.
- */
-attribute_deprecated void av_set_cpu_flags_mask(int mask);
-
-/**
- * Parse CPU flags from a string.
- *
- * The returned flags contain the specified flags as well as related unspecified flags.
- *
- * This function exists only for compatibility with libav.
- * Please use av_parse_cpu_caps() when possible.
- * @return a combination of AV_CPU_* flags, negative on error.
- */
-attribute_deprecated
-int av_parse_cpu_flags(const char *s);
-
-/**
- * Parse CPU caps from a string and update the given AV_CPU_* flags based on that.
- *
- * @return negative on error.
- */
-int av_parse_cpu_caps(unsigned *flags, const char *s);
-
-/**
- * @return the number of logical CPU cores present.
- */
-int av_cpu_count(void);
-
-#endif /* AVUTIL_CPU_H */

Externals/ffmpeg/include/libavutil/crc.h

@@ -1,86 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_CRC_H
-#define AVUTIL_CRC_H
-
-#include <stdint.h>
-#include <stddef.h>
-#include "attributes.h"
-
-/**
- * @defgroup lavu_crc32 CRC32
- * @ingroup lavu_crypto
- * @{
- */
-
-typedef uint32_t AVCRC;
-
-typedef enum {
-    AV_CRC_8_ATM,
-    AV_CRC_16_ANSI,
-    AV_CRC_16_CCITT,
-    AV_CRC_32_IEEE,
-    AV_CRC_32_IEEE_LE,  /*< reversed bitorder version of AV_CRC_32_IEEE */
-    AV_CRC_16_ANSI_LE,  /*< reversed bitorder version of AV_CRC_16_ANSI */
-    AV_CRC_24_IEEE = 12,
-    AV_CRC_MAX,         /*< Not part of public API! Do not use outside libavutil. */
-}AVCRCId;
-
-/**
- * Initialize a CRC table.
- * @param ctx must be an array of size sizeof(AVCRC)*257 or sizeof(AVCRC)*1024
- * @param le If 1, the lowest bit represents the coefficient for the highest
- *           exponent of the corresponding polynomial (both for poly and
- *           actual CRC).
- *           If 0, you must swap the CRC parameter and the result of av_crc
- *           if you need the standard representation (can be simplified in
- *           most cases to e.g. bswap16):
- *           av_bswap32(crc << (32-bits))
- * @param bits number of bits for the CRC
- * @param poly generator polynomial without the x**bits coefficient, in the
- *             representation as specified by le
- * @param ctx_size size of ctx in bytes
- * @return <0 on failure
- */
-int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size);
-
-/**
- * Get an initialized standard CRC table.
- * @param crc_id ID of a standard CRC
- * @return a pointer to the CRC table or NULL on failure
- */
-const AVCRC *av_crc_get_table(AVCRCId crc_id);
-
-/**
- * Calculate the CRC of a block.
- * @param crc CRC of previous blocks if any or initial value for CRC
- * @return CRC updated with the data from the given block
- *
- * @see av_crc_init() "le" parameter
- */
-uint32_t av_crc(const AVCRC *ctx, uint32_t crc,
-                const uint8_t *buffer, size_t length) av_pure;
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_CRC_H */

Externals/ffmpeg/include/libavutil/dict.h

@@ -1,196 +0,0 @@
-/*
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * Public dictionary API.
- * @deprecated
- *  AVDictionary is provided for compatibility with libav. It is both in
- *  implementation as well as API inefficient. It does not scale and is
- *  extremely slow with large dictionaries.
- *  It is recommended that new code uses our tree container from tree.c/h
- *  where applicable, which uses AVL trees to achieve O(log n) performance.
- */
-
-#ifndef AVUTIL_DICT_H
-#define AVUTIL_DICT_H
-
-#include <stdint.h>
-
-#include "version.h"
-
-/**
- * @addtogroup lavu_dict AVDictionary
- * @ingroup lavu_data
- *
- * @brief Simple key:value store
- *
- * @{
- * Dictionaries are used for storing key:value pairs. To create
- * an AVDictionary, simply pass an address of a NULL pointer to
- * av_dict_set(). NULL can be used as an empty dictionary wherever
- * a pointer to an AVDictionary is required.
- * Use av_dict_get() to retrieve an entry or iterate over all
- * entries and finally av_dict_free() to free the dictionary
- * and all its contents.
- *
- @code
-   AVDictionary *d = NULL;           // "create" an empty dictionary
-   AVDictionaryEntry *t = NULL;
-
-   av_dict_set(&d, "foo", "bar", 0); // add an entry
-
-   char *k = av_strdup("key");       // if your strings are already allocated,
-   char *v = av_strdup("value");     // you can avoid copying them like this
-   av_dict_set(&d, k, v, AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
-
-   while (t = av_dict_get(d, "", t, AV_DICT_IGNORE_SUFFIX)) {
-       <....>                             // iterate over all entries in d
-   }
-   av_dict_free(&d);
- @endcode
- *
- */
-
-#define AV_DICT_MATCH_CASE      1   /**< Only get an entry with exact-case key match. Only relevant in av_dict_get(). */
-#define AV_DICT_IGNORE_SUFFIX   2   /**< Return first entry in a dictionary whose first part corresponds to the search key,
-                                         ignoring the suffix of the found key string. Only relevant in av_dict_get(). */
-#define AV_DICT_DONT_STRDUP_KEY 4   /**< Take ownership of a key that's been
-                                         allocated with av_malloc() or another memory allocation function. */
-#define AV_DICT_DONT_STRDUP_VAL 8   /**< Take ownership of a value that's been
-                                         allocated with av_malloc() or another memory allocation function. */
-#define AV_DICT_DONT_OVERWRITE 16   ///< Don't overwrite existing entries.
-#define AV_DICT_APPEND         32   /**< If the entry already exists, append to it.  Note that no
-                                      delimiter is added, the strings are simply concatenated. */
-
-typedef struct AVDictionaryEntry {
-    char *key;
-    char *value;
-} AVDictionaryEntry;
-
-typedef struct AVDictionary AVDictionary;
-
-/**
- * Get a dictionary entry with matching key.
- *
- * The returned entry key or value must not be changed, or it will
- * cause undefined behavior.
- *
- * To iterate through all the dictionary entries, you can set the matching key
- * to the null string "" and set the AV_DICT_IGNORE_SUFFIX flag.
- *
- * @param prev Set to the previous matching element to find the next.
- *             If set to NULL the first matching element is returned.
- * @param key matching key
- * @param flags a collection of AV_DICT_* flags controlling how the entry is retrieved
- * @return found entry or NULL in case no matching entry was found in the dictionary
- */
-AVDictionaryEntry *av_dict_get(const AVDictionary *m, const char *key,
-                               const AVDictionaryEntry *prev, int flags);
-
-/**
- * Get number of entries in dictionary.
- *
- * @param m dictionary
- * @return  number of entries in dictionary
- */
-int av_dict_count(const AVDictionary *m);
-
-/**
- * Set the given entry in *pm, overwriting an existing entry.
- *
- * Note: If AV_DICT_DONT_STRDUP_KEY or AV_DICT_DONT_STRDUP_VAL is set,
- * these arguments will be freed on error.
- *
- * @param pm pointer to a pointer to a dictionary struct. If *pm is NULL
- * a dictionary struct is allocated and put in *pm.
- * @param key entry key to add to *pm (will be av_strduped depending on flags)
- * @param value entry value to add to *pm (will be av_strduped depending on flags).
- *        Passing a NULL value will cause an existing entry to be deleted.
- * @return >= 0 on success otherwise an error code <0
- */
-int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags);
-
-/**
- * Convenience wrapper for av_dict_set that converts the value to a string
- * and stores it.
- *
- * Note: If AV_DICT_DONT_STRDUP_KEY is set, key will be freed on error.
- */
-int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags);
-
-/**
- * Parse the key/value pairs list and add the parsed entries to a dictionary.
- *
- * In case of failure, all the successfully set entries are stored in
- * *pm. You may need to manually free the created dictionary.
- *
- * @param key_val_sep  a 0-terminated list of characters used to separate
- *                     key from value
- * @param pairs_sep    a 0-terminated list of characters used to separate
- *                     two pairs from each other
- * @param flags        flags to use when adding to dictionary.
- *                     AV_DICT_DONT_STRDUP_KEY and AV_DICT_DONT_STRDUP_VAL
- *                     are ignored since the key/value tokens will always
- *                     be duplicated.
- * @return             0 on success, negative AVERROR code on failure
- */
-int av_dict_parse_string(AVDictionary **pm, const char *str,
-                         const char *key_val_sep, const char *pairs_sep,
-                         int flags);
-
-/**
- * Copy entries from one AVDictionary struct into another.
- * @param dst pointer to a pointer to a AVDictionary struct. If *dst is NULL,
- *            this function will allocate a struct for you and put it in *dst
- * @param src pointer to source AVDictionary struct
- * @param flags flags to use when setting entries in *dst
- * @note metadata is read using the AV_DICT_IGNORE_SUFFIX flag
- */
-void av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags);
-
-/**
- * Free all the memory allocated for an AVDictionary struct
- * and all keys and values.
- */
-void av_dict_free(AVDictionary **m);
-
-/**
- * Get dictionary entries as a string.
- *
- * Create a string containing dictionary's entries.
- * Such string may be passed back to av_dict_parse_string().
- * @note String is escaped with backslashes ('\').
- *
- * @param[in]  m             dictionary
- * @param[out] buffer        Pointer to buffer that will be allocated with string containg entries.
- *                           Buffer must be freed by the caller when is no longer needed.
- * @param[in]  key_val_sep   character used to separate key from value
- * @param[in]  pairs_sep     character used to separate two pairs from each other
- * @return                   >= 0 on success, negative on error
- * @warning Separators cannot be neither '\\' nor '\0'. They also cannot be the same.
- */
-int av_dict_get_string(const AVDictionary *m, char **buffer,
-                       const char key_val_sep, const char pairs_sep);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_DICT_H */

Externals/ffmpeg/include/libavutil/display.h

@@ -1,86 +0,0 @@
-/*
- * Copyright (c) 2014 Vittorio Giovara <vittorio.giovara@gmail.com>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_DISPLAY_H
-#define AVUTIL_DISPLAY_H
-
-#include <stdint.h>
-
-/**
- * The display transformation matrix specifies an affine transformation that
- * should be applied to video frames for correct presentation. It is compatible
- * with the matrices stored in the ISO/IEC 14496-12 container format.
- *
- * The data is a 3x3 matrix represented as a 9-element array:
- *
- *                                  | a b u |
- *   (a, b, u, c, d, v, x, y, w) -> | c d v |
- *                                  | x y w |
- *
- * All numbers are stored in native endianness, as 16.16 fixed-point values,
- * except for u, v and w, which are stored as 2.30 fixed-point values.
- *
- * The transformation maps a point (p, q) in the source (pre-transformation)
- * frame to the point (p', q') in the destination (post-transformation) frame as
- * follows:
- *               | a b u |
- *   (p, q, 1) . | c d v | = z * (p', q', 1)
- *               | x y w |
- *
- * The transformation can also be more explicitly written in components as
- * follows:
- *   p' = (a * p + c * q + x) / z;
- *   q' = (b * p + d * q + y) / z;
- *   z  =  u * p + v * q + w
- */
-
-/**
- * Extract the rotation component of the transformation matrix.
- *
- * @param matrix the transformation matrix
- * @return the angle (in degrees) by which the transformation rotates the frame.
- *         The angle will be in range [-180.0, 180.0], or NaN if the matrix is
- *         singular.
- *
- * @note floating point numbers are inherently inexact, so callers are
- *       recommended to round the return value to nearest integer before use.
- */
-double av_display_rotation_get(const int32_t matrix[9]);
-
-/**
- * Initialize a transformation matrix describing a pure rotation by the
- * specified angle (in degrees).
- *
- * @param matrix an allocated transformation matrix (will be fully overwritten
- *               by this function)
- * @param angle rotation angle in degrees.
- */
-void av_display_rotation_set(int32_t matrix[9], double angle);
-
-/**
- * Flip the input matrix horizontally and/or vertically.
- *
- * @param matrix an allocated transformation matrix
- * @param hflip whether the matrix should be flipped horizontally
- * @param vflip whether the matrix should be flipped vertically
- */
-void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip);
-
-#endif /* AVUTIL_DISPLAY_H */

Externals/ffmpeg/include/libavutil/downmix_info.h

@@ -1,115 +0,0 @@
-/*
- * Copyright (c) 2014 Tim Walker <tdskywalker@gmail.com>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_DOWNMIX_INFO_H
-#define AVUTIL_DOWNMIX_INFO_H
-
-#include "frame.h"
-
-/**
- * @file
- * audio downmix medatata
- */
-
-/**
- * @addtogroup lavu_audio
- * @{
- */
-
-/**
- * @defgroup downmix_info Audio downmix metadata
- * @{
- */
-
-/**
- * Possible downmix types.
- */
-enum AVDownmixType {
-    AV_DOWNMIX_TYPE_UNKNOWN, /**< Not indicated. */
-    AV_DOWNMIX_TYPE_LORO,    /**< Lo/Ro 2-channel downmix (Stereo). */
-    AV_DOWNMIX_TYPE_LTRT,    /**< Lt/Rt 2-channel downmix, Dolby Surround compatible. */
-    AV_DOWNMIX_TYPE_DPLII,   /**< Lt/Rt 2-channel downmix, Dolby Pro Logic II compatible. */
-    AV_DOWNMIX_TYPE_NB       /**< Number of downmix types. Not part of ABI. */
-};
-
-/**
- * This structure describes optional metadata relevant to a downmix procedure.
- *
- * All fields are set by the decoder to the value indicated in the audio
- * bitstream (if present), or to a "sane" default otherwise.
- */
-typedef struct AVDownmixInfo {
-    /**
-     * Type of downmix preferred by the mastering engineer.
-     */
-    enum AVDownmixType preferred_downmix_type;
-
-    /**
-     * Absolute scale factor representing the nominal level of the center
-     * channel during a regular downmix.
-     */
-    double center_mix_level;
-
-    /**
-     * Absolute scale factor representing the nominal level of the center
-     * channel during an Lt/Rt compatible downmix.
-     */
-    double center_mix_level_ltrt;
-
-    /**
-     * Absolute scale factor representing the nominal level of the surround
-     * channels during a regular downmix.
-     */
-    double surround_mix_level;
-
-    /**
-     * Absolute scale factor representing the nominal level of the surround
-     * channels during an Lt/Rt compatible downmix.
-     */
-    double surround_mix_level_ltrt;
-
-    /**
-     * Absolute scale factor representing the level at which the LFE data is
-     * mixed into L/R channels during downmixing.
-     */
-    double lfe_mix_level;
-} AVDownmixInfo;
-
-/**
- * Get a frame's AV_FRAME_DATA_DOWNMIX_INFO side data for editing.
- *
- * If the side data is absent, it is created and added to the frame.
- *
- * @param frame the frame for which the side data is to be obtained or created
- *
- * @return the AVDownmixInfo structure to be edited by the caller, or NULL if
- *         the structure cannot be allocated.
- */
-AVDownmixInfo *av_downmix_info_update_side_data(AVFrame *frame);
-
-/**
- * @}
- */
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_DOWNMIX_INFO_H */

Externals/ffmpeg/include/libavutil/error.h

@@ -1,126 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * error code definitions
- */
-
-#ifndef AVUTIL_ERROR_H
-#define AVUTIL_ERROR_H
-
-#include <errno.h>
-#include <stddef.h>
-
-/**
- * @addtogroup lavu_error
- *
- * @{
- */
-
-
-/* error handling */
-#if EDOM > 0
-#define AVERROR(e) (-(e))   ///< Returns a negative error code from a POSIX error code, to return from library functions.
-#define AVUNERROR(e) (-(e)) ///< Returns a POSIX error code from a library function error return value.
-#else
-/* Some platforms have E* and errno already negated. */
-#define AVERROR(e) (e)
-#define AVUNERROR(e) (e)
-#endif
-
-#define FFERRTAG(a, b, c, d) (-(int)MKTAG(a, b, c, d))
-
-#define AVERROR_BSF_NOT_FOUND      FFERRTAG(0xF8,'B','S','F') ///< Bitstream filter not found
-#define AVERROR_BUG                FFERRTAG( 'B','U','G','!') ///< Internal bug, also see AVERROR_BUG2
-#define AVERROR_BUFFER_TOO_SMALL   FFERRTAG( 'B','U','F','S') ///< Buffer too small
-#define AVERROR_DECODER_NOT_FOUND  FFERRTAG(0xF8,'D','E','C') ///< Decoder not found
-#define AVERROR_DEMUXER_NOT_FOUND  FFERRTAG(0xF8,'D','E','M') ///< Demuxer not found
-#define AVERROR_ENCODER_NOT_FOUND  FFERRTAG(0xF8,'E','N','C') ///< Encoder not found
-#define AVERROR_EOF                FFERRTAG( 'E','O','F',' ') ///< End of file
-#define AVERROR_EXIT               FFERRTAG( 'E','X','I','T') ///< Immediate exit was requested; the called function should not be restarted
-#define AVERROR_EXTERNAL           FFERRTAG( 'E','X','T',' ') ///< Generic error in an external library
-#define AVERROR_FILTER_NOT_FOUND   FFERRTAG(0xF8,'F','I','L') ///< Filter not found
-#define AVERROR_INVALIDDATA        FFERRTAG( 'I','N','D','A') ///< Invalid data found when processing input
-#define AVERROR_MUXER_NOT_FOUND    FFERRTAG(0xF8,'M','U','X') ///< Muxer not found
-#define AVERROR_OPTION_NOT_FOUND   FFERRTAG(0xF8,'O','P','T') ///< Option not found
-#define AVERROR_PATCHWELCOME       FFERRTAG( 'P','A','W','E') ///< Not yet implemented in FFmpeg, patches welcome
-#define AVERROR_PROTOCOL_NOT_FOUND FFERRTAG(0xF8,'P','R','O') ///< Protocol not found
-
-#define AVERROR_STREAM_NOT_FOUND   FFERRTAG(0xF8,'S','T','R') ///< Stream not found
-/**
- * This is semantically identical to AVERROR_BUG
- * it has been introduced in Libav after our AVERROR_BUG and with a modified value.
- */
-#define AVERROR_BUG2               FFERRTAG( 'B','U','G',' ')
-#define AVERROR_UNKNOWN            FFERRTAG( 'U','N','K','N') ///< Unknown error, typically from an external library
-#define AVERROR_EXPERIMENTAL       (-0x2bb2afa8) ///< Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
-#define AVERROR_INPUT_CHANGED      (-0x636e6701) ///< Input changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_OUTPUT_CHANGED)
-#define AVERROR_OUTPUT_CHANGED     (-0x636e6702) ///< Output changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_INPUT_CHANGED)
-/* HTTP & RTSP errors */
-#define AVERROR_HTTP_BAD_REQUEST   FFERRTAG(0xF8,'4','0','0')
-#define AVERROR_HTTP_UNAUTHORIZED  FFERRTAG(0xF8,'4','0','1')
-#define AVERROR_HTTP_FORBIDDEN     FFERRTAG(0xF8,'4','0','3')
-#define AVERROR_HTTP_NOT_FOUND     FFERRTAG(0xF8,'4','0','4')
-#define AVERROR_HTTP_OTHER_4XX     FFERRTAG(0xF8,'4','X','X')
-#define AVERROR_HTTP_SERVER_ERROR  FFERRTAG(0xF8,'5','X','X')
-
-#define AV_ERROR_MAX_STRING_SIZE 64
-
-/**
- * Put a description of the AVERROR code errnum in errbuf.
- * In case of failure the global variable errno is set to indicate the
- * error. Even in case of failure av_strerror() will print a generic
- * error message indicating the errnum provided to errbuf.
- *
- * @param errnum      error code to describe
- * @param errbuf      buffer to which description is written
- * @param errbuf_size the size in bytes of errbuf
- * @return 0 on success, a negative value if a description for errnum
- * cannot be found
- */
-int av_strerror(int errnum, char *errbuf, size_t errbuf_size);
-
-/**
- * Fill the provided buffer with a string containing an error string
- * corresponding to the AVERROR code errnum.
- *
- * @param errbuf         a buffer
- * @param errbuf_size    size in bytes of errbuf
- * @param errnum         error code to describe
- * @return the buffer in input, filled with the error description
- * @see av_strerror()
- */
-static inline char *av_make_error_string(char *errbuf, size_t errbuf_size, int errnum)
-{
-    av_strerror(errnum, errbuf, errbuf_size);
-    return errbuf;
-}
-
-/**
- * Convenience macro, the return value should be used only directly in
- * function arguments but never stand-alone.
- */
-#define av_err2str(errnum) \
-    av_make_error_string((char[AV_ERROR_MAX_STRING_SIZE]){0}, AV_ERROR_MAX_STRING_SIZE, errnum)
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_ERROR_H */

Externals/ffmpeg/include/libavutil/eval.h

@@ -1,113 +0,0 @@
-/*
- * Copyright (c) 2002 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * simple arithmetic expression evaluator
- */
-
-#ifndef AVUTIL_EVAL_H
-#define AVUTIL_EVAL_H
-
-#include "avutil.h"
-
-typedef struct AVExpr AVExpr;
-
-/**
- * Parse and evaluate an expression.
- * Note, this is significantly slower than av_expr_eval().
- *
- * @param res a pointer to a double where is put the result value of
- * the expression, or NAN in case of error
- * @param s expression as a zero terminated string, for example "1+2^3+5*5+sin(2/3)"
- * @param const_names NULL terminated array of zero terminated strings of constant identifiers, for example {"PI", "E", 0}
- * @param const_values a zero terminated array of values for the identifiers from const_names
- * @param func1_names NULL terminated array of zero terminated strings of funcs1 identifiers
- * @param funcs1 NULL terminated array of function pointers for functions which take 1 argument
- * @param func2_names NULL terminated array of zero terminated strings of funcs2 identifiers
- * @param funcs2 NULL terminated array of function pointers for functions which take 2 arguments
- * @param opaque a pointer which will be passed to all functions from funcs1 and funcs2
- * @param log_ctx parent logging context
- * @return >= 0 in case of success, a negative value corresponding to an
- * AVERROR code otherwise
- */
-int av_expr_parse_and_eval(double *res, const char *s,
-                           const char * const *const_names, const double *const_values,
-                           const char * const *func1_names, double (* const *funcs1)(void *, double),
-                           const char * const *func2_names, double (* const *funcs2)(void *, double, double),
-                           void *opaque, int log_offset, void *log_ctx);
-
-/**
- * Parse an expression.
- *
- * @param expr a pointer where is put an AVExpr containing the parsed
- * value in case of successful parsing, or NULL otherwise.
- * The pointed to AVExpr must be freed with av_expr_free() by the user
- * when it is not needed anymore.
- * @param s expression as a zero terminated string, for example "1+2^3+5*5+sin(2/3)"
- * @param const_names NULL terminated array of zero terminated strings of constant identifiers, for example {"PI", "E", 0}
- * @param func1_names NULL terminated array of zero terminated strings of funcs1 identifiers
- * @param funcs1 NULL terminated array of function pointers for functions which take 1 argument
- * @param func2_names NULL terminated array of zero terminated strings of funcs2 identifiers
- * @param funcs2 NULL terminated array of function pointers for functions which take 2 arguments
- * @param log_ctx parent logging context
- * @return >= 0 in case of success, a negative value corresponding to an
- * AVERROR code otherwise
- */
-int av_expr_parse(AVExpr **expr, const char *s,
-                  const char * const *const_names,
-                  const char * const *func1_names, double (* const *funcs1)(void *, double),
-                  const char * const *func2_names, double (* const *funcs2)(void *, double, double),
-                  int log_offset, void *log_ctx);
-
-/**
- * Evaluate a previously parsed expression.
- *
- * @param const_values a zero terminated array of values for the identifiers from av_expr_parse() const_names
- * @param opaque a pointer which will be passed to all functions from funcs1 and funcs2
- * @return the value of the expression
- */
-double av_expr_eval(AVExpr *e, const double *const_values, void *opaque);
-
-/**
- * Free a parsed expression previously created with av_expr_parse().
- */
-void av_expr_free(AVExpr *e);
-
-/**
- * Parse the string in numstr and return its value as a double. If
- * the string is empty, contains only whitespaces, or does not contain
- * an initial substring that has the expected syntax for a
- * floating-point number, no conversion is performed. In this case,
- * returns a value of zero and the value returned in tail is the value
- * of numstr.
- *
- * @param numstr a string representing a number, may contain one of
- * the International System number postfixes, for example 'K', 'M',
- * 'G'. If 'i' is appended after the postfix, powers of 2 are used
- * instead of powers of 10. The 'B' postfix multiplies the value for
- * 8, and can be appended after another postfix or used alone. This
- * allows using for example 'KB', 'MiB', 'G' and 'B' as postfix.
- * @param tail if non-NULL puts here the pointer to the char next
- * after the last parsed character
- */
-double av_strtod(const char *numstr, char **tail);
-
-#endif /* AVUTIL_EVAL_H */

Externals/ffmpeg/include/libavutil/ffversion.h

@@ -1,4 +0,0 @@
-#ifndef AVUTIL_FFVERSION_H
-#define AVUTIL_FFVERSION_H
-#define FFMPEG_VERSION "git-2015-01-25-04d6e3e"
-#endif /* AVUTIL_FFVERSION_H */

Externals/ffmpeg/include/libavutil/fifo.h

@@ -1,158 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * a very simple circular buffer FIFO implementation
- */
-
-#ifndef AVUTIL_FIFO_H
-#define AVUTIL_FIFO_H
-
-#include <stdint.h>
-#include "avutil.h"
-#include "attributes.h"
-
-typedef struct AVFifoBuffer {
-    uint8_t *buffer;
-    uint8_t *rptr, *wptr, *end;
-    uint32_t rndx, wndx;
-} AVFifoBuffer;
-
-/**
- * Initialize an AVFifoBuffer.
- * @param size of FIFO
- * @return AVFifoBuffer or NULL in case of memory allocation failure
- */
-AVFifoBuffer *av_fifo_alloc(unsigned int size);
-
-/**
- * Initialize an AVFifoBuffer.
- * @param nmemb number of elements
- * @param size  size of the single element
- * @return AVFifoBuffer or NULL in case of memory allocation failure
- */
-AVFifoBuffer *av_fifo_alloc_array(size_t nmemb, size_t size);
-
-/**
- * Free an AVFifoBuffer.
- * @param f AVFifoBuffer to free
- */
-void av_fifo_free(AVFifoBuffer *f);
-
-/**
- * Free an AVFifoBuffer and reset pointer to NULL.
- * @param f AVFifoBuffer to free
- */
-void av_fifo_freep(AVFifoBuffer **f);
-
-/**
- * Reset the AVFifoBuffer to the state right after av_fifo_alloc, in particular it is emptied.
- * @param f AVFifoBuffer to reset
- */
-void av_fifo_reset(AVFifoBuffer *f);
-
-/**
- * Return the amount of data in bytes in the AVFifoBuffer, that is the
- * amount of data you can read from it.
- * @param f AVFifoBuffer to read from
- * @return size
- */
-int av_fifo_size(const AVFifoBuffer *f);
-
-/**
- * Return the amount of space in bytes in the AVFifoBuffer, that is the
- * amount of data you can write into it.
- * @param f AVFifoBuffer to write into
- * @return size
- */
-int av_fifo_space(const AVFifoBuffer *f);
-
-/**
- * Feed data from an AVFifoBuffer to a user-supplied callback.
- * @param f AVFifoBuffer to read from
- * @param buf_size number of bytes to read
- * @param func generic read function
- * @param dest data destination
- */
-int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int));
-
-/**
- * Feed data from a user-supplied callback to an AVFifoBuffer.
- * @param f AVFifoBuffer to write to
- * @param src data source; non-const since it may be used as a
- * modifiable context by the function defined in func
- * @param size number of bytes to write
- * @param func generic write function; the first parameter is src,
- * the second is dest_buf, the third is dest_buf_size.
- * func must return the number of bytes written to dest_buf, or <= 0 to
- * indicate no more data available to write.
- * If func is NULL, src is interpreted as a simple byte array for source data.
- * @return the number of bytes written to the FIFO
- */
-int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void*, void*, int));
-
-/**
- * Resize an AVFifoBuffer.
- * In case of reallocation failure, the old FIFO is kept unchanged.
- *
- * @param f AVFifoBuffer to resize
- * @param size new AVFifoBuffer size in bytes
- * @return <0 for failure, >=0 otherwise
- */
-int av_fifo_realloc2(AVFifoBuffer *f, unsigned int size);
-
-/**
- * Enlarge an AVFifoBuffer.
- * In case of reallocation failure, the old FIFO is kept unchanged.
- * The new fifo size may be larger than the requested size.
- *
- * @param f AVFifoBuffer to resize
- * @param additional_space the amount of space in bytes to allocate in addition to av_fifo_size()
- * @return <0 for failure, >=0 otherwise
- */
-int av_fifo_grow(AVFifoBuffer *f, unsigned int additional_space);
-
-/**
- * Read and discard the specified amount of data from an AVFifoBuffer.
- * @param f AVFifoBuffer to read from
- * @param size amount of data to read in bytes
- */
-void av_fifo_drain(AVFifoBuffer *f, int size);
-
-/**
- * Return a pointer to the data stored in a FIFO buffer at a certain offset.
- * The FIFO buffer is not modified.
- *
- * @param f    AVFifoBuffer to peek at, f must be non-NULL
- * @param offs an offset in bytes, its absolute value must be less
- *             than the used buffer size or the returned pointer will
- *             point outside to the buffer data.
- *             The used buffer size can be checked with av_fifo_size().
- */
-static inline uint8_t *av_fifo_peek2(const AVFifoBuffer *f, int offs)
-{
-    uint8_t *ptr = f->rptr + offs;
-    if (ptr >= f->end)
-        ptr = f->buffer + (ptr - f->end);
-    else if (ptr < f->buffer)
-        ptr = f->end - (f->buffer - ptr);
-    return ptr;
-}
-
-#endif /* AVUTIL_FIFO_H */

Externals/ffmpeg/include/libavutil/file.h

@@ -1,67 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_FILE_H
-#define AVUTIL_FILE_H
-
-#include <stdint.h>
-
-#include "avutil.h"
-
-/**
- * @file
- * Misc file utilities.
- */
-
-/**
- * Read the file with name filename, and put its content in a newly
- * allocated buffer or map it with mmap() when available.
- * In case of success set *bufptr to the read or mmapped buffer, and
- * *size to the size in bytes of the buffer in *bufptr.
- * The returned buffer must be released with av_file_unmap().
- *
- * @param log_offset loglevel offset used for logging
- * @param log_ctx context used for logging
- * @return a non negative number in case of success, a negative value
- * corresponding to an AVERROR error code in case of failure
- */
-int av_file_map(const char *filename, uint8_t **bufptr, size_t *size,
-                int log_offset, void *log_ctx);
-
-/**
- * Unmap or free the buffer bufptr created by av_file_map().
- *
- * @param size size in bytes of bufptr, must be the same as returned
- * by av_file_map()
- */
-void av_file_unmap(uint8_t *bufptr, size_t size);
-
-/**
- * Wrapper to work around the lack of mkstemp() on mingw.
- * Also, tries to create file in /tmp first, if possible.
- * *prefix can be a character constant; *filename will be allocated internally.
- * @return file descriptor of opened file (or negative value corresponding to an
- * AVERROR code on error)
- * and opened file name in **filename.
- * @note On very old libcs it is necessary to set a secure umask before
- *       calling this, av_tempfile() can't call umask itself as it is used in
- *       libraries and could interfere with the calling application.
- */
-int av_tempfile(const char *prefix, char **filename, int log_offset, void *log_ctx);
-
-#endif /* AVUTIL_FILE_H */

Externals/ffmpeg/include/libavutil/frame.h

@@ -1,771 +0,0 @@
-/*
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @ingroup lavu_frame
- * reference-counted frame API
- */
-
-#ifndef AVUTIL_FRAME_H
-#define AVUTIL_FRAME_H
-
-#include <stdint.h>
-
-#include "avutil.h"
-#include "buffer.h"
-#include "dict.h"
-#include "rational.h"
-#include "samplefmt.h"
-#include "pixfmt.h"
-#include "version.h"
-
-
-/**
- * @defgroup lavu_frame AVFrame
- * @ingroup lavu_data
- *
- * @{
- * AVFrame is an abstraction for reference-counted raw multimedia data.
- */
-
-enum AVFrameSideDataType {
-    /**
-     * The data is the AVPanScan struct defined in libavcodec.
-     */
-    AV_FRAME_DATA_PANSCAN,
-    /**
-     * ATSC A53 Part 4 Closed Captions.
-     * A53 CC bitstream is stored as uint8_t in AVFrameSideData.data.
-     * The number of bytes of CC data is AVFrameSideData.size.
-     */
-    AV_FRAME_DATA_A53_CC,
-    /**
-     * Stereoscopic 3d metadata.
-     * The data is the AVStereo3D struct defined in libavutil/stereo3d.h.
-     */
-    AV_FRAME_DATA_STEREO3D,
-    /**
-     * The data is the AVMatrixEncoding enum defined in libavutil/channel_layout.h.
-     */
-    AV_FRAME_DATA_MATRIXENCODING,
-    /**
-     * Metadata relevant to a downmix procedure.
-     * The data is the AVDownmixInfo struct defined in libavutil/downmix_info.h.
-     */
-    AV_FRAME_DATA_DOWNMIX_INFO,
-    /**
-     * ReplayGain information in the form of the AVReplayGain struct.
-     */
-    AV_FRAME_DATA_REPLAYGAIN,
-    /**
-     * This side data contains a 3x3 transformation matrix describing an affine
-     * transformation that needs to be applied to the frame for correct
-     * presentation.
-     *
-     * See libavutil/display.h for a detailed description of the data.
-     */
-    AV_FRAME_DATA_DISPLAYMATRIX,
-    /**
-     * Active Format Description data consisting of a single byte as specified
-     * in ETSI TS 101 154 using AVActiveFormatDescription enum.
-     */
-    AV_FRAME_DATA_AFD,
-    /**
-     * Motion vectors exported by some codecs (on demand through the export_mvs
-     * flag set in the libavcodec AVCodecContext flags2 option).
-     * The data is the AVMotionVector struct defined in
-     * libavutil/motion_vector.h.
-     */
-    AV_FRAME_DATA_MOTION_VECTORS,
-    /**
-     * Recommmends skipping the specified number of samples. This is exported
-     * only if the "skip_manual" AVOption is set in libavcodec.
-     * This has the same format as AV_PKT_DATA_SKIP_SAMPLES.
-     * @code
-     * u32le number of samples to skip from start of this packet
-     * u32le number of samples to skip from end of this packet
-     * u8    reason for start skip
-     * u8    reason for end   skip (0=padding silence, 1=convergence)
-     * @endcode
-     */
-    AV_FRAME_DATA_SKIP_SAMPLES,
-};
-
-enum AVActiveFormatDescription {
-    AV_AFD_SAME         = 8,
-    AV_AFD_4_3          = 9,
-    AV_AFD_16_9         = 10,
-    AV_AFD_14_9         = 11,
-    AV_AFD_4_3_SP_14_9  = 13,
-    AV_AFD_16_9_SP_14_9 = 14,
-    AV_AFD_SP_4_3       = 15,
-};
-
-typedef struct AVFrameSideData {
-    enum AVFrameSideDataType type;
-    uint8_t *data;
-    int      size;
-    AVDictionary *metadata;
-} AVFrameSideData;
-
-/**
- * This structure describes decoded (raw) audio or video data.
- *
- * AVFrame must be allocated using av_frame_alloc(). Note that this only
- * allocates the AVFrame itself, the buffers for the data must be managed
- * through other means (see below).
- * AVFrame must be freed with av_frame_free().
- *
- * AVFrame is typically allocated once and then reused multiple times to hold
- * different data (e.g. a single AVFrame to hold frames received from a
- * decoder). In such a case, av_frame_unref() will free any references held by
- * the frame and reset it to its original clean state before it
- * is reused again.
- *
- * The data described by an AVFrame is usually reference counted through the
- * AVBuffer API. The underlying buffer references are stored in AVFrame.buf /
- * AVFrame.extended_buf. An AVFrame is considered to be reference counted if at
- * least one reference is set, i.e. if AVFrame.buf[0] != NULL. In such a case,
- * every single data plane must be contained in one of the buffers in
- * AVFrame.buf or AVFrame.extended_buf.
- * There may be a single buffer for all the data, or one separate buffer for
- * each plane, or anything in between.
- *
- * sizeof(AVFrame) is not a part of the public ABI, so new fields may be added
- * to the end with a minor bump.
- * Similarly fields that are marked as to be only accessed by
- * av_opt_ptr() can be reordered. This allows 2 forks to add fields
- * without breaking compatibility with each other.
- */
-typedef struct AVFrame {
-#define AV_NUM_DATA_POINTERS 8
-    /**
-     * pointer to the picture/channel planes.
-     * This might be different from the first allocated byte
-     *
-     * Some decoders access areas outside 0,0 - width,height, please
-     * see avcodec_align_dimensions2(). Some filters and swscale can read
-     * up to 16 bytes beyond the planes, if these filters are to be used,
-     * then 16 extra bytes must be allocated.
-     */
-    uint8_t *data[AV_NUM_DATA_POINTERS];
-
-    /**
-     * For video, size in bytes of each picture line.
-     * For audio, size in bytes of each plane.
-     *
-     * For audio, only linesize[0] may be set. For planar audio, each channel
-     * plane must be the same size.
-     *
-     * For video the linesizes should be multiples of the CPUs alignment
-     * preference, this is 16 or 32 for modern desktop CPUs.
-     * Some code requires such alignment other code can be slower without
-     * correct alignment, for yet other it makes no difference.
-     *
-     * @note The linesize may be larger than the size of usable data -- there
-     * may be extra padding present for performance reasons.
-     */
-    int linesize[AV_NUM_DATA_POINTERS];
-
-    /**
-     * pointers to the data planes/channels.
-     *
-     * For video, this should simply point to data[].
-     *
-     * For planar audio, each channel has a separate data pointer, and
-     * linesize[0] contains the size of each channel buffer.
-     * For packed audio, there is just one data pointer, and linesize[0]
-     * contains the total size of the buffer for all channels.
-     *
-     * Note: Both data and extended_data should always be set in a valid frame,
-     * but for planar audio with more channels that can fit in data,
-     * extended_data must be used in order to access all channels.
-     */
-    uint8_t **extended_data;
-
-    /**
-     * width and height of the video frame
-     */
-    int width, height;
-
-    /**
-     * number of audio samples (per channel) described by this frame
-     */
-    int nb_samples;
-
-    /**
-     * format of the frame, -1 if unknown or unset
-     * Values correspond to enum AVPixelFormat for video frames,
-     * enum AVSampleFormat for audio)
-     */
-    int format;
-
-    /**
-     * 1 -> keyframe, 0-> not
-     */
-    int key_frame;
-
-    /**
-     * Picture type of the frame.
-     */
-    enum AVPictureType pict_type;
-
-#if FF_API_AVFRAME_LAVC
-    attribute_deprecated
-    uint8_t *base[AV_NUM_DATA_POINTERS];
-#endif
-
-    /**
-     * Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
-     */
-    AVRational sample_aspect_ratio;
-
-    /**
-     * Presentation timestamp in time_base units (time when frame should be shown to user).
-     */
-    int64_t pts;
-
-    /**
-     * PTS copied from the AVPacket that was decoded to produce this frame.
-     */
-    int64_t pkt_pts;
-
-    /**
-     * DTS copied from the AVPacket that triggered returning this frame. (if frame threading isn't used)
-     * This is also the Presentation time of this AVFrame calculated from
-     * only AVPacket.dts values without pts values.
-     */
-    int64_t pkt_dts;
-
-    /**
-     * picture number in bitstream order
-     */
-    int coded_picture_number;
-    /**
-     * picture number in display order
-     */
-    int display_picture_number;
-
-    /**
-     * quality (between 1 (good) and FF_LAMBDA_MAX (bad))
-     */
-    int quality;
-
-#if FF_API_AVFRAME_LAVC
-    attribute_deprecated
-    int reference;
-
-    /**
-     * QP table
-     */
-    attribute_deprecated
-    int8_t *qscale_table;
-    /**
-     * QP store stride
-     */
-    attribute_deprecated
-    int qstride;
-
-    attribute_deprecated
-    int qscale_type;
-
-    /**
-     * mbskip_table[mb]>=1 if MB didn't change
-     * stride= mb_width = (width+15)>>4
-     */
-    attribute_deprecated
-    uint8_t *mbskip_table;
-
-    /**
-     * motion vector table
-     * @code
-     * example:
-     * int mv_sample_log2= 4 - motion_subsample_log2;
-     * int mb_width= (width+15)>>4;
-     * int mv_stride= (mb_width << mv_sample_log2) + 1;
-     * motion_val[direction][x + y*mv_stride][0->mv_x, 1->mv_y];
-     * @endcode
-     */
-    int16_t (*motion_val[2])[2];
-
-    /**
-     * macroblock type table
-     * mb_type_base + mb_width + 2
-     */
-    attribute_deprecated
-    uint32_t *mb_type;
-
-    /**
-     * DCT coefficients
-     */
-    attribute_deprecated
-    short *dct_coeff;
-
-    /**
-     * motion reference frame index
-     * the order in which these are stored can depend on the codec.
-     */
-    attribute_deprecated
-    int8_t *ref_index[2];
-#endif
-
-    /**
-     * for some private data of the user
-     */
-    void *opaque;
-
-    /**
-     * error
-     */
-    uint64_t error[AV_NUM_DATA_POINTERS];
-
-#if FF_API_AVFRAME_LAVC
-    attribute_deprecated
-    int type;
-#endif
-
-    /**
-     * When decoding, this signals how much the picture must be delayed.
-     * extra_delay = repeat_pict / (2*fps)
-     */
-    int repeat_pict;
-
-    /**
-     * The content of the picture is interlaced.
-     */
-    int interlaced_frame;
-
-    /**
-     * If the content is interlaced, is top field displayed first.
-     */
-    int top_field_first;
-
-    /**
-     * Tell user application that palette has changed from previous frame.
-     */
-    int palette_has_changed;
-
-#if FF_API_AVFRAME_LAVC
-    attribute_deprecated
-    int buffer_hints;
-
-    /**
-     * Pan scan.
-     */
-    attribute_deprecated
-    struct AVPanScan *pan_scan;
-#endif
-
-    /**
-     * reordered opaque 64bit (generally an integer or a double precision float
-     * PTS but can be anything).
-     * The user sets AVCodecContext.reordered_opaque to represent the input at
-     * that time,
-     * the decoder reorders values as needed and sets AVFrame.reordered_opaque
-     * to exactly one of the values provided by the user through AVCodecContext.reordered_opaque
-     * @deprecated in favor of pkt_pts
-     */
-    int64_t reordered_opaque;
-
-#if FF_API_AVFRAME_LAVC
-    /**
-     * @deprecated this field is unused
-     */
-    attribute_deprecated void *hwaccel_picture_private;
-
-    attribute_deprecated
-    struct AVCodecContext *owner;
-    attribute_deprecated
-    void *thread_opaque;
-
-    /**
-     * log2 of the size of the block which a single vector in motion_val represents:
-     * (4->16x16, 3->8x8, 2-> 4x4, 1-> 2x2)
-     */
-    uint8_t motion_subsample_log2;
-#endif
-
-    /**
-     * Sample rate of the audio data.
-     */
-    int sample_rate;
-
-    /**
-     * Channel layout of the audio data.
-     */
-    uint64_t channel_layout;
-
-    /**
-     * AVBuffer references backing the data for this frame. If all elements of
-     * this array are NULL, then this frame is not reference counted.
-     *
-     * There may be at most one AVBuffer per data plane, so for video this array
-     * always contains all the references. For planar audio with more than
-     * AV_NUM_DATA_POINTERS channels, there may be more buffers than can fit in
-     * this array. Then the extra AVBufferRef pointers are stored in the
-     * extended_buf array.
-     */
-    AVBufferRef *buf[AV_NUM_DATA_POINTERS];
-
-    /**
-     * For planar audio which requires more than AV_NUM_DATA_POINTERS
-     * AVBufferRef pointers, this array will hold all the references which
-     * cannot fit into AVFrame.buf.
-     *
-     * Note that this is different from AVFrame.extended_data, which always
-     * contains all the pointers. This array only contains the extra pointers,
-     * which cannot fit into AVFrame.buf.
-     *
-     * This array is always allocated using av_malloc() by whoever constructs
-     * the frame. It is freed in av_frame_unref().
-     */
-    AVBufferRef **extended_buf;
-    /**
-     * Number of elements in extended_buf.
-     */
-    int        nb_extended_buf;
-
-    AVFrameSideData **side_data;
-    int            nb_side_data;
-
-/**
- * @defgroup lavu_frame_flags AV_FRAME_FLAGS
- * Flags describing additional frame properties.
- *
- * @{
- */
-
-/**
- * The frame data may be corrupted, e.g. due to decoding errors.
- */
-#define AV_FRAME_FLAG_CORRUPT       (1 << 0)
-/**
- * @}
- */
-
-    /**
-     * Frame flags, a combination of @ref lavu_frame_flags
-     */
-    int flags;
-
-    /**
-     * MPEG vs JPEG YUV range.
-     * It must be accessed using av_frame_get_color_range() and
-     * av_frame_set_color_range().
-     * - encoding: Set by user
-     * - decoding: Set by libavcodec
-     */
-    enum AVColorRange color_range;
-
-    enum AVColorPrimaries color_primaries;
-
-    enum AVColorTransferCharacteristic color_trc;
-
-    /**
-     * YUV colorspace type.
-     * It must be accessed using av_frame_get_colorspace() and
-     * av_frame_set_colorspace().
-     * - encoding: Set by user
-     * - decoding: Set by libavcodec
-     */
-    enum AVColorSpace colorspace;
-
-    enum AVChromaLocation chroma_location;
-
-    /**
-     * frame timestamp estimated using various heuristics, in stream time base
-     * Code outside libavcodec should access this field using:
-     * av_frame_get_best_effort_timestamp(frame)
-     * - encoding: unused
-     * - decoding: set by libavcodec, read by user.
-     */
-    int64_t best_effort_timestamp;
-
-    /**
-     * reordered pos from the last AVPacket that has been input into the decoder
-     * Code outside libavcodec should access this field using:
-     * av_frame_get_pkt_pos(frame)
-     * - encoding: unused
-     * - decoding: Read by user.
-     */
-    int64_t pkt_pos;
-
-    /**
-     * duration of the corresponding packet, expressed in
-     * AVStream->time_base units, 0 if unknown.
-     * Code outside libavcodec should access this field using:
-     * av_frame_get_pkt_duration(frame)
-     * - encoding: unused
-     * - decoding: Read by user.
-     */
-    int64_t pkt_duration;
-
-    /**
-     * metadata.
-     * Code outside libavcodec should access this field using:
-     * av_frame_get_metadata(frame)
-     * - encoding: Set by user.
-     * - decoding: Set by libavcodec.
-     */
-    AVDictionary *metadata;
-
-    /**
-     * decode error flags of the frame, set to a combination of
-     * FF_DECODE_ERROR_xxx flags if the decoder produced a frame, but there
-     * were errors during the decoding.
-     * Code outside libavcodec should access this field using:
-     * av_frame_get_decode_error_flags(frame)
-     * - encoding: unused
-     * - decoding: set by libavcodec, read by user.
-     */
-    int decode_error_flags;
-#define FF_DECODE_ERROR_INVALID_BITSTREAM   1
-#define FF_DECODE_ERROR_MISSING_REFERENCE   2
-
-    /**
-     * number of audio channels, only used for audio.
-     * Code outside libavcodec should access this field using:
-     * av_frame_get_channels(frame)
-     * - encoding: unused
-     * - decoding: Read by user.
-     */
-    int channels;
-
-    /**
-     * size of the corresponding packet containing the compressed
-     * frame. It must be accessed using av_frame_get_pkt_size() and
-     * av_frame_set_pkt_size().
-     * It is set to a negative value if unknown.
-     * - encoding: unused
-     * - decoding: set by libavcodec, read by user.
-     */
-    int pkt_size;
-
-    /**
-     * Not to be accessed directly from outside libavutil
-     */
-    AVBufferRef *qp_table_buf;
-} AVFrame;
-
-/**
- * Accessors for some AVFrame fields.
- * The position of these field in the structure is not part of the ABI,
- * they should not be accessed directly outside libavcodec.
- */
-int64_t av_frame_get_best_effort_timestamp(const AVFrame *frame);
-void    av_frame_set_best_effort_timestamp(AVFrame *frame, int64_t val);
-int64_t av_frame_get_pkt_duration         (const AVFrame *frame);
-void    av_frame_set_pkt_duration         (AVFrame *frame, int64_t val);
-int64_t av_frame_get_pkt_pos              (const AVFrame *frame);
-void    av_frame_set_pkt_pos              (AVFrame *frame, int64_t val);
-int64_t av_frame_get_channel_layout       (const AVFrame *frame);
-void    av_frame_set_channel_layout       (AVFrame *frame, int64_t val);
-int     av_frame_get_channels             (const AVFrame *frame);
-void    av_frame_set_channels             (AVFrame *frame, int     val);
-int     av_frame_get_sample_rate          (const AVFrame *frame);
-void    av_frame_set_sample_rate          (AVFrame *frame, int     val);
-AVDictionary *av_frame_get_metadata       (const AVFrame *frame);
-void          av_frame_set_metadata       (AVFrame *frame, AVDictionary *val);
-int     av_frame_get_decode_error_flags   (const AVFrame *frame);
-void    av_frame_set_decode_error_flags   (AVFrame *frame, int     val);
-int     av_frame_get_pkt_size(const AVFrame *frame);
-void    av_frame_set_pkt_size(AVFrame *frame, int val);
-AVDictionary **avpriv_frame_get_metadatap(AVFrame *frame);
-int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type);
-int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int type);
-enum AVColorSpace av_frame_get_colorspace(const AVFrame *frame);
-void    av_frame_set_colorspace(AVFrame *frame, enum AVColorSpace val);
-enum AVColorRange av_frame_get_color_range(const AVFrame *frame);
-void    av_frame_set_color_range(AVFrame *frame, enum AVColorRange val);
-
-/**
- * Get the name of a colorspace.
- * @return a static string identifying the colorspace; can be NULL.
- */
-const char *av_get_colorspace_name(enum AVColorSpace val);
-
-/**
- * Allocate an AVFrame and set its fields to default values.  The resulting
- * struct must be freed using av_frame_free().
- *
- * @return An AVFrame filled with default values or NULL on failure.
- *
- * @note this only allocates the AVFrame itself, not the data buffers. Those
- * must be allocated through other means, e.g. with av_frame_get_buffer() or
- * manually.
- */
-AVFrame *av_frame_alloc(void);
-
-/**
- * Free the frame and any dynamically allocated objects in it,
- * e.g. extended_data. If the frame is reference counted, it will be
- * unreferenced first.
- *
- * @param frame frame to be freed. The pointer will be set to NULL.
- */
-void av_frame_free(AVFrame **frame);
-
-/**
- * Set up a new reference to the data described by the source frame.
- *
- * Copy frame properties from src to dst and create a new reference for each
- * AVBufferRef from src.
- *
- * If src is not reference counted, new buffers are allocated and the data is
- * copied.
- *
- * @return 0 on success, a negative AVERROR on error
- */
-int av_frame_ref(AVFrame *dst, const AVFrame *src);
-
-/**
- * Create a new frame that references the same data as src.
- *
- * This is a shortcut for av_frame_alloc()+av_frame_ref().
- *
- * @return newly created AVFrame on success, NULL on error.
- */
-AVFrame *av_frame_clone(const AVFrame *src);
-
-/**
- * Unreference all the buffers referenced by frame and reset the frame fields.
- */
-void av_frame_unref(AVFrame *frame);
-
-/**
- * Move everythnig contained in src to dst and reset src.
- */
-void av_frame_move_ref(AVFrame *dst, AVFrame *src);
-
-/**
- * Allocate new buffer(s) for audio or video data.
- *
- * The following fields must be set on frame before calling this function:
- * - format (pixel format for video, sample format for audio)
- * - width and height for video
- * - nb_samples and channel_layout for audio
- *
- * This function will fill AVFrame.data and AVFrame.buf arrays and, if
- * necessary, allocate and fill AVFrame.extended_data and AVFrame.extended_buf.
- * For planar formats, one buffer will be allocated for each plane.
- *
- * @param frame frame in which to store the new buffers.
- * @param align required buffer size alignment
- *
- * @return 0 on success, a negative AVERROR on error.
- */
-int av_frame_get_buffer(AVFrame *frame, int align);
-
-/**
- * Check if the frame data is writable.
- *
- * @return A positive value if the frame data is writable (which is true if and
- * only if each of the underlying buffers has only one reference, namely the one
- * stored in this frame). Return 0 otherwise.
- *
- * If 1 is returned the answer is valid until av_buffer_ref() is called on any
- * of the underlying AVBufferRefs (e.g. through av_frame_ref() or directly).
- *
- * @see av_frame_make_writable(), av_buffer_is_writable()
- */
-int av_frame_is_writable(AVFrame *frame);
-
-/**
- * Ensure that the frame data is writable, avoiding data copy if possible.
- *
- * Do nothing if the frame is writable, allocate new buffers and copy the data
- * if it is not.
- *
- * @return 0 on success, a negative AVERROR on error.
- *
- * @see av_frame_is_writable(), av_buffer_is_writable(),
- * av_buffer_make_writable()
- */
-int av_frame_make_writable(AVFrame *frame);
-
-/**
- * Copy the frame data from src to dst.
- *
- * This function does not allocate anything, dst must be already initialized and
- * allocated with the same parameters as src.
- *
- * This function only copies the frame data (i.e. the contents of the data /
- * extended data arrays), not any other properties.
- *
- * @return >= 0 on success, a negative AVERROR on error.
- */
-int av_frame_copy(AVFrame *dst, const AVFrame *src);
-
-/**
- * Copy only "metadata" fields from src to dst.
- *
- * Metadata for the purpose of this function are those fields that do not affect
- * the data layout in the buffers.  E.g. pts, sample rate (for audio) or sample
- * aspect ratio (for video), but not width/height or channel layout.
- * Side data is also copied.
- */
-int av_frame_copy_props(AVFrame *dst, const AVFrame *src);
-
-/**
- * Get the buffer reference a given data plane is stored in.
- *
- * @param plane index of the data plane of interest in frame->extended_data.
- *
- * @return the buffer reference that contains the plane or NULL if the input
- * frame is not valid.
- */
-AVBufferRef *av_frame_get_plane_buffer(AVFrame *frame, int plane);
-
-/**
- * Add a new side data to a frame.
- *
- * @param frame a frame to which the side data should be added
- * @param type type of the added side data
- * @param size size of the side data
- *
- * @return newly added side data on success, NULL on error
- */
-AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
-                                        enum AVFrameSideDataType type,
-                                        int size);
-
-/**
- * @return a pointer to the side data of a given type on success, NULL if there
- * is no side data with such type in this frame.
- */
-AVFrameSideData *av_frame_get_side_data(const AVFrame *frame,
-                                        enum AVFrameSideDataType type);
-
-/**
- * If side data of the supplied type exists in the frame, free it and remove it
- * from the frame.
- */
-void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type);
-
-/**
- * @return a string identifying the side data type
- */
-const char *av_frame_side_data_name(enum AVFrameSideDataType type);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_FRAME_H */

Externals/ffmpeg/include/libavutil/hash.h

@@ -1,112 +0,0 @@
-/*
- * Copyright (C) 2013 Reimar Döffinger <Reimar.Doeffinger@gmx.de>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_HASH_H
-#define AVUTIL_HASH_H
-
-#include <stdint.h>
-
-struct AVHashContext;
-
-/**
- * Allocate a hash context for the algorithm specified by name.
- *
- * @return  >= 0 for success, a negative error code for failure
- * @note  The context is not initialized, you must call av_hash_init().
- */
-int av_hash_alloc(struct AVHashContext **ctx, const char *name);
-
-/**
- * Get the names of available hash algorithms.
- *
- * This function can be used to enumerate the algorithms.
- *
- * @param i  index of the hash algorithm, starting from 0
- * @return   a pointer to a static string or NULL if i is out of range
- */
-const char *av_hash_names(int i);
-
-/**
- * Get the name of the algorithm corresponding to the given hash context.
- */
-const char *av_hash_get_name(const struct AVHashContext *ctx);
-
-/**
- * Maximum value that av_hash_get_size will currently return.
- *
- * You can use this if you absolutely want or need to use static allocation
- * and are fine with not supporting hashes newly added to libavutil without
- * recompilation.
- * Note that you still need to check against av_hash_get_size, adding new hashes
- * with larger sizes will not be considered an ABI change and should not cause
- * your code to overflow a buffer.
- */
-#define AV_HASH_MAX_SIZE 64
-
-/**
- * Get the size of the resulting hash value in bytes.
- *
- * The pointer passed to av_hash_final have space for at least this many bytes.
- */
-int av_hash_get_size(const struct AVHashContext *ctx);
-
-/**
- * Initialize or reset a hash context.
- */
-void av_hash_init(struct AVHashContext *ctx);
-
-/**
- * Update a hash context with additional data.
- */
-void av_hash_update(struct AVHashContext *ctx, const uint8_t *src, int len);
-
-/**
- * Finalize a hash context and compute the actual hash value.
- */
-void av_hash_final(struct AVHashContext *ctx, uint8_t *dst);
-
-/**
- * Finalize a hash context and compute the actual hash value.
- * If size is smaller than the hash size, the hash is truncated;
- * if size is larger, the buffer is padded with 0.
- */
-void av_hash_final_bin(struct AVHashContext *ctx, uint8_t *dst, int size);
-
-/**
- * Finalize a hash context and compute the actual hash value as a hex string.
- * The string is always 0-terminated.
- * If size is smaller than 2 * hash_size + 1, the hex string is truncated.
- */
-void av_hash_final_hex(struct AVHashContext *ctx, uint8_t *dst, int size);
-
-/**
- * Finalize a hash context and compute the actual hash value as a base64 string.
- * The string is always 0-terminated.
- * If size is smaller than AV_BASE64_SIZE(hash_size), the base64 string is
- * truncated.
- */
-void av_hash_final_b64(struct AVHashContext *ctx, uint8_t *dst, int size);
-
-/**
- * Free hash context.
- */
-void av_hash_freep(struct AVHashContext **ctx);
-
-#endif /* AVUTIL_HASH_H */

Externals/ffmpeg/include/libavutil/hmac.h

@@ -1,99 +0,0 @@
-/*
- * Copyright (C) 2012 Martin Storsjo
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_HMAC_H
-#define AVUTIL_HMAC_H
-
-#include <stdint.h>
-
-/**
- * @defgroup lavu_hmac HMAC
- * @ingroup lavu_crypto
- * @{
- */
-
-enum AVHMACType {
-    AV_HMAC_MD5,
-    AV_HMAC_SHA1,
-    AV_HMAC_SHA224 = 10,
-    AV_HMAC_SHA256,
-    AV_HMAC_SHA384,
-    AV_HMAC_SHA512,
-};
-
-typedef struct AVHMAC AVHMAC;
-
-/**
- * Allocate an AVHMAC context.
- * @param type The hash function used for the HMAC.
- */
-AVHMAC *av_hmac_alloc(enum AVHMACType type);
-
-/**
- * Free an AVHMAC context.
- * @param ctx The context to free, may be NULL
- */
-void av_hmac_free(AVHMAC *ctx);
-
-/**
- * Initialize an AVHMAC context with an authentication key.
- * @param ctx    The HMAC context
- * @param key    The authentication key
- * @param keylen The length of the key, in bytes
- */
-void av_hmac_init(AVHMAC *ctx, const uint8_t *key, unsigned int keylen);
-
-/**
- * Hash data with the HMAC.
- * @param ctx  The HMAC context
- * @param data The data to hash
- * @param len  The length of the data, in bytes
- */
-void av_hmac_update(AVHMAC *ctx, const uint8_t *data, unsigned int len);
-
-/**
- * Finish hashing and output the HMAC digest.
- * @param ctx    The HMAC context
- * @param out    The output buffer to write the digest into
- * @param outlen The length of the out buffer, in bytes
- * @return       The number of bytes written to out, or a negative error code.
- */
-int av_hmac_final(AVHMAC *ctx, uint8_t *out, unsigned int outlen);
-
-/**
- * Hash an array of data with a key.
- * @param ctx    The HMAC context
- * @param data   The data to hash
- * @param len    The length of the data, in bytes
- * @param key    The authentication key
- * @param keylen The length of the key, in bytes
- * @param out    The output buffer to write the digest into
- * @param outlen The length of the out buffer, in bytes
- * @return       The number of bytes written to out, or a negative error code.
- */
-int av_hmac_calc(AVHMAC *ctx, const uint8_t *data, unsigned int len,
-                 const uint8_t *key, unsigned int keylen,
-                 uint8_t *out, unsigned int outlen);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_HMAC_H */

Externals/ffmpeg/include/libavutil/imgutils.h

@@ -1,213 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_IMGUTILS_H
-#define AVUTIL_IMGUTILS_H
-
-/**
- * @file
- * misc image utilities
- *
- * @addtogroup lavu_picture
- * @{
- */
-
-#include "avutil.h"
-#include "pixdesc.h"
-#include "rational.h"
-
-/**
- * Compute the max pixel step for each plane of an image with a
- * format described by pixdesc.
- *
- * The pixel step is the distance in bytes between the first byte of
- * the group of bytes which describe a pixel component and the first
- * byte of the successive group in the same plane for the same
- * component.
- *
- * @param max_pixsteps an array which is filled with the max pixel step
- * for each plane. Since a plane may contain different pixel
- * components, the computed max_pixsteps[plane] is relative to the
- * component in the plane with the max pixel step.
- * @param max_pixstep_comps an array which is filled with the component
- * for each plane which has the max pixel step. May be NULL.
- */
-void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4],
-                                const AVPixFmtDescriptor *pixdesc);
-
-/**
- * Compute the size of an image line with format pix_fmt and width
- * width for the plane plane.
- *
- * @return the computed size in bytes
- */
-int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane);
-
-/**
- * Fill plane linesizes for an image with pixel format pix_fmt and
- * width width.
- *
- * @param linesizes array to be filled with the linesize for each plane
- * @return >= 0 in case of success, a negative error code otherwise
- */
-int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width);
-
-/**
- * Fill plane data pointers for an image with pixel format pix_fmt and
- * height height.
- *
- * @param data pointers array to be filled with the pointer for each image plane
- * @param ptr the pointer to a buffer which will contain the image
- * @param linesizes the array containing the linesize for each
- * plane, should be filled by av_image_fill_linesizes()
- * @return the size in bytes required for the image buffer, a negative
- * error code in case of failure
- */
-int av_image_fill_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int height,
-                           uint8_t *ptr, const int linesizes[4]);
-
-/**
- * Allocate an image with size w and h and pixel format pix_fmt, and
- * fill pointers and linesizes accordingly.
- * The allocated image buffer has to be freed by using
- * av_freep(&pointers[0]).
- *
- * @param align the value to use for buffer size alignment
- * @return the size in bytes required for the image buffer, a negative
- * error code in case of failure
- */
-int av_image_alloc(uint8_t *pointers[4], int linesizes[4],
-                   int w, int h, enum AVPixelFormat pix_fmt, int align);
-
-/**
- * Copy image plane from src to dst.
- * That is, copy "height" number of lines of "bytewidth" bytes each.
- * The first byte of each successive line is separated by *_linesize
- * bytes.
- *
- * bytewidth must be contained by both absolute values of dst_linesize
- * and src_linesize, otherwise the function behavior is undefined.
- *
- * @param dst_linesize linesize for the image plane in dst
- * @param src_linesize linesize for the image plane in src
- */
-void av_image_copy_plane(uint8_t       *dst, int dst_linesize,
-                         const uint8_t *src, int src_linesize,
-                         int bytewidth, int height);
-
-/**
- * Copy image in src_data to dst_data.
- *
- * @param dst_linesizes linesizes for the image in dst_data
- * @param src_linesizes linesizes for the image in src_data
- */
-void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],
-                   const uint8_t *src_data[4], const int src_linesizes[4],
-                   enum AVPixelFormat pix_fmt, int width, int height);
-
-/**
- * Setup the data pointers and linesizes based on the specified image
- * parameters and the provided array.
- *
- * The fields of the given image are filled in by using the src
- * address which points to the image data buffer. Depending on the
- * specified pixel format, one or multiple image data pointers and
- * line sizes will be set.  If a planar format is specified, several
- * pointers will be set pointing to the different picture planes and
- * the line sizes of the different planes will be stored in the
- * lines_sizes array. Call with src == NULL to get the required
- * size for the src buffer.
- *
- * To allocate the buffer and fill in the dst_data and dst_linesize in
- * one call, use av_image_alloc().
- *
- * @param dst_data      data pointers to be filled in
- * @param dst_linesizes linesizes for the image in dst_data to be filled in
- * @param src           buffer which will contain or contains the actual image data, can be NULL
- * @param pix_fmt       the pixel format of the image
- * @param width         the width of the image in pixels
- * @param height        the height of the image in pixels
- * @param align         the value used in src for linesize alignment
- * @return the size in bytes required for src, a negative error code
- * in case of failure
- */
-int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4],
-                         const uint8_t *src,
-                         enum AVPixelFormat pix_fmt, int width, int height, int align);
-
-/**
- * Return the size in bytes of the amount of data required to store an
- * image with the given parameters.
- *
- * @param[in] align the assumed linesize alignment
- */
-int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align);
-
-/**
- * Copy image data from an image into a buffer.
- *
- * av_image_get_buffer_size() can be used to compute the required size
- * for the buffer to fill.
- *
- * @param dst           a buffer into which picture data will be copied
- * @param dst_size      the size in bytes of dst
- * @param src_data      pointers containing the source image data
- * @param src_linesizes linesizes for the image in src_data
- * @param pix_fmt       the pixel format of the source image
- * @param width         the width of the source image in pixels
- * @param height        the height of the source image in pixels
- * @param align         the assumed linesize alignment for dst
- * @return the number of bytes written to dst, or a negative value
- * (error code) on error
- */
-int av_image_copy_to_buffer(uint8_t *dst, int dst_size,
-                            const uint8_t * const src_data[4], const int src_linesize[4],
-                            enum AVPixelFormat pix_fmt, int width, int height, int align);
-
-/**
- * Check if the given dimension of an image is valid, meaning that all
- * bytes of the image can be addressed with a signed int.
- *
- * @param w the width of the picture
- * @param h the height of the picture
- * @param log_offset the offset to sum to the log level for logging with log_ctx
- * @param log_ctx the parent logging context, it may be NULL
- * @return >= 0 if valid, a negative error code otherwise
- */
-int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx);
-
-/**
- * Check if the given sample aspect ratio of an image is valid.
- *
- * It is considered invalid if the denominator is 0 or if applying the ratio
- * to the image size would make the smaller dimension less than 1. If the
- * sar numerator is 0, it is considered unknown and will return as valid.
- *
- * @param w width of the image
- * @param h height of the image
- * @param sar sample aspect ratio of the image
- * @return 0 if valid, a negative AVERROR code otherwise
- */
-int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar);
-
-/**
- * @}
- */
-
-
-#endif /* AVUTIL_IMGUTILS_H */

Externals/ffmpeg/include/libavutil/intfloat.h

@@ -1,77 +0,0 @@
-/*
- * Copyright (c) 2011 Mans Rullgard
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_INTFLOAT_H
-#define AVUTIL_INTFLOAT_H
-
-#include <stdint.h>
-#include "attributes.h"
-
-union av_intfloat32 {
-    uint32_t i;
-    float    f;
-};
-
-union av_intfloat64 {
-    uint64_t i;
-    double   f;
-};
-
-/**
- * Reinterpret a 32-bit integer as a float.
- */
-static av_always_inline float av_int2float(uint32_t i)
-{
-    union av_intfloat32 v;
-    v.i = i;
-    return v.f;
-}
-
-/**
- * Reinterpret a float as a 32-bit integer.
- */
-static av_always_inline uint32_t av_float2int(float f)
-{
-    union av_intfloat32 v;
-    v.f = f;
-    return v.i;
-}
-
-/**
- * Reinterpret a 64-bit integer as a double.
- */
-static av_always_inline double av_int2double(uint64_t i)
-{
-    union av_intfloat64 v;
-    v.i = i;
-    return v.f;
-}
-
-/**
- * Reinterpret a double as a 64-bit integer.
- */
-static av_always_inline uint64_t av_double2int(double f)
-{
-    union av_intfloat64 v;
-    v.f = f;
-    return v.i;
-}
-
-#endif /* AVUTIL_INTFLOAT_H */

Externals/ffmpeg/include/libavutil/intfloat_readwrite.h

@@ -1,44 +0,0 @@
-/*
- * copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_INTFLOAT_READWRITE_H
-#define AVUTIL_INTFLOAT_READWRITE_H
-
-#include <stdint.h>
-
-#include "attributes.h"
-#include "version.h"
-
-#if FF_API_INTFLOAT
-/* IEEE 80 bits extended float */
-typedef struct AVExtFloat  {
-    uint8_t exponent[2];
-    uint8_t mantissa[8];
-} AVExtFloat;
-
-attribute_deprecated double av_int2dbl(int64_t v) av_const;
-attribute_deprecated float av_int2flt(int32_t v) av_const;
-attribute_deprecated double av_ext2dbl(const AVExtFloat ext) av_const;
-attribute_deprecated int64_t av_dbl2int(double d) av_const;
-attribute_deprecated int32_t av_flt2int(float d) av_const;
-attribute_deprecated AVExtFloat av_dbl2ext(double d) av_const;
-#endif /* FF_API_INTFLOAT */
-
-#endif /* AVUTIL_INTFLOAT_READWRITE_H */

Externals/ffmpeg/include/libavutil/intreadwrite.h

@@ -1,629 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_INTREADWRITE_H
-#define AVUTIL_INTREADWRITE_H
-
-#include <stdint.h>
-#include "libavutil/avconfig.h"
-#include "attributes.h"
-#include "bswap.h"
-
-typedef union {
-    uint64_t u64;
-    uint32_t u32[2];
-    uint16_t u16[4];
-    uint8_t  u8 [8];
-    double   f64;
-    float    f32[2];
-} av_alias av_alias64;
-
-typedef union {
-    uint32_t u32;
-    uint16_t u16[2];
-    uint8_t  u8 [4];
-    float    f32;
-} av_alias av_alias32;
-
-typedef union {
-    uint16_t u16;
-    uint8_t  u8 [2];
-} av_alias av_alias16;
-
-/*
- * Arch-specific headers can provide any combination of
- * AV_[RW][BLN](16|24|32|48|64) and AV_(COPY|SWAP|ZERO)(64|128) macros.
- * Preprocessor symbols must be defined, even if these are implemented
- * as inline functions.
- *
- * R/W means read/write, B/L/N means big/little/native endianness.
- * The following macros require aligned access, compared to their
- * unaligned variants: AV_(COPY|SWAP|ZERO)(64|128), AV_[RW]N[8-64]A.
- * Incorrect usage may range from abysmal performance to crash
- * depending on the platform.
- *
- * The unaligned variants are AV_[RW][BLN][8-64] and AV_COPY*U.
- */
-
-#ifdef HAVE_AV_CONFIG_H
-
-#include "config.h"
-
-#if   ARCH_ARM
-#   include "arm/intreadwrite.h"
-#elif ARCH_AVR32
-#   include "avr32/intreadwrite.h"
-#elif ARCH_MIPS
-#   include "mips/intreadwrite.h"
-#elif ARCH_PPC
-#   include "ppc/intreadwrite.h"
-#elif ARCH_TOMI
-#   include "tomi/intreadwrite.h"
-#elif ARCH_X86
-#   include "x86/intreadwrite.h"
-#endif
-
-#endif /* HAVE_AV_CONFIG_H */
-
-/*
- * Map AV_RNXX <-> AV_R[BL]XX for all variants provided by per-arch headers.
- */
-
-#if AV_HAVE_BIGENDIAN
-
-#   if    defined(AV_RN16) && !defined(AV_RB16)
-#       define AV_RB16(p) AV_RN16(p)
-#   elif !defined(AV_RN16) &&  defined(AV_RB16)
-#       define AV_RN16(p) AV_RB16(p)
-#   endif
-
-#   if    defined(AV_WN16) && !defined(AV_WB16)
-#       define AV_WB16(p, v) AV_WN16(p, v)
-#   elif !defined(AV_WN16) &&  defined(AV_WB16)
-#       define AV_WN16(p, v) AV_WB16(p, v)
-#   endif
-
-#   if    defined(AV_RN24) && !defined(AV_RB24)
-#       define AV_RB24(p) AV_RN24(p)
-#   elif !defined(AV_RN24) &&  defined(AV_RB24)
-#       define AV_RN24(p) AV_RB24(p)
-#   endif
-
-#   if    defined(AV_WN24) && !defined(AV_WB24)
-#       define AV_WB24(p, v) AV_WN24(p, v)
-#   elif !defined(AV_WN24) &&  defined(AV_WB24)
-#       define AV_WN24(p, v) AV_WB24(p, v)
-#   endif
-
-#   if    defined(AV_RN32) && !defined(AV_RB32)
-#       define AV_RB32(p) AV_RN32(p)
-#   elif !defined(AV_RN32) &&  defined(AV_RB32)
-#       define AV_RN32(p) AV_RB32(p)
-#   endif
-
-#   if    defined(AV_WN32) && !defined(AV_WB32)
-#       define AV_WB32(p, v) AV_WN32(p, v)
-#   elif !defined(AV_WN32) &&  defined(AV_WB32)
-#       define AV_WN32(p, v) AV_WB32(p, v)
-#   endif
-
-#   if    defined(AV_RN48) && !defined(AV_RB48)
-#       define AV_RB48(p) AV_RN48(p)
-#   elif !defined(AV_RN48) &&  defined(AV_RB48)
-#       define AV_RN48(p) AV_RB48(p)
-#   endif
-
-#   if    defined(AV_WN48) && !defined(AV_WB48)
-#       define AV_WB48(p, v) AV_WN48(p, v)
-#   elif !defined(AV_WN48) &&  defined(AV_WB48)
-#       define AV_WN48(p, v) AV_WB48(p, v)
-#   endif
-
-#   if    defined(AV_RN64) && !defined(AV_RB64)
-#       define AV_RB64(p) AV_RN64(p)
-#   elif !defined(AV_RN64) &&  defined(AV_RB64)
-#       define AV_RN64(p) AV_RB64(p)
-#   endif
-
-#   if    defined(AV_WN64) && !defined(AV_WB64)
-#       define AV_WB64(p, v) AV_WN64(p, v)
-#   elif !defined(AV_WN64) &&  defined(AV_WB64)
-#       define AV_WN64(p, v) AV_WB64(p, v)
-#   endif
-
-#else /* AV_HAVE_BIGENDIAN */
-
-#   if    defined(AV_RN16) && !defined(AV_RL16)
-#       define AV_RL16(p) AV_RN16(p)
-#   elif !defined(AV_RN16) &&  defined(AV_RL16)
-#       define AV_RN16(p) AV_RL16(p)
-#   endif
-
-#   if    defined(AV_WN16) && !defined(AV_WL16)
-#       define AV_WL16(p, v) AV_WN16(p, v)
-#   elif !defined(AV_WN16) &&  defined(AV_WL16)
-#       define AV_WN16(p, v) AV_WL16(p, v)
-#   endif
-
-#   if    defined(AV_RN24) && !defined(AV_RL24)
-#       define AV_RL24(p) AV_RN24(p)
-#   elif !defined(AV_RN24) &&  defined(AV_RL24)
-#       define AV_RN24(p) AV_RL24(p)
-#   endif
-
-#   if    defined(AV_WN24) && !defined(AV_WL24)
-#       define AV_WL24(p, v) AV_WN24(p, v)
-#   elif !defined(AV_WN24) &&  defined(AV_WL24)
-#       define AV_WN24(p, v) AV_WL24(p, v)
-#   endif
-
-#   if    defined(AV_RN32) && !defined(AV_RL32)
-#       define AV_RL32(p) AV_RN32(p)
-#   elif !defined(AV_RN32) &&  defined(AV_RL32)
-#       define AV_RN32(p) AV_RL32(p)
-#   endif
-
-#   if    defined(AV_WN32) && !defined(AV_WL32)
-#       define AV_WL32(p, v) AV_WN32(p, v)
-#   elif !defined(AV_WN32) &&  defined(AV_WL32)
-#       define AV_WN32(p, v) AV_WL32(p, v)
-#   endif
-
-#   if    defined(AV_RN48) && !defined(AV_RL48)
-#       define AV_RL48(p) AV_RN48(p)
-#   elif !defined(AV_RN48) &&  defined(AV_RL48)
-#       define AV_RN48(p) AV_RL48(p)
-#   endif
-
-#   if    defined(AV_WN48) && !defined(AV_WL48)
-#       define AV_WL48(p, v) AV_WN48(p, v)
-#   elif !defined(AV_WN48) &&  defined(AV_WL48)
-#       define AV_WN48(p, v) AV_WL48(p, v)
-#   endif
-
-#   if    defined(AV_RN64) && !defined(AV_RL64)
-#       define AV_RL64(p) AV_RN64(p)
-#   elif !defined(AV_RN64) &&  defined(AV_RL64)
-#       define AV_RN64(p) AV_RL64(p)
-#   endif
-
-#   if    defined(AV_WN64) && !defined(AV_WL64)
-#       define AV_WL64(p, v) AV_WN64(p, v)
-#   elif !defined(AV_WN64) &&  defined(AV_WL64)
-#       define AV_WN64(p, v) AV_WL64(p, v)
-#   endif
-
-#endif /* !AV_HAVE_BIGENDIAN */
-
-/*
- * Define AV_[RW]N helper macros to simplify definitions not provided
- * by per-arch headers.
- */
-
-#if defined(__GNUC__) && !defined(__TI_COMPILER_VERSION__)
-
-union unaligned_64 { uint64_t l; } __attribute__((packed)) av_alias;
-union unaligned_32 { uint32_t l; } __attribute__((packed)) av_alias;
-union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
-
-#   define AV_RN(s, p) (((const union unaligned_##s *) (p))->l)
-#   define AV_WN(s, p, v) ((((union unaligned_##s *) (p))->l) = (v))
-
-#elif defined(__DECC)
-
-#   define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p)))
-#   define AV_WN(s, p, v) (*((__unaligned uint##s##_t*)(p)) = (v))
-
-#elif AV_HAVE_FAST_UNALIGNED
-
-#   define AV_RN(s, p) (((const av_alias##s*)(p))->u##s)
-#   define AV_WN(s, p, v) (((av_alias##s*)(p))->u##s = (v))
-
-#else
-
-#ifndef AV_RB16
-#   define AV_RB16(x)                           \
-    ((((const uint8_t*)(x))[0] << 8) |          \
-      ((const uint8_t*)(x))[1])
-#endif
-#ifndef AV_WB16
-#   define AV_WB16(p, darg) do {                \
-        unsigned d = (darg);                    \
-        ((uint8_t*)(p))[1] = (d);               \
-        ((uint8_t*)(p))[0] = (d)>>8;            \
-    } while(0)
-#endif
-
-#ifndef AV_RL16
-#   define AV_RL16(x)                           \
-    ((((const uint8_t*)(x))[1] << 8) |          \
-      ((const uint8_t*)(x))[0])
-#endif
-#ifndef AV_WL16
-#   define AV_WL16(p, darg) do {                \
-        unsigned d = (darg);                    \
-        ((uint8_t*)(p))[0] = (d);               \
-        ((uint8_t*)(p))[1] = (d)>>8;            \
-    } while(0)
-#endif
-
-#ifndef AV_RB32
-#   define AV_RB32(x)                                \
-    (((uint32_t)((const uint8_t*)(x))[0] << 24) |    \
-               (((const uint8_t*)(x))[1] << 16) |    \
-               (((const uint8_t*)(x))[2] <<  8) |    \
-                ((const uint8_t*)(x))[3])
-#endif
-#ifndef AV_WB32
-#   define AV_WB32(p, darg) do {                \
-        unsigned d = (darg);                    \
-        ((uint8_t*)(p))[3] = (d);               \
-        ((uint8_t*)(p))[2] = (d)>>8;            \
-        ((uint8_t*)(p))[1] = (d)>>16;           \
-        ((uint8_t*)(p))[0] = (d)>>24;           \
-    } while(0)
-#endif
-
-#ifndef AV_RL32
-#   define AV_RL32(x)                                \
-    (((uint32_t)((const uint8_t*)(x))[3] << 24) |    \
-               (((const uint8_t*)(x))[2] << 16) |    \
-               (((const uint8_t*)(x))[1] <<  8) |    \
-                ((const uint8_t*)(x))[0])
-#endif
-#ifndef AV_WL32
-#   define AV_WL32(p, darg) do {                \
-        unsigned d = (darg);                    \
-        ((uint8_t*)(p))[0] = (d);               \
-        ((uint8_t*)(p))[1] = (d)>>8;            \
-        ((uint8_t*)(p))[2] = (d)>>16;           \
-        ((uint8_t*)(p))[3] = (d)>>24;           \
-    } while(0)
-#endif
-
-#ifndef AV_RB64
-#   define AV_RB64(x)                                   \
-    (((uint64_t)((const uint8_t*)(x))[0] << 56) |       \
-     ((uint64_t)((const uint8_t*)(x))[1] << 48) |       \
-     ((uint64_t)((const uint8_t*)(x))[2] << 40) |       \
-     ((uint64_t)((const uint8_t*)(x))[3] << 32) |       \
-     ((uint64_t)((const uint8_t*)(x))[4] << 24) |       \
-     ((uint64_t)((const uint8_t*)(x))[5] << 16) |       \
-     ((uint64_t)((const uint8_t*)(x))[6] <<  8) |       \
-      (uint64_t)((const uint8_t*)(x))[7])
-#endif
-#ifndef AV_WB64
-#   define AV_WB64(p, darg) do {                \
-        uint64_t d = (darg);                    \
-        ((uint8_t*)(p))[7] = (d);               \
-        ((uint8_t*)(p))[6] = (d)>>8;            \
-        ((uint8_t*)(p))[5] = (d)>>16;           \
-        ((uint8_t*)(p))[4] = (d)>>24;           \
-        ((uint8_t*)(p))[3] = (d)>>32;           \
-        ((uint8_t*)(p))[2] = (d)>>40;           \
-        ((uint8_t*)(p))[1] = (d)>>48;           \
-        ((uint8_t*)(p))[0] = (d)>>56;           \
-    } while(0)
-#endif
-
-#ifndef AV_RL64
-#   define AV_RL64(x)                                   \
-    (((uint64_t)((const uint8_t*)(x))[7] << 56) |       \
-     ((uint64_t)((const uint8_t*)(x))[6] << 48) |       \
-     ((uint64_t)((const uint8_t*)(x))[5] << 40) |       \
-     ((uint64_t)((const uint8_t*)(x))[4] << 32) |       \
-     ((uint64_t)((const uint8_t*)(x))[3] << 24) |       \
-     ((uint64_t)((const uint8_t*)(x))[2] << 16) |       \
-     ((uint64_t)((const uint8_t*)(x))[1] <<  8) |       \
-      (uint64_t)((const uint8_t*)(x))[0])
-#endif
-#ifndef AV_WL64
-#   define AV_WL64(p, darg) do {                \
-        uint64_t d = (darg);                    \
-        ((uint8_t*)(p))[0] = (d);               \
-        ((uint8_t*)(p))[1] = (d)>>8;            \
-        ((uint8_t*)(p))[2] = (d)>>16;           \
-        ((uint8_t*)(p))[3] = (d)>>24;           \
-        ((uint8_t*)(p))[4] = (d)>>32;           \
-        ((uint8_t*)(p))[5] = (d)>>40;           \
-        ((uint8_t*)(p))[6] = (d)>>48;           \
-        ((uint8_t*)(p))[7] = (d)>>56;           \
-    } while(0)
-#endif
-
-#if AV_HAVE_BIGENDIAN
-#   define AV_RN(s, p)    AV_RB##s(p)
-#   define AV_WN(s, p, v) AV_WB##s(p, v)
-#else
-#   define AV_RN(s, p)    AV_RL##s(p)
-#   define AV_WN(s, p, v) AV_WL##s(p, v)
-#endif
-
-#endif /* HAVE_FAST_UNALIGNED */
-
-#ifndef AV_RN16
-#   define AV_RN16(p) AV_RN(16, p)
-#endif
-
-#ifndef AV_RN32
-#   define AV_RN32(p) AV_RN(32, p)
-#endif
-
-#ifndef AV_RN64
-#   define AV_RN64(p) AV_RN(64, p)
-#endif
-
-#ifndef AV_WN16
-#   define AV_WN16(p, v) AV_WN(16, p, v)
-#endif
-
-#ifndef AV_WN32
-#   define AV_WN32(p, v) AV_WN(32, p, v)
-#endif
-
-#ifndef AV_WN64
-#   define AV_WN64(p, v) AV_WN(64, p, v)
-#endif
-
-#if AV_HAVE_BIGENDIAN
-#   define AV_RB(s, p)    AV_RN##s(p)
-#   define AV_WB(s, p, v) AV_WN##s(p, v)
-#   define AV_RL(s, p)    av_bswap##s(AV_RN##s(p))
-#   define AV_WL(s, p, v) AV_WN##s(p, av_bswap##s(v))
-#else
-#   define AV_RB(s, p)    av_bswap##s(AV_RN##s(p))
-#   define AV_WB(s, p, v) AV_WN##s(p, av_bswap##s(v))
-#   define AV_RL(s, p)    AV_RN##s(p)
-#   define AV_WL(s, p, v) AV_WN##s(p, v)
-#endif
-
-#define AV_RB8(x)     (((const uint8_t*)(x))[0])
-#define AV_WB8(p, d)  do { ((uint8_t*)(p))[0] = (d); } while(0)
-
-#define AV_RL8(x)     AV_RB8(x)
-#define AV_WL8(p, d)  AV_WB8(p, d)
-
-#ifndef AV_RB16
-#   define AV_RB16(p)    AV_RB(16, p)
-#endif
-#ifndef AV_WB16
-#   define AV_WB16(p, v) AV_WB(16, p, v)
-#endif
-
-#ifndef AV_RL16
-#   define AV_RL16(p)    AV_RL(16, p)
-#endif
-#ifndef AV_WL16
-#   define AV_WL16(p, v) AV_WL(16, p, v)
-#endif
-
-#ifndef AV_RB32
-#   define AV_RB32(p)    AV_RB(32, p)
-#endif
-#ifndef AV_WB32
-#   define AV_WB32(p, v) AV_WB(32, p, v)
-#endif
-
-#ifndef AV_RL32
-#   define AV_RL32(p)    AV_RL(32, p)
-#endif
-#ifndef AV_WL32
-#   define AV_WL32(p, v) AV_WL(32, p, v)
-#endif
-
-#ifndef AV_RB64
-#   define AV_RB64(p)    AV_RB(64, p)
-#endif
-#ifndef AV_WB64
-#   define AV_WB64(p, v) AV_WB(64, p, v)
-#endif
-
-#ifndef AV_RL64
-#   define AV_RL64(p)    AV_RL(64, p)
-#endif
-#ifndef AV_WL64
-#   define AV_WL64(p, v) AV_WL(64, p, v)
-#endif
-
-#ifndef AV_RB24
-#   define AV_RB24(x)                           \
-    ((((const uint8_t*)(x))[0] << 16) |         \
-     (((const uint8_t*)(x))[1] <<  8) |         \
-      ((const uint8_t*)(x))[2])
-#endif
-#ifndef AV_WB24
-#   define AV_WB24(p, d) do {                   \
-        ((uint8_t*)(p))[2] = (d);               \
-        ((uint8_t*)(p))[1] = (d)>>8;            \
-        ((uint8_t*)(p))[0] = (d)>>16;           \
-    } while(0)
-#endif
-
-#ifndef AV_RL24
-#   define AV_RL24(x)                           \
-    ((((const uint8_t*)(x))[2] << 16) |         \
-     (((const uint8_t*)(x))[1] <<  8) |         \
-      ((const uint8_t*)(x))[0])
-#endif
-#ifndef AV_WL24
-#   define AV_WL24(p, d) do {                   \
-        ((uint8_t*)(p))[0] = (d);               \
-        ((uint8_t*)(p))[1] = (d)>>8;            \
-        ((uint8_t*)(p))[2] = (d)>>16;           \
-    } while(0)
-#endif
-
-#ifndef AV_RB48
-#   define AV_RB48(x)                                     \
-    (((uint64_t)((const uint8_t*)(x))[0] << 40) |         \
-     ((uint64_t)((const uint8_t*)(x))[1] << 32) |         \
-     ((uint64_t)((const uint8_t*)(x))[2] << 24) |         \
-     ((uint64_t)((const uint8_t*)(x))[3] << 16) |         \
-     ((uint64_t)((const uint8_t*)(x))[4] <<  8) |         \
-      (uint64_t)((const uint8_t*)(x))[5])
-#endif
-#ifndef AV_WB48
-#   define AV_WB48(p, darg) do {                \
-        uint64_t d = (darg);                    \
-        ((uint8_t*)(p))[5] = (d);               \
-        ((uint8_t*)(p))[4] = (d)>>8;            \
-        ((uint8_t*)(p))[3] = (d)>>16;           \
-        ((uint8_t*)(p))[2] = (d)>>24;           \
-        ((uint8_t*)(p))[1] = (d)>>32;           \
-        ((uint8_t*)(p))[0] = (d)>>40;           \
-    } while(0)
-#endif
-
-#ifndef AV_RL48
-#   define AV_RL48(x)                                     \
-    (((uint64_t)((const uint8_t*)(x))[5] << 40) |         \
-     ((uint64_t)((const uint8_t*)(x))[4] << 32) |         \
-     ((uint64_t)((const uint8_t*)(x))[3] << 24) |         \
-     ((uint64_t)((const uint8_t*)(x))[2] << 16) |         \
-     ((uint64_t)((const uint8_t*)(x))[1] <<  8) |         \
-      (uint64_t)((const uint8_t*)(x))[0])
-#endif
-#ifndef AV_WL48
-#   define AV_WL48(p, darg) do {                \
-        uint64_t d = (darg);                    \
-        ((uint8_t*)(p))[0] = (d);               \
-        ((uint8_t*)(p))[1] = (d)>>8;            \
-        ((uint8_t*)(p))[2] = (d)>>16;           \
-        ((uint8_t*)(p))[3] = (d)>>24;           \
-        ((uint8_t*)(p))[4] = (d)>>32;           \
-        ((uint8_t*)(p))[5] = (d)>>40;           \
-    } while(0)
-#endif
-
-/*
- * The AV_[RW]NA macros access naturally aligned data
- * in a type-safe way.
- */
-
-#define AV_RNA(s, p)    (((const av_alias##s*)(p))->u##s)
-#define AV_WNA(s, p, v) (((av_alias##s*)(p))->u##s = (v))
-
-#ifndef AV_RN16A
-#   define AV_RN16A(p) AV_RNA(16, p)
-#endif
-
-#ifndef AV_RN32A
-#   define AV_RN32A(p) AV_RNA(32, p)
-#endif
-
-#ifndef AV_RN64A
-#   define AV_RN64A(p) AV_RNA(64, p)
-#endif
-
-#ifndef AV_WN16A
-#   define AV_WN16A(p, v) AV_WNA(16, p, v)
-#endif
-
-#ifndef AV_WN32A
-#   define AV_WN32A(p, v) AV_WNA(32, p, v)
-#endif
-
-#ifndef AV_WN64A
-#   define AV_WN64A(p, v) AV_WNA(64, p, v)
-#endif
-
-/*
- * The AV_COPYxxU macros are suitable for copying data to/from unaligned
- * memory locations.
- */
-
-#define AV_COPYU(n, d, s) AV_WN##n(d, AV_RN##n(s));
-
-#ifndef AV_COPY16U
-#   define AV_COPY16U(d, s) AV_COPYU(16, d, s)
-#endif
-
-#ifndef AV_COPY32U
-#   define AV_COPY32U(d, s) AV_COPYU(32, d, s)
-#endif
-
-#ifndef AV_COPY64U
-#   define AV_COPY64U(d, s) AV_COPYU(64, d, s)
-#endif
-
-#ifndef AV_COPY128U
-#   define AV_COPY128U(d, s)                                    \
-    do {                                                        \
-        AV_COPY64U(d, s);                                       \
-        AV_COPY64U((char *)(d) + 8, (const char *)(s) + 8);     \
-    } while(0)
-#endif
-
-/* Parameters for AV_COPY*, AV_SWAP*, AV_ZERO* must be
- * naturally aligned. They may be implemented using MMX,
- * so emms_c() must be called before using any float code
- * afterwards.
- */
-
-#define AV_COPY(n, d, s) \
-    (((av_alias##n*)(d))->u##n = ((const av_alias##n*)(s))->u##n)
-
-#ifndef AV_COPY16
-#   define AV_COPY16(d, s) AV_COPY(16, d, s)
-#endif
-
-#ifndef AV_COPY32
-#   define AV_COPY32(d, s) AV_COPY(32, d, s)
-#endif
-
-#ifndef AV_COPY64
-#   define AV_COPY64(d, s) AV_COPY(64, d, s)
-#endif
-
-#ifndef AV_COPY128
-#   define AV_COPY128(d, s)                    \
-    do {                                       \
-        AV_COPY64(d, s);                       \
-        AV_COPY64((char*)(d)+8, (char*)(s)+8); \
-    } while(0)
-#endif
-
-#define AV_SWAP(n, a, b) FFSWAP(av_alias##n, *(av_alias##n*)(a), *(av_alias##n*)(b))
-
-#ifndef AV_SWAP64
-#   define AV_SWAP64(a, b) AV_SWAP(64, a, b)
-#endif
-
-#define AV_ZERO(n, d) (((av_alias##n*)(d))->u##n = 0)
-
-#ifndef AV_ZERO16
-#   define AV_ZERO16(d) AV_ZERO(16, d)
-#endif
-
-#ifndef AV_ZERO32
-#   define AV_ZERO32(d) AV_ZERO(32, d)
-#endif
-
-#ifndef AV_ZERO64
-#   define AV_ZERO64(d) AV_ZERO(64, d)
-#endif
-
-#ifndef AV_ZERO128
-#   define AV_ZERO128(d)         \
-    do {                         \
-        AV_ZERO64(d);            \
-        AV_ZERO64((char*)(d)+8); \
-    } while(0)
-#endif
-
-#endif /* AVUTIL_INTREADWRITE_H */

Externals/ffmpeg/include/libavutil/lfg.h

@@ -1,62 +0,0 @@
-/*
- * Lagged Fibonacci PRNG
- * Copyright (c) 2008 Michael Niedermayer
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_LFG_H
-#define AVUTIL_LFG_H
-
-typedef struct AVLFG {
-    unsigned int state[64];
-    int index;
-} AVLFG;
-
-void av_lfg_init(AVLFG *c, unsigned int seed);
-
-/**
- * Get the next random unsigned 32-bit number using an ALFG.
- *
- * Please also consider a simple LCG like state= state*1664525+1013904223,
- * it may be good enough and faster for your specific use case.
- */
-static inline unsigned int av_lfg_get(AVLFG *c){
-    c->state[c->index & 63] = c->state[(c->index-24) & 63] + c->state[(c->index-55) & 63];
-    return c->state[c->index++ & 63];
-}
-
-/**
- * Get the next random unsigned 32-bit number using a MLFG.
- *
- * Please also consider av_lfg_get() above, it is faster.
- */
-static inline unsigned int av_mlfg_get(AVLFG *c){
-    unsigned int a= c->state[(c->index-55) & 63];
-    unsigned int b= c->state[(c->index-24) & 63];
-    return c->state[c->index++ & 63] = 2*a*b+a+b;
-}
-
-/**
- * Get the next two numbers generated by a Box-Muller Gaussian
- * generator using the random numbers issued by lfg.
- *
- * @param out array where the two generated numbers are placed
- */
-void av_bmg_get(AVLFG *lfg, double out[2]);
-
-#endif /* AVUTIL_LFG_H */

Externals/ffmpeg/include/libavutil/log.h

@@ -1,350 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_LOG_H
-#define AVUTIL_LOG_H
-
-#include <stdarg.h>
-#include "avutil.h"
-#include "attributes.h"
-
-typedef enum {
-    AV_CLASS_CATEGORY_NA = 0,
-    AV_CLASS_CATEGORY_INPUT,
-    AV_CLASS_CATEGORY_OUTPUT,
-    AV_CLASS_CATEGORY_MUXER,
-    AV_CLASS_CATEGORY_DEMUXER,
-    AV_CLASS_CATEGORY_ENCODER,
-    AV_CLASS_CATEGORY_DECODER,
-    AV_CLASS_CATEGORY_FILTER,
-    AV_CLASS_CATEGORY_BITSTREAM_FILTER,
-    AV_CLASS_CATEGORY_SWSCALER,
-    AV_CLASS_CATEGORY_SWRESAMPLER,
-    AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT = 40,
-    AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
-    AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT,
-    AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT,
-    AV_CLASS_CATEGORY_DEVICE_OUTPUT,
-    AV_CLASS_CATEGORY_DEVICE_INPUT,
-    AV_CLASS_CATEGORY_NB, ///< not part of ABI/API
-}AVClassCategory;
-
-#define AV_IS_INPUT_DEVICE(category) \
-    (((category) == AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT) || \
-     ((category) == AV_CLASS_CATEGORY_DEVICE_AUDIO_INPUT) || \
-     ((category) == AV_CLASS_CATEGORY_DEVICE_INPUT))
-
-#define AV_IS_OUTPUT_DEVICE(category) \
-    (((category) == AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT) || \
-     ((category) == AV_CLASS_CATEGORY_DEVICE_AUDIO_OUTPUT) || \
-     ((category) == AV_CLASS_CATEGORY_DEVICE_OUTPUT))
-
-struct AVOptionRanges;
-
-/**
- * Describe the class of an AVClass context structure. That is an
- * arbitrary struct of which the first field is a pointer to an
- * AVClass struct (e.g. AVCodecContext, AVFormatContext etc.).
- */
-typedef struct AVClass {
-    /**
-     * The name of the class; usually it is the same name as the
-     * context structure type to which the AVClass is associated.
-     */
-    const char* class_name;
-
-    /**
-     * A pointer to a function which returns the name of a context
-     * instance ctx associated with the class.
-     */
-    const char* (*item_name)(void* ctx);
-
-    /**
-     * a pointer to the first option specified in the class if any or NULL
-     *
-     * @see av_set_default_options()
-     */
-    const struct AVOption *option;
-
-    /**
-     * LIBAVUTIL_VERSION with which this structure was created.
-     * This is used to allow fields to be added without requiring major
-     * version bumps everywhere.
-     */
-
-    int version;
-
-    /**
-     * Offset in the structure where log_level_offset is stored.
-     * 0 means there is no such variable
-     */
-    int log_level_offset_offset;
-
-    /**
-     * Offset in the structure where a pointer to the parent context for
-     * logging is stored. For example a decoder could pass its AVCodecContext
-     * to eval as such a parent context, which an av_log() implementation
-     * could then leverage to display the parent context.
-     * The offset can be NULL.
-     */
-    int parent_log_context_offset;
-
-    /**
-     * Return next AVOptions-enabled child or NULL
-     */
-    void* (*child_next)(void *obj, void *prev);
-
-    /**
-     * Return an AVClass corresponding to the next potential
-     * AVOptions-enabled child.
-     *
-     * The difference between child_next and this is that
-     * child_next iterates over _already existing_ objects, while
-     * child_class_next iterates over _all possible_ children.
-     */
-    const struct AVClass* (*child_class_next)(const struct AVClass *prev);
-
-    /**
-     * Category used for visualization (like color)
-     * This is only set if the category is equal for all objects using this class.
-     * available since version (51 << 16 | 56 << 8 | 100)
-     */
-    AVClassCategory category;
-
-    /**
-     * Callback to return the category.
-     * available since version (51 << 16 | 59 << 8 | 100)
-     */
-    AVClassCategory (*get_category)(void* ctx);
-
-    /**
-     * Callback to return the supported/allowed ranges.
-     * available since version (52.12)
-     */
-    int (*query_ranges)(struct AVOptionRanges **, void *obj, const char *key, int flags);
-} AVClass;
-
-/**
- * @addtogroup lavu_log
- *
- * @{
- *
- * @defgroup lavu_log_constants Logging Constants
- *
- * @{
- */
-
-/**
- * Print no output.
- */
-#define AV_LOG_QUIET    -8
-
-/**
- * Something went really wrong and we will crash now.
- */
-#define AV_LOG_PANIC     0
-
-/**
- * Something went wrong and recovery is not possible.
- * For example, no header was found for a format which depends
- * on headers or an illegal combination of parameters is used.
- */
-#define AV_LOG_FATAL     8
-
-/**
- * Something went wrong and cannot losslessly be recovered.
- * However, not all future data is affected.
- */
-#define AV_LOG_ERROR    16
-
-/**
- * Something somehow does not look correct. This may or may not
- * lead to problems. An example would be the use of '-vstrict -2'.
- */
-#define AV_LOG_WARNING  24
-
-/**
- * Standard information.
- */
-#define AV_LOG_INFO     32
-
-/**
- * Detailed information.
- */
-#define AV_LOG_VERBOSE  40
-
-/**
- * Stuff which is only useful for libav* developers.
- */
-#define AV_LOG_DEBUG    48
-
-#define AV_LOG_MAX_OFFSET (AV_LOG_DEBUG - AV_LOG_QUIET)
-
-/**
- * @}
- */
-
-/**
- * Sets additional colors for extended debugging sessions.
- * @code
-   av_log(ctx, AV_LOG_DEBUG|AV_LOG_C(134), "Message in purple\n");
-   @endcode
- * Requires 256color terminal support. Uses outside debugging is not
- * recommended.
- */
-#define AV_LOG_C(x) (x << 8)
-
-/**
- * Send the specified message to the log if the level is less than or equal
- * to the current av_log_level. By default, all logging messages are sent to
- * stderr. This behavior can be altered by setting a different logging callback
- * function.
- * @see av_log_set_callback
- *
- * @param avcl A pointer to an arbitrary struct of which the first field is a
- *        pointer to an AVClass struct.
- * @param level The importance level of the message expressed using a @ref
- *        lavu_log_constants "Logging Constant".
- * @param fmt The format string (printf-compatible) that specifies how
- *        subsequent arguments are converted to output.
- */
-void av_log(void *avcl, int level, const char *fmt, ...) av_printf_format(3, 4);
-
-
-/**
- * Send the specified message to the log if the level is less than or equal
- * to the current av_log_level. By default, all logging messages are sent to
- * stderr. This behavior can be altered by setting a different logging callback
- * function.
- * @see av_log_set_callback
- *
- * @param avcl A pointer to an arbitrary struct of which the first field is a
- *        pointer to an AVClass struct.
- * @param level The importance level of the message expressed using a @ref
- *        lavu_log_constants "Logging Constant".
- * @param fmt The format string (printf-compatible) that specifies how
- *        subsequent arguments are converted to output.
- * @param vl The arguments referenced by the format string.
- */
-void av_vlog(void *avcl, int level, const char *fmt, va_list vl);
-
-/**
- * Get the current log level
- *
- * @see lavu_log_constants
- *
- * @return Current log level
- */
-int av_log_get_level(void);
-
-/**
- * Set the log level
- *
- * @see lavu_log_constants
- *
- * @param level Logging level
- */
-void av_log_set_level(int level);
-
-/**
- * Set the logging callback
- *
- * @note The callback must be thread safe, even if the application does not use
- *       threads itself as some codecs are multithreaded.
- *
- * @see av_log_default_callback
- *
- * @param callback A logging function with a compatible signature.
- */
-void av_log_set_callback(void (*callback)(void*, int, const char*, va_list));
-
-/**
- * Default logging callback
- *
- * It prints the message to stderr, optionally colorizing it.
- *
- * @param avcl A pointer to an arbitrary struct of which the first field is a
- *        pointer to an AVClass struct.
- * @param level The importance level of the message expressed using a @ref
- *        lavu_log_constants "Logging Constant".
- * @param fmt The format string (printf-compatible) that specifies how
- *        subsequent arguments are converted to output.
- * @param vl The arguments referenced by the format string.
- */
-void av_log_default_callback(void *avcl, int level, const char *fmt,
-                             va_list vl);
-
-/**
- * Return the context name
- *
- * @param  ctx The AVClass context
- *
- * @return The AVClass class_name
- */
-const char* av_default_item_name(void* ctx);
-AVClassCategory av_default_get_category(void *ptr);
-
-/**
- * Format a line of log the same way as the default callback.
- * @param line          buffer to receive the formated line
- * @param line_size     size of the buffer
- * @param print_prefix  used to store whether the prefix must be printed;
- *                      must point to a persistent integer initially set to 1
- */
-void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl,
-                        char *line, int line_size, int *print_prefix);
-
-/**
- * av_dlog macros
- * Useful to print debug messages that shouldn't get compiled in normally.
- */
-
-#ifdef DEBUG
-#    define av_dlog(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__)
-#else
-#    define av_dlog(pctx, ...) do { if (0) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__); } while (0)
-#endif
-
-/**
- * Skip repeated messages, this requires the user app to use av_log() instead of
- * (f)printf as the 2 would otherwise interfere and lead to
- * "Last message repeated x times" messages below (f)printf messages with some
- * bad luck.
- * Also to receive the last, "last repeated" line if any, the user app must
- * call av_log(NULL, AV_LOG_QUIET, "%s", ""); at the end
- */
-#define AV_LOG_SKIP_REPEATED 1
-
-/**
- * Include the log severity in messages originating from codecs.
- *
- * Results in messages such as:
- * [rawvideo @ 0xDEADBEEF] [error] encode did not produce valid pts
- */
-#define AV_LOG_PRINT_LEVEL 2
-
-void av_log_set_flags(int arg);
-int av_log_get_flags(void);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_LOG_H */

Externals/ffmpeg/include/libavutil/macros.h

@@ -1,48 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * @ingroup lavu
- * Utility Preprocessor macros
- */
-
-#ifndef AVUTIL_MACROS_H
-#define AVUTIL_MACROS_H
-
-/**
- * @addtogroup preproc_misc Preprocessor String Macros
- *
- * String manipulation macros
- *
- * @{
- */
-
-#define AV_STRINGIFY(s)         AV_TOSTRING(s)
-#define AV_TOSTRING(s) #s
-
-#define AV_GLUE(a, b) a ## b
-#define AV_JOIN(a, b) AV_GLUE(a, b)
-
-/**
- * @}
- */
-
-#define AV_PRAGMA(s) _Pragma(#s)
-
-#endif /* AVUTIL_MACROS_H */

Externals/ffmpeg/include/libavutil/mathematics.h

@@ -1,164 +0,0 @@
-/*
- * copyright (c) 2005-2012 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_MATHEMATICS_H
-#define AVUTIL_MATHEMATICS_H
-
-#include <stdint.h>
-#include <math.h>
-#include "attributes.h"
-#include "rational.h"
-#include "intfloat.h"
-
-#ifndef M_E
-#define M_E            2.7182818284590452354   /* e */
-#endif
-#ifndef M_LN2
-#define M_LN2          0.69314718055994530942  /* log_e 2 */
-#endif
-#ifndef M_LN10
-#define M_LN10         2.30258509299404568402  /* log_e 10 */
-#endif
-#ifndef M_LOG2_10
-#define M_LOG2_10      3.32192809488736234787  /* log_2 10 */
-#endif
-#ifndef M_PHI
-#define M_PHI          1.61803398874989484820   /* phi / golden ratio */
-#endif
-#ifndef M_PI
-#define M_PI           3.14159265358979323846  /* pi */
-#endif
-#ifndef M_PI_2
-#define M_PI_2         1.57079632679489661923  /* pi/2 */
-#endif
-#ifndef M_SQRT1_2
-#define M_SQRT1_2      0.70710678118654752440  /* 1/sqrt(2) */
-#endif
-#ifndef M_SQRT2
-#define M_SQRT2        1.41421356237309504880  /* sqrt(2) */
-#endif
-#ifndef NAN
-#define NAN            av_int2float(0x7fc00000)
-#endif
-#ifndef INFINITY
-#define INFINITY       av_int2float(0x7f800000)
-#endif
-
-/**
- * @addtogroup lavu_math
- * @{
- */
-
-
-enum AVRounding {
-    AV_ROUND_ZERO     = 0, ///< Round toward zero.
-    AV_ROUND_INF      = 1, ///< Round away from zero.
-    AV_ROUND_DOWN     = 2, ///< Round toward -infinity.
-    AV_ROUND_UP       = 3, ///< Round toward +infinity.
-    AV_ROUND_NEAR_INF = 5, ///< Round to nearest and halfway cases away from zero.
-    AV_ROUND_PASS_MINMAX = 8192, ///< Flag to pass INT64_MIN/MAX through instead of rescaling, this avoids special cases for AV_NOPTS_VALUE
-};
-
-/**
- * Return the greatest common divisor of a and b.
- * If both a and b are 0 or either or both are <0 then behavior is
- * undefined.
- */
-int64_t av_const av_gcd(int64_t a, int64_t b);
-
-/**
- * Rescale a 64-bit integer with rounding to nearest.
- * A simple a*b/c isn't possible as it can overflow.
- */
-int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const;
-
-/**
- * Rescale a 64-bit integer with specified rounding.
- * A simple a*b/c isn't possible as it can overflow.
- *
- * @return rescaled value a, or if AV_ROUND_PASS_MINMAX is set and a is
- *         INT64_MIN or INT64_MAX then a is passed through unchanged.
- */
-int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding) av_const;
-
-/**
- * Rescale a 64-bit integer by 2 rational numbers.
- */
-int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const;
-
-/**
- * Rescale a 64-bit integer by 2 rational numbers with specified rounding.
- *
- * @return rescaled value a, or if AV_ROUND_PASS_MINMAX is set and a is
- *         INT64_MIN or INT64_MAX then a is passed through unchanged.
- */
-int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq,
-                         enum AVRounding) av_const;
-
-/**
- * Compare 2 timestamps each in its own timebases.
- * The result of the function is undefined if one of the timestamps
- * is outside the int64_t range when represented in the others timebase.
- * @return -1 if ts_a is before ts_b, 1 if ts_a is after ts_b or 0 if they represent the same position
- */
-int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b);
-
-/**
- * Compare 2 integers modulo mod.
- * That is we compare integers a and b for which only the least
- * significant log2(mod) bits are known.
- *
- * @param mod must be a power of 2
- * @return a negative value if a is smaller than b
- *         a positive value if a is greater than b
- *         0                if a equals          b
- */
-int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod);
-
-/**
- * Rescale a timestamp while preserving known durations.
- *
- * @param in_ts Input timestamp
- * @param in_tb Input timebase
- * @param fs_tb Duration and *last timebase
- * @param duration duration till the next call
- * @param out_tb Output timebase
- */
-int64_t av_rescale_delta(AVRational in_tb, int64_t in_ts,  AVRational fs_tb, int duration, int64_t *last, AVRational out_tb);
-
-/**
- * Add a value to a timestamp.
- *
- * This function guarantees that when the same value is repeatly added that
- * no accumulation of rounding errors occurs.
- *
- * @param ts Input timestamp
- * @param ts_tb Input timestamp timebase
- * @param inc value to add to ts
- * @param inc_tb inc timebase
- */
-int64_t av_add_stable(AVRational ts_tb, int64_t ts, AVRational inc_tb, int64_t inc);
-
-
-    /**
- * @}
- */
-
-#endif /* AVUTIL_MATHEMATICS_H */

Externals/ffmpeg/include/libavutil/md5.h

@@ -1,81 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_MD5_H
-#define AVUTIL_MD5_H
-
-#include <stdint.h>
-
-#include "attributes.h"
-#include "version.h"
-
-/**
- * @defgroup lavu_md5 MD5
- * @ingroup lavu_crypto
- * @{
- */
-
-extern const int av_md5_size;
-
-struct AVMD5;
-
-/**
- * Allocate an AVMD5 context.
- */
-struct AVMD5 *av_md5_alloc(void);
-
-/**
- * Initialize MD5 hashing.
- *
- * @param ctx pointer to the function context (of size av_md5_size)
- */
-void av_md5_init(struct AVMD5 *ctx);
-
-/**
- * Update hash value.
- *
- * @param ctx hash function context
- * @param src input data to update hash with
- * @param len input data length
- */
-void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, int len);
-
-/**
- * Finish hashing and output digest value.
- *
- * @param ctx hash function context
- * @param dst buffer where output digest value is stored
- */
-void av_md5_final(struct AVMD5 *ctx, uint8_t *dst);
-
-/**
- * Hash an array of data.
- *
- * @param dst The output buffer to write the digest into
- * @param src The data to hash
- * @param len The length of the data, in bytes
- */
-void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_MD5_H */

Externals/ffmpeg/include/libavutil/mem.h

@@ -1,389 +0,0 @@
-/*
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * memory handling functions
- */
-
-#ifndef AVUTIL_MEM_H
-#define AVUTIL_MEM_H
-
-#include <limits.h>
-#include <stdint.h>
-
-#include "attributes.h"
-#include "error.h"
-#include "avutil.h"
-
-/**
- * @addtogroup lavu_mem
- * @{
- */
-
-
-#if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1110 || defined(__SUNPRO_C)
-    #define DECLARE_ALIGNED(n,t,v)      t __attribute__ ((aligned (n))) v
-    #define DECLARE_ASM_CONST(n,t,v)    const t __attribute__ ((aligned (n))) v
-#elif defined(__TI_COMPILER_VERSION__)
-    #define DECLARE_ALIGNED(n,t,v)                      \
-        AV_PRAGMA(DATA_ALIGN(v,n))                      \
-        t __attribute__((aligned(n))) v
-    #define DECLARE_ASM_CONST(n,t,v)                    \
-        AV_PRAGMA(DATA_ALIGN(v,n))                      \
-        static const t __attribute__((aligned(n))) v
-#elif defined(__GNUC__)
-    #define DECLARE_ALIGNED(n,t,v)      t __attribute__ ((aligned (n))) v
-    #define DECLARE_ASM_CONST(n,t,v)    static const t av_used __attribute__ ((aligned (n))) v
-#elif defined(_MSC_VER)
-    #define DECLARE_ALIGNED(n,t,v)      __declspec(align(n)) t v
-    #define DECLARE_ASM_CONST(n,t,v)    __declspec(align(n)) static const t v
-#else
-    #define DECLARE_ALIGNED(n,t,v)      t v
-    #define DECLARE_ASM_CONST(n,t,v)    static const t v
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(3,1)
-    #define av_malloc_attrib __attribute__((__malloc__))
-#else
-    #define av_malloc_attrib
-#endif
-
-#if AV_GCC_VERSION_AT_LEAST(4,3)
-    #define av_alloc_size(...) __attribute__((alloc_size(__VA_ARGS__)))
-#else
-    #define av_alloc_size(...)
-#endif
-
-/**
- * Allocate a block of size bytes with alignment suitable for all
- * memory accesses (including vectors if available on the CPU).
- * @param size Size in bytes for the memory block to be allocated.
- * @return Pointer to the allocated block, NULL if the block cannot
- * be allocated.
- * @see av_mallocz()
- */
-void *av_malloc(size_t size) av_malloc_attrib av_alloc_size(1);
-
-/**
- * Allocate a block of size * nmemb bytes with av_malloc().
- * @param nmemb Number of elements
- * @param size Size of the single element
- * @return Pointer to the allocated block, NULL if the block cannot
- * be allocated.
- * @see av_malloc()
- */
-av_alloc_size(1, 2) static inline void *av_malloc_array(size_t nmemb, size_t size)
-{
-    if (!size || nmemb >= INT_MAX / size)
-        return NULL;
-    return av_malloc(nmemb * size);
-}
-
-/**
- * Allocate or reallocate a block of memory.
- * If ptr is NULL and size > 0, allocate a new block. If
- * size is zero, free the memory block pointed to by ptr.
- * @param ptr Pointer to a memory block already allocated with
- * av_realloc() or NULL.
- * @param size Size in bytes of the memory block to be allocated or
- * reallocated.
- * @return Pointer to a newly-reallocated block or NULL if the block
- * cannot be reallocated or the function is used to free the memory block.
- * @warning Pointers originating from the av_malloc() family of functions must
- *          not be passed to av_realloc(). The former can be implemented using
- *          memalign() (or other functions), and there is no guarantee that
- *          pointers from such functions can be passed to realloc() at all.
- *          The situation is undefined according to POSIX and may crash with
- *          some libc implementations.
- * @see av_fast_realloc()
- */
-void *av_realloc(void *ptr, size_t size) av_alloc_size(2);
-
-/**
- * Allocate or reallocate a block of memory.
- * This function does the same thing as av_realloc, except:
- * - It takes two arguments and checks the result of the multiplication for
- *   integer overflow.
- * - It frees the input block in case of failure, thus avoiding the memory
- *   leak with the classic "buf = realloc(buf); if (!buf) return -1;".
- */
-void *av_realloc_f(void *ptr, size_t nelem, size_t elsize);
-
-/**
- * Allocate or reallocate a block of memory.
- * If *ptr is NULL and size > 0, allocate a new block. If
- * size is zero, free the memory block pointed to by ptr.
- * @param   ptr Pointer to a pointer to a memory block already allocated
- *          with av_realloc(), or pointer to a pointer to NULL.
- *          The pointer is updated on success, or freed on failure.
- * @param   size Size in bytes for the memory block to be allocated or
- *          reallocated
- * @return  Zero on success, an AVERROR error code on failure.
- * @warning Pointers originating from the av_malloc() family of functions must
- *          not be passed to av_reallocp(). The former can be implemented using
- *          memalign() (or other functions), and there is no guarantee that
- *          pointers from such functions can be passed to realloc() at all.
- *          The situation is undefined according to POSIX and may crash with
- *          some libc implementations.
- */
-int av_reallocp(void *ptr, size_t size);
-
-/**
- * Allocate or reallocate an array.
- * If ptr is NULL and nmemb > 0, allocate a new block. If
- * nmemb is zero, free the memory block pointed to by ptr.
- * @param ptr Pointer to a memory block already allocated with
- * av_realloc() or NULL.
- * @param nmemb Number of elements
- * @param size Size of the single element
- * @return Pointer to a newly-reallocated block or NULL if the block
- * cannot be reallocated or the function is used to free the memory block.
- * @warning Pointers originating from the av_malloc() family of functions must
- *          not be passed to av_realloc(). The former can be implemented using
- *          memalign() (or other functions), and there is no guarantee that
- *          pointers from such functions can be passed to realloc() at all.
- *          The situation is undefined according to POSIX and may crash with
- *          some libc implementations.
- */
-av_alloc_size(2, 3) void *av_realloc_array(void *ptr, size_t nmemb, size_t size);
-
-/**
- * Allocate or reallocate an array through a pointer to a pointer.
- * If *ptr is NULL and nmemb > 0, allocate a new block. If
- * nmemb is zero, free the memory block pointed to by ptr.
- * @param ptr Pointer to a pointer to a memory block already allocated
- * with av_realloc(), or pointer to a pointer to NULL.
- * The pointer is updated on success, or freed on failure.
- * @param nmemb Number of elements
- * @param size Size of the single element
- * @return Zero on success, an AVERROR error code on failure.
- * @warning Pointers originating from the av_malloc() family of functions must
- *          not be passed to av_realloc(). The former can be implemented using
- *          memalign() (or other functions), and there is no guarantee that
- *          pointers from such functions can be passed to realloc() at all.
- *          The situation is undefined according to POSIX and may crash with
- *          some libc implementations.
- */
-av_alloc_size(2, 3) int av_reallocp_array(void *ptr, size_t nmemb, size_t size);
-
-/**
- * Free a memory block which has been allocated with av_malloc(z)() or
- * av_realloc().
- * @param ptr Pointer to the memory block which should be freed.
- * @note ptr = NULL is explicitly allowed.
- * @note It is recommended that you use av_freep() instead.
- * @see av_freep()
- */
-void av_free(void *ptr);
-
-/**
- * Allocate a block of size bytes with alignment suitable for all
- * memory accesses (including vectors if available on the CPU) and
- * zero all the bytes of the block.
- * @param size Size in bytes for the memory block to be allocated.
- * @return Pointer to the allocated block, NULL if it cannot be allocated.
- * @see av_malloc()
- */
-void *av_mallocz(size_t size) av_malloc_attrib av_alloc_size(1);
-
-/**
- * Allocate a block of nmemb * size bytes with alignment suitable for all
- * memory accesses (including vectors if available on the CPU) and
- * zero all the bytes of the block.
- * The allocation will fail if nmemb * size is greater than or equal
- * to INT_MAX.
- * @param nmemb
- * @param size
- * @return Pointer to the allocated block, NULL if it cannot be allocated.
- */
-void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib;
-
-/**
- * Allocate a block of size * nmemb bytes with av_mallocz().
- * @param nmemb Number of elements
- * @param size Size of the single element
- * @return Pointer to the allocated block, NULL if the block cannot
- * be allocated.
- * @see av_mallocz()
- * @see av_malloc_array()
- */
-av_alloc_size(1, 2) static inline void *av_mallocz_array(size_t nmemb, size_t size)
-{
-    if (!size || nmemb >= INT_MAX / size)
-        return NULL;
-    return av_mallocz(nmemb * size);
-}
-
-/**
- * Duplicate the string s.
- * @param s string to be duplicated
- * @return Pointer to a newly-allocated string containing a
- * copy of s or NULL if the string cannot be allocated.
- */
-char *av_strdup(const char *s) av_malloc_attrib;
-
-/**
- * Duplicate a substring of the string s.
- * @param s string to be duplicated
- * @param len the maximum length of the resulting string (not counting the
- *            terminating byte).
- * @return Pointer to a newly-allocated string containing a
- * copy of s or NULL if the string cannot be allocated.
- */
-char *av_strndup(const char *s, size_t len) av_malloc_attrib;
-
-/**
- * Duplicate the buffer p.
- * @param p buffer to be duplicated
- * @return Pointer to a newly allocated buffer containing a
- * copy of p or NULL if the buffer cannot be allocated.
- */
-void *av_memdup(const void *p, size_t size);
-
-/**
- * Free a memory block which has been allocated with av_malloc(z)() or
- * av_realloc() and set the pointer pointing to it to NULL.
- * @param ptr Pointer to the pointer to the memory block which should
- * be freed.
- * @note passing a pointer to a NULL pointer is safe and leads to no action.
- * @see av_free()
- */
-void av_freep(void *ptr);
-
-/**
- * Add an element to a dynamic array.
- *
- * The array to grow is supposed to be an array of pointers to
- * structures, and the element to add must be a pointer to an already
- * allocated structure.
- *
- * The array is reallocated when its size reaches powers of 2.
- * Therefore, the amortized cost of adding an element is constant.
- *
- * In case of success, the pointer to the array is updated in order to
- * point to the new grown array, and the number pointed to by nb_ptr
- * is incremented.
- * In case of failure, the array is freed, *tab_ptr is set to NULL and
- * *nb_ptr is set to 0.
- *
- * @param tab_ptr pointer to the array to grow
- * @param nb_ptr  pointer to the number of elements in the array
- * @param elem    element to add
- * @see av_dynarray_add_nofree(), av_dynarray2_add()
- */
-void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem);
-
-/**
- * Add an element to a dynamic array.
- *
- * Function has the same functionality as av_dynarray_add(),
- * but it doesn't free memory on fails. It returns error code
- * instead and leave current buffer untouched.
- *
- * @param tab_ptr pointer to the array to grow
- * @param nb_ptr  pointer to the number of elements in the array
- * @param elem    element to add
- * @return >=0 on success, negative otherwise.
- * @see av_dynarray_add(), av_dynarray2_add()
- */
-int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem);
-
-/**
- * Add an element of size elem_size to a dynamic array.
- *
- * The array is reallocated when its number of elements reaches powers of 2.
- * Therefore, the amortized cost of adding an element is constant.
- *
- * In case of success, the pointer to the array is updated in order to
- * point to the new grown array, and the number pointed to by nb_ptr
- * is incremented.
- * In case of failure, the array is freed, *tab_ptr is set to NULL and
- * *nb_ptr is set to 0.
- *
- * @param tab_ptr   pointer to the array to grow
- * @param nb_ptr    pointer to the number of elements in the array
- * @param elem_size size in bytes of the elements in the array
- * @param elem_data pointer to the data of the element to add. If NULL, the space of
- *                  the new added element is not filled.
- * @return          pointer to the data of the element to copy in the new allocated space.
- *                  If NULL, the new allocated space is left uninitialized."
- * @see av_dynarray_add(), av_dynarray_add_nofree()
- */
-void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size,
-                       const uint8_t *elem_data);
-
-/**
- * Multiply two size_t values checking for overflow.
- * @return  0 if success, AVERROR(EINVAL) if overflow.
- */
-static inline int av_size_mult(size_t a, size_t b, size_t *r)
-{
-    size_t t = a * b;
-    /* Hack inspired from glibc: only try the division if nelem and elsize
-     * are both greater than sqrt(SIZE_MAX). */
-    if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
-        return AVERROR(EINVAL);
-    *r = t;
-    return 0;
-}
-
-/**
- * Set the maximum size that may me allocated in one block.
- */
-void av_max_alloc(size_t max);
-
-/**
- * deliberately overlapping memcpy implementation
- * @param dst destination buffer
- * @param back how many bytes back we start (the initial size of the overlapping window), must be > 0
- * @param cnt number of bytes to copy, must be >= 0
- *
- * cnt > back is valid, this will copy the bytes we just copied,
- * thus creating a repeating pattern with a period length of back.
- */
-void av_memcpy_backptr(uint8_t *dst, int back, int cnt);
-
-/**
- * Reallocate the given block if it is not large enough, otherwise do nothing.
- *
- * @see av_realloc
- */
-void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size);
-
-/**
- * Allocate a buffer, reusing the given one if large enough.
- *
- * Contrary to av_fast_realloc the current buffer contents might not be
- * preserved and on error the old buffer is freed, thus no special
- * handling to avoid memleaks is necessary.
- *
- * @param ptr pointer to pointer to already allocated buffer, overwritten with pointer to new buffer
- * @param size size of the buffer *ptr points to
- * @param min_size minimum size of *ptr buffer after returning, *ptr will be NULL and
- *                 *size 0 if an error occurred.
- */
-void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_MEM_H */

Externals/ffmpeg/include/libavutil/motion_vector.h

@@ -1,50 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_MOTION_VECTOR_H
-#define AVUTIL_MOTION_VECTOR_H
-
-#include <stdint.h>
-
-typedef struct AVMotionVector {
-    /**
-     * Where the current macroblock comes from; negative value when it comes
-     * from the past, positive value when it comes from the future.
-     * XXX: set exact relative ref frame reference instead of a +/- 1 "direction".
-     */
-    int32_t source;
-    /**
-     * Width and height of the block.
-     */
-    uint8_t w, h;
-    /**
-     * Absolute source position. Can be outside the frame area.
-     */
-    int16_t src_x, src_y;
-    /**
-     * Absolute destination position. Can be outside the frame area.
-     */
-    int16_t dst_x, dst_y;
-    /**
-     * Extra flag information.
-     * Currently unused.
-     */
-    uint64_t flags;
-} AVMotionVector;
-
-#endif /* AVUTIL_MOTION_VECTOR_H */

Externals/ffmpeg/include/libavutil/murmur3.h

@@ -1,32 +0,0 @@
-/*
- * Copyright (C) 2013 Reimar Döffinger <Reimar.Doeffinger@gmx.de>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_MURMUR3_H
-#define AVUTIL_MURMUR3_H
-
-#include <stdint.h>
-
-struct AVMurMur3 *av_murmur3_alloc(void);
-void av_murmur3_init_seeded(struct AVMurMur3 *c, uint64_t seed);
-void av_murmur3_init(struct AVMurMur3 *c);
-void av_murmur3_update(struct AVMurMur3 *c, const uint8_t *src, int len);
-void av_murmur3_final(struct AVMurMur3 *c, uint8_t dst[16]);
-
-#endif /* AVUTIL_MURMUR3_H */

Externals/ffmpeg/include/libavutil/old_pix_fmts.h

@@ -1,177 +0,0 @@
-/*
- * copyright (c) 2006-2012 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_OLD_PIX_FMTS_H
-#define AVUTIL_OLD_PIX_FMTS_H
-
-/*
- * This header exists to prevent new pixel formats from being accidentally added
- * to the deprecated list.
- * Do not include it directly. It will be removed on next major bump
- *
- * Do not add new items to this list. Use the AVPixelFormat enum instead.
- */
-    PIX_FMT_NONE = AV_PIX_FMT_NONE,
-    PIX_FMT_YUV420P,   ///< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
-    PIX_FMT_YUYV422,   ///< packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
-    PIX_FMT_RGB24,     ///< packed RGB 8:8:8, 24bpp, RGBRGB...
-    PIX_FMT_BGR24,     ///< packed RGB 8:8:8, 24bpp, BGRBGR...
-    PIX_FMT_YUV422P,   ///< planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
-    PIX_FMT_YUV444P,   ///< planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
-    PIX_FMT_YUV410P,   ///< planar YUV 4:1:0,  9bpp, (1 Cr & Cb sample per 4x4 Y samples)
-    PIX_FMT_YUV411P,   ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
-    PIX_FMT_GRAY8,     ///<        Y        ,  8bpp
-    PIX_FMT_MONOWHITE, ///<        Y        ,  1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb
-    PIX_FMT_MONOBLACK, ///<        Y        ,  1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb
-    PIX_FMT_PAL8,      ///< 8 bit with PIX_FMT_RGB32 palette
-    PIX_FMT_YUVJ420P,  ///< planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV420P and setting color_range
-    PIX_FMT_YUVJ422P,  ///< planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV422P and setting color_range
-    PIX_FMT_YUVJ444P,  ///< planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV444P and setting color_range
-#if FF_API_XVMC
-    PIX_FMT_XVMC_MPEG2_MC,///< XVideo Motion Acceleration via common packet passing
-    PIX_FMT_XVMC_MPEG2_IDCT,
-#endif /* FF_API_XVMC */
-    PIX_FMT_UYVY422,   ///< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
-    PIX_FMT_UYYVYY411, ///< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
-    PIX_FMT_BGR8,      ///< packed RGB 3:3:2,  8bpp, (msb)2B 3G 3R(lsb)
-    PIX_FMT_BGR4,      ///< packed RGB 1:2:1 bitstream,  4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits
-    PIX_FMT_BGR4_BYTE, ///< packed RGB 1:2:1,  8bpp, (msb)1B 2G 1R(lsb)
-    PIX_FMT_RGB8,      ///< packed RGB 3:3:2,  8bpp, (msb)2R 3G 3B(lsb)
-    PIX_FMT_RGB4,      ///< packed RGB 1:2:1 bitstream,  4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits
-    PIX_FMT_RGB4_BYTE, ///< packed RGB 1:2:1,  8bpp, (msb)1R 2G 1B(lsb)
-    PIX_FMT_NV12,      ///< planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V)
-    PIX_FMT_NV21,      ///< as above, but U and V bytes are swapped
-
-    PIX_FMT_ARGB,      ///< packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
-    PIX_FMT_RGBA,      ///< packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
-    PIX_FMT_ABGR,      ///< packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
-    PIX_FMT_BGRA,      ///< packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
-
-    PIX_FMT_GRAY16BE,  ///<        Y        , 16bpp, big-endian
-    PIX_FMT_GRAY16LE,  ///<        Y        , 16bpp, little-endian
-    PIX_FMT_YUV440P,   ///< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
-    PIX_FMT_YUVJ440P,  ///< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of PIX_FMT_YUV440P and setting color_range
-    PIX_FMT_YUVA420P,  ///< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
-#if FF_API_VDPAU
-    PIX_FMT_VDPAU_H264,///< H.264 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
-    PIX_FMT_VDPAU_MPEG1,///< MPEG-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
-    PIX_FMT_VDPAU_MPEG2,///< MPEG-2 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
-    PIX_FMT_VDPAU_WMV3,///< WMV3 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
-    PIX_FMT_VDPAU_VC1, ///< VC-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
-#endif
-    PIX_FMT_RGB48BE,   ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big-endian
-    PIX_FMT_RGB48LE,   ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as little-endian
-
-    PIX_FMT_RGB565BE,  ///< packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), big-endian
-    PIX_FMT_RGB565LE,  ///< packed RGB 5:6:5, 16bpp, (msb)   5R 6G 5B(lsb), little-endian
-    PIX_FMT_RGB555BE,  ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), big-endian, most significant bit to 0
-    PIX_FMT_RGB555LE,  ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), little-endian, most significant bit to 0
-
-    PIX_FMT_BGR565BE,  ///< packed BGR 5:6:5, 16bpp, (msb)   5B 6G 5R(lsb), big-endian
-    PIX_FMT_BGR565LE,  ///< packed BGR 5:6:5, 16bpp, (msb)   5B 6G 5R(lsb), little-endian
-    PIX_FMT_BGR555BE,  ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), big-endian, most significant bit to 1
-    PIX_FMT_BGR555LE,  ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), little-endian, most significant bit to 1
-
-    PIX_FMT_VAAPI_MOCO, ///< HW acceleration through VA API at motion compensation entry-point, Picture.data[3] contains a vaapi_render_state struct which contains macroblocks as well as various fields extracted from headers
-    PIX_FMT_VAAPI_IDCT, ///< HW acceleration through VA API at IDCT entry-point, Picture.data[3] contains a vaapi_render_state struct which contains fields extracted from headers
-    PIX_FMT_VAAPI_VLD,  ///< HW decoding through VA API, Picture.data[3] contains a vaapi_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
-
-    PIX_FMT_YUV420P16LE,  ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
-    PIX_FMT_YUV420P16BE,  ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
-    PIX_FMT_YUV422P16LE,  ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
-    PIX_FMT_YUV422P16BE,  ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
-    PIX_FMT_YUV444P16LE,  ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
-    PIX_FMT_YUV444P16BE,  ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
-#if FF_API_VDPAU
-    PIX_FMT_VDPAU_MPEG4,  ///< MPEG4 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers
-#endif
-    PIX_FMT_DXVA2_VLD,    ///< HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer
-
-    PIX_FMT_RGB444LE,  ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), little-endian, most significant bits to 0
-    PIX_FMT_RGB444BE,  ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), big-endian, most significant bits to 0
-    PIX_FMT_BGR444LE,  ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), little-endian, most significant bits to 1
-    PIX_FMT_BGR444BE,  ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), big-endian, most significant bits to 1
-    PIX_FMT_GRAY8A,    ///< 8bit gray, 8bit alpha
-    PIX_FMT_BGR48BE,   ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big-endian
-    PIX_FMT_BGR48LE,   ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as little-endian
-
-    //the following 10 formats have the disadvantage of needing 1 format for each bit depth, thus
-    //If you want to support multiple bit depths, then using PIX_FMT_YUV420P16* with the bpp stored separately
-    //is better
-    PIX_FMT_YUV420P9BE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
-    PIX_FMT_YUV420P9LE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
-    PIX_FMT_YUV420P10BE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
-    PIX_FMT_YUV420P10LE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
-    PIX_FMT_YUV422P10BE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
-    PIX_FMT_YUV422P10LE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
-    PIX_FMT_YUV444P9BE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
-    PIX_FMT_YUV444P9LE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
-    PIX_FMT_YUV444P10BE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
-    PIX_FMT_YUV444P10LE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
-    PIX_FMT_YUV422P9BE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
-    PIX_FMT_YUV422P9LE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
-    PIX_FMT_VDA_VLD,    ///< hardware decoding through VDA
-
-#ifdef AV_PIX_FMT_ABI_GIT_MASTER
-    PIX_FMT_RGBA64BE,  ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
-    PIX_FMT_RGBA64LE,  ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
-    PIX_FMT_BGRA64BE,  ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
-    PIX_FMT_BGRA64LE,  ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
-#endif
-    PIX_FMT_GBRP,      ///< planar GBR 4:4:4 24bpp
-    PIX_FMT_GBRP9BE,   ///< planar GBR 4:4:4 27bpp, big endian
-    PIX_FMT_GBRP9LE,   ///< planar GBR 4:4:4 27bpp, little endian
-    PIX_FMT_GBRP10BE,  ///< planar GBR 4:4:4 30bpp, big endian
-    PIX_FMT_GBRP10LE,  ///< planar GBR 4:4:4 30bpp, little endian
-    PIX_FMT_GBRP16BE,  ///< planar GBR 4:4:4 48bpp, big endian
-    PIX_FMT_GBRP16LE,  ///< planar GBR 4:4:4 48bpp, little endian
-
-#ifndef AV_PIX_FMT_ABI_GIT_MASTER
-    PIX_FMT_RGBA64BE=0x123,  ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
-    PIX_FMT_RGBA64LE,  ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
-    PIX_FMT_BGRA64BE,  ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
-    PIX_FMT_BGRA64LE,  ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
-#endif
-    PIX_FMT_0RGB=0x123+4,      ///< packed RGB 8:8:8, 32bpp, 0RGB0RGB...
-    PIX_FMT_RGB0,      ///< packed RGB 8:8:8, 32bpp, RGB0RGB0...
-    PIX_FMT_0BGR,      ///< packed BGR 8:8:8, 32bpp, 0BGR0BGR...
-    PIX_FMT_BGR0,      ///< packed BGR 8:8:8, 32bpp, BGR0BGR0...
-    PIX_FMT_YUVA444P,  ///< planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
-    PIX_FMT_YUVA422P,  ///< planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
-
-    PIX_FMT_YUV420P12BE, ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
-    PIX_FMT_YUV420P12LE, ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
-    PIX_FMT_YUV420P14BE, ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
-    PIX_FMT_YUV420P14LE, ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
-    PIX_FMT_YUV422P12BE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
-    PIX_FMT_YUV422P12LE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
-    PIX_FMT_YUV422P14BE, ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
-    PIX_FMT_YUV422P14LE, ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
-    PIX_FMT_YUV444P12BE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
-    PIX_FMT_YUV444P12LE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
-    PIX_FMT_YUV444P14BE, ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
-    PIX_FMT_YUV444P14LE, ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
-    PIX_FMT_GBRP12BE,    ///< planar GBR 4:4:4 36bpp, big endian
-    PIX_FMT_GBRP12LE,    ///< planar GBR 4:4:4 36bpp, little endian
-    PIX_FMT_GBRP14BE,    ///< planar GBR 4:4:4 42bpp, big endian
-    PIX_FMT_GBRP14LE,    ///< planar GBR 4:4:4 42bpp, little endian
-
-    PIX_FMT_NB,        ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
-#endif /* AVUTIL_OLD_PIX_FMTS_H */

Externals/ffmpeg/include/libavutil/opt.h

@@ -1,901 +0,0 @@
-/*
- * AVOptions
- * copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_OPT_H
-#define AVUTIL_OPT_H
-
-/**
- * @file
- * AVOptions
- */
-
-#include "rational.h"
-#include "avutil.h"
-#include "dict.h"
-#include "log.h"
-#include "pixfmt.h"
-#include "samplefmt.h"
-#include "version.h"
-
-/**
- * @defgroup avoptions AVOptions
- * @ingroup lavu_data
- * @{
- * AVOptions provide a generic system to declare options on arbitrary structs
- * ("objects"). An option can have a help text, a type and a range of possible
- * values. Options may then be enumerated, read and written to.
- *
- * @section avoptions_implement Implementing AVOptions
- * This section describes how to add AVOptions capabilities to a struct.
- *
- * All AVOptions-related information is stored in an AVClass. Therefore
- * the first member of the struct should be a pointer to an AVClass describing it.
- * The option field of the AVClass must be set to a NULL-terminated static array
- * of AVOptions. Each AVOption must have a non-empty name, a type, a default
- * value and for number-type AVOptions also a range of allowed values. It must
- * also declare an offset in bytes from the start of the struct, where the field
- * associated with this AVOption is located. Other fields in the AVOption struct
- * should also be set when applicable, but are not required.
- *
- * The following example illustrates an AVOptions-enabled struct:
- * @code
- * typedef struct test_struct {
- *     AVClass *class;
- *     int      int_opt;
- *     char    *str_opt;
- *     uint8_t *bin_opt;
- *     int      bin_len;
- * } test_struct;
- *
- * static const AVOption test_options[] = {
- *   { "test_int", "This is a test option of int type.", offsetof(test_struct, int_opt),
- *     AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX },
- *   { "test_str", "This is a test option of string type.", offsetof(test_struct, str_opt),
- *     AV_OPT_TYPE_STRING },
- *   { "test_bin", "This is a test option of binary type.", offsetof(test_struct, bin_opt),
- *     AV_OPT_TYPE_BINARY },
- *   { NULL },
- * };
- *
- * static const AVClass test_class = {
- *     .class_name = "test class",
- *     .item_name  = av_default_item_name,
- *     .option     = test_options,
- *     .version    = LIBAVUTIL_VERSION_INT,
- * };
- * @endcode
- *
- * Next, when allocating your struct, you must ensure that the AVClass pointer
- * is set to the correct value. Then, av_opt_set_defaults() can be called to
- * initialize defaults. After that the struct is ready to be used with the
- * AVOptions API.
- *
- * When cleaning up, you may use the av_opt_free() function to automatically
- * free all the allocated string and binary options.
- *
- * Continuing with the above example:
- *
- * @code
- * test_struct *alloc_test_struct(void)
- * {
- *     test_struct *ret = av_malloc(sizeof(*ret));
- *     ret->class = &test_class;
- *     av_opt_set_defaults(ret);
- *     return ret;
- * }
- * void free_test_struct(test_struct **foo)
- * {
- *     av_opt_free(*foo);
- *     av_freep(foo);
- * }
- * @endcode
- *
- * @subsection avoptions_implement_nesting Nesting
- *      It may happen that an AVOptions-enabled struct contains another
- *      AVOptions-enabled struct as a member (e.g. AVCodecContext in
- *      libavcodec exports generic options, while its priv_data field exports
- *      codec-specific options). In such a case, it is possible to set up the
- *      parent struct to export a child's options. To do that, simply
- *      implement AVClass.child_next() and AVClass.child_class_next() in the
- *      parent struct's AVClass.
- *      Assuming that the test_struct from above now also contains a
- *      child_struct field:
- *
- *      @code
- *      typedef struct child_struct {
- *          AVClass *class;
- *          int flags_opt;
- *      } child_struct;
- *      static const AVOption child_opts[] = {
- *          { "test_flags", "This is a test option of flags type.",
- *            offsetof(child_struct, flags_opt), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT_MIN, INT_MAX },
- *          { NULL },
- *      };
- *      static const AVClass child_class = {
- *          .class_name = "child class",
- *          .item_name  = av_default_item_name,
- *          .option     = child_opts,
- *          .version    = LIBAVUTIL_VERSION_INT,
- *      };
- *
- *      void *child_next(void *obj, void *prev)
- *      {
- *          test_struct *t = obj;
- *          if (!prev && t->child_struct)
- *              return t->child_struct;
- *          return NULL
- *      }
- *      const AVClass child_class_next(const AVClass *prev)
- *      {
- *          return prev ? NULL : &child_class;
- *      }
- *      @endcode
- *      Putting child_next() and child_class_next() as defined above into
- *      test_class will now make child_struct's options accessible through
- *      test_struct (again, proper setup as described above needs to be done on
- *      child_struct right after it is created).
- *
- *      From the above example it might not be clear why both child_next()
- *      and child_class_next() are needed. The distinction is that child_next()
- *      iterates over actually existing objects, while child_class_next()
- *      iterates over all possible child classes. E.g. if an AVCodecContext
- *      was initialized to use a codec which has private options, then its
- *      child_next() will return AVCodecContext.priv_data and finish
- *      iterating. OTOH child_class_next() on AVCodecContext.av_class will
- *      iterate over all available codecs with private options.
- *
- * @subsection avoptions_implement_named_constants Named constants
- *      It is possible to create named constants for options. Simply set the unit
- *      field of the option the constants should apply to a string and
- *      create the constants themselves as options of type AV_OPT_TYPE_CONST
- *      with their unit field set to the same string.
- *      Their default_val field should contain the value of the named
- *      constant.
- *      For example, to add some named constants for the test_flags option
- *      above, put the following into the child_opts array:
- *      @code
- *      { "test_flags", "This is a test option of flags type.",
- *        offsetof(child_struct, flags_opt), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT_MIN, INT_MAX, "test_unit" },
- *      { "flag1", "This is a flag with value 16", 0, AV_OPT_TYPE_CONST, { .i64 = 16 }, 0, 0, "test_unit" },
- *      @endcode
- *
- * @section avoptions_use Using AVOptions
- * This section deals with accessing options in an AVOptions-enabled struct.
- * Such structs in FFmpeg are e.g. AVCodecContext in libavcodec or
- * AVFormatContext in libavformat.
- *
- * @subsection avoptions_use_examine Examining AVOptions
- * The basic functions for examining options are av_opt_next(), which iterates
- * over all options defined for one object, and av_opt_find(), which searches
- * for an option with the given name.
- *
- * The situation is more complicated with nesting. An AVOptions-enabled struct
- * may have AVOptions-enabled children. Passing the AV_OPT_SEARCH_CHILDREN flag
- * to av_opt_find() will make the function search children recursively.
- *
- * For enumerating there are basically two cases. The first is when you want to
- * get all options that may potentially exist on the struct and its children
- * (e.g.  when constructing documentation). In that case you should call
- * av_opt_child_class_next() recursively on the parent struct's AVClass.  The
- * second case is when you have an already initialized struct with all its
- * children and you want to get all options that can be actually written or read
- * from it. In that case you should call av_opt_child_next() recursively (and
- * av_opt_next() on each result).
- *
- * @subsection avoptions_use_get_set Reading and writing AVOptions
- * When setting options, you often have a string read directly from the
- * user. In such a case, simply passing it to av_opt_set() is enough. For
- * non-string type options, av_opt_set() will parse the string according to the
- * option type.
- *
- * Similarly av_opt_get() will read any option type and convert it to a string
- * which will be returned. Do not forget that the string is allocated, so you
- * have to free it with av_free().
- *
- * In some cases it may be more convenient to put all options into an
- * AVDictionary and call av_opt_set_dict() on it. A specific case of this
- * are the format/codec open functions in lavf/lavc which take a dictionary
- * filled with option as a parameter. This allows to set some options
- * that cannot be set otherwise, since e.g. the input file format is not known
- * before the file is actually opened.
- */
-
-enum AVOptionType{
-    AV_OPT_TYPE_FLAGS,
-    AV_OPT_TYPE_INT,
-    AV_OPT_TYPE_INT64,
-    AV_OPT_TYPE_DOUBLE,
-    AV_OPT_TYPE_FLOAT,
-    AV_OPT_TYPE_STRING,
-    AV_OPT_TYPE_RATIONAL,
-    AV_OPT_TYPE_BINARY,  ///< offset must point to a pointer immediately followed by an int for the length
-    AV_OPT_TYPE_DICT,
-    AV_OPT_TYPE_CONST = 128,
-    AV_OPT_TYPE_IMAGE_SIZE = MKBETAG('S','I','Z','E'), ///< offset must point to two consecutive integers
-    AV_OPT_TYPE_PIXEL_FMT  = MKBETAG('P','F','M','T'),
-    AV_OPT_TYPE_SAMPLE_FMT = MKBETAG('S','F','M','T'),
-    AV_OPT_TYPE_VIDEO_RATE = MKBETAG('V','R','A','T'), ///< offset must point to AVRational
-    AV_OPT_TYPE_DURATION   = MKBETAG('D','U','R',' '),
-    AV_OPT_TYPE_COLOR      = MKBETAG('C','O','L','R'),
-    AV_OPT_TYPE_CHANNEL_LAYOUT = MKBETAG('C','H','L','A'),
-#if FF_API_OLD_AVOPTIONS
-    FF_OPT_TYPE_FLAGS = 0,
-    FF_OPT_TYPE_INT,
-    FF_OPT_TYPE_INT64,
-    FF_OPT_TYPE_DOUBLE,
-    FF_OPT_TYPE_FLOAT,
-    FF_OPT_TYPE_STRING,
-    FF_OPT_TYPE_RATIONAL,
-    FF_OPT_TYPE_BINARY,  ///< offset must point to a pointer immediately followed by an int for the length
-    FF_OPT_TYPE_CONST=128,
-#endif
-};
-
-/**
- * AVOption
- */
-typedef struct AVOption {
-    const char *name;
-
-    /**
-     * short English help text
-     * @todo What about other languages?
-     */
-    const char *help;
-
-    /**
-     * The offset relative to the context structure where the option
-     * value is stored. It should be 0 for named constants.
-     */
-    int offset;
-    enum AVOptionType type;
-
-    /**
-     * the default value for scalar options
-     */
-    union {
-        int64_t i64;
-        double dbl;
-        const char *str;
-        /* TODO those are unused now */
-        AVRational q;
-    } default_val;
-    double min;                 ///< minimum valid value for the option
-    double max;                 ///< maximum valid value for the option
-
-    int flags;
-#define AV_OPT_FLAG_ENCODING_PARAM  1   ///< a generic parameter which can be set by the user for muxing or encoding
-#define AV_OPT_FLAG_DECODING_PARAM  2   ///< a generic parameter which can be set by the user for demuxing or decoding
-#if FF_API_OPT_TYPE_METADATA
-#define AV_OPT_FLAG_METADATA        4   ///< some data extracted or inserted into the file like title, comment, ...
-#endif
-#define AV_OPT_FLAG_AUDIO_PARAM     8
-#define AV_OPT_FLAG_VIDEO_PARAM     16
-#define AV_OPT_FLAG_SUBTITLE_PARAM  32
-/**
- * The option is inteded for exporting values to the caller.
- */
-#define AV_OPT_FLAG_EXPORT          64
-/**
- * The option may not be set through the AVOptions API, only read.
- * This flag only makes sense when AV_OPT_FLAG_EXPORT is also set.
- */
-#define AV_OPT_FLAG_READONLY        128
-#define AV_OPT_FLAG_FILTERING_PARAM (1<<16) ///< a generic parameter which can be set by the user for filtering
-//FIXME think about enc-audio, ... style flags
-
-    /**
-     * The logical unit to which the option belongs. Non-constant
-     * options and corresponding named constants share the same
-     * unit. May be NULL.
-     */
-    const char *unit;
-} AVOption;
-
-/**
- * A single allowed range of values, or a single allowed value.
- */
-typedef struct AVOptionRange {
-    const char *str;
-    /**
-     * Value range.
-     * For string ranges this represents the min/max length.
-     * For dimensions this represents the min/max pixel count or width/height in multi-component case.
-     */
-    double value_min, value_max;
-    /**
-     * Value's component range.
-     * For string this represents the unicode range for chars, 0-127 limits to ASCII.
-     */
-    double component_min, component_max;
-    /**
-     * Range flag.
-     * If set to 1 the struct encodes a range, if set to 0 a single value.
-     */
-    int is_range;
-} AVOptionRange;
-
-/**
- * List of AVOptionRange structs.
- */
-typedef struct AVOptionRanges {
-    /**
-     * Array of option ranges.
-     *
-     * Most of option types use just one component.
-     * Following describes multi-component option types:
-     *
-     * AV_OPT_TYPE_IMAGE_SIZE:
-     * component index 0: range of pixel count (width * height).
-     * component index 1: range of width.
-     * component index 2: range of height.
-     *
-     * @note To obtain multi-component version of this structure, user must
-     *       provide AV_OPT_MULTI_COMPONENT_RANGE to av_opt_query_ranges or
-     *       av_opt_query_ranges_default function.
-     *
-     * Multi-component range can be read as in following example:
-     *
-     * @code
-     * int range_index, component_index;
-     * AVOptionRanges *ranges;
-     * AVOptionRange *range[3]; //may require more than 3 in the future.
-     * av_opt_query_ranges(&ranges, obj, key, AV_OPT_MULTI_COMPONENT_RANGE);
-     * for (range_index = 0; range_index < ranges->nb_ranges; range_index++) {
-     *     for (component_index = 0; component_index < ranges->nb_components; component_index++)
-     *         range[component_index] = ranges->range[ranges->nb_ranges * component_index + range_index];
-     *     //do something with range here.
-     * }
-     * av_opt_freep_ranges(&ranges);
-     * @endcode
-     */
-    AVOptionRange **range;
-    /**
-     * Number of ranges per component.
-     */
-    int nb_ranges;
-    /**
-     * Number of componentes.
-     */
-    int nb_components;
-} AVOptionRanges;
-
-
-#if FF_API_OLD_AVOPTIONS
-/**
- * Set the field of obj with the given name to value.
- *
- * @param[in] obj A struct whose first element is a pointer to an
- * AVClass.
- * @param[in] name the name of the field to set
- * @param[in] val The value to set. If the field is not of a string
- * type, then the given string is parsed.
- * SI postfixes and some named scalars are supported.
- * If the field is of a numeric type, it has to be a numeric or named
- * scalar. Behavior with more than one scalar and +- infix operators
- * is undefined.
- * If the field is of a flags type, it has to be a sequence of numeric
- * scalars or named flags separated by '+' or '-'. Prefixing a flag
- * with '+' causes it to be set without affecting the other flags;
- * similarly, '-' unsets a flag.
- * @param[out] o_out if non-NULL put here a pointer to the AVOption
- * found
- * @param alloc this parameter is currently ignored
- * @return 0 if the value has been set, or an AVERROR code in case of
- * error:
- * AVERROR_OPTION_NOT_FOUND if no matching option exists
- * AVERROR(ERANGE) if the value is out of range
- * AVERROR(EINVAL) if the value is not valid
- * @deprecated use av_opt_set()
- */
-attribute_deprecated
-int av_set_string3(void *obj, const char *name, const char *val, int alloc, const AVOption **o_out);
-
-attribute_deprecated const AVOption *av_set_double(void *obj, const char *name, double n);
-attribute_deprecated const AVOption *av_set_q(void *obj, const char *name, AVRational n);
-attribute_deprecated const AVOption *av_set_int(void *obj, const char *name, int64_t n);
-
-double av_get_double(void *obj, const char *name, const AVOption **o_out);
-AVRational av_get_q(void *obj, const char *name, const AVOption **o_out);
-int64_t av_get_int(void *obj, const char *name, const AVOption **o_out);
-attribute_deprecated const char *av_get_string(void *obj, const char *name, const AVOption **o_out, char *buf, int buf_len);
-attribute_deprecated const AVOption *av_next_option(FF_CONST_AVUTIL55 void *obj, const AVOption *last);
-#endif
-
-/**
- * Show the obj options.
- *
- * @param req_flags requested flags for the options to show. Show only the
- * options for which it is opt->flags & req_flags.
- * @param rej_flags rejected flags for the options to show. Show only the
- * options for which it is !(opt->flags & req_flags).
- * @param av_log_obj log context to use for showing the options
- */
-int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags);
-
-/**
- * Set the values of all AVOption fields to their default values.
- *
- * @param s an AVOption-enabled struct (its first member must be a pointer to AVClass)
- */
-void av_opt_set_defaults(void *s);
-
-#if FF_API_OLD_AVOPTIONS
-attribute_deprecated
-void av_opt_set_defaults2(void *s, int mask, int flags);
-#endif
-
-/**
- * Parse the key/value pairs list in opts. For each key/value pair
- * found, stores the value in the field in ctx that is named like the
- * key. ctx must be an AVClass context, storing is done using
- * AVOptions.
- *
- * @param opts options string to parse, may be NULL
- * @param key_val_sep a 0-terminated list of characters used to
- * separate key from value
- * @param pairs_sep a 0-terminated list of characters used to separate
- * two pairs from each other
- * @return the number of successfully set key/value pairs, or a negative
- * value corresponding to an AVERROR code in case of error:
- * AVERROR(EINVAL) if opts cannot be parsed,
- * the error code issued by av_opt_set() if a key/value pair
- * cannot be set
- */
-int av_set_options_string(void *ctx, const char *opts,
-                          const char *key_val_sep, const char *pairs_sep);
-
-/**
- * Parse the key-value pairs list in opts. For each key=value pair found,
- * set the value of the corresponding option in ctx.
- *
- * @param ctx          the AVClass object to set options on
- * @param opts         the options string, key-value pairs separated by a
- *                     delimiter
- * @param shorthand    a NULL-terminated array of options names for shorthand
- *                     notation: if the first field in opts has no key part,
- *                     the key is taken from the first element of shorthand;
- *                     then again for the second, etc., until either opts is
- *                     finished, shorthand is finished or a named option is
- *                     found; after that, all options must be named
- * @param key_val_sep  a 0-terminated list of characters used to separate
- *                     key from value, for example '='
- * @param pairs_sep    a 0-terminated list of characters used to separate
- *                     two pairs from each other, for example ':' or ','
- * @return  the number of successfully set key=value pairs, or a negative
- *          value corresponding to an AVERROR code in case of error:
- *          AVERROR(EINVAL) if opts cannot be parsed,
- *          the error code issued by av_set_string3() if a key/value pair
- *          cannot be set
- *
- * Options names must use only the following characters: a-z A-Z 0-9 - . / _
- * Separators must use characters distinct from option names and from each
- * other.
- */
-int av_opt_set_from_string(void *ctx, const char *opts,
-                           const char *const *shorthand,
-                           const char *key_val_sep, const char *pairs_sep);
-/**
- * Free all allocated objects in obj.
- */
-void av_opt_free(void *obj);
-
-/**
- * Check whether a particular flag is set in a flags field.
- *
- * @param field_name the name of the flag field option
- * @param flag_name the name of the flag to check
- * @return non-zero if the flag is set, zero if the flag isn't set,
- *         isn't of the right type, or the flags field doesn't exist.
- */
-int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name);
-
-/**
- * Set all the options from a given dictionary on an object.
- *
- * @param obj a struct whose first element is a pointer to AVClass
- * @param options options to process. This dictionary will be freed and replaced
- *                by a new one containing all options not found in obj.
- *                Of course this new dictionary needs to be freed by caller
- *                with av_dict_free().
- *
- * @return 0 on success, a negative AVERROR if some option was found in obj,
- *         but could not be set.
- *
- * @see av_dict_copy()
- */
-int av_opt_set_dict(void *obj, struct AVDictionary **options);
-
-
-/**
- * Set all the options from a given dictionary on an object.
- *
- * @param obj a struct whose first element is a pointer to AVClass
- * @param options options to process. This dictionary will be freed and replaced
- *                by a new one containing all options not found in obj.
- *                Of course this new dictionary needs to be freed by caller
- *                with av_dict_free().
- * @param search_flags A combination of AV_OPT_SEARCH_*.
- *
- * @return 0 on success, a negative AVERROR if some option was found in obj,
- *         but could not be set.
- *
- * @see av_dict_copy()
- */
-int av_opt_set_dict2(void *obj, struct AVDictionary **options, int search_flags);
-
-/**
- * Extract a key-value pair from the beginning of a string.
- *
- * @param ropts        pointer to the options string, will be updated to
- *                     point to the rest of the string (one of the pairs_sep
- *                     or the final NUL)
- * @param key_val_sep  a 0-terminated list of characters used to separate
- *                     key from value, for example '='
- * @param pairs_sep    a 0-terminated list of characters used to separate
- *                     two pairs from each other, for example ':' or ','
- * @param flags        flags; see the AV_OPT_FLAG_* values below
- * @param rkey         parsed key; must be freed using av_free()
- * @param rval         parsed value; must be freed using av_free()
- *
- * @return  >=0 for success, or a negative value corresponding to an
- *          AVERROR code in case of error; in particular:
- *          AVERROR(EINVAL) if no key is present
- *
- */
-int av_opt_get_key_value(const char **ropts,
-                         const char *key_val_sep, const char *pairs_sep,
-                         unsigned flags,
-                         char **rkey, char **rval);
-
-enum {
-
-    /**
-     * Accept to parse a value without a key; the key will then be returned
-     * as NULL.
-     */
-    AV_OPT_FLAG_IMPLICIT_KEY = 1,
-};
-
-/**
- * @defgroup opt_eval_funcs Evaluating option strings
- * @{
- * This group of functions can be used to evaluate option strings
- * and get numbers out of them. They do the same thing as av_opt_set(),
- * except the result is written into the caller-supplied pointer.
- *
- * @param obj a struct whose first element is a pointer to AVClass.
- * @param o an option for which the string is to be evaluated.
- * @param val string to be evaluated.
- * @param *_out value of the string will be written here.
- *
- * @return 0 on success, a negative number on failure.
- */
-int av_opt_eval_flags (void *obj, const AVOption *o, const char *val, int        *flags_out);
-int av_opt_eval_int   (void *obj, const AVOption *o, const char *val, int        *int_out);
-int av_opt_eval_int64 (void *obj, const AVOption *o, const char *val, int64_t    *int64_out);
-int av_opt_eval_float (void *obj, const AVOption *o, const char *val, float      *float_out);
-int av_opt_eval_double(void *obj, const AVOption *o, const char *val, double     *double_out);
-int av_opt_eval_q     (void *obj, const AVOption *o, const char *val, AVRational *q_out);
-/**
- * @}
- */
-
-#define AV_OPT_SEARCH_CHILDREN   0x0001 /**< Search in possible children of the
-                                             given object first. */
-/**
- *  The obj passed to av_opt_find() is fake -- only a double pointer to AVClass
- *  instead of a required pointer to a struct containing AVClass. This is
- *  useful for searching for options without needing to allocate the corresponding
- *  object.
- */
-#define AV_OPT_SEARCH_FAKE_OBJ   0x0002
-
-/**
- *  Allows av_opt_query_ranges and av_opt_query_ranges_default to return more than
- *  one component for certain option types.
- *  @see AVOptionRanges for details.
- */
-#define AV_OPT_MULTI_COMPONENT_RANGE 0x1000
-
-/**
- * Look for an option in an object. Consider only options which
- * have all the specified flags set.
- *
- * @param[in] obj A pointer to a struct whose first element is a
- *                pointer to an AVClass.
- *                Alternatively a double pointer to an AVClass, if
- *                AV_OPT_SEARCH_FAKE_OBJ search flag is set.
- * @param[in] name The name of the option to look for.
- * @param[in] unit When searching for named constants, name of the unit
- *                 it belongs to.
- * @param opt_flags Find only options with all the specified flags set (AV_OPT_FLAG).
- * @param search_flags A combination of AV_OPT_SEARCH_*.
- *
- * @return A pointer to the option found, or NULL if no option
- *         was found.
- *
- * @note Options found with AV_OPT_SEARCH_CHILDREN flag may not be settable
- * directly with av_opt_set(). Use special calls which take an options
- * AVDictionary (e.g. avformat_open_input()) to set options found with this
- * flag.
- */
-const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
-                            int opt_flags, int search_flags);
-
-/**
- * Look for an option in an object. Consider only options which
- * have all the specified flags set.
- *
- * @param[in] obj A pointer to a struct whose first element is a
- *                pointer to an AVClass.
- *                Alternatively a double pointer to an AVClass, if
- *                AV_OPT_SEARCH_FAKE_OBJ search flag is set.
- * @param[in] name The name of the option to look for.
- * @param[in] unit When searching for named constants, name of the unit
- *                 it belongs to.
- * @param opt_flags Find only options with all the specified flags set (AV_OPT_FLAG).
- * @param search_flags A combination of AV_OPT_SEARCH_*.
- * @param[out] target_obj if non-NULL, an object to which the option belongs will be
- * written here. It may be different from obj if AV_OPT_SEARCH_CHILDREN is present
- * in search_flags. This parameter is ignored if search_flags contain
- * AV_OPT_SEARCH_FAKE_OBJ.
- *
- * @return A pointer to the option found, or NULL if no option
- *         was found.
- */
-const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
-                             int opt_flags, int search_flags, void **target_obj);
-
-/**
- * Iterate over all AVOptions belonging to obj.
- *
- * @param obj an AVOptions-enabled struct or a double pointer to an
- *            AVClass describing it.
- * @param prev result of the previous call to av_opt_next() on this object
- *             or NULL
- * @return next AVOption or NULL
- */
-const AVOption *av_opt_next(FF_CONST_AVUTIL55 void *obj, const AVOption *prev);
-
-/**
- * Iterate over AVOptions-enabled children of obj.
- *
- * @param prev result of a previous call to this function or NULL
- * @return next AVOptions-enabled child or NULL
- */
-void *av_opt_child_next(void *obj, void *prev);
-
-/**
- * Iterate over potential AVOptions-enabled children of parent.
- *
- * @param prev result of a previous call to this function or NULL
- * @return AVClass corresponding to next potential child or NULL
- */
-const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev);
-
-/**
- * @defgroup opt_set_funcs Option setting functions
- * @{
- * Those functions set the field of obj with the given name to value.
- *
- * @param[in] obj A struct whose first element is a pointer to an AVClass.
- * @param[in] name the name of the field to set
- * @param[in] val The value to set. In case of av_opt_set() if the field is not
- * of a string type, then the given string is parsed.
- * SI postfixes and some named scalars are supported.
- * If the field is of a numeric type, it has to be a numeric or named
- * scalar. Behavior with more than one scalar and +- infix operators
- * is undefined.
- * If the field is of a flags type, it has to be a sequence of numeric
- * scalars or named flags separated by '+' or '-'. Prefixing a flag
- * with '+' causes it to be set without affecting the other flags;
- * similarly, '-' unsets a flag.
- * @param search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN
- * is passed here, then the option may be set on a child of obj.
- *
- * @return 0 if the value has been set, or an AVERROR code in case of
- * error:
- * AVERROR_OPTION_NOT_FOUND if no matching option exists
- * AVERROR(ERANGE) if the value is out of range
- * AVERROR(EINVAL) if the value is not valid
- */
-int av_opt_set         (void *obj, const char *name, const char *val, int search_flags);
-int av_opt_set_int     (void *obj, const char *name, int64_t     val, int search_flags);
-int av_opt_set_double  (void *obj, const char *name, double      val, int search_flags);
-int av_opt_set_q       (void *obj, const char *name, AVRational  val, int search_flags);
-int av_opt_set_bin     (void *obj, const char *name, const uint8_t *val, int size, int search_flags);
-int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags);
-int av_opt_set_pixel_fmt (void *obj, const char *name, enum AVPixelFormat fmt, int search_flags);
-int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags);
-int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags);
-int av_opt_set_channel_layout(void *obj, const char *name, int64_t ch_layout, int search_flags);
-/**
- * @note Any old dictionary present is discarded and replaced with a copy of the new one. The
- * caller still owns val is and responsible for freeing it.
- */
-int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags);
-
-/**
- * Set a binary option to an integer list.
- *
- * @param obj    AVClass object to set options on
- * @param name   name of the binary option
- * @param val    pointer to an integer list (must have the correct type with
- *               regard to the contents of the list)
- * @param term   list terminator (usually 0 or -1)
- * @param flags  search flags
- */
-#define av_opt_set_int_list(obj, name, val, term, flags) \
-    (av_int_list_length(val, term) > INT_MAX / sizeof(*(val)) ? \
-     AVERROR(EINVAL) : \
-     av_opt_set_bin(obj, name, (const uint8_t *)(val), \
-                    av_int_list_length(val, term) * sizeof(*(val)), flags))
-
-/**
- * @}
- */
-
-/**
- * @defgroup opt_get_funcs Option getting functions
- * @{
- * Those functions get a value of the option with the given name from an object.
- *
- * @param[in] obj a struct whose first element is a pointer to an AVClass.
- * @param[in] name name of the option to get.
- * @param[in] search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN
- * is passed here, then the option may be found in a child of obj.
- * @param[out] out_val value of the option will be written here
- * @return >=0 on success, a negative error code otherwise
- */
-/**
- * @note the returned string will be av_malloc()ed and must be av_free()ed by the caller
- */
-int av_opt_get         (void *obj, const char *name, int search_flags, uint8_t   **out_val);
-int av_opt_get_int     (void *obj, const char *name, int search_flags, int64_t    *out_val);
-int av_opt_get_double  (void *obj, const char *name, int search_flags, double     *out_val);
-int av_opt_get_q       (void *obj, const char *name, int search_flags, AVRational *out_val);
-int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out);
-int av_opt_get_pixel_fmt (void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt);
-int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt);
-int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val);
-int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *ch_layout);
-/**
- * @param[out] out_val The returned dictionary is a copy of the actual value and must
- * be freed with av_dict_free() by the caller
- */
-int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val);
-/**
- * @}
- */
-/**
- * Gets a pointer to the requested field in a struct.
- * This function allows accessing a struct even when its fields are moved or
- * renamed since the application making the access has been compiled,
- *
- * @returns a pointer to the field, it can be cast to the correct type and read
- *          or written to.
- */
-void *av_opt_ptr(const AVClass *avclass, void *obj, const char *name);
-
-/**
- * Free an AVOptionRanges struct and set it to NULL.
- */
-void av_opt_freep_ranges(AVOptionRanges **ranges);
-
-/**
- * Get a list of allowed ranges for the given option.
- *
- * The returned list may depend on other fields in obj like for example profile.
- *
- * @param flags is a bitmask of flags, undefined flags should not be set and should be ignored
- *              AV_OPT_SEARCH_FAKE_OBJ indicates that the obj is a double pointer to a AVClass instead of a full instance
- *              AV_OPT_MULTI_COMPONENT_RANGE indicates that function may return more than one component, @see AVOptionRanges
- *
- * The result must be freed with av_opt_freep_ranges.
- *
- * @return number of compontents returned on success, a negative errro code otherwise
- */
-int av_opt_query_ranges(AVOptionRanges **, void *obj, const char *key, int flags);
-
-/**
- * Copy options from src object into dest object.
- *
- * Options that require memory allocation (e.g. string or binary) are malloc'ed in dest object.
- * Original memory allocated for such options is freed unless both src and dest options points to the same memory.
- *
- * @param dest Object to copy from
- * @param src  Object to copy into
- * @return 0 on success, negative on error
- */
-int av_opt_copy(void *dest, FF_CONST_AVUTIL55 void *src);
-
-/**
- * Get a default list of allowed ranges for the given option.
- *
- * This list is constructed without using the AVClass.query_ranges() callback
- * and can be used as fallback from within the callback.
- *
- * @param flags is a bitmask of flags, undefined flags should not be set and should be ignored
- *              AV_OPT_SEARCH_FAKE_OBJ indicates that the obj is a double pointer to a AVClass instead of a full instance
- *              AV_OPT_MULTI_COMPONENT_RANGE indicates that function may return more than one component, @see AVOptionRanges
- *
- * The result must be freed with av_opt_free_ranges.
- *
- * @return number of compontents returned on success, a negative errro code otherwise
- */
-int av_opt_query_ranges_default(AVOptionRanges **, void *obj, const char *key, int flags);
-
-/**
- * Check if given option is set to its default value.
- *
- * Options o must belong to the obj. This function must not be called to check child's options state.
- * @see av_opt_is_set_to_default_by_name().
- *
- * @param obj  AVClass object to check option on
- * @param o    option to be checked
- * @return     >0 when option is set to its default,
- *              0 when option is not set its default,
- *             <0 on error
- */
-int av_opt_is_set_to_default(void *obj, const AVOption *o);
-
-/**
- * Check if given option is set to its default value.
- *
- * @param obj          AVClass object to check option on
- * @param name         option name
- * @param search_flags combination of AV_OPT_SEARCH_*
- * @return             >0 when option is set to its default,
- *                     0 when option is not set its default,
- *                     <0 on error
- */
-int av_opt_is_set_to_default_by_name(void *obj, const char *name, int search_flags);
-
-
-#define AV_OPT_SERIALIZE_SKIP_DEFAULTS              0x00000001  ///< Serialize options that are not set to default values only.
-#define AV_OPT_SERIALIZE_OPT_FLAGS_EXACT            0x00000002  ///< Serialize options that exactly match opt_flags only.
-
-/**
- * Serialize object's options.
- *
- * Create a string containing object's serialized options.
- * Such string may be passed back to av_opt_set_from_string() in order to restore option values.
- * A key/value or pairs separator occurring in the serialized value or
- * name string are escaped through the av_escape() function.
- *
- * @param[in]  obj           AVClass object to serialize
- * @param[in]  opt_flags     serialize options with all the specified flags set (AV_OPT_FLAG)
- * @param[in]  flags         combination of AV_OPT_SERIALIZE_* flags
- * @param[out] buffer        Pointer to buffer that will be allocated with string containg serialized options.
- *                           Buffer must be freed by the caller when is no longer needed.
- * @param[in]  key_val_sep   character used to separate key from value
- * @param[in]  pairs_sep     character used to separate two pairs from each other
- * @return                   >= 0 on success, negative on error
- * @warning Separators cannot be neither '\\' nor '\0'. They also cannot be the same.
- */
-int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer,
-                     const char key_val_sep, const char pairs_sep);
-/**
- * @}
- */
-
-#endif /* AVUTIL_OPT_H */

Externals/ffmpeg/include/libavutil/parseutils.h

@@ -1,187 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_PARSEUTILS_H
-#define AVUTIL_PARSEUTILS_H
-
-#include <time.h>
-
-#include "rational.h"
-
-/**
- * @file
- * misc parsing utilities
- */
-
-/**
- * Parse str and store the parsed ratio in q.
- *
- * Note that a ratio with infinite (1/0) or negative value is
- * considered valid, so you should check on the returned value if you
- * want to exclude those values.
- *
- * The undefined value can be expressed using the "0:0" string.
- *
- * @param[in,out] q pointer to the AVRational which will contain the ratio
- * @param[in] str the string to parse: it has to be a string in the format
- * num:den, a float number or an expression
- * @param[in] max the maximum allowed numerator and denominator
- * @param[in] log_offset log level offset which is applied to the log
- * level of log_ctx
- * @param[in] log_ctx parent logging context
- * @return >= 0 on success, a negative error code otherwise
- */
-int av_parse_ratio(AVRational *q, const char *str, int max,
-                   int log_offset, void *log_ctx);
-
-#define av_parse_ratio_quiet(rate, str, max) \
-    av_parse_ratio(rate, str, max, AV_LOG_MAX_OFFSET, NULL)
-
-/**
- * Parse str and put in width_ptr and height_ptr the detected values.
- *
- * @param[in,out] width_ptr pointer to the variable which will contain the detected
- * width value
- * @param[in,out] height_ptr pointer to the variable which will contain the detected
- * height value
- * @param[in] str the string to parse: it has to be a string in the format
- * width x height or a valid video size abbreviation.
- * @return >= 0 on success, a negative error code otherwise
- */
-int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str);
-
-/**
- * Parse str and store the detected values in *rate.
- *
- * @param[in,out] rate pointer to the AVRational which will contain the detected
- * frame rate
- * @param[in] str the string to parse: it has to be a string in the format
- * rate_num / rate_den, a float number or a valid video rate abbreviation
- * @return >= 0 on success, a negative error code otherwise
- */
-int av_parse_video_rate(AVRational *rate, const char *str);
-
-/**
- * Put the RGBA values that correspond to color_string in rgba_color.
- *
- * @param color_string a string specifying a color. It can be the name of
- * a color (case insensitive match) or a [0x|#]RRGGBB[AA] sequence,
- * possibly followed by "@" and a string representing the alpha
- * component.
- * The alpha component may be a string composed by "0x" followed by an
- * hexadecimal number or a decimal number between 0.0 and 1.0, which
- * represents the opacity value (0x00/0.0 means completely transparent,
- * 0xff/1.0 completely opaque).
- * If the alpha component is not specified then 0xff is assumed.
- * The string "random" will result in a random color.
- * @param slen length of the initial part of color_string containing the
- * color. It can be set to -1 if color_string is a null terminated string
- * containing nothing else than the color.
- * @return >= 0 in case of success, a negative value in case of
- * failure (for example if color_string cannot be parsed).
- */
-int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen,
-                   void *log_ctx);
-
-/**
- * Get the name of a color from the internal table of hard-coded named
- * colors.
- *
- * This function is meant to enumerate the color names recognized by
- * av_parse_color().
- *
- * @param color_idx index of the requested color, starting from 0
- * @param rgbp      if not NULL, will point to a 3-elements array with the color value in RGB
- * @return the color name string or NULL if color_idx is not in the array
- */
-const char *av_get_known_color_name(int color_idx, const uint8_t **rgb);
-
-/**
- * Parse timestr and return in *time a corresponding number of
- * microseconds.
- *
- * @param timeval puts here the number of microseconds corresponding
- * to the string in timestr. If the string represents a duration, it
- * is the number of microseconds contained in the time interval.  If
- * the string is a date, is the number of microseconds since 1st of
- * January, 1970 up to the time of the parsed date.  If timestr cannot
- * be successfully parsed, set *time to INT64_MIN.
-
- * @param timestr a string representing a date or a duration.
- * - If a date the syntax is:
- * @code
- * [{YYYY-MM-DD|YYYYMMDD}[T|t| ]]{{HH:MM:SS[.m...]]]}|{HHMMSS[.m...]]]}}[Z]
- * now
- * @endcode
- * If the value is "now" it takes the current time.
- * Time is local time unless Z is appended, in which case it is
- * interpreted as UTC.
- * If the year-month-day part is not specified it takes the current
- * year-month-day.
- * - If a duration the syntax is:
- * @code
- * [-][HH:]MM:SS[.m...]
- * [-]S+[.m...]
- * @endcode
- * @param duration flag which tells how to interpret timestr, if not
- * zero timestr is interpreted as a duration, otherwise as a date
- * @return >= 0 in case of success, a negative value corresponding to an
- * AVERROR code otherwise
- */
-int av_parse_time(int64_t *timeval, const char *timestr, int duration);
-
-/**
- * Parse the input string p according to the format string fmt and
- * store its results in the structure dt.
- * This implementation supports only a subset of the formats supported
- * by the standard strptime().
- *
- * In particular it actually supports the parameters:
- * - %H: the hour as a decimal number, using a 24-hour clock, in the
- * range '00' through '23'
- * - %J: hours as a decimal number, in the range '0' through INT_MAX
- * - %M: the minute as a decimal number, using a 24-hour clock, in the
- * range '00' through '59'
- * - %S: the second as a decimal number, using a 24-hour clock, in the
- * range '00' through '59'
- * - %Y: the year as a decimal number, using the Gregorian calendar
- * - %m: the month as a decimal number, in the range '1' through '12'
- * - %d: the day of the month as a decimal number, in the range '1'
- * through '31'
- * - %%: a literal '%'
- *
- * @return a pointer to the first character not processed in this
- * function call, or NULL in case the function fails to match all of
- * the fmt string and therefore an error occurred
- */
-char *av_small_strptime(const char *p, const char *fmt, struct tm *dt);
-
-/**
- * Attempt to find a specific tag in a URL.
- *
- * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
- * Return 1 if found.
- */
-int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info);
-
-/**
- * Convert the decomposed UTC time in tm to a time_t value.
- */
-time_t av_timegm(struct tm *tm);
-
-#endif /* AVUTIL_PARSEUTILS_H */

Externals/ffmpeg/include/libavutil/pixdesc.h

@@ -1,385 +0,0 @@
-/*
- * pixel format descriptor
- * Copyright (c) 2009 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_PIXDESC_H
-#define AVUTIL_PIXDESC_H
-
-#include <inttypes.h>
-
-#include "attributes.h"
-#include "pixfmt.h"
-
-typedef struct AVComponentDescriptor {
-    /**
-     * Which of the 4 planes contains the component.
-     */
-    uint16_t plane        : 2;
-
-    /**
-     * Number of elements between 2 horizontally consecutive pixels minus 1.
-     * Elements are bits for bitstream formats, bytes otherwise.
-     */
-    uint16_t step_minus1  : 3;
-
-    /**
-     * Number of elements before the component of the first pixel plus 1.
-     * Elements are bits for bitstream formats, bytes otherwise.
-     */
-    uint16_t offset_plus1 : 3;
-
-    /**
-     * Number of least significant bits that must be shifted away
-     * to get the value.
-     */
-    uint16_t shift        : 3;
-
-    /**
-     * Number of bits in the component minus 1.
-     */
-    uint16_t depth_minus1 : 4;
-} AVComponentDescriptor;
-
-/**
- * Descriptor that unambiguously describes how the bits of a pixel are
- * stored in the up to 4 data planes of an image. It also stores the
- * subsampling factors and number of components.
- *
- * @note This is separate of the colorspace (RGB, YCbCr, YPbPr, JPEG-style YUV
- *       and all the YUV variants) AVPixFmtDescriptor just stores how values
- *       are stored not what these values represent.
- */
-typedef struct AVPixFmtDescriptor {
-    const char *name;
-    uint8_t nb_components;  ///< The number of components each pixel has, (1-4)
-
-    /**
-     * Amount to shift the luma width right to find the chroma width.
-     * For YV12 this is 1 for example.
-     * chroma_width = -((-luma_width) >> log2_chroma_w)
-     * The note above is needed to ensure rounding up.
-     * This value only refers to the chroma components.
-     */
-    uint8_t log2_chroma_w;  ///< chroma_width = -((-luma_width )>>log2_chroma_w)
-
-    /**
-     * Amount to shift the luma height right to find the chroma height.
-     * For YV12 this is 1 for example.
-     * chroma_height= -((-luma_height) >> log2_chroma_h)
-     * The note above is needed to ensure rounding up.
-     * This value only refers to the chroma components.
-     */
-    uint8_t log2_chroma_h;
-    uint8_t flags;
-
-    /**
-     * Parameters that describe how pixels are packed.
-     * If the format has 2 or 4 components, then alpha is last.
-     * If the format has 1 or 2 components, then luma is 0.
-     * If the format has 3 or 4 components,
-     * if the RGB flag is set then 0 is red, 1 is green and 2 is blue;
-     * otherwise 0 is luma, 1 is chroma-U and 2 is chroma-V.
-     */
-    AVComponentDescriptor comp[4];
-
-    /**
-     * Alternative comma-separated names.
-     */
-    const char *alias;
-} AVPixFmtDescriptor;
-
-/**
- * Pixel format is big-endian.
- */
-#define AV_PIX_FMT_FLAG_BE           (1 << 0)
-/**
- * Pixel format has a palette in data[1], values are indexes in this palette.
- */
-#define AV_PIX_FMT_FLAG_PAL          (1 << 1)
-/**
- * All values of a component are bit-wise packed end to end.
- */
-#define AV_PIX_FMT_FLAG_BITSTREAM    (1 << 2)
-/**
- * Pixel format is an HW accelerated format.
- */
-#define AV_PIX_FMT_FLAG_HWACCEL      (1 << 3)
-/**
- * At least one pixel component is not in the first data plane.
- */
-#define AV_PIX_FMT_FLAG_PLANAR       (1 << 4)
-/**
- * The pixel format contains RGB-like data (as opposed to YUV/grayscale).
- */
-#define AV_PIX_FMT_FLAG_RGB          (1 << 5)
-/**
- * The pixel format is "pseudo-paletted". This means that FFmpeg treats it as
- * paletted internally, but the palette is generated by the decoder and is not
- * stored in the file.
- */
-#define AV_PIX_FMT_FLAG_PSEUDOPAL    (1 << 6)
-/**
- * The pixel format has an alpha channel.
- */
-#define AV_PIX_FMT_FLAG_ALPHA        (1 << 7)
-
-#if FF_API_PIX_FMT
-/**
- * @deprecated use the AV_PIX_FMT_FLAG_* flags
- */
-#define PIX_FMT_BE        AV_PIX_FMT_FLAG_BE
-#define PIX_FMT_PAL       AV_PIX_FMT_FLAG_PAL
-#define PIX_FMT_BITSTREAM AV_PIX_FMT_FLAG_BITSTREAM
-#define PIX_FMT_HWACCEL   AV_PIX_FMT_FLAG_HWACCEL
-#define PIX_FMT_PLANAR    AV_PIX_FMT_FLAG_PLANAR
-#define PIX_FMT_RGB       AV_PIX_FMT_FLAG_RGB
-#define PIX_FMT_PSEUDOPAL AV_PIX_FMT_FLAG_PSEUDOPAL
-#define PIX_FMT_ALPHA     AV_PIX_FMT_FLAG_ALPHA
-#endif
-
-#if FF_API_PIX_FMT_DESC
-/**
- * The array of all the pixel format descriptors.
- */
-extern attribute_deprecated const AVPixFmtDescriptor av_pix_fmt_descriptors[];
-#endif
-
-/**
- * Read a line from an image, and write the values of the
- * pixel format component c to dst.
- *
- * @param data the array containing the pointers to the planes of the image
- * @param linesize the array containing the linesizes of the image
- * @param desc the pixel format descriptor for the image
- * @param x the horizontal coordinate of the first pixel to read
- * @param y the vertical coordinate of the first pixel to read
- * @param w the width of the line to read, that is the number of
- * values to write to dst
- * @param read_pal_component if not zero and the format is a paletted
- * format writes the values corresponding to the palette
- * component c in data[1] to dst, rather than the palette indexes in
- * data[0]. The behavior is undefined if the format is not paletted.
- */
-void av_read_image_line(uint16_t *dst, const uint8_t *data[4],
-                        const int linesize[4], const AVPixFmtDescriptor *desc,
-                        int x, int y, int c, int w, int read_pal_component);
-
-/**
- * Write the values from src to the pixel format component c of an
- * image line.
- *
- * @param src array containing the values to write
- * @param data the array containing the pointers to the planes of the
- * image to write into. It is supposed to be zeroed.
- * @param linesize the array containing the linesizes of the image
- * @param desc the pixel format descriptor for the image
- * @param x the horizontal coordinate of the first pixel to write
- * @param y the vertical coordinate of the first pixel to write
- * @param w the width of the line to write, that is the number of
- * values to write to the image line
- */
-void av_write_image_line(const uint16_t *src, uint8_t *data[4],
-                         const int linesize[4], const AVPixFmtDescriptor *desc,
-                         int x, int y, int c, int w);
-
-/**
- * Return the pixel format corresponding to name.
- *
- * If there is no pixel format with name name, then looks for a
- * pixel format with the name corresponding to the native endian
- * format of name.
- * For example in a little-endian system, first looks for "gray16",
- * then for "gray16le".
- *
- * Finally if no pixel format has been found, returns AV_PIX_FMT_NONE.
- */
-enum AVPixelFormat av_get_pix_fmt(const char *name);
-
-/**
- * Return the short name for a pixel format, NULL in case pix_fmt is
- * unknown.
- *
- * @see av_get_pix_fmt(), av_get_pix_fmt_string()
- */
-const char *av_get_pix_fmt_name(enum AVPixelFormat pix_fmt);
-
-/**
- * Print in buf the string corresponding to the pixel format with
- * number pix_fmt, or a header if pix_fmt is negative.
- *
- * @param buf the buffer where to write the string
- * @param buf_size the size of buf
- * @param pix_fmt the number of the pixel format to print the
- * corresponding info string, or a negative value to print the
- * corresponding header.
- */
-char *av_get_pix_fmt_string(char *buf, int buf_size,
-                            enum AVPixelFormat pix_fmt);
-
-/**
- * Return the number of bits per pixel used by the pixel format
- * described by pixdesc. Note that this is not the same as the number
- * of bits per sample.
- *
- * The returned number of bits refers to the number of bits actually
- * used for storing the pixel information, that is padding bits are
- * not counted.
- */
-int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc);
-
-/**
- * Return the number of bits per pixel for the pixel format
- * described by pixdesc, including any padding or unused bits.
- */
-int av_get_padded_bits_per_pixel(const AVPixFmtDescriptor *pixdesc);
-
-/**
- * @return a pixel format descriptor for provided pixel format or NULL if
- * this pixel format is unknown.
- */
-const AVPixFmtDescriptor *av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt);
-
-/**
- * Iterate over all pixel format descriptors known to libavutil.
- *
- * @param prev previous descriptor. NULL to get the first descriptor.
- *
- * @return next descriptor or NULL after the last descriptor
- */
-const AVPixFmtDescriptor *av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev);
-
-/**
- * @return an AVPixelFormat id described by desc, or AV_PIX_FMT_NONE if desc
- * is not a valid pointer to a pixel format descriptor.
- */
-enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc);
-
-/**
- * Utility function to access log2_chroma_w log2_chroma_h from
- * the pixel format AVPixFmtDescriptor.
- *
- * See av_get_chroma_sub_sample() for a function that asserts a
- * valid pixel format instead of returning an error code.
- * Its recommended that you use avcodec_get_chroma_sub_sample unless
- * you do check the return code!
- *
- * @param[in]  pix_fmt the pixel format
- * @param[out] h_shift store log2_chroma_w
- * @param[out] v_shift store log2_chroma_h
- *
- * @return 0 on success, AVERROR(ENOSYS) on invalid or unknown pixel format
- */
-int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt,
-                                     int *h_shift, int *v_shift);
-
-/**
- * @return number of planes in pix_fmt, a negative AVERROR if pix_fmt is not a
- * valid pixel format.
- */
-int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt);
-
-void ff_check_pixfmt_descriptors(void);
-
-/**
- * Utility function to swap the endianness of a pixel format.
- *
- * @param[in]  pix_fmt the pixel format
- *
- * @return pixel format with swapped endianness if it exists,
- * otherwise AV_PIX_FMT_NONE
- */
-enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt);
-
-#define FF_LOSS_RESOLUTION  0x0001 /**< loss due to resolution change */
-#define FF_LOSS_DEPTH       0x0002 /**< loss due to color depth change */
-#define FF_LOSS_COLORSPACE  0x0004 /**< loss due to color space conversion */
-#define FF_LOSS_ALPHA       0x0008 /**< loss of alpha bits */
-#define FF_LOSS_COLORQUANT  0x0010 /**< loss due to color quantization */
-#define FF_LOSS_CHROMA      0x0020 /**< loss of chroma (e.g. RGB to gray conversion) */
-
-/**
- * Compute what kind of losses will occur when converting from one specific
- * pixel format to another.
- * When converting from one pixel format to another, information loss may occur.
- * For example, when converting from RGB24 to GRAY, the color information will
- * be lost. Similarly, other losses occur when converting from some formats to
- * other formats. These losses can involve loss of chroma, but also loss of
- * resolution, loss of color depth, loss due to the color space conversion, loss
- * of the alpha bits or loss due to color quantization.
- * av_get_fix_fmt_loss() informs you about the various types of losses
- * which will occur when converting from one pixel format to another.
- *
- * @param[in] dst_pix_fmt destination pixel format
- * @param[in] src_pix_fmt source pixel format
- * @param[in] has_alpha Whether the source pixel format alpha channel is used.
- * @return Combination of flags informing you what kind of losses will occur
- * (maximum loss for an invalid dst_pix_fmt).
- */
-int av_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt,
-                        enum AVPixelFormat src_pix_fmt,
-                        int has_alpha);
-
-/**
- * Compute what kind of losses will occur when converting from one specific
- * pixel format to another.
- * When converting from one pixel format to another, information loss may occur.
- * For example, when converting from RGB24 to GRAY, the color information will
- * be lost. Similarly, other losses occur when converting from some formats to
- * other formats. These losses can involve loss of chroma, but also loss of
- * resolution, loss of color depth, loss due to the color space conversion, loss
- * of the alpha bits or loss due to color quantization.
- * av_get_fix_fmt_loss() informs you about the various types of losses
- * which will occur when converting from one pixel format to another.
- *
- * @param[in] dst_pix_fmt destination pixel format
- * @param[in] src_pix_fmt source pixel format
- * @param[in] has_alpha Whether the source pixel format alpha channel is used.
- * @return Combination of flags informing you what kind of losses will occur
- * (maximum loss for an invalid dst_pix_fmt).
- */
-enum AVPixelFormat av_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
-                                             enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
-
-/**
- * @return the name for provided color range or NULL if unknown.
- */
-const char *av_color_range_name(enum AVColorRange range);
-
-/**
- * @return the name for provided color primaries or NULL if unknown.
- */
-const char *av_color_primaries_name(enum AVColorPrimaries primaries);
-
-/**
- * @return the name for provided color transfer or NULL if unknown.
- */
-const char *av_color_transfer_name(enum AVColorTransferCharacteristic transfer);
-
-/**
- * @return the name for provided color space or NULL if unknown.
- */
-const char *av_color_space_name(enum AVColorSpace space);
-
-/**
- * @return the name for provided chroma location or NULL if unknown.
- */
-const char *av_chroma_location_name(enum AVChromaLocation location);
-
-#endif /* AVUTIL_PIXDESC_H */

Externals/ffmpeg/include/libavutil/pixelutils.h

@@ -1,52 +0,0 @@
-/*
- * This file is part of FFmpeg.
- *
- * FFmpeg 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.
- *
- * FFmpeg 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 FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef AVUTIL_PIXELUTILS_H
-#define AVUTIL_PIXELUTILS_H
-
-#include <stddef.h>
-#include <stdint.h>
-#include "common.h"
-
-/**
- * Sum of abs(src1[x] - src2[x])
- */
-typedef int (*av_pixelutils_sad_fn)(const uint8_t *src1, ptrdiff_t stride1,
-                                    const uint8_t *src2, ptrdiff_t stride2);
-
-/**
- * Get a potentially optimized pointer to a Sum-of-absolute-differences
- * function (see the av_pixelutils_sad_fn prototype).
- *
- * @param w_bits  1<<w_bits is the requested width of the block size
- * @param h_bits  1<<h_bits is the requested height of the block size
- * @param aligned If set to 2, the returned sad function will assume src1 and
- *                src2 addresses are aligned on the block size.
- *                If set to 1, the returned sad function will assume src1 is
- *                aligned on the block size.
- *                If set to 0, the returned sad function assume no particular
- *                alignment.
- * @param log_ctx context used for logging, can be NULL
- *
- * @return a pointer to the SAD function or NULL in case of error (because of
- *         invalid parameters)
- */
-av_pixelutils_sad_fn av_pixelutils_get_sad_fn(int w_bits, int h_bits,
-                                              int aligned, void *log_ctx);
-
-#endif /* AVUTIL_PIXELUTILS_H */