eingebettete Videos lokal extrahieren
Videos auf Websites (Smartphone) › direkt auf Android TV / Fire TV öffnen – via Raspberry Pi
Ich betrachte auf meinem Smartphone Websites mit eingebetteten Videos. Aber ich spiele diese sofort bequem im Video-Spieler meines Smart-TVs ab. Ich kann diese auch sofort herunter laden. Hierzu nutze ich meinen Raspberry Pi, der je die tatsächliche Video-URL geschwind ermittelt und weiter reicht. Wie das geht, erkläre ich in diesem Beitrag.
Das Prinzip: Das Smartphone sendet über das lokale Heimnetzwerk die Website-URL (Adresse) an den Raspberry Pi. Dieser extrahiert die eigentliche Video-URL und schickt sie sofort weiter an den Smart-TV. Dort öffnet sich dann die lokale Video-Abspiel-Software und der Film beginnt.
Auf vielen Internetseiten sind Videos eingebettet. Man könnte diese Seiten natürlich im Browser auf dem Smart-TV öffnen. Aber das wäre viel zu umständlich. Ich nutze einfach die Teilen-Funktion im Browser auf dem Android-Smartphone bzw. -Tablet und sofort startet das tatsächliche Video im lokalen Video-Player (z. B. VLC) auf dem Smart-TV. Für meine Variante muss es sich dabei bei einem auf Android basierenden TV handeln. Ich selbst nutze einen (älteren) Fire-TV-Stick. Auch hier werkelt ja eigentlich ein Android im Hintergrund.
Für diese Technik gibt es bereits fertige (kostenpflichtige) Programme. Aber hier wird die Website-URL immer an einen externen Server von jemand anderem geschickt x. Die Antwort (Video-URL) dauert zum einen teils recht lange. Zum anderen erfährt der Anbieter natürlich stets von den eigenen Sehgewohnheiten.
x So funktionieren m. W. auch Browser-Addons, mittels denen man eingebettete Videos lokal auf das Gerät laden kann.
Ich habe mir (mit der Hilfe von KI) also einfach eine eigene kleine Server-Anwendung gebastelt, die auf dem Raspberry Pi läuft und auf Eingang lauscht. Außerdem benötigen wir noch eine „Teilen-App“ auf dem Smartphone und eine „Empfänger-App“ auf dem Android-Smart-TV.
➜ Meine Anleitung schreibe ich auf Basis meiner Unterlagen. Sie dient in erster Linie mir, falls ich dies später noch einmal nachbauen möchte. Evtl. Fehler darin sehen Sie mir bitte nach.
Vorbereitung
Zunächst muss der Raspberry Pi stets mit der selben IP-Adresse (statische IP-Adresse) im Heimnetz ansprechbar sein. So etwas richtet man im Router ein. Diese lokale IP-Adresse merken- bzw. notieren wir uns. Wir brauchen sie später noch.
Dann benötigen wir auf dem Smartphone eine App, die die jeweilige Website-Adresse (URL) via Teilen-Dialog an ein anderes Gerät im Heimnetz (an unseren Raspberry Pi) weiterreichen kann. Ich nutze unter Android die Open-Source-Software HTTP Shortcuts.
Und schließlich benötigen wir auf dem TV-Gerät eine App, die sogenannte „HTTP-Requests“ (von unserem Raspberry Pi) entegen nehmen– bzw. lauschen kann. Da auf meinem Fernseher (bzw. Fire TV Stick) Android läuft, habe ich dort die App Tasker installiert.
Tasker ist hierfür zum einen eigentlich völlig überdimensioniert. Aber ich habe keine andere kleine App gefunden, die solche HTTP-Requests entegen nehmen kann und die vom Betriebssystem nicht ständig beendet wird, wenn sie längere Zeit nicht genutzt wird. Zum anderen ist Tasker schwierig auf dem TV zu installieren (und kostet Geld). Ich habe es dennoch geschafft (siehe oberer Link).
Als Alternative käme ggf. Kodi für Android in Frage. Allerdings müsste dann Kodi permanent im Vordergrund laufen. Dafür beinhaltet diese App natürlich bereits einen Video-Player für URLs.
Außerdem ist es sehr empfehlenswert, wenn man sich ffmpeg auf dem Raspberry installiert (falls nicht schon vorhanden). Dies ist ein kleines Video-Konvertierungs-Tool (ohne Benutzeroberfläche). Auf dieses wird später ggf. (automatisch) zurück gegriffen, wenn man es mit gesplitteten Video-Stream-Dateien zu tun haben wird. Wir wollen am Ende ja nur eine einzige (komplette) Datei / URL zum Abspielen bzw. Downloaden haben.
Man muss in der Konsole des Raspberry hierfür nur eingeben:
sudo apt install ffmpeg
Danach muss man nicht mehr daran denken.
Die Server-Anwendung auf dem Raspberry Pi
Kommen wir als erstes zum Herzstück dieser Lösung. Ich gehe davon aus, dass man das typische „Setup“ auf dem Raspberry Pi besitzt: Standard-Raspberry-Pi-OS, der Nutzer heißt „pi“ und der Home-Ordner ebenso.
Als erstes stoßen wir das obligatorische Update und Upgrade an. Danach installieren wir Python3, eine virtuelle Python3-Umgebung (venv) und ffmpeg (falls nicht bereits vorhanden):
sudo apt update && sudo apt upgrade -y sudo apt install python3 python3-venv ffmpeg -y
Nun erstellen wir im Home-Ordner das Verzeichnis „video_offloader“ unserer Anwendung (und gleich ein Download-Verzeichnis für später):
mkdir -p /home/pi/video_offloader/downloads cd /home/pi/video_offloader
Wir wechseln dann also wieder in das Verzeichnis „video_offloader“.
Nun erstellen wir dort eine virtuelle Python-Umgebung („python venv“). Was soll das denn sein? Dies kann man sich vielleicht so vorstellen wie ein „portables“ Programmpaket unter Windows: Jegliche nötigen (Python-) Addons werden dort gespeichert bzw. gleich herunter geladen. Das „globale“ Python des Raspberry Pi OS bekommt davon nichts mit bzw. wird dadurch nicht beeinträchtigt (es würde sich sonst beschweren):
python3 -m venv venv source venv/bin/activate
Dass die Umgebung aktiv ist, erkennt man am Vorangestellten (venv) in der Terminal-Zeile. Wir befinden uns also gerade innerhalb dieser venv-Umgebung und sind dort völlig frei darin, einige nötige Abhängigkeiten zu installieren:
pip install --upgrade pip pip install Flask yt-dlp requests
Wir haben u. a. zwei wichtige Anwendungen innherhalb dieser Umgebung installiert: Flask – Dies ist ein winziger Webserver, der später auf die HTTP-Requests von der „Teilen-App“ lauschen wird.
Außerdem haben wir yt-dlp installiert – Dieses Programm ist dafür verantwortlich, die tatsächlichen Video-URLs aus Websites zu extrahieren. Vermutlich nutzen alle kommerziellen Lösungen ebenfalls dieses kleine Programm (auf ihren eigenen Servern).
Wir bleiben innerhalb der virtuellen Umgebung und legen das eigentliche Skript an:
nano app.py
Dort fügen wir nun diesen Code ein:
from flask import Flask, request, jsonify
import yt_dlp
import requests
import threading
app = Flask(__name__)
# ==========================================
# KONFIGURATION
# ==========================================
PORT = 5002
HOST = "0.0.0.0"
FIRE_TV_IP = "192.168.178.9"
TASKER_PORT = "1821"
DOWNLOAD_DIR = "/home/pi/video_offloader/downloads"
# ==========================================
# Gemeinsame yt-dlp Basis-Optionen
YDL_BASE_OPTS = {
'format': 'best[height<=720]/best',
'format_sort': ['res:720', 'ext:mp4:m4a'],
'merge_output_format': 'mp4', # Gewährleistet, dass das Endergebnis immer eine MP4 ist
'noplaylist': True,
'quiet': True,
'no_warnings': True,
}
def bg_download(url, opts):
"""Diese Funktion läuft isoliert im Hintergrund"""
try:
with yt_dlp.YoutubeDL(opts) as ydl:
ydl.download([url])
except Exception as e:
print(f"Fehler beim Hintergrund-Download: {str(e)}")
@app.route('/cast_yt-dlp', methods=['POST'])
def cast_video():
data = request.get_json()
if not data or 'url' not in data:
return jsonify({"error": "Keine URL gefunden"}), 400
original_url = data['url']
try:
with yt_dlp.YoutubeDL(YDL_BASE_OPTS) as ydl:
info = ydl.extract_info(original_url, download=False)
video_url = info.get('url')
if video_url:
target_url = f"http://{FIRE_TV_IP}:{TASKER_PORT}/play_vlc?{video_url}"
response = requests.get(target_url)
return jsonify({
"status": "success",
"extracted_url": video_url,
"target_response": response.status_code
}), 200
else:
return jsonify({"error": "Konnte keinen Videolink extrahieren"}), 500
except Exception as e:
return jsonify({"error": str(e)}), 500
@app.route('/download', methods=['POST'])
def download_video():
data = request.get_json()
if not data or 'url' not in data:
return jsonify({"error": "Keine URL gefunden"}), 400
original_url = data['url']
ydl_opts = YDL_BASE_OPTS.copy()
ydl_opts['outtmpl'] = f"{DOWNLOAD_DIR}/%(title)s.%(ext)s"
# Thread starten, damit Flask sofort antworten kann
thread = threading.Thread(target=bg_download, args=(original_url, ydl_opts))
thread.start()
return jsonify({
"status": "pending",
"message": "Download im Hintergrund gestartet."
}), 202 # 202 steht für "Accepted" (Akzeptiert, wird verarbeitet)
if __name__ == '__main__':
app.run(host=HOST, port=PORT)Beachten Sie die tatsächliche (statische) IP-Adresse Ihres SmartTVs (bzw. in meinem Fall des Fire-TV-Sticks). Die beiden Port-Angaben können beibehalten werden (es sei denn, sie werden durch andere Software bereits bespielt). Außerdem kann der Speicherpfad auf dem Raspberry angegeben / geändert werden (für die reine Download-Funktionalität). Der entsprechende Ordner muss natürlich existieren und beschreibbar sein.
Mittels STRG + S speichern wir das Skript. Mittels STRG + X verlassen wir den Editor.
Wir befinden uns immer noch in der Venv-Umgebung. Dort starten wir unseren kleinen Server erst einmal manuell (später per Dienst):
python3 app.py
Unsere Anwendung auf dem Raspberry Pi sollte nun (ohne Fehlermeldung im Terminal) auf einen Befehl lauschen. Aber woher soll dieser Befehl kommen? Hierzu nutze ich die oben erwähnte App HTTP Shortcuts auf meinem Android-Tablet:
Die Sender-Anwendung auf Android
Beachten Sie dieses Bildschirmfoto von meinem Android-Tablet:
Hier nutze ich die Teilen-Funktion von HTTP-Shortcuts: Ich teile also im Browser auf meinem Smartphone die URL (Adresse) einer Website, auf der ein Video eingebettet ist. Man kann diese Adresse, wie man sieht, auch noch an diverse andere Dienste oder Websites weiterreichen. In diesem Fall ist jedoch unsere „Lauscher-Anwendung“ auf dem Raspberry Pi relevant.
Unter ›HTTP Shortcuts‹ erstelle ich nun eine Variable und einen Befehl:
Variable erstellen
Zunächst müssen wir eine neue Variable erstellen:
Name: url_ohne_titel
Wert: leer lassen
Teilen erlauben: ja, angehakt
Art der geteilten Daten: Nur Text
Alle anderen Optionen können so beibehalten bleiben.
Shortcut „Senden“ erstellen
Nun erstellen wir einen Shortcut, mittels dem wir später die Website-URL via Teilen-Menü an den Raspberry (bzw. an unsere Python-Anwendung) weiterreichen können.
➜ Hinweis: Wir müssen jetzt die konkrete bzw. feste IP-Adresse des Raspberry in unserem Heimnetzwerk kennen, s. o.
Typ: Von Grund auf erstellen
Name: z. B. „Website-URL › Raspberry › Video-URL › SmartTV “
Allgemeine Einstellungen
Methode: POST
URL: http://IP-des-Raspberry:5002/cast_yt-dlp
Request-Header
Content-Type: application/json
Request-Body
Request-Body-Typ: Benutzerdefinierter Text
Content-Type: application/json
Request-Body:
{
"url": "{url_ohne_titel}"
}„{url_ohne_titel}“ ist hier unsere eben angelegte Variable und müsste ggf. mittels Button oder Dropdown oder ähnlich eingefügt werden (nicht eintippen).
Response-Einstellungen
Bei Erfolg: Response anzeigen
Bei Fehler: Vereinfachte Fehlermeldung anzeigen
Anzeige-Typ: Toast-Popup
Shortcut „Download“ erstellen
Unsere kleine Python-Anwendung auf dem Raspberry Pi kann ja Videos auch direkt (auf den Raspberry) herunter laden. Daher erstellen wir noch einen zweiten Shortcut:
Typ: Von Grund auf erstellen
Name: z. B. „Website-URL › Raspberry › Video-Download“
Allgemeine Einstellungen
Methode: POST
URL: http://IP-des-Raspberry:5002/download
Request-Header
Content-Type: application/json
Request-Body
Request-Body-Typ: Benutzerdefinierter Text
Content-Type: application/json
Request-Body:
{
"url": "{url_ohne_titel}"
}Response-Einstellungen
Bei Erfolg: Response anzeigen
Bei Fehler: Vereinfachte Fehlermeldung anzeigen
Anzeige-Typ: Toast-Popup
Dieser Shortcut ist fast identisch mit dem ersten. Insbesondere jedoch der HTTP-Befehl („/download“) ist ein anderer. Dadurch weiß das Python-Skript, was es machen soll. Wir können den ersten Shortcut einfach duplizieren bzw. entsprechend ändern.
Video-Download-Funktion testen
Ohne den Smart-TV angeschaltet zu haben, können wir zunächst einmal testen, ob unsere Python-Anwendung auf dem Raspberry funktioniert, indem wir ein Video direkt auf den Raspberry Pi herunter laden.
Im Terminal befinden wir uns ja immer noch in der Venv-Umgebung bzw. hatten dort die Anwendung manuell gestartet (s. o.). Dieser Dienst lauscht also. Sicherlich sollten wir auch ›ffmpeg‹ installiert haben (s. o.). Das schadet nicht, ist nicht groß und frisst kein Brot.
➜ Natürlich müssen sich das Smartphone / Tablet bzw. der Raspberry Pi im selben Heimnetzwerk („WLAN“) befinden.
Auf dem Android-Gerät (Smartphone, Tablet) rufen wir eine Website auf, auf der ein Video eingebettet ist. Nehmen wir zum Test einfach Youtube.
Wir gehen im Android-Browser also auf das Teilen-Menü und wählen hier das blaue Icon von HTP Shortcuts. Daraufhin sollte ein Popup erscheinen mit unseren beiden Shortcuts. Wir wählen nun den Download-Shortcut.
Es sollte ein kleines Popup (Toast-Nachricht) mit „… pending“ unten auf dem Bildschirm erscheinen. Nun schauen wir in den (im Skript definierten) Download-Ordner auf dem Raspberry Pi: Dort sollte nun eine neue Datei angelegt sein, deren Größe sich erhöht, bis der Download abgeschlossen ist.
Ich greife via Samba von meinem Windows-Computer oder vom Smartphone direkt auf den Raspberry zu – also via Datei-Explorer. Auch auf meinem Android-Smart-TV (bzw. Fire TV Stick) habe ich so einen netzwerkfähigen Dateibrowser (MixPlorer) installiert. Somit kann ich sofort auf diese Datei zugreifen bzw. das Video abspielen.
Die Raspberry-Anwendung als Dienst starten lassen
Derzeit läuft unser kleiner Video-Offloader-Server auf dem Raspberry Pi ja noch manuell: Wir befinden uns via Terminal noch in der venv-Umgebung. Diese verlassen wir nun bzw. stoppen die Anwendung:
Wir geben dort deactivate ein, gefolgt von Enter.
Selbstverständlich sollte unser Video-Offloader-Server automatisch beim Systemstart aktiviert sein. Hierfür tragen wir nun einen Dienst ein:
Service-Datei anlegen
Wir erstellen eine neue Konfigurationsdatei im systemd-Verzeichnis. Wir nennen den Dienst „video_offloader.service“:
sudo nano /etc/systemd/system/video_offloader.service
Konfiguration einfügen
Wir fügen folgende Konfiguration ein:
[Unit] Description=Video Offloader Flask Application After=network.target [Service] Type=simple User=pi WorkingDirectory=/home/pi/video_offloader ExecStart=/home/pi/video_offloader/venv/bin/python3 app.py Restart=always RestartSec=5 [Install] WantedBy=multi-user.target
Beachten Sie Nutzer und Pfade – Falls dies bei Ihnen anders sein sollte.
Wir speichern diese Datei mit STRG + S und verlassen den nano-Editor mit STRG + X
Systemd-Manager neu laden
Wir laden nun den Dienste-Hintergrundprozess neu:
sudo systemctl daemon-reload
Dienst aktivieren und starten
Nun aktivieren wir unseren neuen Dienst und starten ihn gleich im Anschluss:
sudo systemctl enable video_offloader.service sudo systemctl start video_offloader.service
Status prüfen
Läuft der neue Dienst korrekt? Dies prüfen wir mit:
sudo systemctl status video_offloader.service
Dort sollte alles im grünen Bereich sein. Idealerweise startet man den Raspberry Pi nun neu und veranlasst danach (etwas warten) via Android bzw. HTTP Shortcuts erneut einen Video-Download. Erscheint diese Datei dann im Download-Ordner auf dem Raspberry Pi, funktioniert unser Dienst bzw. der Video-Offloader.
Die Empfänger-Anwendung auf dem Smart-TV
Der primäre Sinn der Anwendung auf dem Raspberry Pi besteht natürlich im sofortigen Abspielen eines auf einer Website eingebetteten Videos direkt auf dem Smart-TV. Auf diesem sollte man zunächst eine ordentliche Video-Player-App installiert haben – Ich nutze VLC for Android.
Noch einmal das grobe Prinzip
Aber VLC auf dem Android-TV kann leider nicht auf HTTP-Anfragen lauschen. Daher benötigen wir auf dem Fernseher (bzw. auf dem Fire TV Stick) eine weitere Anwendung, die dies kann und die erhaltene Video-URL (vom Raspberry) an z. B. VLC weiter geben kann.
Vielleicht gibt es hierfür irgendwo da draußen einen leichtgewichtigen Server, der auch nicht gleich vom Android auf dem TV / dem Fire TV Stick beendet wird.
Als Alternative zu Tasker (und VLC) auf dem Smart-TV wäre – wie schon erwähnt – Kodi zu nennen: Kodi ist zum einen natürlich ein Videospieler und gleichzeitig kann Kodi auch auf HTTP-Eingänge horchen. Allerdings muss dieses Mediencenter dann permanent im Vordergrund laufen.
Ich hatte aber keine entsprechend leichtgewichtige Hintergrund-App gefunden. Wie oben bereits erwähnt, bin ich ein großer Freund der App Tasker und beschreibe hier meine Einrichtung mit dieser Anwendung.
Unter Tasker muss als erstes ein Task eingerichtet werden:
Task anlegen
Name: z. B. „HTTP-Datei abspielen“
Aktionen darin:
- HTTP-Antwort
Anforderungs-ID: %http_request_id
Statuscode: 200
Typ: Text - Variable Aufteilen
Name: %http_request_path
Teiler: /play_vlc? - Sende Intend
Aktion: android.intent.action.VIEW
Typ: Default
MIME Typ: video/*
Daten: %http_request_path2
Paket: org.videolan.vlc
Ziel: Activity
Wenn man VLC nicht installiert hat, müsste man „Paket“ nicht ausfüllen. Android auf dem TV wird dann vermutlich fragen, mit welcher Anwendung die eintreffende Video-URL geöffnet werden soll.
Diesen Task speichern wir erst einmal. Nun benötigen wir noch das Lauscher-Profil, welches die Video-URL vom Raspberry entgegen nehmen- und diesen Task auslösen wird:
Profil anlegen
Name: z. B. „URL via HTTP übermittelt › VLC“
Ereignis: HTTP-Anfrage
darin:
Port: 1821
Methode: GET
Pfad: /play_vlc?
Timeout: 10 Sekunden
Als Aktion für dieses Profil wählt man natürlich den zuvor angelegten Task aus.
Wer keinen Dunst von Tasker hat, sollte sich ggf. zunächst die Anleitung für Tasker-Einsteiger auf meinem anderen Blog durchlesen. Diese App ist ziemlich „mächtig“, aber eben auch kompliziert.
Nachdem man also den Task und das Profil angelegt hat, verlässt man Tasker via mehrmaligem Drücken der Zurück-Taste auf der Fernbedienung. Zudem sollte man ggf. die s. g. ADB-Befehle ausführen, damit das TV-Android Tasker im Hintergrund nicht beendet und damit dieses Programm nötige Rechte erhält. Denn wir benötigen diesen Dienst ja als permanenten Lauscher auf dem Fernseher – auch wenn eine andere App im Vordergrund ist.
Hinweis: Nach dem Hochfahren des Smart-TV / FireTV-Sticks wird es eine gewisse Zeit dauern, bis Tasker im Hintergrund automatisch gestartet ist.
Fazit
Ich weiß: Insbesondere das Durchreichen einer konkreten Video-URL an die Medien-App (VLC) auf dem TV ist via Tasker recht kompliziert. Steht alles, ist es jedoch eine Freude: Man ist nicht mehr von fragwürdigen, kommerziellen Apps abhängig und kein dritter Dienst erfährt, welche Video-URLs man hierbei aufruft. Zudem startet VLC auf dem TV mit der exakten Video-Adresse innerhalb von ca. zwei Sekunden.
Kern ist hierbei das Programm yt-dlp, welches wir via venv-Umgebung auf dem Raspberry lokal betreiben. Wir senden die Website-URL also nicht an eine entfernte yt-dlp-Instanz (oder eine ähnliche Software) auf einen Fremdserver.
Dass wir ein Video auch noch lokal auf dem Raspberry (z. B. auf einen dort eingesteckten USB-Stick) speichern können, ist eine nette zusätzliche Funktion und man kann sich somit sehr bequem via Teilen-Menü und einem Fingertipp auf dem Smartphone eine kleine, lokale Videosammlung anlegen (ich glaube, Musik ginge auch).
Tipp: yt-dlp funktioniert übrigens häufig auch mit Live-TV-Seiten und ich glaube, auch mit Musik. Probieren Sie es aus.
Allerdings funktioniert yt-dlp nicht korrekt mit allen Websites. Kern ist dieser Bereich des Codes unserer app.py:
# Gemeinsame yt-dlp Basis-Optionen
YDL_BASE_OPTS = {
'format': 'best[height<=720]/best',
'format_sort': ['res:720', 'ext:mp4:m4a'],
'merge_output_format': 'mp4',
'noplaylist': True,
'quiet': True,
'no_warnings': True,
}Ggf. müsste man diese Optionen anpassen (KI fragen), den Dienst neustarten (sudo systemctl restart video_offloader.service) und das Abspielen erneut versuchen. Außerdem sollte man prüfen, ob die Empfänger-App auf dem TV noch läuft (und nicht beendet wurde).
yt-dlp updaten
Noch etwas: Da sich die Video-Einbettungs-Techniken diverser Websites stets ändern können, wäre es wichtig, dass man yt-dlp innerhalb der venv-Umgebung auf dem Raspberry Pi regelmäßig aktualisiert.
Ich führe daher via Cronjob auf meinem Raspberry Pi automatisch nachts einmal pro Woche diesen Befehl aus:
/home/pi/video_offloader/venv/bin/pip install --upgrade yt-dlp
Falls man einen anderen Installationsordner nutzt, müsste man den Pfad zu ›pip‹ natürlich anpassen.