About a Stream

Alas – I am not really a gamer, I played Doom in the 90’s and that’s about it. As a hobby music producer and wannabe superstar DJ the live music broadcasts on Twitch were of much more interest to me, and as a web developer, programmer, the technology behind the live streams also interested me.

Most game streamers on Twitch require at least two fairly high powered Windows PC’s to stream their content live to Twitch, one PC for game play and one PC to capture the game play video content and encode it into a format supported by the Twitch ingest media servers. OBS Studio is a popular free and open source software for video recording and live streaming and most of the top streamers have created a very professional looking stream with OBS using overlay graphics and dynamic alerts to provide interaction between the streamer and the viewers. Top streamers regularly attract viewing audiences in the 10s of thousands.

Using OBS Studio on my trusty old Macbook Pro I was able to live stream my latest DJ set using a couple of webcams, some audio visualisation graphics and moi the superstar DJ on the decks! After playing for a few hours I had attracted a grand total of 1 viewer and his dog – but hey it was a lot of fun.

A few weeks later a friend of mine said to me “man you just don’t stream enough” and it was clear that to attract viewers and followers I would have to put in a lot of streaming hours which I just didn’t have time for.  I thought that some kinda 24/7 automated stream would be cool – I could stream all day long! I wasn’t about to go out and buy a new Mac (or god forbid a gaming PC) and attempt to stream 24/7 from my home so I started thinking about other ways to develop a streaming platform that would run (economically) on a hosted unix server.

ffmpeg

I’ve been involved with media streaming projects in the past and was familiar with FFMPEG “A complete, cross-platform solution to record, convert and stream audio and video” A quick Google for “ffmpeg twitch” revealed that FFMPEG can also stream it’s output to Twitch (and other live stream services – YouTube, Facebook etc.) and after a few test streams I set about developing my own streaming platform using Docker service containers.

In November 2017 I started streaming Techno DJ sets 24/7. My goal was to create an interactive Twitch music channel (mostly playing Techno DJ sets) where viewers could interact with the channel by “liking” the DJ that was playing and change what was playing by making requests. Other DJ’s could upload their own sets which would then be reviewed and added to a dynamically changing daily playlist. I wanted the channel to be visually interesting with constantly changing and interesting visuals and dynamic overlays showing what was currently playing and how viewers had recently interacted with the channel. I also wanted to be able to feed audio into the stream relatively dynamically either from static local media files, live feeds – i.e. me on the sofa or from online sources such as Soundcloud and YouTube.

My Docker live stream environment looks a bit like this:

The media servers create the main audio and background video streams. The stream manager creates dynamic graphic and text overlays based on what is playing, viewer stats, ticker tape messages etc. It also monitors the encoder log files for errors and can restart encoders when required. Similarly the chat bot server interacts with viewers on Twitch accepting commands from the Twitch stream chat IRC channel allowing viewers to see what’s playing, “like” the current DJ or make requests. All the stream data required by the manager and chat bot is either stored in an SQL database or cached using memcached. The encoders – running ffmpeg in small debian Docker containers – encode all the stream data – audio, video, graphic and text overlays into a format accepted by the streaming service provider, i.e. Twitch.

I started developing the docker images and code for my live streaming platform on a VMWare Ubuntu server with access to a fairly good Intel processor. The most processor intensive containers are the media encoders running FFMPEG. Without a dedicated graphics GPU all the rendering needs to be done by the main processor/s. As the quality and frame rate of the stream increase so does the processing power required to encode the stream fast enough to satisfy the streaming service provider. For example YouTube expects a 720p HD stream to have a resolution of 1280×720 and a video bitrate range of  1,500 – 4,000 Kbps. As my content was relatively static – no high frame rate game action – I was able to lower my frames per second to 15 and still produce an acceptable looking 720p HD stream and with some other FFMPEG tweaks I was ready to move the stream to a live server.

Going Live

My live server is an 8GB VPS with 4 CPU cores. As soon as I started up the streaming containers everything else running on the server ground to a halt and it was pretty clear that I would need a dedicated server for live streaming.

With RAM and bandwidth not a real issue the VPS just needed enough CPU power to run at least 1 encoder. It took a few upgrades before I found a VPS that could handle the stream without completely maxing out the available processing power and that came within my monthly budget. The live server has been running one Twitch stream for over 6 months without any real problems. Occasionally the CPU maxes out causing the encoder threads to fail usually resulting in a stream “hang” or crash – this is no big problem Docker restarts the crashed server instantly and the stream manager will restart the encoder when errors in the logs are detected.

