Come posso impostare flussi audio live su un dispositivo conforme DLNA?

Esiste un modo per trasmettere l'output live della scheda audio dal nostro desktop amd64 12.04.1 LTS a un dispositivo esterno conforme DLNA nella nostra rete? Selezionare i contenuti multimediali nelle directory condivise usando Rygel, miniDLNA e uShare va sempre bene, ma finora non siamo riusciti a ottenere un flusso audio live su un client tramite DLNA.

Pulseaudio afferma di avere un server multimediale DLNA / UPnP che, insieme a Rygel, dovrebbe fare proprio questo. Ma non siamo riusciti a farlo funzionare.

Abbiamo seguito i passaggi descritti in live.gnome.org , questa risposta qui e anche in un'altra guida simile .

In 12.04 LTS possiamo selezionare il dispositivo audio locale o il nostro stream GST-Launch nel client DLNA ma Rygel visualizza il seguente messaggio e il client afferma che ha raggiunto la fine della playlist:

(rygel:7380): Rygel-WARNING **: rygel-http-request.vala:97: Invalid seek request

Non c'era modo di ascoltare flussi audio dal vivo sul client.

Solo dopo un aggiornamento della distribuzione a 14.04 LTS siamo stati in grado di selezionare un flusso live sui nostri renderer DLNA dalle impostazioni ben descritte nella risposta di seguito . Tuttavia, dopo aver avviato rygel abbiamo dovuto selezionare un flusso stabilito e non siamo riusciti a inviare un nuovo flusso ai nostri dispositivi UPnP. I metadati audio non sono stati trasmessi.

Esistono altre alternative per inviare l'audio della nostra scheda audio come live streaming a un client DLNA?

Pulseaudio-DLNA

Ho creato un piccolo server che scopre tutti i renderer upnp nella tua rete e li aggiunge come sink a pulseaudio. Quindi puoi controllare ogni applicazione tramite pavucontrol per giocare sui tuoi dispositivi upnp.

Questo è il tipo di comfort che ho sempre desiderato quando ho a che fare con dispositivi upnp su Linux.

L'applicazione può essere installata dal pacchetto sorgente o DEB scaricabile da git o dopo aver aggiunto il ppa ufficiale del progetto : qos / pulseaudio-dlna alle nostre fonti con:

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

Quindi eseguiamo pulseaudio-dlna dalla riga di comando con le seguenti opzioni:

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

Vedi anche pulseaudio-dlna "Informazioni" per ulteriori informazioni.

Quando era presente un renderer DLNA, possiamo selezionarlo dal menu audio come sink di output:

Pavucontrol è l'elemento mancante in questo puzzle! Avevo anche impostato tutto correttamente e il dispositivo esterno (LG TV) stava mostrando che il suono veniva riprodotto ma non ho sentito alcun suono. Oggi ho installato pavucontrol e quando l'ho aperto ho trovato l'opzione per canalizzare l'audio attraverso il server DLNA. L'opzione DLNA viene mostrata solo quando c'è un suono emesso da un lettore a pulseaudio.

Mi dispiace di non poterti aiutare affatto con Rygel, ma potrebbe esserci un'alternativa che potrebbe funzionare per te.

Il principio è ottenere un programma per registrare lo stream su un file audio, quindi avviare miniDLNA con una configurazione personalizzata che punti alla directory in cui si trova lo stream.

Esempio: supponiamo che stiamo lavorando in ~ / stream /. Crea ~ / 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

Quindi salva lo stream su un file audio in quella directory. Googling per "FFmpeg record audio card audio" ha dato questo comando

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

ma non ho avuto molta fortuna. Un'altra opzione è vlc se hai una GUI disponibile e questo non funziona.

Quindi avviare miniDLNA in un'altra finestra del terminale:

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

Si dovrebbe individuare OutputStream.flac e quindi accessibile dal proprio dispositivo di rete.

Spero che se non lo hai già risolto ti abbia dato alcune idee.

Un'idea che ho dovuto trasmettere in streaming "ciò che sento" su un renderer DLNA (come WDTV) era quella di server il flusso con VLC come flusso http con pulse://alsa_output.xxx.monitorcome input e transcodificarlo in MP3 o FLAC. Quindi volevo usare un punto di controllo DLNA per consentire al renderer di riprodurre questo flusso. VLC serve correttamente il flusso transcodificato, ma non consente di impostare il tipo mime, quindi il renderer rifiuta di riprodurlo.

L'idea successiva era quella di scrivere un server http in Python che serve invece lo stream. Ottiene il flusso audio dall'impulso con parec, lo codifica con flac( lameo qualunque cosa tu voglia) e imposta correttamente il tipo mime.

Funziona con il seguente (molto semplice) 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()

Regola i parametri, eseguilo e punta il renderer DLNA sul tuo computer. Ha funzionato per me con un WDTV come renderer e un telefono Android con BubbleUPnP come punto di controllo (puoi inserire l'URL dello stream quando aggiungi un nuovo elemento alla playlist manualmente). Ma dovrebbe funzionare con qualsiasi dispositivo conforme DLNA.

NOTA: questa soluzione funziona, ma una soluzione più nuova e probabilmente migliore è stata proposta da Massimo.

Ecco una risposta per Ubuntu 14.04 (anch'esso testato e funzionante il 15.04 ), per completezza:

1. installa tutti i pacchetti necessari: sudo apt-get install rygel rygel-preferences rygel-gst-launch

2. creare il file ~/.config/rygel.confche contiene quanto segue:

   [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. Esegui i seguenti comandi dalla riga di comando (questi possono essere inseriti in uno script se lo desideri):

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

4. Esegui il paprefscomando e assicurati che entrambe le opzioni DLNA siano abilitate (selezionate) nella scheda "Server di rete".

5. Riproduci dell'audio sul tuo computer. Eseguire il pavucontrolprogramma e, nella scheda "Riproduzione", modificare il dispositivo di output in "Streaming DLNA / UPnP".

A questo punto, dovresti essere in grado di riprodurre i flussi MPEG e FLAC da un client DLNA (renderer / punto di controllo).

NOTA: potrebbe essere necessario riavviare il computer (o riavviare il polso) affinché le cose inizino a funzionare.

Lo script Python di Adam è proprio quello di cui avevo bisogno. Brillante. Rygel con gst-launch non funziona con uno dei miei renderer, ma questo script funziona con entrambi. Nel mio caso sto prendendo un input di flusso audio da squeezelite (per squeezebox) e invio a un renderer. Lo script funziona anche nella forma originale per ricevere input da un monitor pulseaudio se è quello che serve.

Sapendo poco di tutto ciò, sono riuscito a fare alcune aggiunte allo script che:

i) consentire l'esecuzione da uno script di shell e terminare con un SIGTERM / SIGKILL (l'istruzione 'tranne' ora include 'systemexit')

ii) consente allo script di essere arrestato e riavviato e riutilizzare la stessa porta (poiché era lo script riavviato tendeva a fallire dicendo che non poteva aprire la porta se il renderer lo avesse ancora aperto) - (l'istruzione allow_reuse_address = True)

iii) creare una versione che prende input da stdin e lo ricampiona usando sox per l'output in formato wav (sulla porta 8082)

Quindi la mia versione è simile a:

#!/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()

Non sono sicuro se questo sarà utile per te ora, ma ho scritto un post su come farlo funzionare su Ubuntu 12.10:

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