no catch sigint

.gitignore

@@ -0,0 +1,6 @@
+/cmd/prune/prune
+/prune
+/cmd/ui/ui
+/ui
+**/*.sw*
+**/testdata

cams.sh

@@ -0,0 +1,33 @@
+#! /bin/bash
+
+set -euo pipefail
+cd "$(dirname "$(realpath "$BASH_SOURCE")")"
+
+mkdir -p ./record.d/
+
+for i in 83 98; do
+   (
+      while sleep 1; do
+         mkdir -p ./record.d/$i/
+         /var/services/homes/squeaky2x3/bin/ffmpeg7 \
+            -y \
+            -rtsp_transport udp \
+            -i rtsp://192.168.0.$i:8554/unicast \
+            -t 180 \
+            ./record.d/$i/$(date +%Y-%m-%dT%H-%M-%S).%05d.jpg \
+            < /dev/null &> ./record.d/$i/ffmpeg.log
+      done
+   ) &
+done
+
+cleanup() {
+   local jobs="$(jobs -p)"
+   if [ -n "$jobs" ]; then
+      echo -e "killing $jobs"
+      kill -9 $jobs
+      wait
+   fi
+}
+trap cleanup EXIT
+echo -e "waiting..."
+wait

cmd/prune/main.go

@@ -0,0 +1,267 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"math/big"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path"
+	"slices"
+	"sort"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+
+	"ffmpeg.d/pkg/fs"
+)
+
+func main() {
+	ctx, can := signal.NotifyContext(context.Background(), syscall.SIGINT)
+	defer can()
+
+	if err := Run(ctx, os.Args[1:]); err != nil {
+		panic(err)
+	}
+}
+
+func Run(ctx context.Context, args []string) error {
+	cams, err := lsd(args[0])
+	if err != nil {
+		return fmt.Errorf("failed to lsd %s: %w", args[0], err)
+	}
+
+	movementInterval, err := time.ParseDuration(args[1])
+	if err != nil {
+		return err
+	}
+
+	for _, cam := range cams {
+		files, err := lsf(cam)
+		if err != nil {
+			return fmt.Errorf("failed to lsf %s: %w", cam, err)
+		} else if len(files) < 1 {
+			continue
+		}
+
+		series := []string{}
+		for _, f := range files {
+			series = append(series, strings.Split(path.Base(f), ".")[0])
+		}
+		sort.Strings(series)
+		series = slices.Compact(series)
+		series = slices.DeleteFunc(series, func(s string) bool {
+			return path.Base(s) > time.Now().Add(-10*time.Minute).Format("2006-01-02T15-04-05.")
+		})
+
+		for _, series := range series {
+			if err := func() error {
+				seriesFiles := []string{}
+				for _, file := range files {
+					if strings.HasPrefix(path.Base(file), series) {
+						seriesFiles = append(seriesFiles, file)
+					}
+				}
+				if seriesHasMovement, err := seriesHasMovement(ctx, seriesFiles, movementInterval); err != nil {
+					return err
+				} else if seriesHasMovement > -1 {
+					outd := strings.ReplaceAll(cam, "record", "movement")
+					os.MkdirAll(outd, os.ModePerm)
+
+					fileWithMovement := seriesFiles[seriesHasMovement]
+					if b, err := os.ReadFile(fileWithMovement); err != nil {
+						return err
+					} else if err := os.WriteFile(path.Join(outd, series+path.Ext(fileWithMovement)), b, os.ModePerm); err != nil {
+						return err
+					}
+
+					firstFileInfo, err := os.Stat(seriesFiles[0])
+					if err != nil {
+						return err
+					}
+					lastFileInfo, err := os.Stat(seriesFiles[len(seriesFiles)-1])
+					if err != nil {
+						return err
+					}
+					durationSeconds := lastFileInfo.ModTime().Sub(firstFileInfo.ModTime()).Seconds()
+					frames := len(seriesFiles)
+					fps := int(float64(frames) / durationSeconds)
+
+					log.Println("found movement in", series, "over", durationSeconds, "seconds at", fps, "fps")
+
+					cmd := exec.CommandContext(ctx,
+						"ffmpeg",
+						"-y",
+						"-framerate", strconv.Itoa(fps),
+						"-pattern_type", "glob",
+						"-i", path.Join(cam, series)+".*.jpg",
+						"-r", strconv.Itoa(fps),
+						path.Join(outd, series+".mp4"),
+					)
+					if out, err := cmd.CombinedOutput(); err != nil {
+						return fmt.Errorf("failed to persist series %s: (%w) %s", series, err, out)
+					}
+				} else {
+					log.Println("no movement in", series)
+				}
+				for _, seriesFile := range seriesFiles {
+					if err := os.Remove(seriesFile); err != nil {
+						return fmt.Errorf("failed to rm series %s[%s]: %w", series, seriesFile, err)
+					}
+				}
+				return nil
+			}(); err != nil {
+				log.Println("failed series", series, ":", err)
+			}
+		}
+	}
+
+	for _, cam := range cams {
+		if err := func() error {
+			camMovementD := strings.ReplaceAll(cam, "record", "movement")
+
+			movementFiles, err := lsf(camMovementD)
+			if err != nil {
+				return err
+			}
+			sort.Strings(movementFiles)
+
+			var sizeOfCamDMiB int64
+			for _, movementFile := range movementFiles {
+				stat, err := os.Stat(movementFile)
+				if err != nil {
+					return err
+				}
+				fileSizeMiB := stat.Size() / 1024 / 1024
+				sizeOfCamDMiB += fileSizeMiB
+			}
+
+			GiB100 := int64(100 * 1024)
+			for sizeOfCamDMiB > GiB100 && len(movementFiles) > 0 {
+				oldestFile := movementFiles[0]
+
+				oldestFileStat, err := os.Stat(oldestFile)
+				if err != nil {
+					return err
+				}
+				oldestFileSizeMiB := oldestFileStat.Size() / 1024 / 1024
+
+				log.Println("deleting old file", oldestFile)
+				if err := os.Remove(oldestFile); err != nil {
+					return err
+				}
+
+				sizeOfCamDMiB -= oldestFileSizeMiB
+				movementFiles = movementFiles[1:]
+			}
+			return nil
+		}(); err != nil {
+			log.Println("failed to cap size of cam", cam, " dir:", err)
+		}
+	}
+
+	return nil
+}
+
+func seriesHasMovement(ctx context.Context, files []string, movementInterval time.Duration) (int, error) {
+	if len(files) < 1 {
+		return -1, nil
+	}
+
+	f := files[0]
+	fStat, err := os.Stat(f)
+	if err != nil {
+		return -1, err
+	}
+	fTime := fStat.ModTime()
+
+	for i := 1; i < len(files); i++ {
+		g := files[i]
+		gStat, err := os.Stat(g)
+		if err != nil {
+			return -1, err
+		}
+		gTime := gStat.ModTime()
+
+		if gTime.Sub(fTime) < movementInterval {
+			continue
+		}
+
+		if hasMovement, err := hasMovement(ctx, f, g); err != nil {
+			return -1, fmt.Errorf("failed to check for movement between %s and %s: %w", f, g, err)
+		} else if hasMovement {
+			return i, nil
+		}
+
+		f = g
+		fTime = gTime
+	}
+	return -1, nil
+}
+
+func hasMovement(ctx context.Context, a, b string) (bool, error) {
+	sizeOfCmd := exec.CommandContext(ctx, "identify", a)
+	sizeOfOutput, err := sizeOfCmd.CombinedOutput()
+	if err != nil {
+		return false, fmt.Errorf("failed to identify %s: (%w) %s", a, err, sizeOfOutput)
+	}
+	hw := strings.Fields(string(sizeOfOutput))[2]
+	h, err := strconv.ParseInt(strings.Split(hw, "x")[0], 10, 16)
+	if err != nil {
+		return false, fmt.Errorf("failed parsing %s for HxW: %w", hw, err)
+	}
+	w, err := strconv.ParseInt(strings.Split(hw, "x")[1], 10, 16)
+	if err != nil {
+		return false, fmt.Errorf("failed parsing %s for HxW: %w", hw, err)
+	}
+	total := h * w
+
+	compareCmd := exec.CommandContext(ctx, "compare", "-metric", "AE", "-fuzz", "15%", a, b, "/dev/null")
+	compareOutput, _ := compareCmd.CombinedOutput()
+
+	f, _, err := big.ParseFloat(string(compareOutput), 10, 0, big.ToNearestEven)
+	if err != nil {
+		return false, fmt.Errorf("failed to parse %s for a number of changed pixels: %w", compareOutput, err)
+	}
+	i := new(big.Int)
+	f.Int(i)
+	delta := i.Int64()
+
+	percentPixelsChanged := int(100.0 * float64(delta) / float64(total))
+	return percentPixelsChanged > 10, nil
+}
+
+func mv(wPath, rPath string) error {
+	r, err := os.Open(rPath)
+	if err != nil {
+		return err
+	}
+	defer r.Close()
+
+	os.MkdirAll(path.Dir(wPath), os.ModePerm)
+	w, err := os.Create(wPath)
+	if err != nil {
+		return err
+	}
+	defer w.Close()
+
+	if _, err := io.Copy(w, r); err != nil {
+		w.Close()
+		os.Remove(wPath)
+		return err
+	}
+
+	return os.Remove(rPath)
+}
+
+func lsd(d string) ([]string, error) {
+	return fs.LsD(d)
+}
+
+func lsf(d string) ([]string, error) {
+	return fs.LsF(d)
+}

