icecast – Blog of Kliment Andreev – A place so I won't forget things

AWS, CentOS: Create your own radio station and deploy it on Alexa (optional)

Kliment Andreev — Sun, 06 Oct 2019 12:55:24 +0000

In this post I’ll explain how to run your own Internet radio station. On top of that, I’ll show you how to build an Alexa skill to deploy your station in the cloud, so anyone with Alexa can say: “Alexa, play <whatever_station>” and hear your Internet radio station. There are many tutorials that describe this, but most of them require that you pay for some radio station hosting. If that’s easier for you, then you can skip this tutorial. If you want to have your own radio on the Internet (build from scratch) and deploy it or not on Alexa, than this guide is for you. There are some prerequisites though. You’ll need a CentOS 7 instance with a public IP and if you decide to publish it on Alexa, then you’ll need valid SSL certificate.
IMPORTANT: If your want your station to be public on Alexa, then you also need license for the music. But no worries, if you just want your music played over Alexa at home (and not public), you can still do it.
Also, the ices2 client can’t stream MP3 files, so you have to convert them to OGG. If you want to stream MP3s directly, check the earlier version of ices. The configuration file is almost identical. Ogg-Vorbis is perfectly fine and I’ll show you how to convert your library from MP3 to OGG.
So, there are two parts of this tutorial. Build your own station first and then the optional Alexa part. Let’s start.

CentOS 7

Make sure you have a CentOS 7 instance ready in the cloud with a public IP. NATed instances are OK as long as you can control the ports. In addition, make sure SELinux is disabled. Disabling the OS firewall is optional. I assume that the firewall on the instance is on.

icecast

icecast is a streaming server similar to shoutcast. It broadcasts a stream that’s provided by a source. The source can be a microphone, sound card or a file. In order to stream a file, we need a client such as ices, LiquidSoap etc. You are not the client, you are the listener. Now that we have this straighten up, let’s install icecast from the source. Just copy and paste everything below. If you get an error, execute line by line and see where it fails. Fix any issues, if any.

yum -y groupinstall "Development Tools"
yum install -y wget curl-devel libvorbis-devel libxslt-devel libxslt-devel openssl-devel
cd /tmp
wget http://downloads.xiph.org/releases/icecast/icecast-2.4.4.tar.gz
tar xzvf icecast-2.4.4.tar.gz
cd icecast-2.4.4
./configure --prefix=/opt/icecast --with-curl --with-openssl
make
make install

We specified /opt/icecast where icecast will be installed (line 7). You can change that in the configure statement, but you have to adjust everything after. icecast creates a sample configuration file named icecast.xml under /opt/icecast/etc. If you look at the XML file, you’ll see a bunch of settings and some of them have to be changed.
We’ll change the following parameters:

location

admin

hostname

source-password

relay-password

admin-user

admin-password

logdir

user

group

So, let’s change these manually or with this code. Adjust to suit your needs.

cd /opt/icecast/etc
location="New Jersey"
admin=klimenta@iandreev.com
hostname=radio.iandreev.com
sourcepwd=Sup3rStr0ngP455w0rd
relaypwd=Sup3rStr0ngP455w0rd
admin=myusername
password=Sup3rStr0ngP455w0rd
logdir=/opt/icecast/log
user=nobody
group=nobody
sed -i "s/Earth/$location/" icecast.xml
sed -i "s/icemaster@localhost/$admin/" icecast.xml
sed -i "s/localhost/$hostname/" icecast.xml
sed -i "s/hackme/$sourcepwd/" icecast.xml
sed -i "s/hackme/$relaypwd/" icecast.xml
sed -i "s/admin/$admin/" icecast.xml
sed -i "s/hackme/$password/" icecast.xml
sed -i "s|/opt/icecast/var/log/icecast|$logdir|" icecast.xml
sed -i "s/nobody/$user/" icecast.xml
sed -i "s/nogroup/$group/" icecast.xml

Let’s create the log directory and give the icecast daemon permission to write.

cd /opt/icecast
mkdir log
chown -R nobody:nobody log

icecast doesn’t come with a startup systemd script, so we’ll have to take care of that.

cat << EOF > /etc/systemd/system/icecast.service
[Unit]
Description=Icecast Network Audio Streaming Server
After=network.target

[Service]
Type=simple
User=nobody
Group=nobody
ExecStart=/opt/icecast/bin/icecast -c /opt/icecast/etc/icecast.xml
ExecReload=/bin/kill -HUP $MAINPID
ExecStop=/bin/kill $MAINPID

[Install]
WantedBy=multi-user.target
EOF

Now you can enable icecast on boot and start it.

systemctl enable icecast
systemctl start icecast

If you run systemctl status icecast, you should see that the daemon is running. Also, if you check the error log (tail /opt/icecast/log/error.log), you’ll see that the daemon is running too. Ignore the SSL warning for now.
icecast runs on port 8000, so if you have a firewall, you’ll have to poke a hole.

firewall-cmd --add-port=8000/tcp --zone=public --permanent
firewall-cmd --reload

From a browser, go to your server’s IP on port 8000, e.g. http://201.202.203.24:8000 and you’ll see something like this.

If you click on Administration, you’ll be prompted to log in. Use the admin-user and admin-password that you’ve changed in icecast.xml.

ices

Now that we have the streaming server ready, let’s install the source client. The source client will provide the stream to the server. We’ll use ices for this.

