Update Darwin build job to use macOS 13 for consistency

.github/workflows/docker-dev.yml

@@ -0,0 +1,58 @@
+name: Docker development build
+
+on:
+  push:
+    branches: [develop]
+
+jobs:
+  build-amd64:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        architecture: [amd64]
+    steps:
+      - name: Login to DockerHub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Available platforms
+        run: echo ${{ steps.buildx.outputs.platforms }}
+      - name: Run Buildx
+        run: docker buildx build --platform linux/${{matrix.architecture}} -t kerberos/agent-dev:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7) --push .
+      - name: Create new and append to manifest
+        run: docker buildx imagetools create -t kerberos/agent-dev:$(echo $GITHUB_SHA | cut -c1-7) kerberos/agent-dev:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7)
+      - name: Create new and append to latest manifest
+        run: docker buildx imagetools create -t kerberos/agent-dev:latest kerberos/agent-dev:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7)
+  build-other:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        #architecture: [arm64, arm/v7, arm/v6]
+        architecture: [arm64, arm/v7]
+    steps:
+      - name: Login to DockerHub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Available platforms
+        run: echo ${{ steps.buildx.outputs.platforms }}
+      - name: Run Buildx
+        run: docker buildx build --platform linux/${{matrix.architecture}} -t kerberos/agent-dev:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7) --push .
+      - name: Create new and append to manifest
+        run: docker buildx imagetools create --append -t kerberos/agent-dev:$(echo $GITHUB_SHA | cut -c1-7) kerberos/agent-dev:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7)
+      - name: Create new and append to manifest latest
+        run: docker buildx imagetools create --append -t kerberos/agent-dev:latest kerberos/agent-dev:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7)

.github/workflows/docker-nightly.yml

@@ -1,14 +1,12 @@
-name: Nightly build
+name: Docker nightly build
 
 on:
   # Triggers the workflow every day at 9PM (CET).
   schedule:
     - cron: "0 22 * * *"
-  # Allows manual triggering from the Actions tab.
-  workflow_dispatch:
 
 jobs:
-  nightly-build-amd64:
+  build-amd64:
     runs-on: ubuntu-latest
     strategy:
       matrix:
@@ -20,9 +18,7 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          ref: master
+        run: git clone https://github.com/kerberos-io/agent && cd agent
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v2
       - name: Set up Docker Buildx
@@ -30,10 +26,10 @@ jobs:
       - name: Available platforms
         run: echo ${{ steps.buildx.outputs.platforms }}
       - name: Run Buildx
-        run: docker buildx build --platform linux/${{matrix.architecture}} -t kerberos/agent-nightly:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7) --push .
+        run: cd agent && docker buildx build --platform linux/${{matrix.architecture}} -t kerberos/agent-nightly:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7) --push .
       - name: Create new and append to manifest
-        run: docker buildx imagetools create -t kerberos/agent-nightly:$(echo $GITHUB_SHA | cut -c1-7) kerberos/agent-nightly:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7)
-  nightly-build-other:
+        run: cd agent && docker buildx imagetools create -t kerberos/agent-nightly:$(echo $GITHUB_SHA | cut -c1-7) kerberos/agent-nightly:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7)
+  build-other:
     runs-on: ubuntu-latest
     strategy:
       matrix:
@@ -45,9 +41,7 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          ref: master
+        run: git clone https://github.com/kerberos-io/agent && cd agent
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v2
       - name: Set up Docker Buildx
@@ -55,6 +49,6 @@ jobs:
       - name: Available platforms
         run: echo ${{ steps.buildx.outputs.platforms }}
       - name: Run Buildx
-        run: docker buildx build --platform linux/${{matrix.architecture}} -t kerberos/agent-nightly:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7) --push .
+        run: cd agent && docker buildx build --platform linux/${{matrix.architecture}} -t kerberos/agent-nightly:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7) --push .
       - name: Create new and append to manifest
-        run: docker buildx imagetools create --append -t kerberos/agent-nightly:$(echo $GITHUB_SHA | cut -c1-7) kerberos/agent-nightly:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7)
+        run: cd agent && docker buildx imagetools create --append -t kerberos/agent-nightly:$(echo $GITHUB_SHA | cut -c1-7) kerberos/agent-nightly:arch-$(echo ${{matrix.architecture}} | tr / -)-$(echo $GITHUB_SHA | cut -c1-7)

.github/workflows/docker.yml

@@ -34,7 +34,7 @@ jobs:
           length: 7
       - name: Run Build
         run: |
-          docker build --provenance=false --build-arg VERSION=${{github.event.inputs.tag || github.ref_name}} -t ${{matrix.architecture}} .
+          docker build -t ${{matrix.architecture}} .
           CID=$(docker create ${{matrix.architecture}})
           docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
           docker rm ${CID}
@@ -44,12 +44,17 @@ jobs:
         run: |
           docker tag ${{matrix.architecture}} $REPO-arch:arch-${{matrix.architecture}}-${{github.event.inputs.tag || github.ref_name}}
           docker push $REPO-arch:arch-${{matrix.architecture}}-${{github.event.inputs.tag || github.ref_name}}
+      - name: Create new manifest
+        run: docker manifest create $REPO:${{ github.event.inputs.tag || github.ref_name }} $REPO-arch:arch-${{matrix.architecture}}-${{github.event.inputs.tag || github.ref_name}}
+      - name: Create latest manifest
+        run: docker manifest create $REPO:latest $REPO-arch:arch-${{matrix.architecture}}-${{github.event.inputs.tag || github.ref_name}}
+        if: github.event.inputs.tag == 'test'
       - name: Upload artifact
         uses: actions/upload-artifact@v4
         with:
           name: agent-${{matrix.architecture}}.tar
           path: agent-${{matrix.architecture}}.tar
-          
+        
   build-arm64:
     runs-on: ubuntu-24.04-arm 
     permissions:
@@ -71,7 +76,7 @@ jobs:
           length: 7
       - name: Run Build
         run: |
-          docker build --provenance=false --build-arg VERSION=${{github.event.inputs.tag || github.ref_name}} -t ${{matrix.architecture}} -f Dockerfile.arm64 .
+          docker build -t ${{matrix.architecture}} -f Dockerfile.arm64 .
           CID=$(docker create ${{matrix.architecture}})
           docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
           docker rm ${CID}
@@ -87,9 +92,38 @@ jobs:
           name: agent-${{matrix.architecture}}.tar
           path: agent-${{matrix.architecture}}.tar
 
+  build-darwin:
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: write
+    strategy:
+      matrix:
+        architecture: [amd64, arm64]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Build Darwin binary with Docker
+        run: |
+          docker build -f Dockerfile.cross \
+            --build-arg GOOS=darwin \
+            --build-arg GOARCH=${{matrix.architecture}} \
+            -t darwin-${{matrix.architecture}} .
+          CID=$(docker create darwin-${{matrix.architecture}})
+          docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
+          docker rm ${CID}
+      - name: Tar Darwin binary and clean
+        run: tar -cf agent-darwin-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
+      - name: Upload darwin artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: agent-darwin-${{matrix.architecture}}.tar
+          path: agent-darwin-${{matrix.architecture}}.tar
+
   create-manifest:
     runs-on: ubuntu-24.04
-    needs: [build-amd64, build-arm64]
+    needs: [build-amd64, build-arm64, build-darwin]
     steps:
       - name: Login to DockerHub
         uses: docker/login-action@v2

.github/workflows/issue-userstory-create.yml

@@ -1,51 +0,0 @@
-name: Create User Story Issue
-on:
-  workflow_dispatch:
-    inputs:
-      issue_title:
-        description: 'Title for the issue'
-        required: true
-      issue_description:
-        description: 'Brief description of the feature'
-        required: true
-      complexity:
-        description: 'Complexity of the feature'
-        required: true
-        type: choice
-        options:
-          - 'Low'
-          - 'Medium'
-          - 'High'
-        default: 'Medium'
-      duration:
-        description: 'Estimated duration'
-        required: true
-        type: choice
-        options:
-          - '1 day'
-          - '3 days'
-          - '1 week'
-          - '2 weeks'
-          - '1 month'
-        default: '1 week'
-
-jobs:
-  create-issue:
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-    steps:
-      - name: Create Issue with User Story
-        uses: cedricve/llm-create-issue-user-story@main
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          azure_openai_api_key: ${{ secrets.AZURE_OPENAI_API_KEY }}
-          azure_openai_endpoint: ${{ secrets.AZURE_OPENAI_ENDPOINT }}
-          azure_openai_version: ${{ secrets.AZURE_OPENAI_VERSION }}
-          openai_model: ${{ secrets.OPENAI_MODEL }}
-          issue_title: ${{ github.event.inputs.issue_title }}
-          issue_description: ${{ github.event.inputs.issue_description }}
-          complexity: ${{ github.event.inputs.complexity }}
-          duration: ${{ github.event.inputs.duration }}
-          labels: 'user-story,feature'
-          assignees: ${{ github.actor }}

