Feature 4769 - Add customer pipe handler to IPTV networks

Tachioma

Necroing an old feature request that had a fair few votes on it as a really liked / requested feature.

Allow the use pre and post commands to IPTV Muxes OR networks as a whole without having to alter the M3U line-by-line or individual MUX URLs.

E.g.

Current faffery required :
pipe:///usr/bin/ffmpeg -reconnect 1 -reconnect_at_eof 1 -reconnect_streamed 1 -reconnect_delay_max 2000 -probesize 1000k -analyzeduration 0 -fpsprobesize 0 -fflags -nobuffer -err_detect ignore_err -i https://someurl/somechannel/someUUID -codec copy -f mpegts -tune zerolatency pipe:1

PRE : /usr/bin/ffmpeg -reconnect 1 -reconnect_at_eof 1 -reconnect_streamed 1 -reconnect_delay_max 2000 -probesize 1000k -analyzeduration 0 -fpsprobesize 0 -fflags -nobuffer -err_detect ignore_err
URL : https://someurl/somechannel/someUUID
POST : -codec copy -f mpegts -tune zerolatency pipe:1

Simply, 3 fields that when combined create final the MUX.

Chris G

Why can't you do that already?
Fetch the m3u and add stuff before and after the URL?

Tachioma

Chris G
You're thinking about this wrong, you can't do that easily via the CLI or at all via UI.
You can create a network, that pulls an m3u from a source, on a schedule (quite feasible and many people do, from the UI) and that automagically creates multiple muxes.
However, there is no current way to manage or alter those mux URLs to include commands to pre and/or post to assist in playback without scripting or manually doing it to every mux. Hence why I made this : https://tvheadend.org/d/9048-script-to-update-iptv-muxes
Like I mentioned, it's an old request that had a lot of love.

Chris G

Take a look at my pluto script here: https://tvheadend.org/d/8936-pluto-tv-script
Or this xumo script I made:

#!/usr/bin/python
import requests
from datetime import datetime, timezone, timedelta
import uuid
import xml.etree.ElementTree as ET
import socket
import io
import os
import sys
import subprocess
import time
import re

# CONFIG #############################################################################################
SOCKET = "/config/epggrab/xmltv.sock"  # Path to your UNIX socket
USE_STREAMLINK = True  # Use Streamlink instead of FFmpeg
######################################################################################################


def stream(channel_id):
    broadcast = requests.get(
        f"https://android-tv-mds.xumo.com/v2/channels/channel/{channel_id}/broadcast.json?hour="
        + datetime.now(timezone.utc).strftime("%H")
    ).json()
    bid = broadcast["assets"][0]["id"]
    streams = requests.get(
        f"https://android-tv-mds.xumo.com/v2/assets/asset/{bid}.json?f=providers"
    ).json()
    for stream in streams["providers"]:
        for src in stream["sources"]:
            uri = src["uri"]
            uri = uri.replace("[PLATFORM]", "androidtv")
            uri = uri.replace("[APP_VERSION]", "androidtv")
            uri = uri.replace("[timestamp]", str(time.time()))
            uri = uri.replace("[app_bundle]", "com.xumo.xumo.tv")
            uri = uri.replace("[device_make]", "Amazon")
            uri = uri.replace("[device_model]", "AFTT")
            uri = uri.replace("[content_language]", "en")
            uri = uri.replace("[IS_LAT]", "0")
            uri = uri.replace("[IFA]", str(uuid.uuid4()))
            uri = re.sub(r"\[([^]]+)\]", "", uri)
            break
        break
    if USE_STREAMLINK:
        subprocess.run(["streamlink", uri, "best", "--stdout"], stdout=sys.stdout)
    else:
        subprocess.run(
            [
                "ffmpeg",
                "-hide_banner",
                "-loglevel",
                "error",
                "-i",
                uri,
                "-c",
                "copy",
                "-f",
                "mpegts",
                "-tune",
                "zerolatency",
                "pipe:1",
            ],
            stdout=sys.stdout,
        )


if len(sys.argv) > 1:
    stream(sys.argv[1])
