sora-sdk 2025.1.0.dev10__tar.gz → 2025.1.0.dev12__tar.gz

{sora_sdk-2025.1.0.dev10/src/sora_sdk.egg-info → sora_sdk-2025.1.0.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: sora_sdk
-Version: 2025.1.0.dev10
+Version: 2025.1.0.dev12
 Summary: WebRTC SFU Sora Python SDK
 Home-page: https://github.com/shiguredo/sora-python-sdk
 Author-email: "Shiguredo Inc." <contact+pypi@shiguredo.jp>

{sora_sdk-2025.1.0.dev10 → sora_sdk-2025.1.0.dev12}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "sora_sdk"
 authors = [{ name = "Shiguredo Inc.", email = "contact+pypi@shiguredo.jp" }]
-version = "2025.1.0.dev10"
+version = "2025.1.0.dev12"
 description = "WebRTC SFU Sora Python SDK"
 readme = "README.md"
 license = { file = "LICENSE" }

{sora_sdk-2025.1.0.dev10 → sora_sdk-2025.1.0.dev12/src/sora_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: sora_sdk
-Version: 2025.1.0.dev10
+Version: 2025.1.0.dev12
 Summary: WebRTC SFU Sora Python SDK
 Home-page: https://github.com/shiguredo/sora-python-sdk
 Author-email: "Shiguredo Inc." <contact+pypi@shiguredo.jp>

{sora_sdk-2025.1.0.dev10 → sora_sdk-2025.1.0.dev12}/tests/test_apple_video_toolbox.py

@@ -1,22 +1,21 @@
+import os
 import sys
 import time
 import uuid
 
+import jwt
 import pytest
 from client import SoraClient, SoraRole
 
-"""
-GitHub Actions で Video Toolbox を送受信で利用しようとするとエラーになるので、
-テストを sendonly のみに絞っている
-"""
 
-
-@pytest.mark.skipif(sys.platform != "darwin", reason="macOS でのみ実行する")
+@pytest.mark.skipif(
+    os.environ.get("APPLE_VIDEO_TOOLBOX") is None, reason="Apple Video Toolbox でのみ実行する"
+)
 @pytest.mark.parametrize(
     "video_codec_type",
     ["H264", "H265"],
 )
-def test_macos_video_hwa_sendonly(setup, video_codec_type):
+def test_apple_video_toolbox_sendonly(setup, video_codec_type):
     signaling_urls = setup.get("signaling_urls")
     channel_id_prefix = setup.get("channel_id_prefix")
     metadata = setup.get("metadata")
@@ -57,7 +56,73 @@ def test_macos_video_hwa_sendonly(setup, video_codec_type):
     assert outbound_rtp_stats["packetsSent"] > 0
 
 
-@pytest.mark.skipif(sys.platform != "darwin", reason="macOS でのみ実行する")
+@pytest.mark.skipif(
+    os.environ.get("APPLE_VIDEO_TOOLBOX") is None, reason="Apple Video Toolbox でのみ実行する"
+)
+@pytest.mark.parametrize(
+    "video_codec_type",
+    ["H264", "H265"],
+)
+def test_apple_video_toolbox_sendonly_recvonly(setup, video_codec_type):
+    signaling_urls = setup.get("signaling_urls")
+    channel_id_prefix = setup.get("channel_id_prefix")
+    metadata = setup.get("metadata")
+
+    channel_id = f"{channel_id_prefix}_{__name__}_{sys._getframe().f_code.co_name}_{uuid.uuid4()}"
+
+    sendonly = SoraClient(
+        signaling_urls,
+        SoraRole.SENDONLY,
+        channel_id,
+        audio=False,
+        video=True,
+        video_codec_type=video_codec_type,
+        metadata=metadata,
+    )
+    sendonly.connect(fake_video=True)
+
+    recvonly = SoraClient(
+        signaling_urls,
+        SoraRole.RECVONLY,
+        channel_id,
+        metadata=metadata,
+    )
+    recvonly.connect()
+
+    time.sleep(5)
+
+    sendonly_stats = sendonly.get_stats()
+    recvonly_stats = recvonly.get_stats()
+
+    sendonly.disconnect()
+    recvonly.disconnect()
+
+    # codec が無かったら StopIteration 例外が上がる
+    sendonly_codec_stats = next(s for s in sendonly_stats if s.get("type") == "codec")
+    # 指定した video_codec_type が採用されているかどうか確認する
+    assert sendonly_codec_stats["mimeType"] == f"video/{video_codec_type}"
+
+    # outbound-rtp が無かったら StopIteration 例外が上がる
+    outbound_rtp_stats = next(s for s in sendonly_stats if s.get("type") == "outbound-rtp")
+    assert outbound_rtp_stats["encoderImplementation"] == "VideoToolbox"
+    assert outbound_rtp_stats["bytesSent"] > 0
+    assert outbound_rtp_stats["packetsSent"] > 0
+
+    # codec が無かったら StopIteration 例外が上がる
+    recvonly_codec_stats = next(s for s in recvonly_stats if s.get("type") == "codec")
+    # 指定した video_codec_type が採用されているかどうか確認する
+    assert recvonly_codec_stats["mimeType"] == f"video/{video_codec_type}"
+
+    # outbound-rtp が無かったら StopIteration 例外が上がる
+    inbound_rtp_stats = next(s for s in recvonly_stats if s.get("type") == "inbound-rtp")
+    assert inbound_rtp_stats["decoderImplementation"] == "VideoToolbox"
+    assert inbound_rtp_stats["bytesReceived"] > 0
+    assert inbound_rtp_stats["packetsReceived"] > 0
+
+
+@pytest.mark.skipif(
+    os.environ.get("APPLE_VIDEO_TOOLBOX") is None, reason="Apple Video Toolbox でのみ実行する"
+)
 @pytest.mark.parametrize(
     (
         "video_codec_type",
@@ -89,7 +154,7 @@ def test_macos_video_hwa_sendonly(setup, video_codec_type):
         ("H265", "VideoToolbox", 200, 320, 180, 1),
     ],
 )
-def test_macos_simulcast(
+def test_apple_video_toolbox_simulcast(
     setup,
     video_codec_type,
     expected_implementation,
@@ -186,115 +251,192 @@ def test_macos_simulcast(
             )
 
 
-@pytest.mark.skip(reason="ローカルでは成功する")
-def test_macos_h264_sendonly_recvonly(setup):
+@pytest.mark.skipif(
+    os.environ.get("APPLE_VIDEO_TOOLBOX") is None, reason="Apple Video Toolbox でのみ実行する"
+)
+@pytest.mark.parametrize(
+    (
+        "video_codec_type",
+        "encoder_implementation",
+        "video_bit_rate",
+        "video_width",
+        "video_height",
+    ),
+    [
+        # どうやら scaleResolutionDownTo を指定すると規定されたテーブルのビットレートでは足りない模様
+        ("H264", "VideoToolbox", 1000, 320, 180),
+        ("H265", "VideoToolbox", 1000, 320, 180),
+    ],
+)
+def test_apple_video_toolbox_simulcast_authz_scale_resolution_to(
+    setup,
+    video_codec_type,
+    encoder_implementation,
+    video_bit_rate,
+    video_width,
+    video_height,
+):
     signaling_urls = setup.get("signaling_urls")
     channel_id_prefix = setup.get("channel_id_prefix")
-    metadata = setup.get("metadata")
+    secret = setup.get("secret")
 
     channel_id = f"{channel_id_prefix}_{__name__}_{sys._getframe().f_code.co_name}_{uuid.uuid4()}"
 
+    simulcast_encodings = [
+        {
+            "rid": "r0",
+            "active": True,
+            "scaleResolutionDownTo": {"maxWidth": 320, "maxHeight": 180},
+            "scalabilityMode": "L1T1",
+        },
+        {
+            "rid": "r1",
+            "active": True,
+            "scaleResolutionDownTo": {"maxWidth": 320, "maxHeight": 180},
+            "scalabilityMode": "L1T1",
+        },
+        {
+            "rid": "r2",
+            "active": True,
+            "scaleResolutionDownTo": {"maxWidth": 320, "maxHeight": 180},
+            "scalabilityMode": "L1T1",
+        },
+    ]
+
+    access_token = jwt.encode(
+        {
+            "channel_id": channel_id,
+            "video": True,
+            "video_codec_type": video_codec_type,
+            "video_bit_rate": video_bit_rate,
+            "simulcast": True,
+            "simulcast_encodings": simulcast_encodings,
+            # 現在時刻 + 300 秒 (5分)
+            "exp": int(time.time()) + 300,
+        },
+        secret,
+        algorithm="HS256",
+    )
+
     sendonly = SoraClient(
         signaling_urls,
         SoraRole.SENDONLY,
         channel_id,
         audio=False,
         video=True,
-        video_codec_type="H264",
-        metadata=metadata,
-    )
-    sendonly.connect()
-
-    recvonly = SoraClient(
-        signaling_urls,
-        SoraRole.RECVONLY,
-        channel_id,
-        metadata=metadata,
+        metadata={"access_token": access_token},
+        video_width=video_width,
+        video_height=video_height,
     )
-    recvonly.connect()
+    sendonly.connect(fake_video=True)
 
     time.sleep(5)
 
-    sendonly_stats = sendonly.get_stats()
-    recvonly_stats = recvonly.get_stats()
+    # "type": "offer" の SDP で Simulcast があるかどうか
+    assert sendonly.offer_message is not None
+    assert sendonly.offer_message["sdp"] is not None
+    assert video_codec_type in sendonly.offer_message["sdp"]
+    assert "a=simulcast:recv r0;r1;r2" in sendonly.offer_message["sdp"]
 
-    sendonly.disconnect()
-    recvonly.disconnect()
+    assert "encodings" in sendonly.offer_message
+    assert len(sendonly.offer_message["encodings"]) == 3
 
-    # codec が無かったら StopIteration 例外が上がる
-    sendonly_codec_stats = next(s for s in sendonly_stats if s.get("type") == "codec")
-    # H.264 が採用されているかどうか確認する
-    assert sendonly_codec_stats["mimeType"] == "video/H264"
+    assert sendonly.offer_message["encodings"][0]["rid"] == simulcast_encodings[0]["rid"]
+    assert sendonly.offer_message["encodings"][1]["rid"] == simulcast_encodings[1]["rid"]
+    assert sendonly.offer_message["encodings"][2]["rid"] == simulcast_encodings[2]["rid"]
 
-    # outbound-rtp が無かったら StopIteration 例外が上がる
-    outbound_rtp_stats = next(s for s in sendonly_stats if s.get("type") == "outbound-rtp")
-    assert outbound_rtp_stats["encoderImplementation"] == "VideoToolbox"
-    assert outbound_rtp_stats["bytesSent"] > 0
-    assert outbound_rtp_stats["packetsSent"] > 0
+    assert sendonly.offer_message["encodings"][0]["active"] == simulcast_encodings[0]["active"]
+    assert sendonly.offer_message["encodings"][1]["active"] == simulcast_encodings[1]["active"]
+    assert sendonly.offer_message["encodings"][2]["active"] == simulcast_encodings[2]["active"]
 
-    # codec が無かったら StopIteration 例外が上がる
-    recvonly_codec_stats = next(s for s in recvonly_stats if s.get("type") == "codec")
-    # H.264 が採用されているかどうか確認する
-    assert recvonly_codec_stats["mimeType"] == "video/H264"
-
-    # outbound-rtp が無かったら StopIteration 例外が上がる
-    inbound_rtp_stats = next(s for s in recvonly_stats if s.get("type") == "inbound-rtp")
-    assert inbound_rtp_stats["decoderImplementation"] == "VideoToolbox"
-    assert inbound_rtp_stats["bytesReceived"] > 0
-    assert inbound_rtp_stats["packetsReceived"] > 0
-
-
-@pytest.mark.skip(reason="ローカルでは成功する")
-def test_macos_h265_sendonly_recvonly(setup):
-    signaling_urls = setup.get("signaling_urls")
-    channel_id_prefix = setup.get("channel_id_prefix")
-    metadata = setup.get("metadata")
+    assert (
+        sendonly.offer_message["encodings"][0]["scaleResolutionDownTo"]["maxWidth"]
+        == simulcast_encodings[0]["scaleResolutionDownTo"]["maxWidth"]
+    )
+    assert (
+        sendonly.offer_message["encodings"][1]["scaleResolutionDownTo"]["maxWidth"]
+        == simulcast_encodings[1]["scaleResolutionDownTo"]["maxWidth"]
+    )
+    assert (
+        sendonly.offer_message["encodings"][2]["scaleResolutionDownTo"]["maxWidth"]
+        == simulcast_encodings[2]["scaleResolutionDownTo"]["maxWidth"]
+    )
 
-    channel_id = f"{channel_id_prefix}_{__name__}_{sys._getframe().f_code.co_name}_{uuid.uuid4()}"
+    assert (
+        sendonly.offer_message["encodings"][0]["scalabilityMode"]
+        == simulcast_encodings[0]["scalabilityMode"]
+    )
 
-    sendonly = SoraClient(
-        signaling_urls,
-        SoraRole.SENDONLY,
-        channel_id,
-        audio=False,
-        video=True,
-        video_codec_type="H265",
-        metadata=metadata,
+    assert (
+        sendonly.offer_message["encodings"][1]["scalabilityMode"]
+        == simulcast_encodings[1]["scalabilityMode"]
     )
-    sendonly.connect()
 
-    recvonly = SoraClient(
-        signaling_urls,
-        SoraRole.RECVONLY,
-        channel_id,
-        metadata=metadata,
+    assert (
+        sendonly.offer_message["encodings"][2]["scalabilityMode"]
+        == simulcast_encodings[2]["scalabilityMode"]
     )
-    recvonly.connect()
 
-    time.sleep(5)
+    # "type": "answer" の SDP で Simulcast があるかどうか
+    assert sendonly.answer_message is not None
+    assert "sdp" in sendonly.answer_message
+    assert "a=simulcast:send r0;r1;r2" in sendonly.answer_message["sdp"]
 
     sendonly_stats = sendonly.get_stats()
-    recvonly_stats = recvonly.get_stats()
-
     sendonly.disconnect()
-    recvonly.disconnect()
 
     # codec が無かったら StopIteration 例外が上がる
     sendonly_codec_stats = next(s for s in sendonly_stats if s.get("type") == "codec")
-    assert sendonly_codec_stats["mimeType"] == "video/H265"
+    assert sendonly_codec_stats["mimeType"] == f"video/{video_codec_type}"
 
-    # outbound-rtp が無かったら StopIteration 例外が上がる
-    outbound_rtp_stats = next(s for s in sendonly_stats if s.get("type") == "outbound-rtp")
-    assert outbound_rtp_stats["encoderImplementation"] == "VideoToolbox"
-    assert outbound_rtp_stats["bytesSent"] > 0
-    assert outbound_rtp_stats["packetsSent"] > 0
+    # 複数の outbound-rtp 統計情報を取得
+    outbound_rtp_stats = [
+        s for s in sendonly_stats if s.get("type") == "outbound-rtp" and s.get("kind") == "video"
+    ]
+    # simulcast_count に関係なく統計情報はかならず 3 本出力される
+    # これは SDP で rid で ~r0 とかやる減るはず
+    assert len(outbound_rtp_stats) == 3
 
-    # codec が無かったら StopIteration 例外が上がる
-    recvonly_codec_stats = next(s for s in recvonly_stats if s.get("type") == "codec")
-    assert recvonly_codec_stats["mimeType"] == "video/H265"
+    # rid でソート
+    sorted_stats = sorted(outbound_rtp_stats, key=lambda x: x.get("rid", ""))
 
-    # outbound-rtp が無かったら StopIteration 例外が上がる
-    inbound_rtp_stats = next(s for s in recvonly_stats if s.get("type") == "inbound-rtp")
-    assert inbound_rtp_stats["decoderImplementation"] == "VideoToolbox"
-    assert inbound_rtp_stats["bytesReceived"] > 0
-    assert inbound_rtp_stats["packetsReceived"] > 0
+    for i, s in enumerate(sorted_stats):
+        assert s["rid"] == f"r{i}"
+        assert s["kind"] == "video"
+
+        # VP8 の場合は scaleResolutionDownTo を指定すると SimulcastEncoderAdapter が無くなる
+        # TODO: 念のため他の挙動も確認すること
+        if video_codec_type == "VP9":
+            assert "SimulcastEncoderAdapter" in s["encoderImplementation"]
+        assert encoder_implementation in s["encoderImplementation"]
+
+        assert s["keyFramesEncoded"] > 0
+        assert s["bytesSent"] > 500
+        assert s["packetsSent"] > 10
+
+        assert s["frameWidth"] == 320
+        assert s["frameHeight"] == 176
+
+        # FIXME:これは libwebrtc 側の挙動を制御できず L1T2 になってしまう
+        scalability_mode = None
+        # FIXME: scalabilityMode がない場合がある
+        if "scalabilityMode" in s:
+            scalability_mode = s["scalabilityMode"]
+            assert s["scalabilityMode"] == "L1T2"
+
+        # targetBitrate が指定したビットレートの 90% 以上、100% 以下に収まることを確認
+        expected_bitrate = video_bit_rate * 1000
+        print(
+            s["rid"],
+            video_codec_type,
+            s["encoderImplementation"],
+            scalability_mode,
+            expected_bitrate,
+            s["targetBitrate"],
+            s["frameWidth"],
+            s["frameHeight"],
+            s["bytesSent"],
+            s["packetsSent"],
+        )
+        # 期待値の 20% 以上、100% 以下に収まることを確認
+        assert expected_bitrate * 0.2 <= s["targetBitrate"] <= expected_bitrate

{sora_sdk-2025.1.0.dev10 → sora_sdk-2025.1.0.dev12}/tests/test_authz_simulcast.py

@@ -7,6 +7,7 @@ import pytest
 from client import SoraClient, SoraRole
 
 
+@pytest.mark.skipif(sys.platform == "darwin", reason="Apple では SW コーデックは動作させない")
 @pytest.mark.parametrize(
     (
         "video_codec_type",
@@ -91,7 +92,6 @@ def test_simulcast_authz_scale_resolution_to(
     assert sendonly.offer_message["sdp"] is not None
     assert video_codec_type in sendonly.offer_message["sdp"]
     assert "a=simulcast:recv r0;r1;r2" in sendonly.offer_message["sdp"]
-    sendonly_stats = sendonly.get_stats()
 
     assert "encodings" in sendonly.offer_message
     assert len(sendonly.offer_message["encodings"]) == 3
@@ -121,22 +121,25 @@ def test_simulcast_authz_scale_resolution_to(
         sendonly.offer_message["encodings"][0]["scalabilityMode"]
         == simulcast_encodings[0]["scalabilityMode"]
     )
+
     assert (
         sendonly.offer_message["encodings"][1]["scalabilityMode"]
         == simulcast_encodings[1]["scalabilityMode"]
     )
+
     assert (
         sendonly.offer_message["encodings"][2]["scalabilityMode"]
         == simulcast_encodings[2]["scalabilityMode"]
     )
 
-    sendonly.disconnect()
-
     # "type": "answer" の SDP で Simulcast があるかどうか
     assert sendonly.answer_message is not None
     assert "sdp" in sendonly.answer_message
     assert "a=simulcast:send r0;r1;r2" in sendonly.answer_message["sdp"]
 
+    sendonly_stats = sendonly.get_stats()
+    sendonly.disconnect()
+
     # codec が無かったら StopIteration 例外が上がる
     sendonly_codec_stats = next(s for s in sendonly_stats if s.get("type") == "codec")
     assert sendonly_codec_stats["mimeType"] == f"video/{video_codec_type}"
@@ -170,7 +173,11 @@ def test_simulcast_authz_scale_resolution_to(
         assert s["frameHeight"] == 352
 
         # FIXME:これは libwebrtc 側の挙動を制御できず L1T2 になってしまう
-        assert s["scalabilityMode"] == "L1T2"
+        scalability_mode = None
+        # FIXME: scalabilityMode がない場合がある
+        if "scalabilityMode" in s:
+            scalability_mode = s["scalabilityMode"]
+            assert s["scalabilityMode"] == "L1T2"
 
         # targetBitrate が指定したビットレートの 90% 以上、100% 以下に収まることを確認
         expected_bitrate = video_bit_rate * 1000
@@ -178,7 +185,7 @@ def test_simulcast_authz_scale_resolution_to(
             s["rid"],
             video_codec_type,
             s["encoderImplementation"],
-            s["scalabilityMode"],
+            scalability_mode,
             expected_bitrate,
             s["targetBitrate"],
             s["frameWidth"],

{sora_sdk-2025.1.0.dev10 → sora_sdk-2025.1.0.dev12}/tests/test_intel_vpl.py

@@ -4,7 +4,12 @@ import time
 import uuid
 
 import pytest
-from client import SoraClient, SoraRole
+from client import (
+    SoraClient,
+    SoraRole,
+    codec_type_string_to_codec_type,
+    is_codec_supported,
+)
 
 from sora_sdk import (
     SoraVideoCodecImplementation,
@@ -41,8 +46,10 @@ def test_intel_vpl_available(setup):
                         # Sora Python SDK では VPL VP9 Encoder が正常に動作しないため無効
                         assert c.encoder is False
                     case SoraVideoCodecType.AV1:
-                        assert c.decoder is True
-                        assert c.encoder is True
+                        # チップによって対応指定ないものがあるので判断しない
+                        # assert c.decoder is True
+                        # assert c.encoder is True
+                        pass
                     case SoraVideoCodecType.H264:
                         assert c.decoder is True
                         assert c.encoder is True
@@ -76,6 +83,9 @@ def test_intel_vpl_sendonly(
     expected_codec_implementation,
     preference_codec_implementation,
 ):
+    if not is_codec_supported(video_codec_type, SoraVideoCodecImplementation.INTEL_VPL):
+        pytest.skip(f"このチップでは {video_codec_type} がサポートされていません")
+
     signaling_urls = setup.get("signaling_urls")
     channel_id_prefix = setup.get("channel_id_prefix")
     metadata = setup.get("metadata")
@@ -184,6 +194,9 @@ def test_intel_vpl_simulcast(
     video_height,
     simulcast_count,
 ):
+    if not is_codec_supported(video_codec_type, SoraVideoCodecImplementation.INTEL_VPL):
+        pytest.skip(f"このチップでは {video_codec_type} がサポートされていません")
+
     signaling_urls = setup.get("signaling_urls")
     channel_id_prefix = setup.get("channel_id_prefix")
     metadata = setup.get("metadata")
@@ -205,15 +218,7 @@ def test_intel_vpl_simulcast(
         video_codec_preference=SoraVideoCodecPreference(
             codecs=[
                 SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.AV1,
-                    encoder=SoraVideoCodecImplementation.INTEL_VPL,
-                ),
-                SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.H264,
-                    encoder=SoraVideoCodecImplementation.INTEL_VPL,
-                ),
-                SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.H265,
+                    type=codec_type_string_to_codec_type(video_codec_type),
                     encoder=SoraVideoCodecImplementation.INTEL_VPL,
                 ),
             ]
@@ -315,6 +320,9 @@ def test_intel_vpl_sendonly_recvonly(
     expected_codec_implementation,
     preference_codec_implementation,
 ):
+    if not is_codec_supported(video_codec_type, SoraVideoCodecImplementation.INTEL_VPL):
+        pytest.skip(f"このチップでは {video_codec_type} がサポートされていません")
+
     signaling_urls = setup.get("signaling_urls")
     channel_id_prefix = setup.get("channel_id_prefix")
     metadata = setup.get("metadata")
@@ -579,6 +587,9 @@ def test_intel_vpl_vp9_sendonly_recvonly(setup):
 def test_intel_vpl_av1_mini_resolution(
     setup, video_codec_type, expected_implementation, video_bit_rate, video_width, video_height
 ):
+    if not is_codec_supported(video_codec_type, SoraVideoCodecImplementation.INTEL_VPL):
+        pytest.skip(f"このチップでは {video_codec_type} がサポートされていません")
+
     signaling_urls = setup.get("signaling_urls")
     channel_id_prefix = setup.get("channel_id_prefix")
     metadata = setup.get("metadata")
@@ -689,6 +700,10 @@ def test_intel_vpl_sendonly_recvonly_sw_hw(
     - 送信はソフトウェアだけど、受信はハードウェアでやる
     - 送信はハードウェアだけど、受信はソフトウェアでやる
     """
+
+    if not is_codec_supported(video_codec_type, SoraVideoCodecImplementation.INTEL_VPL):
+        pytest.skip(f"このチップでは {video_codec_type} がサポートされていません")
+
     signaling_urls = setup.get("signaling_urls")
     channel_id_prefix = setup.get("channel_id_prefix")
     metadata = setup.get("metadata")

{sora_sdk-2025.1.0.dev10 → sora_sdk-2025.1.0.dev12}/tests/test_nvidia_video_codec_sdk.py

@@ -4,9 +4,18 @@ import time
 import uuid
 
 import pytest
-from client import SoraClient, SoraRole
+from client import (
+    SoraClient,
+    SoraRole,
+    codec_type_string_to_codec_type,
+    is_codec_supported,
+)
 
-from sora_sdk import SoraVideoCodecImplementation, SoraVideoCodecPreference, SoraVideoCodecType
+from sora_sdk import (
+    SoraVideoCodecImplementation,
+    SoraVideoCodecPreference,
+    SoraVideoCodecType,
+)
 
 
 # @pytest.mark.skip()
@@ -19,13 +28,17 @@ from sora_sdk import SoraVideoCodecImplementation, SoraVideoCodecPreference, Sor
         "expected_implementation",
     ),
     [
-        ("VP9", "NvCodec"),
         ("AV1", "NvCodec"),
         ("H264", "NvCodec"),
         ("H265", "NvCodec"),
     ],
 )
-def test_intel_vpl_sendonly(setup, video_codec_type, expected_implementation):
+def test_nvidia_codec_sdk_sendonly(setup, video_codec_type, expected_implementation):
+    if not is_codec_supported(
+        video_codec_type, SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK
+    ):
+        pytest.skip(f"このチップでは {video_codec_type} がサポートされていません")
+
     signaling_urls = setup.get("signaling_urls")
     channel_id_prefix = setup.get("channel_id_prefix")
     metadata = setup.get("metadata")
@@ -43,15 +56,7 @@ def test_intel_vpl_sendonly(setup, video_codec_type, expected_implementation):
         video_codec_preference=SoraVideoCodecPreference(
             codecs=[
                 SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.AV1,
-                    encoder=SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK,
-                ),
-                SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.H264,
-                    encoder=SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK,
-                ),
-                SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.H265,
+                    type=codec_type_string_to_codec_type(video_codec_type),
                     encoder=SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK,
                 ),
             ]
@@ -108,34 +113,32 @@ def test_intel_vpl_sendonly(setup, video_codec_type, expected_implementation):
     # FIXME: AV1 では、解像度が一定数より低くなる場合、エラーになるのでコメントアウトしている
     [
         # 1080p
-        ("VP9", "NvCodec", 5000, 1920, 1080, 3),
+        ("AV1", "NvCodec", 5000, 1920, 1080, 3),
         ("H264", "NvCodec", 5000, 1920, 1080, 3),
         ("H265", "NvCodec", 5000, 1920, 1080, 3),
         # 720p
-        ("VP9", "NvCodec", 2500, 1280, 720, 3),
+        ("AV1", "NvCodec", 2500, 1280, 720, 3),
         ("H264", "NvCodec", 2500, 1280, 720, 3),
         ("H265", "NvCodec", 2500, 1280, 720, 3),
         # 540p
-        ("VP9", "NvCodec", 1200, 960, 540, 3),
+        ("AV1", "NvCodec", 1200, 960, 540, 3),
         ("H264", "NvCodec", 1200, 960, 540, 3),
         ("H265", "NvCodec", 1200, 960, 540, 3),
         # 360p
-        ("VP9", "NvCodec", 700, 640, 360, 2),
+        ("AV1", "NvCodec", 700, 640, 360, 2),
         ("H264", "NvCodec", 700, 640, 360, 2),
         ("H265", "NvCodec", 700, 640, 360, 2),
         # 270p
-        ("VP9", "NvCodec", 450, 480, 270, 2),
-        ("H264", "NvCodec", 450, 480, 270, 2),
-        ("H265", "NvCodec", 450, 480, 270, 2),
+        # ("H264", "NvCodec", 450, 480, 270, 2),
+        # ("H265", "NvCodec", 450, 480, 270, 2),
         # 180p
-        ("VP9", "NvCodec", 200, 320, 180, 1),
-        ("H264", "NvCodec", 200, 320, 180, 1),
-        ("H265", "NvCodec", 142, 320, 180, 1),
+        # ("H264", "NvCodec", 200, 320, 180, 1),
+        # ("H265", "NvCodec", 142, 320, 180, 1),
         # 135p
-        ("H265", "NvCodec", 101, 240, 135, 1),
+        # ("H265", "NvCodec", 101, 240, 135, 1),
     ],
 )
-def test_intel_vpl_simulcast(
+def test_nvidia_codec_sdk_simulcast(
     setup,
     video_codec_type,
     expected_implementation,
@@ -144,6 +147,11 @@ def test_intel_vpl_simulcast(
     video_height,
     simulcast_count,
 ):
+    if not is_codec_supported(
+        video_codec_type, SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK
+    ):
+        pytest.skip(f"このチップでは {video_codec_type} がサポートされていません")
+
     signaling_urls = setup.get("signaling_urls")
     channel_id_prefix = setup.get("channel_id_prefix")
     metadata = setup.get("metadata")
@@ -165,15 +173,7 @@ def test_intel_vpl_simulcast(
         video_codec_preference=SoraVideoCodecPreference(
             codecs=[
                 SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.AV1,
-                    encoder=SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK,
-                ),
-                SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.H264,
-                    encoder=SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK,
-                ),
-                SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.H265,
+                    type=codec_type_string_to_codec_type(video_codec_type),
                     encoder=SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK,
                 ),
             ]
@@ -258,13 +258,17 @@ def test_intel_vpl_simulcast(
         "expected_implementation",
     ),
     [
-        ("VP9", "NvCodec"),
         ("AV1", "NvCodec"),
         ("H264", "NvCodec"),
         ("H265", "NvCodec"),
     ],
 )
-def test_intel_vpl_sendonly_recvonly(setup, video_codec_type, expected_implementation):
+def test_nvidia_codec_sdk_sendonly_recvonly(setup, video_codec_type, expected_implementation):
+    if not is_codec_supported(
+        video_codec_type, SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK
+    ):
+        pytest.skip(f"このチップでは {video_codec_type} がサポートされていません")
+
     signaling_urls = setup.get("signaling_urls")
     channel_id_prefix = setup.get("channel_id_prefix")
     metadata = setup.get("metadata")
@@ -282,15 +286,7 @@ def test_intel_vpl_sendonly_recvonly(setup, video_codec_type, expected_implement
         video_codec_preference=SoraVideoCodecPreference(
             codecs=[
                 SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.AV1,
-                    encoder=SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK,
-                ),
-                SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.H264,
-                    encoder=SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK,
-                ),
-                SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.H265,
+                    type=codec_type_string_to_codec_type(video_codec_type),
                     encoder=SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK,
                 ),
             ]
@@ -306,15 +302,7 @@ def test_intel_vpl_sendonly_recvonly(setup, video_codec_type, expected_implement
         video_codec_preference=SoraVideoCodecPreference(
             codecs=[
                 SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.AV1,
-                    decoder=SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK,
-                ),
-                SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.H264,
-                    decoder=SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK,
-                ),
-                SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.H265,
+                    type=codec_type_string_to_codec_type(video_codec_type),
                     decoder=SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK,
                 ),
             ]
@@ -361,3 +349,94 @@ def test_intel_vpl_sendonly_recvonly(setup, video_codec_type, expected_implement
     assert inbound_rtp_stats["decoderImplementation"] == expected_implementation
     assert inbound_rtp_stats["bytesReceived"] > 0
     assert inbound_rtp_stats["packetsReceived"] > 0
+
+
+@pytest.mark.skipif(
+    os.environ.get("NVIDIA_VIDEO_SDK") is None, reason="NVIDIA Video Codec SDK でのみ実行する"
+)
+def test_nvidia_codec_sdk_vp9_hwa_decoder(setup):
+    """
+    NVIDIA Video Codec SDK VP9 はデコーダーは利用できるので、そのテスト
+    """
+    signaling_urls = setup.get("signaling_urls")
+    channel_id_prefix = setup.get("channel_id_prefix")
+    metadata = setup.get("metadata")
+
+    channel_id = f"{channel_id_prefix}_{__name__}_{sys._getframe().f_code.co_name}_{uuid.uuid4()}"
+
+    sendonly = SoraClient(
+        signaling_urls,
+        SoraRole.SENDONLY,
+        channel_id,
+        audio=False,
+        video=True,
+        video_codec_type="VP9",
+        metadata=metadata,
+        video_codec_preference=SoraVideoCodecPreference(
+            codecs=[
+                SoraVideoCodecPreference.Codec(
+                    type=SoraVideoCodecType.VP9,
+                    # NVIDIA Video Codec SDK で VP9 Encoder は搭載していないので INTERNAL を指定
+                    encoder=SoraVideoCodecImplementation.INTERNAL,
+                ),
+            ]
+        ),
+    )
+    sendonly.connect(fake_video=True)
+
+    recvonly = SoraClient(
+        signaling_urls,
+        SoraRole.RECVONLY,
+        channel_id,
+        metadata=metadata,
+        video_codec_preference=SoraVideoCodecPreference(
+            codecs=[
+                SoraVideoCodecPreference.Codec(
+                    type=SoraVideoCodecType.VP9,
+                    # NVIDIA Video Codec SDK で VP9 Decoder は搭載しているので NVIDIA_VIDEO_CODEC_SDK を指定
+                    decoder=SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK,
+                ),
+            ]
+        ),
+    )
+    recvonly.connect()
+
+    time.sleep(5)
+
+    sendonly_stats = sendonly.get_stats()
+    recvonly_stats = recvonly.get_stats()
+
+    sendonly.disconnect()
+    recvonly.disconnect()
+
+    # offer の sdp に video_codec_type が含まれているかどうかを確認している
+    assert sendonly.offer_message is not None
+    assert "sdp" in sendonly.offer_message
+    assert "VP9" in sendonly.offer_message["sdp"]
+
+    # answer の sdp に video_codec_type が含まれているかどうかを確認している
+    assert sendonly.answer_message is not None
+    assert "sdp" in sendonly.answer_message
+    assert "VP9" in sendonly.answer_message["sdp"]
+
+    # codec が無かったら StopIteration 例外が上がる
+    sendonly_codec_stats = next(s for s in sendonly_stats if s.get("type") == "codec")
+    # VP9 が採用されているかどうか確認する
+    assert sendonly_codec_stats["mimeType"] == "video/VP9"
+
+    # outbound-rtp が無かったら StopIteration 例外が上がる
+    outbound_rtp_stats = next(s for s in sendonly_stats if s.get("type") == "outbound-rtp")
+    assert outbound_rtp_stats["encoderImplementation"] == "libvpx"
+    assert outbound_rtp_stats["bytesSent"] > 0
+    assert outbound_rtp_stats["packetsSent"] > 0
+
+    # codec が無かったら StopIteration 例外が上がる
+    recvonly_codec_stats = next(s for s in recvonly_stats if s.get("type") == "codec")
+    # VP9 が採用されているかどうか確認する
+    assert recvonly_codec_stats["mimeType"] == "video/VP9"
+
+    # inbound-rtp が無かったら StopIteration 例外が上がる
+    inbound_rtp_stats = next(s for s in recvonly_stats if s.get("type") == "inbound-rtp")
+    assert inbound_rtp_stats["decoderImplementation"] == "NvCodec"
+    assert inbound_rtp_stats["bytesReceived"] > 0
+    assert inbound_rtp_stats["packetsReceived"] > 0