video function

app.py

@@ -200,13 +200,52 @@ def inference(img, dsdg_thresh):
         x2 = x + w
         y2 = y + h
         bbox = (x, y, x2, y2)
-        img_deepix, confidences_deepix, cls_deepix = deepix_model_inference(img, bbox)
+        # img_deepix, confidences_deepix, cls_deepix = deepix_model_inference(img, bbox)
         img_dsdg, confidences_dsdg, cls_dsdg = dsdg_model_inference(img, bbox, dsdg_thresh)
-        return img_deepix, confidences_deepix, cls_deepix, img_dsdg, confidences_dsdg, cls_dsdg
+        return img, {}, 2, img_dsdg, confidences_dsdg, cls_dsdg
     else:
         return img, {}, None, img, {}, None
 
 
+def process_video(vid_path, dsdg_thresh):
+    cap = cv.VideoCapture(vid_path)
+
+    input_width = int(cap.get(cv.CAP_PROP_FRAME_WIDTH))
+    input_height = int(cap.get(cv.CAP_PROP_FRAME_HEIGHT))
+
+    # Set video codec and create VideoWriter object to save the output video
+    fourcc = cv.VideoWriter_fourcc(*'XVID')
+    output_vid_path = 'output_dsdg.mp4'
+    out_dsdg = cv.VideoWriter(output_vid_path, fourcc, 6.0, (input_width, input_height))
+
+    frame_counter = 0
+    confidences_arr = []
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        # Process only every 5th frame
+        if frame_counter % 5 == 0:
+            # Run inference on the current frame
+            _, _, _, img_dsdg, confidences_dsdg, _ = inference(frame, dsdg_thresh)
+            confidences_arr.append(confidences_dsdg['Real confidence'])
+
+            # Resize the DSDG frame to match the input video dimensions
+            img_dsdg = cv.resize(img_dsdg, (input_width, input_height))
+
+            # Write the DSDG frame to the output video
+            out_dsdg.write(img_dsdg)
+
+        frame_counter += 1
+    avg_conf = sum(confidences_arr) / len(confidences_arr)
+    confidences_dsdg = {'Average real confidence': avg_conf}
+    # Release resources
+    cap.release()
+    out_dsdg.release()
+    return vid_path, {'Not supported right now': 0}, 2, output_vid_path, avg_conf, avg_conf
+
+
 def upload_to_s3(image_array, app_version, *labels):
     folder = 'demo'
     bucket_name = 'livenessng'
@@ -244,15 +283,15 @@ demo = gr.Blocks()
 with demo:
     with gr.Row():
         with gr.Column():
-            input_img = gr.Image(source='webcam', shape=None, type='numpy', streaming=False)
+            input_vid = gr.Video(format='mp4', source='webcam')
             dsdg_thresh = gr.Slider(value=DSDG_THRESHOLD, label='DSDG threshold')
             btn_run = gr.Button(value="Run")
         with gr.Column():
             outputs=[
-                gr.Image(label='DeePixBiS', type='numpy'),
+                gr.Video(label='DeePixBiS', format='mp4'),
                 gr.Label(num_top_classes=2, label='DeePixBiS'),
                 gr.Number(visible=False, value=-1),
-                gr.Image(label='DSDG', type='numpy'),
+                gr.Video(label='DSDG', format='mp4'),
                 gr.Label(num_top_classes=2, label='DSDG'),
                 gr.Number(visible=False, value=-1)]
         with gr.Column():
@@ -260,13 +299,13 @@ with demo:
                 ["Spoof", "Real", "None"], label="True label", type='index')
             flag = gr.Button(value="Flag")
             status = gr.Textbox()
-            example_block = gr.Examples(examples, [input_img], outputs)
+            # example_block = gr.Examples(examples, [input_vid], outputs)
 
-    btn_run.click(inference, [input_img, dsdg_thresh], outputs)
+    btn_run.click(process_video, [input_vid, dsdg_thresh], outputs)
     app_version_block = gr.Textbox(value=app_version, visible=False)
     flag.click(
         upload_to_s3,
-        [input_img, app_version_block, radio]+[outputs[2], outputs[5]],
+        [input_vid, app_version_block, radio]+[outputs[2], outputs[5]],
         [status], show_progress=True)