.github/workflows/pr-build.yml

@@ -7,34 +7,28 @@ env:
   REPO: kerberos/agent
 
 jobs:
-  build:
-    runs-on: ${{ matrix.runner }}
+  build-amd64:
+    runs-on: ubuntu-24.04
     permissions:
       contents: write
     strategy:
       matrix:
-        include:
-          - architecture: amd64
-            runner: ubuntu-24.04
-            dockerfile: Dockerfile
-          - architecture: arm64
-            runner: ubuntu-24.04-arm
-            dockerfile: Dockerfile.arm64
+        architecture: [amd64]
     steps:
-      - name: Checkout
-        uses: actions/checkout@v3
       - name: Login to DockerHub
         uses: docker/login-action@v2
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Checkout
+        uses: actions/checkout@v3
       - uses: benjlevesque/short-sha@v2.1
         id: short-sha
         with:
           length: 7
       - name: Run Build
         run: |
-          docker build -t ${{ matrix.architecture }} -f ${{ matrix.dockerfile }} .
+          docker build -t ${{matrix.architecture}} .
           CID=$(docker create ${{matrix.architecture}})
           docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
           docker rm ${CID}
@@ -45,4 +39,73 @@ jobs:
         with:
           name: agent-${{matrix.architecture}}.tar
           path: agent-${{matrix.architecture}}.tar
+          
+  build-arm64:
+    runs-on: ubuntu-24.04-arm 
+    permissions:
+      contents: write
+    strategy:
+      matrix:
+        architecture: [arm64]
+    steps:
+      - name: Login to DockerHub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Checkout
+        uses: actions/checkout@v3
+      - uses: benjlevesque/short-sha@v2.1
+        id: short-sha
+        with:
+          length: 7
+      - name: Run Build
+        run: |
+          docker build -t ${{matrix.architecture}} -f Dockerfile.arm64 .
+          CID=$(docker create ${{matrix.architecture}})
+          docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
+          docker rm ${CID}
+      - name: Strip binary
+        run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: agent-${{matrix.architecture}}.tar
+          path: agent-${{matrix.architecture}}.tar
+          
+  build-darwin:
+    runs-on: macos-13
+    permissions:
+      contents: write
+    strategy:
+      matrix:
+        architecture: [arm64]
+    steps:
+      - name: Setup Docker on macOS
+        uses: douglascamata/setup-docker-macos-action@v1.0.0
+      - name: Login to DockerHub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Checkout
+        uses: actions/checkout@v3
+      - uses: benjlevesque/short-sha@v2.1
+        id: short-sha
+        with:
+          length: 7
+      - name: Build Darwin binary with Docker
+        run: |
+          docker build -f Dockerfile.arm64 \
+            -t darwin-${{matrix.architecture}} .
+          CID=$(docker create darwin-${{matrix.architecture}})
+          docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
+          docker rm ${CID}
+      - name: Tar Darwin binary and clean
+        run: tar -cf agent-darwin-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
+      - name: Upload darwin artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: agent-darwin-${{matrix.architecture}}.tar
+          path: agent-darwin-${{matrix.architecture}}.tar
 

.github/workflows/pr-description.yaml

@@ -2,11 +2,6 @@ name: Autofill PR description
 
 on: pull_request
 
-env:
-  ORGANIZATION: uugai
-  PROJECT: ${{ github.event.repository.name }}
-  PR_NUMBER: ${{ github.event.number }}
-  
 jobs:
   openai-pr-description:
     runs-on: ubuntu-22.04
@@ -21,6 +16,4 @@ jobs:
           azure_openai_api_key: ${{ secrets.AZURE_OPENAI_API_KEY }}
           azure_openai_endpoint: ${{ secrets.AZURE_OPENAI_ENDPOINT }}
           azure_openai_version: ${{ secrets.AZURE_OPENAI_VERSION }}
-          openai_model: ${{ secrets.OPENAI_MODEL }}
-          pull_request_url: https://pr${{ env.PR_NUMBER }}.api.kerberos.lol
           overwrite_description: true

.gitignore

@@ -14,5 +14,4 @@ machinery/test*
 machinery/init-dev.sh
 machinery/.env.local
 machinery/vendor
-deployments/docker/private-docker-compose.yaml
-video.mp4
+deployments/docker/private-docker-compose.yaml

Dockerfile

@@ -1,6 +1,5 @@
 
 ARG BASE_IMAGE_VERSION=amd64-ddbe40e
-ARG VERSION=0.0.0
 FROM kerberos/base:${BASE_IMAGE_VERSION} AS build-machinery
 LABEL AUTHOR=uug.ai
 
@@ -33,10 +32,12 @@ RUN cat /go/src/github.com/kerberos-io/agent/machinery/version
 ##################
 # Build Machinery
 
+ARG GOOS=linux
+ENV GOOS=${GOOS}
+
 RUN cd /go/src/github.com/kerberos-io/agent/machinery && \
 	go mod download && \
-	VERSION=$(cd /go/src/github.com/kerberos-io/agent && git describe --tags --always 2>/dev/null || echo "${VERSION}") && \
-	go build -tags timetzdata,netgo,osusergo --ldflags "-s -w -X github.com/kerberos-io/agent/machinery/src/utils.VERSION=${VERSION} -extldflags '-static -latomic'" main.go && \
+	go build -tags timetzdata,netgo,osusergo --ldflags '-s -w -extldflags "-static -latomic"' main.go && \
 	mkdir -p /agent && \
 	mv main /agent && \
 	mv version /agent && \

Dockerfile.arm64

@@ -1,6 +1,5 @@
 
 ARG BASE_IMAGE_VERSION=arm64-ddbe40e
-ARG VERSION=0.0.0
 FROM kerberos/base:${BASE_IMAGE_VERSION} AS build-machinery
 LABEL AUTHOR=uug.ai
 
@@ -33,10 +32,12 @@ RUN cat /go/src/github.com/kerberos-io/agent/machinery/version
 ##################
 # Build Machinery
 
+ARG GOOS=linux
+ENV GOOS=${GOOS}
+
 RUN cd /go/src/github.com/kerberos-io/agent/machinery && \
 	go mod download && \
-	VERSION=$(cd /go/src/github.com/kerberos-io/agent && git describe --tags --always 2>/dev/null || echo "${VERSION}") && \
-	go build -tags timetzdata,netgo,osusergo --ldflags "-s -w -X github.com/kerberos-io/agent/machinery/src/utils.VERSION=${VERSION} -extldflags '-static -latomic'" main.go && \
+	go build -tags timetzdata,netgo,osusergo --ldflags '-s -w -extldflags "-static -latomic"' main.go && \
 	mkdir -p /agent && \
 	mv main /agent && \
 	mv version /agent && \

machinery/main.go