cmd/prune/main_test.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+	"context"
+	"os"
+	"path"
+	"testing"
+	"time"
+)
+
+func TestRun(t *testing.T) {
+	d := path.Join(t.TempDir(), "record")
+	if err := os.MkdirAll(d, os.ModePerm); err != nil {
+		t.Fatal(err)
+	}
+
+	a, err := os.ReadFile(path.Join("testdata", "a.jpg"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	b, err := os.ReadFile(path.Join("testdata", "b.jpg"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	seriesA := "2024-09-18T10-50-00"
+	seriesB := time.Now().Format("2006-01-02T15-04-05")
+
+	now := time.Now()
+	if err := os.WriteFile(path.Join(d, seriesA+".0.jpg"), a, os.ModePerm); err != nil {
+		t.Fatal(err)
+	} else if err := os.Chtimes(path.Join(d, seriesA+".0.jpg"), now, now.Add(-4000*time.Millisecond)); err != nil {
+		t.Fatal(err)
+	} else if err := os.WriteFile(path.Join(d, seriesA+".1.jpg"), a, os.ModePerm); err != nil {
+		t.Fatal(err)
+	} else if err := os.Chtimes(path.Join(d, seriesA+".1.jpg"), now, now.Add(-3500*time.Millisecond)); err != nil {
+		t.Fatal(err)
+	} else if err := os.WriteFile(path.Join(d, seriesA+".2.jpg"), b, os.ModePerm); err != nil {
+		t.Fatal(err)
+	} else if err := os.Chtimes(path.Join(d, seriesA+".2.jpg"), now, now.Add(-3000*time.Millisecond)); err != nil {
+		t.Fatal(err)
+	} else if err := os.WriteFile(path.Join(d, seriesA+".3.jpg"), b, os.ModePerm); err != nil {
+		t.Fatal(err)
+	} else if err := os.Chtimes(path.Join(d, seriesA+".3.jpg"), now, now.Add(-2500*time.Millisecond)); err != nil {
+		t.Fatal(err)
+	} else if err := os.WriteFile(path.Join(d, seriesB+".0.jpg"), b, os.ModePerm); err != nil {
+		t.Fatal(err)
+	} else if err := os.Chtimes(path.Join(d, seriesB+".0.jpg"), now, now.Add(-2000*time.Millisecond)); err != nil {
+		t.Fatal(err)
+	}
+
+	start := time.Now()
+	if err := Run(context.Background(), []string{path.Dir(d), "1s"}); err != nil {
+		t.Fatal(err)
+	}
+	t.Log(time.Since(start))
+
+	if results, err := lsf(path.Join(path.Dir(d), "movement")); err != nil {
+		t.Fatal("failed to lsf for results:", err)
+	} else if len(results) != 2 {
+		t.Fatal(results)
+	} else if path.Base(results[0]) != seriesA+".jpg" {
+		t.Fatal(results)
+	} else if path.Base(results[1]) != seriesA+".mp4" {
+		t.Fatal(results)
+	}
+
+	if records, err := lsf(d); err != nil {
+		t.Fatal(err)
+	} else if len(records) != 1 {
+		t.Fatal(records)
+	} else if path.Base(records[0]) != seriesB+".0.jpg" {
+		t.Fatal(err)
+	}
+}

cmd/rmdir/main.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+
+	"ffmpeg.d/pkg/fs"
+)
+
+func main() {
+	if err := Run(context.Background(), os.Args[1:]); err != nil {
+		panic(err)
+	}
+}
+
+func Run(ctx context.Context, args []string) error {
+	cams, err := lsd(args[0])
+	if err != nil {
+		return fmt.Errorf("failed to lsd %s: %w", args[0], err)
+	}
+
+	for _, cam := range cams {
+		files, err := lsf(cam)
+		if err != nil {
+			return fmt.Errorf("failed to lsf %s: %w", cam, err)
+		} else if len(files) < 1 {
+			continue
+		}
+
+		for _, file := range files {
+			log.Println("rm", file)
+			if os.Getenv("DRY_RUN") == "false" {
+				os.Remove(file)
+			}
+		}
+	}
+
+	return nil
+}
+
+func lsd(d string) ([]string, error) {
+	return fs.LsD(d)
+}
+
+func lsf(d string) ([]string, error) {
+	return fs.LsF(d)
+}

cmd/ui/index.html.tmpl

@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html>
+  <header>
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/water.css@2/out/dark.css">
+  </header>
+  <body>
+    <div>
+      {{ range .Series }}
+        <div style="display: inline-block; width: 12em; height: 9em; margin-bottom: .7em;">
+           <a href="/media/{{ .HREF }}">
+             <img src="/media/{{ .Thumbnail }}" alt="{{ .HREF }}"/>
+             <span>{{ .Thumbnail }}</span>
+             <br>
+           </a>
+        </div>
+      {{ end }}
+    </div>
+  </body>
+  <footer>
+  </footer>
+</html>

cmd/ui/main.go

@@ -0,0 +1,125 @@
+package main
+
+import (
+	"context"
+	"embed"
+	_ "embed"
+	"flag"
+	"fmt"
+	"html/template"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"os/signal"
+	"path"
+	"slices"
+	"strings"
+	"syscall"
+
+	"ffmpeg.d/pkg/fs"
+)
+
+//go:embed *.tmpl
+var TMPL embed.FS
+
+func main() {
+	ctx, can := signal.NotifyContext(context.Background(), syscall.SIGINT)
+	defer can()
+
+	if err := Run(ctx, os.Args[1:]); err != nil {
+		panic(err)
+	}
+}
+
+func Run(ctx context.Context, args []string) error {
+	flags := flag.NewFlagSet(os.Args[0], flag.ContinueOnError)
+	d := flags.String("d", "./testdata/", "directory containing directories of (x.jpg,x.mp4)")
+	p := flags.Int("p", 38080, "port to listen on")
+	if err := flags.Parse(args); err != nil {
+		return err
+	}
+
+	tmpl, err := template.ParseFS(TMPL, "*.tmpl")
+	if err != nil {
+		return err
+	}
+
+	s := &http.Server{
+		Addr: fmt.Sprintf(":%d", *p),
+		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if strings.HasPrefix(r.URL.Path, "/media/") {
+				http.StripPrefix("/media/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+					w.Header().Set("Cache-Control", "private, max-age=31536000")
+					w.Header().Add("Cache-Control", "immutable")
+					http.FileServer(http.Dir(*d)).ServeHTTP(w, r)
+				})).ServeHTTP(w, r)
+				return
+			}
+
+			type Series struct {
+				HREF      string
+				Thumbnail string
+			}
+
+			ds, err := fs.LsD(*d)
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+			seriesByKey := map[string]Series{}
+			for _, d := range ds {
+				files, err := fs.LsF(d)
+				if err != nil {
+					http.Error(w, err.Error(), http.StatusInternalServerError)
+					return
+				}
+				for _, f := range files {
+					key := strings.Split(path.Base(f), ".")[0]
+					v := seriesByKey[key]
+					switch path.Ext(f) {
+					case ".jpg":
+						v.Thumbnail = path.Join(path.Base(d), path.Base(f))
+					case ".mp4":
+						v.HREF = path.Join(path.Base(d), path.Base(f))
+					}
+					seriesByKey[key] = v
+				}
+			}
+			series := []Series{}
+			for _, v := range seriesByKey {
+				series = append(series, v)
+			}
+			slices.SortFunc(series, func(a, b Series) int {
+				return -1 * strings.Compare(path.Base(a.HREF), path.Base(b.HREF))
+			})
+
+			if err := tmpl.Execute(w, map[string]any{
+				"Series": series,
+			}); err != nil {
+				log.Println(err)
+			}
+		}),
+		BaseContext: func(net.Listener) context.Context {
+			return ctx
+		},
+	}
+	defer s.Shutdown(ctx)
+
+	errs := make(chan error)
+	go func() {
+		defer close(errs)
+
+		errs <- s.ListenAndServe()
+	}()
+
+	select {
+	case err := <-errs:
+		return err
+	case <-ctx.Done():
+		s.Shutdown(ctx)
+		for range errs {
+		}
+	}
+	return nil
+}

