sora-sdk 2025.4.0.dev0__tar.gz → 2025.4.0.dev2__tar.gz

{sora_sdk-2025.4.0.dev0/src/sora_sdk.egg-info → sora_sdk-2025.4.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sora_sdk
-Version: 2025.4.0.dev0
+Version: 2025.4.0.dev2
 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.4.0.dev2/VERSION

@@ -0,0 +1 @@
+2025.4.0.dev2

{sora_sdk-2025.4.0.dev0 → sora_sdk-2025.4.0.dev2}/buildbase.py

@@ -302,7 +302,12 @@ def _extractzip(z: zipfile.ZipFile, path: str):
 def extract(file: str, output_dir: str, output_dirname: str, filetype: Optional[str] = None):
     path = os.path.join(output_dir, output_dirname)
     logging.info(f"Extract {file} to {path}")
-    if filetype == "gzip" or file.endswith(".tar.gz"):
+    if (
+        filetype == "gzip"
+        or file.endswith(".tar.gz")
+        or filetype == "lzma"
+        or file.endswith(".tar.xz")
+    ):
         rm_rf(path)
         with tarfile.open(file) as t:
             dir = is_single_dir_tar(t)
@@ -378,6 +383,7 @@ def git_clone_shallow(url, hash, dir, submodule=False):
 
 
 def apply_patch(patch, dir, depth):
+    patch = os.path.abspath(patch)
     with cd(dir):
         logging.info(f"patch -p{depth} < {patch}")
         if platform.system() == "Windows":
@@ -800,6 +806,7 @@ def build_and_install_boost(
                     )
         elif target_os == "android":
             # Android の場合、android-ndk を使ってビルドする
+            # ただし cxx が指定されてた場合はそちらを優先する
             with open("project-config.jam", "w", encoding="utf-8") as f:
                 bin = os.path.join(
                     android_ndk, "toolchains", "llvm", "prebuilt", android_build_platform, "bin"
@@ -814,7 +821,7 @@ def build_and_install_boost(
                 f.write(
                     f"using clang \
                     : android \
-                    : {escape(os.path.join(bin, 'clang++'))} \
+                    : {escape(cxx if len(cxx) != 0 else os.path.join(bin, 'clang++'))} \
                       --target=aarch64-none-linux-android{native_api_level} \
                       --sysroot={escape(sysroot)} \
                     : <archiver>{escape(os.path.join(bin, 'llvm-ar'))} \
@@ -932,7 +939,7 @@ def build_sora(
         ]
 
     with cd(local_sora_cpp_sdk_dir):
-        cmd(["python3", "run.py", platform, *local_sora_cpp_sdk_args])
+        cmd(["python3", "run.py", "build", platform, *local_sora_cpp_sdk_args])
 
 
 class SoraInfo(NamedTuple):
@@ -1226,6 +1233,93 @@ def install_sdl2(
         cmd(["cmake", "--install", ".", "--config", configuration])
 
 
+@versioned
+def install_sdl3(
+    version, source_dir, build_dir, install_dir, debug: bool, platform: str, cmake_args: List[str]
+):
+    url = f"https://github.com/libsdl-org/SDL/releases/download/release-{version}/SDL3-{version}.tar.gz"
+    path = download(url, source_dir)
+    sdl3_source_dir = os.path.join(source_dir, "sdl3")
+    sdl3_build_dir = os.path.join(build_dir, "sdl3")
+    sdl3_install_dir = os.path.join(install_dir, "sdl3")
+    rm_rf(sdl3_source_dir)
+    rm_rf(sdl3_build_dir)
+    rm_rf(sdl3_install_dir)
+    extract(path, source_dir, "sdl3")
+
+    mkdir_p(sdl3_build_dir)
+    with cd(sdl3_build_dir):
+        configuration = "Debug" if debug else "Release"
+        cmake_args = cmake_args[:]
+        cmake_args += [
+            sdl3_source_dir,
+            f"-DCMAKE_BUILD_TYPE={configuration}",
+            f"-DCMAKE_INSTALL_PREFIX={cmake_path(sdl3_install_dir)}",
+            "-DBUILD_SHARED_LIBS=OFF",
+            "-DSDL_STATIC=ON",
+            "-DSDL_SHARED=OFF",
+        ]
+        if platform == "windows":
+            cmake_args += [
+                f"-DCMAKE_MSVC_RUNTIME_LIBRARY={'MultiThreaded' if not debug else 'MultiThreadedDebug'}",
+                "-DSDL_AUDIO=OFF",
+                "-DSDL_JOYSTICK=OFF",
+                "-DSDL_HAPTIC=OFF",
+                # GitHub Actions 上で gameinput.h が存在しないのに
+                # なぜか  check_c_source_compiles() が成功してしまうので
+                # HAVE_GAMEINPUT_H=0 で強制的に無効化する
+                "-DHAVE_GAMEINPUT_H=0",
+            ]
+        elif platform == "macos":
+            # どの環境でも同じようにインストールされるようにするため全部 ON/OFF を明示的に指定する
+            cmake_args += [
+                "-DSDL_AUDIO=OFF",
+                "-DSDL_VIDEO=ON",
+                "-DSDL_RENDER=ON",
+                "-DSDL_HAPTIC=ON",
+                "-DSDL_POWER=ON",
+                "-DSDL_JOYSTICK=ON",
+                "-DSDL_SENSOR=ON",
+                "-DSDL_OPENGL=ON",
+                "-DSDL_OPENGLES=ON",
+                "-DSDL_METAL=ON",
+                "-DSDL_VULKAN=OFF",
+            ]
+        elif platform == "linux":
+            # どの環境でも同じようにインストールされるようにするため全部 ON/OFF を明示的に指定する
+            cmake_args += [
+                "-DSDL_AUDIO=OFF",
+                "-DSDL_VIDEO=ON",
+                "-DSDL_RENDER=ON",
+                "-DSDL_HAPTIC=ON",
+                "-DSDL_POWER=ON",
+                "-DSDL_JOYSTICK=ON",
+                "-DSDL_SENSOR=ON",
+                "-DSDL_OPENGL=ON",
+                "-DSDL_OPENGLES=ON",
+                "-DSDL_X11=ON",
+                "-DSDL_X11_SHARED=OFF",
+                "-DSDL_X11_XCURSOR=OFF",
+                "-DSDL_X11_XDBE=OFF",
+                "-DSDL_X11_XFIXES=OFF",
+                "-DSDL_X11_XINPUT=OFF",
+                "-DSDL_X11_XRANDR=OFF",
+                "-DSDL_X11_XSCRNSAVER=OFF",
+                "-DSDL_X11_XSHAPE=OFF",
+                "-DSDL_X11_XSYNC=OFF",
+                "-DSDL_WAYLAND=OFF",
+                "-DSDL_VULKAN=OFF",
+                "-DSDL_KMSDRM=OFF",
+                "-DSDL_RPI=OFF",
+            ]
+        cmd(["cmake"] + cmake_args)
+
+        cmd(
+            ["cmake", "--build", ".", "--config", configuration, f"-j{multiprocessing.cpu_count()}"]
+        )
+        cmd(["cmake", "--install", ".", "--config", configuration])
+
+
 @versioned
 def install_cli11(version, install_dir):
     cli11_install_dir = os.path.join(install_dir, "cli11")
@@ -1307,6 +1401,33 @@ def install_vpl(version, configuration, source_dir, build_dir, install_dir, cmak
         cmd(["cmake", "--install", ".", "--config", configuration])
 
 
+@versioned
+def install_blend2d_official(
+    version,
+    configuration,
+    source_dir,
+    build_dir,
+    install_dir,
+    ios,
+    cmake_args,
+):
+    rm_rf(os.path.join(source_dir, "blend2d"))
+    rm_rf(os.path.join(build_dir, "blend2d"))
+    rm_rf(os.path.join(install_dir, "blend2d"))
+
+    url = f"https://blend2d.com/download/blend2d-{version}.tar.gz"
+    path = download(url, source_dir)
+    extract(path, source_dir, "blend2d")
+    _build_blend2d(
+        configuration=configuration,
+        source_dir=source_dir,
+        build_dir=build_dir,
+        install_dir=install_dir,
+        ios=ios,
+        cmake_args=cmake_args,
+    )
+
+
 @versioned
 def install_blend2d(
     version,
@@ -1332,7 +1453,17 @@ def install_blend2d(
         asmjit_version,
         os.path.join(source_dir, "blend2d", "3rdparty", "asmjit"),
     )
+    _build_blend2d(
+        configuration=configuration,
+        source_dir=source_dir,
+        build_dir=build_dir,
+        install_dir=install_dir,
+        ios=ios,
+        cmake_args=cmake_args,
+    )
+
 
+def _build_blend2d(configuration, source_dir, build_dir, install_dir, ios, cmake_args):
     mkdir_p(os.path.join(build_dir, "blend2d"))
     with cd(os.path.join(build_dir, "blend2d")):
         cmd(
@@ -1747,6 +1878,7 @@ def install_opus(
                 "cmake",
                 f"-DCMAKE_INSTALL_PREFIX={cmake_path(opus_install_dir)}",
                 f"-DCMAKE_BUILD_TYPE={configuration}",
+                "-DCMAKE_POSITION_INDEPENDENT_CODE=ON",
                 "-DOPUS_BUILD_SHARED_LIBRARY=OFF",
                 "-DOPUS_BUILD_TESTING=OFF",
                 "-DOPUS_BUILD_PROGRAMS=OFF",
@@ -1803,6 +1935,163 @@ def install_amf(version, install_dir):
     )
 
 
+@versioned
+def install_mbedtls(version, source_dir, build_dir, install_dir, debug, cmake_args):
+    rm_rf(os.path.join(source_dir, "mbedtls"))
+    rm_rf(os.path.join(build_dir, "mbedtls"))
+    rm_rf(os.path.join(install_dir, "mbedtls"))
+    git_clone_shallow(
+        "https://github.com/Mbed-TLS/mbedtls.git",
+        version,
+        os.path.join(source_dir, "mbedtls"),
+    )
+    with cd(os.path.join(source_dir, "mbedtls")):
+        configuration = "Debug" if debug else "Release"
+        cmd(["python3", "scripts/config.py", "set", "MBEDTLS_SSL_DTLS_SRTP"])
+        cmd(
+            [
+                "cmake",
+                f"-DCMAKE_INSTALL_PREFIX={cmake_path(os.path.join(install_dir, 'mbedtls'))}",
+                f"-DCMAKE_BUILD_TYPE={configuration}",
+                "-DCMAKE_POSITION_INDEPENDENT_CODE=ON",
+                "-B",
+                os.path.join(build_dir, "mbedtls"),
+            ]
+            + cmake_args
+        )
+        cmd(
+            [
+                "cmake",
+                "--build",
+                os.path.join(build_dir, "mbedtls"),
+                f"-j{multiprocessing.cpu_count()}",
+                "--config",
+                "Release",
+            ]
+        )
+        cmd(["cmake", "--install", os.path.join(build_dir, "mbedtls")])
+
+
+@versioned
+def install_libjpeg_turbo(version, source_dir, build_dir, install_dir, configuration, cmake_args):
+    libjpeg_source_dir = os.path.join(source_dir, "libjpeg-turbo")
+    libjpeg_build_dir = os.path.join(build_dir, "libjpeg-turbo")
+    libjpeg_install_dir = os.path.join(install_dir, "libjpeg-turbo")
+    rm_rf(libjpeg_source_dir)
+    rm_rf(libjpeg_build_dir)
+    rm_rf(libjpeg_install_dir)
+    git_clone_shallow(
+        "https://github.com/libjpeg-turbo/libjpeg-turbo.git",
+        version,
+        libjpeg_source_dir,
+    )
+    mkdir_p(libjpeg_build_dir)
+    with cd(libjpeg_build_dir):
+        cmd(
+            [
+                "cmake",
+                libjpeg_source_dir,
+                f"-DCMAKE_INSTALL_PREFIX={libjpeg_install_dir}",
+                f"-DCMAKE_BUILD_TYPE={configuration}",
+                "-DENABLE_SHARED=FALSE",
+                "-DENABLE_STATIC=TRUE",
+                "-DCMAKE_BUILD_TYPE=Release",
+                "-DCMAKE_POSITION_INDEPENDENT_CODE=ON",
+            ]
+            + cmake_args
+        )
+        cmd(
+            [
+                "cmake",
+                "--build",
+                libjpeg_build_dir,
+                f"-j{multiprocessing.cpu_count()}",
+                "--config",
+                "Release",
+            ]
+        )
+        cmd(["cmake", "--install", libjpeg_build_dir])
+
+
+@versioned
+def install_libyuv(
+    version, source_dir, build_dir, install_dir, libjpeg_turbo_dir, configuration, cmake_args
+):
+    libyuv_source_dir = os.path.join(source_dir, "libyuv")
+    libyuv_build_dir = os.path.join(build_dir, "libyuv")
+    libyuv_install_dir = os.path.join(install_dir, "libyuv")
+    rm_rf(libyuv_source_dir)
+    rm_rf(libyuv_build_dir)
+    rm_rf(libyuv_install_dir)
+    git_clone_shallow(
+        "https://chromium.googlesource.com/libyuv/libyuv",
+        version,
+        libyuv_source_dir,
+    )
+    mkdir_p(libyuv_build_dir)
+    with cd(libyuv_build_dir):
+        cmd(
+            [
+                "cmake",
+                libyuv_source_dir,
+                f"-DCMAKE_INSTALL_PREFIX={cmake_path(libyuv_install_dir)}",
+                f"-DCMAKE_BUILD_TYPE={configuration}",
+                f"-DCMAKE_PREFIX_PATH={cmake_path(libjpeg_turbo_dir)}",
+                *cmake_args,
+            ]
+        )
+        cmd(
+            [
+                "cmake",
+                "--build",
+                libyuv_build_dir,
+                f"-j{multiprocessing.cpu_count()}",
+                "--config",
+                "Release",
+            ]
+        )
+        cmd(["cmake", "--install", libyuv_build_dir])
+
+
+@versioned
+def install_aom(version, source_dir, build_dir, install_dir, configuration, cmake_args):
+    aom_source_dir = os.path.join(source_dir, "aom")
+    aom_build_dir = os.path.join(build_dir, "aom")
+    aom_install_dir = os.path.join(install_dir, "aom")
+    rm_rf(aom_source_dir)
+    rm_rf(aom_build_dir)
+    rm_rf(aom_install_dir)
+    git_clone_shallow(
+        "https://aomedia.googlesource.com/aom",
+        version,
+        aom_source_dir,
+    )
+    with cd(aom_source_dir):
+        cmd(
+            [
+                "cmake",
+                "-B",
+                aom_build_dir,
+                f"-DCMAKE_INSTALL_PREFIX={cmake_path(aom_install_dir)}",
+                f"-DCMAKE_BUILD_TYPE={configuration}",
+                "-DENABLE_DOCS=OFF",
+                "-DENABLE_TESTS=OFF",
+                *cmake_args,
+            ]
+        )
+        cmd(
+            [
+                "cmake",
+                "--build",
+                aom_build_dir,
+                f"-j{multiprocessing.cpu_count()}",
+                "--config",
+                "Release",
+            ]
+        )
+        cmd(["cmake", "--install", aom_build_dir])
+
+
 class PlatformTarget(object):
     def __init__(self, os, osver, arch, extra=None):
         self.os = os

{sora_sdk-2025.4.0.dev0 → sora_sdk-2025.4.0.dev2}/pyproject.toml

@@ -28,7 +28,7 @@ python-preference = "only-managed"
 dev-dependencies = [
     "nanobind==2.8.0",
     "setuptools==80.9",
-    "build==1.2.2.post1",
+    "build==1.3.0",
     "wheel==0.45.1",
     "numpy",
     "httpx",

{sora_sdk-2025.4.0.dev0 → sora_sdk-2025.4.0.dev2/src/sora_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sora_sdk
-Version: 2025.4.0.dev0
+Version: 2025.4.0.dev2
 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.4.0.dev0 → sora_sdk-2025.4.0.dev2}/src/sora_sdk.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ tests/test_capability.py
 tests/test_degradation_preference.py
 tests/test_encoded_transform.py
 tests/test_intel_vpl.py
+tests/test_key_frame_request.py
 tests/test_messaging.py
 tests/test_messaging_header.py
 tests/test_nvidia_video_codec_sdk.py

{sora_sdk-2025.4.0.dev0 → sora_sdk-2025.4.0.dev2}/tests/test_amd_amf.py

@@ -2,6 +2,7 @@ import os
 import time
 
 import pytest
+from api import request_key_frame_api
 from client import (
     SoraClient,
     SoraRole,
@@ -60,8 +61,70 @@ def test_amd_amf_available(settings):
 @pytest.mark.parametrize(
     "video_codec_type",
     [
-        # AV1 は decoder が正常に動作しない
-        # "AV1",
+        "AV1",
+        "H264",
+        "H265",
+    ],
+)
+def test_amd_amf_key_frame_request(settings, video_codec_type):
+    sendonly = SoraClient(
+        settings,
+        SoraRole.SENDONLY,
+        audio=False,
+        video=True,
+        video_codec_type=video_codec_type,
+        video_codec_preference=SoraVideoCodecPreference(
+            codecs=[
+                SoraVideoCodecPreference.Codec(
+                    type=codec_type_string_to_codec_type(video_codec_type),
+                    encoder=SoraVideoCodecImplementation.AMD_AMF,
+                ),
+            ]
+        ),
+    )
+    sendonly.connect(fake_video=True)
+
+    time.sleep(3)
+
+    assert sendonly.connection_id is not None
+
+    # キーフレーム要求 API を 3 秒間隔で 3 回呼び出す
+    api_count = 3
+    for _ in range(api_count):
+        response = request_key_frame_api(
+            settings.api_url, sendonly.channel_id, sendonly.connection_id
+        )
+        assert response.status_code == 200
+        time.sleep(3)
+
+    # 統計を取得する
+    sendonly_stats = sendonly.get_stats()
+
+    sendonly.disconnect()
+
+    # outbound-rtp が無かったら StopIteration 例外が上がる
+    outbound_rtp_stats = next(s for s in sendonly_stats if s.get("type") == "outbound-rtp")
+
+    print("video_codec_type:", video_codec_type)
+    print("keyFramesEncoded:", outbound_rtp_stats["keyFramesEncoded"])
+    print("pliCount:", outbound_rtp_stats["pliCount"])
+    print(
+        "keyFramesEncoded >= pliCount * 0.7:",
+        outbound_rtp_stats["keyFramesEncoded"] >= outbound_rtp_stats["pliCount"] * 0.7,
+    )
+
+    assert outbound_rtp_stats["keyFramesEncoded"] > api_count
+    assert outbound_rtp_stats["pliCount"] >= api_count
+
+    # PLI カウントの 50% 以上がキーフレームとしてエンコードされることを確認
+    assert outbound_rtp_stats["keyFramesEncoded"] >= outbound_rtp_stats["pliCount"] * 0.7
+
+
+@pytest.mark.skipif(os.environ.get("AMD_AMF") is None, reason="AMD AMF でのみ実行する")
+@pytest.mark.parametrize(
+    "video_codec_type",
+    [
+        "AV1",
         "H264",
         "H265",
     ],
@@ -89,6 +152,8 @@ def test_amd_amf_sendonly_recvonly(settings, video_codec_type):
     )
     sendonly.connect(fake_video=True)
 
+    time.sleep(5)
+
     recvonly = SoraClient(
         settings,
         SoraRole.RECVONLY,
@@ -123,7 +188,6 @@ def test_amd_amf_sendonly_recvonly(settings, video_codec_type):
 
     # codec が無かったら StopIteration 例外が上がる
     sendonly_codec_stats = next(s for s in sendonly_stats if s.get("type") == "codec")
-    # H.264/H.265 が採用されているかどうか確認する
     assert sendonly_codec_stats["mimeType"] == f"video/{video_codec_type}"
 
     # outbound-rtp が無かったら StopIteration 例外が上がる
@@ -131,10 +195,13 @@ def test_amd_amf_sendonly_recvonly(settings, video_codec_type):
     assert outbound_rtp_stats["encoderImplementation"] == "AMF"
     assert outbound_rtp_stats["bytesSent"] > 0
     assert outbound_rtp_stats["packetsSent"] > 0
+    assert outbound_rtp_stats["keyFramesEncoded"] > 0
+    assert outbound_rtp_stats["pliCount"] > 0
+    # PLI カウントの 50% 以上がキーフレームとしてエンコードされることを確認
+    assert outbound_rtp_stats["keyFramesEncoded"] >= outbound_rtp_stats["pliCount"] * 0.5
 
     # codec が無かったら StopIteration 例外が上がる
     recvonly_codec_stats = next(s for s in recvonly_stats if s.get("type") == "codec")
-    # H.264/H.265 が採用されているかどうか確認する
     assert recvonly_codec_stats["mimeType"] == f"video/{video_codec_type}"
 
     # inbound-rtp が無かったら StopIteration 例外が上がる
@@ -142,6 +209,7 @@ def test_amd_amf_sendonly_recvonly(settings, video_codec_type):
     assert inbound_rtp_stats["decoderImplementation"] == "AMF"
     assert inbound_rtp_stats["bytesReceived"] > 0
     assert inbound_rtp_stats["packetsReceived"] > 0
+    assert inbound_rtp_stats["keyFramesDecoded"] > 0
 
 
 @pytest.mark.skipif(os.environ.get("AMD_AMF") is None, reason="AMD AMF でのみ実行する")

{sora_sdk-2025.4.0.dev0 → sora_sdk-2025.4.0.dev2}/tests/test_intel_vpl.py

@@ -3,6 +3,7 @@ import platform
 import time
 
 import pytest
+from api import get_stats_connection_api, request_key_frame_api
 from client import (
     SoraClient,
     SoraRole,
@@ -43,8 +44,8 @@ def test_intel_vpl_available():
                     case SoraVideoCodecType.VP9:
                         assert c.decoder is True
                         # VPL 的に VP9 は利用できるが、
-                        # Sora Python SDK では VPL VP9 Encoder が正常に動作しないため無効
-                        assert c.encoder is False
+                        # Sora Python SDK では VPL VP9 Encoder が正常に動作しない
+                        assert c.encoder is True
                     case SoraVideoCodecType.AV1:
                         # チップによって対応指定ないものがあるので判断しない
                         # assert c.decoder is True
@@ -60,6 +61,69 @@ def test_intel_vpl_available():
                         pytest.fail(f"未実装の codec_type: {c.type}")
 
 
+@pytest.mark.skipif(os.environ.get("INTEL_VPL") is None, reason="Intel VPL でのみ実行する")
+@pytest.mark.parametrize(
+    "video_codec_type",
+    [
+        "VP9",
+        "AV1",
+        "H264",
+        "H265",
+    ],
+)
+def test_intel_vpl_key_frame_request(settings, video_codec_type):
+    sendonly = SoraClient(
+        settings,
+        SoraRole.SENDONLY,
+        audio=False,
+        video=True,
+        video_codec_type=video_codec_type,
+        video_codec_preference=SoraVideoCodecPreference(
+            codecs=[
+                SoraVideoCodecPreference.Codec(
+                    type=codec_type_string_to_codec_type(video_codec_type),
+                    encoder=SoraVideoCodecImplementation.INTEL_VPL,
+                ),
+            ]
+        ),
+    )
+    sendonly.connect(fake_video=True)
+
+    time.sleep(3)
+
+    assert sendonly.connection_id is not None
+
+    # キーフレーム要求 API を 3 秒間隔で 3 回呼び出す
+    api_count = 3
+    for _ in range(api_count):
+        response = request_key_frame_api(
+            settings.api_url, sendonly.channel_id, sendonly.connection_id
+        )
+        assert response.status_code == 200
+        time.sleep(3)
+
+    # 統計を取得する
+    sendonly_stats = sendonly.get_stats()
+
+    sendonly.disconnect()
+
+    # outbound-rtp が無かったら StopIteration 例外が上がる
+    outbound_rtp_stats = next(s for s in sendonly_stats if s.get("type") == "outbound-rtp")
+
+    # 3 回以上
+    assert outbound_rtp_stats["keyFramesEncoded"] > api_count
+    assert outbound_rtp_stats["pliCount"] >= api_count
+    print("keyFramesEncoded:", outbound_rtp_stats["keyFramesEncoded"])
+    print("pliCount:", outbound_rtp_stats["pliCount"])
+
+    # PLI カウントの 50% 以上がキーフレームとしてエンコードされることを確認
+    assert outbound_rtp_stats["keyFramesEncoded"] >= outbound_rtp_stats["pliCount"] * 0.7
+    print(
+        "keyFramesEncoded >= pliCount * 0.7:",
+        outbound_rtp_stats["keyFramesEncoded"] >= outbound_rtp_stats["pliCount"] * 0.7,
+    )
+
+
 @pytest.mark.skipif(os.environ.get("INTEL_VPL") is None, reason="Intel VPL でのみ実行する")
 @pytest.mark.parametrize(
     (
@@ -73,14 +137,17 @@ def test_intel_vpl_available():
     # FIXME: AV1 では、解像度が一定数より低くなる場合、エラーになるのでコメントアウトしている
     [
         # 1080p
+        ("VP9", "libvpl", 1920, 1080, 3),
         ("AV1", "libvpl", 1920, 1080, 3),
         ("H264", "libvpl", 1920, 1080, 3),
         ("H265", "libvpl", 1920, 1080, 3),
         # 720p
+        ("VP9", "libvpl", 1280, 720, 3),
         ("AV1", "libvpl", 1280, 720, 3),
         ("H264", "libvpl", 1280, 720, 3),
         ("H265", "libvpl", 1280, 720, 3),
         # 540p
+        ("VP9", "libvpl", 960, 540, 3),
         ("AV1", "libvpl", 960, 540, 3),
         ("H264", "libvpl", 960, 540, 3),
         ("H265", "libvpl", 960, 540, 3),
@@ -139,7 +206,7 @@ def test_intel_vpl_simulcast(
     )
     sendonly.connect(fake_video=True)
 
-    time.sleep(10)
+    time.sleep(3)
 
     sendonly_stats = sendonly.get_stats()
 
@@ -218,6 +285,7 @@ def test_intel_vpl_simulcast(
 @pytest.mark.parametrize(
     "video_codec_type",
     [
+        "VP9",
         "AV1",
         "H264",
         "H265",
@@ -246,6 +314,8 @@ def test_intel_vpl_sendonly_recvonly(settings, video_codec_type):
     )
     sendonly.connect(fake_video=True)
 
+    time.sleep(3)
+
     recvonly = SoraClient(
         settings,
         SoraRole.RECVONLY,
@@ -260,7 +330,7 @@ def test_intel_vpl_sendonly_recvonly(settings, video_codec_type):
     )
     recvonly.connect()
 
-    time.sleep(5)
+    time.sleep(3)
 
     sendonly_stats = sendonly.get_stats()
     recvonly_stats = recvonly.get_stats()
@@ -346,7 +416,7 @@ def test_intel_vpl_av1_mini_resolution(
     )
     sendonly.connect(fake_video=True)
 
-    time.sleep(5)
+    time.sleep(3)
 
     assert sendonly.connect_message is not None
     assert sendonly.connect_message["channel_id"] == settings.channel_id
@@ -384,21 +454,39 @@ def test_intel_vpl_av1_mini_resolution(
     assert outbound_rtp_stats["packetsSent"] > 0
 
 
+## VPL Decode
+
+
 @pytest.mark.skipif(os.environ.get("INTEL_VPL") is None, reason="Intel VPL でのみ実行する")
-def test_intel_vpl_decoding_av1(settings):
+@pytest.mark.parametrize(
+    (
+        "video_codec_type",
+        "encoder_implementation",
+        "decoder_implementation",
+    ),
+    [
+        ("VP9", "libvpx", "libvpl"),
+        ("AV1", "libaom", "libvpl"),
+    ],
+)
+def test_intel_vpl_decode(
+    settings, video_codec_type, encoder_implementation, decoder_implementation
+):
     """
-    N100 などは AV1 のデコーディングに対応している
+    * N100 などは AV1 のデコーディングに対応している
+    * VPL VP9 はデコーダーは利用できるので、そのテスト
     """
     sendonly = SoraClient(
         settings,
         SoraRole.SENDONLY,
         audio=False,
         video=True,
-        video_codec_type="AV1",
+        video_codec_type=video_codec_type,
         video_codec_preference=SoraVideoCodecPreference(
             codecs=[
                 SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.AV1,
+                    type=codec_type_string_to_codec_type(video_codec_type),
+                    # エンコーダーはソフトウェアを利用する
                     encoder=SoraVideoCodecImplementation.INTERNAL,
                 ),
             ]
@@ -406,13 +494,15 @@ def test_intel_vpl_decoding_av1(settings):
     )
     sendonly.connect(fake_video=True)
 
+    time.sleep(3)
+
     recvonly = SoraClient(
         settings,
         SoraRole.RECVONLY,
         video_codec_preference=SoraVideoCodecPreference(
             codecs=[
                 SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.AV1,
+                    type=codec_type_string_to_codec_type(video_codec_type),
                     decoder=SoraVideoCodecImplementation.INTEL_VPL,
                 ),
             ]
@@ -420,7 +510,7 @@ def test_intel_vpl_decoding_av1(settings):
     )
     recvonly.connect()
 
-    time.sleep(5)
+    time.sleep(3)
 
     sendonly_stats = sendonly.get_stats()
     recvonly_stats = recvonly.get_stats()
@@ -431,61 +521,52 @@ def test_intel_vpl_decoding_av1(settings):
     # offer の sdp に video_codec_type が含まれているかどうかを確認している
     assert sendonly.offer_message is not None
     assert "sdp" in sendonly.offer_message
-    assert "AV1" in sendonly.offer_message["sdp"]
+    assert video_codec_type in sendonly.offer_message["sdp"]
 
     # answer の sdp に video_codec_type が含まれているかどうかを確認している
     assert sendonly.answer_message is not None
     assert "sdp" in sendonly.answer_message
-    assert "AV1" in sendonly.answer_message["sdp"]
+    assert video_codec_type in sendonly.answer_message["sdp"]
 
     # codec が無かったら StopIteration 例外が上がる
     sendonly_codec_stats = next(s for s in sendonly_stats if s.get("type") == "codec")
-    assert sendonly_codec_stats["mimeType"] == "video/AV1"
+    # VP9 が採用されているかどうか確認する
+    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"] == "libaom"
+    assert outbound_rtp_stats["encoderImplementation"] == encoder_implementation
     assert outbound_rtp_stats["bytesSent"] > 0
     assert outbound_rtp_stats["packetsSent"] > 0
+    assert outbound_rtp_stats["keyFramesEncoded"] > 0
+    assert outbound_rtp_stats["pliCount"] > 0
 
     # codec が無かったら StopIteration 例外が上がる
     recvonly_codec_stats = next(s for s in recvonly_stats if s.get("type") == "codec")
-    assert recvonly_codec_stats["mimeType"] == "video/AV1"
+    # VP9 が採用されているかどうか確認する
+    assert recvonly_codec_stats["mimeType"] == f"video/{video_codec_type}"
 
     # 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["decoderImplementation"] == decoder_implementation
     assert inbound_rtp_stats["bytesReceived"] > 0
     assert inbound_rtp_stats["packetsReceived"] > 0
-
-
-## VP9
+    assert inbound_rtp_stats["keyFramesDecoded"] > 0
 
 
 @pytest.mark.skipif(os.environ.get("INTEL_VPL") is None, reason="Intel VPL でのみ実行する")
-@pytest.mark.xfail(
-    strict=True, reason="VP9 は C++ SDK の Intel VPL で対応できていないのでテストが失敗する"
-)
-@pytest.mark.parametrize(
-    (
-        "video_codec_type",
-        "expected_implementation",
-    ),
-    [
-        ("VP9", "libvpl"),
-    ],
-)
-def test_intel_vpl_vp9_failed(settings, video_codec_type, expected_implementation):
+def test_intel_vpl_av1_rtp_hdr_ext(settings):
     sendonly = SoraClient(
         settings,
         SoraRole.SENDONLY,
         audio=False,
         video=True,
-        video_codec_type=video_codec_type,
+        video_codec_type="AV1",
         video_codec_preference=SoraVideoCodecPreference(
             codecs=[
                 SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.VP9,
+                    type=codec_type_string_to_codec_type("AV1"),
+                    # エンコーダーはソフトウェアを利用する
                     encoder=SoraVideoCodecImplementation.INTEL_VPL,
                 ),
             ]
@@ -493,113 +574,36 @@ def test_intel_vpl_vp9_failed(settings, video_codec_type, expected_implementatio
     )
     sendonly.connect(fake_video=True)
 
-    time.sleep(5)
-
-    assert sendonly.connect_message is not None
-    assert sendonly.connect_message["channel_id"] == settings.channel_id
-    assert "video" in sendonly.connect_message
-    assert sendonly.connect_message["video"]["codec_type"] == video_codec_type
+    time.sleep(3)
 
-    # offer の sdp に video_codec_type が含まれているかどうかを確認している
+    assert sendonly.connection_id is not None
     assert sendonly.offer_message is not None
     assert "sdp" in sendonly.offer_message
-    assert video_codec_type in sendonly.offer_message["sdp"]
+    assert "AV1" in sendonly.offer_message["sdp"]
+    assert (
+        "https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension"
+        in sendonly.offer_message["sdp"]
+    )
 
-    # answer の sdp に video_codec_type が含まれているかどうかを確認している
     assert sendonly.answer_message is not None
     assert "sdp" in sendonly.answer_message
-    assert video_codec_type in sendonly.answer_message["sdp"]
-
-    sendonly_stats = sendonly.get_stats()
-
-    sendonly.disconnect()
-
-    # codec が無かったら StopIteration 例外が上がる
-    codec_stats = next(s for s in sendonly_stats if s.get("type") == "codec")
-    # VP9 が採用されているかどうか確認する
-    assert 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")
-    # ここで libvpx になって失敗する
-    assert outbound_rtp_stats["encoderImplementation"] == expected_implementation
-    assert outbound_rtp_stats["bytesSent"] > 0
-    assert outbound_rtp_stats["packetsSent"] > 0
-
-
-@pytest.mark.skipif(os.environ.get("INTEL_VPL") is None, reason="Intel VPL でのみ実行する")
-def test_intel_vpl_decoding_vp9(settings):
-    """
-    VPL VP9 はデコーダーは利用できるので、そのテスト
-    """
-    sendonly = SoraClient(
-        settings,
-        SoraRole.SENDONLY,
-        audio=False,
-        video=True,
-        video_codec_type="VP9",
-        video_codec_preference=SoraVideoCodecPreference(
-            codecs=[
-                SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.VP9,
-                    # VPL で VP9 Encoder は正常に動作しないので無効化しているので INTERNAL を指定
-                    encoder=SoraVideoCodecImplementation.INTERNAL,
-                ),
-            ]
-        ),
+    assert "AV1" in sendonly.answer_message["sdp"]
+    assert (
+        "https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension"
+        in sendonly.answer_message["sdp"]
     )
-    sendonly.connect(fake_video=True)
 
-    recvonly = SoraClient(
-        settings,
-        SoraRole.RECVONLY,
-        video_codec_preference=SoraVideoCodecPreference(
-            codecs=[
-                SoraVideoCodecPreference.Codec(
-                    type=SoraVideoCodecType.VP9,
-                    decoder=SoraVideoCodecImplementation.INTEL_VPL,
-                ),
-            ]
-        ),
+    # コネクションの統計情報を取得
+    response = get_stats_connection_api(
+        settings.api_url, sendonly.channel_id, sendonly.connection_id
     )
-    recvonly.connect()
-
-    time.sleep(5)
-
-    sendonly_stats = sendonly.get_stats()
-    recvonly_stats = recvonly.get_stats()
+    # FIX: ここで失敗すると disconnect が実行されずメモリーリークになる
+    assert response.status_code == 200
+    stats = response.json()
 
     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
+    # AV1 の RTP ヘッダー拡張が送られてきていることを確認
+    assert stats["rtp_hdrext"]["total_received_rtp_hdrext_av1_rtp_sepc"] > 0, (
+        "Dependency Descriptor RTP Header Extension が Python SDK から送られてきていません"
+    )

sora_sdk-2025.4.0.dev2/tests/test_key_frame_request.py

@@ -0,0 +1,75 @@
+import time
+
+import pytest
+from api import request_key_frame_api
+from client import (
+    SoraClient,
+    SoraRole,
+    codec_type_string_to_codec_type,
+)
+
+from sora_sdk import (
+    SoraVideoCodecImplementation,
+    SoraVideoCodecPreference,
+)
+
+
+@pytest.mark.parametrize(
+    "video_codec_type",
+    [
+        "VP9",
+        "VP8",
+        "AV1",
+    ],
+)
+def test_key_frame_request(settings, video_codec_type):
+    sendonly = SoraClient(
+        settings,
+        SoraRole.SENDONLY,
+        audio=False,
+        video=True,
+        video_codec_type=video_codec_type,
+        video_codec_preference=SoraVideoCodecPreference(
+            codecs=[
+                SoraVideoCodecPreference.Codec(
+                    type=codec_type_string_to_codec_type(video_codec_type),
+                    encoder=SoraVideoCodecImplementation.INTERNAL,
+                ),
+            ]
+        ),
+    )
+    sendonly.connect(fake_video=True)
+
+    time.sleep(3)
+
+    assert sendonly.connection_id is not None
+
+    # キーフレーム要求 API を 3 秒間隔で 3 回呼び出す
+    api_count = 3
+    for _ in range(api_count):
+        response = request_key_frame_api(
+            settings.api_url, sendonly.channel_id, sendonly.connection_id
+        )
+        assert response.status_code == 200
+        time.sleep(3)
+
+    # 統計を取得する
+    sendonly_stats = sendonly.get_stats()
+
+    sendonly.disconnect()
+
+    # outbound-rtp が無かったら StopIteration 例外が上がる
+    outbound_rtp_stats = next(s for s in sendonly_stats if s.get("type") == "outbound-rtp")
+
+    # 3 回以上
+    assert outbound_rtp_stats["keyFramesEncoded"] > api_count
+    assert outbound_rtp_stats["pliCount"] >= api_count
+    print("keyFramesEncoded:", outbound_rtp_stats["keyFramesEncoded"])
+    print("pliCount:", outbound_rtp_stats["pliCount"])
+
+    # PLI カウントの 50% 以上がキーフレームとしてエンコードされることを確認
+    assert outbound_rtp_stats["keyFramesEncoded"] >= outbound_rtp_stats["pliCount"] * 0.7
+    print(
+        "keyFramesEncoded >= pliCount * 0.7:",
+        outbound_rtp_stats["keyFramesEncoded"] >= outbound_rtp_stats["pliCount"] * 0.7,
+    )

{sora_sdk-2025.4.0.dev0 → sora_sdk-2025.4.0.dev2}/tests/test_nvidia_video_codec_sdk.py

@@ -2,6 +2,7 @@ import os
 import time
 
 import pytest
+from api import request_key_frame_api
 from client import (
     SoraClient,
     SoraRole,
@@ -56,6 +57,70 @@ def test_nvidia_video_codec_sdk_available():
                         pytest.fail(f"未実装の codec_type: {c.type}")
 
 
+@pytest.mark.skipif(
+    os.environ.get("NVIDIA_VIDEO_CODEC_SDK") is None, reason="NVIDIA Video Codec SDK でのみ実行する"
+)
+@pytest.mark.parametrize(
+    "video_codec_type",
+    [
+        "AV1",
+        "H264",
+        "H265",
+    ],
+)
+def test_intel_vpl_key_frame_request(settings, video_codec_type):
+    sendonly = SoraClient(
+        settings,
+        SoraRole.SENDONLY,
+        audio=False,
+        video=True,
+        video_codec_type=video_codec_type,
+        video_codec_preference=SoraVideoCodecPreference(
+            codecs=[
+                SoraVideoCodecPreference.Codec(
+                    type=codec_type_string_to_codec_type(video_codec_type),
+                    encoder=SoraVideoCodecImplementation.NVIDIA_VIDEO_CODEC_SDK,
+                ),
+            ]
+        ),
+    )
+    sendonly.connect(fake_video=True)
+
+    time.sleep(3)
+
+    assert sendonly.connection_id is not None
+
+    # キーフレーム要求 API を 3 秒間隔で 3 回呼び出す
+    api_count = 3
+    for _ in range(api_count):
+        response = request_key_frame_api(
+            settings.api_url, sendonly.channel_id, sendonly.connection_id
+        )
+        assert response.status_code == 200
+        time.sleep(3)
+
+    # 統計を取得する
+    sendonly_stats = sendonly.get_stats()
+
+    sendonly.disconnect()
+
+    # outbound-rtp が無かったら StopIteration 例外が上がる
+    outbound_rtp_stats = next(s for s in sendonly_stats if s.get("type") == "outbound-rtp")
+
+    # 3 回以上
+    assert outbound_rtp_stats["keyFramesEncoded"] > api_count
+    assert outbound_rtp_stats["pliCount"] >= api_count
+    print("keyFramesEncoded:", outbound_rtp_stats["keyFramesEncoded"])
+    print("pliCount:", outbound_rtp_stats["pliCount"])
+
+    # PLI カウントの 50% 以上がキーフレームとしてエンコードされることを確認
+    assert outbound_rtp_stats["keyFramesEncoded"] >= outbound_rtp_stats["pliCount"] * 0.7
+    print(
+        "keyFramesEncoded >= pliCount * 0.7:",
+        outbound_rtp_stats["keyFramesEncoded"] >= outbound_rtp_stats["pliCount"] * 0.7,
+    )
+
+
 @pytest.mark.skipif(
     os.environ.get("NVIDIA_VIDEO_CODEC_SDK") is None, reason="NVIDIA Video Codec SDK でのみ実行する"
 )

{sora_sdk-2025.4.0.dev0 → sora_sdk-2025.4.0.dev2}/tests/test_sendonly_recvonly.py

@@ -68,6 +68,8 @@ def test_sendonly_recvonly_video(
     )
     sendonly.connect(fake_video=True)
 
+    time.sleep(5)
+
     recvonly = SoraClient(
         settings,
         SoraRole.RECVONLY,
@@ -91,6 +93,11 @@ def test_sendonly_recvonly_video(
     assert outbound_rtp_stats["encoderImplementation"] == encoder_implementation
     assert outbound_rtp_stats["bytesSent"] > 0
     assert outbound_rtp_stats["packetsSent"] > 0
+    assert outbound_rtp_stats["keyFramesEncoded"] > 0
+    assert outbound_rtp_stats["pliCount"] > 0
+
+    print("keyFramesEncoded:", outbound_rtp_stats["keyFramesEncoded"])
+    print("pliCount:", outbound_rtp_stats["pliCount"])
 
     # codec が無かったら StopIteration 例外が上がる
     recvonly_codec_stats = next(s for s in recvonly_stats if s.get("type") == "codec")
@@ -101,3 +108,6 @@ def test_sendonly_recvonly_video(
     assert inbound_rtp_stats["decoderImplementation"] == decoder_implementation
     assert inbound_rtp_stats["bytesReceived"] > 0
     assert inbound_rtp_stats["packetsReceived"] > 0
+    assert inbound_rtp_stats["keyFramesDecoded"] > 0
+
+    print("keyFrameDecoded:", inbound_rtp_stats["keyFramesDecoded"])

sora_sdk-2025.4.0.dev0/VERSION

@@ -1 +0,0 @@
-2025.4.0.dev0