How do I set up live audio streams to a DLNA compliant device?

Pulseaudio-DLNA

I created a little server which discovers all upnp renderers in your network and adds them as sinks to pulseaudio. So you can control every application via pavucontrol to play on your upnp devices.

That's the kind of comfort I always wanted when dealing with upnp devices under linux.

The application can be installed from source or DEB package downloadable from git, or after we had added the project's official ppa:qos/pulseaudio-dlna to our sources with:

sudo apt-get update && sudo apt-get install pulseaudio-dlna

We then run pulseaudio-dlna from the command line with following options:

pulseaudio-dlna [--host <host>] [--port <port>] [--encoder <encoder>] [--renderer-urls <urls>] [--debug]
pulseaudio-dlna [-h | --help | --version]

See also the pulseaudio-dlna "About" for more.

When there was a DLNA renderer present we can then select it from the sound menu as an output sink:

Pavucontrol is the missing item in this jigsaw puzzle! I had also set up everything correctly and the external device(LG TV) was showing that the sound was being played but I did not hear any sound. Today I installed pavucontrol and when I opened it I found the option to channel sound through the DLNA server. The DLNA option is only shown when there is sound output from a player to pulseaudio.

I'm sorry I can't help you with Rygel at all, but there may be an alternative which may work for you.

The principle is get a program to record the stream to an audiofile, then launch miniDLNA with a custom config which points to the directory that stream is in.

Example: Say we're working in ~/stream/. Create ~/stream/minidlna.conf

network_interface=wlan0
media_dir=/home/<user>/stream/
friendly_name=Live Audio Stream
db_dir=/home/<user>/stream/
album_art_names=Cover.jpg/cover.jpg/AlbumArtSmall.jpg/albumartsmall.jpg/AlbumArt.jpg/albumart.jpg/Album.jpg/album.jpg/Folder.jpg/folder.jpg/Thumb.jpg/thumb.jpg
inotify=no
enable_tivo=no
strict_dlna=no
notify_interval=900
serial=12345678
model_number=1

Then save the stream to an audiofile in that directory. Googling for "FFmpeg record sound card audio" yielded this command

ffmpeg -f alsa -i default -acodec flac ~/stream/OutputStream.flac

but I didn't have much luck with it. Another option is vlc is you have a GUI available and this doesn't work.

Then boot up miniDLNA in another terminal window:

minidlna -d -f ~/stream/minidlna.conf -P ~/stream/minidlna.pid

It should locate OutputStream.flac and then be accessible from your network device.

Hopefully if you haven't already got it solved that's given you a few ideas.

One idea I had to stream "what I hear" to a DLNA renderer (like WDTV) was to server the stream with VLC as http stream with pulse://alsa_output.xxx.monitor as input and transcode it to MP3 or FLAC. Then I wanted to use some DLNA control point to let the renderer play taht stream. VLC does serve the transcoded stream correctly, but it does not allow to set the mime type, so the renderer refuses to play it.

The next idea was to write a http server in python that serves the stream instead. It gets the audio stream from pulse with parec, encodes it with flac (or lame or whatever you want) and sets the mime type correctly.

It works with the following (very simple) script:

#!/usr/bin/python

import BaseHTTPServer
import SocketServer
import subprocess

PORT = 8080
# run "pactl list short |grep monitor" to see what monitors are available
# you may add a null sink for streaming, so that what is streamed is not played back locally
# add null sink with "pactl load-module module-null-sink"
MONITOR = 'null.monitor'
MIMETYPE = 'audio/flac'
ENCODER = 'flac - -c --channels 2 --bps 16 --sample-rate 44100 --endian little --sign signed'
BUFFER = 65536

class Handler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_HEAD(s):
    print s.client_address, s.path, s.command
    s.send_response(200)
    s.send_header('content-type', MIMETYPE)
    s.end_headers()
def do_GET(s):
    s.do_HEAD()
    pa = subprocess.Popen('parec -d {} | {}'.format(MONITOR, ENCODER), shell = True, bufsize = BUFFER, stdout = subprocess.PIPE)
    while True:
        data = pa.stdout.read(1024)
        if len(data) == 0: break
        s.wfile.write(data)
    print 'stream closed'


httpd = SocketServer.TCPServer(("", PORT), Handler)

