View difference between Paste ID: 2FRWu0Ja and z43X1mBH

-import cv2
+
 import time
 import socket
-from collections import deque
+
 import subprocess
 from datetime import datetime
 import re
 
 # =============== KONFIGURACJA ===============
-# ================== KONFIGURACJA ==================
+
 RTSP_URL = "rtsp://admin:[email protected]:554/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif"
-CAMERAS = {
+
-    "KAMERA1": "rtsp://admin:[email protected]:554/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif",
+BASE_DIR = r"D:\wideo"
-}
+RAW_DIR = os.path.join(BASE_DIR, "raw")
 CLIPS_DIR = os.path.join(BASE_DIR, "clips")
-PRE_SECONDS = 10        # ile sekund PRZED triggerem w buforze
+
-POST_SECONDS = 15       # ile sekund PO triggerze nagrywać
+RAW_PATH = os.path.join(RAW_DIR, "cam1_raw.mp4")   # tu ffmpeg nagrywa ciągły strumień
-FPS_DEFAULT = 25        # jeśli kamera nie poda sensownego FPS
+CAMERA_NAME = "KAMERA1"
 
-OUTPUT_DIR = r"D:\wideo"
+PRE_SECONDS = 10       # ile sekund PRZED triggerem
-RETENTION_DAYS = 1      # na testy, potem np. 30
+POST_SECONDS = 15      # ile sekund PO triggerze
 RETENTION_DAYS = 1     # na testy, potem np. 30
 
 TCP_HOST = "0.0.0.0"
 TCP_PORT = 5000
 
-# ================== POMOCNICZE ==================
+FFMPEG_EXE = "ffmpeg"  # jeśli nie w PATH, podaj pełną ścieżkę, np. r"C:\ffmpeg\bin\ffmpeg.exe"
 
-def ensure_output_dir():
+# globalnie zapamiętany czas startu RAW-a
-    os.makedirs(OUTPUT_DIR, exist_ok=True)
+raw_start_time = None
 raw_lock = threading.Lock()
 
-def cleanup_old_files():
+
-    now = time.time()
+# =============== POMOCNICZE ===============
-    cutoff = now - RETENTION_DAYS * 24 * 3600
+
-    for filename in os.listdir(OUTPUT_DIR):
+def ensure_dirs():
-        filepath = os.path.join(OUTPUT_DIR, filename)
+    os.makedirs(RAW_DIR, exist_ok=True)
-        if os.path.isfile(filepath):
+    os.makedirs(CLIPS_DIR, exist_ok=True)
-            if os.path.getmtime(filepath) < cutoff:
+
-                print(f"[CLEANUP] Usuwam stary plik: {filename}")
+
-                os.remove(filepath)
+def sanitize_part_code(code: str) -> str:
     code = code.strip()
     if not code:
-def cleanup_worker():
+        code = "NO_CODE"
     return re.sub(r"[^0-9A-Za-z_-]", "_", code)
-        cleanup_old_files()
+
 
 def cleanup_old_clips():
     while True:
-def sanitize_part_code(part_code: str) -> str:
+
-    part_code = part_code.strip()
+        cutoff = now - RETENTION_DAYS * 24 * 3600
-    if not part_code:
+
-        part_code = "NO_CODE"
+            for fname in os.listdir(CLIPS_DIR):
-    return re.sub(r"[^0-9A-Za-z_-]", "_", part_code)
+                fpath = os.path.join(CLIPS_DIR, fname)
                 if os.path.isfile(fpath) and os.path.getmtime(fpath) < cutoff:
                     print(f"[CLEANUP] Usuwam stary klip: {fname}")
-# ================== KAMERA – BUFOR + TRIGGER (LICZONY NA KLATKACH) ==================
+                    os.remove(fpath)
         except Exception as e:
-class CameraRecorder(threading.Thread):
+            print("[CLEANUP] Błąd cleanup:", e)
-    def __init__(self, name, url):
+
-        super().__init__(daemon=True)
+
-        self.name = name
+
-        self.url = url
+# =============== START FFMPEG (RAW) ===============
 
-        self.cap = None
+def start_ffmpeg_raw():
-        self._open_stream()
+    """
     Uruchamia ffmpeg, który ciągle nagrywa RTSP do RAW_PATH.
-        fps = self.cap.get(cv2.CAP_PROP_FPS) if self.cap else 0
+    """
-        if fps <= 0 or fps > 120:
+    global raw_start_time
-            fps = FPS_DEFAULT
+
-        self.fps = fps
+    # jeśli plik już istnieje – spróbuj go usunąć, żeby zacząć od nowa
     if os.path.exists(RAW_PATH):