As I developed the stream I started added more overlays, more graphics and shiny knobs. All things that require more encoder power until I was at a point where I knew I would need to consider a new VPS, especially if I wanted to simultaneously stream to other services such as YouTube.

The Live Stream on Twitch @ 720p HD (15fps)

Introducing the Packet c2.medium.x86

About this time the nice people at Packet sent me an email inviting users to test their new AMD EPYC c2.medium.x86 bare metal servers and I jumped at the opportunity of trying out my streaming platform on a big beast of a server.

Installing my streaming environment on the c2.medium.x86 was a real breeze. The Packet c2.medium.x86 Ubuntu server deployed in Amsterdam in just a few minutes. I installed Docker and transferred all my data via a remote tar over ssh from my live streaming server to the c2.medium.x86. All my Docker containers built in a few minutes and then it was simply a case of stopping my live stream containers in London and starting the c2.medium.x86 containers in Amsterdam. Et Voila  – I was streaming from Amsterdam!

The c2.medium.x86 really puts the BEAR into bare metal server – because it is a beast of a machine with 24 physical cores / 48 hyperthreaded cores at a 2.0 Ghz base clock speed (3.0 Ghz max with turbo). With one encoder running my live Twitch stream the processor overall load was about 1%. You can see ffmpeg using 76% of one hyperthreaded  core below.

I asked a few questions in the Packet slack community about processor usage and the opinion was that I could probably run another 47 encoders before I maxed out the AMD EPYC processor. That would be 48 unique streams! To test this theory I created another three ffmpeg encoders to give me four concurrent live streams encoding on the AMD EPYC – 2 on Twitch, 1 on YouTube, 1 on Facebook. With all four encoders running processor utilisation was around 4%. Unfortunately I didn’t have any more YouTube, Facebook or Twitch accounts to stress the CPU with!

FFMPEG uses multi threading to take advantage of multi core processors, with 4 encoders running you can see lots of ffmpeg processes nicely spread across AMD EPYC hyperthreaded cores.

Conclusions

I am no expert when it comes to understanding the architecture of modern servers and processors but I do know that the AMD EPYC running in the Packet c2.medium.x86 was perfect for live stream encoding with ffmpeg.

Live streaming is becoming very popular across many social media platforms and whilst there are online services available that will multicast your live stream to multiple services there is no reason why you cannot create your own on demand streams broadcasting live content to various platforms either for a live event or for a one time marketing project.

Simply spin up a c2.medium.x86 and let it fly.

I want to thank Packet for giving me the opportunity of testing the c2.medium.x86 Server as part of their AMD EPYC challenge.

With Shoutcast you can create live broadcasts very quickly and reach large audiences cost effectively. I wanted to implement a new Amazon AWS server running Ubuntu 12.04 for a live streaming event and thought I would document the Shoutcast install process as I went along.

The commands below were executed as root, if you do not have root access use the sudo prefix to execute them with superuser privileges.

DOWNLOAD SHOUTCAST

Shoutcast does not come already packaged as an installer for Ubuntu so first we want to download the correct version of Shoutcast for our server.

goto http://www.shoutcast.com/broadcast-tools and download the version you require, I need the 64bit version for my 64bit Ubuntu 12.04 Amazon AWS server. The current version at time of writing is SHOUTcast Server v2.0.0.29/posix(linux x64)

Create an application directory for Shoutcast

/home/apps/shoutcast

get the shoutcast package

wget http://download.nullsoft.com/shoutcast/tools/sc_serv2_linux_x64_07_31_2011.tar.gz

Extract the package

gzip -d sc_serv2_linux_x64_07_31_2011.tar.gz
tar -xvf sc_serv2_linux_x64_07_31_2011.tar

This will extract the Shoutcast files, you will see the main binary sc_serv, some example config files and folders for logs and documentation.

If you want to start Shoutcast now, simple type ./sc_serv and you will be prompted to choose one of the detected config files. Choose 0 for the basic config file and check if the Shoutcast daemon starts without errors. The most likely startup error will be that it cannot bind the default TCP port as it is already in use, by default shoutcast will use TCP8000.