cmd/ui/testdata/cam/1.jpg

@@ -0,0 +1 @@
+LAdN7KVw-Ig.jpg

cmd/ui/testdata/cam/1.mp4

@@ -0,0 +1 @@
+LAdN7KVw-Ig.mp4

cmd/ui/testdata/cam/2.jpg

@@ -0,0 +1 @@
+LAdN7KVw-Ig.jpg

cmd/ui/testdata/cam/2.mp4

@@ -0,0 +1 @@
+LAdN7KVw-Ig.mp4

cmd/ui/testdata/cam/3.jpg

@@ -0,0 +1 @@
+LAdN7KVw-Ig.jpg

cmd/ui/testdata/cam/3.mp4

@@ -0,0 +1 @@
+LAdN7KVw-Ig.mp4

cmd/ui/testdata/cam/4.jpg

@@ -0,0 +1 @@
+LAdN7KVw-Ig.jpg

cmd/ui/testdata/cam/5.mp4

@@ -0,0 +1 @@
+LAdN7KVw-Ig.mp4

cmd/ui/testdata/cam/6.jpg

@@ -0,0 +1 @@
+LAdN7KVw-Ig.jpg

cmd/ui/testdata/cam/6.mp4

@@ -0,0 +1 @@
+LAdN7KVw-Ig.mp4

