Update Darwin build job to use macOS 13 for consistency

Update Darwin build job to use macOS 13 xlarge for improved performance
Replace manual Docker installation steps with setup action in Darwin build job
2026-11-10 21:00:49 +00:00 · 2025-09-12 11:24:02 +00:00 · 2025-09-12 11:23:20 +00:00 · 2025-09-12 11:21:50 +00:00 · 2025-09-12 11:19:52 +00:00 · 2025-09-12 11:18:29 +00:00
35 changed files with 991 additions and 3820 deletions
@@ -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)
@@ -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)
@@ -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
@@ -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 }}
@@ -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

@@ -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
@@ -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
@@ -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 && \
@@ -95,7 +96,7 @@ RUN addgroup -S kerberosio && adduser -S agent -G kerberosio && addgroup agent v
 COPY --chown=0:0 --from=build-machinery /dist /
 COPY --chown=0:0 --from=build-ui /dist /

-RUN apk update && apk add ca-certificates curl ffmpeg libstdc++ libc6-compat --no-cache && rm -rf /var/cache/apk/*
+RUN apk update && apk add ca-certificates curl libstdc++ libc6-compat --no-cache && rm -rf /var/cache/apk/*

 ##################
 # Try running agent
@@ -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 && \
@@ -95,7 +96,7 @@ RUN addgroup -S kerberosio && adduser -S agent -G kerberosio && addgroup agent v
 COPY --chown=0:0 --from=build-machinery /dist /
 COPY --chown=0:0 --from=build-ui /dist /

-RUN apk update && apk add ca-certificates curl ffmpeg libstdc++ libc6-compat --no-cache && rm -rf /var/cache/apk/*
+RUN apk update && apk add ca-certificates curl libstdc++ libc6-compat --no-cache && rm -rf /var/cache/apk/*

 ##################
 # Try running agent
@@ -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 :(")
 	}
 }
@@ -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
@@ -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)

@@ -800,19 +800,11 @@ func HandleLiveStreamHD(livestreamCursor *packets.QueueCursor, configuration *mo
 		// Check if we need to enable the live stream
 		if config.Capture.Liveview != "false" {

-			// Create per-peer broadcasters instead of shared tracks.
-			// Each viewer gets its own track with independent, non-blocking writes
-			// so a slow/congested peer cannot stall the others.
+			// Should create a track here.
 			streams, _ := rtspClient.GetStreams()
-			videoBroadcaster := webrtc.NewVideoBroadcaster(streams)
-			audioBroadcaster := webrtc.NewAudioBroadcaster(streams)
-
-			if videoBroadcaster == nil && audioBroadcaster == nil {
-				log.Log.Error("cloud.HandleLiveStreamHD(): failed to create both video and audio broadcasters")
-				return
-			}
-
-			go webrtc.WriteToTrack(livestreamCursor, configuration, communication, mqttClient, videoBroadcaster, audioBroadcaster, rtspClient)
+			videoTrack := webrtc.NewVideoTrack(streams)
+			audioTrack := webrtc.NewAudioTrack(streams)
+			go webrtc.WriteToTrack(livestreamCursor, configuration, communication, mqttClient, videoTrack, audioTrack, rtspClient)

 			if config.Capture.ForwardWebRTC == "true" {

@@ -820,7 +812,7 @@ func HandleLiveStreamHD(livestreamCursor *packets.QueueCursor, configuration *mo
 				log.Log.Info("cloud.HandleLiveStreamHD(): Waiting for peer connections.")
 				for handshake := range communication.HandleLiveHDHandshake {
 					log.Log.Info("cloud.HandleLiveStreamHD(): setting up a peer connection.")
-					go webrtc.InitializeWebRTCConnection(configuration, communication, mqttClient, videoBroadcaster, audioBroadcaster, handshake)
+					go webrtc.InitializeWebRTCConnection(configuration, communication, mqttClient, videoTrack, audioTrack, handshake)
 				}
 			}

@@ -21,7 +21,6 @@ import (
 	"github.com/kerberos-io/agent/machinery/src/packets"
 	routers "github.com/kerberos-io/agent/machinery/src/routers/mqtt"
 	"github.com/kerberos-io/agent/machinery/src/utils"
-	"github.com/kerberos-io/agent/machinery/src/webrtc"
 	"github.com/tevino/abool"
 )

@@ -304,7 +303,7 @@ func RunAgent(configDirectory string, configuration *models.Configuration, commu
 	}

 	// Handle livestream HD (high resolution over WEBRTC)
-	communication.HandleLiveHDHandshake = make(chan models.LiveHDHandshake, 100)
+	communication.HandleLiveHDHandshake = make(chan models.RequestHDStreamPayload, 10)
 	if subStreamEnabled {
 		livestreamHDCursor := subQueue.Latest()
 		go cloud.HandleLiveStreamHD(livestreamHDCursor, configuration, communication, mqttClient, rtspSubClient)
@@ -553,11 +552,6 @@ func GetDashboard(c *gin.Context, configDirectory string, configuration *models.
 	// The total number of recordings stored in the directory.
 	recordingDirectory := configDirectory + "/data/recordings"
 	numberOfRecordings := utils.NumberOfMP4sInDirectory(recordingDirectory)
-	activeWebRTCReaders := webrtc.GetActivePeerConnectionCount()
-	pendingWebRTCHandshakes := 0
-	if communication.HandleLiveHDHandshake != nil {
-		pendingWebRTCHandshakes = len(communication.HandleLiveHDHandshake)
-	}

 	// All days stored in this agent.
 	days := []string{}
@@ -580,8 +574,6 @@ func GetDashboard(c *gin.Context, configDirectory string, configuration *models.
 		"cameraOnline":       cameraIsOnline,
 		"cloudOnline":        cloudIsOnline,
 		"numberOfRecordings": numberOfRecordings,
-		"webrtcReaders":      activeWebRTCReaders,
-		"webrtcPending":      pendingWebRTCHandshakes,
 		"days":               days,
 		"latestEvents":       latestEvents,
 	})
@@ -8,17 +8,6 @@ import (
 	"github.com/tevino/abool"
 )

-type LiveHDSignalingCallbacks struct {
-	SendAnswer    func(sessionID string, sdp string) error
-	SendCandidate func(sessionID string, candidate string) error
-	SendError     func(sessionID string, message string) error
-}
-
-type LiveHDHandshake struct {
-	Payload   RequestHDStreamPayload
-	Signaling *LiveHDSignalingCallbacks
-}
-
 // The communication struct that is managing
 // all the communication between the different goroutines.
 type Communication struct {
@@ -38,7 +27,7 @@ type Communication struct {
 	HandleHeartBeat       chan string
 	HandleLiveSD          chan int64
 	HandleLiveHDKeepalive chan string
-	HandleLiveHDHandshake chan LiveHDHandshake
+	HandleLiveHDHandshake chan RequestHDStreamPayload
 	HandleLiveHDPeers     chan string
 	HandleONVIF           chan OnvifAction
 	IsConfiguring         *abool.AtomicBool
@@ -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
@@ -90,32 +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(true)
-		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 ;)
@@ -145,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!
@@ -155,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
 	}
@@ -170,18 +145,12 @@ func ConfigureMQTT(configDirectory string, configuration *models.Configuration,
 	return nil
 }

-// maxSignalingAge is the maximum age of a WebRTC signaling message (request-hd-stream,
-// receive-hd-candidates) before it is considered stale and discarded. With CleanSession=false
-// the MQTT broker may replay queued messages from previous sessions; this prevents the agent
-// from setting up peer connections for viewers that are no longer waiting.
-const maxSignalingAge = 30 * time.Second
-
 func MQTTListenerHandler(mqttClient mqtt.Client, hubKey string, configDirectory string, configuration *models.Configuration, communication *models.Communication) {
 	if hubKey == "" {
 		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.
 			// {
@@ -281,18 +250,6 @@ func MQTTListenerHandler(mqttClient mqtt.Client, hubKey string, configDirectory

 				// We'll find out which message we received, and act accordingly.
 				log.Log.Info("routers.mqtt.main.MQTTListenerHandler(): received message with action: " + payload.Action)
-
-				// For time-sensitive WebRTC signaling messages, discard stale ones that may
-				// have been queued by the broker while CleanSession=false.
-				if payload.Action == "request-hd-stream" || payload.Action == "receive-hd-candidates" {
-					messageAge := time.Since(time.Unix(message.Timestamp, 0))
-					if messageAge > maxSignalingAge {
-						log.Log.Info("routers.mqtt.main.MQTTListenerHandler(): discarding stale " + payload.Action +
-							" message (age: " + messageAge.Round(time.Second).String() + ")")
-						return
-					}
-				}
-
 				switch payload.Action {
 				case "record":
 					go HandleRecording(mqttClient, hubKey, payload, configuration, communication)
@@ -320,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)
-		}
 	}
 }

@@ -538,13 +485,9 @@ func HandleRequestHDStream(mqttClient mqtt.Client, hubKey string, payload models
 		if communication.CameraConnected {
 			// Set the Hub key, so we can send back the answer.
 			requestHDStreamPayload.HubKey = hubKey
-			if communication.HandleLiveHDHandshake == nil {
-				log.Log.Error("routers.mqtt.main.HandleRequestHDStream(): handshake channel is nil, dropping request")
-				return
-			}
-
-			communication.HandleLiveHDHandshake <- models.LiveHDHandshake{
-				Payload: requestHDStreamPayload,
+			select {
+			case communication.HandleLiveHDHandshake <- requestHDStreamPayload:
+			default:
 			}
 			log.Log.Info("routers.mqtt.main.HandleRequestHDStream(): received request to setup webrtc.")
 		} else {
@@ -6,7 +6,6 @@ import (
 	"image"
 	"net/http"
 	"sync"
-	"time"

 	"github.com/gin-gonic/gin"
 	"github.com/gorilla/websocket"
@@ -15,7 +14,6 @@ import (
 	"github.com/kerberos-io/agent/machinery/src/models"
 	"github.com/kerberos-io/agent/machinery/src/packets"
 	"github.com/kerberos-io/agent/machinery/src/utils"
-	"github.com/kerberos-io/agent/machinery/src/webrtc"
 )

 type Message struct {
@@ -30,23 +28,6 @@ type Connection struct {
 	Cancels map[string]context.CancelFunc
 }

-func writeWebRTCError(connection *Connection, clientID string, sessionID string, errorMessage string) {
-	if connection == nil {
-		return
-	}
-
-	if err := connection.WriteJson(Message{
-		ClientID:    clientID,
-		MessageType: "webrtc-error",
-		Message: map[string]string{
-			"session_id": sessionID,
-			"message":    errorMessage,
-		},
-	}); err != nil {
-		log.Log.Error("routers.websocket.main.writeWebRTCError(): " + err.Error())
-	}
-}
-
 // Concurrency handling - sending messages
 func (c *Connection) WriteJson(message Message) error {
 	c.mu.Lock()
@@ -134,82 +115,6 @@ func WebsocketHandler(c *gin.Context, configuration *models.Configuration, commu
 						go ForwardSDStream(ctx, clientID, sockets[clientID], configuration, communication, captureDevice)
 					}
 				}
-
-			case "stream-hd":
-				sessionID := message.Message["session_id"]
-				sessionDescription := message.Message["sdp"]
-
-				if sessionID == "" || sessionDescription == "" {
-					writeWebRTCError(sockets[clientID], clientID, sessionID, "missing session_id or sdp")
-					break
-				}
-
-				if !communication.CameraConnected {
-					writeWebRTCError(sockets[clientID], clientID, sessionID, "camera is not connected")
-					break
-				}
-
-				if communication.HandleLiveHDHandshake == nil {
-					writeWebRTCError(sockets[clientID], clientID, sessionID, "webrtc liveview is not available")
-					break
-				}
-
-				handshake := models.LiveHDHandshake{
-					Payload: models.RequestHDStreamPayload{
-						Timestamp:          time.Now().Unix(),
-						SessionID:          sessionID,
-						SessionDescription: sessionDescription,
-					},
-					Signaling: &models.LiveHDSignalingCallbacks{
-						SendAnswer: func(callbackSessionID string, sdp string) error {
-							return sockets[clientID].WriteJson(Message{
-								ClientID:    clientID,
-								MessageType: "webrtc-answer",
-								Message: map[string]string{
-									"session_id": callbackSessionID,
-									"sdp":        sdp,
-								},
-							})
-						},
-						SendCandidate: func(callbackSessionID string, candidate string) error {
-							return sockets[clientID].WriteJson(Message{
-								ClientID:    clientID,
-								MessageType: "webrtc-candidate",
-								Message: map[string]string{
-									"session_id": callbackSessionID,
-									"candidate":  candidate,
-								},
-							})
-						},
-						SendError: func(callbackSessionID string, errorMessage string) error {
-							writeWebRTCError(sockets[clientID], clientID, callbackSessionID, errorMessage)
-							return nil
-						},
-					},
-				}
-
-				communication.HandleLiveHDHandshake <- handshake
-
-			case "webrtc-candidate":
-				sessionID := message.Message["session_id"]
-				candidate := message.Message["candidate"]
-
-				if sessionID == "" || candidate == "" {
-					writeWebRTCError(sockets[clientID], clientID, sessionID, "missing session_id or candidate")
-					break
-				}
-
-				if !communication.CameraConnected {
-					writeWebRTCError(sockets[clientID], clientID, sessionID, "camera is not connected")
-					break
-				}
-
-				key := configuration.Config.Key + "/" + sessionID
-				go webrtc.RegisterCandidates(key, models.ReceiveHDCandidatesPayload{
-					Timestamp: time.Now().Unix(),
-					SessionID: sessionID,
-					Candidate: candidate,
-				})
 			}

 			err = conn.ReadJSON(&message)
@@ -25,11 +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"

@@ -199,13 +195,6 @@ func GetMediaFormatted(files []os.FileInfo, recordingDirectory string, configura
 			timestampInt, err := strconv.ParseInt(timestamp, 10, 64)
 			if err == nil {

-				if eventFilter.TimestampOffsetStart > 0 {
-					// TimestampOffsetStart represents the newest lower bound to include.
-					if timestampInt < eventFilter.TimestampOffsetStart {
-						continue
-					}
-				}
-
 				// If we have an offset we will check if we should skip or not
 				if eventFilter.TimestampOffsetEnd > 0 {
 					// Medias are sorted from new to older. TimestampOffsetEnd holds the oldest
@@ -1,54 +0,0 @@
-package utils
-
-import (
-	"os"
-	"testing"
-	"time"
-
-	"github.com/kerberos-io/agent/machinery/src/models"
-)
-
-type stubFileInfo struct {
-	name string
-}
-
-func (s stubFileInfo) Name() string       { return s.name }
-func (s stubFileInfo) Size() int64        { return 0 }
-func (s stubFileInfo) Mode() os.FileMode  { return 0 }
-func (s stubFileInfo) ModTime() time.Time { return time.Unix(0, 0) }
-func (s stubFileInfo) IsDir() bool        { return false }
-func (s stubFileInfo) Sys() interface{}   { return nil }
-
-func TestGetMediaFormattedHonorsTimestampRange(t *testing.T) {
-	configuration := &models.Configuration{}
-	configuration.Config.Timezone = "UTC"
-	configuration.Config.Name = "Front Door"
-	configuration.Config.Key = "camera-1"
-
-	files := []os.FileInfo{
-		stubFileInfo{name: "1700000200_6_7_8_9_10.mp4"},
-		stubFileInfo{name: "1700000100_6_7_8_9_10.mp4"},
-		stubFileInfo{name: "1700000000_6_7_8_9_10.mp4"},
-	}
-
-	media := GetMediaFormatted(files, "/tmp/recordings", configuration, models.EventFilter{
-		TimestampOffsetStart: 1700000050,
-		TimestampOffsetEnd:   1700000200,
-		NumberOfElements:     10,
-	})
-
-	if len(media) != 1 {
-		t.Fatalf("expected 1 media item in time range, got %d", len(media))
-	}
-
-	if media[0].Timestamp != "1700000100" {
-		t.Fatalf("expected timestamp 1700000100, got %s", media[0].Timestamp)
-	}
-
-	if media[0].CameraName != "Front Door" {
-		t.Fatalf("expected camera name to be preserved, got %s", media[0].CameraName)
-	}
-	if media[0].CameraKey != "camera-1" {
-		t.Fatalf("expected camera key to be preserved, got %s", media[0].CameraKey)
-	}
-}
@@ -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)
-	}
-}
@@ -1,270 +0,0 @@
-// AAC to G.711 µ-law transcoder using FFmpeg (libavcodec + libswresample).
-// Build with:  go build -tags ffmpeg ...
-//
-// Requires:  libavcodec-dev, libavutil-dev, libswresample-dev  (FFmpeg ≥ 5.x)
-// and an AAC decoder compiled into the FFmpeg build (usually the default).
-//
-//go:build ffmpeg
-
-package webrtc
-
-/*
-#cgo pkg-config: libavcodec libavutil libswresample
-#cgo CFLAGS: -Wno-deprecated-declarations
-
-#include <libavcodec/avcodec.h>
-#include <libavutil/channel_layout.h>
-#include <libavutil/frame.h>
-#include <libavutil/mem.h>
-#include <libavutil/opt.h>
-#include <libswresample/swresample.h>
-#include <stdlib.h>
-#include <string.h>
-
-// ── Transcoder handle ───────────────────────────────────────────────────
-
-typedef struct {
-    AVCodecContext       *codec_ctx;
-    AVCodecParserContext *parser;
-    SwrContext           *swr_ctx;
-    AVFrame              *frame;
-    AVPacket             *pkt;
-    int                   swr_initialized;
-    int                   in_sample_rate;
-    int                   in_channels;
-} aac_transcoder_t;
-
-// ── Create / Destroy ────────────────────────────────────────────────────
-
-static aac_transcoder_t* aac_transcoder_create(void) {
-    const AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_AAC);
-    if (!codec) return NULL;
-
-    aac_transcoder_t *t = (aac_transcoder_t*)calloc(1, sizeof(aac_transcoder_t));
-    if (!t) return NULL;
-
-    t->codec_ctx = avcodec_alloc_context3(codec);
-    if (!t->codec_ctx) { free(t); return NULL; }
-
-    if (avcodec_open2(t->codec_ctx, codec, NULL) < 0) {
-        avcodec_free_context(&t->codec_ctx);
-        free(t);
-        return NULL;
-    }
-
-    t->parser = av_parser_init(AV_CODEC_ID_AAC);
-    if (!t->parser) {
-        avcodec_free_context(&t->codec_ctx);
-        free(t);
-        return NULL;
-    }
-
-    t->frame = av_frame_alloc();
-    t->pkt   = av_packet_alloc();
-    if (!t->frame || !t->pkt) {
-        if (t->frame) av_frame_free(&t->frame);
-        if (t->pkt)   av_packet_free(&t->pkt);
-        av_parser_close(t->parser);
-        avcodec_free_context(&t->codec_ctx);
-        free(t);
-        return NULL;
-    }
-
-    return t;
-}
-
-static void aac_transcoder_destroy(aac_transcoder_t *t) {
-    if (!t) return;
-    if (t->swr_ctx)   swr_free(&t->swr_ctx);
-    if (t->frame)     av_frame_free(&t->frame);
-    if (t->pkt)       av_packet_free(&t->pkt);
-    if (t->parser)    av_parser_close(t->parser);
-    if (t->codec_ctx) avcodec_free_context(&t->codec_ctx);
-    free(t);
-}
-
-// ── Lazy resampler init (called after the first decoded frame) ──────────
-
-static int aac_init_swr(aac_transcoder_t *t) {
-    int64_t in_ch_layout = (int64_t)t->codec_ctx->channel_layout;
-    if (in_ch_layout == 0)
-        in_ch_layout = av_get_default_channel_layout(t->codec_ctx->channels);
-
-    t->swr_ctx = swr_alloc_set_opts(
-        NULL,
-        AV_CH_LAYOUT_MONO,                             // out: mono
-        AV_SAMPLE_FMT_S16,                             // out: signed 16-bit
-        8000,                                           // out: 8 kHz
-        in_ch_layout,                                   // in:  from decoder
-        t->codec_ctx->sample_fmt,                       // in:  from decoder
-        t->codec_ctx->sample_rate,                      // in:  from decoder
-        0, NULL);
-
-    if (!t->swr_ctx) return -1;
-    if (swr_init(t->swr_ctx) < 0) {
-        swr_free(&t->swr_ctx);
-        return -1;
-    }
-
-    t->in_sample_rate = t->codec_ctx->sample_rate;
-    t->in_channels    = t->codec_ctx->channels;
-    t->swr_initialized = 1;
-    return 0;
-}
-
-// ── Transcode ADTS → 8 kHz mono S16 PCM ────────────────────────────────
-// Caller must free *out_pcm with av_free() when non-NULL.
-
-static int aac_transcode_to_pcm(aac_transcoder_t *t,
-                                 const uint8_t *data, int data_size,
-                                 uint8_t **out_pcm, int *out_size) {
-    *out_pcm  = NULL;
-    *out_size = 0;
-    if (!data || data_size <= 0) return 0;
-
-    int buf_cap = 8192;
-    uint8_t *buf = (uint8_t*)av_malloc(buf_cap);
-    if (!buf) return -1;
-    int buf_len = 0;
-
-    while (data_size > 0) {
-        uint8_t *pout = NULL;
-        int      pout_size = 0;
-
-        int used = av_parser_parse2(t->parser, t->codec_ctx,
-                                    &pout, &pout_size,
-                                    data, data_size,
-                                    AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0);
-        if (used < 0) break;
-        data      += used;
-        data_size -= used;
-        if (pout_size == 0) continue;
-
-        // Feed parsed frame to decoder
-        t->pkt->data = pout;
-        t->pkt->size = pout_size;
-        if (avcodec_send_packet(t->codec_ctx, t->pkt) < 0) continue;
-
-        // Pull all decoded frames
-        while (avcodec_receive_frame(t->codec_ctx, t->frame) == 0) {
-            if (!t->swr_initialized) {
-                if (aac_init_swr(t) < 0) {
-                    av_frame_unref(t->frame);
-                    av_free(buf);
-                    return -1;
-                }
-            }
-
-            int out_samples = swr_get_out_samples(t->swr_ctx,
-                                                   t->frame->nb_samples);
-            if (out_samples <= 0) out_samples = t->frame->nb_samples;
-
-            int needed = buf_len + out_samples * 2; // S16 = 2 bytes/sample
-            if (needed > buf_cap) {
-                buf_cap = needed * 2;
-                uint8_t *tmp = (uint8_t*)av_realloc(buf, buf_cap);
-                if (!tmp) { av_frame_unref(t->frame); av_free(buf); return -1; }
-                buf = tmp;
-            }
-
-            uint8_t *dst = buf + buf_len;
-            int converted = swr_convert(t->swr_ctx,
-                                        &dst, out_samples,
-                                        (const uint8_t**)t->frame->extended_data,
-                                        t->frame->nb_samples);
-            if (converted > 0)
-                buf_len += converted * 2;
-
-            av_frame_unref(t->frame);
-        }
-    }
-
-    if (buf_len == 0) {
-        av_free(buf);
-        return 0;
-    }
-
-    *out_pcm  = buf;
-    *out_size = buf_len;
-    return 0;
-}
-*/
-import "C"
-
-import (
-	"errors"
-	"fmt"
-	"unsafe"
-
-	"github.com/kerberos-io/agent/machinery/src/log"
-	"github.com/zaf/g711"
-)
-
-// AACTranscodingAvailable reports whether AAC→PCMU transcoding
-// is compiled in (requires the "ffmpeg" build tag).
-func AACTranscodingAvailable() bool { return true }
-
-// AACTranscoder decodes ADTS-wrapped AAC audio to 8 kHz mono PCM
-// and encodes it as G.711 µ-law for WebRTC transport.
-type AACTranscoder struct {
-	handle *C.aac_transcoder_t
-}
-
-// NewAACTranscoder creates a transcoder backed by FFmpeg's AAC decoder.
-func NewAACTranscoder() (*AACTranscoder, error) {
-	h := C.aac_transcoder_create()
-	if h == nil {
-		return nil, errors.New("failed to create AAC transcoder (FFmpeg AAC decoder not available?)")
-	}
-	log.Log.Info("webrtc.aac_transcoder: AAC → G.711 µ-law transcoder initialised (FFmpeg)")
-	return &AACTranscoder{handle: h}, nil
-}
-
-// Transcode converts an ADTS buffer (one or more AAC frames) into
-// G.711 µ-law encoded audio suitable for a PCMU WebRTC track.
-func (t *AACTranscoder) Transcode(adtsData []byte) ([]byte, error) {
-	if t == nil || t.handle == nil || len(adtsData) == 0 {
-		return nil, nil
-	}
-
-	var outPCM *C.uint8_t
-	var outSize C.int
-
-	ret := C.aac_transcode_to_pcm(
-		t.handle,
-		(*C.uint8_t)(unsafe.Pointer(&adtsData[0])),
-		C.int(len(adtsData)),
-		&outPCM, &outSize,
-	)
-	if ret < 0 {
-		return nil, errors.New("AAC decode/resample failed")
-	}
-	if outSize == 0 || outPCM == nil {
-		return nil, nil // decoder buffering, no output yet
-	}
-	defer C.av_free(unsafe.Pointer(outPCM))
-
-	// Copy S16LE PCM to Go slice, then encode to µ-law.
-	pcm := C.GoBytes(unsafe.Pointer(outPCM), outSize)
-	ulaw := g711.EncodeUlaw(pcm)
-
-	// Log resampler details once.
-	if t.handle.swr_initialized == 1 && t.handle.in_sample_rate != 0 {
-		log.Log.Info(fmt.Sprintf(
-			"webrtc.aac_transcoder: first output – resampling %d Hz / %d ch → 8000 Hz mono → µ-law",
-			int(t.handle.in_sample_rate), int(t.handle.in_channels)))
-		// Prevent repeated logging by zeroing the field we check.
-		t.handle.in_sample_rate = 0
-	}
-
-	return ulaw, nil
-}
-
-// Close releases all FFmpeg resources held by the transcoder.
-func (t *AACTranscoder) Close() {
-	if t != nil && t.handle != nil {
-		C.aac_transcoder_destroy(t.handle)
-		t.handle = nil
-		log.Log.Info("webrtc.aac_transcoder: transcoder closed")
-	}
-}
@@ -1,205 +0,0 @@
-// AAC transcoding fallback that uses the ffmpeg binary at runtime.
-// Build with -tags ffmpeg to use the in-process CGO implementation instead.
-//
-//go:build !ffmpeg
-
-package webrtc
-
-import (
-	"bytes"
-	"errors"
-	"io"
-	"os/exec"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/kerberos-io/agent/machinery/src/log"
-)
-
-// AACTranscodingAvailable reports whether AAC→PCMU transcoding
-// is available in the current runtime.
-func AACTranscodingAvailable() bool {
-	_, err := exec.LookPath("ffmpeg")
-	return err == nil
-}
-
-// AACTranscoder uses an ffmpeg subprocess to convert ADTS AAC to raw PCMU.
-type AACTranscoder struct {
-	cmd       *exec.Cmd
-	stdin     io.WriteCloser
-	stdout    io.ReadCloser
-	stderrBuf bytes.Buffer
-
-	mu        sync.Mutex
-	outMu     sync.Mutex
-	outBuf    bytes.Buffer
-	closed    bool
-	closeOnce sync.Once
-}
-
-// NewAACTranscoder creates a runtime ffmpeg-based transcoder.
-func NewAACTranscoder() (*AACTranscoder, error) {
-	ffmpegPath, err := exec.LookPath("ffmpeg")
-	if err != nil {
-		return nil, errors.New("AAC transcoding not available: ffmpeg binary not found in PATH")
-	}
-	log.Log.Info("webrtc.aac_transcoder: using ffmpeg binary at " + ffmpegPath)
-
-	cmd := exec.Command(
-		ffmpegPath,
-		"-hide_banner",
-		"-loglevel", "error",
-		"-fflags", "+nobuffer",
-		"-flags", "low_delay",
-		"-f", "aac",
-		"-i", "pipe:0",
-		"-vn",
-		"-ac", "1",
-		"-ar", "8000",
-		"-acodec", "pcm_mulaw",
-		"-f", "mulaw",
-		"pipe:1",
-	)
-
-	stdin, err := cmd.StdinPipe()
-	if err != nil {
-		return nil, err
-	}
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		return nil, err
-	}
-	cmd.Stderr = &bytes.Buffer{}
-
-	if err := cmd.Start(); err != nil {
-		return nil, err
-	}
-
-	t := &AACTranscoder{
-		cmd:    cmd,
-		stdin:  stdin,
-		stdout: stdout,
-	}
-	if stderrBuf, ok := cmd.Stderr.(*bytes.Buffer); ok {
-		t.stderrBuf = *stderrBuf
-	}
-
-	go func() {
-		buf := make([]byte, 4096)
-		for {
-			n, readErr := stdout.Read(buf)
-			if n > 0 {
-				t.outMu.Lock()
-				_, _ = t.outBuf.Write(buf[:n])
-				buffered := t.outBuf.Len()
-				t.outMu.Unlock()
-				if buffered <= 8192 || buffered%16000 == 0 {
-					log.Log.Info("webrtc.aac_transcoder: ffmpeg produced PCMU bytes, buffered=" + strconv.Itoa(buffered))
-				}
-			}
-			if readErr != nil {
-				if readErr != io.EOF {
-					log.Log.Warning("webrtc.aac_transcoder: stdout reader stopped: " + readErr.Error())
-				}
-				return
-			}
-		}
-	}()
-
-	log.Log.Info("webrtc.aac_transcoder: AAC → PCMU transcoder initialised (ffmpeg process)")
-	return t, nil
-}
-
-// Transcode writes ADTS AAC to ffmpeg and returns any PCMU bytes produced.
-func (t *AACTranscoder) Transcode(adtsData []byte) ([]byte, error) {
-	if t == nil || len(adtsData) == 0 {
-		return nil, nil
-	}
-
-	t.mu.Lock()
-	defer t.mu.Unlock()
-
-	if t.closed {
-		return nil, errors.New("AAC transcoder is closed")
-	}
-
-	if _, err := t.stdin.Write(adtsData); err != nil {
-		return nil, err
-	}
-	if len(adtsData) <= 512 || len(adtsData)%1024 == 0 {
-		log.Log.Info("webrtc.aac_transcoder: wrote AAC bytes to ffmpeg, input=" + strconv.Itoa(len(adtsData)))
-	}
-
-	deadline := time.Now().Add(75 * time.Millisecond)
-	for {
-		data := t.readAvailable()
-		if len(data) > 0 {
-			log.Log.Info("webrtc.aac_transcoder: returning PCMU bytes=" + strconv.Itoa(len(data)))
-			return data, nil
-		}
-
-		if time.Now().After(deadline) {
-			if stderr := t.stderrString(); stderr != "" {
-				log.Log.Warning("webrtc.aac_transcoder: no output before deadline, ffmpeg stderr: " + stderr)
-			} else {
-				log.Log.Info("webrtc.aac_transcoder: no PCMU output before deadline")
-			}
-			return nil, nil
-		}
-		time.Sleep(5 * time.Millisecond)
-	}
-}
-
-func (t *AACTranscoder) readAvailable() []byte {
-	t.outMu.Lock()
-	defer t.outMu.Unlock()
-
-	if t.outBuf.Len() == 0 {
-		return nil
-	}
-
-	out := make([]byte, t.outBuf.Len())
-	copy(out, t.outBuf.Bytes())
-	t.outBuf.Reset()
-	return out
-}
-
-func (t *AACTranscoder) stderrString() string {
-	if t == nil {
-		return ""
-	}
-	if stderrBuf, ok := t.cmd.Stderr.(*bytes.Buffer); ok {
-		return strings.TrimSpace(stderrBuf.String())
-	}
-	return strings.TrimSpace(t.stderrBuf.String())
-}
-
-// Close stops the ffmpeg subprocess.
-func (t *AACTranscoder) Close() {
-	if t == nil {
-		return
-	}
-
-	t.closeOnce.Do(func() {
-		t.mu.Lock()
-		t.closed = true
-		if t.stdin != nil {
-			_ = t.stdin.Close()
-		}
-		t.mu.Unlock()
-
-		if t.stdout != nil {
-			_ = t.stdout.Close()
-		}
-
-		if t.cmd != nil {
-			_ = t.cmd.Process.Kill()
-			_, _ = t.cmd.Process.Wait()
-			if stderr := t.stderrString(); stderr != "" {
-				log.Log.Info("webrtc.aac_transcoder: ffmpeg stderr on close: " + stderr)
-			}
-		}
-	})
-}
@@ -1,137 +0,0 @@
-package webrtc
-
-import (
-	"io"
-	"sync"
-
-	"github.com/kerberos-io/agent/machinery/src/log"
-	pionWebRTC "github.com/pion/webrtc/v4"
-	pionMedia "github.com/pion/webrtc/v4/pkg/media"
-)
-
-const (
-	// peerSampleBuffer controls how many samples can be buffered per peer before
-	// dropping. Keeps slow peers from blocking the broadcaster.
-	peerSampleBuffer = 60
-)
-
-// peerTrack is a per-peer track with its own non-blocking sample channel.
-type peerTrack struct {
-	track   *pionWebRTC.TrackLocalStaticSample
-	samples chan pionMedia.Sample
-	done    chan struct{}
-}
-
-// TrackBroadcaster fans out media samples to multiple peer-specific tracks
-// without blocking. Each peer gets its own TrackLocalStaticSample and a
-// goroutine that drains samples independently, so a slow/congested peer
-// cannot stall the others.
-type TrackBroadcaster struct {
-	mu       sync.RWMutex
-	peers    map[string]*peerTrack
-	mimeType string
-	id       string
-	streamID string
-}
-
-// NewTrackBroadcaster creates a new broadcaster for either video or audio.
-func NewTrackBroadcaster(mimeType string, id string, streamID string) *TrackBroadcaster {
-	return &TrackBroadcaster{
-		peers:    make(map[string]*peerTrack),
-		mimeType: mimeType,
-		id:       id,
-		streamID: streamID,
-	}
-}
-
-// AddPeer creates a new per-peer track and starts a writer goroutine.
-// Returns the track to be added to the PeerConnection via AddTrack().
-func (b *TrackBroadcaster) AddPeer(sessionKey string) (*pionWebRTC.TrackLocalStaticSample, error) {
-	track, err := pionWebRTC.NewTrackLocalStaticSample(
-		pionWebRTC.RTPCodecCapability{MimeType: b.mimeType},
-		b.id,
-		b.streamID,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	pt := &peerTrack{
-		track:   track,
-		samples: make(chan pionMedia.Sample, peerSampleBuffer),
-		done:    make(chan struct{}),
-	}
-
-	b.mu.Lock()
-	b.peers[sessionKey] = pt
-	b.mu.Unlock()
-
-	// Per-peer writer goroutine — drains samples independently.
-	go func() {
-		defer close(pt.done)
-		for sample := range pt.samples {
-			if err := pt.track.WriteSample(sample); err != nil {
-				if err == io.ErrClosedPipe {
-					return
-				}
-				log.Log.Error("webrtc.broadcaster.peerWriter(): error writing sample for " + sessionKey + ": " + err.Error())
-			}
-		}
-	}()
-
-	log.Log.Info("webrtc.broadcaster.AddPeer(): added peer track for " + sessionKey)
-	return track, nil
-}
-
-// RemovePeer stops the writer goroutine and removes the peer.
-func (b *TrackBroadcaster) RemovePeer(sessionKey string) {
-	b.mu.Lock()
-	pt, exists := b.peers[sessionKey]
-	if exists {
-		delete(b.peers, sessionKey)
-	}
-	b.mu.Unlock()
-
-	if exists {
-		close(pt.samples)
-		<-pt.done // wait for writer goroutine to finish
-		log.Log.Info("webrtc.broadcaster.RemovePeer(): removed peer track for " + sessionKey)
-	}
-}
-
-// WriteSample fans out a sample to all connected peers without blocking.
-// If a peer's buffer is full (slow consumer), the sample is dropped for
-// that peer only — other peers are unaffected.
-func (b *TrackBroadcaster) WriteSample(sample pionMedia.Sample) {
-	b.mu.RLock()
-	defer b.mu.RUnlock()
-
-	for sessionKey, pt := range b.peers {
-		select {
-		case pt.samples <- sample:
-		default:
-			log.Log.Warning("webrtc.broadcaster.WriteSample(): dropping sample for slow peer " + sessionKey)
-		}
-	}
-}
-
-// PeerCount returns the current number of connected peers.
-func (b *TrackBroadcaster) PeerCount() int {
-	b.mu.RLock()
-	defer b.mu.RUnlock()
-	return len(b.peers)
-}
-
-// Close removes all peers and stops all writer goroutines.
-func (b *TrackBroadcaster) Close() {
-	b.mu.Lock()
-	keys := make([]string, 0, len(b.peers))
-	for k := range b.peers {
-		keys = append(keys, k)
-	}
-	b.mu.Unlock()
-
-	for _, key := range keys {
-		b.RemovePeer(key)
-	}
-}
@@ -45,9 +45,9 @@
    "crypto": false
  },
  "scripts": {
-    "start": "DISABLE_ESLINT_PLUGIN=true react-scripts start",
-    "build": "DISABLE_ESLINT_PLUGIN=true GENERATE_SOURCEMAP=false REACT_APP_ENVIRONMENT=production react-scripts build && rm -rf ../machinery/www && mv build ../machinery/www",
-    "test": "DISABLE_ESLINT_PLUGIN=true react-scripts test",
+    "start": "react-scripts start",
+    "build": "GENERATE_SOURCEMAP=false REACT_APP_ENVIRONMENT=production react-scripts build && rm -rf ../machinery/www && mv build ../machinery/www",
+    "test": "react-scripts test",
    "eject": "react-scripts eject",
    "lint": "eslint --debug 'src/**/*.{js,jsx,ts,tsx}'",
    "format": "prettier --write \"**/*.{js,jsx,json,md}\""
@@ -237,4 +237,4 @@
      "remove_after_upload_enabled": "Enable delete on upload"
    }
  }
