Freebox Player (Revolution / V6)

• Je crée un serveur HTTP avec VLC, qui sert http://mon_ip/stream
• J'appelle setAVTransportURI avec cette URI en argument (avec le framework Coherence via Python, ou même "à la main" avec uPNPInspector de gupnp-tools)

Le contenu est refusé.

Si l'adresse contient une extension "reconnue" par le Player, comme .ogg ou .ts le contenu est accepté quand bien même il ne correspond absolument pas à l'extension en question. Pour moi ça ressemble à une whitelist d'extensions. Pour servir du OGG par http c'est pas vraiment un problème, par contre pour du RTSP c'est bizarre de coller un .ts à l'URL du flux de contrôle SDP.

Je n'ai pas cherché du côté des méta-données. J'essaierai de voir si fournir ces informations permet de débrayer la vérification de l'extension de l'url.

Pour référence, voilà le script Python que j'utilise (J'ai un équivalent pour RTSP, mais il est plus compliqué donc moins minimal).

#!/usr/bin/env python

from __future__ import print_function

import subprocess, itertools, operator
import twisted.internet, coherence.base, socket


C_MediaRenderer = "urn:schemas-upnp-org:device:MediaRenderer:1"
C_DeviceName    = "Freebox Player"
C_StreamURL     = ":8081/stream.ogg"
C_Transcode     = "acodec=vorbis,ab=320,channels=2," \
                  "samplerate=44100"


class Controller(object):
    def __init__(self, reactor):
        reactor.addSystemEventTrigger('before', 'shutdown', self.stop)
        reactor.callWhenRunning(self.start)
        self.coherence = None
        self.device = None
        self.vlc = None
        reactor.run()

    def start(self):
        if self.coherence:
            return
        self.coherence = coherence.base.Coherence({
                'logmode': 'warning',
                'controlpoint': 'yes'})
        self.coherence.connect(self.found,
                'Coherence.UPnP.Device.detection_completed')

    def stop(self):
        if self.vlc:
            self.vlc.terminate()
        if self.device:
            self.device.client.av_transport.stop()

    @property
    def default_source(self):
        try:
            line = next(itertools.ifilter(
                    operator.methodcaller("startswith", "Default Sink"),
                    subprocess.check_output(["pactl", "info"]).split("\n")
                ))
            _, sink = line.split(":", 1)
        except (StopIteration, ValueError):
            return ""
        return sink.strip() + ".monitor"

    @staticmethod
    def find_ip_facing(dest_url):
        try:
            _, url = dest_url.split("://", 1)
        except ValueError:
            url = dest_url
        try:
            host, port = url.rsplit(":", 1)
        except ValueError:
            host, port = url, 80
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect((host, int(port)))
        return s.getsockname()[0]

    def found(self, device):
        if not (device.device_type == C_MediaRenderer
                and device.friendly_name == C_DeviceName
                and device.client):
            return

        if not self.vlc:
            self.vlc = subprocess.Popen([
                    "cvlc", "-vvv",
                    "pulse://{}".format(self.default_source),
                    ":sout=#transcode{{{}}}"
                    ":std{{access=http,mux=ogg,dst={}}}".format(
                        C_Transcode, C_StreamURL),
                ])

        if self.device:
            return
        self.device = device

        my_ip = self.find_ip_facing(device.urlbase)
        device.client.av_transport.set_av_transport_uri(0,
                "http://{}{}".format(my_ip, C_StreamURL))


Controller(twisted.internet.reactor)