rename frame number to frame index everywhere (#1222)

facefusion.ini

@@ -30,7 +30,7 @@ face_selector_gender =
 face_selector_race =
 reference_face_position =
 reference_face_distance =
-reference_frame_number =
+reference_frame_index =
 
 [face_tracker]
 face_tracker_score =

facefusion/apis/asset_helper.py

@@ -93,7 +93,7 @@ async def save_asset_files(upload_files : List[UploadFile]) -> List[str]:
 	return asset_paths
 
 
-def read_asset_frames(asset : ImageAsset | VideoAsset, frame_numbers : List[str]) -> List[VisionFrame]:
+def read_asset_frames(asset : ImageAsset | VideoAsset, frame_indexes : List[str]) -> List[VisionFrame]:
 	vision_frames = []
 
 	if asset.get('media') == 'image':
@@ -103,9 +103,9 @@ def read_asset_frames(asset : ImageAsset | VideoAsset, frame_numbers : List[str]
 			vision_frames.append(vision_frame)
 
 	if asset.get('media') == 'video':
-		for frame_number in frame_numbers:
+		for frame_index in frame_indexes:
-			if frame_number.isdigit():
+			if frame_index.isdigit():
-				vision_frame = read_static_video_frame(asset.get('path'), int(frame_number))
+				vision_frame = read_static_video_frame(asset.get('path'), int(frame_index))
 
 				if is_vision_frame(vision_frame):
 					vision_frames.append(vision_frame)
@@ -113,9 +113,9 @@ def read_asset_frames(asset : ImageAsset | VideoAsset, frame_numbers : List[str]
 	return vision_frames
 
 
-def capture_asset_frames(asset : ImageAsset | VideoAsset, frame_numbers : List[str], resolution : str) -> List[VisionFrame]:
+def capture_asset_frames(asset : ImageAsset | VideoAsset, frame_indexes : List[str], resolution : str) -> List[VisionFrame]:
 	capture_vision_frames = []
-	temp_vision_frames = read_asset_frames(asset, frame_numbers)
+	temp_vision_frames = read_asset_frames(asset, frame_indexes)
 
 	for temp_vision_frame in temp_vision_frames:
 		capture_vision_frame = fit_contain_frame(temp_vision_frame, unpack_resolution(resolution))
@@ -124,9 +124,9 @@ def capture_asset_frames(asset : ImageAsset | VideoAsset, frame_numbers : List[s
 	return capture_vision_frames
 
 
-def capture_asset_faces(asset : ImageAsset | VideoAsset, frame_numbers : List[str], resolution : str) -> List[VisionFrame]:
+def capture_asset_faces(asset : ImageAsset | VideoAsset, frame_indexes : List[str], resolution : str) -> List[VisionFrame]:
 	capture_vision_frames = []
-	temp_vision_frames = read_asset_frames(asset, frame_numbers)
+	temp_vision_frames = read_asset_frames(asset, frame_indexes)
 	crop_size = unpack_resolution(resolution)
 
 	for temp_vision_frame in temp_vision_frames:

facefusion/apis/endpoints/assets.py

@@ -92,14 +92,14 @@ async def get_asset(request : Request) -> Response:
 		if asset:
 			if asset.get('media') in [ 'image', 'video' ] and request.query_params.get('action') == 'capture':
 				resolution = request.query_params.get('resolution')
-				frame_numbers = request.query_params.getlist('frame_number')
+				frame_indexes = request.query_params.getlist('frame_index')
 				vision_frames = []
 
 				if request.query_params.get('subject') == 'frame':
-					vision_frames = capture_asset_frames(asset, frame_numbers, resolution) #type:ignore[arg-type]
+					vision_frames = capture_asset_frames(asset, frame_indexes, resolution) #type:ignore[arg-type]
 
 				if request.query_params.get('subject') == 'face':
-					vision_frames = capture_asset_faces(asset, frame_numbers, resolution) #type:ignore[arg-type]
+					vision_frames = capture_asset_faces(asset, frame_indexes, resolution) #type:ignore[arg-type]
 
 				if is_vision_frames(vision_frames):
 					return Response(content = to_strip_buffer(vision_frames), media_type = 'image/jpeg')

facefusion/args_helper.py

@@ -34,7 +34,7 @@ def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
 	apply_state_item('face_selector_race', args.get('face_selector_race'))
 	apply_state_item('reference_face_position', args.get('reference_face_position'))
 	apply_state_item('reference_face_distance', args.get('reference_face_distance'))
-	apply_state_item('reference_frame_number', args.get('reference_frame_number'))
+	apply_state_item('reference_frame_index', args.get('reference_frame_index'))
 	apply_state_item('face_tracker_score', args.get('face_tracker_score'))
 	apply_state_item('face_occluder_model', args.get('face_occluder_model'))
 	apply_state_item('face_parser_model', args.get('face_parser_model'))

facefusion/audio.py

@@ -56,11 +56,11 @@ def read_voice(audio_path : str, fps : Fps) -> Optional[List[AudioFrame]]:
 	return None
 
 
-def get_audio_frame(audio_path : str, fps : Fps, frame_number : int = 0) -> Optional[AudioFrame]:
+def get_audio_frame(audio_path : str, fps : Fps, frame_index : int = 0) -> Optional[AudioFrame]:
 	if is_audio(audio_path):
 		audio_frames = read_static_audio(audio_path, fps)
-		if frame_number in range(len(audio_frames)):
+		if frame_index in range(len(audio_frames)):
-			return audio_frames[frame_number]
+			return audio_frames[frame_index]
 	return None
 
 
@@ -78,11 +78,11 @@ def extract_audio_frames(spectrogram : Spectrogram, fps : Fps) -> List[AudioFram
 	return audio_frames
 
 
-def get_voice_frame(audio_path : str, fps : Fps, frame_number : int = 0) -> Optional[AudioFrame]:
+def get_voice_frame(audio_path : str, fps : Fps, frame_index : int = 0) -> Optional[AudioFrame]:
 	if is_audio(audio_path):
 		voice_frames = read_static_voice(audio_path, fps)
-		if frame_number in range(len(voice_frames)):
+		if frame_index in range(len(voice_frames)):
-			return voice_frames[frame_number]
+			return voice_frames[frame_index]
 	return None
 
 

facefusion/content_analyser.py

@@ -169,10 +169,10 @@ def analyse_video(video_path : str, trim_frame_start : int, trim_frame_end : int
 		progress.set_title(translator.get('analysing'))
 		progress.count(frame_range)
 
-		for frame_number in frame_range:
+		for frame_index in frame_range:
 			vision_frame = video_manager.read_video_frame(video_reader)
 
-			if frame_number % int(video_fps) == 0:
+			if frame_index % int(video_fps) == 0:
 				if is_vision_frame(vision_frame):
 					total += 1
 

facefusion/core.py

@@ -101,7 +101,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) == '61e33ef3'
+	return hash_helper.create_hash(content_analyser_content) == 'b51ff11f'
 
 
 def processors_pre_check() -> bool:

facefusion/ffmpeg.py

@@ -25,8 +25,8 @@ def run_ffmpeg_with_progress(commands : List[Command], update_progress : UpdateP
 					process.terminate()
 
 				if 'frame=' in __line__:
-					_, frame_number = __line__.split('frame=')
+					_, frame_index = __line__.split('frame=')
-					update_progress(int(frame_number))
+					update_progress(int(frame_index))
 
 			if log_level == 'debug':
 				log_debug(process)
@@ -70,9 +70,9 @@ def open_ffmpeg(commands : List[Command]) -> subprocess.Popen[Buffer]:
 	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[Buffer]:
+def create_video_reader(video_path : str, frame_index : int, video_metadata : VideoReaderMetadata) -> subprocess.Popen[Buffer]:
 	commands = ffmpeg_builder.chain(
-		ffmpeg_builder.seek_to(frame_number / video_metadata.get('fps')),
+		ffmpeg_builder.seek_to(frame_index / video_metadata.get('fps')),
 		ffmpeg_builder.set_input(video_path),
 		ffmpeg_builder.restrict_color_transfer(video_metadata.get('color_transfer')),
 		ffmpeg_builder.prevent_frame_drop(),

facefusion/ffmpeg_builder.py

@@ -55,8 +55,8 @@ def set_input_fps(input_fps : Fps) -> List[Command]:
 	return [ '-r', str(input_fps) ]
 
 
-def set_start_number(frame_number : int) -> List[Command]:
+def set_start_number(frame_index : int) -> List[Command]:
-	return [ '-start_number', str(frame_number) ]
+	return [ '-start_number', str(frame_index) ]
 
 
 def set_output(output_path : str) -> List[Command]:

facefusion/frame_store.py

@@ -10,18 +10,18 @@ def get_frame_store(id : str) -> VisionFrameSet:
 	return FRAME_STORE_SET.get(id)
 
 
-def set_frame(id : str, frame_number : int, vision_frame : VisionFrame) -> None:
+def set_frame(id : str, frame_index : int, vision_frame : VisionFrame) -> None:
 	frame_store = get_frame_store(id)
-	frame_store[frame_number] = vision_frame
+	frame_store[frame_index] = vision_frame
 
 
 def select_frame_set(id : str, frame_start : int, frame_end : int) -> VisionFrameSet:
 	frame_store = get_frame_store(id)
 	frame_set = {}
 
-	for frame_number in range(frame_start, frame_end + 1):
+	for frame_index in range(frame_start, frame_end + 1):
-		if frame_number in frame_store:
+		if frame_index in frame_store:
-			frame_set[frame_number] = frame_store.get(frame_number)
+			frame_set[frame_index] = frame_store.get(frame_index)
 
 	return frame_set
 

facefusion/locales.py

@@ -122,7 +122,7 @@ LOCALES : Locales =\
 			'face_selector_race': 'filter the detected faces based on their race',
 			'reference_face_position': 'specify the position used to create the reference face',
 			'reference_face_distance': 'specify the similarity between the reference face and target face',
-			'reference_frame_number': 'specify the frame used to create the reference face',
+			'reference_frame_index': 'specify the frame used to create the reference face',
 			'face_tracker_score': 'specify the overlap score used to match the tracked faces',
 			'face_occluder_model': 'choose the model responsible for the occlusion mask',
 			'face_parser_model': 'choose the model responsible for the region mask',

facefusion/program.py

@@ -446,10 +446,10 @@ def create_face_selector_program() -> ArgumentParser:
 	capability_store.register_capability_set(
 		[
 			group_face_selector.add_argument(
-				'--reference-frame-number',
+				'--reference-frame-index',
-				help = translator.get('help.reference_frame_number'),
+				help = translator.get('help.reference_frame_index'),
 				type = int,
-				default = config.get_int_value('face_selector', 'reference_frame_number', '0')
+				default = config.get_int_value('face_selector', 'reference_frame_index', '0')
 			)
 		],
 		scopes = [ 'api', 'cli' ],

facefusion/temp_helper.py

@@ -26,8 +26,8 @@ def resolve_temp_frame_set(temp_path : str, output_path : str, temp_frame_format
 	temp_frame_set = {}
 
 	for temp_frame_path in resolve_file_pattern(temp_frames_pattern):
-		frame_number = int(get_file_name(temp_frame_path))
+		frame_index = int(get_file_name(temp_frame_path))
-		temp_frame_set[frame_number] = temp_frame_path
+		temp_frame_set[frame_index] = temp_frame_path
 
 	return temp_frame_set
 

facefusion/types.py

@@ -257,7 +257,7 @@ VideoReader = TypedDict('VideoReader',
 	'file_path' : str,
 	'process' : subprocess.Popen[bytes],
 	'metadata' : VideoReaderMetadata,
-	'frame_number' : int
+	'frame_index' : int
 })
 VideoReaderSet : TypeAlias = Dict[str, VideoReader]
 VideoWriter = TypedDict('VideoWriter',
@@ -544,7 +544,7 @@ StateKey = Literal\
 	'face_selector_age_end',
 	'reference_face_position',
 	'reference_face_distance',
-	'reference_frame_number',
+	'reference_frame_index',
 	'face_tracker_score',
 	'face_occluder_model',
 	'face_parser_model',
@@ -620,7 +620,7 @@ State = TypedDict('State',
 	'face_selector_age_end' : int,
 	'reference_face_position' : int,
 	'reference_face_distance' : float,
-	'reference_frame_number' : int,
+	'reference_frame_index' : int,
 	'face_tracker_score' : Score,
 	'face_occluder_model' : FaceOccluderModel,
 	'face_parser_model' : FaceParserModel,

facefusion/video_manager.py

@@ -28,30 +28,30 @@ def get_reader(video_path : str, context : str) -> VideoReader:
 			'file_path': video_path,
 			'process': ffmpeg.create_video_reader(video_path, 0, video_metadata),
 			'metadata': video_metadata,
-			'frame_number': 0
+			'frame_index': 0
 		}
 
 	return VIDEO_POOL_SET.get('reader').get(reader_id)
 
 
-def conditional_seek_video_reader(video_reader : VideoReader, frame_number : int = 0) -> None:
+def conditional_seek_video_reader(video_reader : VideoReader, frame_index : int = 0) -> None:
 	frame_total = video_reader.get('metadata').get('frame_total')
-	frame_number = min(frame_total - 1, frame_number)
+	frame_index = min(frame_total - 1, frame_index)
-	skip_total = frame_number - video_reader.get('frame_number')
+	skip_total = frame_index - video_reader.get('frame_index')
 	skip_margin = 128
 
 	if 0 < skip_total <= skip_margin:
 		drain_video_reader(video_reader, skip_total)
 
-	if not video_reader.get('frame_number') == frame_number:
+	if not video_reader.get('frame_index') == frame_index:
-		seek_video_reader(video_reader, frame_number)
+		seek_video_reader(video_reader, frame_index)
 
 
-def seek_video_reader(video_reader : VideoReader, frame_number : int = 0) -> None:
+def seek_video_reader(video_reader : VideoReader, frame_index : int = 0) -> None:
 	close_video_reader(video_reader)
 
-	video_reader['process'] = ffmpeg.create_video_reader(video_reader.get('file_path'), frame_number, video_reader.get('metadata'))
+	video_reader['process'] = ffmpeg.create_video_reader(video_reader.get('file_path'), frame_index, video_reader.get('metadata'))
-	video_reader['frame_number'] = frame_number
+	video_reader['frame_index'] = frame_index
 
 
 def drain_video_reader(video_reader : VideoReader, skip_total : int) -> None:
@@ -62,7 +62,7 @@ def drain_video_reader(video_reader : VideoReader, skip_total : int) -> None:
 	for _ in range(skip_total):
 		video_reader.get('process').stdout.read(frame_size)
 
-	video_reader['frame_number'] = video_reader.get('frame_number') + skip_total
+	video_reader['frame_index'] = video_reader.get('frame_index') + skip_total
 
 
 def read_video_frame(video_reader : VideoReader) -> Optional[VisionFrame]:
@@ -72,7 +72,7 @@ def read_video_frame(video_reader : VideoReader) -> Optional[VisionFrame]:
 	vision_frame = numpy.empty(width * height * channel_total, numpy.uint8)
 
 	if video_stream.readinto(vision_frame) == vision_frame.size:
-		video_reader['frame_number'] = video_reader.get('frame_number') + 1
+		video_reader['frame_index'] = video_reader.get('frame_index') + 1
 		return vision_frame.reshape(height, width, channel_total)
 
 	return None
@@ -84,9 +84,9 @@ def read_video_frames(video_reader : VideoReader, frame_start : int, frame_end :
 	keep_margin = 4
 	frame_gaps = []
 
-	for frame_number in range(frame_start, frame_end + 1):
+	for frame_index in range(frame_start, frame_end + 1):
-		if frame_number not in frame_set:
+		if frame_index not in frame_set:
-			frame_gaps.append(frame_number)
+			frame_gaps.append(frame_index)
 
 	if frame_gaps:
 		collect_video_frames(video_reader, get_first(frame_gaps), get_last(frame_gaps))
@@ -97,17 +97,17 @@ def read_video_frames(video_reader : VideoReader, frame_start : int, frame_end :
 
 def collect_video_frames(video_reader : VideoReader, frame_start : int, frame_end : int) -> None:
 	reader_id = video_reader.get('id')
-	skip_total = frame_start - video_reader.get('frame_number')
+	skip_total = frame_start - video_reader.get('frame_index')
 	skip_margin = 16
 
 	if skip_total < 0 or skip_total > skip_margin:
 		seek_video_reader(video_reader, frame_start)
 
-	for frame_number in range(video_reader.get('frame_number'), frame_end + 1):
+	for frame_index in range(video_reader.get('frame_index'), frame_end + 1):
 		vision_frame = read_video_frame(video_reader)
 
 		if vision.is_vision_frame(vision_frame):
-			frame_store.set_frame(reader_id, frame_number, vision_frame)
+			frame_store.set_frame(reader_id, frame_index, vision_frame)
 
 
 def close_video_reader(video_reader : VideoReader) -> None:

facefusion/vision.py

@@ -72,36 +72,36 @@ def restrict_image_resolution(image_path : str, resolution : Resolution) -> Reso
 
 
 @lru_cache(maxsize = 64)
-def read_static_video_frame(video_path : str, frame_number : int = 0) -> Optional[VisionFrame]:
+def read_static_video_frame(video_path : str, frame_index : int = 0) -> Optional[VisionFrame]:
-	return read_video_frame(video_path, frame_number)
+	return read_video_frame(video_path, frame_index)
 
 
-def read_video_frame(video_path : str, frame_number : int = 0) -> Optional[VisionFrame]:
+def read_video_frame(video_path : str, frame_index : int = 0) -> Optional[VisionFrame]:
 	if is_video(video_path):
 		video_reader = video_manager.get_reader(video_path, 'read_video_frame')
 
 		with thread_semaphore():
-			video_manager.conditional_seek_video_reader(video_reader, frame_number)
+			video_manager.conditional_seek_video_reader(video_reader, frame_index)
 			return video_manager.read_video_frame(video_reader)
 
 	return None
 
 
-def select_video_frames(video_path : str, frame_number : int = 0, frame_offset : int = 2) -> List[VisionFrame]:
+def select_video_frames(video_path : str, frame_index : int = 0, frame_offset : int = 2) -> List[VisionFrame]:
 	vision_frames = []
-	frame_start = frame_number - frame_offset
+	frame_start = frame_index - frame_offset
-	frame_end = frame_number + frame_offset
+	frame_end = frame_index + frame_offset
 
 	if is_video(video_path):
 		with thread_lock():
 			video_reader = video_manager.get_reader(video_path, 'select_video_frames')
 			frame_set = video_manager.read_video_frames(video_reader, max(frame_start, 0), frame_end)
 
-			for frame_number in range(frame_start, frame_end + 1):
+			for frame_index in range(frame_start, frame_end + 1):
 				vision_frame = create_empty_vision_frame()
 
-				if frame_number in frame_set:
+				if frame_index in frame_set:
-					vision_frame = frame_set.get(frame_number)
+					vision_frame = frame_set.get(frame_index)
 
 				vision_frames.append(vision_frame)
 

facefusion/workflows/core.py

@@ -50,7 +50,7 @@ def clear() -> ErrorCode:
 	return 0
 
 
-def conditional_get_source_audio_frame(frame_number : int) -> AudioFrame:
+def conditional_get_source_audio_frame(frame_index : int) -> AudioFrame:
 	if state_manager.get_item('workflow_mode') in [ 'audio-to-image:frames', 'audio-to-image:video', 'image-to-video' ]:
 		source_audio_path = get_first(filter_audio_paths(state_manager.get_item('source_paths')))
 		fps = state_manager.get_item('output_audio_fps')
@@ -58,9 +58,9 @@ def conditional_get_source_audio_frame(frame_number : int) -> AudioFrame:
 		if state_manager.get_item('workflow_mode') == 'image-to-video':
 			trim_frame_start, _ = restrict_trim_video_frame(state_manager.get_item('target_path'), state_manager.get_item('trim_frame_start'), state_manager.get_item('trim_frame_end'))
 			fps = restrict_video_fps(state_manager.get_item('target_path'), state_manager.get_item('output_video_fps'))
-			frame_number = frame_number - trim_frame_start
+			frame_index = frame_index - trim_frame_start
 
-		source_audio_frame = get_audio_frame(source_audio_path, fps, frame_number)
+		source_audio_frame = get_audio_frame(source_audio_path, fps, frame_index)
 
 		if numpy.any(source_audio_frame):
 			return source_audio_frame
@@ -68,7 +68,7 @@ def conditional_get_source_audio_frame(frame_number : int) -> AudioFrame:
 	return create_empty_audio_frame()
 
 
-def conditional_get_source_voice_frame(frame_number : int) -> AudioFrame:
+def conditional_get_source_voice_frame(frame_index : int) -> AudioFrame:
 	if state_manager.get_item('workflow_mode') in [ 'audio-to-image:frames', 'audio-to-image:video', 'image-to-video' ]:
 		source_audio_path = get_first(filter_audio_paths(state_manager.get_item('source_paths')))
 		temp_fps = state_manager.get_item('output_audio_fps')
@@ -76,9 +76,9 @@ def conditional_get_source_voice_frame(frame_number : int) -> AudioFrame:
 		if state_manager.get_item('workflow_mode') == 'image-to-video':
 			trim_frame_start, _ = restrict_trim_video_frame(state_manager.get_item('target_path'), state_manager.get_item('trim_frame_start'), state_manager.get_item('trim_frame_end'))
 			temp_fps = restrict_video_fps(state_manager.get_item('target_path'), state_manager.get_item('output_video_fps'))
-			frame_number = frame_number - trim_frame_start
+			frame_index = frame_index - trim_frame_start
 
-		source_voice_frame = get_voice_frame(source_audio_path, temp_fps, frame_number)
+		source_voice_frame = get_voice_frame(source_audio_path, temp_fps, frame_index)
 
 		if numpy.any(source_voice_frame):
 			return source_voice_frame
@@ -88,22 +88,22 @@ def conditional_get_source_voice_frame(frame_number : int) -> AudioFrame:
 
 def conditional_get_reference_vision_frame() -> VisionFrame:
 	if state_manager.get_item('workflow_mode') in [ 'image-to-video', 'image-to-video:frames' ]:
-		return read_static_video_frame(state_manager.get_item('target_path'), state_manager.get_item('reference_frame_number'))
+		return read_static_video_frame(state_manager.get_item('target_path'), state_manager.get_item('reference_frame_index'))
 	return read_static_image(state_manager.get_item('target_path'))
 
 
-def conditional_get_target_vision_frames(frame_number : int) -> List[VisionFrame]:
+def conditional_get_target_vision_frames(frame_index : int) -> List[VisionFrame]:
 	if state_manager.get_item('workflow_mode') in [ 'image-to-video', 'image-to-video:frames' ]:
-		return select_video_frames(state_manager.get_item('target_path'), frame_number, state_manager.get_item('target_frame_amount'))
+		return select_video_frames(state_manager.get_item('target_path'), frame_index, state_manager.get_item('target_frame_amount'))
 	return [ read_static_image(state_manager.get_item('target_path')) ]
 
 
-def process_temp_frame(temp_frame_path : str, frame_number : int) -> bool:
+def process_temp_frame(temp_frame_path : str, frame_index : int) -> bool:
 	reference_vision_frame = conditional_get_reference_vision_frame()
 	source_vision_frames = read_static_images(state_manager.get_item('source_paths'))
-	source_audio_frame = conditional_get_source_audio_frame(frame_number)
+	source_audio_frame = conditional_get_source_audio_frame(frame_index)
-	source_voice_frame = conditional_get_source_voice_frame(frame_number)
+	source_voice_frame = conditional_get_source_voice_frame(frame_index)
-	target_vision_frames = conditional_get_target_vision_frames(frame_number)
+	target_vision_frames = conditional_get_target_vision_frames(frame_index)
 	temp_vision_frame = read_static_image(temp_frame_path, 'rgba').copy()
 	temp_vision_mask = extract_vision_mask(temp_vision_frame)
 
@@ -123,11 +123,11 @@ def process_temp_frame(temp_frame_path : str, frame_number : int) -> bool:
 	return write_image(temp_frame_path, temp_vision_frame)
 
 
-def process_temp_vision_frame(target_vision_frames : List[VisionFrame], temp_vision_frame : VisionFrame, frame_number : int) -> VisionFrame:
+def process_temp_vision_frame(target_vision_frames : List[VisionFrame], temp_vision_frame : VisionFrame, frame_index : int) -> VisionFrame:
 	reference_vision_frame = conditional_get_reference_vision_frame()
 	source_vision_frames = read_static_images(state_manager.get_item('source_paths'))
-	source_audio_frame = conditional_get_source_audio_frame(frame_number)
+	source_audio_frame = conditional_get_source_audio_frame(frame_index)
-	source_voice_frame = conditional_get_source_voice_frame(frame_number)
+	source_voice_frame = conditional_get_source_voice_frame(frame_index)
 	temp_vision_mask = extract_vision_mask(temp_vision_frame)
 
 	for processor_module in get_processors_modules(state_manager.get_item('processors')):
@@ -156,8 +156,8 @@ def process_frames() -> ErrorCode:
 			with ThreadPoolExecutor(max_workers = state_manager.get_item('execution_thread_count')) as executor:
 				futures : Deque[Future[bool]] = deque()
 
-				for frame_number, temp_frame_path in temp_frame_set.items():
+				for frame_index, temp_frame_path in temp_frame_set.items():
-					future = executor.submit(process_temp_frame, temp_frame_path, frame_number)
+					future = executor.submit(process_temp_frame, temp_frame_path, frame_index)
 					futures.append(future)
 
 				while futures:

facefusion/workflows/to_video.py

@@ -42,15 +42,15 @@ def create_temp_frames() -> ErrorCode:
 	return 0
 
 
-def process_memory_frame(frame_number : int, temp_video_resolution : Resolution, output_video_resolution : Resolution) -> VisionFrame:
+def process_memory_frame(frame_index : int, temp_video_resolution : Resolution, output_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_frames = select_video_frames(state_manager.get_item('target_path'), frame_index, state_manager.get_item('target_frame_amount'))
 	target_vision_frame = get_middle(target_vision_frames)
 	temp_vision_frame = target_vision_frame.copy()
 
 	if not (target_vision_frame.shape[1], target_vision_frame.shape[0]) == temp_video_resolution:
 		temp_vision_frame = cv2.resize(target_vision_frame, temp_video_resolution)
 
-	temp_vision_frame = process_temp_vision_frame(target_vision_frames, temp_vision_frame, frame_number)
+	temp_vision_frame = process_temp_vision_frame(target_vision_frames, temp_vision_frame, frame_index)
 
 	if not (temp_vision_frame.shape[1], temp_vision_frame.shape[0]) == output_video_resolution:
 		temp_vision_frame = cv2.resize(temp_vision_frame, output_video_resolution)
@@ -78,13 +78,13 @@ def process_memory_frames() -> ErrorCode:
 			progress.set_title(translator.get('processing'))
 			progress.count(temp_frame_range)
 
-			read_static_video_frame(state_manager.get_item('target_path'), state_manager.get_item('reference_frame_number'))
+			read_static_video_frame(state_manager.get_item('target_path'), state_manager.get_item('reference_frame_index'))
 
 			with ThreadPoolExecutor(max_workers = state_manager.get_item('execution_thread_count')) as executor:
 				futures : Deque[Future[VisionFrame]] = deque()
 
-				for frame_number in temp_frame_range:
+				for frame_index in temp_frame_range:
-					future = executor.submit(process_memory_frame, frame_number, temp_video_resolution, output_video_resolution)
+					future = executor.submit(process_memory_frame, frame_index, temp_video_resolution, output_video_resolution)
 					futures.append(future)
 
 				while futures:

tests/test_cli_batch_runner.py

@@ -17,15 +17,15 @@ def before_all() -> None:
 		'https://github.com/facefusion/facefusion-assets/releases/download/examples-3.0.0/target-240p.mp4'
 	])
 
-	for frame_number in [ 1, 2 ]:
+	for frame_index in [ 1, 2 ]:
 		ffmpeg.run_ffmpeg(
 			ffmpeg_builder.chain(
 				ffmpeg_builder.set_input(get_test_example_file('target-240p.mp4')),
 				[
 					'-vframes',
-					str(frame_number)
+					str(frame_index)
 				],
-				ffmpeg_builder.set_output(get_test_example_file('target-240p-batch-' + str(frame_number) + '.jpg'))
+				ffmpeg_builder.set_output(get_test_example_file('target-240p-batch-' + str(frame_index) + '.jpg'))
 			)
 		)
 

tests/test_frame_store.py

@@ -54,8 +54,8 @@ def test_select_frame_set() -> None:
 def test_reduce_frames() -> None:
 	target_frame = read_video_frame(get_test_example_file('target-240p.mp4'), 0)
 
-	for frame_number in range(0, 10):
+	for frame_index in range(0, 10):
-		set_frame('reader-1', frame_number, target_frame)
+		set_frame('reader-1', frame_index, target_frame)
 
 	reduce_frames('reader-1', 4, 6)
 

tests/test_video_manager.py

@@ -59,26 +59,26 @@ def test_conditional_seek_video_reader() -> None:
 	video_reader = get_reader(get_test_example_file('target-240p-25fps.mp4'), 'read_video_frame')
 	video_frames = {}
 
-	for frame_number in range(30):
+	for frame_index in range(30):
-		video_frames[frame_number] = read_video_frame(video_reader)
+		video_frames[frame_index] = read_video_frame(video_reader)
 
-	for frame_number in [ 5, 17, 29 ]:
+	for frame_index in [ 5, 17, 29 ]:
-		conditional_seek_video_reader(video_reader, frame_number)
+		conditional_seek_video_reader(video_reader, frame_index)
 
-		assert numpy.array_equal(read_video_frame(video_reader), video_frames.get(frame_number)) is True
+		assert numpy.array_equal(read_video_frame(video_reader), video_frames.get(frame_index)) is True
 
 
 def test_seek_video_reader() -> None:
 	video_reader = get_reader(get_test_example_file('target-240p-25fps.mp4'), 'read_video_frame')
 	video_frames = {}
 
-	for frame_number in range(30):
+	for frame_index in range(30):
-		video_frames[frame_number] = read_video_frame(video_reader)
+		video_frames[frame_index] = read_video_frame(video_reader)
 
-	for frame_number in [ 5, 17, 29 ]:
+	for frame_index in [ 5, 17, 29 ]:
-		seek_video_reader(video_reader, frame_number)
+		seek_video_reader(video_reader, frame_index)
 
-		assert numpy.array_equal(read_video_frame(video_reader), video_frames.get(frame_number)) is True
+		assert numpy.array_equal(read_video_frame(video_reader), video_frames.get(frame_index)) is True
 
 
 def test_drain_video_reader() -> None:
@@ -86,7 +86,7 @@ def test_drain_video_reader() -> None:
 
 	drain_video_reader(video_reader, 10)
 
-	assert video_reader.get('frame_number') == 10
+	assert video_reader.get('frame_index') == 10
 
 	vision_frame = read_video_frame(video_reader)
 	seek_video_reader(video_reader, 10)
@@ -98,7 +98,7 @@ def test_read_video_frame() -> None:
 	video_reader = get_reader(get_test_example_file('target-240p-25fps.mp4'), 'read_video_frame')
 
 	assert read_video_frame(video_reader).shape == (226, 426, 3)
-	assert video_reader.get('frame_number') == 1
+	assert video_reader.get('frame_index') == 1
 
 	seek_video_reader(video_reader, 269)
 
@@ -111,10 +111,10 @@ def test_read_video_frames() -> None:
 
 	assert sorted(read_video_frames(video_reader, 0, 4)) == [ 0, 1, 2, 3, 4 ]
 
-	frame_number = video_reader.get('frame_number')
+	frame_index = video_reader.get('frame_index')
 
 	assert sorted(read_video_frames(video_reader, 1, 3)) == [ 1, 2, 3 ]
-	assert video_reader.get('frame_number') == frame_number
+	assert video_reader.get('frame_index') == frame_index
 
 	read_video_frames(video_reader, 21, 25)
 
@@ -129,7 +129,7 @@ def test_collect_video_frames() -> None:
 	collect_video_frames(video_reader, 20, 24)
 
 	assert sorted(get_frame_store(video_reader.get('id'))) == [ 20, 21, 22, 23, 24 ]
-	assert video_reader.get('frame_number') == 25
+	assert video_reader.get('frame_index') == 25
 
 
 def test_close_video_reader() -> None:
@@ -159,7 +159,7 @@ def test_write_video_frame() -> None:
 	video_reader = get_reader(target_path, 'read_video_frame')
 	video_writer = get_writer(target_path, 25.0, (426, 226), (426, 226), 25.0)
 
-	for frame_number in range(25):
+	for frame_index in range(25):
 		write_video_frame(video_writer, read_video_frame(video_reader))
 
 	assert close_video_writer(video_writer) is True