Full Ableton Link support

CMakeLists.txt

@@ -889,6 +889,7 @@ add_library(mixxx-lib STATIC EXCLUDE_FROM_ALL
   src/engine/sidechain/enginesidechain.cpp
   src/engine/sidechain/networkinputstreamworker.cpp
   src/engine/sidechain/networkoutputstreamworker.cpp
+  src/engine/sync/abletonlink.cpp
   src/engine/sync/enginesync.cpp
   src/engine/sync/internalclock.cpp
   src/engine/sync/synccontrol.cpp
@@ -1604,7 +1605,7 @@ if(APPLE)
       "-weak_framework AVFAudio"
     )
     target_compile_definitions(mixxx-lib PUBLIC __AU_EFFECTS__)
-  endif()
+endif()
 endif()
 
 if(EMSCRIPTEN)
@@ -1630,9 +1631,10 @@ if(MSVC)
         /wd4200 # C4200: nonstandard extension used: zero-sized array in struct/union
                 # Note: Even with CMAKE_C_STANDARD = 99 MSVC does not complain about C99 flexible array members
     )
-    target_compile_definitions(mixxx-lib PUBLIC _SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING _CRT_SECURE_NO_WARNINGS)
+    # _HAS_DEPRECATED_RESULT_OF is needed to compile AbletonLink with MSVC in C++20 mode (upstream fix is expected in AbletonLink 3.0.6: https://github.com/Ableton/link/issues/119)
+    target_compile_definitions(mixxx-lib PUBLIC WIN32_LEAN_AND_MEAN _SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING _HAS_DEPRECATED_RESULT_OF _CRT_SECURE_NO_WARNINGS)
   endif()
-else()
+ else()
   # TODO: Add -Wtrampolines, not yet supported by clazy
   target_compile_options(mixxx-lib PUBLIC -Wall -Wextra $<$<COMPILE_LANGUAGE:CXX>:-Woverloaded-virtual> -Wfloat-conversion -Werror=return-type -Wformat=2 -Wformat-security -Wvla -Wundef)
   if(WARNINGS_PEDANTIC)
@@ -1692,6 +1694,9 @@ if(WIN32)
   # _WIN32_WINNT_WIN7 = 0x0601
   target_compile_definitions(mixxx-lib PUBLIC WINVER=0x0601)
   target_compile_definitions(mixxx-lib PUBLIC _WIN32_WINNT=0x0601)
+  # Exclude Win32 APIs such as Cryptography, DDE, RPC, Shell, and Windows Sockets where including Windows.h.
+  # This prevents "Winsock.h already included", when compiling the ASIO dependency of Ableton Link.
+  target_compile_definitions(mixxx-lib PUBLIC WIN32_LEAN_AND_MEAN)
   if(MSVC)
     target_compile_definitions(mixxx-lib PUBLIC _USE_MATH_DEFINES)
   endif()
@@ -2283,6 +2288,37 @@ if(WIN32)
   target_include_directories(mixxx PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}")
 endif()
 
+# ASIO (included in Ableton Link) requires atomic on clang to link `std::__atomic_base<unsigned int>::is_lock_free() const'
+include(CheckAtomic)
+if(HAVE_CXX_ATOMICS_WITH_LIB OR HAVE_CXX_ATOMICS64_WITH_LIB)
+  message(STATUS "Linking libatomic is needed for atomic support on this platform")
+  target_link_libraries(mixxx-lib PUBLIC atomic)
+endif()
+
+# Ableton Link
+find_package(AbletonLink NAMES AbletonLink ableton ableton-link ableton-link-dev)
+# Note Debian Bug#993999 - Wrong CMake include path: https://salsa.debian.org/multimedia-team/ableton-link/-/commit/047f75abeeb6494256cb8d498995c17afd2a17e8
+
+if (AbletonLink_FOUND)
+  message(STATUS "Using existing system installation of Ableton Link")
+  target_link_libraries(mixxx-lib PUBLIC Ableton::Link)
+else()
+  message(STATUS "Fetch Ableton Link from GitHub")
+include(FetchContent)
+
+set(FETCHCONTENT_QUIET FALSE)
+
+  FetchContent_Declare(AbletonLink
+    GIT_REPOSITORY  https://github.com/Ableton/link.git
+    GIT_TAG         Link-3.0.6
+  )
+  FetchContent_MakeAvailable(AbletonLink)
+
+  include(${abletonlink_SOURCE_DIR}/AbletonLinkConfig.cmake)
+  target_link_libraries(mixxx-lib PUBLIC Ableton::Link)
+  target_include_directories(mixxx-lib SYSTEM PUBLIC ${abletonlink_SOURCE_DIR}/include/)
+endif()
+
 # Chromaprint
 find_package(Chromaprint REQUIRED)
 target_link_libraries(mixxx-lib PRIVATE Chromaprint::Chromaprint)
