Como configurar fluxos de áudio ao vivo em um dispositivo compatível com DLNA?

Existe uma maneira de transmitir a saída ao vivo da placa de som do nosso desktop 12.04.1 LTS amd64 para um dispositivo externo compatível com DLNA em nossa rede? Selecionar conteúdo de mídia em diretórios compartilhados usando Rygel, miniDLNA e uShare é sempre bom - mas até agora não conseguimos obter um fluxo de áudio ao vivo para um cliente via DLNA.

A Pulseaudio afirma ter um servidor de mídia DLNA / UPnP que, juntamente com a Rygel, deve fazer exatamente isso. Mas não conseguimos fazê-lo funcionar.

Seguimos as etapas descritas em live.gnome.org , esta resposta aqui e também em outro guia semelhante .

No 12.04 LTS , podemos selecionar o dispositivo de áudio local ou nosso fluxo GST-Launch no cliente DLNA, mas Rygel exibe a seguinte mensagem e o cliente declara que chegou ao final da lista de reprodução:

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

Não havia como ouvir fluxos de áudio ao vivo no cliente.

Somente após uma atualização de distribuição para 14.04 LTS , pudemos selecionar uma transmissão ao vivo em nossos renderizadores DLNA a partir das configurações bem descritas na resposta abaixo . Ainda assim, precisamos selecionar um fluxo estabelecido depois que começamos o rygel e não conseguimos enviar um novo fluxo aos nossos dispositivos UPnP. Os metadados de áudio não foram transmitidos.

Existem outras alternativas para enviar o áudio da nossa placa de som como transmissão ao vivo para um cliente DLNA?

Pulseaudio-DLNA

Criei um pequeno servidor que descobre todos os renderizadores upnp na sua rede e os adiciona como sumidouros ao pulseaudio. Assim, você pode controlar todos os aplicativos via pavucontrol para reproduzir em seus dispositivos upnp.

Esse é o tipo de conforto que eu sempre quis ao lidar com dispositivos upnp no linux.

O aplicativo pode ser instalado a partir da fonte ou do pacote DEB disponível para download no git , ou após adicionarmos o ppa: qos / pulseaudio-dlna oficial do projeto às nossas fontes com:

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

Em seguida, executamos o pulseaudio-dlna na linha de comando com as seguintes opções:

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

Veja também o pulseaudio-dlna "About" para mais.

Quando havia um renderizador DLNA presente, podemos selecioná-lo no menu de som como um coletor de saída:

Pavucontrol é o item que falta neste quebra-cabeça! Eu também havia configurado tudo corretamente e o dispositivo externo (LG TV) estava mostrando que o som estava sendo reproduzido, mas não ouvi nenhum som. Hoje instalei o pavucontrol e, quando o abri, encontrei a opção de canalizar o som através do servidor DLNA. A opção DLNA é mostrada apenas quando há saída de som de um player para o pulseaudio.

Sinto muito, mas não posso ajudá-lo com Rygel, mas pode haver uma alternativa que funcione para você.

O princípio é obter um programa para gravar o fluxo em um audiofile e iniciar o miniDLNA com uma configuração personalizada que aponte para o diretório em que o fluxo está.

Exemplo: digamos que estamos trabalhando em ~ / stream /. Crie ~ / 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

Em seguida, salve o fluxo em um audiofile nesse diretório. A pesquisa no Google "Áudio da placa de som de gravação FFmpeg" produziu este comando

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

mas não tive muita sorte com isso. Outra opção é vlc: você tem uma interface gráfica disponível e isso não funciona.

Em seguida, inicialize o miniDLNA em outra janela do terminal:

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

Ele deve localizar OutputStream.flac e, em seguida, ser acessível a partir do seu dispositivo de rede.

Espero que, se você ainda não o resolveu, isso lhe deu algumas idéias.

Uma idéia que tive que transmitir "o que ouvi" a um renderizador DLNA (como WDTV) foi o servidor de fluxo com VLC como fluxo http com pulse://alsa_output.xxx.monitorentrada e transcodificado para MP3 ou FLAC. Então eu queria usar algum ponto de controle DLNA para deixar o renderizador reproduzir o fluxo. O VLC atende ao fluxo transcodificado corretamente, mas não permite definir o tipo MIME; portanto, o renderizador se recusa a reproduzi-lo.

A próxima idéia foi escrever um servidor http em python que serve o fluxo. Ele recebe o fluxo de áudio do pulso parec, codifica-o flac( lameou o que você quiser) e define o tipo de mímica corretamente.

Funciona com o seguinte script (muito simples):

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

Ajuste os parâmetros, execute-o e aponte o renderizador DLNA para sua máquina. Funcionou para mim com um WDTV como renderizador e um telefone Android com BubbleUPnP como ponto de controle (você pode digitar o URL do fluxo ao adicionar um novo item à lista de reprodução manualmente). Mas deve funcionar com qualquer dispositivo compatível com DLNA.

NOTA: Esta solução funciona, mas uma solução mais nova e provavelmente melhor foi proposta pela Massimo.

Aqui está uma resposta para o Ubuntu 14.04 (também testado e funcionando no 15.04 ), para ser completo:

1. instale os pacotes necessários: sudo apt-get install rygel rygel-preferences rygel-gst-launch

2. crie o arquivo ~/.config/rygel.confque contém o seguinte:

   [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 os seguintes comandos na linha de comando (eles podem ser colocados em um script, se desejado):

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

4. Execute o paprefscomando e verifique se as duas opções de DLNA estão ativadas (marcadas) na guia "Servidor de rede".

5. Reproduza um pouco de áudio no seu computador. Execute o pavucontrolprograma e, na guia "Reprodução", altere o dispositivo de saída para "DLNA / UPnP Streaming".

Nesse ponto, você poderá reproduzir os fluxos MPEG e FLAC de um cliente DLNA (renderizador / ponto de controle).

NOTA: pode ser necessário reiniciar o computador (ou reiniciar o pulso) para que as coisas comecem a funcionar.

O script python de Adam é exatamente o que eu precisava. Brilhante. O Rygel com gst-launch não funciona com um dos meus renderizadores, mas esse script funciona com ambos. No meu caso, estou pegando uma entrada de fluxo de áudio do squeezelite (para squeezebox) e enviando para um renderizador. O script também funciona na forma original para receber informações de um monitor pulseaudio, se for necessário.

Sabendo pouco sobre isso, consegui fazer algumas adições ao script que:

i) permitir que seja executado a partir de um script shell e finalizado com um SIGTERM / SIGKILL (a instrução 'exceto' agora inclui 'systemexit')

ii) permite que o script seja parado e reiniciado e reutilize a mesma porta (como o script reiniciado tendia a falhar, dizendo que não seria possível abrir a porta se o renderizador ainda a abrisse) - (a instrução allow_reuse_address = True)

iii) crie uma versão que aceite a entrada do stdin e a faça uma nova amostragem usando sox para gerar no formato wav (na porta 8082)

Então, minha versão se parece com:

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

Não tenho certeza se isso será útil para você agora, mas escrevi um post sobre como fazer isso funcionar no Ubuntu 12.10:

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