tiny-dlna 0.5.2__tar.gz → 0.7.0__tar.gz

{tiny-dlna-0.5.2 → tiny-dlna-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tiny-dlna
-Version: 0.5.2
+Version: 0.7.0
 Summary: a tiny DLNA receiver
 Home-page: https://github.com/mitnk/tiny-dlna
 Author: mitnk
@@ -31,3 +31,15 @@ from apps like 虎牙直播, Bilibili, and other video platforms. Additionally,
 can also use `nano-dlna` to play local videos (like in your RaspberryPi) on it.
 
 Note: mpv needs to be installed on your system.
+
+::
+
+    $ tiny-cli list
+
+List available DLNA devices.
+
+::
+
+    $ tiny-cli play ~/Movies/foo/bar.mp4 -q 'TV'
+
+Play video on the DLNA device having "TV" in its name.

{tiny-dlna-0.5.2 → tiny-dlna-0.7.0}/README.md

@@ -19,7 +19,7 @@ from apps like 虎牙直播, Bilibili, and other video platforms. Additionally,
 can also use `nano-dlna` to play local videos (like in your RaspberryPi) on it.
 
 Note that [mpv](https://mpv.io/) needs to be installed on your system. On Mac,
-do following:
+do following (for Windows, add the mpv's root into PATH):
 
 ```
 $ ln -sf /Applications/mpv.app/Contents/MacOS/mpv /usr/local/bin/
@@ -32,6 +32,26 @@ List available DLNA devices:
 $ tiny-cli list
 ```
 
+Play a local video file on a DLNA device having "TV" in its name:
+```
+$ tiny-cli play ~/Movies/foo/bar.mp4 -q TV
+```
+
+If there is a `bar.srt` in the same directory, it will be served as long as
+the DLNA device supports subtitles.
+
+## Dev
+
+```
+$ python -m tiny_dlna.tiny_cli -h
+$ python -m tiny_dlna.tiny_render -h
+```
+
+### More DLNA Actions, like Seek/Pause?
+
+This repository will be kept minimal. For additional DLNA actions, consider
+forking it.
+
 ## Related projects
 
 - https://github.com/xfangfang/Macast

{tiny-dlna-0.5.2 → tiny-dlna-0.7.0}/setup.py

@@ -24,22 +24,35 @@ from apps like 虎牙直播, Bilibili, and other video platforms. Additionally,
 can also use `nano-dlna` to play local videos (like in your RaspberryPi) on it.
 
 Note: mpv needs to be installed on your system.
+
+::
+
+    $ tiny-cli list
+
+List available DLNA devices.
+
+::
+
+    $ tiny-cli play ~/Movies/foo/bar.mp4 -q 'TV'
+
+Play video on the DLNA device having "TV" in its name.
 """
 
 setup(
     name='tiny-dlna',
-    version='0.5.2',
+    version='0.7.0',
     description='a tiny DLNA receiver',
     long_description=DESC,
     url='https://github.com/mitnk/tiny-dlna',
     author='mitnk',
     license='MIT',
     keywords='dlna',
-    py_modules=["tiny_cli", "tiny_render", "tiny_ssdp"],
+    packages=['tiny_dlna'],
+    package_dir={'tiny_dlna': 'tiny_dlna'},
     entry_points={
         'console_scripts': [
-            'tiny-render=tiny_render:main',
-            'tiny-cli=tiny_cli:main',
+            'tiny-render=tiny_dlna.tiny_render:main',
+            'tiny-cli=tiny_dlna.tiny_cli:main',
         ],
     },
     install_requires=[

tiny-dlna-0.7.0/tiny_dlna/tiny_cli.py

@@ -0,0 +1,288 @@
+import argparse
+import json
+import logging
+import os.path
+import random
+import shutil
+import signal
+import socket
+import threading
+import time
+import urllib.parse
+import urllib.request as urlreq
+import xml.etree.ElementTree as ET
+
+from flask import Flask, send_from_directory
+from xml.sax.saxutils import escape as xmlescape
+from .tiny_ssdp import SSDP_MULTICAST_IP, SSDP_PORT, get_host_ip
+from .tiny_xmls import *  # NOQA
+
+logger = logging.getLogger('tiny_cli')
+
+MSEARCH_MSG = (
+    'M-SEARCH * HTTP/1.1\r\n'
+    f'HOST: {SSDP_MULTICAST_IP}:{SSDP_PORT}\r\n'
+    'MAN: "ssdp:discover"\r\n'
+    'MX: 1\r\n'
+    'ST: urn:schemas-upnp-org:service:AVTransport:1\r\n'
+    '\r\n'
+)
+DIR_LINKS = '~/.config/tiny-dlna/symlinks'
+
+
+def _get_device_info(location):
+    p = urllib.parse.urlparse(location)
+
+    attrs = {}
+    namespace = {'ns': 'urn:schemas-upnp-org:device-1-0'}
+    namespaces = {
+        '': 'urn:schemas-upnp-org:device-1-0',
+        'dlna': 'urn:schemas-dlna-org:device-1-0'
+    }
+
+    with urlreq.urlopen(location, timeout=1.0) as r:
+        xml = r.read()
+        root = ET.fromstring(xml.strip())
+
+        friendly_name = root.find('.//ns:friendlyName', namespace).text
+        if friendly_name:
+            attrs['friendly_name'] = friendly_name
+
+        elem = root.find(
+            ".//service[serviceId='urn:upnp-org:serviceId:AVTransport']",
+            namespaces=namespaces,
+        )
+        if elem:
+            control_url = elem.find('controlURL', namespaces).text
+            if control_url:
+                attrs['control_url'] = f'http://{p.hostname}:{p.port}/{control_url}'
+
+    return attrs
+
+
+def _parse_ssdp_response(resp):
+    lines = resp.split('\r\n')
+    device = {}
+
+    if not lines[0].endswith('200 OK'):
+        return None
+
+    for line in lines:
+        try:
+            k, v = [x.strip() for x in line.split(':', 1)]
+        except ValueError:
+            continue
+
+        k = k.lower()
+        if k == 'location':
+            device['location'] = v
+        elif k == 'usn':
+            device['usn'] = v
+        elif k == 'st':
+            device['st'] = v
+
+    if ':service:AVTransport:' not in device.get('st', ''):
+        return None
+
+    attrs = _get_device_info(device['location'])
+    device.update(attrs)
+    return device
+
+
+def get_dlna_devices():
+    # Create the UDP socket
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
+    sock.settimeout(1.2)
+
+    # Send the M-SEARCH message to the SSDP multicast address
+    logger.debug("Sending M-SEARCH...")
+    sock.sendto(MSEARCH_MSG.encode('utf-8'), (SSDP_MULTICAST_IP, SSDP_PORT))
+
+    devices = []
+    known_locations = set()
+    while True:
+        try:
+            data, addr = sock.recvfrom(1024)
+            device = _parse_ssdp_response(data.decode('utf-8'))
+            location = device.get('location')
+            logger.debug(f'got reply from {addr}, Location: {location}')
+            if device and location not in known_locations:
+                devices.append(device)
+                known_locations.add(location)
+        except socket.timeout:
+            break
+
+    return devices
+
+
+def list_dlna_devices():
+    devices = get_dlna_devices()
+    print(json.dumps({'devices': devices}, sort_keys=True, indent=2))
+
+
+def post(url, action_data, headers):
+    action_data = action_data.encode("utf-8")
+    r = urlreq.Request(url, action_data, headers)
+    urlreq.urlopen(r)
+    logging.debug("Request sent")
+
+
+app = Flask(__name__)
+
+
+@app.route('/videos/<name_video>')
+def serve_video(name_video):
+    dir_base = os.path.expanduser(DIR_LINKS)
+    return send_from_directory(dir_base, name_video)
+
+
+def run_flask_server(port):
+    app.run(host='0.0.0.0', port=port)
+
+
+def send_dlna_command(url_control, action_body, action_name):
+    st = "urn:schemas-upnp-org:service:AVTransport:1"
+    headers = {
+        'Content-Type': 'text/xml; charset="utf-8"',
+        'SOAPACTION': f'"{st}#{action_name}"',
+        "Connection": "close",
+    }
+    post(url_control, action_body, headers)
+
+
+def send_set_av_transport(url_control, url_video, url_srt=None):
+    title = url_video.split('/')[-1]
+    meta_items = XML_VIDEO.format(title=title)
+    if url_srt:
+        meta_items += XML_SUBTITLE.format(url_srt=url_srt)
+    metadata = XML_META.format(items=meta_items)
+    xml = XML_SETAV.format(
+        url_video=url_video,
+        metadata=xmlescape(metadata),
+    )
+    send_dlna_command(url_control, xml, 'SetAVTransportURI')
+
+
+def send_play(url_control):
+    send_dlna_command(url_control, XML_PLAY, 'Play')
+
+
+def send_stop(url_control):
+    dir_links = os.path.expanduser(DIR_LINKS)
+    try:
+        shutil.rmtree(dir_links)
+    except:  # NOQA
+        pass
+    send_dlna_command(url_control, XML_STOP, 'Stop')
+
+
+def create_link(path_file):
+    name_file = os.path.basename(path_file)
+    dir_links = os.path.expanduser(DIR_LINKS)
+    if not os.path.exists(dir_links):
+        os.makedirs(dir_links, exist_ok=True)
+
+    path_link = os.path.join(dir_links, name_file)
+    if os.path.exists(path_link):
+        if os.path.islink(path_link):
+            os.remove(path_link)
+        else:
+            logger.error('failed to create softlink')
+            exit(1)
+
+    os.symlink(path_file, path_link)
+    logger.info(f'created softlink: {path_link}')
+
+
+def get_control_url(args):
+    devices = get_dlna_devices()
+    for d in devices:
+        if args.query.lower() in d['friendly_name'].lower():
+            return d.get('control_url')
+
+
+def play_video(args):
+    path_video = args.video_file
+    if not os.path.isfile(path_video):
+        print(f'no such file: {path_video}')
+        exit(0)
+
+    url_control = get_control_url(args)
+    if not url_control:
+        print('no such DLNA device found')
+        exit(0)
+
+    ip = get_host_ip()
+    port = random.randint(50000, 58999)
+
+    logger.info(f'play video file: {path_video}')
+    create_link(path_video)
+    name_video = os.path.basename(path_video)
+    url_video = f"http://{ip}:{port}/videos/{name_video}"
+
+    path_srt = '.'.join(path_video.split('.')[:-1]) + '.srt'
+    if os.path.exists(path_srt):
+        create_link(path_srt)
+        name_srt = os.path.basename(path_srt)
+        url_srt = f"http://{ip}:{port}/videos/{name_srt}"
+    else:
+        path_srt = None
+        url_srt = None
+
+    server_thread = threading.Thread(target=run_flask_server, args=(port,))
+    server_thread.daemon = True
+    server_thread.start()
+
+    # Give some time for the server to start
+    time.sleep(1.6)
+
+    send_set_av_transport(url_control, url_video, url_srt)
+    send_play(url_control)
+
+    def signal_handler(sig, frame):
+        send_stop(url_control)
+        exit(0)
+    signal.signal(signal.SIGINT, signal_handler)
+
+    # Keep main thread running so the server stays up and we can catch signal
+    while True:
+        time.sleep(1)
+
+
+def main():
+    logging.basicConfig(
+        level=logging.ERROR,
+        format='[%(asctime)s][%(levelname)s] %(message)s',
+    )
+
+    parser = argparse.ArgumentParser(prog='tiny-cli')
+    subparsers = parser.add_subparsers(dest='command', required=True,
+                                       help='Choose a command')
+
+    greet_parser = subparsers.add_parser('list', help='List available DLNA devices')
+    greet_parser.add_argument('-v', dest='verbose', action='store_true',
+                              help='Enable verbose logs')
+
+    play_parser = subparsers.add_parser('play', help='Play via via DLNA device')
+    play_parser.add_argument('video_file')
+    play_parser.add_argument('-v', dest='verbose', action='store_true',
+                             help='Enable verbose logs')
+    play_parser.add_argument('-q', dest='query', type=str, required=True,
+                             help='Specify Device by Friendly Name')
+
+    args = parser.parse_args()
+    if args.verbose:
+        logger.setLevel(logging.DEBUG)
+
+    if args.command == 'list':
+        list_dlna_devices()
+    elif args.command == 'play':
+        if not args.verbose:
+            logging.getLogger('werkzeug').setLevel(logging.ERROR)
+        play_video(args)
+
+
+if __name__ == '__main__':
+    main()

{tiny-dlna-0.5.2 → tiny-dlna-0.7.0/tiny_dlna}/tiny_render.py

@@ -1,3 +1,4 @@
+import argparse
 import html
 import logging
 import re
@@ -7,89 +8,13 @@ import time
 import xml.etree.ElementTree as ET
 
 from flask import Flask, request, Response
-from tiny_ssdp import ssdp_listener, RENDER_PORT, UUID
+from .tiny_ssdp import get_uuid, ssdp_listener
+from .tiny_xmls import *  # NOQA
 
 app = Flask(__name__)
 logger = logging.getLogger('tiny_render')
 
 
-XML_DESC_PTN = """<?xml version="1.0" encoding="UTF-8"?>
-<root xmlns:dlna="urn:schemas-dlna-org:device-1-0" xmlns="urn:schemas-upnp-org:device-1-0">
-  <specVersion>
-    <major>1</major>
-    <minor>0</minor>
-  </specVersion>
-  <device>
-    <deviceType>urn:schemas-upnp-org:device:MediaRenderer:1</deviceType>
-    <friendlyName>{}</friendlyName>
-    <manufacturer>mitnk</manufacturer>
-    <modelName>Tiny-Render</modelName>
-    <modelDescription>AVTransport Media Renderer</modelDescription>
-    <UDN>uuid:{}</UDN>
-    <dlna:X_DLNADOC xmlns:dlna="urn:schemas-dlna-org:device-1-0">DMR-1.50</dlna:X_DLNADOC>
-      <serviceList>
-        <service>
-        <serviceType>urn:schemas-upnp-org:service:AVTransport:1</serviceType>
-        <serviceId>urn:upnp-org:serviceId:AVTransport</serviceId>
-        <SCPDURL>AVTransport/scpd.xml</SCPDURL>
-        <controlURL>AVTransport/control</controlURL>
-        <eventSubURL>AVTransport/event</eventSubURL>
-        </service>
-      </serviceList>
-  </device>
-</root>"""
-
-XML_AVSET_DONE = """
-<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
-  <s:Body>
-    <u:SetAVTransportURIResponse xmlns:u="urn:schemas-upnp-org:service:AVTransport:1"/>
-  </s:Body>
-</s:Envelope>
-"""
-
-XML_PLAY_DONE = """
-<s:Envelope s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
-  <s:Body>
-    <u:PlayResponse xmlns:u="urn:schemas-upnp-org:service:AVTransport:1"/>
-  </s:Body>
-</s:Envelope>
-"""
-
-XML_POSINFO = """
-<s:Envelope s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
-  <s:Body>
-    <u:GetPositionInfoResponse xmlns:u="urn:schemas-upnp-org:service:AVTransport:1">
-      <Track>0</Track>
-      <TrackDuration>00:00:00</TrackDuration>
-      <RelTime>{0}</RelTime>
-      <AbsTime>{0}</AbsTime>
-      <RelCount>2147483647</RelCount>
-      <AbsCount>2147483647</AbsCount>
-    </u:GetPositionInfoResponse>
-  </s:Body>
-</s:Envelope>
-"""
-
-XML_TRANSINFO = """
-<s:Envelope s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
-  <s:Body>
-    <u:GetTransportInfoResponse xmlns:u="urn:schemas-upnp-org:service:AVTransport:1">
-      <CurrentTransportState>PLAYING</CurrentTransportState>
-      <CurrentTransportStatus>OK</CurrentTransportStatus>
-      <CurrentSpeed>1</CurrentSpeed>
-    </u:GetTransportInfoResponse>
-  </s:Body>
-</s:Envelope>
-"""
-
-XML_STOP_DONE = """
-<s:Envelope s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
-  <s:Body>
-    <u:StopResponse xmlns:u="urn:schemas-upnp-org:service:AVTransport:1"/>
-  </s:Body>
-</s:Envelope>
-"""
-
 class MPVRenderer:
     def __init__(self):
         self.process = None
@@ -120,11 +45,33 @@ _DATA = {
     'STARTED_AT': 0,
 }
 
+
 @app.route('/description.xml')
 def description():
     friendly_name = app.config['FRIENDLY_NAME']
-    xml = XML_DESC_PTN.format(friendly_name, UUID)
-    return Response(xml, mimetype="text/xml")
+    uuid_str = get_uuid()
+    xml = XML_DESC_PTN.format(friendly_name, uuid_str)
+    resp = Response(xml, mimetype="text/xml")
+    resp.headers['Server'] = 'UPnP/1.0 Werkzeug/3.0 TinyRender/0.7'
+    return resp
+
+# these 3 dlna_ routings below are only here so that some dummy app
+# could treat our "tiny render" as a proper dlna device. (Mouyu ..)
+@app.route('/dlna/AVTransport.xml')
+def dlna_avtransport():
+    resp = Response(XML_DLNA_AVT, mimetype="text/xml")
+    return resp
+
+@app.route('/dlna/RenderingControl.xml')
+def dlna_render_control():
+    resp = Response(XML_DLNA_RENDER_CTRL, mimetype="text/xml")
+    return resp
+
+@app.route('/dlna/ConnectionManager.xml')
+def dlna_conn_manager():
+    resp = Response(XML_DLNA_CONN_MANAGER, mimetype="text/xml")
+    return resp
+
 
 def to_track_time(seconds):
     hours = seconds // 3600
@@ -132,12 +79,12 @@ def to_track_time(seconds):
     remaining_seconds = seconds % 60
     return f"{hours}:{minutes:02}:{remaining_seconds:02}"
 
-def is_stop(request):
-    return b'<u:Stop' in request.data
-
 def is_play(request):
     return b'<u:Play' in request.data
 
+def is_stop(request):
+    return b'<u:Stop' in request.data
+
 def is_setav(request):
     return b'SetAVTransportURI' in request.data
 
@@ -157,27 +104,35 @@ def get_title_re(xml_data):
         return match.group(1)
 
 def get_metadata(request):
-    root = ET.fromstring(request.data)
+    root = ET.fromstring(request.data.strip())
     current_uri = root.find('.//CurrentURI').text
     metadata = root.find('.//CurrentURIMetaData').text
+    if not metadata:
+        logger.debug('no metadata')
+        return {'video': current_uri, 'title': ''}
 
-    current_srt = ''
     title = ''
-
     metadata = html.unescape(metadata)
     try:
-        metadata = ET.fromstring(metadata)
+        # HACK: replace all `&` to `&amp;`
+        metadata = metadata.replace('&', '&amp;')
+        metadata = ET.fromstring(metadata.strip())
     except ET.ParseError:
         # HACK: fall back to `re` to get title only (e.g. Huya)
         logger.debug('** got xml.ParseError, fall back to re')
         title = get_title_re(metadata)
         return {'video': current_uri, 'title': title}
 
-    ns = {'dc': 'http://purl.org/dc/elements/1.1/'}
-    obj = metadata.find('.//dc:title', ns)
-    if obj:
+    ns = {
+        'dc': 'http://purl.org/dc/elements/1.1/',
+        '': 'urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/'
+    }
+    item = metadata.find('.//item', namespaces=ns)
+    obj = item.find('.//dc:title', namespaces=ns)
+    if obj is not None:
         title = obj.text
 
+    current_srt = ''
     for res in metadata.findall('.//{urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/}res'):
         if res.get('type') == 'text/subtitle':
             current_srt = res.text.strip()
@@ -186,7 +141,7 @@ def get_metadata(request):
     return {
         'video': current_uri,
         'srt': current_srt,
-        'title': current_srt,
+        'title': title,
     }
 
 
@@ -199,7 +154,7 @@ def control():
         video_title = metadata.get('title', '')
 
         logger.debug(f'Action: SetAV: {current_uri}')
-        logger.debug(f'SRT: {current_srt}')
+        logger.debug(f'Title: {video_title} SRT: {current_srt}')
         _DATA['CURRENT_URI'] = current_uri
         _DATA['CURRENT_SRT'] = current_srt
         _DATA['VIDEO_TITLE'] = video_title
@@ -211,11 +166,11 @@ def control():
         srt = _DATA['CURRENT_SRT']
         title = _DATA['VIDEO_TITLE']
         logger.debug(f'action: Play: {url}')
-        logger.debug(f'title: {title} srt: {srt}')
         renderer.play_media(url, title, srt)
         return Response(XML_PLAY_DONE, mimetype="text/xml")
 
     elif is_getpos(request):
+        # this is only a dummy impl; we need rpc to mpv process for real.
         logger.debug('action: GetPositionInfo')
         seconds = int(time.time() - _DATA['STARTED_AT'])
         reltime = to_track_time(seconds)
@@ -236,47 +191,50 @@ def control():
         return Response(XML_STOP_DONE, mimetype="text/xml")
 
     elif is_seek(request):
-        logger.debug('seek')
-        return Response('To Seek', status=500)
+        logger.debug('action:seek')
+        return Response(XML_SEEK_DONE, mimetype="text/xml")
 
     logger.error(f'action not support: {request.data}')
     return Response('Action Not Supported', status=500)
 
 
 class SSDPServer(threading.Thread):
+    def __init__(self, render_port):
+        super().__init__()
+        self.render_port = render_port
+
     def run(self):
-        ssdp_listener()
+        ssdp_listener(self.render_port)
 
 
 def main():
-    import argparse
-
     parser = argparse.ArgumentParser(prog='tiny-render')
-    parser.add_argument('--http-log', action='store_true', help='Enable server logs')
+    parser.add_argument('--http-logs', action='store_true', help='Enable server logs')
     parser.add_argument('--verbose', '-v', action='store_true', help='Enable debug logs')
     parser.add_argument('--name', type=str, default='Tiny Render', help='Change render name')
 
     args = parser.parse_args()
 
     logging.basicConfig(
-        level=logging.INFO,
+        level=logging.ERROR,
         format='[%(asctime)s][%(levelname)s] %(message)s',
     )
 
-    if not args.http_log:
+    if not args.http_logs:
         logging.getLogger('werkzeug').setLevel(logging.ERROR)
-        logging.getLogger('ssdp').setLevel(logging.ERROR)
+        logging.getLogger('tiny_ssdp').setLevel(logging.ERROR)
 
     if args.verbose:
-        logging.basicConfig(level=logging.DEBUG)
+        logger.setLevel(logging.DEBUG)
 
-    ssdp = SSDPServer()
+    port = 59876
+    ssdp = SSDPServer(port)
     ssdp.start()
 
     friendly_name = args.name
     app.config['FRIENDLY_NAME'] = friendly_name
     logging.info(f'Starting DLNA Receiver: {friendly_name}')
-    app.run(host="0.0.0.0", port=RENDER_PORT, debug=False)
+    app.run(host="0.0.0.0", port=port, debug=False)
 
 
 if __name__ == "__main__":