CREATE STARTUP SERVICE

We want to run Shoutcast as a background service that can easily be stopped and started. Use the bash script below and paste it into a new file called shoutcast in /etc/init.d

Modify the script with the correct locations of your sc_serv binary and the configuration file you want to use.

Make the script executable and give it full permissions

chmod +x /etc/init.d/shoutcast
chmod 755 /etc/init.d/shoutcast

Then install shoutcast as a service with

root@ubuntu:/etc/init.d# update-rc.d shoutcast defaults
Adding system startup for /etc/init.d/shoutcast …
/etc/rc0.d/K20shoutcast -> ../init.d/shoutcast
/etc/rc1.d/K20shoutcast -> ../init.d/shoutcast
/etc/rc6.d/K20shoutcast -> ../init.d/shoutcast
/etc/rc2.d/S20shoutcast -> ../init.d/shoutcast
/etc/rc3.d/S20shoutcast -> ../init.d/shoutcast
/etc/rc4.d/S20shoutcast -> ../init.d/shoutcast
/etc/rc5.d/S20shoutcast -> ../init.d/shoutcast

Start service

Check if shoutcast will start and stop using

/etc/init.d/start shoutcast or service shoutcast start

You can confirm shoutcast is running by searching for it’s running process

ps -ef | grep sc_serv

You can also confirm the server is running by connecting to shoutcast with your browser using

http://server.address:8000/index.html

TCP 8000 is the default listener port used by Shoutcast, note, if your server is already using TCP8000 select another port for Shoutcast and configure it in your config file with e.g. portbase=8010

Restart shoutcast and connect using http://server.address:8010/index.html

Ensure that you change the default changeme admin  passwords in the configuration file.

To configure your streaming mount points simply create configuration entries for each live stream you require

streamid_1=1
streampath_1=/livestream1
streampassword_1=password
streamid_2=2
streampath_2=/livestream2
streampassword_2=password

Test streaming

Assuming Shoutcast now starts correctly with your configuration file and you can connect to the admin page with your browser you should configure your streaming client to connect to the server.

The client will normally specify the server type as shoutcast, and then will require the server address and password for the mountpoint. In some cases you may need to specify the mount point in the client too as configured.

Here is a server config example from Nicecast connecting on TCP8002.

With your streaming client source connected, you can then publish the stream address as http://server.address:8010/mountpointname

Test you are now streaming live by connecting any media player to the stream url.

Note be sure to configure the stream meta information in your client, shoutcast will reject the streaming client connection if the source URL meta tag is left blank.

Startup script

#!/bin/sh

### BEGIN INIT INFO
# Provides:          Shoutcast application instance
# Required-Start:    $all
# Required-Stop:     $all
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: starts instance of Shoutcast
# Description:       starts instance of Shoutcast using start-stop-daemon
### END INIT INFO#

############################################################################
##  CHANGE THESE VALUES to match your setup
## CONFIG is the fully qualified location of your config file
## DAEMON is the fully qualified location of the sc_serv binary
############################################################################

CONFIG="/home/apps/shoutcast/sc_serv_basic.conf"
DAEMON="/home/apps/shoutcast/sc_serv"

# Check for SHOUTcast binary
test -f $DAEMON || exit 0

# The init commands
case "$1" in
        start)
                echo "Starting SHOUTcast server..."
                $DAEMON $CONFIG  > /dev/null 2>&1 &
                ;;
        stop)
                echo "Stopping SHOUTcast server..."
                kill -9 `ps -C sc_serv -o pid --no-headers`
                ;;
        restart)
                echo "Stopping SHOUTcast server..."
                kill -9 `ps -C sc_serv -o pid --no-headers`
                echo "Starting SHOUTcast server..."
                $DAEMON $CONFIG  > /dev/null 2>&1 &
                ;;
        *)
                echo "usage: /etc/init.d/shoutcast"
                echo "$0 {start | stop | restart}"
                exit 1
                ;;
esac

The deal was to offer audio or video media in return for Liking a Facebook page (although this is optional). I also wanted a rating system for the media which could be used later together with the Social information harvested from users as a marketing opportunity.

A working demonstration is available here your comments are very welcome. You will need to connect with the app and like the Facebook page before the media will stream.

The app is written in PHP with a MySQL database, using a few jQuery plugins including jPlayer for the media player and jRating integrated with jPlayer and the database for the rating system.