-}
+}
@@ -194,7 +194,7 @@ export const getDashboardInformation = (onSuccess, onError) => {
  };
 };

-export const getEvents = (eventfilter, onSuccess, onError, append = false) => {
+export const getEvents = (eventfilter, onSuccess, onError) => {
  return (dispatch) => {
    doGetEvents(
      eventfilter,
@@ -203,7 +203,6 @@ export const getEvents = (eventfilter, onSuccess, onError, append = false) => {
          type: 'GET_EVENTS',
          events: data.events,
          filter: eventfilter,
-          append,
        });
        if (onSuccess) {
          onSuccess();
@@ -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
@@ -26,23 +26,6 @@ import {
 import './Dashboard.scss';
 import ReactTooltip from 'react-tooltip';
 import config from '../../config';
-import { getConfig } from '../../actions/agent';
-
-function createUUID() {
-  if (
-    typeof window !== 'undefined' &&
-    window.crypto &&
-    typeof window.crypto.randomUUID === 'function'
-  ) {
-    return window.crypto.randomUUID();
-  }
-
-  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (char) => {
-    const random = Math.floor(Math.random() * 16);
-    const value = char === 'x' ? random : 8 + Math.floor(random / 4);
-    return value.toString(16);
-  });
-}

 // eslint-disable-next-line react/prefer-stateless-function
 class Dashboard extends React.Component {
@@ -50,55 +33,43 @@ class Dashboard extends React.Component {
    super();
    this.state = {
      liveviewLoaded: false,
-      liveviewMode: 'webrtc',
      open: false,
      currentRecording: '',
      initialised: false,
    };
-    this.videoRef = React.createRef();
-    this.pendingRemoteCandidates = [];
    this.initialiseLiveview = this.initialiseLiveview.bind(this);
-    this.initialiseSDLiveview = this.initialiseSDLiveview.bind(this);
-    this.startWebRTCLiveview = this.startWebRTCLiveview.bind(this);
-    this.handleWebRTCSignalMessage = this.handleWebRTCSignalMessage.bind(this);
-    this.fallbackToSDLiveview = this.fallbackToSDLiveview.bind(this);
  }

  componentDidMount() {
-    const { dispatchGetConfig } = this.props;
-    dispatchGetConfig(() => this.initialiseLiveview());
+    const liveview = document.getElementsByClassName('videocard-video');
+    if (liveview && liveview.length > 0) {
+      liveview[0].addEventListener('load', () => {
+        this.setState({
+          liveviewLoaded: true,
+        });
+      });
+    }
    this.initialiseLiveview();
  }

-  componentDidUpdate(prevProps) {
-    const { images, dashboard } = this.props;
-    const { liveviewLoaded, liveviewMode } = this.state;
-    const configLoaded = this.hasAgentConfig(this.props);
-    const prevConfigLoaded = this.hasAgentConfig(prevProps);
-
-    if (!prevConfigLoaded && configLoaded) {
-      this.initialiseLiveview();
-    }
-
-    if (
-      liveviewMode === 'sd' &&
-      !liveviewLoaded &&
-      prevProps.images !== images &&
-      images.length > 0
-    ) {
-      this.setState({
-        liveviewLoaded: true,
-      });
-    }
-
-    if (!prevProps.dashboard.cameraOnline && dashboard.cameraOnline) {
-      this.initialiseLiveview();
-    }
+  componentDidUpdate() {
+    this.initialiseLiveview();
  }

  componentWillUnmount() {
-    this.stopSDLiveview();
-    this.stopWebRTCLiveview();
+    const liveview = document.getElementsByClassName('videocard-video');
+    if (liveview && liveview.length > 0) {
+      liveview[0].remove();
+    }
+
+    if (this.requestStreamSubscription) {
+      this.requestStreamSubscription.unsubscribe();
+    }
+    const { dispatchSend } = this.props;
+    const message = {
+      message_type: 'stop-sd',
+    };
+    dispatchSend(message);
  }

  handleClose() {
@@ -108,378 +79,32 @@ class Dashboard extends React.Component {
    });
  }

-  // eslint-disable-next-line react/sort-comp
-  hasAgentConfig(props) {
-    const currentProps = props || this.props;
-    const { config: configResponse } = currentProps;
-    return !!(configResponse && configResponse.config);
-  }
-
-  browserSupportsWebRTC() {
-    return (
-      typeof window !== 'undefined' &&
-      typeof window.RTCPeerConnection !== 'undefined'
-    );
-  }
-
-  buildPeerConnectionConfig() {
-    const { config: configResponse } = this.props;
-    const agentConfig =
-      configResponse && configResponse.config ? configResponse.config : {};
-    const iceServers = [];
-
-    if (agentConfig.stunuri) {
-      iceServers.push({
-        urls: [agentConfig.stunuri],
-      });
-    }
-
-    if (agentConfig.turnuri) {
-      const turnServer = {
-        urls: [agentConfig.turnuri],
-      };
-
-      if (agentConfig.turn_username) {
-        turnServer.username = agentConfig.turn_username;
-      }
-
-      if (agentConfig.turn_password) {
-        turnServer.credential = agentConfig.turn_password;
-      }
-
-      iceServers.push(turnServer);
-    }
-
-    return {
-      iceServers,
-      iceTransportPolicy: agentConfig.turn_force === 'true' ? 'relay' : 'all',
-    };
+  getCurrentTimestamp() {
+    return Math.round(Date.now() / 1000);
  }

  initialiseLiveview() {
    const { initialised } = this.state;
-    const { dashboard } = this.props;
-
-    if (initialised || !dashboard.cameraOnline) {
-      return;
-    }
-
-    if (!this.hasAgentConfig()) {
-      return;
-    }
-
-    if (this.browserSupportsWebRTC()) {
-      this.startWebRTCLiveview();
-    } else {
-      this.fallbackToSDLiveview('WebRTC is not supported in this browser.');
-    }
-  }
-
-  initialiseSDLiveview() {
-    if (this.requestStreamSubscription) {
-      return;
-    }
-
-    const message = {
-      message_type: 'stream-sd',
-    };
-    const { connected, dispatchSend } = this.props;
-    if (connected) {
-      dispatchSend(message);
-    }
-
-    const requestStreamInterval = interval(2000);
-    this.requestStreamSubscription = requestStreamInterval.subscribe(() => {
-      const { connected: isConnected } = this.props;
-      if (isConnected) {
+    if (!initialised) {
+      const message = {
+        message_type: 'stream-sd',
+      };
+      const { connected, dispatchSend } = this.props;
+      if (connected) {
        dispatchSend(message);
      }
-    });
-  }

-  stopSDLiveview() {
-    if (this.requestStreamSubscription) {
-      this.requestStreamSubscription.unsubscribe();
-      this.requestStreamSubscription = null;
-    }
-
-    const { dispatchSend } = this.props;
-    dispatchSend({
-      message_type: 'stop-sd',
-    });
-  }
-
-  stopWebRTCLiveview() {
-    if (this.webrtcTimeout) {
-      window.clearTimeout(this.webrtcTimeout);
-      this.webrtcTimeout = null;
-    }
-
-    if (this.webrtcSocket) {
-      this.webrtcSocket.onopen = null;
-      this.webrtcSocket.onmessage = null;
-      this.webrtcSocket.onerror = null;
-      this.webrtcSocket.onclose = null;
-      this.webrtcSocket.close();
-      this.webrtcSocket = null;
-    }
-
-    if (this.webrtcPeerConnection) {
-      this.webrtcPeerConnection.ontrack = null;
-      this.webrtcPeerConnection.onicecandidate = null;
-      this.webrtcPeerConnection.onconnectionstatechange = null;
-      this.webrtcPeerConnection.close();
-      this.webrtcPeerConnection = null;
-    }
-
-    this.pendingRemoteCandidates = [];
-    this.webrtcOfferStarted = false;
-    this.webrtcSessionId = null;
-    this.webrtcClientId = null;
-
-    if (this.videoRef.current) {
-      this.videoRef.current.srcObject = null;
-    }
-  }
-
-  sendWebRTCMessage(messageType, message = {}) {
-    if (!this.webrtcSocket || this.webrtcSocket.readyState !== WebSocket.OPEN) {
-      return;
-    }
-
-    this.webrtcSocket.send(
-      JSON.stringify({
-        client_id: this.webrtcClientId,
-        message_type: messageType,
-        message,
-      })
-    );
-  }
-
-  async handleWebRTCSignalMessage(event) {
-    let data;
-    try {
-      data = JSON.parse(event.data);
-    } catch (error) {
-      return;
-    }
-
-    const { message_type: messageType, message = {} } = data;
-    const { session_id: sessionID, sdp, candidate } = message;
-
-    if (messageType === 'hello-back') {
-      await this.beginWebRTCLiveview();
-      return;
-    }
-
-    if (sessionID && sessionID !== this.webrtcSessionId) {
-      return;
-    }
-
-    switch (messageType) {
-      case 'webrtc-answer':
-        try {
-          await this.webrtcPeerConnection.setRemoteDescription({
-            type: 'answer',
-            sdp: window.atob(sdp),
-          });
-          await this.flushPendingRemoteCandidates();
-        } catch (error) {
-          this.fallbackToSDLiveview(
-            `Unable to apply WebRTC answer: ${error.message}`
-          );
+      const requestStreamInterval = interval(2000);
+      this.requestStreamSubscription = requestStreamInterval.subscribe(() => {
+        const { connected: isConnected } = this.props;
+        if (isConnected) {
+          dispatchSend(message);
        }
-        break;
-
-      case 'webrtc-candidate': {
-        try {
-          const candidateInit = JSON.parse(candidate);
-          if (
-            this.webrtcPeerConnection.remoteDescription &&
-            this.webrtcPeerConnection.remoteDescription.type
-          ) {
-            await this.webrtcPeerConnection.addIceCandidate(candidateInit);
-          } else {
-            this.pendingRemoteCandidates.push(candidateInit);
-          }
-        } catch (error) {
-          this.fallbackToSDLiveview(
-            `Unable to apply WebRTC candidate: ${error.message}`
-          );
-        }
-        break;
-      }
-
-      case 'webrtc-error':
-        this.fallbackToSDLiveview(
-          message.message || 'The agent could not start the WebRTC liveview.'
-        );
-        break;
-
-      default:
-        break;
-    }
-  }
-
-  async beginWebRTCLiveview() {
-    if (!this.webrtcPeerConnection || this.webrtcOfferStarted) {
-      return;
-    }
-
-    try {
-      this.webrtcOfferStarted = true;
-      const offer = await this.webrtcPeerConnection.createOffer({
-        offerToReceiveAudio: true,
-        offerToReceiveVideo: true,
      });
-      await this.webrtcPeerConnection.setLocalDescription(offer);
-      this.sendWebRTCMessage('stream-hd', {
-        session_id: this.webrtcSessionId,
-        sdp: window.btoa(this.webrtcPeerConnection.localDescription.sdp),
-      });
-    } catch (error) {
-      this.fallbackToSDLiveview(
-        `Unable to initialise WebRTC liveview: ${error.message}`,
-      );
-    }
-  }
-
-  async flushPendingRemoteCandidates() {
-    if (
-      !this.webrtcPeerConnection ||
-      !this.webrtcPeerConnection.remoteDescription
-    ) {
-      return;
-    }
-
-    while (this.pendingRemoteCandidates.length > 0) {
-      const candidateInit = this.pendingRemoteCandidates.shift();
-      try {
-        // eslint-disable-next-line no-await-in-loop
-        await this.webrtcPeerConnection.addIceCandidate(candidateInit);
-      } catch (error) {
-        this.fallbackToSDLiveview(
-          `Unable to add remote ICE candidate: ${error.message}`,
-        );
-        return;
-      }
-    }
-  }
-
-  startWebRTCLiveview() {
-    if (this.webrtcPeerConnection || this.webrtcSocket) {
-      return;
-    }
-
-    this.stopSDLiveview();
-
-    this.webrtcClientId = createUUID();
-    this.webrtcSessionId = createUUID();
-    this.pendingRemoteCandidates = [];
-
-    this.webrtcPeerConnection = new window.RTCPeerConnection(
-      this.buildPeerConnectionConfig()
-    );
-
-    this.webrtcPeerConnection.ontrack = (event) => {
-      const [remoteStream] = event.streams;
-      if (this.videoRef.current && remoteStream) {
-        this.videoRef.current.srcObject = remoteStream;
-        const playPromise = this.videoRef.current.play();
-        if (playPromise && playPromise.catch) {
-          playPromise.catch(() => {});
-        }
-      }
-
      this.setState({
-        liveviewLoaded: true,
-      });
-    };
-
-    this.webrtcPeerConnection.onicecandidate = (event) => {
-      if (!event.candidate) {
-        return;
-      }
-
-      this.sendWebRTCMessage('webrtc-candidate', {
-        session_id: this.webrtcSessionId,
-        candidate: JSON.stringify(event.candidate.toJSON()),
-      });
-    };
-
-    this.webrtcPeerConnection.onconnectionstatechange = () => {
-      const { connectionState } = this.webrtcPeerConnection;
-      if (connectionState === 'connected') {
-        this.setState({
-          liveviewLoaded: true,
-        });
-      }
-
-      if (
-        connectionState === 'failed' ||
-        connectionState === 'disconnected' ||
-        connectionState === 'closed'
-      ) {
-        this.fallbackToSDLiveview(
-          `WebRTC connection ${connectionState}, falling back to SD liveview.`,
-        );
-      }
-    };
-
-    this.webrtcSocket = new WebSocket(config.WS_URL);
-    this.webrtcSocket.onopen = () => {
-      this.sendWebRTCMessage('hello', {});
-    };
-    this.webrtcSocket.onmessage = this.handleWebRTCSignalMessage;
-    this.webrtcSocket.onerror = () => {
-      this.fallbackToSDLiveview('Unable to open the WebRTC signaling channel.');
-    };
-    this.webrtcSocket.onclose = () => {
-      const { liveviewLoaded } = this.state;
-      if (!liveviewLoaded) {
-        this.fallbackToSDLiveview('WebRTC signaling channel closed early.');
-      }
-    };
-
-    this.webrtcTimeout = window.setTimeout(() => {
-      const { liveviewLoaded } = this.state;
-      if (!liveviewLoaded) {
-        this.fallbackToSDLiveview(
-          'WebRTC connection timed out, falling back to SD liveview.'
-        );
-      }
-    }, 10000);
-
-    this.setState({
-      initialised: true,
-      liveviewLoaded: false,
-      liveviewMode: 'webrtc',
-    });
-  }
-
-  fallbackToSDLiveview(errorMessage) {
-    const { liveviewMode } = this.state;
-
-    if (liveviewMode === 'sd' && this.requestStreamSubscription) {
-      return;
-    }
-
-    this.stopWebRTCLiveview();
-    if (errorMessage) {
-      // eslint-disable-next-line no-console
-      console.warn(errorMessage);
-    }
-
-    this.setState(
-      {
        initialised: true,
-        liveviewLoaded: false,
-        liveviewMode: 'sd',
-      },
-      () => {
-        this.initialiseSDLiveview();
-      }
-    );
+      });
+    }
  }

  openModal(file) {
@@ -491,8 +116,7 @@ class Dashboard extends React.Component {

  render() {
    const { dashboard, t, images } = this.props;
-    const { liveviewLoaded, liveviewMode, open, currentRecording } = this.state;
-    const listenerCount = dashboard.webrtcReaders ? dashboard.webrtcReaders : 0;
+    const { liveviewLoaded, open, currentRecording } = this.state;

    // We check if the camera was getting a valid frame
    // during the last 5 seconds, otherwise we assume the camera is offline.
@@ -546,6 +170,7 @@ class Dashboard extends React.Component {
            divider="0"
            footer={t('dashboard.total_recordings')}
          />
+
          <Link to="/settings">
            <Card
              title="IP Camera"
@@ -684,9 +309,7 @@ class Dashboard extends React.Component {
            )}
          </div>
          <div>
-            <h2>
-              {t('dashboard.live_view')} ({listenerCount})
-            </h2>
+            <h2>{t('dashboard.live_view')}</h2>
            {(!liveviewLoaded || !isCameraOnline) && (
              <SetupBox
                btnicon="preferences"
@@ -703,16 +326,12 @@ class Dashboard extends React.Component {
                  liveviewLoaded && isCameraOnline ? 'visible' : 'hidden',
              }}
            >
-              {liveviewMode === 'webrtc' ? (
-                <video ref={this.videoRef} autoPlay muted playsInline />
-              ) : (
-                <ImageCard
-                  imageSrc={`data:image/png;base64, ${
-                    images.length ? images[0] : ''
-                  }`}
-                  onerror=""
-                />
-              )}
+              <ImageCard
+                imageSrc={`data:image/png;base64, ${
+                  images.length ? images[0] : ''
+                }`}
+                onerror=""
+              />
            </div>
          </div>
        </div>
@@ -724,25 +343,20 @@ class Dashboard extends React.Component {

 const mapStateToProps = (state /* , ownProps */) => ({
  dashboard: state.agent.dashboard,
-  config: state.agent.config,
  connected: state.wss.connected,
  images: state.wss.images,
 });

 const mapDispatchToProps = (dispatch) => ({
  dispatchSend: (message) => dispatch(send(message)),
-  dispatchGetConfig: (onSuccess, onError) =>
-    dispatch(getConfig(onSuccess, onError)),
 });

 Dashboard.propTypes = {
  dashboard: PropTypes.object.isRequired,
-  config: PropTypes.object.isRequired,
  connected: PropTypes.bool.isRequired,
  images: PropTypes.array.isRequired,
  t: PropTypes.func.isRequired,
  dispatchSend: PropTypes.func.isRequired,
-  dispatchGetConfig: PropTypes.func.isRequired,
 };

 export default withTranslation()(
@@ -3,7 +3,6 @@ import PropTypes from 'prop-types';
 import { withTranslation } from 'react-i18next';
 import {
  Breadcrumb,
-  ControlBar,
  VideoCard,
  Button,
  Modal,
@@ -17,53 +16,14 @@ import { getEvents } from '../../actions/agent';
 import config from '../../config';
 import './Media.scss';

-function formatDateTimeLocal(date) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, '0');
-  const day = String(date.getDate()).padStart(2, '0');
-  const hours = String(date.getHours()).padStart(2, '0');
-  const minutes = String(date.getMinutes()).padStart(2, '0');
-
-  return `${year}-${month}-${day}T${hours}:${minutes}`;
-}
-
-function getDefaultTimeWindow() {
-  const endDate = new Date();
-  const startDate = new Date(endDate.getTime() - 60 * 60 * 1000);
-
-  return {
-    startDateTime: formatDateTimeLocal(startDate),
-    endDateTime: formatDateTimeLocal(endDate),
-    timestamp_offset_start: Math.floor(startDate.getTime() / 1000),
-    timestamp_offset_end: Math.floor(endDate.getTime() / 1000) + 59,
-  };
-}
-
-function normalizeInputValue(valueOrEvent) {
-  if (valueOrEvent && valueOrEvent.target) {
-    return valueOrEvent.target.value;
-  }
-
-  return valueOrEvent;
-}
-
 // eslint-disable-next-line react/prefer-stateless-function
 class Media extends React.Component {
  constructor() {
    super();
-
-    const defaultTimeWindow = getDefaultTimeWindow();
-
-    const initialFilter = {
-      timestamp_offset_start: defaultTimeWindow.timestamp_offset_start,
-      timestamp_offset_end: defaultTimeWindow.timestamp_offset_end,
-      number_of_elements: 12,
-    };
-
    this.state = {
-      appliedFilter: initialFilter,
-      startDateTime: defaultTimeWindow.startDateTime,
-      endDateTime: defaultTimeWindow.endDateTime,
+      timestamp_offset_start: 0,
+      timestamp_offset_end: 0,
+      number_of_elements: 12,
      isScrolling: false,
      open: false,
      currentRecording: '',
@@ -72,8 +32,7 @@ class Media extends React.Component {

  componentDidMount() {
    const { dispatchGetEvents } = this.props;
-    const { appliedFilter } = this.state;
-    dispatchGetEvents(appliedFilter);
+    dispatchGetEvents(this.state);
    document.addEventListener('scroll', this.trackScrolling);
  }

@@ -90,107 +49,29 @@ class Media extends React.Component {

  trackScrolling = () => {
    const { events, dispatchGetEvents } = this.props;
-    const { isScrolling, appliedFilter } = this.state;
+    const { isScrolling } = this.state;
    const wrappedElement = document.getElementById('loader');
-    if (!wrappedElement || isScrolling || !this.isBottom(wrappedElement)) {
-      return;
-    }
-
-    this.setState({
-      isScrolling: true,
-    });
-
-    // Get last element
-    const lastElement = events[events.length - 1];
-    if (lastElement) {
-      dispatchGetEvents(
-        {
-          ...appliedFilter,
+    if (!isScrolling && this.isBottom(wrappedElement)) {
+      this.setState({
+        isScrolling: true,
+      });
+      // Get last element
+      const lastElement = events[events.length - 1];
+      if (lastElement) {
+        this.setState({
          timestamp_offset_end: parseInt(lastElement.timestamp, 10),
-        },
-        () => {
+        });
+        dispatchGetEvents(this.state, () => {
          setTimeout(() => {
            this.setState({
              isScrolling: false,
            });
          }, 1000);
-        },
-        () => {
-          this.setState({
-            isScrolling: false,
-          });
-        },
-        true
-      );
-    } else {
-      this.setState({
-        isScrolling: false,
-      });
+        });
+      }
    }
  };

-  buildEventFilter(startDateTime, endDateTime) {
-    const { appliedFilter } = this.state;
-
-    return {
-      timestamp_offset_start: this.getTimestampFromInput(
-        startDateTime,
-        'start'
-      ),
-      timestamp_offset_end: this.getTimestampFromInput(endDateTime, 'end'),
-      number_of_elements: appliedFilter.number_of_elements,
-    };
-  }
-
-  handleDateFilterChange(field, value) {
-    const { dispatchGetEvents } = this.props;
-    const { startDateTime, endDateTime } = this.state;
-    const normalizedValue = normalizeInputValue(value);
-    const nextStartDateTime =
-      field === 'startDateTime' ? normalizedValue : startDateTime;
-    const nextEndDateTime =
-      field === 'endDateTime' ? normalizedValue : endDateTime;
-    const nextFilter = this.buildEventFilter(
-      nextStartDateTime,
-      nextEndDateTime
-    );
-    const shouldApplyFilter =
-      (nextStartDateTime === '' || nextStartDateTime.length === 16) &&
-      (nextEndDateTime === '' || nextEndDateTime.length === 16);
-
-    this.setState(
-      {
-        [field]: normalizedValue,
-        appliedFilter: shouldApplyFilter
-          ? nextFilter
-          : this.state.appliedFilter,
-        isScrolling: false,
-      },
-      () => {
-        if (shouldApplyFilter) {
-          dispatchGetEvents(nextFilter);
-        }
-      }
-    );
-  }
-
-  getTimestampFromInput(value, boundary) {
-    if (!value) {
-      return 0;
-    }
-
-    const date = new Date(value);
-    if (Number.isNaN(date.getTime())) {
-      return 0;
-    }
-
-    const seconds = Math.floor(date.getTime() / 1000);
-    if (boundary === 'end') {
-      return seconds + 59;
-    }
-    return seconds;
-  }
-
  isBottom(el) {
    return el.getBoundingClientRect().bottom + 50 <= window.innerHeight;
  }
@@ -204,9 +85,7 @@ class Media extends React.Component {

  render() {
    const { events, eventsLoaded, t } = this.props;
-    const { isScrolling, open, currentRecording, startDateTime, endDateTime } =
-      this.state;
-
+    const { isScrolling, open, currentRecording } = this.state;
    return (
      <div id="media">
        <Breadcrumb
@@ -223,37 +102,6 @@ class Media extends React.Component {
          </Link>
        </Breadcrumb>

-        <div className="media-control-bar">
-          <ControlBar>
-            <div className="media-filters">
-              <div className="media-filters__field">
-                <label htmlFor="recordings-start-time">Start time</label>
-                <input
-                  className="media-filters__input"
-                  id="recordings-start-time"
-                  type="datetime-local"
-                  value={startDateTime}
-                  onChange={(value) =>
-                    this.handleDateFilterChange('startDateTime', value)
-                  }
-                />
-              </div>
-              <div className="media-filters__field">
-                <label htmlFor="recordings-end-time">End time</label>
-                <input
-                  className="media-filters__input"
-                  id="recordings-end-time"
-                  type="datetime-local"
-                  value={endDateTime}
-                  onChange={(value) =>
-                    this.handleDateFilterChange('endDateTime', value)
-                  }
-                />
-              </div>
-            </div>
-          </ControlBar>
-        </div>
-
        <div className="stats grid-container --four-columns">
          {events.map((event) => (
            <div
@@ -275,11 +123,6 @@ class Media extends React.Component {
            </div>
          ))}
        </div>
-        {events.length === 0 && eventsLoaded === 0 && (
-          <div className="media-empty-state">
-            No recordings found in the selected time range.
-          </div>
-        )}
        {open && (
          <Modal>
            <ModalHeader
@@ -339,13 +182,13 @@ const mapStateToProps = (state /* , ownProps */) => ({
 });

 const mapDispatchToProps = (dispatch) => ({
-  dispatchGetEvents: (eventFilter, success, error, append) =>
-    dispatch(getEvents(eventFilter, success, error, append)),
+  dispatchGetEvents: (eventFilter, success, error) =>
+    dispatch(getEvents(eventFilter, success, error)),
 });

 Media.propTypes = {
  t: PropTypes.func.isRequired,
-  events: PropTypes.arrayOf(PropTypes.object).isRequired,
+  events: PropTypes.objectOf(PropTypes.object).isRequired,
  eventsLoaded: PropTypes.number.isRequired,
  dispatchGetEvents: PropTypes.func.isRequired,
 };
@@ -1,103 +1,4 @@
 #media {
-  .media-control-bar {
-    .control-bar {
-      display: block;
-      padding: 0 var(--main-content-gutter);
-    }
-
-    .control-bar .filtering {
-      display: block;
-    }
-
-    .control-bar .filtering > * {
-      border-right: 0;
-      flex: 1 1 100% !important;
-      max-width: none;
-      width: 100%;
-    }
-  }
-
-  .media-filters {
-    align-items: stretch;
-    display: grid;
-    gap: 0;
-    grid-template-columns: repeat(2, minmax(0, 1fr));
-    min-width: 0;
-    width: 100%;
-  }
-
-  .media-filters__field {
-    border-right: 1px solid var(--bg-muted);
-    min-width: 0;
-    padding: 16px 24px;
-
-    label {
-      display: block;
-      font-size: 14px;
-      font-weight: 600;
-      margin-bottom: 8px;
-      white-space: nowrap;
-    }
-  }
-
-  .media-filters__field:first-child {
-    padding-left: 0;
-  }
-
-  .media-filters__input {
-    appearance: none;
-    background: var(--white);
-    border: 1px solid var(--grey-light);
-    border-radius: 8px;
-    box-sizing: border-box;
-    color: var(--black);
-    font-size: 16px;
-    min-height: 48px;
-    padding: 0 14px 0 0;
-    width: 100%;
-  }
-
-  .media-filters__input::-webkit-datetime-edit,
-  .media-filters__input::-webkit-datetime-edit-fields-wrapper {
-    padding: 0;
-  }
-
-  .media-filters__input:focus {
-    border-color: var(--oss);
-    outline: 0;
-  }
-
-  .media-filters__field:first-child .media-filters__input {
-    padding-left: 0;
-  }
-
-  .media-filters__field:last-child {
-    border-right: 0;
-    padding-right: 0;
-  }
-
-  @media (max-width: 700px) {
-    .media-filters {
-      grid-template-columns: 1fr;
-    }
-
-    .media-filters__field {
-      border-right: 0;
-      border-bottom: 1px solid var(--bg-muted);
-      padding-left: 0;
-      padding-right: 0;
-    }
-
-    .media-filters__field:last-child {
-      border-bottom: 0;
-    }
-  }
-
-  .media-empty-state {
-    margin: 24px 0;
-    opacity: 0.8;
-    text-align: center;
-  }

  #loader {
    display: flex;
@@ -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 = {
@@ -123,12 +123,16 @@ const agent = (
      };

    case 'GET_EVENTS':
+      const { timestamp_offset_end } = action.filter;
      const { events } = action;
      return {
        ...state,
        eventsLoaded: events.length,
-        events: action.append ? [...state.events, ...events] : [...events],
-        eventfilter: action.filter,
+        events:
+          timestamp_offset_end === 0
+            ? [...events]
+            : [...state.events, ...events],
+        eventfilter: action.eventfilter,
      };

    default:
Author	SHA1	Message	Date
Cédric Verstraeten	20b6226ba3	Update Darwin build job to use macOS 13 for consistency	2025-09-12 11:24:02 +00:00
Cédric Verstraeten	aba07a4527	Update Darwin build job to use macOS 13 xlarge for improved performance	2025-09-12 11:23:20 +00:00
Cédric Verstraeten	8a6b2da968	Replace manual Docker installation steps with setup action in Darwin build job	2025-09-12 11:21:50 +00:00
Cédric Verstraeten	8240d7b9b0	Fix Docker machine creation command in Darwin build job	2025-09-12 11:19:52 +00:00
Cédric Verstraeten	36a234976f	Update Darwin build job to run on macOS latest and configure Docker machine	2025-09-12 11:18:29 +00:00
Cédric Verstraeten	502c892e33	Remove Docker Buildx setup step from Darwin build job	2025-09-12 11:15:09 +00:00
Cédric Verstraeten	722b94d88f	Update Darwin build job to run on macOS 26 and install Docker	2025-09-12 11:12:21 +00:00
Cédric Verstraeten	69be9eabeb	Fix Darwin build job to run on macOS 15 instead of macOS 26	2025-09-12 11:08:26 +00:00
Cédric Verstraeten	af69d46c95	Update Darwin build job to run on macOS and remove obsolete GOOS argument	2025-09-12 11:07:22 +00:00
Cédric Verstraeten	c114b3da5b	Add GOOS argument to Dockerfiles for build environment configuration	2025-09-12 12:33:11 +02:00
Cédric Verstraeten	e715575f20	Refactor PR build workflow to target arm64 for Darwin binaries and remove obsolete cross-compilation Dockerfiles	2025-09-12 12:23:00 +02:00
Cédric Verstraeten	b4cf49d4be	Add build process for Darwin binaries in PR workflow	2025-09-12 12:18:22 +02:00
Cédric Verstraeten	d41c45ba59	Add support for cross-compilation in Docker workflows and create Darwin binary	2025-09-12 12:15:10 +02:00