CalvinBackup/facefusion
1
0
Fork 0
mirror of https://github.com/facefusion/facefusion.git synced 2026-06-06 20:53:54 +02:00
Code Issues Packages Projects Releases Wiki Activity

Feat/remb both direction (#1145)

Browse Source 
* revamp remb to take both directions

* extract more methods
This commit is contained in:
Henry Ruhs
2026-06-03 10:31:33 +02:00
committed by GitHub
parent d9553b12e8
commit 2ac9b70550
8 changed files with 169 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test_api_stream_manager.py
+27 -27
View File
@@ -53,6 +53,30 @@ async def test_process_image() -> None:
assert create_hash(websocket_mock.send_bytes.call_args[0][0]) == '0142782f'
@pytest.mark.anyio
async def test_receive_vision_frames() -> None:
image_buffer = open(get_test_example_file('source.jpg'), 'rb').read()
websocket_mock = AsyncMock()
websocket_mock.receive.side_effect =\
[
{
'type': 'websocket.receive',
'bytes': image_buffer
},
{
'type': 'websocket.receive',
'bytes': 'invalid'.encode()
},
{
'type': 'websocket.disconnect'
}
]
vision_frames = receive_vision_frames(websocket_mock)
assert create_hash((await anext(vision_frames)).tobytes()) == '5ed32ca0'
@pytest.mark.parametrize('video_codec, session_id', [ ('av1', 'test-process-video-av1'), ('vp8', 'test-process-video-vp8') ])
def test_process_video(video_codec : VideoCodec, session_id : str) -> None:
peer_connection = rtc.create_peer_connection()
@@ -80,39 +104,15 @@ def test_process_video(video_codec : VideoCodec, session_id : str) -> None:
receiver_bitrate = peer.get('receiver_bitrate')
assert sender_bitrate.value == 0
assert receiver_bitrate.value == 0
assert receiver_bitrate.value == 8000
rtc.handle_remb(0, 8000000, ctypes.addressof(sender_bitrate))
rtc.handle_sender_bitrate(0, 8000000, ctypes.addressof(sender_bitrate))
assert sender_bitrate.value == 8000
rtc.handle_remb(0, 4000000, ctypes.addressof(receiver_bitrate))
rtc.adapt_receiver_bitrate(peer, 4000)
assert receiver_bitrate.value == 4000
@pytest.mark.anyio
async def test_receive_vision_frames() -> None:
image_buffer = open(get_test_example_file('source.jpg'), 'rb').read()
websocket_mock = AsyncMock()
websocket_mock.receive.side_effect =\
[
{
'type': 'websocket.receive',
'bytes': image_buffer
},
{
'type': 'websocket.receive',
'bytes': 'invalid'.encode()
},
{
'type': 'websocket.disconnect'
}
]
vision_frames = receive_vision_frames(websocket_mock)
assert create_hash((await anext(vision_frames)).tobytes()) == '5ed32ca0'
@pytest.mark.parametrize('video_codec, payload_type, session_id', [ ('av1', 35, 'test-run-peer-loop-av1'), ('vp8', 96, 'test-run-peer-loop-vp8') ])
def test_run_peer_loop(video_codec : VideoCodec, payload_type : int, session_id : SessionId) -> None:
peer_connection = rtc.create_peer_connection()
tests/test_api_stream_video.py
+31 -31
View File
@@ -56,7 +56,7 @@ def test_run_video_encode_loop(video_codec : VideoCodec, payload_type : int) ->
'codec': video_codec
},
'sender_bitrate': ctypes.c_uint(0),
'receiver_bitrate': ctypes.c_uint(0)
'receiver_bitrate': ctypes.c_uint(8000)
}
video_deque : deque[VideoPack] = deque()
@@ -86,6 +86,36 @@ def test_run_video_encode_loop(video_codec : VideoCodec, payload_type : int) ->
pytest.skip()
@pytest.mark.parametrize('video_codec', [ 'av1', 'vp8' ])
def test_receive_video_frames(video_codec : VideoCodec) -> None:
video_frame = read_video_frame(get_test_example_file('target-240p.mp4'))
video_deque : deque[VideoPack] = deque()
video_event = threading.Event()
datachannel_library_mock = MagicMock()
datachannel_library_mock.rtcReceiveMessage.side_effect = [ 0, -1 ]
with patch('facefusion.apis.stream_video.datachannel_module.create_static_library', return_value = datachannel_library_mock):
with patch('facefusion.apis.stream_video.decode_video_frame', return_value = video_frame):
rtc_peer_video : RtcPeerVideo =\
{
'sender_track': 0,
'receiver_track': 0,
'codec': video_codec
}
video_receiver_thread = threading.Thread(target = receive_video_frames, args = (rtc_peer_video, video_deque, video_event), daemon = True)
video_receiver_thread.start()
video_receiver_thread.join(timeout = 5.0)
vision_frame, _ = video_deque.popleft()
if is_linux() or is_windows():
assert create_hash(vision_frame.tobytes()) == 'a17439db'
if is_macos():
assert create_hash(vision_frame.tobytes()) == '38d00e2a'
@pytest.mark.parametrize('video_codec', [ 'av1', 'vp8' ])
def test_fill_video_deque(video_codec : VideoCodec) -> None:
video_frame = read_video_frame(get_test_example_file('target-240p.mp4'))
@@ -117,36 +147,6 @@ def test_fill_video_deque(video_codec : VideoCodec) -> None:
assert create_hash(vision_frame.tobytes()) == 'ff3ecb43'
@pytest.mark.parametrize('video_codec', [ 'av1', 'vp8' ])
def test_receive_video_frames(video_codec : VideoCodec) -> None:
video_frame = read_video_frame(get_test_example_file('target-240p.mp4'))
video_deque : deque[VideoPack] = deque()
video_event = threading.Event()
datachannel_library_mock = MagicMock()
datachannel_library_mock.rtcReceiveMessage.side_effect = [ 0, -1 ]
with patch('facefusion.apis.stream_video.datachannel_module.create_static_library', return_value = datachannel_library_mock):
with patch('facefusion.apis.stream_video.decode_video_frame', return_value = video_frame):
rtc_peer_video : RtcPeerVideo =\
{
'sender_track': 0,
'receiver_track': 0,
'codec': video_codec
}
video_receiver_thread = threading.Thread(target = receive_video_frames, args = (rtc_peer_video, video_deque, video_event), daemon = True)
video_receiver_thread.start()
video_receiver_thread.join(timeout = 5.0)
vision_frame, _ = video_deque.popleft()
if is_linux() or is_windows():
assert create_hash(vision_frame.tobytes()) == 'a17439db'
if is_macos():
assert create_hash(vision_frame.tobytes()) == '38d00e2a'
@pytest.mark.parametrize('video_codec', [ 'av1', 'vp8' ])
def test_encode_and_decode_video_frame(video_codec : VideoCodec) -> None:
video_frame = read_video_frame(get_test_example_file('target-240p.mp4'))
tests/test_rtc.py
+11 -11
View File
@@ -5,7 +5,7 @@ import pytest
from facefusion import state_manager
from facefusion.libraries import datachannel as datachannel_module, opus as opus_module, vpx as vpx_module
from facefusion.rtc import add_audio_track, add_video_track, create_peer_connection, create_sdp_answer, create_sdp_offer, delete_peers, get_payload_type, handle_remb, send_audio, send_video, set_remote_description, wire_remb
from facefusion.rtc import adapt_receiver_bitrate, add_audio_track, add_video_track, create_peer_connection, create_sdp_answer, create_sdp_offer, delete_peers, get_payload_type, handle_sender_bitrate, send_audio, send_video, set_remote_description, wire_sender_bitrate
from facefusion.types import RtcPeer, VideoCodec
@@ -153,7 +153,7 @@ def test_get_payload_type() -> None:
@pytest.mark.parametrize('video_codec, payload_type', [ ('av1', 35), ('vp8', 96) ])
def test_wire_remb(video_codec : VideoCodec, payload_type : int) -> None:
def test_wire_sender_bitrate(video_codec : VideoCodec, payload_type : int) -> None:
datachannel_library = datachannel_module.create_static_library()
peer_connection = create_peer_connection()
video_sender_track = add_video_track(peer_connection, 'sendonly', video_codec, payload_type)
@@ -170,38 +170,38 @@ def test_wire_remb(video_codec : VideoCodec, payload_type : int) -> None:
'receiver_bitrate': ctypes.c_uint(0)
}
wire_remb(video_sender_track, rtc_peer.get('sender_bitrate'))
wire_sender_bitrate(video_sender_track, rtc_peer.get('sender_bitrate'))
assert rtc_peer.get('sender_bitrate').value == 0
handle_remb(0, 6000000, ctypes.addressof(rtc_peer.get('sender_bitrate')))
handle_sender_bitrate(0, 8000000, ctypes.addressof(rtc_peer.get('sender_bitrate')))
assert rtc_peer.get('sender_bitrate').value == 6000
assert rtc_peer.get('sender_bitrate').value == 8000
datachannel_library.rtcDeletePeerConnection(peer_connection)
@pytest.mark.parametrize('video_codec, payload_type', [ ('av1', 35), ('vp8', 96) ])
def test_wire_remb_receiver(video_codec : VideoCodec, payload_type : int) -> None:
def test_adapt_receiver_bitrate(video_codec : VideoCodec, payload_type : int) -> None:
datachannel_library = datachannel_module.create_static_library()
peer_connection = create_peer_connection()
video_sender_track = add_video_track(peer_connection, 'sendonly', video_codec, payload_type)
video_receiver_track = add_video_track(peer_connection, 'recvonly', video_codec, payload_type)
rtc_peer : RtcPeer =\
{
'peer_connection': peer_connection,
'video':
{
'sender_track': video_receiver_track,
'sender_track': video_sender_track,
'receiver_track': video_receiver_track,
'codec': video_codec
},
'sender_bitrate': ctypes.c_uint(0),
'receiver_bitrate': ctypes.c_uint(0)
'receiver_bitrate': ctypes.c_uint(8000)
}
wire_remb(video_receiver_track, rtc_peer.get('receiver_bitrate'))
handle_remb(0, 6000000, ctypes.addressof(rtc_peer.get('receiver_bitrate')))
adapt_receiver_bitrate(rtc_peer, 4000)
assert rtc_peer.get('receiver_bitrate').value == 6000
assert rtc_peer.get('receiver_bitrate').value == 4000
datachannel_library.rtcDeletePeerConnection(peer_connection)