cd /tmp
wget http://downloads.us.xiph.org/releases/ices/ices-2.0.2.tar.gz
tar xzvf ices-2.0.2.tar.gz
cd ices-2.0.2
yum -y install libshout-devel
./configure --prefix=/opt/ices
make && make install

ices creates some configuration files under /opt/ices/share/ices. We’ll use the ices-playlist.xml template to generate a radio station for us.

cd /opt/ices/share/ices
cp ices-playlist.xml myradio.xml

Now edit myradio.xml and change the following with a script or manually. Make sure you adjust for your needs.

logpath

logfile

name

genre

description

password

source-password in icecast.xml

mount

param name

cd /opt/ices/share/ices
logpath=/opt/ices/log
logfile=myradio.log
name="Radio MyRadio"
genre="Some genre"
descr="Best Radio in the Universe and beyond"
pwd=Sup3rStr0ngP455w0rd
mount=/myradio.ogg
playlist=/opt/ices/playlists/myradio.txt
sed -i "s|/var/log/ices|$logpath|" myradio.xml
sed -i "s/ices.log/$logfile/" myradio.xml
sed -i "s/Example stream name/$name/" myradio.xml
sed -i "s/Example genre/$genre/" myradio.xml
sed -i "s/A short description of your stream/$descr/" myradio.xml
sed -i "s/hackme/$pwd/" myradio.xml
sed -i "s|/example1.ogg|$mount|" myradio.xml
sed -i "s|playlist.txt|$playlist|" myradio.xml

Let’s create two directories. One for the logs and the other for the files where we’ll store playlists. Not the music files – the playlists. The playlists tells ices where to look for your music.

cd /opt/ices
mkdir log playlists
chown -R nobody:nobody log

Create a startup script for ices as well. Look at line 10, that’s where my config file for this radio station is. Can you have multiple radio stations? Absolutely, one icecast server can handle multiple ices clients. Just invoke another ices client with a different config file and create a similar startup script with a different URL, e.g …/myradio.ogg and …/mystation.ogg.

cat << EOF > /etc/systemd/system/ices-myradio.service
[Unit]
Description=Ices Network Audio Streaming Client for MyRadio
After=icecast.service

[Service]
Type=simple
User=nobody
Group=nobody
ExecStart=/opt/ices/bin/ices /opt/ices/share/ices/myradio.xml
ExecReload=/bin/kill -HUP $MAINPID
ExecStop=/bin/kill $MAINPID
Restart=always
RestartSec=3

[Install]
WantedBy=multi-user.target
EOF

At this point you can tell ices where your music is stored. As I mentioned earlier, we’ll have to use Ogg-Vorbis files (.ogg).
So, create a folder where your music files will be stored. I’ll use /music/myradio and put some public royalty free music there.
Courtesy of Patrick de Arteaga. Please give him some credit and visit his site.

mkdir -p /music/myradio
cd /music/myradio
wget -U 'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.1.6) Gecko/20070802 SeaMonkey/1.1.4' https://patrickdearteaga.com/audio/Battleship.ogg
wget -U 'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.1.6) Gecko/20070802 SeaMonkey/1.1.4' https://patrickdearteaga.com/audio/Chiptronical.ogg
wget -U 'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.1.6) Gecko/20070802 SeaMonkey/1.1.4' https://patrickdearteaga.com/audio/Friends.ogg

OK, so we have our music there. When the stream ends, it will start from the first song. Now we have to create the playlist and put it under the /opt/ices/conf directory.
If you remember we specified directive in the myradio.xml file referencing where the playlist is stored. Let’s create the file.