Media and user information are stored in the database.

What is FFMPEG, video and audio

What is FFmpeg? Simply put, FFmpeg is a Hyper fast Audio and Video encoder. It is a free software project that “produces libraries and programs for handling multimedia data. The name of the project comes from the MPEG video standards group, together with “FF” for “fast forward“.”

FFmpeg will do everything you want with audio and video but installing it and getting to grips with the command line options can be daunting. Here I will create a very simple list of the most common tasks you will want to do with FFmpeg video including command line options showing how to do it.

Installing ffMPEG  MAC OSX, Linux FOR USE WITH VIDEO AND AUDIO

The FFmpeg source code compiles and runs on all platforms, but getting the latest build with all the latest codecs and libraries compiled for your operating system can be troublesome. I am working mostly with Linux (Ubuntu) and OSX and found the easiest way to install the latest version of FFmpeg and libraries was to compile the source code myself.

FFMPEG INSTALL FOR  UBUNTU

For Ubuntu (10.10, 11.04, 11.10, 12.04) by far the best guide to do this comes from the Ubuntu forums, so I will not document everything use this LINK for the complete guide.

Follow these steps for the Ubuntu install.

Install the Dependencies

sudo apt-get remove ffmpeg x264 libx264-dev
sudo apt-get update
sudo apt-get install build-essential checkinstall git libfaac-dev libjack-jackd2-dev \
  libmp3lame-dev libopencore-amrnb-dev libopencore-amrwb-dev libsdl1.2-dev libtheora-dev \
  libva-dev libvdpau-dev libvorbis-dev libx11-dev libxfixes-dev texi2html yasm zlib1g-dev

Install x264

cd
git clone git://git.videolan.org/x264
cd x264
./configure --enable-static
make
sudo checkinstall --pkgname=x264 --pkgversion="3:$(./version.sh | \
    awk -F'[" ]' '/POINT/{print $4"+git"$5}')" --backup=no --deldoc=yes \
    --fstrans=no --default

Install FFmpeg

cd
git clone --depth 1 git://source.ffmpeg.org/ffmpeg
cd ffmpeg
./configure --enable-gpl --enable-libfaac --enable-libmp3lame --enable-libopencore-amrnb \
    --enable-libopencore-amrwb --enable-libtheora --enable-libvorbis --enable-libx264 \
    --enable-nonfree --enable-postproc --enable-version3 --enable-x11grab
make
sudo checkinstall --pkgname=ffmpeg --pkgversion="5:$(date +%Y%m%d%H%M)-git" --backup=no \
  --deldoc=yes --fstrans=no --default
hash x264 ffmpeg ffplay ffprobe

Ignore all the compilation warnings, they are very boring. I first compiled FFMpeg on an Amazon EC2 Micro instance and the compilation took well over an hour. On my 512 Linode it took about 10 mins. Note that the compilation process is processor intensive, if you are doing this on a live server do it out of hours so as not to affect other applications.

The newest source code for FFmpeg is always here

git clone --depth 1 git://source.ffmpeg.org/ffmpeg

FFMPEG MAC OSX LION 10.7.2

UPDATE – if you are using Mountain Lion OS X 10.8 check this post out for extra steps required.

For OSX use the Homebrew package manager to compile and install the latest version of FFmpeg. If you need to install Homebrew run the following from a terminal command line

/usr/bin/ruby -e "$(curl -fsSL https://raw.github.com/gist/323731)"

—————————————–

==> This script will install:
/usr/local/bin/brew
/usr/local/Library/Formula/…
/usr/local/Library/Homebrew/…
==> The following directories will be made group writable:
/usr/local/.
==> The following directories will have their group set to admin:
/usr/local/.

Press enter to continue
==> /usr/bin/sudo /bin/chmod g+rwx /usr/local/.
==> /usr/bin/sudo /usr/bin/chgrp admin /usr/local/.
==> Downloading and Installing Homebrew…
Warning: Now install Xcode: http://developer.apple.com/technologies/xcode.html
==> Installation successful!

Now type: brew help

—————————————–

Homebrew is dependent on XCode, the Apple development application, before you can install any packages with Homebrew install the free XCode app from the Appstore. It is a big application and around a 2GB download so visit the Apps Store and go for a coffee.

