Use is vision frame everywhere (#1210)

* use is_vision_frame everywhere

* fix hash

* fix lint

facefusion/content_analyser.py

@@ -9,7 +9,7 @@ from facefusion.download import conditional_download_hashes, conditional_downloa
 from facefusion.filesystem import resolve_relative_path
 from facefusion.thread_helper import conditional_thread_semaphore
 from facefusion.types import Detection, DownloadScope, DownloadSet, Fps, InferencePool, ModelSet, VisionFrame
-from facefusion.vision import detect_video_fps, fit_contain_frame, read_image
+from facefusion.vision import detect_video_fps, fit_contain_frame, is_vision_frame, read_image
 
 STREAM_COUNTER = 0
 
@@ -172,7 +172,7 @@ def analyse_video(video_path : str, trim_frame_start : int, trim_frame_end : int
 			vision_frame = video_manager.read_video_frame(video_reader)
 
 			if frame_number % int(video_fps) == 0:
-				if numpy.any(vision_frame):
+				if is_vision_frame(vision_frame):
 					total += 1
 
 					if analyse_frame(vision_frame):

facefusion/core.py

@@ -100,7 +100,7 @@ def pre_check() -> bool:
 def common_pre_check() -> bool:
 	content_analyser_content = inspect.getsource(content_analyser).encode()
 
-	return hash_helper.create_hash(content_analyser_content) == '0922c180'
+	return hash_helper.create_hash(content_analyser_content) == '3c6ce25e'
 
 
 def processors_pre_check() -> bool:

facefusion/face_creator.py

@@ -10,6 +10,7 @@ from facefusion.face_helper import apply_nms, average_points, convert_to_face_la
 from facefusion.face_landmarker import detect_face_landmark, estimate_face_landmark_68_5
 from facefusion.face_recognizer import calculate_face_embedding
 from facefusion.types import BoundingBox, Face, FaceLandmark5, FaceLandmarkSet, FaceScoreSet, Score, VisionFrame
+from facefusion.vision import is_vision_frame
 
 
 def create_faces(vision_frame : VisionFrame, bounding_boxes : List[BoundingBox], face_scores : List[Score], face_landmarks_5 : List[FaceLandmark5]) -> List[Face]:
@@ -73,7 +74,7 @@ def get_many_faces(vision_frames : List[VisionFrame]) -> List[Face]:
 	many_faces : List[Face] = []
 
 	for vision_frame in vision_frames:
-		if numpy.any(vision_frame):
+		if is_vision_frame(vision_frame):
 			all_bounding_boxes = []
 			all_face_scores = []
 			all_face_landmarks_5 = []

facefusion/face_store.py

@@ -1,17 +1,16 @@
 import threading
 from typing import List, Optional
 
-import numpy
-
 from facefusion.hash_helper import create_hash
 from facefusion.types import Face, FaceStore, VisionFrame
+from facefusion.vision import is_vision_frame
 
 FACE_STORE : FaceStore = {}
 
 
 def get_faces(vision_frame : VisionFrame) -> Optional[List[Face]]:
-	if numpy.any(vision_frame):
-		vision_hash = create_hash(vision_frame.tobytes())
+	if is_vision_frame(vision_frame):
+		vision_hash = create_hash(vision_frame.data)
 
 		if FACE_STORE.get(vision_hash):
 			return FACE_STORE.get(vision_hash).get('faces')
@@ -20,8 +19,8 @@ def get_faces(vision_frame : VisionFrame) -> Optional[List[Face]]:
 
 
 def set_faces(vision_frame : VisionFrame, faces : List[Face]) -> None:
-	if numpy.any(vision_frame):
-		vision_hash = create_hash(vision_frame.tobytes())
+	if is_vision_frame(vision_frame):
+		vision_hash = create_hash(vision_frame.data)
 		FACE_STORE.setdefault(vision_hash,
 		{
 			'lock': threading.Lock()
@@ -29,8 +28,8 @@ def set_faces(vision_frame : VisionFrame, faces : List[Face]) -> None:
 
 
 def resolve_lock(vision_frame : VisionFrame) -> threading.Lock:
-	if numpy.any(vision_frame):
-		vision_hash = create_hash(vision_frame.tobytes())
+	if is_vision_frame(vision_frame):
+		vision_hash = create_hash(vision_frame.data)
 		return FACE_STORE.setdefault(vision_hash,
 		{
 			'lock': threading.Lock()

facefusion/ffmpeg.py

@@ -66,7 +66,7 @@ def run_ffmpeg(commands : List[Command]) -> subprocess.Popen[bytes]:
 
 def open_ffmpeg(commands : List[Command]) -> subprocess.Popen[bytes]:
 	commands = ffmpeg_builder.run(commands)
-	return subprocess.Popen(commands, stdin = subprocess.PIPE, stdout = subprocess.PIPE)
+	return subprocess.Popen(commands, stdin = subprocess.PIPE, stderr = subprocess.DEVNULL, stdout = subprocess.PIPE)
 
 
 def create_video_reader(video_path : str, frame_number : int, video_metadata : VideoReaderMetadata) -> subprocess.Popen[bytes]:

facefusion/streamer.py

@@ -5,7 +5,6 @@ from concurrent.futures import ThreadPoolExecutor
 from typing import Deque, Iterator, List
 
 import cv2
-import numpy
 from tqdm import tqdm
 
 from facefusion import ffmpeg_builder, logger, state_manager, translator
@@ -15,7 +14,7 @@ from facefusion.ffmpeg import open_ffmpeg
 from facefusion.filesystem import is_directory
 from facefusion.processors.core import get_processors_modules
 from facefusion.types import Fps, StreamMode, VisionFrame
-from facefusion.vision import extract_vision_mask, read_static_images
+from facefusion.vision import extract_vision_mask, is_vision_frame, read_static_images
 
 
 def multi_process_capture(camera_capture : cv2.VideoCapture, camera_fps : Fps) -> Iterator[VisionFrame]:
@@ -31,7 +30,7 @@ def multi_process_capture(camera_capture : cv2.VideoCapture, camera_fps : Fps) -
 				if analyse_stream(capture_vision_frame, camera_fps):
 					camera_capture.release()
 
-				if numpy.any(capture_vision_frame):
+				if is_vision_frame(capture_vision_frame):
 					future = executor.submit(process_stream_frame, source_vision_frames, capture_vision_frame)
 					futures.append(future)
 

facefusion/uis/components/preview.py

@@ -18,7 +18,7 @@ from facefusion.types import AudioFrame, Face, Mask, VisionFrame
 from facefusion.uis import choices as uis_choices
 from facefusion.uis.core import get_ui_component, get_ui_components, register_ui_component
 from facefusion.uis.types import ComponentOptions, PreviewMode
-from facefusion.vision import detect_frame_orientation, extract_vision_mask, fit_cover_frame, merge_vision_mask, obscure_frame, read_static_image, read_static_images, read_video_frame, restrict_frame, select_video_frames, unpack_resolution
+from facefusion.vision import detect_frame_orientation, extract_vision_mask, fit_cover_frame, is_vision_frame, merge_vision_mask, obscure_frame, read_static_image, read_static_images, read_video_frame, restrict_frame, select_video_frames, unpack_resolution
 
 PREVIEW_IMAGE : Optional[gradio.Image] = None
 
@@ -277,7 +277,7 @@ def create_face_by_face(reference_vision_frame : VisionFrame, source_vision_fram
 		target_crop_vision_frame = extract_crop_frame(target_vision_frame, target_face)
 		output_crop_vision_frame = extract_crop_frame(temp_vision_frame, target_face)
 
-		if numpy.any(target_crop_vision_frame) and numpy.any(output_crop_vision_frame):
+		if is_vision_frame(target_crop_vision_frame) and is_vision_frame(output_crop_vision_frame):
 			target_crop_dimension = min(target_crop_vision_frame.shape[:2])
 			target_crop_vision_frame = fit_cover_frame(target_crop_vision_frame, (target_crop_dimension, target_crop_dimension))
 			output_crop_vision_frame = fit_cover_frame(output_crop_vision_frame, (target_crop_dimension, target_crop_dimension))

facefusion/uis/components/webcam.py

@@ -106,7 +106,7 @@ def start(webcam_device_id : int, webcam_mode : WebcamMode, webcam_resolution :
 				yield capture_vision_frame
 			if webcam_mode in [ 'udp', 'v4l2' ]:
 				try:
-					stream.stdin.write(capture_vision_frame.tobytes())
+					stream.stdin.write(capture_vision_frame.data)
 				except Exception:
 					pass
 

facefusion/video_manager.py

@@ -133,7 +133,7 @@ def get_writer(video_path : str, temp_video_fps : Fps, temp_video_resolution : R
 
 
 def write_video_frame(video_writer : VideoWriter, vision_frame : VisionFrame) -> None:
-	video_writer.get('process').stdin.write(vision_frame.tobytes())
+	video_writer.get('process').stdin.write(vision_frame.data)
 
 
 def close_video_writer(video_writer : VideoWriter) -> bool:

facefusion/workflows/to_video.py

@@ -1,5 +1,4 @@
 from concurrent.futures import ThreadPoolExecutor, as_completed
-from typing import Tuple
 
 import cv2
 import numpy
@@ -84,7 +83,7 @@ def process_disk_frames() -> ErrorCode:
 	return 0
 
 
-def process_stream_frame(frame_number : int, temp_video_resolution : Resolution) -> Tuple[int, VisionFrame]:
+def process_stream_frame(frame_number : int, temp_video_resolution : Resolution) -> VisionFrame:
 	target_vision_frames = select_video_frames(state_manager.get_item('target_path'), frame_number, state_manager.get_item('target_frame_amount'))
 	target_vision_frame = get_middle(target_vision_frames)
 	temp_vision_frame = target_vision_frame.copy()
@@ -100,7 +99,7 @@ def process_stream_frame(frame_number : int, temp_video_resolution : Resolution)
 	if state_manager.get_item('temp_pixel_format') == 'bgr24':
 		temp_vision_frame = temp_vision_frame[:, :, :3]
 
-	return frame_number, numpy.ascontiguousarray(temp_vision_frame)
+	return numpy.ascontiguousarray(temp_vision_frame)
 
 
 def process_stream_frames() -> ErrorCode:
@@ -131,7 +130,7 @@ def process_stream_frames() -> ErrorCode:
 							pending_future.cancel()
 
 					if not future.cancelled():
-						_, temp_vision_frame = future.result()
+						temp_vision_frame = future.result()
 						video_manager.write_video_frame(video_writer, temp_vision_frame)
 						progress.update()
 

tests/test_video_manager.py

@@ -50,34 +50,35 @@ def test_get_reader() -> None:
 	assert video_metadata.get('resolution') == (426, 226)
 	assert video_metadata.get('fps') == 25.0
 	assert video_metadata.get('frame_total') == 270
+
 	assert get_reader(get_test_example_file('target-240p-25fps.mp4'), 'read_video_frame') is video_reader
 	assert not get_reader(get_test_example_file('target-240p-25fps.mp4'), 'select_video_frames').get('id') == video_reader.get('id')
 
 
 def test_conditional_seek_video_reader() -> None:
 	video_reader = get_reader(get_test_example_file('target-240p-25fps.mp4'), 'read_video_frame')
-	sequential_frames = {}
+	video_frames = {}
 
 	for frame_number in range(30):
-		sequential_frames[frame_number] = read_video_frame(video_reader)
+		video_frames[frame_number] = read_video_frame(video_reader)
 
 	for frame_number in [ 5, 17, 29 ]:
 		conditional_seek_video_reader(video_reader, frame_number)
 
-		assert numpy.array_equal(read_video_frame(video_reader), sequential_frames.get(frame_number)) is True
+		assert numpy.array_equal(read_video_frame(video_reader), video_frames.get(frame_number)) is True
 
 
 def test_seek_video_reader() -> None:
 	video_reader = get_reader(get_test_example_file('target-240p-25fps.mp4'), 'read_video_frame')
-	sequential_frames = {}
+	video_frames = {}
 
 	for frame_number in range(30):
-		sequential_frames[frame_number] = read_video_frame(video_reader)
+		video_frames[frame_number] = read_video_frame(video_reader)
 
 	for frame_number in [ 5, 17, 29 ]:
 		seek_video_reader(video_reader, frame_number)
 
-		assert numpy.array_equal(read_video_frame(video_reader), sequential_frames.get(frame_number)) is True
+		assert numpy.array_equal(read_video_frame(video_reader), video_frames.get(frame_number)) is True
 
 
 def test_drain_video_reader() -> None:
@@ -133,6 +134,7 @@ def test_collect_video_frames() -> None:
 
 def test_close_video_reader() -> None:
 	video_reader = get_reader(get_test_example_file('target-240p-25fps.mp4'), 'select_video_frames')
+
 	read_video_frames(video_reader, 0, 4)
 	close_video_reader(video_reader)
 
@@ -176,6 +178,7 @@ def test_close_video_writer() -> None:
 	create_temp_directory(target_path)
 	video_reader = get_reader(target_path, 'read_video_frame')
 	video_writer = get_writer(target_path, 30.0, (426, 226), (426, 226), 30.0)
+
 	write_video_frame(video_writer, read_video_frame(video_reader))
 
 	assert close_video_writer(video_writer) is True
@@ -186,6 +189,7 @@ def test_clear_video_pool() -> None:
 	create_temp_directory(target_path)
 	video_reader = get_reader(target_path, 'select_video_frames')
 	video_writer = get_writer(target_path, 25.0, (426, 226), (426, 226), 25.0)
+
 	read_video_frames(video_reader, 0, 4)
 	write_video_frame(video_writer, read_video_frame(video_reader))
 	clear_video_pool()