-        self.width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH) or 640)
+
-        self.height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT) or 480)
+            os.remove(RAW_PATH)
         except Exception:
-        # ile klatek trzymamy w buforze
+
-        self.pre_frames = int(self.fps * PRE_SECONDS)
+
-        # ile klatek nagrywamy po triggerze
+    cmd = [
-        self.post_frames_target = int(self.fps * POST_SECONDS)
+        FFMPEG_EXE,
         "-rtsp_transport", "tcp",
-        # bufor z ostatnimi klatkami
+        "-i", RTSP_URL,
-        self.buffer = deque(maxlen=self.pre_frames)
+        "-c", "copy",
         "-an",
-        self.lock = threading.Lock()
+        "-reset_timestamps", "1",
         RAW_PATH,
-        # stan nagrywania
+    ]
-        self.recording = False
+
-        self.writer = None
+    print("[FFMPEG] Start nagrywania RAW...")
-        self.post_frames_left = 0  # ile klatek jeszcze zapisać po triggerze
+    # odpalamy ffmpeg jako proces w tle
     proc = subprocess.Popen(
-        # do reconnectów
+        cmd,
-        self.fail_count = 0
+        stdout=subprocess.DEVNULL,
-        self.max_fail_before_reopen = int(self.fps * 2)  # ok. 2 sekundy błędów z rzędu
+        stderr=subprocess.DEVNULL
     )
-        print(
+
-            f"[{self.name}] Start. {self.width}x{self.height} @ {self.fps} fps, "
+    with raw_lock:
-            f"bufor={self.pre_frames} klatek, post={self.post_frames_target} klatek"
+        raw_start_time = time.time()
-        )
+
     print(f"[FFMPEG] RAW zapisuje się do: {RAW_PATH}")
-    def _open_stream(self):
+    print(f"[FFMPEG] Czas startu RAW: {datetime.fromtimestamp(raw_start_time)}")
-        if self.cap:
+
-            self.cap.release()
+    # proces ffmpeg będzie sobie chodził w tle; nie czekamy na niego tutaj
-        print(f"[{self.name}] Otwieram RTSP...")
+    return proc
-        # ograniczamy buforowanie po stronie OpenCV (jeśli jest obsługiwane)
+
-        self.cap = cv2.VideoCapture(self.url)
+
 # =============== WYCIĘCIE KLIPU ===============
-            self.cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
+
 def cut_clip(part_code: str, trigger_time: float):
     """
     Wywołuje ffmpeg, żeby wyciąć klip:
-        if not self.cap.isOpened():
+      [trigger_time - PRE, trigger_time + POST]
-            print(f"[{self.name}] ❌ Nie można otworzyć strumienia RTSP!")
+    z pliku RAW.
     """
-    def _start_new_writer(self, part_code: str, use_prebuffer: bool):
+    with raw_lock:
-        """
+        rst = raw_start_time
-        Tworzy nowy plik:
+
-        - use_prebuffer=True  -> przed bieżącymi klatkami dopisuje cały bufor (ostatnie PRE_SECONDS)
+    if rst is None:
-        - use_prebuffer=False -> tylko od TERAZ, bez cofania
+        print("[CLIP] RAW jeszcze nie wystartował – pomijam.")
-        Nazwa: RRRR_MM_DD_GG_MM_SS_KOD_KAMERA.mp4
+        return
-        """
+
     if not os.path.exists(RAW_PATH):
-        ts_name = datetime.fromtimestamp(now).strftime("%Y_%m_%d_%H_%M_%S")
+        print(f"[CLIP] RAW nie istnieje: {RAW_PATH}")
-        safe_code = sanitize_part_code(part_code)
+        return
-        filename = f"{ts_name}_{safe_code}_{self.name}.mp4"
+
-        filepath = os.path.join(OUTPUT_DIR, filename)
+    window_start = trigger_time - PRE_SECONDS
     offset = window_start - rst
-        print(f"[{self.name}] Start nagrania: {filename} | prebuffer={use_prebuffer}")
+    if offset < 0:
         offset = 0.0  # jeśli trigger był bardzo szybko po starcie
-        writer = cv2.VideoWriter(
+
-            filepath,
+    duration = PRE_SECONDS + POST_SECONDS
-            cv2.VideoWriter_fourcc(*"mp4v"),
+
-            self.fps,
+    ts_name = datetime.fromtimestamp(trigger_time).strftime("%Y_%m_%d_%H_%M_%S")
-            (self.width, self.height)
+    safe_code = sanitize_part_code(part_code)
-        )
+    out_name = f"{ts_name}_{safe_code}_{CAMERA_NAME}.mp4"
     out_path = os.path.join(CLIPS_DIR, out_name)