With XCode installed you can install FFmpeg using brew on OSX 10.7.2 with the following command line

brew install ffmpeg --use-clang

MP4Box for MAC and LINUX

If you will be streaming video using the Apple Darwin Streaming Server you will need to hint your video files, install the gpac package using Homebrew (OSX) or apt-get (Linux) to obtain the MP4Box utility for hinting video files.

brew install gpac

apt-get install gpac

Remember the MP4Box command is case sensitive, it’s MP4Box not mp4box.

TEST FFMPEG

All being well type ffmpeg from your command line and check that the software has installed sucessfully.

ffmpeg version git-2012-01-19-1ce8377 Copyright (c) 2000-2012 the FFmpeg developers
built on Jan 19 2012 10:42:18 with gcc 4.6.1

HOW TO – How to do what you want with FFmpeg

Extract Audio from a Video using FFMPEG

This will extract the audio from a video file – myvideo.mp4 and create a new 44Khz 2 channel stereo 128Kbps MP3 file.

ffmpeg -i myvideo.mp4 -vn -ar 44100 -ac 2 -ab 128k -f mp3 myvideoaudio.mp3

CREATE A Video from an Image file using FFMPEG

You see this a lot on YouTube and Facebook, people actually want to share audio so they create a video that consists of one still image for the duration of the song. I have done this before with full blown video apps and its a long process for a relatively simple requirement. With FFmpeg its done ultra fast with a simple command line, an image file and an audio file:

Create a 720×576 (PAL) MP4 x264 video myvideo.mp4 from the image myimage.jpg and the audiofile myaudio.mp3

ffmpeg -s 720x576 -r 25 -loop 1 -shortest -y -i  myimage.jpg -i  myaudio.mp3 -acodec libfaac -ac 2 -ar 44100 -ab 128k -async 1 -vcodec libx264 -level 1.3 myvideo.mp4

Here is an example from Uncle Iggy

i-wanna-be-your-dog.jpg => i-wanna-be-your-dog-mp3 => myvideo.mp4

Note that I made the image 720×576 pixels to match the encode settings. 25fps is probably overkill here and results in a larger video file.

ffmpeg -s 720x576 -r 25 -loop 1 -shortest -y -i  i-wanna-be-your-dog.jpg -i I-Wanna-Be-Your-Dog.mp3 -acodec libfdk_aac -ac 2 -b:a 128k -async 1 -vcodec libx264 myvideo.mp4

I am going to hint this too so I can add it to my Quicktime server and RTSP stream it (click the image for a demo).

MP4Box -hint myvideo.mp4

(Image source – google images, music from Iggy and the Stooges.)

Now lets add a series of images to the video to make it slightly more interesting. This is a very quick method for creating a slide show type video from a series of images.

We do this by specifying the input parameter with the % wildcard, i.e. image-%3d.jpg where %3d indicates our image will be named image-XXX.jpg, i.e. image001.jpg, image002.jpg, image003.jpg etc.

Forcing FFmpeg to use a framerate of 1 frame per second (-force_fps), our images are shown with a 1 second delay between them and our resulting video at 1fps is relatively small, 4Mb or so, not much larger than the MP3 file.

For a longer delay use two images that are identical together which  would create a 2 second gap, 4 images a 4 second gap etc.

ffmpeg -s 720x576 -r 1 -force_fps -loop 1 -shortest -y -i  image%3d.jpg -i I-Wanna-Be-Your-Dog.mp3 -acodec libfdk_aac -ac 2 -b:a 128k -async 1 -vcodec libx264 myvideo.mp4

CREATE An FFMPEG VIDEO FROM A PHOTOSHOP IMAGE SEQUENCE

Photoshop is great for creating titles quickly using the video timeline to render text and images into 25fps image sequence frames that we can quickly convert into video using ffmpeg. To add audio to your clip trim the audio to the length of your video.

Use this command to create the video, you can see the results by clicking the image below.

ffmpeg -s 720x576 -r 25 -i  photoshop0%3d.jpg -i sample.mp3 -acodec libfdk_aac -ac 2 -b:a 128k -async 1 -vcodec libx264 myvideo.mp4

EXTRACT A SINGLE IMAGE FROM A VIDEO USING FFMPEG

If we want to extract a single frame image file from a video, for example to use as a movie poster image  use the following command line –