@@ -2613,7 +2649,7 @@ else()
   if(APPLE)
     # Restore the previous CMAKE_FIND_FRAMEWORK value
     set(CMAKE_FIND_FRAMEWORK ${_previous_find_framework})
-  endif()
+endif()
 endif()
 
 # Ogg

cmake/modules/CheckAtomic.cmake

@@ -0,0 +1,106 @@
+# SPDX-FileCopyrightText: 2003-2018 University of Illinois at Urbana-Champaign.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+#[=======================================================================[.rst:
+CheckAtomic
+-----------
+
+Check if the compiler supports std:atomic out of the box or if libatomic is
+needed for atomic support. If it is needed libatomicis added to
+``CMAKE_REQUIRED_LIBRARIES``. So after running CheckAtomic you can use
+std:atomic.
+
+Since 5.75.0.
+#]=======================================================================]
+
+include(CheckCXXSourceCompiles)
+include(CheckLibraryExists)
+
+# Sometimes linking against libatomic is required for atomic ops, if
+# the platform doesn't support lock-free atomics.
+
+function(check_working_cxx_atomics varname)
+	set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
+	set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -std=c++11")
+	check_cxx_source_compiles("
+	#include <atomic>
+	std::atomic<int> x;
+	std::atomic<short> y;
+	std::atomic<char> z;
+	int main() {
+		++z;
+		++y;
+		return ++x;
+	}
+	" ${varname})
+	set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
+endfunction()
+
+function(check_working_cxx_atomics64 varname)
+	set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
+	set(CMAKE_REQUIRED_FLAGS "-std=c++11 ${CMAKE_REQUIRED_FLAGS}")
+	check_cxx_source_compiles("
+	#include <atomic>
+	#include <cstdint>
+	std::atomic<uint64_t> x (0);
+	int main() {
+		uint64_t i = x.load(std::memory_order_relaxed);
+		x.is_lock_free();
+		return 0;
+	}
+	" ${varname})
+	set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
+endfunction()
+
+# Check for (non-64-bit) atomic operations.
+if(MSVC)
+	set(HAVE_CXX_ATOMICS_WITHOUT_LIB True)
+else()
+	# First check if atomics work without the library.
+	if (CMAKE_COMPILER_IS_GNUCXX
+		OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "AppleClang"
+		OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang"
+		OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Intel")
+		check_working_cxx_atomics(HAVE_CXX_ATOMICS_WITHOUT_LIB)
+	endif()
+	# If not, check if the library exists, and atomics work with it.
+	if(NOT HAVE_CXX_ATOMICS_WITHOUT_LIB)
+		check_library_exists(atomic __atomic_fetch_add_4 "" HAVE_LIBATOMIC)
+		if(HAVE_LIBATOMIC)
+			list(APPEND CMAKE_REQUIRED_LIBRARIES "atomic")
+			check_working_cxx_atomics(HAVE_CXX_ATOMICS_WITH_LIB)
+			if (NOT HAVE_CXX_ATOMICS_WITH_LIB)
+				message(FATAL_ERROR "Host compiler must support std::atomic!")
+			endif()
+		else()
+			message(FATAL_ERROR "Host compiler appears to require libatomic, but cannot find it.")
+		endif()
+	endif()
+endif()
+
+# Check for 64 bit atomic operations.
+if(MSVC)
+	set(HAVE_CXX_ATOMICS64_WITHOUT_LIB True)
+else()
+	# First check if atomics work without the library.
+	if (CMAKE_COMPILER_IS_GNUCXX
+		OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "AppleClang"
+		OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang"
+		OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Intel")
+		check_working_cxx_atomics64(HAVE_CXX_ATOMICS64_WITHOUT_LIB)
+	endif()
+	# If not, check if the library exists, and atomics work with it.
+	if(NOT HAVE_CXX_ATOMICS64_WITHOUT_LIB)
+		check_library_exists(atomic __atomic_load_8 "" HAVE_CXX_LIBATOMICS64)
+		if(HAVE_CXX_LIBATOMICS64)
+			list(APPEND CMAKE_REQUIRED_LIBRARIES "atomic")
+			check_working_cxx_atomics64(HAVE_CXX_ATOMICS64_WITH_LIB)
+			if (NOT HAVE_CXX_ATOMICS64_WITH_LIB)
+				message(FATAL_ERROR "Host compiler must support 64-bit std::atomic!")
+			endif()
+		else()
+			message(FATAL_ERROR "Host compiler appears to require libatomic for 64-bit operations, but cannot find it.")
+		endif()
+	endif()
+endif()

res/skins/LateNight/style_palemoon.qss

@@ -400,6 +400,9 @@ WTrackProperty[selected="true"],
   padding: 0px 2px 0px 2px;
   }
   #BatteryBox,
+  #AbletonLinkPeers{
+  color: #d2d2d2;
+  }
   #ClockWidget {
     margin-bottom: 1px;
   }

res/skins/LateNight/toolbar.xml

@@ -137,6 +137,34 @@
         </Connection>
       </StatusLight>
 
+      <WidgetGroup>
+        <ObjectName>AbletonLinkWidget</ObjectName>
+        <Layout>horizontal</Layout>
+        <SizePolicy>min,min</SizePolicy>
+        <Children>
+          <Template src="skin:/controls/button_2state_persist.xml">
+            <SetVariable name="TooltipId">sync_enabled</SetVariable>
+            <SetVariable name="ObjectName">GuiToggleButton</SetVariable>
+            <SetVariable name="Size">35f,20f</SetVariable>
+            <SetVariable name="state_0_text">Link</SetVariable>
+            <SetVariable name="state_1_text">Link</SetVariable>
+            <SetVariable name="ConfigKey">[AbletonLink],sync_enabled</SetVariable>
+          </Template>
+          <Number>
+            <TooltipId>num_peers</TooltipId>
+            <ObjectName>AbletonLinkPeers</ObjectName>
+            <Size>25f,0min</Size>
+            <NumberOfDigits>0</NumberOfDigits>
+            <Alignment>center</Alignment>
+            <Connection>
+              <ConfigKey>[AbletonLink],num_peers</ConfigKey>
+            </Connection>
+          </Number>
+        </Children>
+      </WidgetGroup>
+
+      <WidgetGroup><Size>100f,1min</Size></WidgetGroup>
+
       <WidgetGroup>
         <ObjectName>ClockWidget</ObjectName>
         <Layout>horizontal</Layout>

src/controllers/controlpickermenu.cpp

@@ -384,6 +384,18 @@ ControlPickerMenu::ControlPickerMenu(QWidget* pParent)
             tr("Decrease internal Leader BPM by 0.1"),
             pSyncMenu);
     pSyncMenu->addSeparator();
