5 second loading indicator between frames on live feed.

[ajh123]

I'm using a generic RTSP stream (from a MediaMTX server) and there is a loading indicator between frames on the live camera view on Unifi Protect. My RTSP stream is just raw video data I made from a Java program.

This image shows the loading, the preview on the right updates with the right frame before the main preview window.

docker-compose.yml config:

version: "3.5"
services:
  media_converter:
    restart: unless-stopped
    container_name: media_converter
    image: bluenviron/mediamtx:latest-ffmpeg
    ports:
      - 8554:8554
      - 1935:1935
      - 8888:8888
      - 8889:8889
      - 8890:8890/udp
      - 8189:8189/udp
  proxy-1:
    restart: unless-stopped
    image: keshavdv/unifi-cam-proxy:dev # I'm also using the dev image
    volumes:
      - "./client.pem:/client.pem"
    command: >-
        unifi-cam-proxy
        --host 10.0.0.1
        --mac 'AA:BB:CC:00:11:22'
        --cert /client.pem
        --token {TOKEN}
        rtsp -s rtsp://media_converter:8554/test_cam_stream

The Java program

The Java testing program, it uses FFMPEG to submit frames to an RTSP stream on MediaMTX.

package uk.minersonline;

import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.OutputStream;

public class Main {
    // Customize video size and frame rate here
    private static final int VIDEO_WIDTH = 640;
    private static final int VIDEO_HEIGHT = 480;
    private static final int FRAME_RATE = 100;
    private static final String OUTPUT_PATH = "rtsp://10.0.0.109:8554/test_cam_stream"; // this IP is correct

    // FFmpeg command is updated to use dynamic video size and frame rate
    private static final String FFMPEG_COMMAND = String.format(
            "ffmpeg -y -f rawvideo -pixel_format rgb24 -video_size %dx%d -framerate %d -i - -c copy -c:v libx264 -preset ultrafast -f rtsp %s",
            VIDEO_WIDTH, VIDEO_HEIGHT, FRAME_RATE, OUTPUT_PATH);


    public static void main(String[] args) throws Exception {
        // Start FFmpeg process with the HLS command
        ProcessBuilder processBuilder = new ProcessBuilder(FFMPEG_COMMAND.split(" "));
        processBuilder.redirectErrorStream(true);
        Process ffmpegProcess = processBuilder.start();
        OutputStream ffmpegInput = ffmpegProcess.getOutputStream();

        // Frame generator to create frames continuously
        FrameGenerator frameGenerator = new FrameGenerator();

        // Main loop for streaming frames
        while (true) {
            // Generate a new frame (BufferedImage)
            BufferedImage frame = frameGenerator.createFrame(VIDEO_WIDTH, VIDEO_HEIGHT);

            // Feed the frame to FFmpeg via stdin
            writeFrameToFFmpeg(frame, ffmpegInput);

            // Sleep to match the customized frame rate (e.g., 30 FPS)
            Thread.sleep(1000 / FRAME_RATE);
        }
    }

    // Function to write BufferedImage frame data to FFmpeg stdin
    private static void writeFrameToFFmpeg(BufferedImage frame, OutputStream ffmpegInput) throws Exception {
        int width = frame.getWidth();
        int height = frame.getHeight();

        // Write each pixel's RGB value as raw data
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                int pixel = frame.getRGB(x, y);
                ffmpegInput.write((pixel >> 16) & 0xFF); // Red
                ffmpegInput.write((pixel >> 8) & 0xFF);  // Green
                ffmpegInput.write(pixel & 0xFF);         // Blue
            }
        }
        ffmpegInput.flush();
    }
}

// A simple frame generator class to create continuous frames with color changes
class FrameGenerator {
    private int frameCount = 0;

    public BufferedImage createFrame(int width, int height) {
        BufferedImage frame = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR);
        Graphics2D g2d = frame.createGraphics();

        // Create a simple color animation based on the frame count
        g2d.setColor(new Color((frameCount * 5) % 255, (frameCount * 7) % 255, (frameCount * 3) % 255));
        g2d.fillRect(0, 0, width, height);

        g2d.dispose();
        frameCount++;
        return frame;
    }
}

---

I assume it may be a problem with MediaMTX, my Java program, or FFMPEG parameters but I could be wrong.

Or, is this loading normal? I don't have any other stream sources to test this. Also, the stream works fine in VLC Media Player.