sora-sdk 2025.1.0.dev8__tar.gz → 2025.1.0.dev9__tar.gz

{sora_sdk-2025.1.0.dev8/src/sora_sdk.egg-info → sora_sdk-2025.1.0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: sora_sdk
-Version: 2025.1.0.dev8
+Version: 2025.1.0.dev9
 Summary: WebRTC SFU Sora Python SDK
 Home-page: https://github.com/shiguredo/sora-python-sdk
 Author-email: "Shiguredo Inc." <contact+pypi@shiguredo.jp>
@@ -233,11 +233,15 @@ Please read <https://github.com/shiguredo/oss/blob/master/README.en.md> before u
   - MAINTAIN_FRAMERATE / MAINTAIN_RESOLUTION / BALANCED が指定できる
 - Intel / Apple / NVIDIA のハードウェアデコーダー/エンコーダーに対応
   - Intel VPL (AV1 / H.264 / H.265)
+    - Ubuntu x86_64 / Windows x86_64 で利用できる
   - Apple Video Toolbox (H.264 / H.265)
+    - macOS arm64 で利用できる
   - NVIDIA Video Codec SDK (VP9 / H.264 / H.265)
+    - Ubuntu x86_64 / Windows x86_64 で利用できる
   - NVIDIA Jetson JetPack SDK (AV1 / H.264 / H.265)
   - [各プラットフォームで利用可能な HWA への対応](https://github.com/shiguredo/sora-cpp-sdk?tab=readme-ov-file#%E7%89%B9%E5%BE%B4)
 - [OpenH264](https://github.com/cisco/openh264) を利用した H.264 のソフトウェアエンコーダー/デコーダーに対応
+  - Ubuntu x86_64 / Ubuntu arm64 / Windows x86_64 / macOS arm64 で利用できる
 - 音声デバイス処理に [sounddevice](https://pypi.org/project/sounddevice/) などが利用できる
 - 映像デバイス処理に [opencv-python](https://pypi.org/project/opencv-python/) などが利用できる
 - 音声認識などの入力に受信した音声を利用できる

{sora_sdk-2025.1.0.dev8 → sora_sdk-2025.1.0.dev9}/README.md

@@ -34,11 +34,15 @@ Please read <https://github.com/shiguredo/oss/blob/master/README.en.md> before u
   - MAINTAIN_FRAMERATE / MAINTAIN_RESOLUTION / BALANCED が指定できる
 - Intel / Apple / NVIDIA のハードウェアデコーダー/エンコーダーに対応
   - Intel VPL (AV1 / H.264 / H.265)
+    - Ubuntu x86_64 / Windows x86_64 で利用できる
   - Apple Video Toolbox (H.264 / H.265)
+    - macOS arm64 で利用できる
   - NVIDIA Video Codec SDK (VP9 / H.264 / H.265)
+    - Ubuntu x86_64 / Windows x86_64 で利用できる
   - NVIDIA Jetson JetPack SDK (AV1 / H.264 / H.265)
   - [各プラットフォームで利用可能な HWA への対応](https://github.com/shiguredo/sora-cpp-sdk?tab=readme-ov-file#%E7%89%B9%E5%BE%B4)
 - [OpenH264](https://github.com/cisco/openh264) を利用した H.264 のソフトウェアエンコーダー/デコーダーに対応
+  - Ubuntu x86_64 / Ubuntu arm64 / Windows x86_64 / macOS arm64 で利用できる
 - 音声デバイス処理に [sounddevice](https://pypi.org/project/sounddevice/) などが利用できる
 - 映像デバイス処理に [opencv-python](https://pypi.org/project/opencv-python/) などが利用できる
 - 音声認識などの入力に受信した音声を利用できる

{sora_sdk-2025.1.0.dev8 → sora_sdk-2025.1.0.dev9}/pyproject.toml

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

{sora_sdk-2025.1.0.dev8 → sora_sdk-2025.1.0.dev9/src/sora_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: sora_sdk
-Version: 2025.1.0.dev8
+Version: 2025.1.0.dev9
 Summary: WebRTC SFU Sora Python SDK
 Home-page: https://github.com/shiguredo/sora-python-sdk
 Author-email: "Shiguredo Inc." <contact+pypi@shiguredo.jp>
@@ -233,11 +233,15 @@ Please read <https://github.com/shiguredo/oss/blob/master/README.en.md> before u
   - MAINTAIN_FRAMERATE / MAINTAIN_RESOLUTION / BALANCED が指定できる
 - Intel / Apple / NVIDIA のハードウェアデコーダー/エンコーダーに対応
   - Intel VPL (AV1 / H.264 / H.265)
+    - Ubuntu x86_64 / Windows x86_64 で利用できる
   - Apple Video Toolbox (H.264 / H.265)
+    - macOS arm64 で利用できる
   - NVIDIA Video Codec SDK (VP9 / H.264 / H.265)
+    - Ubuntu x86_64 / Windows x86_64 で利用できる
   - NVIDIA Jetson JetPack SDK (AV1 / H.264 / H.265)
   - [各プラットフォームで利用可能な HWA への対応](https://github.com/shiguredo/sora-cpp-sdk?tab=readme-ov-file#%E7%89%B9%E5%BE%B4)
 - [OpenH264](https://github.com/cisco/openh264) を利用した H.264 のソフトウェアエンコーダー/デコーダーに対応
+  - Ubuntu x86_64 / Ubuntu arm64 / Windows x86_64 / macOS arm64 で利用できる
 - 音声デバイス処理に [sounddevice](https://pypi.org/project/sounddevice/) などが利用できる
 - 映像デバイス処理に [opencv-python](https://pypi.org/project/opencv-python/) などが利用できる
 - 音声認識などの入力に受信した音声を利用できる

{sora_sdk-2025.1.0.dev8 → sora_sdk-2025.1.0.dev9}/src/sora_sdk.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ tests/test_authz.py
 tests/test_authz_simulcast.py
 tests/test_ca_cert.py
 tests/test_capability.py
+tests/test_codec_preference.py
 tests/test_degradation_preference.py
 tests/test_encoded_transform.py
 tests/test_intel_vpl.py
@@ -27,6 +28,7 @@ tests/test_messaging.py
 tests/test_messaging_header.py
 tests/test_nvidia_video_codec_sdk.py
 tests/test_openh264.py
+tests/test_opus.py
 tests/test_re_offer_re_answer_sdp.py
 tests/test_sendonly_recvonly.py
 tests/test_signaling.py

{sora_sdk-2025.1.0.dev8 → sora_sdk-2025.1.0.dev9}/tests/test_authz_simulcast.py

@@ -19,6 +19,7 @@ from client import SoraClient, SoraRole
         # どうやら scaleResolutionDownTo を指定すると規定されたテーブルのビットレートでは足りない模様
         ("VP8", "libvpx", 2500, 960, 540),
         ("VP9", "libvpx", 2000, 960, 540),
+        ("AV1", "libaom", 2500, 960, 540),
     ],
 )
 def test_simulcast_authz_scale_resolution_to(
@@ -92,6 +93,43 @@ def test_simulcast_authz_scale_resolution_to(
     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
+
+    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"]
+
+    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"]
+
+    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"]
+    )
+
+    assert (
+        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 があるかどうか
@@ -140,6 +178,7 @@ def test_simulcast_authz_scale_resolution_to(
             s["rid"],
             video_codec_type,
             s["encoderImplementation"],
+            s["scalabilityMode"],
             expected_bitrate,
             s["targetBitrate"],
             s["frameWidth"],

sora_sdk-2025.1.0.dev9/tests/test_codec_preference.py

@@ -0,0 +1,124 @@
+import sys
+
+from sora_sdk import (
+    Sora,
+    SoraVideoCodecImplementation,
+    SoraVideoCodecPreference,
+    SoraVideoCodecType,
+    get_video_codec_capability,
+)
+
+
+# このテストでは Linux では NVIDIA Video Codec SDK > Intel VPL > OpenH264 の順で優先される
+# このテストでは Windows では NVIDIA Video Codec SDK > Intel VPL の順で優先される
+# このテストでは macOS では Video Toolbox >OpenH264 の順で優先される
+def test_get_codec_capability(setup):
+    openh264_path = setup.get("openh264_path")
+    capability = get_video_codec_capability(openh264_path)
+
+    intel_vpl_available = False
+    cisco_openh264_available = False
+    nvidia_video_codec_sdk_available = False
+
+    for e in capability.engines:
+        if e.name == SoraVideoCodecImplementation.INTEL_VPL:
+            intel_vpl_available = True
+        if e.name == SoraVideoCodecImplementation.CISCO_OPENH264:
+            cisco_openh264_available = True
+        if e.name == SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK:
+            nvidia_video_codec_sdk_available = True
+
+    match sys.platform:
+        case "linux":
+            assert openh264_path is not None
+            assert cisco_openh264_available is True
+        case "darwin":
+            assert openh264_path is not None
+            assert cisco_openh264_available is True
+        case "win32":
+            # SDK 的には Windows は非対応だが GitHub Actions の E2E テストの OpenH264 のパスは指定してある
+            assert openh264_path is not None
+            assert cisco_openh264_available is True
+
+    codecs = []
+    for e in capability.engines:
+        if sys.platform == "linux":
+            # Intel VPL があったら Open H.264 は採用しない
+            if intel_vpl_available and e.name == SoraVideoCodecImplementation.CISCO_OPENH264:
+                continue
+
+            # NVIDIA Video Codec SDK があったら Intel VPL は採用しない
+            if (
+                nvidia_video_codec_sdk_available
+                and e.name == SoraVideoCodecImplementation.INTEL_VPL
+            ):
+                continue
+
+            # NVIDIA Video Codec SDK があったら OpenH264 は採用しない
+            if (
+                nvidia_video_codec_sdk_available
+                and e.name == SoraVideoCodecImplementation.CISCO_OPENH264
+            ):
+                continue
+
+        # macOS では INTERNAL の Video Toolbox が利用されるので OpenH264 は採用しないようにする
+        if sys.platform == "darwin":
+            if e.name == SoraVideoCodecImplementation.CISCO_OPENH264:
+                continue
+
+        for c in e.codecs:
+            if c.decoder or c.encoder:
+                # encoder/decoder どちらかが true であれば採用する
+                if c.decoder or c.encoder:
+                    codecs.append(
+                        SoraVideoCodecPreference.Codec(
+                            type=c.type,
+                            decoder=e.name,
+                            encoder=e.name,
+                        )
+                    )
+
+        # print(e.parameters.nvcodec_gpu_device_name)
+        # print(e.parameters.openh264_path)
+        # print(e.parameters.version)
+        # print(e.parameters.vpl_impl)
+        # print(e.parameters.vpl_impl_value)
+
+    Sora(
+        video_codec_preference=SoraVideoCodecPreference(
+            codecs=codecs,
+        ),
+        openh264=openh264_path,
+    )
+
+
+def test_video_codec_preference(setup):
+    openh264_path = setup.get("openh264_path")
+    Sora(
+        video_codec_preference=SoraVideoCodecPreference(
+            codecs=[
+                SoraVideoCodecPreference.Codec(
+                    type=SoraVideoCodecType.VP8,
+                    decoder=SoraVideoCodecImplementation.INTERNAL,
+                    encoder=SoraVideoCodecImplementation.INTERNAL,
+                ),
+                SoraVideoCodecPreference.Codec(
+                    type=SoraVideoCodecType.VP9,
+                    decoder=SoraVideoCodecImplementation.INTERNAL,
+                    encoder=SoraVideoCodecImplementation.INTERNAL,
+                ),
+                SoraVideoCodecPreference.Codec(
+                    type=SoraVideoCodecType.AV1,
+                    decoder=SoraVideoCodecImplementation.INTERNAL,
+                    encoder=SoraVideoCodecImplementation.INTERNAL,
+                ),
+                # H.264 だけは OpenH264 を利用するようにする
+                SoraVideoCodecPreference.Codec(
+                    type=SoraVideoCodecType.H264,
+                    decoder=SoraVideoCodecImplementation.CISCO_OPENH264,
+                    encoder=SoraVideoCodecImplementation.CISCO_OPENH264,
+                ),
+            ],
+        ),
+        openh264=openh264_path,
+    )

{sora_sdk-2025.1.0.dev8 → sora_sdk-2025.1.0.dev9}/tests/test_intel_vpl.py

@@ -10,10 +10,49 @@ from sora_sdk import (
     SoraVideoCodecImplementation,
     SoraVideoCodecPreference,
     SoraVideoCodecType,
+    get_video_codec_capability,
 )
 
 
-# @pytest.mark.skip()
+@pytest.mark.skipif(os.environ.get("INTEL_VPL") is None, reason="Intel VPL でのみ実行する")
+def test_intel_vpl_available(setup):
+    capability = get_video_codec_capability()
+
+    intel_vpl_available = False
+    for e in capability.engines:
+        if e.name == SoraVideoCodecImplementation.INTEL_VPL:
+            intel_vpl_available = True
+
+    assert intel_vpl_available is True
+
+    for e in capability.engines:
+        if e.name == SoraVideoCodecImplementation.INTEL_VPL:
+            # 対応コーデックは 5 種類
+            assert len(e.codecs) == 5
+
+            for c in e.codecs:
+                match c.type:
+                    case SoraVideoCodecType.VP8:
+                        assert c.decoder is False
+                        assert c.encoder is False
+                    case SoraVideoCodecType.VP9:
+                        assert c.decoder is True
+                        # VPL 的に VP9 は利用できるが、
+                        # Sora Python SDK では VPL VP9 Encoder が正常に動作しないため無効
+                        assert c.encoder is False
+                    case SoraVideoCodecType.AV1:
+                        assert c.decoder is True
+                        assert c.encoder is True
+                    case SoraVideoCodecType.H264:
+                        assert c.decoder is True
+                        assert c.encoder is True
+                    case SoraVideoCodecType.H265:
+                        assert c.decoder is True
+                        assert c.encoder is True
+                    case _:
+                        pytest.fail(f"未実装の codec_type: {c.type}")
+
+
 @pytest.mark.skipif(os.environ.get("INTEL_VPL") is None, reason="Intel VPL でのみ実行する")
 @pytest.mark.parametrize(
     (
@@ -23,6 +62,8 @@ from sora_sdk import (
         "preference_codec_implementation",
     ),
     [
+        # VPL では VP9 が正常に動作しない
+        # ("VP9", SoraVideoCodecType.VP9, "libvpl", SoraVideoCodecImplementation.INTEL_VPL),
         ("AV1", SoraVideoCodecType.AV1, "libvpl", SoraVideoCodecImplementation.INTEL_VPL),
         ("H264", SoraVideoCodecType.H264, "libvpl", SoraVideoCodecImplementation.INTEL_VPL),
         ("H265", SoraVideoCodecType.H265, "libvpl", SoraVideoCodecImplementation.INTEL_VPL),
@@ -253,7 +294,6 @@ def test_intel_vpl_simulcast(
             assert s["packetsSent"] <= 2
 
 
-# @pytest.mark.skip()
 @pytest.mark.skipif(os.environ.get("INTEL_VPL") is None, reason="Intel VPL でのみ実行する")
 @pytest.mark.parametrize(
     (
@@ -429,6 +469,94 @@ def test_intel_vpl_vp9_sendonly(setup, video_codec_type, expected_implementation
     assert outbound_rtp_stats["packetsSent"] > 0
 
 
+@pytest.mark.skipif(os.environ.get("INTEL_VPL") is None, reason="Intel VPL でのみ実行する")
+def test_intel_vpl_vp9_sendonly_recvonly(setup):
+    """
+    VPL 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,
+                    # VPL で 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,
+                    decoder=SoraVideoCodecImplementation.INTEL_VPL,
+                ),
+            ]
+        ),
+    )
+    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"] == "libvpl"
+    assert inbound_rtp_stats["bytesReceived"] > 0
+    assert inbound_rtp_stats["packetsReceived"] > 0
+
+
 @pytest.mark.xfail(
     strict=True, reason="AV1 は解像度が 120x90 以下の場合に正常に処理ができない問題がある"
 )

{sora_sdk-2025.1.0.dev8 → sora_sdk-2025.1.0.dev9}/tests/test_nvidia_video_codec_sdk.py

@@ -19,10 +19,10 @@ from sora_sdk import SoraVideoCodecImplementation, SoraVideoCodecPreference, Sor
         "expected_implementation",
     ),
     [
-        ("VP9", "NVIDIA Video Codec SDK"),
-        ("AV1", "NVIDIA Video Codec SDK"),
-        ("H264", "NVIDIA Video Codec SDK"),
-        ("H265", "NVIDIA Video Codec SDK"),
+        ("VP9", "NvCodec"),
+        ("AV1", "NvCodec"),
+        ("H264", "NvCodec"),
+        ("H265", "NvCodec"),
     ],
 )
 def test_intel_vpl_sendonly(setup, video_codec_type, expected_implementation):
@@ -108,31 +108,31 @@ def test_intel_vpl_sendonly(setup, video_codec_type, expected_implementation):
     # FIXME: AV1 では、解像度が一定数より低くなる場合、エラーになるのでコメントアウトしている
     [
         # 1080p
-        ("VP9", "NVIDIA Video Codec SDK", 5000, 1920, 1080, 3),
-        ("H264", "NVIDIA Video Codec SDK", 5000, 1920, 1080, 3),
-        ("H265", "NVIDIA Video Codec SDK", 5000, 1920, 1080, 3),
+        ("VP9", "NvCodec", 5000, 1920, 1080, 3),
+        ("H264", "NvCodec", 5000, 1920, 1080, 3),
+        ("H265", "NvCodec", 5000, 1920, 1080, 3),
         # 720p
-        ("VP9", "NVIDIA Video Codec SDK", 2500, 1280, 720, 3),
-        ("H264", "NVIDIA Video Codec SDK", 2500, 1280, 720, 3),
-        ("H265", "NVIDIA Video Codec SDK", 2500, 1280, 720, 3),
+        ("VP9", "NvCodec", 2500, 1280, 720, 3),
+        ("H264", "NvCodec", 2500, 1280, 720, 3),
+        ("H265", "NvCodec", 2500, 1280, 720, 3),
         # 540p
-        ("VP9", "NVIDIA Video Codec SDK", 1200, 960, 540, 3),
-        ("H264", "NVIDIA Video Codec SDK", 1200, 960, 540, 3),
-        ("H265", "NVIDIA Video Codec SDK", 1200, 960, 540, 3),
+        ("VP9", "NvCodec", 1200, 960, 540, 3),
+        ("H264", "NvCodec", 1200, 960, 540, 3),
+        ("H265", "NvCodec", 1200, 960, 540, 3),
         # 360p
-        ("VP9", "NVIDIA Video Codec SDK", 700, 640, 360, 2),
-        ("H264", "NVIDIA Video Codec SDK", 700, 640, 360, 2),
-        ("H265", "NVIDIA Video Codec SDK", 700, 640, 360, 2),
+        ("VP9", "NvCodec", 700, 640, 360, 2),
+        ("H264", "NvCodec", 700, 640, 360, 2),
+        ("H265", "NvCodec", 700, 640, 360, 2),
         # 270p
-        ("VP9", "NVIDIA Video Codec SDK", 450, 480, 270, 2),
-        ("H264", "NVIDIA Video Codec SDK", 450, 480, 270, 2),
-        ("H265", "NVIDIA Video Codec SDK", 450, 480, 270, 2),
+        ("VP9", "NvCodec", 450, 480, 270, 2),
+        ("H264", "NvCodec", 450, 480, 270, 2),
+        ("H265", "NvCodec", 450, 480, 270, 2),
         # 180p
-        ("VP9", "NVIDIA Video Codec SDK", 200, 320, 180, 1),
-        ("H264", "NVIDIA Video Codec SDK", 200, 320, 180, 1),
-        ("H265", "NVIDIA Video Codec SDK", 142, 320, 180, 1),
+        ("VP9", "NvCodec", 200, 320, 180, 1),
+        ("H264", "NvCodec", 200, 320, 180, 1),
+        ("H265", "NvCodec", 142, 320, 180, 1),
         # 135p
-        ("H265", "NVIDIA Video Codec SDK", 101, 240, 135, 1),
+        ("H265", "NvCodec", 101, 240, 135, 1),
     ],
 )
 def test_intel_vpl_simulcast(
@@ -258,9 +258,10 @@ def test_intel_vpl_simulcast(
         "expected_implementation",
     ),
     [
-        ("VP9", "NVIDIA Video Codec SDK"),
-        ("H264", "NVIDIA Video Codec SDK"),
-        ("H265", "NVIDIA Video Codec SDK"),
+        ("VP9", "NvCodec"),
+        ("AV1", "NvCodec"),
+        ("H264", "NvCodec"),
+        ("H265", "NvCodec"),
     ],
 )
 def test_intel_vpl_sendonly_recvonly(setup, video_codec_type, expected_implementation):

{sora_sdk-2025.1.0.dev8 → sora_sdk-2025.1.0.dev9}/tests/test_openh264.py

@@ -12,7 +12,6 @@ from sora_sdk import (
 )
 
 
-@pytest.mark.skipif(sys.platform not in ["darwin", "linux"], reason="macOSとLinuxでのみ実行する")
 def test_openh264_sendonly_recvonly(setup):
     signaling_urls = setup.get("signaling_urls")
     channel_id_prefix = setup.get("channel_id_prefix")
@@ -88,7 +87,6 @@ def test_openh264_sendonly_recvonly(setup):
     assert inbound_rtp_stats["packetsReceived"] > 0
 
 
-@pytest.mark.skipif(sys.platform not in ["darwin", "linux"], reason="macOSとLinuxでのみ実行する")
 @pytest.mark.parametrize(
     (
         "video_codec_type",

sora_sdk-2025.1.0.dev9/tests/test_opus.py

@@ -0,0 +1,68 @@
+import sys
+import time
+import uuid
+
+from client import SoraClient, SoraRole
+
+# opus params のテストは test_signaling.py にある
+
+# https://tex2e.github.io/rfc-translater/html/rfc7587.html
+
+
+def test_sendonly_audio_opus_params_16khz_mono(setup):
+    """
+    SDP では 48000/2 だが、Opus の設定で 16000/1 を配信してみる
+    """
+    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()}"
+
+    with SoraClient(
+        signaling_urls,
+        SoraRole.SENDONLY,
+        channel_id,
+        audio=True,
+        audio_codec_type="OPUS",
+        audio_opus_params={
+            #
+            "maxplaybackrate": 16000,
+            # 受信のみに有効
+            "stereo": False,
+            # 送信のみに有効
+            "sprop_stereo": False,
+        },
+        video=False,
+        metadata=metadata,
+    ) as sendonly:
+        time.sleep(5)
+
+        assert sendonly.connect_message is not None
+        assert "audio" in sendonly.connect_message
+        assert "opus_params" in sendonly.connect_message["audio"]
+        assert sendonly.connect_message["audio"]["opus_params"]["stereo"] is False
+        assert sendonly.connect_message["audio"]["opus_params"]["maxplaybackrate"] == 16000
+        assert sendonly.connect_message["audio"]["opus_params"]["sprop_stereo"] is False
+
+        assert sendonly.offer_message is not None
+        assert "sdp" in sendonly.offer_message
+
+        assert "opus/48000/2" in sendonly.offer_message["sdp"]
+
+        assert "maxplaybackrate=16000" in sendonly.offer_message["sdp"]
+        assert "stereo=0" in sendonly.offer_message["sdp"]
+        assert "sprop-stereo=0" in sendonly.offer_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"] == "audio/opus"
+
+        # outbound-rtp が無かったら StopIteration 例外が上がる
+        outbound_rtp_stats = next(s for s in sendonly_stats if s.get("type") == "outbound-rtp")
+        assert outbound_rtp_stats["bytesSent"] > 0
+        assert outbound_rtp_stats["packetsSent"] > 0