ffmpeg -i myvideo.mp4 -vframes 1 -ss 00:00:05 -f image2 image-%3d.jpg

This will extract 1 frame from myvideo.mp4 starting at the fifth second of the video creating the image file image-XXX.jpg.

BATCH CONVERT video for DARWIN RTSP streaming with ffmpeg

We want to convert existing media files to stream live with Apples Darwin media server. For a live stream everything in Darwin must be encoded with the same parameters. The best way to do this is to batch convert all your media with FFmpeg. I am going to create a bash script on my Mac to use FFmpeg to encode all MP4 files in a folder to a new MP4 folder. I will encode them to 720×576 (pal) 25fps with 2 channel stereo AAC audio at 128kbps and H.264 video at 768Kbps.

touch a new file mp4768 and make it executable, chmod +x mp4768

Edit the file and paste the following

#===================================
#the directory mp4 must be present in the current directory
for f in *.mp4;
do
ffmpeg  -i  "$f" -s 720x576 -r 25 -acodec libfdk_aac -ac 2 -b:a 128k -async 1 -vcodec libx264 -level 1.3 -b:v 768k -bt 768k "mp4/${f%.mp4}.mp4"; done #====================================

Now copy the files you want to convert into a folder, and create a subfolder called mp4. Run the bash script to convert all the files i.e. /bin/mp4768

Don’t forget to hint the files afterward for RTSP streaming with Apples Darwin Streaming media server.

This also gives us the interesting option of combining what we have learnt creating videos from image files, to create on the fly content for live Darwin streams using PHP and FFmpeg – more on that in another post!

If you have more cool FFmpeg video usage examples to add to this post please let me know!

My example will embed the video using Apples recommended multi browser html and javascript code,  reference movie file and a poster image.

First, the reference movie file. If you use Quicktime Pro you can get the software to generate a reference file when you encode your movies for the web. The reference file has a .mov file extension but is not a media file instead it passes information to Quicktime to help it determine the best media to play for the client, i.e. low bandwidth version, iPhone version etc. In my case I am streaming all my media through a Darwin Streaming Server using RTSP and will create a reference file that points to the videos on my Darwin server.

The media reference file is accessed from Quicktime via HTTP so needs to be saved on in a publicly accessible area of your site.

In my example I am going to embed Bowies Lets Dance video. The video is saved in my Darwin media folder /home/media/video and is called davidbowie-lets-dance.mp4.

In my website folder I create a reference file called davidbowie-lets-dance.mov and paste the following text into it.

RTSPtextRTSP://medazzaland.co.uk:554/video/davidbowie-lets-dance.mp4

We need a “poster” image to represent the video, this will be shown on the embed page before the video plays, so we simply take a frame from the video and save it in a publicly accessible folder, in this example its called davidbowie-lets-dance.png

Now the HTML code to embed the video. In the head section we need to include Apples javascript and some styling that is used for the Click Here link on the embedded video.

<script src="http://www.apple.com/library/quicktime/scripts/ac_quicktime.js" language="JavaScript" type="text/javascript"></script>
<script src="http://www.apple.com/library/quicktime/scripts/qtp_library.js" language="JavaScript" type="text/javascript"></script>
<link href="http://www.apple.com/library/quicktime/stylesheets/qtp_library.css" rel="StyleSheet" type="text/css" />

And now for the embed code which should go between the body tags of your html

	<div id="quicktimevideo">
		<script type="text/javascript"><!--
		QT_WritePoster_XHTML('Click to Play - David Bowie - Lets Dance', 'images/davidbowie-lets-dance.png',
			'http://my.medazzaland.co.uk/reference/davidbowie-lets-dance.mov',
			'720', '576', '',
			'controller', 'true',
			'autoplay', 'true',
			'bgcolor', 'black',
			'scale', 'aspect');
	//-->
	</script>
	<noscript>
	<object width="720" height="576" classid="clsid:02BF25D5-8C17-4B23-BC80-D3488ABDDC6B" codebase="http://www.apple.com/qtactivex/qtplugin.cab">
		<param name="src" value="images/davidbowie-lets-dance.png" />
		<param name="href" value="http://my.medazzaland.co.uk/reference/davidbowie-lets-dance.mov" />
		<param name="target" value="myself" />
		<param name="controller" value="false" />
		<param name="autoplay" value="false" />
		<param name="scale" value="aspect" />
		<embed width="720" height="576" type="video/quicktime" pluginspage="http://www.apple.com/quicktime/download/"
			src="images/davidbowie-lets-dance.png"
			href="http://my.medazzaland.co.uk/reference/davidbowie-lets-dance.mov"
			target="myself"
			controller="false"
			autoplay="false"
			scale="aspect">
		</embed>
	</object>
	</noscript>

	</div>

