mirror of
https://github.com/danog/libtgvoip.git
synced 2024-12-11 08:39:49 +01:00
5caaaafa42
I'm now using the entire audio processing module from WebRTC as opposed to individual DSP algorithms pulled from there before. Seems to work better this way.
80 lines
2.8 KiB
C++
80 lines
2.8 KiB
C++
/*
|
|
* Copyright 2011 The WebRTC Project Authors. All rights reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#ifndef RTC_BASE_ATOMICOPS_H_
|
|
#define RTC_BASE_ATOMICOPS_H_
|
|
|
|
#if defined(WEBRTC_WIN)
|
|
// clang-format off
|
|
// clang formating would change include order.
|
|
|
|
// Include winsock2.h before including <windows.h> to maintain consistency with
|
|
// win32.h. To include win32.h directly, it must be broken out into its own
|
|
// build target.
|
|
#include <winsock2.h>
|
|
#include <windows.h>
|
|
// clang-format on
|
|
#endif // defined(WEBRTC_WIN)
|
|
|
|
namespace rtc {
|
|
class AtomicOps {
|
|
public:
|
|
#if defined(WEBRTC_WIN)
|
|
// Assumes sizeof(int) == sizeof(LONG), which it is on Win32 and Win64.
|
|
static int Increment(volatile int* i) {
|
|
return ::InterlockedIncrement(reinterpret_cast<volatile LONG*>(i));
|
|
}
|
|
static int Decrement(volatile int* i) {
|
|
return ::InterlockedDecrement(reinterpret_cast<volatile LONG*>(i));
|
|
}
|
|
static int AcquireLoad(volatile const int* i) { return *i; }
|
|
static void ReleaseStore(volatile int* i, int value) { *i = value; }
|
|
static int CompareAndSwap(volatile int* i, int old_value, int new_value) {
|
|
return ::InterlockedCompareExchange(reinterpret_cast<volatile LONG*>(i),
|
|
new_value, old_value);
|
|
}
|
|
// Pointer variants.
|
|
template <typename T>
|
|
static T* AcquireLoadPtr(T* volatile* ptr) {
|
|
return *ptr;
|
|
}
|
|
template <typename T>
|
|
static T* CompareAndSwapPtr(T* volatile* ptr, T* old_value, T* new_value) {
|
|
return static_cast<T*>(::InterlockedCompareExchangePointer(
|
|
reinterpret_cast<PVOID volatile*>(ptr), new_value, old_value));
|
|
}
|
|
#else
|
|
static int Increment(volatile int* i) { return __sync_add_and_fetch(i, 1); }
|
|
static int Decrement(volatile int* i) { return __sync_sub_and_fetch(i, 1); }
|
|
static int AcquireLoad(volatile const int* i) {
|
|
return __atomic_load_n(i, __ATOMIC_ACQUIRE);
|
|
}
|
|
static void ReleaseStore(volatile int* i, int value) {
|
|
__atomic_store_n(i, value, __ATOMIC_RELEASE);
|
|
}
|
|
static int CompareAndSwap(volatile int* i, int old_value, int new_value) {
|
|
return __sync_val_compare_and_swap(i, old_value, new_value);
|
|
}
|
|
// Pointer variants.
|
|
template <typename T>
|
|
static T* AcquireLoadPtr(T* volatile* ptr) {
|
|
return __atomic_load_n(ptr, __ATOMIC_ACQUIRE);
|
|
}
|
|
template <typename T>
|
|
static T* CompareAndSwapPtr(T* volatile* ptr, T* old_value, T* new_value) {
|
|
return __sync_val_compare_and_swap(ptr, old_value, new_value);
|
|
}
|
|
#endif
|
|
};
|
|
|
|
} // namespace rtc
|
|
|
|
#endif // RTC_BASE_ATOMICOPS_H_
|