ls -d /music/myradio/*.ogg > /opt/ices/playlists/myradio.txt

Now that we have everything ready, let’s enable ices on boot and start it.

systemctl enable ices-myradio
systemctl start ices-myradio

Check if everything is OK.

systemctl status ices-myradio
tail /opt/ices/log/myradio.log

If everything looks good, you can listen to your stream at http://whateverIP:8000/myradio.ogg.
If you are satisfied with this, you can stop reading. You’ve accomplished enough. If you want to see how to convert MP3 to OGG and how to use a reverse proxy so you can stream over HTTP, then read further.

MP3 to OGG conversion (sox)

If you have a bunch of files that you want to convert to OGG, you can use sox. It’s a very powerful tool for conversion between formats. Let’s install it first.

yum -y install libmad-devel libid3tag-devel lame lame-devel flac flac-devel
cd /tmp
wget https://sourceforge.net/projects/sox/files/sox/14.4.2/sox-14.4.2.tar.gz
tar xvfz sox-14.4.2.tar.gz
cd sox-14.4.2
./configure
make -s && make install

Now you can convert the files from MP3 to OGG and vice versa. Conversion is very simple. Just specify the source and the destination file, e.g. sox file1.mp3 file1.ogg and that’s it. If you want to see the details of the file such as bit-rate, duration, sample etc, use soxi, e.g. soxi file.ogg. If you want more details on sox and it’s usage, please check their website. For soxi, check this link.
If you want to convert your files in bulk, you can use this command that will search for MP3 files in your current directory and subdirectories and convert them to OGG.

find . -type f -name "*.mp3" -exec sh -c 'sox "$1" "${1%.mp3}.ogg"' _ {} \;

nginx as reverse proxy

If you recall, we are using http://somenameorip:8000/myradio.ogg to access our station. This is fine for regular users from their home, but in any corporate environment, anything than port 80 and 443 are blocked. So, we have to stream our music over port 80. I’ll show later how to stream over 443 because it’s a requirement for Alexa. First thing first, let’s install nginx.

yum -y install nginx
systemctl enable nginx

nginx creates a configuration file under /etc/nginx called nginx.conf. Look for this snippet in the configuration file.

        location / {
        }

…and change it to this.

        location /myradio.ogg {
          proxy_set_header Host $host;
          proxy_set_header X-Real-IP $remote_addr;
          proxy_pass http://localhost:8000/myradio.ogg;
        }

You can start the reverse proxy now and verify that it’s working.

systemctl start nginx
systemctl status nginx

Because we are proxying over HTTP, we have to open the firewall too and if you want you can close port 8000. It’s not needed anymore.

firewall-cmd --add-port=80/tcp --zone=public --permanent
firewall-cmd --remove-port=8000/tcp --zone=public --permanent
firewall-cmd --reload

Now you can access your station as http://serveriporname/myradio.ogg, so there is no need to specify port 8000.

SSL certificate

If you decide to publish your station on Alexa, you’ll need a valid (not self-signed) certificate. You will also need to reconfigure both nginx and icecast to use SSL. You can’t access your server by IP because you’ll get an invalid certificate warning, so make sure you have your DNS ready to resolve your IP to a valid domain name. Get the certificates ready. You’ll need the private key, the certificate, the intermediate certificate and the root CA certificate. When you purchase a certificate all of these will be available for you (except for the private key).
Let’s create the chain. In my case, I have each certificate in a separate file and I’ll create one certificate for icecast.

mkdir /opt/icecast/ssl
cat star.iandreev.com.key star.iandreev.com.crt star.iandreev.com.inter star.iandreev.com.CA > /opt/icecast/ssl/icecast.pem
chown -R nobody:nobody /opt/icecast/ssl

Then, edit /opt/icecast/etc/icecast.xml and find the following snippet.

Copy these three lines after, so the config looks like this now. We are telling icecast to spawn itself and listen on port 8443 too.

We also have to specify the certificate chain. Find this line in the config and uncomment it. Make sure you uncomment the line, it’s commented by default.

/opt/icecast/ssl/icecast.pem

Now, you have to restart icecast and ices too.

systemctl restart icecast
systemctl restart ices-myradio

And if you check the error.log (yes, error log), you’ll see that icecast is using SSL now.

tail /opt/icecast/log/error.log
[2019-10-03  22:29:23] INFO connection/get_ssl_certificate SSL certificate found at /opt/icecast/ssl/icecast.pem
[2019-10-03  22:29:23] INFO connection/get_ssl_certificate SSL using ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES

Now the nginx part. Edit /etc/nginx/nginx.conf.

        location /myradio.ogg {
          proxy_set_header Host $host;
          proxy_set_header X-Real-IP $remote_addr;
          proxy_pass http://localhost:8000/myradio.ogg;
        }

– Copy your private key to /etc/pki/nginx/private/server.key and your public certificate to /etc/pki/nginx/server.crt. If the directories do not exists, create them. (cd /etc/pki && mkdir -p nginx/private). Also, make sure that the certificate (server.crt) is a chain of certificates, not just a simple server certificate. If you do curl -iv https://yoursite.com, the result for the SSL should be clear without any errors or warning. You can reuse the icecast.pem certificate for icecast and copy that file as server.crt under /etc/pki/nginx/. You can even reference the same file in the same directory, but then you have to change the config files and permissions.
– Reload nginx (systemctl reload nginx)
– Open the firewall

firewall-cmd --add-port=443/tcp --zone=public --permanent
firewall-cmd --reload

Now you can access your server with https. If you want to be even more precise, you can redirect the http to https, so you don’t have to specify the protocol in the browser. Edit nginx.conf and add line 5. Reload nginx after (systemctl reload nginx).

server {
    listen       80 default_server;
    listen       [::]:80 default_server;
    server_name  _;
    return 301 https://$host$request_uri;
    root         /usr/share/nginx/html;

Here is my /etc/nginx/nginx.conf file.

user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;

# Load dynamic modules. See /usr/share/nginx/README.dynamic.
include /usr/share/nginx/modules/*.conf;

events {
    worker_connections 1024;
}

http {
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile            on;
    tcp_nopush          on;
    tcp_nodelay         on;
    keepalive_timeout   65;
    types_hash_max_size 2048;

    include             /etc/nginx/mime.types;
    default_type        application/octet-stream;

    # Load modular configuration files from the /etc/nginx/conf.d directory.
    # See http://nginx.org/en/docs/ngx_core_module.html#include
    # for more information.
    include /etc/nginx/conf.d/*.conf;

    server {
        listen       80 default_server;
        listen       [::]:80 default_server;
        server_name  _;
        return 301 https://$host$request_uri;
        root         /usr/share/nginx/html;

        # Load configuration files for the default server block.
        include /etc/nginx/default.d/*.conf;

        location / {
          proxy_set_header Host $host;
          proxy_set_header X-Real-IP $remote_addr;
          proxy_pass http://localhost:8000/myradio.ogg;
        }

        error_page 404 /404.html;
            location = /40x.html {
        }

        error_page 500 502 503 504 /50x.html;
            location = /50x.html {
        }
    }

# Settings for a TLS enabled server.

    server {
        listen       443 ssl http2 default_server;
        listen       [::]:443 ssl http2 default_server;
        server_name  _;
        root         /usr/share/nginx/html;

        ssl_certificate "/etc/pki/nginx/server.crt";
        ssl_certificate_key "/etc/pki/nginx/private/server.key";
        ssl_session_cache shared:SSL:1m;
        ssl_session_timeout  10m;
        ssl_ciphers HIGH:!aNULL:!MD5;
        ssl_prefer_server_ciphers on;

        # Load configuration files for the default server block.
        include /etc/nginx/default.d/*.conf;

        location /myradio.ogg {
          proxy_set_header Host $host;
          proxy_set_header X-Real-IP $remote_addr;
          proxy_pass http://localhost:8000/myradio.ogg;
        }

        error_page 404 /404.html;
            location = /40x.html {
        }

        error_page 500 502 503 504 /50x.html;
            location = /50x.html {
        }
    }

}

Alexa

Now comes the fun part. It’s much easier than you think thanks to Andy Moore. He has a great step-by-step tutorial for this. I’ll quickly go over what’s needed.
You’ll need your:

Fun fact. I named my station Radio Andreev and whatever I said, Alexa couldn’t understand. It was looking for Radio Andrea all the time. So, do yourself a favor and name your station something that Alexa can understand. I named my station Radio Tincup, my website is https://radio.iandreev.com and the stream is at https://radio.iandreev.com/myradio.ogg. Generate the JSON from the site above or get this code and change your values. Click the (+) sign to expand.

{
  "interactionModel": {
    "languageModel": {
      "invocationName": "radio tincup",
      "intents": [
        {
          "name": "AMAZON.CancelIntent",
          "samples": [
            "Cancel"
          ]
        },
        {
          "name": "AMAZON.HelpIntent",
          "samples": [
            "Help"
          ]
        },
        {
          "name": "AMAZON.StopIntent",
          "samples": [
            "Stop"
          ]
        },
        {
          "name": "Play",
          "samples": [
            "Ask radio tincup to play radio tincup",
            "Start radio tincup",
            "Ask radio tincup to play",
            "Play radio tincup"
          ]
        },
        {
          "name": "AMAZON.NavigateHomeIntent",
          "samples": []
        },
        {
          "name": "AMAZON.PauseIntent",
          "samples": []
        },
        {
          "name": "AMAZON.ResumeIntent",
          "samples": []
        }
      ],
      "types": []
    }
  }
}

And this is your JavaScript.

const Alexa = require('ask-sdk-core');
var https = require('https');

const PlayHandler = {
	canHandle(handlerInput)
	{
		return (
			handlerInput.requestEnvelope.request.type === 'LaunchRequest' ||
			(
				handlerInput.requestEnvelope.request.type === 'IntentRequest' &&
				handlerInput.requestEnvelope.request.intent.name === 'Play'
			) ||
			(
				handlerInput.requestEnvelope.request.type === 'IntentRequest' &&
				handlerInput.requestEnvelope.request.intent.name === 'AMAZON.ResumeIntent'
			)
		);
	},
	handle(handlerInput)
	{
		return handlerInput.responseBuilder
			.addDirective({
				type: 'AudioPlayer.Play',
				playBehavior: 'REPLACE_ALL',
				audioItem:{
					stream:{
						token: '0',
						url: 'https://radio.iandreev.com/myradio.ogg',
						offsetInMilliseconds: 0
					}
				}
			})
			.getResponse();
	}
};

const PauseStopHandler = {
	canHandle(handlerInput)
	{
		return (
				handlerInput.requestEnvelope.request.type === 'IntentRequest' &&
				(
					handlerInput.requestEnvelope.request.intent.name === 'AMAZON.CancelIntent' ||
					handlerInput.requestEnvelope.request.intent.name === 'AMAZON.StopIntent'
				)
			) ||
			(
				handlerInput.requestEnvelope.request.type === 'IntentRequest' &&
				handlerInput.requestEnvelope.request.intent.name === 'AMAZON.PauseIntent'
			);
	},
	handle(handlerInput)
	{
		return handlerInput.responseBuilder
			.addDirective({
				type: 'AudioPlayer.ClearQueue',
				clearBehavior: 'CLEAR_ALL'
			})
			.getResponse();
	}
};

const HelpIntentHandler = {
	canHandle(handlerInput)
	{
		return handlerInput.requestEnvelope.request.type === 'IntentRequest' &&
			handlerInput.requestEnvelope.request.intent.name === 'AMAZON.HelpIntent';
	},
	handle(handlerInput)
	{
		const speechText = 'You can say Play, Stop or Resume. For more information please visit radio dot iandreev dot com';
		return handlerInput.responseBuilder
			.speak(speechText)
			.getResponse();
	}
};

const SessionEndedRequestHandler = {
	canHandle(handlerInput)
	{
		return handlerInput.requestEnvelope.request.type === 'SessionEndedRequest';
	},
	handle(handlerInput)
	{
		return handlerInput.responseBuilder.getResponse();
	}
};

const IntentReflectorHandler = {
	canHandle(handlerInput)
	{
		return handlerInput.requestEnvelope.request.type === 'IntentRequest';
	},
	handle(handlerInput)
	{
		const intentName = handlerInput.requestEnvelope.request.intent.name;
		const speechText = 'NO INTENT HELP TEXT';
		return handlerInput.responseBuilder
			.speak(speechText)
			.getResponse();
	}
};

const ErrorHandler = {
	canHandle()
	{
		return true;
	},
	handle(handlerInput, error)
	{
		const speechText = `Sorry, I could not understand what you said. Please try again.`;
		return handlerInput.responseBuilder
			.speak(speechText)
			.reprompt(speechText)
			.getResponse();
	}
};

exports.handler = Alexa.SkillBuilders.custom()
	.addRequestHandlers(
		PlayHandler,
		PauseStopHandler,
		HelpIntentHandler,
		SessionEndedRequestHandler,
		IntentReflectorHandler)
	.addErrorHandlers(
		ErrorHandler)
	.lambda();

Go to https://developer.amazon.com and log in (or register). Make sure you use the same account in the developer console with the same account that you have your Alexa configured. Once logged in, click on Alexa from the menu and then Alexa Skills Kit.

Click Create Skill. Enter the name of your station and the language.

Choose a Custom model.

Choose Alexa-Hosted.

Scroll up and in the top right corner click Create skill. After 30-40 seconds, you’ll be presented with a different screen. On the left side find the Interfaces menu, then click on it. Then enable the Audio Player on the right.

Scroll up and click on Save Interfaces first, then Build Model.

Click on the JSON Editor on the left, right above Interfaces. Once the editor shows up, delete everything there and paste the JSON file.

Click Save Model then Build Model from the top.

Click on Code from the top and paste the JavaScript in the editor.

Click Save then Deploy from the upper right.

Click on Test, allow access to the microphone and change Skill testing from Off to Development.

Now, with the mouse hit the microphone icon, hold it there, say Alexa Play Radio Tincup and release the button.

Here is what I was talking to. Alexa can’t understand me…or maybe my mic is bad. If Alexa doesn’t understand, just type “Alexa play Radio Tincup” in the text field.

You won’t hear Alexa playing and you won’t hear any music from the computer, but you’ll see a JSON response with the valid URL of your OGG stream.

At this point you are all set. You can play your music using Alexa. For most people this would be the end. But if you really like to publish your station to be public, then proceed. In the console, click on Distribution.

You’ll see a bunch of questions regarding the nature of your station, are you collecting customer information, are you advertising and so on. Just follow the process and hopefully, you’ll get your station published.

Cleanup

You might want to delete the tarballs for the icecast, ices and sox that you’ve downloaded.

rm -rf /tmp/ice*
rm -rf /tmp/sox*

You’ll also want to make sure that the firewall allows only port 80 and 443. Ports 8000 and 8443 can be, but they don’t have to be exposed to the Internet.

firewall-cmd --remove-port=8000/tcp --zone=public --permanent
firewall-cmd --remove-port=8443/tcp --zone=public --permanent
firewall-cmd --reload

FreeBSD: icecast & ices – stream your music on the Internet

Kliment Andreev — Sun, 28 Sep 2014 11:54:44 +0000

In this post I’ll describe how to install and configure a streaming radio station with two separate streams. This means, you can have two or multiple radio stations running on the same port. For this, you’ll need a FreeBSD 10 server and some Ogg Vorbis music files. MP3 is not supported with ices2 client (licensing issues), but it’s easy to overcome that.

Before going any further, this is what you need to know.

icecast is the streaming server
ices is the client that supplies the music files to icecast
you are the listener, not a client

Install icecast

icecast can be easily installed from the packages or the ports. There is no need for any configurations, so we’ll do the packages.

pkg install icecast2

icecast comes up with a startup script, so we have to enable it on boot. Add the following line to /etc/rc.conf.

icecast_enable="yes"

icecast also comes up with a sample config script, so let’s modify it. The configuration parameters are described in the official document and this post will highlight only the necessary changes that you have to make.

cd /usr/local/etc/
cp icecast.xml.sample icecast.xml

Change the location, the admin email, change the passwords for source-password, relay-password and admin-password under authentication. It’s a good practice to change the default admin user as well. In addition, change the log directory under logdir and uncomment the user and the group that will run icecast daemon.

This is how my icecast.xml looks like.


    
    NJ
    icemaster@iandreev.com

    
        10
        2
        5
        524288
        30
        15
        10
        
        1
        
        65535
    

    
        
        password1
        
        password2

        
        username
        password3
    

    

    
    

    
    localhost

    
    
        8000
        
        
    
    

    
    
    
    

    
    

    

    

    1

    
		
        /usr/local/share/icecast

        
        /var/log/icecast
        /usr/local/share/icecast/web
        /usr/local/share/icecast/admin
        

        
        
        
        
    

    
        access.log
        error.log
        
      	3 
      	10000 
        
        
    

    
        0
        
            nobody
            nogroup

Create the log directory and change the ownership.

mkdir /var/log/icecast
chown -R nobody:nogroup /var/log/icecast

Start the icecast and check the log file.

service icecast2 start
tail /var/log/icecast/error.log

If everything is OK you’ll see something like this.

[2014-09-13  23:34:13] INFO main/main Icecast 2.4.0 server started
[2014-09-13  23:34:13] INFO connection/get_ssl_certificate No SSL capability on any configured ports
[2014-09-13  23:34:13] INFO yp/yp_update_thread YP update thread started

Go to http://yourserver.com:8000 and you should see this.

Then go to http://yourserver.com:8000/admin/stats.xml and you should see this.

Install ices

We’ll install ices from the packages and create a separate user and group called radio that will run the ices client. Ices client doesn’t come up with a startup script, so we’ll create one for each stream. In case you reboot, the streaming server and the clients will start automatically. We’ll also create a log directory.

pkg install ices
pw groupadd radio && pw useradd radio -g radio –m
mkdir /var/log/ices
chown –R radio:radio /var/log/ices

Switch to the radio user and create the folders for the configuration files and the two radio stations that you want to run. If you want more streams, just follow the pattern described bellow. In my case, I’ll have two radio stations, trance and liquid.

su - radio
mkdir conf liquid trance
cd ~radio/conf
cp /usr/local/share/ices/ices-playlist.xml liquid-playlist.xml

Let’s configure the first radio station and you’ll see how easy is to configure the the second one.

Edit the configuration file for the first stream (liquid-playlist.xml) and change the following values: background, logpath, logfile and pidfile.
Under stream section, change the name, genre and description.
Under the input section, change the param name=”file” parameter. This value should point to a file that contains each Ogg file in a separate line.
Under the instance section, change the password and the mount. The password supplied here must match the same source-password that was used to configure icecast (see line 31 in my example of icecast config). The mount parameter is how you are going to access the stream (e.g. http://yourserver.com:8000/station_name.ogg). Always end it up with .ogg.
I also change the nominal-bitrate to 128000, which means, ices will encode the streams as 128kbps streams.

Make sure you have enough bandwidth to support this. Use the following link to determine your needs.

Finally, here is my liquid-playlist.xml file.



    
    1
    
    /var/log/ices
    liquid.log
    
    4
    
    0

    
    /home/radio/liquid.pid

    
        
        
            Liquid radio
            Liquid D'n'B genre
            Commercial Free Liquid D'n'B radio stream
        

        

        
            playlist
            basic
            /home/radio/conf/liquid-playlist.txt
            
            0
            
            0
            
            0
        

		
        
            
            localhost
            8000
            password1
            /liquid.ogg

            
            2
            5 

            
            80

            
              
                128000 
                44100
                2

At this point, we need to put some Ogg files that we want to stream. In my case, I’ve put them under /home/radio/liquid for the first stream. Now, go to:

cd ~radio/conf
ls -d /home/radio/liquid/*.ogg > liquid-playlist.txt
cat liquid-playlist.txt

This will generate the playlist for you from all Ogg files. If you have your files separated in sub directories, then do:

cd ~radio/genre
find /home/radio/genre -name "*.ogg" -print > /home/radio/conf/genre-playlist.txt

At this point, start the station with ices liquid-playlist.xml. If everything is OK, you shouldn’t see anything. Ices will start in the background. Do a simple check:

ps -waux | grep ices
tail /var/log/ices/liquid.log

Check your radio with http://yourserver.com:8000/liquid.ogg. Now that you have the first radio ready, it’s very easy to configure the 2nd one. First, let’s create the configuration file as a copy from the first station.

cd ~radio/conf
cp liquid-playlist.xml trance-playlist.xml

I use vi to replace everything in trance-playlist.xml that says liquid as trance. Use :%s/liquid/trance/g.

Put some Ogg file for the 2nd station under ~radio/trance and create the playlist text file.

cd ~radio/conf
ls -d /home/radio/trance/*.ogg > trance-playlist.txt
cat trance-playlist.txt

Start the station with ices trance-playlist.xml and test it with http://yourserver.com:8000/trance.ogg.

Configure ices startup

Once you make sure that everything works fine, let’s create the ices startup files in case the server reboots.

Log as root and do:

cd /usr/local/etc/rc.d

Create the first startup script called ices_liquid and add everything from here.

#!/bin/sh
#
# PROVIDE: ices_liquid
# REQUIRE: DAEMON icecast2
# BEFORE:  LOGIN
# KEYWORD: shutdown

. /etc/rc.subr

name="ices_liquid"
rcvar=ices_liquid_enable

command="/usr/local/bin/ices"
extra_commands="reload"
pidfile="/home/radio/liquid.pid"
sig_reload="USR1"

load_rc_config "$name"
: ${ices_liquid_enable="NO"}
: ${ices_liquid_config="/home/radio/conf/liquid-playlist.xml"}
: ${ices_liquid_flags="${ices_liquid_config}"}
: ${ices_liquid_user="radio"}
required_files="${ices_liquid_config}"

run_rc_command "$1"

Save it and do chmod 555 ices_liquid to make sure it’s executable on start. Add ices_liquid_enable=”YES” in /etc/rc.conf. Follow the same pattern for the second startup script. Copy ices_liquid as ices_trance and replace every occurrence of liquid as trance. Then add ices_trance_enable=”YES” in /etc/rc.conf. Now you can control the streams with the standard FreeBSD daemon command service. E.g.

service ices_liquid start
service ices_liquid stop
service ices_liquid status

OK. At this point you have a streaming station(s) but they all run on port 8000. As we stated above, you can access a station by accessing this URL: http://genre.domain.com:8000/genre.ogg, speaking in general terms. Read further to see how can you bypass this restriction in order to access your radio behind a firewall.

Firewall

icecast runs on port 8000 and in many corporate environments only ports 80 and 443 are allowed inbound through various proxies. I tried to run icecast on port 80, but icecast refused to run. Mind that you can’t run icecast using a non-root account on port 80. Actually, you can. apache runs on port 80 as www user, but it’s parent process runs as root and then forks the processes. But most importantly, if you somehow make icecast to run as root, you can’t run apache on that port. The easiest way is to use mod_proxy. This module will do the heavy lifting for you. It will redirect port 8000 to port 80. This is how we are going to accomplish that using two virtual hosts in Apache.
First, create two DNS aliases, e.g. genre.domain.com and genrefw.domain.com. They should point to the same IP of your icecast server. In Apache, make sure you have mod_proxy and mod_proxy_html modules built in and loaded in httpd.conf. See my other post on how to run virtual hosts under Apache.

LoadModule proxy_module libexec/apache24/mod_proxy.so
LoadModule proxy_http_module libexec/apache24/mod_proxy_http.so
LoadModule cgi_module libexec/apache24/mod_cgi.so

or if you have the prefork/worker config file, you might also see this.


        LoadModule cgi_module libexec/apache24/mod_cgi.so

The virtual hosts directives in httpd-vhosts.conf should look like this.


    ServerAdmin admin@domain.com
    DocumentRoot "/usr/local/www/genre.domain.com"
    ServerName genre.domain.com
    ErrorLog "/var/log/genre.domain.com-error_log"
    CustomLog "/var/log/genre.domain.com-access_log" common
    
        Options All
        AllowOverride All
        Require all granted
   
   ScriptAlias /cgi-bin/ "/usr/local/www/genre.domain.com/cgi-bin/"
   
        Options +ExecCGI
        Order allow,deny
        Allow from all
        AddHandler cgi-script .cgi
   


    ServerAdmin admin@domain.com
    DocumentRoot "/usr/local/www/genrefw.domain.com"
    ServerName genrefw.domain.com
    ErrorLog "/var/log/genrefw.domain.com-error_log"
    CustomLog "/var/log/genrefw.domain.com-access_log" common
    ProxyRequests Off
    ProxyPass / http://genre.domain.com:8000/genre.ogg
    ProxyPassReverse / http://genre.domain.com:8000/genre.ogg
    
        Options All
        AllowOverride All
        Require all granted

Now, you have to create two virtual web sites, genre.domain.com and genrefw.domain.com. The genrefw.domain.com site will be an empty site. Read further and see how I built two web sites. You can make it much simpler or even more complex. I also enabled cgi-bin in order to run some scripts. The step below is optional. If you just want to bypass the firewall, create the two virtual hosts as described above and for regular users use http://genre.domain.com:8000/genre.ogg and for the users behind a firewall use http://genrefw.domain.com/genre.ogg.

Optional

I’ll create a web page that embeds the player and shows some info. There is a HTML5 menu and one of the options will tell you what track is currently playing. That’s why we needed cgi-bin. Here are my HTML and CSS files. Make sure you have 10 background images in the same directory, from background0.jpg to background9.jpg. They will rotate every 90 seconds. It looks cool! :) First, let’s create the cgi-bin folder under the virtual host destination.

cd /usr/local/www/genre.domain.com
mkdir cgi-bin

Then create a file called info.cgi that contains the following:

#!/bin/sh
echo "Content-type: text/html"
echo ""

echo ''
echo ''
echo ''
echo 'Currently Playing '
echo ''
echo ''
grep "INFO playlist" /var/log/ices/genre.log | tail -n 1 | sed 's/ INFO playlist-builtin\/playlist_read//' | sed 's/"//g' | sed 's/\/home\/radio\/genre\///'
echo ''
echo ''
exit 0

Then change permissions.

chmod 755 info.cgi

What this script does? It creates a simple HTML file from the output of the grep command. It just looks for the last appearance of the current playing track in the ices log.

Here is the HTML file.


    
        Genre Radio
            
	    
    



 
 

    INFO
    
        Radio
        
            Classical
            Other Genre
        
    
    About
    Contact

    
        
             
             Your browser does not support the audio element.
        
No sound? Click here!
Commercial Free Genre Radio: Kliment Andreev 2015 (c)

And the CSS file.

*{
    margin: 0;
    padding: 0;
}

body#bg0 {
  background: url('background0.jpg') no-repeat 50% 50% fixed;
  background-size: cover;
  -moz-background-size: cover;
  -o-background-size: cover;
  -webkit-background-size: cover;
}
body#bg1 {
  background: url('background1.jpg') no-repeat 50% 50% fixed;
  background-size: cover;
  -moz-background-size: cover;
  -o-background-size: cover;
  -webkit-background-size: cover;
}
body#bg2 {
  background: url('background2.jpg') no-repeat 50% 50% fixed;
  background-size: cover;
  -moz-background-size: cover;
  -o-background-size: cover;
  -webkit-background-size: cover;
}
body#bg3 {
  background: url('background.jpg') no-repeat 50% 50% fixed;
  background-size: cover;
  -moz-background-size: cover;
  -o-background-size: cover;
  -webkit-background-size: cover;
}
body#bg4 {
  background: url('background4.jpg') no-repeat 50% 50% fixed;
  background-size: cover;
  -moz-background-size: cover;
  -o-background-size: cover;
  -webkit-background-size: cover;
}
body#bg5 {
  background: url('background5.jpg') no-repeat 50% 50% fixed;
  background-size: cover;
  -moz-background-size: cover;
  -o-background-size: cover;
  -webkit-background-size: cover;
}
body#bg6 {
  background: url('background6.jpg') no-repeat 50% 50% fixed;
  background-size: cover;
  -moz-background-size: cover;
  -o-background-size: cover;
  -webkit-background-size: cover;
}
body#bg7 {
  background: url('background7.jpg') no-repeat 50% 50% fixed;
  background-size: cover;
  -moz-background-size: cover;
  -o-background-size: cover;
  -webkit-background-size: cover;
}
body#bg8 {
  background: url('background8.jpg') no-repeat 50% 50% fixed;
  background-size: cover;
  -moz-background-size: cover;
  -o-background-size: cover;
  -webkit-background-size: cover;
}
body#bg9 {
  background: url('background9.jpg') no-repeat 50% 50% fixed;
  background-size: cover;
  -moz-background-size: cover;
  -o-background-size: cover;
  -webkit-background-size: cover;
}

a, a:visited {
        outline:none;
        color:#1c4f64;
}

a:hover{
        text-decoration:none;
}

section, footer, header{
        display: block;
}


footer{
        background-color: #111111;
        bottom: 0;
        box-shadow: 0 -1px 2px rgba(0,0,0,0.4);
        height: 45px;
        left: 0;
        position: fixed;
        width: 100%;
        z-index: 100000;
}

footer h2{
        color: #EEEEEE;
        font-size: 14px;
        font-weight: normal;
        left: 50%;
        margin-left: -400px;
        padding: 13px 0 0;
        position: absolute;
        width: 540px;
}
footer h2 i{
        font-style:normal;
        color:#888;
}

footer a.tzine,a.tzine:visited{
        color: #999999;
        font-size: 12px;
        left: 50%;
        margin: 16px 0 0 110px;
        position: absolute;
        text-decoration: none;
        top: 0;
}

footer a.tzine1,a.tzine1:visited{
        color: #999999;
        font-size: 12px;
        left: -5%;
        margin: 16px 0 0 110px;
        position: absolute;
        text-decoration: none;
        top: 0;
}

footer a i{
        color:#ccc;
        font-style: normal;
}

footer a i b{
        color:#c92020;
        font-weight: normal;
}


body{
        /* Workaround for some mobile browsers */
  background: url('background9.jpg') no-repeat 50% 50% fixed;
  background-size: cover;
  -moz-background-size: cover;
  -o-background-size: cover;
  -webkit-background-size: cover;

        font:14px/1.3 'Segoe UI',Arial, sans-serif;
}