@@ -101,35 +101,31 @@ func main() {
 	switch action {
 
 	case "version":
-		{
-			log.Log.Info("main.Main(): You are currrently running Kerberos Agent " + VERSION)
-		}
+		log.Log.Info("main.Main(): You are currrently running Kerberos Agent " + VERSION)
+
 	case "discover":
-		{
-			// Convert duration to int
-			timeout, err := time.ParseDuration(timeout + "ms")
-			if err != nil {
-				log.Log.Fatal("main.Main(): could not parse timeout: " + err.Error())
-				return
-			}
-			onvif.Discover(timeout)
+		// Convert duration to int
+		timeout, err := time.ParseDuration(timeout + "ms")
+		if err != nil {
+			log.Log.Fatal("main.Main(): could not parse timeout: " + err.Error())
+			return
 		}
+		onvif.Discover(timeout)
+
 	case "decrypt":
-		{
-			log.Log.Info("main.Main(): Decrypting: " + flag.Arg(0) + " with key: " + flag.Arg(1))
-			symmetricKey := []byte(flag.Arg(1))
+		log.Log.Info("main.Main(): Decrypting: " + flag.Arg(0) + " with key: " + flag.Arg(1))
+		symmetricKey := []byte(flag.Arg(1))
 
-			if len(symmetricKey) == 0 {
-				log.Log.Fatal("main.Main(): symmetric key should not be empty")
-				return
-			}
-			if len(symmetricKey) != 32 {
-				log.Log.Fatal("main.Main(): symmetric key should be 32 bytes")
-				return
-			}
-
-			utils.Decrypt(flag.Arg(0), symmetricKey)
+		if symmetricKey == nil || len(symmetricKey) == 0 {
+			log.Log.Fatal("main.Main(): symmetric key should not be empty")
+			return
 		}
+		if len(symmetricKey) != 32 {
+			log.Log.Fatal("main.Main(): symmetric key should be 32 bytes")
+			return
+		}
+
+		utils.Decrypt(flag.Arg(0), symmetricKey)
 
 	case "run":
 		{
@@ -217,8 +213,6 @@ func main() {
 			routers.StartWebserver(configDirectory, &configuration, &communication, &capture)
 		}
 	default:
-		{
-			log.Log.Error("main.Main(): Sorry I don't understand :(")
-		}
+		log.Log.Error("main.Main(): Sorry I don't understand :(")
 	}
 }

machinery/src/capture/gortsplib.go

@@ -85,8 +85,12 @@ type Golibrtsp struct {
 
 	Streams []packets.Stream
 
-	// Per-stream FPS calculation (keyed by stream index)
-	fpsTrackers map[int8]*fpsTracker
+	// FPS calculation fields
+	lastFrameTime    time.Time
+	frameTimeBuffer  []time.Duration
+	frameBufferSize  int
+	frameBufferIndex int
+	fpsMutex         sync.Mutex
 
 	// I-frame interval tracking fields
 	packetsSinceLastKeyframe int
@@ -97,78 +101,6 @@ type Golibrtsp struct {
 	keyframeMutex            sync.Mutex
 }
 
-// fpsTracker holds per-stream state for PTS-based FPS calculation.
-// Each video stream (H264 / H265) gets its own tracker so PTS
-// samples from different codecs never interleave.
-type fpsTracker struct {
-	mu              sync.Mutex
-	lastPTS         time.Duration
-	hasPTS          bool
-	frameTimeBuffer []time.Duration
-	bufferSize      int
-	bufferIndex     int
-	cachedFPS       float64 // latest computed FPS
-}
-
-func newFPSTracker(bufferSize int) *fpsTracker {
-	return &fpsTracker{
-		frameTimeBuffer: make([]time.Duration, bufferSize),
-		bufferSize:      bufferSize,
-	}
-}
-
-// update records a new PTS sample and returns the latest FPS estimate.
-// It must be called once per complete decoded frame (after Decode()
-// succeeds), not on every RTP packet fragment.
-func (ft *fpsTracker) update(pts time.Duration) float64 {
-	ft.mu.Lock()
-	defer ft.mu.Unlock()
-
-	if !ft.hasPTS {
-		ft.lastPTS = pts
-		ft.hasPTS = true
-		return 0
-	}
-
-	interval := pts - ft.lastPTS
-	ft.lastPTS = pts
-
-	// Skip invalid intervals (zero, negative, or very large which
-	// indicate a PTS discontinuity or wrap).
-	if interval <= 0 || interval > 5*time.Second {
-		return ft.cachedFPS
-	}
-
-	ft.frameTimeBuffer[ft.bufferIndex] = interval
-	ft.bufferIndex = (ft.bufferIndex + 1) % ft.bufferSize
-
-	var totalInterval time.Duration
-	validSamples := 0
-	for _, iv := range ft.frameTimeBuffer {
-		if iv > 0 {
-			totalInterval += iv
-			validSamples++
-		}
-	}
-	if validSamples == 0 {
-		return ft.cachedFPS
-	}
-	avgInterval := totalInterval / time.Duration(validSamples)
-	if avgInterval == 0 {
-		return ft.cachedFPS
-	}
-
-	ft.cachedFPS = float64(time.Second) / float64(avgInterval)
-	return ft.cachedFPS
-}
-
-// fps returns the most recent FPS estimate without recording a new sample.
-func (ft *fpsTracker) fps() float64 {
-	ft.mu.Lock()
-	defer ft.mu.Unlock()
-	return ft.cachedFPS
-}
-
 // Init function
 var H264FrameDecoder *Decoder
 var H265FrameDecoder *Decoder
@@ -616,17 +548,18 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
 
 			if len(rtppkt.Payload) > 0 {
 
-				// decode timestamps — validate each call separately
-				pts, okPTS := g.Client.PacketPTS(g.VideoH264Media, rtppkt)
-				pts2, okPTS2 := g.Client.PacketPTS2(g.VideoH264Media, rtppkt)
-				if !okPTS2 {
-					log.Log.Debug("capture.golibrtsp.Start(): unable to get PTS2 from PacketPTS2")
+				// decode timestamp
+				pts, ok := g.Client.PacketPTS(g.VideoH264Media, rtppkt)
+				pts2, ok := g.Client.PacketPTS2(g.VideoH264Media, rtppkt)
+				if !ok {
+					log.Log.Debug("capture.golibrtsp.Start(): " + "unable to get PTS")
 					return
 				}
 
-				// Extract access units from RTP packets.
-				// We need a complete access unit to determine whether
-				// this is a keyframe.
+				// Extract access units from RTP packets
+				// We need to do this, because the decoder expects a full
+				// access unit. Once we have a full access unit, we can
+				// decode it, and know if it's a keyframe or not.
 				au, errDecode := g.VideoH264Decoder.Decode(rtppkt)
 				if errDecode != nil {
 					if errDecode != rtph264.ErrNonStartingPacketAndNoPrevious && errDecode != rtph264.ErrMorePacketsNeeded {
@@ -635,18 +568,6 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
 					return
 				}
 
-				// Frame is complete — update per-stream FPS from PTS.
-				if okPTS {
-					ft := g.fpsTrackers[g.VideoH264Index]
-					if ft == nil {
-						ft = newFPSTracker(30)
-						g.fpsTrackers[g.VideoH264Index] = ft
-					}
-					if ptsFPS := ft.update(pts); ptsFPS > 0 && ptsFPS <= 120 {
-						g.Streams[g.VideoH264Index].FPS = ptsFPS
-					}
-				}
-
 				// We'll need to read out a few things.
 				// prepend an AUD. This is required by some players
 				filteredAU = [][]byte{
@@ -657,10 +578,8 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
 				nonIDRPresent := false
 				idrPresent := false
 
-				var naluTypes []string
 				for _, nalu := range au {
 					typ := h264.NALUType(nalu[0] & 0x1F)
-					naluTypes = append(naluTypes, fmt.Sprintf("%s(%d,sz=%d)", typ.String(), int(typ), len(nalu)))
 					switch typ {
 					case h264.NALUTypeAccessUnitDelimiter:
 						continue
@@ -695,46 +614,18 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
 							g.Streams[g.VideoH264Index].FPS = fps
 							log.Log.Debug(fmt.Sprintf("capture.golibrtsp.Start(%s): Final FPS=%.2f", streamType, fps))
 							g.VideoH264Forma.SPS = nalu
-							if streamType == "main" && len(nalu) > 0 {
-								// Fallback: store SPS from in-band NALUs when SDP was missing it.
-								configuration.Config.Capture.IPCamera.SPSNALUs = [][]byte{nalu}
-							}
 
 						}
 					case h264.NALUTypePPS:
 						g.VideoH264Forma.PPS = nalu
-						if streamType == "main" && len(nalu) > 0 {
-							// Fallback: store PPS from in-band NALUs when SDP was missing it.
-							configuration.Config.Capture.IPCamera.PPSNALUs = [][]byte{nalu}
-						}
 					}
 					filteredAU = append(filteredAU, nalu)
 				}
 
-				if idrPresent && streamType == "main" {
-					// Ensure config has parameter sets before recordings start.
-					if len(configuration.Config.Capture.IPCamera.SPSNALUs) == 0 && len(g.VideoH264Forma.SPS) > 0 {
-						configuration.Config.Capture.IPCamera.SPSNALUs = [][]byte{g.VideoH264Forma.SPS}
-						log.Log.Warning("capture.golibrtsp.Start(main): fallback SPS set from keyframe")
-					}
-					if len(configuration.Config.Capture.IPCamera.PPSNALUs) == 0 && len(g.VideoH264Forma.PPS) > 0 {
-						configuration.Config.Capture.IPCamera.PPSNALUs = [][]byte{g.VideoH264Forma.PPS}
-						log.Log.Warning("capture.golibrtsp.Start(main): fallback PPS set from keyframe")
-					}
-					if len(configuration.Config.Capture.IPCamera.SPSNALUs) == 0 || len(configuration.Config.Capture.IPCamera.PPSNALUs) == 0 {
-						log.Log.Warning("capture.golibrtsp.Start(main): SPS/PPS still missing after IDR keyframe")
-					}
-				}
-
 				if len(filteredAU) <= 1 || (!nonIDRPresent && !idrPresent) {
 					return
 				}
 
-				if idrPresent {
-					log.Log.Debug(fmt.Sprintf("capture.golibrtsp.Start(%s): IDR frame NALUs: [%s]",
-						streamType, fmt.Sprintf("%v", naluTypes)))
-				}
-
 				// Convert to packet.
 				enc, err := h264.AnnexBMarshal(filteredAU)
 				if err != nil {
@@ -760,11 +651,7 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
 				keyframeInterval := g.trackKeyframeInterval(idrPresent)
 				if idrPresent && keyframeInterval > 0 {
 					avgInterval := g.getAverageKeyframeInterval()
-					fps := g.Streams[g.VideoH264Index].FPS
-					if fps <= 0 {
-						fps = 25.0 // Default fallback FPS
-					}
-					gopDuration := float64(keyframeInterval) / fps
+					gopDuration := float64(keyframeInterval) / g.Streams[g.VideoH265Index].FPS
 					gopSize := int(avgInterval) // Store GOP size in a separate variable
 					g.Streams[g.VideoH264Index].GopSize = gopSize
 					log.Log.Debug(fmt.Sprintf("capture.golibrtsp.Start(%s): Keyframe interval=%d packets, Avg=%.1f, GOP=%.1fs, GOPSize=%d",
@@ -829,17 +716,18 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
 
 			if len(rtppkt.Payload) > 0 {
 
-				// decode timestamps — validate each call separately
-				pts, okPTS := g.Client.PacketPTS(g.VideoH265Media, rtppkt)
-				pts2, okPTS2 := g.Client.PacketPTS2(g.VideoH265Media, rtppkt)
-				if !okPTS2 {
-					log.Log.Debug("capture.golibrtsp.Start(): unable to get PTS")
+				// decode timestamp
+				pts, ok := g.Client.PacketPTS(g.VideoH265Media, rtppkt)
+				pts2, ok := g.Client.PacketPTS2(g.VideoH265Media, rtppkt)
+				if !ok {
+					log.Log.Debug("capture.golibrtsp.Start(): " + "unable to get PTS")
 					return
 				}
 
-				// Extract access units from RTP packets.
-				// We need a complete access unit to determine whether
-				// this is a keyframe.
+				// Extract access units from RTP packets
+				// We need to do this, because the decoder expects a full
+				// access unit. Once we have a full access unit, we can
+				// decode it, and know if it's a keyframe or not.
 				au, errDecode := g.VideoH265Decoder.Decode(rtppkt)
 				if errDecode != nil {
 					if errDecode != rtph265.ErrNonStartingPacketAndNoPrevious && errDecode != rtph265.ErrMorePacketsNeeded {
@@ -848,18 +736,6 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
 					return
 				}
 
-				// Frame is complete — update per-stream FPS from PTS.
-				if okPTS {
-					ft := g.fpsTrackers[g.VideoH265Index]
-					if ft == nil {
-						ft = newFPSTracker(30)
-						g.fpsTrackers[g.VideoH265Index] = ft
-					}
-					if ptsFPS := ft.update(pts); ptsFPS > 0 && ptsFPS <= 120 {
-						g.Streams[g.VideoH265Index].FPS = ptsFPS
-					}
-				}
-
 				filteredAU = [][]byte{
 					{byte(h265.NALUType_AUD_NUT) << 1, 1, 0x50},
 				}
@@ -920,11 +796,7 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
 				keyframeInterval := g.trackKeyframeInterval(isRandomAccess)
 				if isRandomAccess && keyframeInterval > 0 {
 					avgInterval := g.getAverageKeyframeInterval()
-					fps := g.Streams[g.VideoH265Index].FPS
-					if fps <= 0 {
-						fps = 25.0 // Default fallback FPS
-					}
-					gopDuration := float64(keyframeInterval) / fps
+					gopDuration := float64(keyframeInterval) / g.Streams[g.VideoH265Index].FPS
 					gopSize := int(avgInterval) // Store GOP size in a separate variable
 					g.Streams[g.VideoH265Index].GopSize = gopSize
 					log.Log.Debug(fmt.Sprintf("capture.golibrtsp.Start(%s): Keyframe interval=%d packets, Avg=%.1f, GOP=%.1fs, GOPSize=%d",
@@ -1307,11 +1179,10 @@ func WriteMPEG4Audio(forma *format.MPEG4Audio, aus [][]byte) ([]byte, error) {
 
 // Initialize FPS calculation buffers
 func (g *Golibrtsp) initFPSCalculation() {
-	// Ensure the per-stream FPS trackers map exists. Individual trackers
-	// can be created lazily when a given stream index is first used.
-	if g.fpsTrackers == nil {
-		g.fpsTrackers = make(map[int8]*fpsTracker)
-	}
+	g.frameBufferSize = 30 // Store last 30 frame intervals
+	g.frameTimeBuffer = make([]time.Duration, g.frameBufferSize)
+	g.frameBufferIndex = 0
+	g.lastFrameTime = time.Time{}
 
 	// Initialize I-frame interval tracking
 	g.keyframeBufferSize = 10 // Store last 10 keyframe intervals
@@ -1321,11 +1192,50 @@ func (g *Golibrtsp) initFPSCalculation() {
 	g.lastKeyframePacketCount = 0
 }
 
-// Get enhanced FPS information from SPS with fallback to PTS-based calculation.
-// The PTS-based FPS is computed per completed frame via fpsTracker.update(),
-// so by the time this is called we already have a good estimate.
+// Calculate FPS from frame timestamps
+func (g *Golibrtsp) calculateFPSFromTimestamps() float64 {
+	g.fpsMutex.Lock()
+	defer g.fpsMutex.Unlock()
+
+	if g.lastFrameTime.IsZero() {
+		g.lastFrameTime = time.Now()
+		return 0
+	}
+
+	now := time.Now()
+	interval := now.Sub(g.lastFrameTime)
+	g.lastFrameTime = now
+
+	// Store the interval
+	g.frameTimeBuffer[g.frameBufferIndex] = interval
+	g.frameBufferIndex = (g.frameBufferIndex + 1) % g.frameBufferSize
+
+	// Calculate average FPS from stored intervals
+	var totalInterval time.Duration
+	validSamples := 0
+
+	for _, interval := range g.frameTimeBuffer {
+		if interval > 0 {
+			totalInterval += interval
+			validSamples++
+		}
+	}
+
+	if validSamples == 0 {
+		return 0
+	}
+
+	avgInterval := totalInterval / time.Duration(validSamples)
+	if avgInterval == 0 {
+		return 0
+	}
+
+	return float64(time.Second) / float64(avgInterval)
+}
+
+// Get enhanced FPS information from SPS with fallback
 func (g *Golibrtsp) getEnhancedFPS(sps *h264.SPS, streamIndex int8) float64 {
-	// First try to get FPS from SPS VUI parameters
+	// First try to get FPS from SPS
 	spsFPS := sps.FPS()
 
 	// Check if SPS FPS is reasonable (between 1 and 120 fps)
@@ -1334,13 +1244,11 @@ func (g *Golibrtsp) getEnhancedFPS(sps *h264.SPS, streamIndex int8) float64 {
 		return spsFPS
 	}
 
-	// Fallback to PTS-based FPS (already calculated per-frame)
-	if ft := g.fpsTrackers[streamIndex]; ft != nil {
-		ptsFPS := ft.fps()
-		if ptsFPS > 0 && ptsFPS <= 120 {
-			log.Log.Debug(fmt.Sprintf("capture.golibrtsp.getEnhancedFPS(): PTS FPS: %.2f", ptsFPS))
-			return ptsFPS
-		}
+	// Fallback to timestamp-based calculation
+	timestampFPS := g.calculateFPSFromTimestamps()
+	if timestampFPS > 0 && timestampFPS <= 120 {
+		log.Log.Debug(fmt.Sprintf("capture.golibrtsp.getEnhancedFPS(): Timestamp FPS: %.2f", timestampFPS))
+		return timestampFPS
 	}
 
 	// Return SPS FPS even if it seems unreasonable, or default

machinery/src/capture/main.go

@@ -159,19 +159,6 @@ func HandleRecordStream(queue *packets.Queue, configDirectory string, configurat
 					}
 
 					// Close mp4
-					if len(mp4Video.SPSNALUs) == 0 && len(configuration.Config.Capture.IPCamera.SPSNALUs) > 0 {
-						mp4Video.SPSNALUs = configuration.Config.Capture.IPCamera.SPSNALUs
-					}
-					if len(mp4Video.PPSNALUs) == 0 && len(configuration.Config.Capture.IPCamera.PPSNALUs) > 0 {
-						mp4Video.PPSNALUs = configuration.Config.Capture.IPCamera.PPSNALUs
-					}
-					if len(mp4Video.VPSNALUs) == 0 && len(configuration.Config.Capture.IPCamera.VPSNALUs) > 0 {
-						mp4Video.VPSNALUs = configuration.Config.Capture.IPCamera.VPSNALUs
-					}
-					if (videoCodec == "H264" && (len(mp4Video.SPSNALUs) == 0 || len(mp4Video.PPSNALUs) == 0)) ||
-						(videoCodec == "H265" && (len(mp4Video.VPSNALUs) == 0 || len(mp4Video.SPSNALUs) == 0 || len(mp4Video.PPSNALUs) == 0)) {
-						log.Log.Warning("capture.main.HandleRecordStream(continuous): closing MP4 without full parameter sets, moov may be incomplete")
-					}
 					mp4Video.Close(&config)
 					log.Log.Info("capture.main.HandleRecordStream(continuous): recording finished: file save: " + name)
 
@@ -292,11 +279,8 @@ func HandleRecordStream(queue *packets.Queue, configDirectory string, configurat
 					ppsNALUS := configuration.Config.Capture.IPCamera.PPSNALUs
 					vpsNALUS := configuration.Config.Capture.IPCamera.VPSNALUs
 
-					if len(spsNALUS) == 0 || len(ppsNALUS) == 0 {
-						log.Log.Warning("capture.main.HandleRecordStream(continuous): missing SPS/PPS at recording start")
-					}
 					// Create a video file, and set the dimensions.
-					mp4Video = video.NewMP4(fullName, spsNALUS, ppsNALUS, vpsNALUS, configuration.Config.Capture.MaxLengthRecording)
+					mp4Video = video.NewMP4(fullName, spsNALUS, ppsNALUS, vpsNALUS)
 					mp4Video.SetWidth(width)
 					mp4Video.SetHeight(height)
 
@@ -515,11 +499,21 @@ func HandleRecordStream(queue *packets.Queue, configDirectory string, configurat
 				ppsNALUS := configuration.Config.Capture.IPCamera.PPSNALUs
 				vpsNALUS := configuration.Config.Capture.IPCamera.VPSNALUs
 
-				if len(spsNALUS) == 0 || len(ppsNALUS) == 0 {
-					log.Log.Warning("capture.main.HandleRecordStream(motiondetection): missing SPS/PPS at recording start")
+				// Create a video file, and set the dimensions.
+				mp4Video := video.NewMP4(fullName, spsNALUS, ppsNALUS, vpsNALUS)
+				mp4Video.SetWidth(width)
+				mp4Video.SetHeight(height)
+
+				if videoCodec == "H264" {
+					videoTrack = mp4Video.AddVideoTrack("H264")
+				} else if videoCodec == "H265" {
+					videoTrack = mp4Video.AddVideoTrack("H265")
+				}
+				if audioCodec == "AAC" {
+					audioTrack = mp4Video.AddAudioTrack("AAC")
+				} else if audioCodec == "PCM_MULAW" {
+					log.Log.Debug("capture.main.HandleRecordStream(continuous): no AAC audio codec detected, skipping audio track.")
 				}
-				// Create the MP4 only once the first keyframe arrives.
-				var mp4Video *video.MP4
 
 				for cursorError == nil {
 
@@ -538,7 +532,7 @@ func HandleRecordStream(queue *packets.Queue, configDirectory string, configurat
 					default:
 					}
 
-					if start && (motionTimestamp+postRecording-now < 0 || now-startRecording > maxRecordingPeriod-500) && nextPkt.IsKeyFrame {
+					if (motionTimestamp+postRecording-now < 0 || now-startRecording > maxRecordingPeriod-500) && nextPkt.IsKeyFrame {
 						log.Log.Info("capture.main.HandleRecordStream(motiondetection): timestamp+postRecording-now < 0  - " + strconv.FormatInt(motionTimestamp+postRecording-now, 10) + " < 0")
 						log.Log.Info("capture.main.HandleRecordStream(motiondetection): now-startRecording > maxRecordingPeriod-500 - " + strconv.FormatInt(now-startRecording, 10) + " > " + strconv.FormatInt(maxRecordingPeriod-500, 10))
 						log.Log.Info("capture.main.HandleRecordStream(motiondetection): closing recording (timestamp: " + strconv.FormatInt(motionTimestamp, 10) + ", postRecording: " + strconv.FormatInt(postRecording, 10) + ", now: " + strconv.FormatInt(now, 10) + ", startRecording: " + strconv.FormatInt(startRecording, 10) + ", maxRecordingPeriod: " + strconv.FormatInt(maxRecordingPeriod, 10))
@@ -548,44 +542,20 @@ func HandleRecordStream(queue *packets.Queue, configDirectory string, configurat
 						// We start the recording if we have a keyframe and the last duration is 0 or less than the current packet time.
 						// It could be start we start from the beginning of the recording.
 						log.Log.Debug("capture.main.HandleRecordStream(motiondetection): write frames")
-						log.Log.Debug("capture.main.HandleRecordStream(motiondetection): recording started on keyframe")
-
-						// Align duration timers with the first keyframe.
-						startRecording = pkt.CurrentTime
-
-						// Create a video file, and set the dimensions.
-						mp4Video = video.NewMP4(fullName, spsNALUS, ppsNALUS, vpsNALUS, configuration.Config.Capture.MaxLengthRecording)
-						mp4Video.SetWidth(width)
-						mp4Video.SetHeight(height)
-
-						if videoCodec == "H264" {
-							videoTrack = mp4Video.AddVideoTrack("H264")
-						} else if videoCodec == "H265" {
-							videoTrack = mp4Video.AddVideoTrack("H265")
-						}
-						if audioCodec == "AAC" {
-							audioTrack = mp4Video.AddAudioTrack("AAC")
-						} else if audioCodec == "PCM_MULAW" {
-							log.Log.Debug("capture.main.HandleRecordStream(continuous): no AAC audio codec detected, skipping audio track.")
-						}
 						start = true
 					}
 					if start {
 						pts := convertPTS(pkt.TimeLegacy)
 						if pkt.IsVideo {
 							log.Log.Debug("capture.main.HandleRecordStream(motiondetection): add video sample")
-							if mp4Video != nil {
-								if err := mp4Video.AddSampleToTrack(videoTrack, pkt.IsKeyFrame, pkt.Data, pts); err != nil {
-									log.Log.Error("capture.main.HandleRecordStream(motiondetection): " + err.Error())
-								}
+							if err := mp4Video.AddSampleToTrack(videoTrack, pkt.IsKeyFrame, pkt.Data, pts); err != nil {
+								log.Log.Error("capture.main.HandleRecordStream(motiondetection): " + err.Error())
 							}
 						} else if pkt.IsAudio {
 							log.Log.Debug("capture.main.HandleRecordStream(motiondetection): add audio sample")
 							if pkt.Codec == "AAC" {
-								if mp4Video != nil {
-									if err := mp4Video.AddSampleToTrack(audioTrack, pkt.IsKeyFrame, pkt.Data, pts); err != nil {
-										log.Log.Error("capture.main.HandleRecordStream(motiondetection): " + err.Error())
-									}
+								if err := mp4Video.AddSampleToTrack(audioTrack, pkt.IsKeyFrame, pkt.Data, pts); err != nil {
+									log.Log.Error("capture.main.HandleRecordStream(motiondetection): " + err.Error())
 								}
 							} else if pkt.Codec == "PCM_MULAW" {
 								// TODO: transcode to AAC, some work to do..
@@ -603,25 +573,7 @@ func HandleRecordStream(queue *packets.Queue, configDirectory string, configurat
 				// This is used to determine if we need to start a new recording.
 				lastRecordingTime = pkt.CurrentTime
 
-				if mp4Video == nil {
-					log.Log.Warning("capture.main.HandleRecordStream(motiondetection): recording closed without keyframe; no MP4 created")
-					continue
-				}
-
 				// This will close the recording and write the last packet.
-				if len(mp4Video.SPSNALUs) == 0 && len(configuration.Config.Capture.IPCamera.SPSNALUs) > 0 {
-					mp4Video.SPSNALUs = configuration.Config.Capture.IPCamera.SPSNALUs
-				}
-				if len(mp4Video.PPSNALUs) == 0 && len(configuration.Config.Capture.IPCamera.PPSNALUs) > 0 {
-					mp4Video.PPSNALUs = configuration.Config.Capture.IPCamera.PPSNALUs
-				}
-				if len(mp4Video.VPSNALUs) == 0 && len(configuration.Config.Capture.IPCamera.VPSNALUs) > 0 {
-					mp4Video.VPSNALUs = configuration.Config.Capture.IPCamera.VPSNALUs
-				}
-				if (videoCodec == "H264" && (len(mp4Video.SPSNALUs) == 0 || len(mp4Video.PPSNALUs) == 0)) ||
-					(videoCodec == "H265" && (len(mp4Video.VPSNALUs) == 0 || len(mp4Video.SPSNALUs) == 0 || len(mp4Video.PPSNALUs) == 0)) {
-					log.Log.Warning("capture.main.HandleRecordStream(motiondetection): closing MP4 without full parameter sets, moov may be incomplete")
-				}
 				mp4Video.Close(&config)
 				log.Log.Info("capture.main.HandleRecordStream(motiondetection): file save: " + name)
 

machinery/src/cloud/Cloud.go

@@ -804,12 +804,6 @@ func HandleLiveStreamHD(livestreamCursor *packets.QueueCursor, configuration *mo
 			streams, _ := rtspClient.GetStreams()
 			videoTrack := webrtc.NewVideoTrack(streams)
 			audioTrack := webrtc.NewAudioTrack(streams)
-
-			if videoTrack == nil && audioTrack == nil {
-				log.Log.Error("cloud.HandleLiveStreamHD(): failed to create both video and audio tracks")
-				return
-			}
-
 			go webrtc.WriteToTrack(livestreamCursor, configuration, communication, mqttClient, videoTrack, audioTrack, rtspClient)
 
 			if config.Capture.ForwardWebRTC == "true" {

machinery/src/routers/http/routes.go

@@ -20,93 +20,96 @@ func AddRoutes(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware, configDirect
 
 	// This is legacy should be removed in future! Now everything
 	// lives under the /api prefix.
-	r.GET("/config", authMiddleware.MiddlewareFunc(), func(c *gin.Context) {
+	r.GET("/config", func(c *gin.Context) {
 		components.GetConfig(c, captureDevice, configuration, communication)
 	})
 
 	// This is legacy should be removed in future! Now everything
 	// lives under the /api prefix.
-	r.POST("/config", authMiddleware.MiddlewareFunc(), func(c *gin.Context) {
+	r.POST("/config", func(c *gin.Context) {
 		components.UpdateConfig(c, configDirectory, configuration, communication)
 	})
 
 	api := r.Group("/api")
 	{
-		// Public endpoints (no authentication required)
 		api.POST("/login", authMiddleware.LoginHandler)
 
-		// Apply JWT authentication middleware.
-		// All routes registered below this line require a valid JWT token.
+		api.GET("/dashboard", func(c *gin.Context) {
+			components.GetDashboard(c, configDirectory, configuration, communication)
+		})
+
+		api.POST("/latest-events", func(c *gin.Context) {
+			components.GetLatestEvents(c, configDirectory, configuration, communication)
+		})
+
+		api.GET("/days", func(c *gin.Context) {
+			components.GetDays(c, configDirectory, configuration, communication)
+		})
+
+		api.GET("/config", func(c *gin.Context) {
+			components.GetConfig(c, captureDevice, configuration, communication)
+		})
+
+		api.POST("/config", func(c *gin.Context) {
+			components.UpdateConfig(c, configDirectory, configuration, communication)
+		})
+
+		// Will verify the hub settings.
+		api.POST("/hub/verify", func(c *gin.Context) {
+			cloud.VerifyHub(c)
+		})
+
+		// Will verify the persistence settings.
+		api.POST("/persistence/verify", func(c *gin.Context) {
+			cloud.VerifyPersistence(c, configDirectory)
+		})
+
+		// Will verify the secondary persistence settings.
+		api.POST("/persistence/secondary/verify", func(c *gin.Context) {
+			cloud.VerifySecondaryPersistence(c, configDirectory)
+		})
+
+		// Camera specific methods. Doesn't require any authorization.
+		// These are available for anyone, but require the agent, to reach
+		// the camera.
+
+		api.POST("/camera/restart", func(c *gin.Context) {
+			components.RestartAgent(c, communication)
+		})
+
+		api.POST("/camera/stop", func(c *gin.Context) {
+			components.StopAgent(c, communication)
+		})
+
+		api.POST("/camera/record", func(c *gin.Context) {
+			components.MakeRecording(c, communication)
+		})
+
+		api.GET("/camera/snapshot/jpeg", func(c *gin.Context) {
+			components.GetSnapshotRaw(c, captureDevice, configuration, communication)
+		})
+
+		api.GET("/camera/snapshot/base64", func(c *gin.Context) {
+			components.GetSnapshotBase64(c, captureDevice, configuration, communication)
+		})
+
+		// Onvif specific methods. Doesn't require any authorization.
+		// Will verify the current onvif settings.
+		api.POST("/camera/onvif/verify", onvif.VerifyOnvifConnection)
+		api.POST("/camera/onvif/login", LoginToOnvif)
+		api.POST("/camera/onvif/capabilities", GetOnvifCapabilities)
+		api.POST("/camera/onvif/presets", GetOnvifPresets)
+		api.POST("/camera/onvif/gotopreset", GoToOnvifPreset)
+		api.POST("/camera/onvif/pantilt", DoOnvifPanTilt)
+		api.POST("/camera/onvif/zoom", DoOnvifZoom)
+		api.POST("/camera/onvif/inputs", DoGetDigitalInputs)
+		api.POST("/camera/onvif/outputs", DoGetRelayOutputs)
+		api.POST("/camera/onvif/outputs/:output", DoTriggerRelayOutput)
+		api.POST("/camera/verify/:streamType", capture.VerifyCamera)
+
+		// Secured endpoints..
 		api.Use(authMiddleware.MiddlewareFunc())
 		{
-			api.GET("/dashboard", func(c *gin.Context) {
-				components.GetDashboard(c, configDirectory, configuration, communication)
-			})
-
-			api.POST("/latest-events", func(c *gin.Context) {
-				components.GetLatestEvents(c, configDirectory, configuration, communication)
-			})
-
-			api.GET("/days", func(c *gin.Context) {
-				components.GetDays(c, configDirectory, configuration, communication)
-			})
-
-			api.GET("/config", func(c *gin.Context) {
-				components.GetConfig(c, captureDevice, configuration, communication)
-			})
-
-			api.POST("/config", func(c *gin.Context) {
-				components.UpdateConfig(c, configDirectory, configuration, communication)
-			})
-
-			// Will verify the hub settings.
-			api.POST("/hub/verify", func(c *gin.Context) {
-				cloud.VerifyHub(c)
-			})
-
-			// Will verify the persistence settings.
-			api.POST("/persistence/verify", func(c *gin.Context) {
-				cloud.VerifyPersistence(c, configDirectory)
-			})
-
-			// Will verify the secondary persistence settings.
-			api.POST("/persistence/secondary/verify", func(c *gin.Context) {
-				cloud.VerifySecondaryPersistence(c, configDirectory)
-			})
-
-			// Camera specific methods.
-			api.POST("/camera/restart", func(c *gin.Context) {
-				components.RestartAgent(c, communication)
-			})
-
-			api.POST("/camera/stop", func(c *gin.Context) {
-				components.StopAgent(c, communication)
-			})
-
-			api.POST("/camera/record", func(c *gin.Context) {
-				components.MakeRecording(c, communication)
-			})
-
-			api.GET("/camera/snapshot/jpeg", func(c *gin.Context) {
-				components.GetSnapshotRaw(c, captureDevice, configuration, communication)
-			})
-
-			api.GET("/camera/snapshot/base64", func(c *gin.Context) {
-				components.GetSnapshotBase64(c, captureDevice, configuration, communication)
-			})
-
-			// Onvif specific methods.
-			api.POST("/camera/onvif/verify", onvif.VerifyOnvifConnection)
-			api.POST("/camera/onvif/login", LoginToOnvif)
-			api.POST("/camera/onvif/capabilities", GetOnvifCapabilities)
-			api.POST("/camera/onvif/presets", GetOnvifPresets)
-			api.POST("/camera/onvif/gotopreset", GoToOnvifPreset)
-			api.POST("/camera/onvif/pantilt", DoOnvifPanTilt)
-			api.POST("/camera/onvif/zoom", DoOnvifZoom)
-			api.POST("/camera/onvif/inputs", DoGetDigitalInputs)
-			api.POST("/camera/onvif/outputs", DoGetRelayOutputs)
-			api.POST("/camera/onvif/outputs/:output", DoTriggerRelayOutput)
-			api.POST("/camera/verify/:streamType", capture.VerifyCamera)
 		}
 	}
 	return api

machinery/src/routers/mqtt/main.go

@@ -90,31 +90,10 @@ func ConfigureMQTT(configDirectory string, configuration *models.Configuration,
 
 		// Some extra options to make sure the connection behaves
 		// properly. More information here: github.com/eclipse/paho.mqtt.golang.
-		opts.SetCleanSession(false)
-		opts.SetResumeSubs(true)
-		opts.SetStore(mqtt.NewMemoryStore())
+		opts.SetCleanSession(true)
 		opts.SetConnectRetry(true)
-		opts.SetAutoReconnect(true)
-		opts.SetConnectRetryInterval(5 * time.Second)
-		opts.SetMaxReconnectInterval(1 * time.Minute)
-		opts.SetKeepAlive(30 * time.Second)
-		opts.SetPingTimeout(10 * time.Second)
-		opts.SetWriteTimeout(10 * time.Second)
-		opts.SetOrderMatters(false)
+		//opts.SetAutoReconnect(true)
 		opts.SetConnectTimeout(30 * time.Second)
-		opts.SetConnectionLostHandler(func(client mqtt.Client, err error) {
-			if err != nil {
-				log.Log.Error("routers.mqtt.main.ConfigureMQTT(): MQTT connection lost: " + err.Error())
-			} else {
-				log.Log.Error("routers.mqtt.main.ConfigureMQTT(): MQTT connection lost")
-			}
-		})
-		opts.SetReconnectingHandler(func(client mqtt.Client, options *mqtt.ClientOptions) {
-			log.Log.Warning("routers.mqtt.main.ConfigureMQTT(): reconnecting to MQTT broker")
-		})
-		opts.SetOnConnectHandler(func(c mqtt.Client) {
-			log.Log.Info("routers.mqtt.main.ConfigureMQTT(): MQTT session is online")
-		})
 
 		hubKey := ""
 		// This is the old way ;)
@@ -144,6 +123,7 @@ func ConfigureMQTT(configDirectory string, configuration *models.Configuration,
 			opts.SetClientID(mqttClientID)
 			log.Log.Info("routers.mqtt.main.ConfigureMQTT(): Set ClientID " + mqttClientID)
 			rand.Seed(time.Now().UnixNano())
+			webrtc.CandidateArrays = make(map[string](chan string))
 
 			opts.OnConnect = func(c mqtt.Client) {
 				// We managed to connect to the MQTT broker, hurray!
@@ -154,14 +134,10 @@ func ConfigureMQTT(configDirectory string, configuration *models.Configuration,
 			}
 		}
 		mqc := mqtt.NewClient(opts)
-		if token := mqc.Connect(); token.WaitTimeout(30 * time.Second) {
+		if token := mqc.Connect(); token.WaitTimeout(3 * time.Second) {
 			if token.Error() != nil {
 				log.Log.Error("routers.mqtt.main.ConfigureMQTT(): unable to establish mqtt broker connection, error was: " + token.Error().Error())
-			} else {
-				log.Log.Info("routers.mqtt.main.ConfigureMQTT(): initial MQTT connection established")
 			}
-		} else {
-			log.Log.Error("routers.mqtt.main.ConfigureMQTT(): timed out while establishing mqtt broker connection")
 		}
 		return mqc
 	}
@@ -174,7 +150,7 @@ func MQTTListenerHandler(mqttClient mqtt.Client, hubKey string, configDirectory
 		log.Log.Info("routers.mqtt.main.MQTTListenerHandler(): no hub key provided, not subscribing to kerberos/hub/{hubkey}")
 	} else {
 		agentListener := fmt.Sprintf("kerberos/agent/%s", hubKey)
-		token := mqttClient.Subscribe(agentListener, 1, func(c mqtt.Client, msg mqtt.Message) {
+		mqttClient.Subscribe(agentListener, 1, func(c mqtt.Client, msg mqtt.Message) {
 
 			// Decode the message, we are expecting following format.
 			// {
@@ -301,16 +277,6 @@ func MQTTListenerHandler(mqttClient mqtt.Client, hubKey string, configDirectory
 
 			}
 		})
-
-		if token.WaitTimeout(10 * time.Second) {
-			if token.Error() != nil {
-				log.Log.Error("routers.mqtt.main.MQTTListenerHandler(): failed to subscribe to " + agentListener + ": " + token.Error().Error())
-			} else {
-				log.Log.Info("routers.mqtt.main.MQTTListenerHandler(): subscribed to " + agentListener)
-			}
-		} else {
-			log.Log.Error("routers.mqtt.main.MQTTListenerHandler(): timed out while subscribing to " + agentListener)
-		}
 	}
 }
 

machinery/src/utils/main.go

@@ -25,10 +25,7 @@ import (
 	"github.com/nfnt/resize"
 )
 
-// VERSION is the agent version. It defaults to "0.0.0" for local dev builds
-// and is overridden at build time via:
-//   go build -ldflags "-X github.com/kerberos-io/agent/machinery/src/utils.VERSION=v1.2.3"
-var VERSION = "0.0.0"
+const VERSION = "3.5.0"
 
 const letterBytes = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 

machinery/src/video/mp4_duration_test.go

@@ -1,176 +0,0 @@
-package video
-
-import (
-	"fmt"
-	"os"
-	"testing"
-
-	mp4ff "github.com/Eyevinn/mp4ff/mp4"
-	"github.com/kerberos-io/agent/machinery/src/models"
-)
-
-// TestMP4Duration creates an MP4 file simulating a 5-second video recording
-// and verifies that the durations in all boxes match the sum of sample durations.
-func TestMP4Duration(t *testing.T) {
-	tmpFile := "/tmp/test_duration.mp4"
-	defer os.Remove(tmpFile)
-
-	// Minimal SPS for H.264 (baseline, 640x480) - proper Annex B format with start code
-	sps := []byte{0x67, 0x42, 0xc0, 0x1e, 0xd9, 0x00, 0xa0, 0x47, 0xfe, 0xc8}
-	pps := []byte{0x68, 0xce, 0x38, 0x80}
-
-	mp4Video := NewMP4(tmpFile, [][]byte{sps}, [][]byte{pps}, nil, 10)
-	mp4Video.SetWidth(640)
-	mp4Video.SetHeight(480)
-	videoTrack := mp4Video.AddVideoTrack("H264")
-
-	// Simulate 5 seconds at 25fps (200 frames, keyframe every 50 frames = 2s)
-	// PTS in milliseconds (timescale=1000)
-	frameDuration := uint64(40) // 40ms per frame = 25fps
-	numFrames := 150
-	gopSize := 50
-
-	// Create a fake Annex B NAL unit (keyframe IDR = type 5, non-keyframe = type 1)
-	makeFrame := func(isKey bool) []byte {
-		nalType := byte(0x01) // non-IDR slice
-		if isKey {
-			nalType = 0x65 // IDR slice
-		}
-		// Start code (4 bytes) + NAL header + some data
-		frame := []byte{0x00, 0x00, 0x00, 0x01, nalType}
-		// Add some padding data
-		for i := 0; i < 100; i++ {
-			frame = append(frame, byte(i))
-		}
-		return frame
-	}
-
-	var expectedDuration uint64
-	for i := 0; i < numFrames; i++ {
-		pts := uint64(i) * frameDuration
-		isKeyframe := i%gopSize == 0
-		err := mp4Video.AddSampleToTrack(videoTrack, isKeyframe, makeFrame(isKeyframe), pts)
-		if err != nil {
-			t.Fatalf("AddSampleToTrack failed at frame %d: %v", i, err)
-		}
-	}
-	expectedDuration = uint64(numFrames) * frameDuration // Should be 6000ms (150 * 40)
-
-	// Close with config that has signing key to avoid nil panics
-	config := &models.Config{
-		Signing: &models.Signing{
-			PrivateKey: "",
-		},
-	}
-	mp4Video.Close(config)
-
-	// Log what the code computed
-	t.Logf("VideoTotalDuration: %d ms", mp4Video.VideoTotalDuration)
-	t.Logf("Expected duration:  %d ms", expectedDuration)
-	t.Logf("Segments: %d", len(mp4Video.SegmentDurations))
-	var sumSegDur uint64
-	for i, d := range mp4Video.SegmentDurations {
-		t.Logf("  Segment %d: duration=%d ms", i, d)
-		sumSegDur += d
-	}
-	t.Logf("Sum of segment durations: %d ms", sumSegDur)
-
-	// Now read back the file and inspect the boxes
-	f, err := os.Open(tmpFile)
-	if err != nil {
-		t.Fatalf("Failed to open output file: %v", err)
-	}
-	defer f.Close()
-
-	fi, err := f.Stat()
-	if err != nil {
-		t.Fatalf("Failed to stat output file: %v", err)
-	}
-
-	parsedFile, err := mp4ff.DecodeFile(f)
-	if err != nil {
-		t.Fatalf("Failed to decode MP4: %v", err)
-	}
-
-	t.Logf("File size: %d bytes", fi.Size())
-
-	// Check moov box
-	if parsedFile.Moov == nil {
-		t.Fatal("No moov box found")
-	}
-
-	// Check mvhd duration
-	mvhd := parsedFile.Moov.Mvhd
-	t.Logf("mvhd.Duration:  %d (timescale=%d) = %.2f seconds", mvhd.Duration, mvhd.Timescale, float64(mvhd.Duration)/float64(mvhd.Timescale))
-	t.Logf("mvhd.Rate:      0x%08x", mvhd.Rate)
-	t.Logf("mvhd.Volume:    0x%04x", mvhd.Volume)
-
-	// Check each trak
-	for i, trak := range parsedFile.Moov.Traks {
-		t.Logf("Track %d:", i)
-		t.Logf("  tkhd.Duration: %d", trak.Tkhd.Duration)
-		t.Logf("  mdhd.Duration: %d (timescale=%d) = %.2f seconds", trak.Mdia.Mdhd.Duration, trak.Mdia.Mdhd.Timescale, float64(trak.Mdia.Mdhd.Duration)/float64(trak.Mdia.Mdhd.Timescale))
-	}
-
-	// Check mvex/mehd
-	if parsedFile.Moov.Mvex != nil && parsedFile.Moov.Mvex.Mehd != nil {
-		t.Logf("mehd.FragmentDuration: %d", parsedFile.Moov.Mvex.Mehd.FragmentDuration)
-	}
-
-	// Sum up actual sample durations from trun boxes in all segments
-	var actualTrunDuration uint64
-	var sampleCount int
-	for _, seg := range parsedFile.Segments {
-		for _, frag := range seg.Fragments {
-			for _, traf := range frag.Moof.Trafs {
-				// Only count video track (track 1)
-				if traf.Tfhd.TrackID == 1 {
-					for _, trun := range traf.Truns {
-						for _, s := range trun.Samples {
-							actualTrunDuration += uint64(s.Dur)
-							sampleCount++
-						}
-					}
-				}
-			}
-		}
-	}
-	t.Logf("Actual trun sample count: %d", sampleCount)
-	t.Logf("Actual trun total duration: %d ms", actualTrunDuration)
-
-	// Check sidx
-	if parsedFile.Sidx != nil {
-		var sidxDuration uint64
-		for _, ref := range parsedFile.Sidx.SidxRefs {
-			sidxDuration += uint64(ref.SubSegmentDuration)
-		}
-		t.Logf("sidx total duration: %d ms", sidxDuration)
-	}
-
-	// VERIFY: All duration values should be consistent
-	// The expected duration for 150 frames at 40ms each:
-	// - The sample-buffering pattern means the LAST sample uses LastVideoSampleDTS as duration
-	// - So all 150 samples should produce 150 * 40ms = 6000ms total
-	// But due to the pending sample pattern, the actual trun durations might differ
-
-	fmt.Println()
-	fmt.Println("=== DURATION CONSISTENCY CHECK ===")
-	fmt.Printf("Expected (150 * 40ms):      %d ms\n", expectedDuration)
-	fmt.Printf("mvhd.Duration:              %d ms\n", mvhd.Duration)
-	fmt.Printf("tkhd.Duration:              %d ms\n", parsedFile.Moov.Traks[0].Tkhd.Duration)
-	fmt.Printf("mdhd.Duration:              %d ms\n", parsedFile.Moov.Traks[0].Mdia.Mdhd.Duration)
-	fmt.Printf("Actual trun durations sum:  %d ms\n", actualTrunDuration)
-	fmt.Printf("VideoTotalDuration:         %d ms\n", mp4Video.VideoTotalDuration)
-	fmt.Printf("Sum of SegmentDurations:    %d ms\n", sumSegDur)
-	fmt.Println()
-
-	// The key assertion: header duration must equal trun sum
-	if mvhd.Duration != actualTrunDuration {
-		t.Errorf("MISMATCH: mvhd.Duration (%d) != actual trun sum (%d), diff = %d ms",
-			mvhd.Duration, actualTrunDuration, int64(mvhd.Duration)-int64(actualTrunDuration))
-	}
-	if parsedFile.Moov.Traks[0].Mdia.Mdhd.Duration != 0 {
-		t.Errorf("MISMATCH: mdhd.Duration should be 0 for fragmented MP4, got %d",
-			parsedFile.Moov.Traks[0].Mdia.Mdhd.Duration)
-	}
-}

ui/src/components/ImageCanvas/ImageCanvas.jsx

@@ -7,7 +7,6 @@ import './ImageCanvas.css';
 
 class ImageCanvas extends React.Component {
   componentDidMount() {
-    this.isUnmounted = false;
     this.width = 0;
     this.height = 0;
 
@@ -59,9 +58,6 @@ class ImageCanvas extends React.Component {
 
     const { image } = this.props;
     this.loadImage(image, (img) => {
-      if (this.isUnmounted || !this.editor) {
-        return;
-      }
       if (this.width !== img.width || this.height !== img.height) {
         this.width = img.width;
         this.height = img.height;
@@ -75,9 +71,6 @@ class ImageCanvas extends React.Component {
   componentDidUpdate() {
     const { image } = this.props;
     this.loadImage(image, (img) => {
-      if (this.isUnmounted || !this.editor) {
-        return;
-      }
       if (this.width !== img.width || this.height !== img.height) {
         this.width = img.width;
         this.height = img.height;
@@ -89,57 +82,11 @@ class ImageCanvas extends React.Component {
     });
   }
 
-  componentWillUnmount() {
-    this.isUnmounted = true;
-
-    if (this.pendingImage) {
-      this.pendingImage.onload = null;
-      this.pendingImage.src = '';
-      this.pendingImage = null;
-    }
-
-    if (this.editor) {
-      this.editor.onSelectionEnd = null;
-      this.editor.onRegionMoveEnd = null;
-      this.editor.onRegionDelete = null;
-
-      if (this.editor.RM) {
-        this.editor.RM.deleteAllRegions();
-      }
-
-      if (typeof this.editor.dispose === 'function') {
-        this.editor.dispose();
-      } else if (typeof this.editor.destroy === 'function') {
-        this.editor.destroy();
-      }
-
-      this.editor = null;
-    }
-
-    if (this.toolbarContainer) {
-      this.toolbarContainer.innerHTML = '';
-      this.toolbarContainer = null;
-    }
-
-    if (this.editorContainer) {
-      this.editorContainer.innerHTML = '';
-      this.editorContainer = null;
-    }
-  }
-
   loadData = (image) => {
-    if (!this.editor) {
-      return;
-    }
-
     const w = image.width;
     const h = image.height;
 
     this.editor.addContentSource(image).then(() => {
-      if (this.isUnmounted || !this.editor) {
-        return;
-      }
-
       // Add exisiting polygons
       this.editor.RM.deleteAllRegions();
       const { polygons } = this.props;
@@ -205,19 +152,11 @@ class ImageCanvas extends React.Component {
 
   // eslint-disable-next-line class-methods-use-this
   loadImage = (path, onready) => {
-    if (this.pendingImage) {
-      this.pendingImage.onload = null;
-    }
-
     const image = new Image();
-    this.pendingImage = image;
-    image.onload = (e) => {
-      if (this.pendingImage === image) {
-        this.pendingImage = null;
-      }
-      onready(e.target);
-    };
     image.src = path;
+    image.addEventListener('load', (e) => {
+      onready(e.target);
+    });
   };
 
   // eslint-disable-next-line class-methods-use-this

ui/src/pages/Dashboard/Dashboard.jsx

@@ -38,14 +38,16 @@ class Dashboard extends React.Component {
       initialised: false,
     };
     this.initialiseLiveview = this.initialiseLiveview.bind(this);
-    this.handleLiveviewLoad = this.handleLiveviewLoad.bind(this);
   }
 
   componentDidMount() {
     const liveview = document.getElementsByClassName('videocard-video');
     if (liveview && liveview.length > 0) {
-      [this.liveviewElement] = liveview;
-      this.liveviewElement.addEventListener('load', this.handleLiveviewLoad);
+      liveview[0].addEventListener('load', () => {
+        this.setState({
+          liveviewLoaded: true,
+        });
+      });
     }
     this.initialiseLiveview();
   }
@@ -55,14 +57,13 @@ class Dashboard extends React.Component {
   }
 
   componentWillUnmount() {
-    if (this.liveviewElement) {
-      this.liveviewElement.removeEventListener('load', this.handleLiveviewLoad);
-      this.liveviewElement = null;
+    const liveview = document.getElementsByClassName('videocard-video');
+    if (liveview && liveview.length > 0) {
+      liveview[0].remove();
     }
 
     if (this.requestStreamSubscription) {
       this.requestStreamSubscription.unsubscribe();
-      this.requestStreamSubscription = null;
     }
     const { dispatchSend } = this.props;
     const message = {
@@ -71,12 +72,6 @@ class Dashboard extends React.Component {
     dispatchSend(message);
   }
 
-  handleLiveviewLoad() {
-    this.setState({
-      liveviewLoaded: true,
-    });
-  }
-
   handleClose() {
     this.setState({
       open: false,

ui/src/pages/Settings/Settings.jsx

@@ -159,10 +159,7 @@ class Settings extends React.Component {
 
   componentWillUnmount() {
     document.removeEventListener('keydown', this.escFunction, false);
-    if (this.requestStreamSubscription) {
-      this.requestStreamSubscription.unsubscribe();
-      this.requestStreamSubscription = null;
-    }
+    clearInterval(this.interval);
 
     const { dispatchSend } = this.props;
     const message = {