else:
    data = requests.get(
        "https://android-tv-mds.xumo.com/v2/channels/list/10032.json?f=genreId&sort=hybrid&geoId=unknown"
    ).json()

    m3u = "#EXTM3U\n"
    live_channels = {}

    for i in data["channel"]["item"]:
        if (
            i["callsign"].endswith("-DRM")
            or i["callsign"].endswith("DRM-CMS")
            or i["properties"].get("is_live") != "true"
        ):
            continue
        live_channels[i["guid"]["value"]] = i["title"]
        m3u += f'#EXTINF:-1 tvg-id="{"xumo-" + i["guid"]["value"]}" tvg-chno="{i["number"]}" tvg-name="{i["title"]}" tvg-logo="https://image.xumo.com/v1/channels/channel/{str(i["guid"]["value"])}/512x512.png?type=color_onBlack",{i["title"]}\n'
        m3u += f'pipe://{os.path.abspath(__file__)} {str(i["guid"]["value"])}\n'

    root = ET.Element("tv")
    programmes = []

    days = [
        datetime.now(timezone.utc).strftime("%Y%m%d"),
        (datetime.now(timezone.utc) + timedelta(days=1)).strftime("%Y%m%d"),
    ]
    start_page = datetime.now(timezone.utc).hour // 6
    max_pages = 2
    grabbed_pages = 0

    for i, day in enumerate(days):
        if grabbed_pages == max_pages:
            break

        for page in range(start_page, 4) if i == 0 else range(4):
            offset = 0

            while True:
                # print(f"Grabbing day:{day} page:{page} offset:{offset}")
                data = requests.get(
                    f"https://android-tv-mds.xumo.com/v2/epg/10032/{day}/{page}.json?limit=50&offset={offset}&f=asset.title&f=asset.descriptions"
                ).json()

                if len(data["channels"]) == 0:
                    break

                offset += 50

                for channel in data["channels"]:
                    channel_id = str(channel["channelId"])
                    if channel_id not in live_channels:
                        continue

                    channel_element = ET.SubElement(
                        root, "channel", id="xumo-" + channel_id
                    )
                    ET.SubElement(channel_element, "display-name").text = live_channels[
                        channel_id
                    ]
                    ET.SubElement(channel_element, "channel-number").text = str(
                        channel["number"]
                    )

                    for programme in channel["schedule"]:
                        asset_id = programme["assetId"]
                        asset = data["assets"][asset_id]
                        descriptions = asset["descriptions"]
                        description = (
                            descriptions.get("large")
                            or descriptions.get("medium")
                            or descriptions.get("small")
                            or descriptions.get("tiny")
                            or ""
                        )

                        programmes.append(
                            {
                                "start": programme["start"],
                                "end": programme["end"],
                                "channel_id": channel_id,
                                "title": asset.get("title", "Untitled"),
                                "episode_title": asset.get("episodeTitle", ""),
                                "description": description,
                                "asset_id": asset_id,
                            }
                        )

            grabbed_pages += 1

            if grabbed_pages == max_pages:
                break

    for programme in programmes:
        programme_element = ET.SubElement(
            root,
            "programme",
            start=datetime.strptime(programme["start"], "%Y-%m-%dT%H:%M:%S%z").strftime(
                "%Y%m%d%H%M%S %z"
            ),
            stop=datetime.strptime(programme["end"], "%Y-%m-%dT%H:%M:%S%z").strftime(
                "%Y%m%d%H%M%S %z"
            ),
            channel="xumo-" + programme["channel_id"],
        )
        ET.SubElement(programme_element, "title").text = programme["title"]
        ET.SubElement(programme_element, "sub-title").text = programme["episode_title"]
        ET.SubElement(programme_element, "desc").text = programme["description"]

        if programme["asset_id"].startswith("EP"):
            ET.SubElement(programme_element, "episode-num", system="dd_progid").text = (
                programme["asset_id"]
            )
        else:
            ET.SubElement(
                programme_element, "episode-num", system="dd_seriesid"
            ).text = programme["asset_id"]

    tree = ET.ElementTree(root)
    ET.indent(tree, space="\t", level=0)

    xml_bytes = io.BytesIO()
    tree.write(xml_bytes, encoding="UTF-8", xml_declaration=True)

    try:
        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
            s.connect(SOCKET)
            xml_bytes.seek(0)
            s.sendall(xml_bytes.read())
    except:
        pass
        with open("xumo.xmltv", "wb") as file:
            tree.write(file, encoding="utf-8", xml_declaration=True)

    print(m3u)

Instead of interacting with an API, you can simply fetch a playlist and prepend and append to the URL's.