This code should work across all browsers and will embed the video using the poster image as a link as show below.

Notice that the embed code points to the reference .mov file with an http link, the reference file then redirects Quicktime to the correct RTSP link for the video.

If you want to serve up a lot of videos in this way, you can create the reference file on the fly with PHP as I have done with this example – click the photo above to goto a demo page. The video information, name, title, size etc. are all stored in a database, the PHP script pulls out the video info from the database and creates the reference files and html on the fly.

As a side note, I was unable to compile Darwin from source under the latest version of Ubuntu Server 11.10, I had to use previously compiled files from another Ubuntu server running Ubuntu 8.x for the install.

I am still looking at perfecting the MP4 encoding for Darwin streaming, so more on that another time and Happy Birthday David Bowie!

DSS no longer compiles and runs new Ubuntu versions. If you want to use Darwin Streaming Server run it as a docker container using my DSS image.

If you want to know how I compiled DSS 6.0.3 on Ubuntu PRECISE back in the stone age – read on…

Over the last few years I have been involved with some projects that required streaming audio and video solutions and I have been working with the Open Source Darwin Streaming Server from Apple running mainly on the Linux platform. DSS will run under Windows but I wouldn’t recommend it.

The Darwin Streaming Server (DSS) is the open source version of Apples quicktime server technology which is built into Apples OS X Server. DSS can run under Mac OSX, Windows and Linux. The streaming server supports QuickTime Movie (MOV),  MPEG-4 (MP4), and 3GPP (3GP) “hinted” files. Support resources for DSS are quite limited so I will start to post information here to document some of the work I have done with DSS, including installation, configuration, use etc.

This first post will document the compilation, installation and testing of the current version of DSS, v6.0.3 under Linux.

The commands below assume you have superuser rights.

Compilation

To compile DSS we first need to make sure we have the required packages for the download and compile utilities.

Execute the following as a superuser, or use the sudo prefix command.

apt-get install build-essential wget

Need to get 19.6MB of archives.
After this operation, 66.8MB of additional disk space will be used.
Do you want to continue [Y/n]?

Hit Y to download and install the required packages.

Change to a working directory for the download and compilation i.e. /home/DSS and download the DSS 6.0.3 source (31MB) tar file directly to your working folder using wget:

wget http://static.macosforge.org/dss/downloads/DarwinStreamingSrvr6.0.3-Source.tar

Uncompress the tar file

tar -xvf DarwinStreamingSrvr6.0.3-Source.tar

Rename the source file directory to allow us to create a patch directory. The patches are required to compile DSS under a 64bit OS, but there is also no harm in applying them if you are using a 32bit OS.

mv DarwinStreamingSrvr6.0.3-Source DarwinStreamingSrvr6.0.3-Source.orig

Download the first patch file

wget http://dss.macosforge.org/trac/raw-attachment/ticket/6/dss-6.0.3.patch

Apply the patch

patch -p0 < dss-6.0.3.patch

Move the source file directory back

mv DarwinStreamingSrvr6.0.3-Source.orig DarwinStreamingSrvr6.0.3-Source

Download the second patch file

wget http://dss.macosforge.org/trac/raw-attachment/ticket/6/dss-hh-20080728-1.patch

Apply the patch

patch -p0 < dss-hh-20080728-1.patch

Change into the DSS source file directory

cd DarwinStreamingSrvr6.0.3-Source

Rename the source install file

mv Install Install.orig

Get the latest install file

wget http://dss.macosforge.org/trac/raw-attachment/ticket/6/Install

Set execute permissions on the install file

chmod +x Install

Compile the source code (dot slash Buildit)

./Buildit

-----------------------
Configuring for the Linux i686 platform
Building for Linux.i686 with gcc

Now is a good time to grab a coffee as the build process could take a few minutes. The various warning messages you will see can be safely ignored and unless you experience another serious error the compilation is completed when the command prompt returns.

