repository·main·Indexed 27 days ago
https://github.com/mixxxdj/mixxxFree, open-source DJ software for live performance on GNU/Linux, Windows, and macOS. This documentation includes guides for building from source, Flatpak installation, and developer references for internal libraries such as QM-DSP (Digital Signal Processing), SPSCQueue (lock-free communication), and rendergraph shaders. It also provides details on controller script linting and Icecast streaming via libshout.
SPSCQueue is a wait-free and lock-free fixed-size queue designed for C++11. It is optimized for scenarios where exactly one thread performs enqueue operations (the producer) and exactly one thread performs dequeue operations (the consumer).
Constraint: Any usage involving multiple writers or multiple readers is invalid and will lead to undefined behavior.
SPSCQueue<int> q(1);
auto t = std::thread([&] {
while (!q.front());
std::cout << *q.front() << std::endl;
q.pop();
});
q.push(1);
t.join();rendergraph::MaterialShader handles shaders automatically. GLSL shaders are extracted programmatically using QShader and then utilized with QOpenGLShader.If your DJ controller is not supported or is not working as expected in Mixxx, you can manually add or modify controller mappings. Mixxx provides methods to get your controller working immediately through custom mapping files or scripts.
http://mixxx.org/forums/viewtopic.php?f=3&t=949To build and run the unit tests for the QM-DSP library, add the test target to your make command.
Requirement: You must have the Boost library installed to run tests.
Depending on your needs, you can use Mixxx in three ways:
Mixxx is compatible with GNU/Linux, Windows, and macOS.
git clone https://github.com/mixxxdj/mixxx.gitFor help using the software, refer to the following resources:
SPSCQueue supports the standard custom allocator interface and the P0401R3 allocate_at_least proposal (available when C++17 is enabled). This allows you to use huge pages to improve performance without wasting allocated space.
Because huge page APIs are platform-dependent, you must provide your own allocator. Below is a reference implementation for Linux using mmap with MAP_HUGETLB.
#include <sys/mman.h>
template <typename T> struct Allocator {
using value_type = T;
struct AllocationResult {
T *ptr;
size_t count;
};
size_t roundup(size_t n) { return (((n - 1) >> 21) + 1) << 21; }
AllocationResult allocate_at_least(size_t n) {
size_t count = roundup(sizeof(T) * n);
auto p = static_cast<T *>(mmap(nullptr, count, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB,
-1, 0));
if (p == MAP_FAILED) {
throw std::bad_alloc();
}
return {p, count / sizeof(T)};
}
void deallocate(T *p, size_t n) { munmap(p, roundup(sizeof(T) * n)); }
};Detailed documentation is available for creating or modifying mapping files. This includes instructions on:
http://mixxx.org/wiki/doku.php/#controller_midi_mapping_documentationIf you are using a version of Qt older than 6.6, you must manually extract GLSL shaders from the .qsb shader bundles to use them with QOpenGLShader.
Use the rg_generate_shaders_gl.py script located in the mixxx/tools directory. This script requires both qsb (part of Qt) and spirv (part of the Vulkan SDK) to be available in your system PATH.
The script generates a generated_shaders_gl.cmake file which contains a CMake variable listing all extracted GLSL shaders, which can then be consumed by the local CMakeLists.txt.
$ ../../../tools/rg_generate_shaders_gl.py --cmake generated_shaders_gl.cmake *.vert *.fragCONTRIBUTING.md file for detailed build instructions, code style guidelines, and the process for opening pull requests.repo command and then add the resulting directory as a remote in Flatpak.