/* Main */
/* Original width e 100% a ne 30%"*/
#menu {
    width: 30%;
    margin: 0;
    padding: 10px 0 0 0;
    list-style: none;  
    background-color: #111;
    background-image: linear-gradient(#444, #111);
    border-radius: 50px;
    box-shadow: 0 2px 1px #9c9c9c;
}

#menu li {
    float: left;
    padding: 0 0 10px 0;
    position: relative;
}

#menu a {
    float: left;
    height: 25px;
    padding: 0 25px;
    color: #999;
    text-transform: uppercase;
    font: bold 12px/25px Arial, Helvetica;
    text-decoration: none;
    text-shadow: 0 1px 0 #000;
}

#menu li:hover > a {
    color: #fafafa;
}

*html #menu li a:hover { /* IE6 */
    color: #fafafa;
}

#menu li:hover > ul {
    display: block;
}

/* Sub-menu */
#menu ul {
    list-style: none;
    margin: 0;
    padding: 0;    
    display: none;
    position: absolute;
    top: 35px;
    left: 0;
    z-index: 99999;    
    background-color: #444;   
    background-image: linear-gradient(#444, #111);    
    -moz-border-radius: 5px;
    border-radius: 5px;
}

#menu ul li {
    float: none;
    margin: 0;
    padding: 0;
    display: block;  
    box-shadow: 0 1px 0 #111111, 
                0 2px 0 #777777;
}