+    addControl("[AbletonLink]",
+            "sync_enabled",
+            tr("Link button"),
+            tr("Joins or disconnect from Ableton Link session"),
+            pSyncMenu);
+    addControl("[AbletonLink]",
+            "num_peers",
+            tr("Ableton Link number of peers"),
+            tr("Number of connected Ableton Link peers"),
+            pSyncMenu);
+
+    pSyncMenu->addSeparator();
     addDeckAndSamplerControl("sync_leader",
             tr("Sync Leader"),
             tr("Sync mode 3-state toggle / indicator (Off, Soft Leader, "

src/engine/enginebuffer.cpp

@@ -1587,6 +1587,10 @@ mixxx::audio::FramePos EngineBuffer::getTrackEndPosition() const {
             m_pTrackSamples->get());
 }
 
+double EngineBuffer::getTrackSampleRate() const {
+    return m_pTrackSampleRate->get();
+}
+
 void EngineBuffer::setTrackEndPosition(mixxx::audio::FramePos position) {
     m_pTrackSamples->set(position.toEngineSamplePosMaybeInvalid());
 }

src/engine/enginebuffer.h

@@ -152,6 +152,7 @@ class EngineBuffer : public EngineObject {
     mixxx::audio::FramePos getExactPlayPos() const;
     double getVisualPlayPos() const;
     mixxx::audio::FramePos getTrackEndPosition() const;
+    double getTrackSampleRate() const;
     void setTrackEndPosition(mixxx::audio::FramePos position);
     double getUserOffset() const;
 

src/engine/enginemixer.cpp

@@ -270,9 +270,11 @@ const CSAMPLE* EngineMixer::getSidechainBuffer() const {
     return m_sidechainMix.data();
 }
 
-void EngineMixer::processChannels(int iBufferSize) {
+void EngineMixer::processChannels(int iBufferSize,
+        std::chrono::microseconds absTimeWhenPrevOutputBufferReachsDac) {
     // Update internal sync lock rate.
-    m_pEngineSync->onCallbackStart(m_sampleRate, iBufferSize);
+    m_pEngineSync->onCallbackStart(
+            m_sampleRate, iBufferSize, absTimeWhenPrevOutputBufferReachsDac);
 
     m_activeBusChannels[EngineChannel::LEFT].clear();
     m_activeBusChannels[EngineChannel::CENTER].clear();
@@ -391,17 +393,17 @@ void EngineMixer::processChannels(int iBufferSize) {
 
     // After local bpms are updated, trigger the rest of the post-processing
     // which ensures that all channels are updating certain values at the
-    // same point in time. This prevents sync from failing depending on
+    // same point in time.  This prevents sync from failing depending on
     // if the sync target was processed before or after the sync origin.
     for (int i = activeChannelsStartIndex;
             i < m_activeChannels.size(); ++i) {
         m_activeChannels[i]->m_pChannel->postProcess(iBufferSize);
     }
 }
 
-void EngineMixer::process(const int iBufferSize) {
+void EngineMixer::process(const int iBufferSize,
+        std::chrono::microseconds absTimeWhenPrevOutputBufferReachsDac) {
     DEBUG_ASSERT(iBufferSize <= static_cast<int>(kMaxEngineSamples));
-
     static bool haveSetName = false;
     if (!haveSetName) {
         QThread::currentThread()->setObjectName("Engine");
@@ -423,7 +425,7 @@ void EngineMixer::process(const int iBufferSize) {
     }
 
     // Prepare all channels for output
-    processChannels(iBufferSize);
+    processChannels(iBufferSize, absTimeWhenPrevOutputBufferReachsDac);
 
     // Compute headphone mix
     // Head phone left/right mix

src/engine/enginemixer.h

@@ -64,7 +64,8 @@ class EngineMixer : public QObject, public AudioSource {
     void onInputConnected(const AudioInput& input);
     void onInputDisconnected(const AudioInput& input);
 
-    void process(const int iBufferSize);
+    void process(const int iBufferSize,
+            std::chrono::microseconds absTimeWhenPrevOutputBufferReachesDac);
 
     // Add an EngineChannel to the mixing engine. This is not thread safe --
     // only call it before the engine has started mixing.
@@ -256,7 +257,8 @@ class EngineMixer : public QObject, public AudioSource {
     // m_activeBusChannels, m_activeHeadphoneChannels, and
     // m_activeTalkoverChannels with each channel that is active for the
     // respective output.
-    void processChannels(int iBufferSize);
+    void processChannels(int iBufferSize,
+            std::chrono::microseconds absTimeWhenPrevOutputBufferReachesDac);
 
     ChannelHandleFactoryPointer m_pChannelHandleFactory;
     void applyMainEffects(int bufferSize);