Skip to content

Update Linux client/server for binary installs #415

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
gilgongo merged 7 commits into from
Apr 30, 2021
Merged

Update Linux client/server for binary installs #415

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
deba709
Update en-Installation-for-Linux.md
gilgongo Apr 4, 2021
781c212
Update en-Server-Linux.md
gilgongo Apr 4, 2021
e5e886b
Update en-Tips-Tricks-More.md
gilgongo Apr 4, 2021
c161185
Update en-Compiling.md
gilgongo Apr 4, 2021
b63419d
Merge branch 'changes' into gilgongo-linuxv2
gilgongo Apr 10, 2021
0570e53
Update en-Tips-Tricks-More.md
gilgongo Apr 29, 2021
be8df7a
Merge branch 'changes' into gilgongo-linuxv2
gilgongo Apr 29, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
106 changes: 4 additions & 102 deletions wiki/en/en-Compiling.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,105 +1,7 @@
---
layout: wiki
title: "Compiling"
layout: redirect
redirect: "/wiki/Compiling"
lang: "en"
permalink: "/wiki/Compiling"
permalink: "https://github.com/jamulussoftware/jamulus/blob/master/COMPILING.md"
category: "hidden"
---

# Compiling Jamulus from Source

## Linux

Please refer to the [client installation page](Installation-for-Linux) or these instructions if you wish to [compile a headless server](Server-Linux#running-a-headless-server)

## macOS
You don't need to compile Jamulus for macOS since we provide official binaries, but if you really want to, follow the instructions below.
### Requirements

1. Install XCode
1. Install Qt as follows

```shell
brew install qt5
brew link qt5 --force
```

### Build project

#### Generate XCode Project file
```shell
qmake -spec macx-xcode Jamulus.pro
```

#### Print build targets and configuration in console
```shell
xcodebuild -list -project Jamulus.xcodeproj
```
will prompt
```shell
Targets:
Jamulus
Qt Preprocess

Build Configurations:
Debug
Release

If no build configuration is specified and -scheme is not passed then "Release" is used.

Schemes:
Jamulus
```

#### Build the project

```shell
xcodebuild build
```

Will build the file and make it available in `./Release/Jamulus.app`


## Windows
You don't need to compile Jamulus for Windows since we provide official binaries, but if you really want to, follow the instructions below.

### Required Software
* A compiler like [Visual Studio](https://visualstudio.microsoft.com) (You only need [Build Tools 2017 or 2019](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=BuildTools&rel=16) but can also choose to download and install the full IDE from the [Visual Studio download page](https://visualstudio.microsoft.com/downloads/))
* [Qt](https://www.qt.io/download)
* Use the free GPLv2 license for Open Source development
* To determine the Qt version you need, check [qt-installer-windows.qs](https://github.com/jamulussoftware/jamulus/blob/master/windows/qt-installer-windows.qs): under INSTALL_COMPONENTS you will see `qt.qt5.[version]`, e.g., 5123 means version 5.12.3.
* Select Components during installation: Expand the Qt section, find the matching version, e.g., **Qt 5.12.3**, and add the compiler components for your compiler, e.g., `MSVC 2017 32-bit/64-bit` for Visual Studio 2019
* [ASIO development files](https://www.steinberg.net/en/company/developer.html)


### Download Jamulus source code
Get the Jamulus source code e.g. via git or [zip download](https://github.com/jamulussoftware/jamulus/archive/master.zip) from the [Jamulus repo](https://github.com/jamulussoftware/jamulus).

### Compiling and building installer

Most users will probably want to use this method:

1. Open PowerShell
1. Navigate to the `jamulus` directory
1. To allow unsigned scripts, right-click on the `windows\deploy_windows.ps1` script, select properties and allow the execution of this script. You can also run `Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser`. (You can revert this after having run this script. For more information see the [Microsoft PowerShell documentation page](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.security/set-executionpolicy)).
1. Edit the $QtCompile32 and $QtCompile64 variables.
1. Run the Jamulus compilation and installer script in PowerShell: `.\windows\deploy_windows.ps1 C:\Qt\QtVersion`.
1. You can now find the Jamulus installer in the `.\deploy` directory.

### Compiling only

1. Create a folder under `\windows` called ASIOSDK2
1. Download the [ASIOSDK](https://www.steinberg.net/asiosdk), open the top level folder in the .zip file and copy the contents into `[\path\to\jamulus\source]\windows\ASIOSDK2` so that, e.g., the folder `[\path\to\jamulus\source]\windows\ASIOSDK2\common` exists
1. Open Jamulus.pro in Qt Creator, configure the project with a default kit, then compile & run


## General notes

### The "headless" build flag

Compiling with the `headless` flag means you can avoid installing some of the dependent packages, save some disk space and/or speed up your build time under the following circumstances:

1. If you plan to run Jamulus on Gentoo Linux, the only packages you should need for a headless build are `qtcore`, `qtnetwork`, `qtconcurrent` and `qtxml` (both for building and running the server).

1. If you are running Jamulus on Ubuntu/Debian, you will need all dependent packages to **compile** the binary, but to **run** the resulting headless Jamulus server you should only need `libqt5core5a`, `libqt5network5`, `libqt5xml5` and probably `libqt5concurrent5`. This may be useful for compiling/upgrading on one machine to run the binary on another (a Raspberry Pi, for example).

1. Note that if you want to compile a GUI client on one machine and run it on another (e.g. a Raspberry Pi) you only need the dependencies listed for a [headless server](Server-Linux#running-a-headless-server) (see point above), only _with_ the JACK sound libraries.
100 changes: 4 additions & 96 deletions wiki/en/en-Installation-for-Linux.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,93 +10,17 @@ permalink: "/wiki/Installation-for-Linux"
# Installation for Linux
Make sure you read the [Getting Started](Getting-Started) page.

## Jamulus packages

Although we don't provide official packages for every Linux distribution, you might find Jamulus in the package manager of your distro. Have a look at this table:

[![Packaging status](https://repology.org/badge/vertical-allrepos/jamulus.svg)](https://repology.org/project/jamulus/versions)


There is also list of unofficial [packages for different distributions here](https://github.com/jamulussoftware/jamulus/discussions/914).

### Flatpak

Jamulus is available as a [Flatpak](https://flatpak.org/) from [Flathub here](https://flathub.org/apps/details/io.jamulus.Jamulus). You will need to setup pipewire in order to use the Jamulus flatpak.

### Debian and Ubuntu
You can install Jamulus from [buster-backports](https://packages.debian.org/de/buster-backports/jamulus) or - if you're on amd64 **Debian**/**Ubuntu** - you may try the compiled .deb packages from GitHub Actions:

1. Download the [latest .deb file]({{ site.download_root_link }}{{ site.download_file_names.deb-gui }})
1. Update apt: `sudo apt-get update`
1. Install the package: `sudo apt install /path/to/{{ site.download_file_names.deb-gui }}`.
1. Since Jamulus needs the JACK server, you have to install it too. We recommend to use `QjackCtl` to configure JACK. You can install it via `sudo apt-get install qjackctl`

Afterwards you should look at the "[Set up your sound card](#set-up-your-sound-card)" step on this page.

**Note:** Jamulus (with GUI) is also [included in Debian Bullseye (testing)](https://packages.debian.org/bullseye/jamulus) thanks to [mirabilos](https://github.com/mirabilos). If you already use Bullseye, just install Jamulus via `sudo apt-get install jamulus`.

---

If you can't use one of the above options, you need to compile Jamulus from source:

## Compile from source

### Get Jamulus sources

1. Open up a terminal window (command line - `CTRL+ALT+T` on Ubuntu and related distros)
1. Download and unzip the sources for the latest release:
```shell
wget https://github.com/jamulussoftware/jamulus/archive/latest.tar.gz
tar -xvf latest.tar.gz
```


### Install dependencies

First, update your package list (e.g. on Debian-based distributions with `sudo apt-get update`).

On **Ubuntu-based** distributions 18.04+, **Debian** 9+ or 10 and Raspberry Pi Raspbian Buster release or later:

```shell
sudo apt-get install build-essential qt5-qmake qtdeclarative5-dev qt5-default qttools5-dev-tools libjack-jackd2-dev
```
Note that if you need to upgrade Jamulus to a newer version, just download the new .deb file and re-install as above.

On **Fedora**:
For installers on other distributions, see [Repology](https://repology.org/project/jamulus/versions). You may also wish to use one of the contributed [installation scripts](https://github.com/jamulussoftware/installscripts).

```shell
sudo dnf install qt5-qtdeclarative-devel jack-audio-connection-kit-dbus libQt5Concurrent5 jack-audio-connection-kit-devel
```

### QjackCtl: Optional, but recommended

[QjackCtl](https://qjackctl.sourceforge.io) is a utility to help you set up the JACK audio server (installed as part of the dependencies above). Install it via e.g.

```shell
sudo apt-get install qjackctl
```

You may also wish to consider using a [low-latency kernel](https://help.ubuntu.com/community/UbuntuStudio/RealTimeKernel) (e.g. for Ubuntu 18.04: `sudo apt-get install linux-lowlatency-hwe-18.04`).

### Compile this bad boy

Now `cd` into the jamulus sources directory you downloaded:

```shell
cd jamulus-latest
```
Now compile the sources with the following commands (the last `make` may take several minutes to run):

```shell
qmake Jamulus.pro
make clean
make
sudo make install
```
**Note:** The compiled version of Jamulus puts itself into `/usr/local/bin`.

You can now delete the sources directory you compiled from.

---

## Set up your sound card

Expand All @@ -114,28 +38,12 @@ Restart JACK for the new settings to take effect

### Start Jamulus

From the command line, execute the command `jamulus`, or if you compiled from source `Jamulus` with a (with a capital 'J'). This will start the Jamulus Client.
With JACK running and configured, start Jamulus from your desktop launcher (or from the command line, execute the command `jamulus`).

If you get problems with sound breaking up (in particular XRUN errors reported by JACK/QjackCtl) try setting bigger values (e.g. 256 frames or 3 periods). Lower ones (e.g. 64 frames) could bring better performance but maybe more sound problems. See the [troubleshooting page](Client-Troubleshooting) otherwise.

## All installed?

Jamulus has been installed and can be used now. You can now take a look at the
Take a look at the

[Jamulus Onboarding page](Onboarding){: .button}

## To update your installation to a new release

Download the new sources as per [Get Jamulus](Installation-for-Linux#get-jamulus-sources) and repeat just the [compilation instructions](Installation-for-Linux#compile-this-bad-boy) as if for a new installation above or use the new .deb package if you used it.

## Notes for geeks

* The "make clean" command is essential to remove the automatically generated Qt files which are present in the .tar.gz file and may not match the Qt version you are using.

* To use an external shared OPUS library instead of the built-in one use qmake `"CONFIG+=opus_shared_lib" Jamulus.pro`.

* To use this file configure the software with `qmake "CONFIG+=noupcasename" Jamulus.pro` to make sure the output target name of this software is **j**amulus instead of **J**amulus.

* Users of Raspberry Pi: You may want to compile the client on another machine and run the binary on the Raspberry Pi. In which case the only libraries you need to run it are those for a [headless server](Server-Linux#running-a-headless-server) build, but _with_ the JACK sound packages. In particular, have a look at the footnote for the headless build.

* As of version 3.5.3, Jamulus is no longer compatible with Qt4.
Loading