-        if not writer.isOpened():
+
-            print(f"[{self.name}] ❌ Nie można otworzyć pliku do zapisu!")
+    print(f"[CLIP] Wycinam klip: {out_name}")
-            return None
+    print(f"[CLIP] offset={offset:.2f}s, duration={duration:.2f}s")
 
-        if use_prebuffer:
+    cmd = [
-            frames = list(self.buffer)  # snapshot, żeby nie iterować po żywym deque
+        FFMPEG_EXE,
-            print(f"[{self.name}] Zapis pre-buffer: {len(frames)} klatek")
+        "-y",
-            for frame in frames:
+        "-ss", f"{offset:.3f}",
-                writer.write(frame)
+        "-i", RAW_PATH,
         "-t", f"{duration:.3f}",
-        self.recording = True
+        "-c", "copy",
-        self.writer = writer
+        out_path,
-        self.post_frames_left = self.post_frames_target  # koniec = post_frames_left == 0
+    ]
 
-        return writer
+    try:
         subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-    def trigger(self, part_code: str):
+        print(f"[CLIP] Klip zapisany: {out_path}")
-        with self.lock:
+    except Exception as e:
-            if self.recording and self.writer:
+        print(f"[CLIP] Błąd wycinania: {e}")
-                # przerywamy stare nagranie natychmiast
+
-                print(f"[{self.name}] Kończę poprzednie nagranie (nowy trigger).")
+
-                try:
+# =============== SERVER TCP ===============
-                    self.writer.release()
+
-                except Exception:
+def tcp_server():
-                    pass
+
-                self.writer = None
+
-                self.recording = False
+
-                self.post_frames_left = 0
+
     print(f"[TCP] Nasłuch na {TCP_HOST}:{TCP_PORT}")
-                # nowe nagranie bez pre-buffer
+
-                self._start_new_writer(part_code, use_prebuffer=False)
+
-            else:
+
-                # pierwsze nagranie po przerwie – z PRE_SECONDS wstecz
+
-                self._start_new_writer(part_code, use_prebuffer=True)
+
                 data = conn.recv(1024)
-            if self.writer:
+
-                print(
+
-                    f"[{self.name}] Nagrywanie: pre={self.pre_frames} klatek, "
+
-                    f"post={self.post_frames_target} klatek"
+
-                )
+
-            else:
+
-                print(f"[{self.name}] ❌ Nie udało się rozpocząć nagrania.")
+
                 trigger_time = time.time()
-    def run(self):
+                # wycinanie w osobnym wątku, żeby nie blokować TCP
-        while True:
+                th = threading.Thread(target=cut_clip, args=(code, trigger_time), daemon=True)
-            if not self.cap or not self.cap.isOpened():
+                th.start()
-                self._open_stream()
+
-                time.sleep(1)
+
-                continue
+
 
-            ret, frame = self.cap.read()
+
-            if not ret:
+# =============== MAIN ===============
-                # nie panikujemy od razu, dajemy trochę błędów pod rząd
+
-                self.fail_count += 1
+
-                if self.fail_count >= self.max_fail_before_reopen:
+    ensure_dirs()
-                    print(f"[{self.name}] Za dużo błędów z rzędu, ponowne otwarcie RTSP.")
+
-                    self._open_stream()
+    # startujemy ffmpeg
-                    self.fail_count = 0
+    ffmpeg_proc = start_ffmpeg_raw()
-                # krótka pauza, ale bardzo mała
+
-                time.sleep(0.01)
+    # uruchamiamy sprzątanie starych klipów
-                continue
+    threading.Thread(target=cleanup_old_clips, daemon=True).start()
 
-            self.fail_count = 0  # mamy poprawną klatkę
+    print("=== TRIGGER + FFMPEG RECORDER URUCHOMIONY ===")
     print("RAW:", RAW_PATH)
-            with self.lock:
+    print("CLIPS:", CLIPS_DIR)
-                # zawsze aktualizujemy bufor PRE_SECONDS
+    print(f"Pre={PRE_SECONDS}s, Post={POST_SECONDS}s, Retencja={RETENTION_DAYS} dni\n")
-                self.buffer.append(frame.copy())
+
     try:
-                if self.recording and self.writer:
+        tcp_server()
-                    # zapisujemy bieżącą klatkę
+    finally:
-                    self.writer.write(frame)
+        # przy zamknięciu – spróbuj zabić ffmpeg
-                    self.post_frames_left -= 1
+
             ffmpeg_proc.terminate()
-                    if self.post_frames_left <= 0:
+
-                        print(f"[{self.name}] Koniec nagrania (wyczerpane post-klatki).")
+
-                        try:
+
-                            self.writer.release()
+
-                        except Exception:
+
-                            pass
+
-                        self.writer = None
+