Installation

First create the qtss user and group required by DSS

addgroup -system qtss
adduser -system -no-create-home -ingroup qtss qtss

and then run the DSS install script. (dot slash Install – case sensitive!)

./Install

The install script creates the DSS directory structure and copies files and sample media. When complete you will be prompted to create an administrator username and password. Enter the username and password you will use to administer DSS. Confirm the password.

Adding userName admin
Setup Complete!

Check permissions for the DSS configuration file in /etc/streaming, it must be writeable or the changes made in the administration pages will fail.

chmod 755 /etc/streaming/streamingserver.xml

The DSS installation is now complete, and the server should be started! To manually start the server use

/usr/local/sbin/streamingadminserver.pl

If the server is already running you will see

Failed to start Streaming Admin Server.
Port 1220 is in use by another process.
The Streaming Admin Server may already be running.

We can also configure DSS to auto start automatically on boot up, to do this download the following script

wget http://dss.macosforge.org/trac/raw-attachment/ticket/6/darwin-streaming-server

make it executable

chmod +x darwin-streaming-server

Move the script into /etc/init.d

mv darwin-streaming-server /etc/init.d/darwin-streaming-server

and update rc.d to so that it can auto start and respond to start/stop commands.

update-rc.d darwin-streaming-server defaults

The server can now be started and stopped with

/etc/init.d/darwin-streaming-server stop

/etc/init.d/darwin-streaming-server start

Configuration

The administration web service for DSS runs on TCP port 1220, to login to the server start a browser session and navigate to

http://servername-or-ip-address:1220

You will see the DSS login page, login with the username and password you created during the installation and click the Log In button.

The setup assistant will ask you for a MP3 broadcast password “The MP3 Broadcast password is required in order to receive MP3 broadcast streams.”

Enter the MP3 broadcast password you wish to use and click next to continue.

The setup assistant will ask you if you want to enable SSL for admin. “This will enable encryption between the administration server and the web client. This feature requires that you have a valid streaming server SSL certificate installed.”

Click the Next button to continue.

The setup assistant will ask you to confirm the Media folder for DSS “This is the folder or directory in which your media is stored.” To accept the default media folder (/usr/local/movies/) click the Next button, or enter the path to a new media folder. If you change the media folder make sure you set ownership of the new folder to the qtss user

chown -R qtss.root /home/mymediafolder

The setup assistant will ask you if you want to use Port 80 for streaming “This allows you to stream through firewalls.” Streaming on TCP port 80 instead of default RTSP ports will ensure that streaming clients behind most firewalls that might have none standard ports, such as RTSP blocked, will be able to access the streaming server via TCP Port 80 which is commonly used for HTTP access and is more likely to be permitted through firewalls. I recommend considering this later as you need to be sure that any existing services running on Port 80, i.e. Apache have been modified or stopped before you try and use DSS streaming on Port 80.

Click the Finish button to continue.

The main DSS administration screen will appear and the DSS installation and basic configuration is complete.

Make a tarball of your install directory and save it somewhere for future use!

Testing

If you look in the default media directory (/usr/local/movies) you will see some test audio and video media files.

i.e. /usr/local/movies/sample_h264_300kbit.mp4

To test your installation and stream one of the example media files open a media player capable of RTSP streaming, i.e. Apple Quicktime Player, VLC and open a new network stream in the player with the address

rtsp://servername-or-ip-address/sample_h264_300kbit.mp4

The 300Kbit h264 sample MP4 file will stream from your server and should play in your media player.

DSS Uses the following default directories for config, playlists, logs etc.

/usr/local/sbin/Darwin Streaming Server —- Server Software
/usr/local/sbin/streamingadminserver.pl —- Web Frontend
/etc/streaming —- Configuration Directory
/etc/streaming/streamingserver.xml —- Configuration File
/var/streaming/logs —- Logs
/usr/local/movies —- Default media directory

I will look at configuring the server further and preparing media for streaming in another blog post.

Further Resources

Looking for a media player for darwin mp3 streams – check out the facebook darwin media tab demo on my facebook page.

http://dss.macosforge.org/

http://ubuntuforums.org/archive/index.php/t-651556.html

http://lists.apple.com/mailman/listinfo2/streaming-server-users

http://dss.macosforge.org/post/40/

http://soundscreen.com/streaming/