#menu ul li:last-child { 
    box-shadow: none;    
}

#menu ul a {    
    padding: 10px;
    height: auto;
    line-height: 1;
    display: block;
    white-space: nowrap;
    float: none;
    text-transform: none;
}

*html #menu ul a { /* IE6 */   
    height: 10px;
    width: 150px;
}

*:first-child+html #menu ul a { /* IE7 */    
    height: 10px;
    width: 150px;
}

#menu ul a:hover {
    background-color: #0186ba;
    background-image: linear-gradient(#04acec, #0186ba);
}

#menu ul li:first-child a {
    border-radius: 5px 5px 0 0;
}

#menu ul li:first-child a:after {
    content: '';
    position: absolute;
    left: 30px;
    top: -8px;
    width: 0;
    height: 0;
    border-left: 5px solid transparent;
    border-right: 5px solid transparent;
    border-bottom: 8px solid #444;
}

#menu ul li:first-child a:hover:after {
    border-bottom-color: #04acec; 
}

#menu ul li:last-child a {
    border-radius: 0 0 5px 5px;
}

/* Clear floated elements */
#menu:after {
    visibility: hidden;
    display: block;
    font-size: 0;
    content: " ";
    clear: both;
    height: 0;
}

* html #menu             { zoom: 1; } /* IE6 */
*:first-child+html #menu { zoom: 1; } /* IE7 */

Convert mp3 to ogg

You can use the sox utility that comes in the ports.

pkg install sox

Check the man page for detailed syntax, but I use simple conversion.

sox filename.mp3 filename.ogg

You can check the properties of any audio file with:

soxi filename

For batch conversion, create this script called mp32ogg.sh and execute it against all files in the folder. It will convert all mp3 files to ogg. Add sox parameters if needed.

#!/bin/sh
for i in *.mp3; do
        sox ./"$i" ./"${i%.mp3}.ogg"
done