print "listening on port", PORT

try:
httpd.serve_forever()
except KeyboardInterrupt:
pass

httpd.server_close()

Adjust the parameters, run it, and point the DLNA renderer to your machine. It worked for me with a WDTV as renderer and an Android phone with BubbleUPnP as control point (You can type in the stream URL when adding a new item to the playlist manually). But it should work with any DLNA compliant devices.

NOTE: This solution works, but a newer and probably better solution has been proposed by Massimo.

Here's an answer for Ubuntu 14.04 (also tested and working on 15.04), for completeness:

1. install any needed packages: sudo apt-get install rygel rygel-preferences rygel-gst-launch

2. create the file ~/.config/rygel.conf that contains the following:

   [GstLaunch]
   enabled=true
   title=@REALNAME@'s stream
   launch-items=myaudioflac;myaudiompeg
   
   myaudioflac-title=FLAC audio on @HOSTNAME@
   myaudioflac-mime=audio/flac
   myaudioflac-launch=pulsesrc device=upnp.monitor ! flacenc quality=8
   
   myaudiompeg-title=MPEG audio on @HOSTNAME@
   myaudiompeg-mime=audio/mpeg
   myaudiompeg-launch=pulsesrc device=upnp.monitor ! lamemp3enc target=quality quality=6
   
   [Playbin]
   enabled=true
   title=Audio/Video playback on @REALNAME@'s computer
   
   [general]
   interface=
   upnp-enabled=true
   
   [MediaExport]
   uris=
   

3. Execute the following commands from the commandline (these could be put into a script if desired):

   pactl load-module module-http-protocol-tcp
   pactl load-module module-rygel-media-server 
   rygel &
   

4. Run the paprefs command, and ensure that both DLNA options are enabled (checked) on the "Network Server" tab.

5. Play some audio on your computer. Run the pavucontrol program, and on the "Playback" tab, change the output device to "DLNA/UPnP Streaming".

At this point, you should be able to play the MPEG and FLAC streams from a DLNA client (renderer / control point).

NOTE: you may need to restart your computer (or restart pulse) in order for things to begin to work.

The python script from Adam is just what I needed. Brilliant. Rygel with gst-launch doesn't work with one of my renderers, but this script works with both. In my case I'm taking an audio stream input from squeezelite (for squeezebox) and sending to a renderer. The script also works in the original form to take input from a pulseaudio monitor if that's what is needed.

Knowing little about any of this I managed to make some additions to the script that:

i) allow it to be run from a shell script and be terminated with a SIGTERM/SIGKILL (the 'except' statement now includes 'systemexit')

ii) allows the script to be stopped and restarted and re-use the same port (as it was the restarted script tended to fail saying it could not open the port if the renderer still had it open) - (the allow_reuse_address = True statement)

iii) make a version that takes input from stdin and resamples it using sox to output in wav format (on port 8082)

So my version looks like:

#!/usr/bin/python

import BaseHTTPServer
import SocketServer
import subprocess

PORT = 8082

MIMETYPE = 'audio/x-wav'
BUFFER = 65536

class Handler(BaseHTTPServer.BaseHTTPRequestHandler):
  def do_HEAD(s):
    print s.client_address, s.path, s.command
    s.send_response(200)
    s.send_header('content-type', MIMETYPE)
    s.end_headers()
  def do_GET(s):
    s.do_HEAD()
    pa = subprocess.Popen('sox -t raw -r 96000 -b 24 -L -e signed -c 2 - -t wav -r 44100 -b 16 -L -e signed -c 2 - ', shell = True, bufsize = BUFFER, stdout = subprocess.PIPE)
    while True:
        data = pa.stdout.read(1024)
        if len(data) == 0: break
        s.wfile.write(data)
    print 'stream closed'

SocketServer.TCPServer.allow_reuse_address = True
httpd = SocketServer.TCPServer(("", PORT), Handler)

print "listening on port", PORT

try:
 httpd.serve_forever()

except (KeyboardInterrupt, SystemExit):
 pass

httpd.server_close()

Not sure if this is will be useful for you now, but I written a post about getting this to work on Ubuntu 12.10:

http://dpc.ucore.info/blog/2012/11/07/dlna-streaming-in-ubuntu-12-dot-10/