pkg/fs/ls.go

@@ -0,0 +1,29 @@
+package fs
+
+import (
+	"os"
+	"path"
+	"sort"
+)
+
+func LsD(d string) ([]string, error) {
+	return ls(d, true)
+}
+
+func LsF(d string) ([]string, error) {
+	return ls(d, false)
+}
+
+func ls(d string, dirs bool) ([]string, error) {
+	entries, err := os.ReadDir(d)
+
+	results := make([]string, 0, len(entries))
+	for i := range entries {
+		if dirs == entries[i].IsDir() {
+			results = append(results, path.Join(d, entries[i].Name()))
+		}
+	}
+	sort.Strings(results)
+
+	return results, err
+}

testdata/ffmpeg.d/.gitignore

@@ -1,2 +0,0 @@
-**/*.sw*
-/cmd/prune/prune

testdata/ffmpeg.d/cmd/prune/main.go

@@ -1,155 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"math/big"
-	"os"
-	"os/exec"
-	"os/signal"
-	"path"
-	"slices"
-	"sort"
-	"strconv"
-	"strings"
-	"syscall"
-	"time"
-)
-
-func main() {
-	ctx, can := signal.NotifyContext(context.Background(), syscall.SIGINT)
-	defer can()
-
-	if err := Run(ctx, os.Args[1:]); err != nil {
-		panic(err)
-	}
-}
-
-func Run(ctx context.Context, args []string) error {
-	cams, err := lsd(args[0])
-	if err != nil {
-		return err
-	}
-
-	for _, cam := range cams {
-		files, err := lsf(cam)
-		if err != nil {
-			return err
-		} else if len(files) < 1 {
-			continue
-		}
-
-		lastChunk := strings.Split(path.Base(files[len(files)-1]), ".")[0]
-		files = slices.DeleteFunc(files, func(f string) bool {
-			return strings.Contains(f, lastChunk)
-		})
-		if len(files) == 0 {
-			continue
-		}
-
-		lastMovementAt := time.Unix(0, 0)
-		prevF := files[0]
-		for _, f := range files[1:] {
-			prev, err := os.Stat(prevF)
-			if err != nil {
-				return err
-			}
-
-			if ok, err := hasMovement(ctx, prevF, f); err != nil {
-				return err
-			} else if ok {
-				lastMovementAt = prev.ModTime()
-			}
-
-			target := "trash"
-			if prev.ModTime().Before(lastMovementAt.Add(3 * time.Minute)) {
-				target = "movement"
-			}
-			if err := func() error {
-				gName := strings.ReplaceAll(prevF, "record", target)
-				if gName == prevF {
-					return fmt.Errorf("would overwrite original %s", prevF)
-				}
-				os.MkdirAll(path.Dir(gName), os.ModePerm)
-
-				f, err := os.Open(prevF)
-				if err != nil {
-					return err
-				}
-				defer f.Close()
-
-				g, err := os.Create(gName)
-				if err != nil {
-					return err
-				}
-				defer g.Close()
-
-				if _, err := io.Copy(g, f); err != nil {
-					return err
-				}
-
-				return os.Remove(prevF)
-			}(); err != nil {
-				return err
-			}
-
-			prevF = f
-		}
-	}
-	return nil
-}
-
-func hasMovement(ctx context.Context, a, b string) (bool, error) {
-	sizeOfCmd := exec.CommandContext(ctx, "identify", a)
-	sizeOfOutput, err := sizeOfCmd.CombinedOutput()
-	if err != nil {
-		return false, fmt.Errorf("failed to identify %s: (%w) %s", a, err, sizeOfOutput)
-	}
-	hw := strings.Fields(string(sizeOfOutput))[2]
-	h, err := strconv.ParseInt(strings.Split(hw, "x")[0], 10, 16)
-	if err != nil {
-		return false, err
-	}
-	w, err := strconv.ParseInt(strings.Split(hw, "x")[1], 10, 16)
-	if err != nil {
-		return false, err
-	}
-	total := h * w
-
-	compareCmd := exec.CommandContext(ctx, "compare", "-metric", "AE", "-fuzz", "15%", a, b, "/dev/null")
-	compareOutput, _ := compareCmd.CombinedOutput()
-
-	f, _, err := big.ParseFloat(string(compareOutput), 10, 0, big.ToNearestEven)
-	if err != nil {
-		return false, err
-	}
-	i := new(big.Int)
-	f.Int(i)
-	delta := i.Int64()
-
-	percentPixelsChanged := int(100.0 * float64(delta) / float64(total))
-	return percentPixelsChanged > 10, nil
-}
-
-func lsd(d string) ([]string, error) {
-	return ls(d, true)
-}
-
-func lsf(d string) ([]string, error) {
-	return ls(d, false)
-}
-
-func ls(d string, dirs bool) ([]string, error) {
-	entries, err := os.ReadDir(d)
-
-	results := make([]string, 0, len(entries))
-	for i := range entries {
-		if dirs == entries[i].IsDir() {
-			results = append(results, path.Join(d, entries[i].Name()))
-		}
-	}
-	sort.Strings(results)
-
-	return results, err
-}