Implement SRT protocol

[master312]

A discussion about SRT protocol implementation.

The https://github.com/Eyevinn/node-srt looks good for this usecase.

[master312]

This is my quick idea for implementation of this feature. It's not concrete plan for to follow, might be useful as guidelie so keep in mind that i might have missed some things.

[ ] Implement SRT destination support, so that current RTMP streams can be

• This should be easy enough to implement, and require very little code change. Maybe startRelay method in stream-relay-service.ts and related types/enums and frontend.

[ ] Implement srt-server service.

• Use node-srt library and rtmp-server service as reference
• This service should keep 'low level' stuff related to STR streams. Like tracking of active connections, their state, and authentication.
• Currently, when raw RTMP connection passes all initial checks in rtmp-server service, the 'rtmp.inject.start' event is fired, and handled by 'onStreamBecomeLive' in stream-mgr service. That method, and 'startRelay' method in stream-relay-service would also need to be updated.
• Since now we have multiple types of streams, it might be a good idea to rename 'rtmp.inject.*' events to just 'inject.*' or something similar. Keep in mind that 'stream.live.*' prefix is already in use.
• stream-instance.model would also need to be updated with enum to represent from which source stream is originating.

[master312]

A simple SRT forward server using 'eyevinn/node-srt' library... Not tested, might be outdated, but should still be usefull.
In actual implementation, we use ffmpeg to do the forwarding to destination host, since there is already infrastructure do to so with minimal changes.

Code

const { SRT } = require("@eyevinn/node-srt");

// Configuration
const listenPort = 1234; // Port to listen for incoming SRT stream
const forwardHost = "127.0.0.1"; // Host to forward the stream to
const forwardPort = 5678; // Port to forward the stream to

// Create the SRT instance
const srt = new SRT();

// Create the listener (server) socket
const listener = srt.createSocket();
listener.bind("0.0.0.0", listenPort);
listener.listen(1); // Allow one connection

console.log(`Listening for SRT stream on port ${listenPort}`);

listener.on("connection", (clientSocket) => {
  console.log(
    `Incoming connection from ${clientSocket.remoteAddress}:${clientSocket.remotePort}`
  );

  // Create the forwarder (client) socket for each incoming connection
  const forwarder = srt.createSocket();

  // Connect the forwarder to the destination
  forwarder.connect(forwardHost, forwardPort);

  forwarder.on("connect", () => {
    console.log(`Connected to forward destination ${forwardHost}:${forwardPort}`);

    // Pipe data from the incoming client to the forwarder
    // This handles the actual stream forwarding
    clientSocket.pipe(forwarder);

    // Optional: Handle stream close/error events for cleanup
    clientSocket.on("close", () => {
      console.log("Incoming connection closed.");
      forwarder.close(); // Close the forwarding connection
    });
    clientSocket.on("error", (err) => {
      console.error("Incoming connection error:", err);
      forwarder.close();
    });

    forwarder.on("close", () => {
      console.log("Forwarding connection closed.");
      // No need to close clientSocket here, it might have triggered this close
    });
    forwarder.on("error", (err) => {
      console.error("Forwarding connection error:", err);
      clientSocket.close(); // Close the incoming connection if forwarding fails
    });
  });

  forwarder.on("error", (err) => {
    // Handle connection errors for the forwarder
    console.error(
      `Failed to connect to forward destination ${forwardHost}:${forwardPort}:`,
      err
    );
    clientSocket.close(); // Close the incoming connection if we can't forward
  });
});

listener.on("error", (err) => {
  console.error("Listener socket error:", err);
});```
</p>
</details>