Streaming the output of a subprocess to 2 or more clients

I have a basic example here

import subprocess
from flask import (
    Flask,
    Response,
)
app = Flask(__name__)

stream = None

@app.route("/play", methods=["GET"])
def channel():
    def createStream():
        global stream
        print("create stream")
        stream = subprocess.Popen(
                ffmpegcmd,
                stdin=subprocess.DEVNULL,
                stdout=subprocess.PIPE,
                stderr=subprocess.DEVNULL,
            )

    def streamData():
        print("stream data")
        try:
            while True:
                chunk = stream.stdout.read(1024)
                if len(chunk) == 0:
                    break
                yield chunk
        except:
            pass


    if not stream:
        link = "https://cph-p2p-msl.akamaized.net/hls/live/2000341/test/master.m3u8"

        ffmpegcmd = [
            "ffmpeg",
            "-re",
            "-i",
            link,
            "-map",
            "0",
            "-codec",
            "copy",
            "-f",
            "mpegts",
            "pipe:"
        ]

        createStream()

        return Response(streamData(), mimetype="application/octet-stream")

    else:

        return Response(streamData(), mimetype="application/octet-stream")

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8001, debug=True)

If 2 or more clients try to stream at the same time, all streams freeze. Closing all streams and re-requesting /play picks up the existing sp and it plays ok.

Does anyone understand what is happening and why it doesn't work?
Is this a bug or limitation of subprocesses?

1. The first request to /play creates the subprocess, but the stream fails to play.
   The issue here is that the sp variable is not accessible outside the createStream() function. When the first request is made, createStream() is called and initializes sp, but when you try to access it in streamData(), it is out of scope and undefined. To fix this, you can make sp a global variable similar to stream, so that it can be accessed throughout the code as follows:

import subprocess
from flask import Flask, Response

app = Flask(__name__)

stream = None
sp = None

@app.route("/play", methods=["GET"])
def channel():
    def createStream():
        global sp  # Make sp a global variable
        print("create stream")
        sp = subprocess.Popen(
            ffmpegcmd,
            stdin=subprocess.DEVNULL,
            stdout=subprocess.PIPE,
            stderr=subprocess.DEVNULL,
        )

    def streamData():
        print("stream data")
        try:
            while True:
                chunk = sp.stdout.read(1024)
                if len(chunk) == 0:
                    break
                yield chunk
        except:
            pass

    global stream
    if not stream:
        link = "https://cph-p2p-msl.akamaized.net/hls/live/2000341/test/master.m3u8"

        ffmpegcmd = [
            "ffmpeg",
            "-re",
            "-i",
            link,
            "-map",
            "0",
            "-codec",
            "copy",
            "-f",
            "mpegts",
            "pipe:",
        ]

        createStream()

        return Response(streamData(), mimetype="application/octet-stream")
    else:
        return Response(streamData(), mimetype="application/octet-stream")

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8001, debug=True)

2. If two or more clients try to stream at the same time, all streams freeze.
   This issue is likely due to the fact that multiple clients are sharing the same sp subprocess. The streamData() function reads from the sp subprocess's stdout, but if multiple clients are reading from it simultaneously, it can cause conflicts and unexpected behavior.

We can fix this:

    import subprocess
    from flask import Flask, Response
    
    app = Flask(__name__)
    
    @app.route("/play", methods=["GET"])
    def channel():
        link = "https://cph-p2p-msl.akamaized.net/hls/live/2000341/test/master.m3u8"
    
        ffmpegcmd = [
            "ffmpeg",
            "-re",
            "-i",
            link,
            "-map",
            "0",
            "-codec",
            "copy",
            "-f",
            "mpegts",
            "pipe:",
        ]
    
        sp = subprocess.Popen(
            ffmpegcmd,
            stdin=subprocess.DEVNULL,
            stdout=subprocess.PIPE,
            stderr=subprocess.DEVNULL,
        )
    
        def streamData():
            print("stream data")
            try:
                while True:
                    chunk = sp.stdout.read(1024)
                    if len(chunk) == 0:
                        break
                    yield chunk
            except:
                pass
    
        return Response(streamData(), mimetype="application/octet-stream")
    
    if __name__ == "__main__":
        app.run(host="0.0.0.0", port=8001, debug=True)

To manage it in a single subprocess, we can use the multiprocessing module:

import subprocess
from flask import Flask, Response
from multiprocessing import Process

app = Flask(__name__)
ffmpeg_process = None  # Global variable to store the FFmpeg subprocess

@app.route("/play", methods=["GET"])
def channel():
    global ffmpeg_process

    # Check if the FFmpeg subprocess is already running
    if ffmpeg_process is None or not ffmpeg_process.is_alive():
        link = "https://cph-p2p-msl.akamaized.net/hls/live/2000341/test/master.m3u8"

        ffmpegcmd = [
            "ffmpeg",
            "-re",
            "-i",
            link,
            "-map",
            "0",
            "-codec",
            "copy",
            "-f",
            "mpegts",
            "pipe:",
        ]

        ffmpeg_process = subprocess.Popen(
            ffmpegcmd,
            stdin=subprocess.DEVNULL,
            stdout=subprocess.PIPE,
            stderr=subprocess.DEVNULL,
        )

    def streamData():
        print("stream data")
        try:
            while True:
                chunk = ffmpeg_process.stdout.read(1024)
                if len(chunk) == 0:
                    break
                yield chunk
        except:
            pass

    return Response(streamData(), mimetype="application/octet-stream")

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8001, debug=True)