Update app.py

app.py

@@ -193,28 +193,27 @@ def zip_files(files, zip_name):
 class CameraProcessor(VideoProcessorBase):
     def __init__(self):
         self.snapshot = None
-        self.recording = False
         self.frames = []
-        self.start_time = None
+        self.recording = False
 
     def recv(self, frame):
         from PIL import Image
         img = frame.to_image()
         self.snapshot = img
-        if self.recording and time.time() - self.start_time < 10:
+        if self.recording:
             self.frames.append(frame.to_ndarray(format="bgr24"))
         return av.VideoFrame.from_image(img)
 
-    def take_snapshot(self):
+    def capture_frame(self):
         from PIL import Image
         return self.snapshot
 
-    def start_recording(self):
+    def capture_video(self, duration=10):
         self.recording = True
         self.frames = []
-        self.start_time = time.time()
-
-    def stop_recording(self):
+        start_time = time.time()
+        while time.time() - start_time < duration and self.recording:
+            time.sleep(0.033)  # ~30 FPS
         self.recording = False
         return self.frames
 
@@ -290,11 +289,11 @@ with tab2:
                 video_processor_factory=CameraProcessor,
                 frontend_rtc_configuration={"iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]}
             )
-            if processors[key].video_processor:
-                if st.button(f"Capture 📸 Cam {i}", key=f"snap_{i}"):
-                    logger.info(f"Capturing snapshot from Camera {i}")
-                    try:
-                        snapshot = processors[key].video_processor.take_snapshot()
+            if st.button(f"Capture Frame 📸 Cam {i}", key=f"snap_{i}"):
+                logger.info(f"Capturing frame from Camera {i}")
+                try:
+                    if processors[key].video_processor:
+                        snapshot = processors[key].video_processor.capture_frame()
                         if snapshot:
                             filename = generate_filename(i)
                             snapshot.save(filename)
@@ -304,56 +303,56 @@ with tab2:
                                 st.session_state['captured_images'] = []
                             st.session_state['captured_images'].append(filename)
                             update_gallery()
-                    except Exception as e:
-                        st.error(f"Snapshot failed: {str(e)}")
-                        logger.error(f"Error capturing snapshot: {str(e)}")
-                record_key = f"record_{i}"
-                if record_key not in st.session_state:
-                    st.session_state[record_key] = False
-                if st.button(f"{'Stop' if st.session_state[record_key] else 'Record'} 🎥 Cam {i}", key=f"rec_{i}"):
-                    if not st.session_state[record_key]:
-                        logger.info(f"Starting recording from Camera {i}")
-                        try:
-                            processors[key].video_processor.start_recording()
-                            st.session_state[record_key] = True
-                        except Exception as e:
-                            st.error(f"Start recording failed: {str(e)}")
-                            logger.error(f"Error starting recording: {str(e)}")
+                        else:
+                            st.error("No frame captured!")
+                            logger.error("No frame available for snapshot")
                     else:
-                        logger.info(f"Stopping recording from Camera {i}")
-                        try:
-                            frames = processors[key].video_processor.stop_recording()
-                            if frames:
-                                mp4_filename = generate_filename(i, "mp4")
-                                with av.open(mp4_filename, "w") as container:
-                                    stream = container.add_stream("h264", rate=30)
-                                    stream.width = frames[0].shape[1]
-                                    stream.height = frames[0].shape[0]
-                                    for frame in frames:
-                                        av_frame = av.VideoFrame.from_ndarray(frame, format="bgr24")
-                                        for packet in stream.encode(av_frame):
-                                            container.mux(packet)
-                                    for packet in stream.encode():
+                        st.error("Camera processor not initialized!")
+                        logger.error("Processor not ready for Camera {i}")
+                except Exception as e:
+                    st.error(f"Frame capture failed: {str(e)}")
+                    logger.error(f"Error capturing frame: {str(e)}")
+            if st.button(f"Capture Video 🎥 Cam {i}", key=f"rec_{i}"):
+                logger.info(f"Capturing 10s video from Camera {i}")
+                try:
+                    if processors[key].video_processor:
+                        frames = processors[key].video_processor.capture_video()
+                        if frames:
+                            mp4_filename = generate_filename(i, "mp4")
+                            with av.open(mp4_filename, "w") as container:
+                                stream = container.add_stream("h264", rate=30)
+                                stream.width = frames[0].shape[1]
+                                stream.height = frames[0].shape[0]
+                                for frame in frames:
+                                    av_frame = av.VideoFrame.from_ndarray(frame, format="bgr24")
+                                    for packet in stream.encode(av_frame):
                                         container.mux(packet)
-                                st.video(mp4_filename)
-                                logger.info(f"Saved video: {mp4_filename}")
-                                # Slice into 10 frames
-                                sliced_images = []
-                                step = max(1, len(frames) // 10)
-                                for j in range(0, len(frames), step):
-                                    if len(sliced_images) < 10:
-                                        img = Image.fromarray(frames[j][:, :, ::-1])  # BGR to RGB
-                                        img_filename = generate_filename(f"{i}_{len(sliced_images)}")
-                                        img.save(img_filename)
-                                        sliced_images.append(img_filename)
-                                        st.image(img, caption=img_filename, use_container_width=True)
-                                st.session_state['captured_images'] = st.session_state.get('captured_images', []) + sliced_images
-                                logger.info(f"Sliced video into {len(sliced_images)} images")
-                                update_gallery()
-                            st.session_state[record_key] = False
-                        except Exception as e:
-                            st.error(f"Stop recording failed: {str(e)}")
-                            logger.error(f"Error stopping recording: {str(e)}")
+                                for packet in stream.encode():
+                                    container.mux(packet)
+                            st.video(mp4_filename)
+                            logger.info(f"Saved video: {mp4_filename}")
+                            # Slice into 10 frames
+                            sliced_images = []
+                            step = max(1, len(frames) // 10)
+                            for j in range(0, len(frames), step):
+                                if len(sliced_images) < 10:
+                                    img = Image.fromarray(frames[j][:, :, ::-1])  # BGR to RGB
+                                    img_filename = generate_filename(f"{i}_{len(sliced_images)}")
+                                    img.save(img_filename)
+                                    sliced_images.append(img_filename)
+                                    st.image(img, caption=img_filename, use_container_width=True)
+                            st.session_state['captured_images'] = st.session_state.get('captured_images', []) + sliced_images
+                            logger.info(f"Sliced video into {len(sliced_images)} images")
+                            update_gallery()
+                        else:
+                            st.error("No frames recorded!")
+                            logger.error("No frames captured during video recording")
+                    else:
+                        st.error("Camera processor not initialized!")
+                        logger.error("Processor not ready for Camera {i}")
+                except Exception as e:
+                    st.error(f"Video capture failed: {str(e)}")
+                    logger.error(f"Error capturing video: {str(e)}")
 
 with tab3:
     st.header("Fine-Tune Titans 🔧 (Tune Fast!)")