agora-python-server-sdk 2.0.3__tar.gz → 2.0.4__tar.gz

agora_python_server_sdk-2.0.4/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.1
+Name: agora_python_server_sdk
+Version: 2.0.4
+Summary: A Python SDK for Agora Server
+Home-page: https://github.com/AgoraIO-Extensions/Agora-Python-Server-SDK
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Note
+- This is a Python SDK wrapper for the Agora RTC SDK.
+- It supports Linux and Mac platforms.
+- The examples are provided as very simple demonstrations and are not recommended for use in production environments.
+
+# Very Important Notice !!!
+- A process can only have one instance.
+- An instance can have multiple connections.
+- In all observers or callbacks, you must not call the SDK's own APIs, nor perform CPU-intensive tasks in the callbacks; data copying is allowed.
+
+# Required Operating Systems and Python Versions
+- Supported Linux versions:
+  - Ubuntu 18.04 LTS and above
+  - CentOS 7.0 and above
+  
+- Supported Mac versions:
+  - MacOS 13 and above
+
+- Python version:
+  - Python 3.8 and above
+
+# Using Agora-Python-Server-SDK
+```
+pip install agora_python_server_sdk
+```
+
+# Running Examples
+
+## Preparing Test Data
+- Download and unzip [test_data.zip](https://download.agora.io/demo/test/test_data_202408221437.zip) to the Agora-Python-Server-SDK directory.
+
+## Executing Test Script
+```
+python agora_rtc/examples/example_audio_pcm_send.py --appId=xxx --channelId=xxx --userId=xxx --audioFile=./test_data/demo.pcm --sampleRate=16000 --numOfChannels=1
+```
+

agora_python_server_sdk-2.0.4/README.md

@@ -0,0 +1,36 @@
+# Note
+- This is a Python SDK wrapper for the Agora RTC SDK.
+- It supports Linux and Mac platforms.
+- The examples are provided as very simple demonstrations and are not recommended for use in production environments.
+
+# Very Important Notice !!!
+- A process can only have one instance.
+- An instance can have multiple connections.
+- In all observers or callbacks, you must not call the SDK's own APIs, nor perform CPU-intensive tasks in the callbacks; data copying is allowed.
+
+# Required Operating Systems and Python Versions
+- Supported Linux versions:
+  - Ubuntu 18.04 LTS and above
+  - CentOS 7.0 and above
+  
+- Supported Mac versions:
+  - MacOS 13 and above
+
+- Python version:
+  - Python 3.8 and above
+
+# Using Agora-Python-Server-SDK
+```
+pip install agora_python_server_sdk
+```
+
+# Running Examples
+
+## Preparing Test Data
+- Download and unzip [test_data.zip](https://download.agora.io/demo/test/test_data_202408221437.zip) to the Agora-Python-Server-SDK directory.
+
+## Executing Test Script
+```
+python agora_rtc/examples/example_audio_pcm_send.py --appId=xxx --channelId=xxx --userId=xxx --audioFile=./test_data/demo.pcm --sampleRate=16000 --numOfChannels=1
+```
+

{agora_python_server_sdk-2.0.3 → agora_python_server_sdk-2.0.4}/agora/rtc/__init__.py

@@ -16,16 +16,16 @@ def _check_download_and_extract_sdk():
     sdk_dir = os.path.join(agora_service_path, "agora_sdk")
     zip_path = os.path.join(agora_service_path, "agora_rtc_sdk.zip")
 
-    url = "https://download.agora.io/sdk/release/agora_rtc_sdk_linux_v4.4_20240914_1538_336910.zip"
+    url = "https://download.agora.io/sdk/release/agora_rtc_sdk_linux_v4.4.30-20240928_160128-358664.zip"
     libagora_rtc_sdk_path = os.path.join(sdk_dir, "libagora_rtc_sdk.so")
     if sys.platform == 'darwin':
-        url = "https://download.agora.io/sdk/release/agora_rtc_sdk_mac_v4.4_20240914_1538_336910.zip"
+        url = "https://download.agora.io/sdk/release/agora_sdk_mac_v4.4.30_22119_FULL_20240928_1647_358680.zip"
         libagora_rtc_sdk_path = os.path.join(sdk_dir, "libAgoraRtcKit.dylib")
 
     if os.path.exists(libagora_rtc_sdk_path):
         return
 
-    logger.error("agora sdk was broken!!! now download it, please wait for a while...")
+    logger.error("missing agora sdk, now download it, please wait for a while...")
     if os.path.exists(sdk_dir):
         os.system(f"rm -rf {sdk_dir}")        
     os.makedirs(agora_service_path, exist_ok=True)

{agora_python_server_sdk-2.0.3 → agora_python_server_sdk-2.0.4}/agora/rtc/_audio_frame_observer.py

@@ -16,7 +16,12 @@ class AudioFrameInner(ctypes.Structure):
         ("samples_per_sec", ctypes.c_int),
         ("buffer", ctypes.c_void_p),
         ("render_time_ms", ctypes.c_int64),
-        ("avsync_type", ctypes.c_int)
+        ("avsync_type", ctypes.c_int),
+        ("far_field_flag", ctypes.c_int),
+        ("rms", ctypes.c_int),
+        ("voice_prob", ctypes.c_int),
+        ("music_prob", ctypes.c_int),
+        ("pitch", ctypes.c_int)
     ]
     def _to_audio_frame(self):
         audio_frame = AudioFrame()
@@ -29,6 +34,12 @@ class AudioFrameInner(ctypes.Structure):
         audio_frame.buffer = bytearray(cdata)
         audio_frame.render_time_ms = self.render_time_ms
         audio_frame.avsync_type = self.avsync_type
+        audio_frame.far_field_flag = self.far_field_flag
+        audio_frame.rms = self.rms
+        audio_frame.voice_prob = self.voice_prob
+        audio_frame.music_prob = self.music_prob
+        audio_frame.pitch = self.pitch
+
         return audio_frame
     
 
@@ -99,7 +110,7 @@ class AudioFrameObserverInner(ctypes.Structure):
         return ret
 
     def _on_playback_audio_frame_before_mixing(self, local_user_handle, channel_id, user_id, audio_frame_inner):
-        logger.debug(f"AudioFrameObserverInner _on_playback_audio_frame_before_mixing: {local_user_handle}, {channel_id}, {user_id}, {audio_frame_inner}")
+        #logger.debug(f"AudioFrameObserverInner _on_playback_audio_frame_before_mixing: {local_user_handle}, {channel_id}, {user_id}, {audio_frame_inner}")
         if channel_id is None:
             channel_id_str = ""
         else:
@@ -112,46 +123,21 @@ class AudioFrameObserverInner(ctypes.Structure):
     
     def _on_get_audio_frame_position(self, local_user_handle):
         logger.debug(f"AudioFrameObserverInner _on_get_audio_frame_position: {local_user_handle}")
-        return 0
         return self.observer.on_get_audio_frame_position(self.local_user)
 
-    def _on_get_playback_audio_frame_param(self, local_user_handle):
+    def _on_get_playback_audio_frame_param(self, local_user_handle) -> AudioParams:
         logger.debug(f"AudioFrameObserverInner _on_get_playback_audio_frame_param: {local_user_handle}")
-        params = AudioParams()
-        params.sample_rate = 16000  # 示例值
-        params.channels = 1          # 示例值
-        params.mode = 0              # 示例值
-        params.samples_per_call = 1024  # 示例值
-        return params
         return self.observer.on_get_playback_audio_frame_param(self.local_user)
 
-    def _on_get_record_audio_frame_param(self, local_user_handle):
+    def _on_get_record_audio_frame_param(self, local_user_handle) -> AudioParams:
         logger.debug(f"AudioFrameObserverInner _on_get_record_audio_frame_param: {local_user_handle}")
-        params = AudioParams()
-        params.sample_rate = 16000  # 示例值
-        params.channels = 1          # 示例值
-        params.mode = 0              # 示例值
-        params.samples_per_call = 1024  # 示例值
-        return params
         return self.observer.on_get_record_audio_frame_param(self.local_user)
 
-    def _on_get_mixed_audio_frame_param(self, local_user_handle):
+    def _on_get_mixed_audio_frame_param(self, local_user_handle) -> AudioParams:
         logger.debug(f"AudioFrameObserverInner _on_get_mixed_audio_frame_param: {local_user_handle}")
-        params = AudioParams()
-        params.sample_rate = 16000  # 示例值
-        params.channels = 1          # 示例值
-        params.mode = 0              # 示例值
-        params.samples_per_call = 1024  # 示例值
-        return params
         return self.observer.on_get_mixed_audio_frame_param(self.local_user)
 
-    def _on_get_ear_monitoring_audio_frame_param(self, local_user_handle):
+    def _on_get_ear_monitoring_audio_frame_param(self, local_user_handle) -> AudioParams:
         logger.debug(f"AudioFrameObserverInner _on_get_ear_monitoring_audio_frame_param: {local_user_handle}")
-        params = AudioParams()
-        params.sample_rate = 16000  # 示例值
-        params.channels = 1          # 示例值
-        params.mode = 0              # 示例值
-        params.samples_per_call = 1024  # 示例值
-        return params
         return self.observer.on_get_ear_monitoring_audio_frame_param(self.local_user)
 

{agora_python_server_sdk-2.0.3 → agora_python_server_sdk-2.0.4}/agora/rtc/_local_user_observer.py

@@ -6,14 +6,6 @@ from .remote_video_track import RemoteVideoTrack, RemoteVideoTrackStats
 import logging
 logger = logging.getLogger(__name__)
 
-
-uid_t = ctypes.c_uint
-track_id_t = ctypes.c_uint
-
-#========localuser observer=====
-
-
-
 class VideoTrackInfoInner(ctypes.Structure):
     _fields_ = [
         ("is_local", ctypes.c_int),
@@ -56,7 +48,6 @@ class RemoteVideoStreamInfo(ctypes.Structure):
         ("total_downscale_level_counts", ctypes.c_uint8)
     ]
 
-# 定义回调函数类型
 ON_AUDIO_TRACK_PUBLISH_SUCCESS_CALLBACK = ctypes.CFUNCTYPE(None, AGORA_HANDLE, AGORA_HANDLE)
 ON_AUDIO_TRACK_PUBLISH_START_CALLBACK = ctypes.CFUNCTYPE(None, AGORA_HANDLE, AGORA_HANDLE)
 ON_AUDIO_TRACK_UNPUBLISHED_CALLBACK = ctypes.CFUNCTYPE(None, AGORA_HANDLE, AGORA_HANDLE)
@@ -95,31 +86,6 @@ ON_REMOTE_SUBSCRIBE_FALLBACK_TO_AUDIO_ONLY_CALLBACK = ctypes.CFUNCTYPE(None, AGO
 ON_STREAM_MESSAGE_CALLBACK = ctypes.CFUNCTYPE(None, AGORA_HANDLE, user_id_t, ctypes.c_int, ctypes.c_char_p, ctypes.c_size_t)
 ON_USER_STATE_CHANGED_CALLBACK = ctypes.CFUNCTYPE(None, AGORA_HANDLE, user_id_t, ctypes.c_uint32)
 
-
-"""
-on_user_info_updated(user_id_t: string ;  msg: int, val: int)
-msg:  
-enum USER_MEDIA_INFO {
-    /**
-     * 0: The user has muted the audio.
-     */
-    USER_MEDIA_INFO_MUTE_AUDIO = 0,
-    /**
-     * 1: The user has muted the video.
-     */
-    USER_MEDIA_INFO_MUTE_VIDEO = 1,
-    /**
-     * 4: The user has enabled the video, which includes video capturing and encoding.
-     */
-    USER_MEDIA_INFO_ENABLE_VIDEO = 4,
-    /**
-     * 8: The user has enabled the local video capturing.
-     */
-    USER_MEDIA_INFO_ENABLE_LOCAL_VIDEO = 8,
-  };
-  val: 1: The user has muted the audio.0: unmuted the audio
-参考：https://doc.shengwang.cn/api-ref/rtc-server-sdk/cpp/classagora_1_1rtc_1_1_i_local_user_observer#onUserInfoUpdated()
-"""
 class RTCLocalUserObserverInner(ctypes.Structure):
     _fields_ = [
         ("on_audio_track_publish_success", ON_AUDIO_TRACK_PUBLISH_SUCCESS_CALLBACK),
@@ -241,7 +207,6 @@ class RTCLocalUserObserverInner(ctypes.Structure):
     def _on_audio_track_publication_failure(self, local_user_handle, local_audio_track_handle, error_code):
         logger.debug(f"LocalUserCB _on_audio_track_publication_failure: {local_user_handle}, {local_audio_track_handle}, {error_code}")
         audio_track = self.local_user.get_audio_map(local_audio_track_handle)
-        #note :move from map for failed publish
         self.local_user.del_audio_map(local_audio_track_handle)
         self.local_user_observer.on_audio_track_publication_failure(self.local_user, audio_track, error_code)
     
@@ -251,22 +216,9 @@ class RTCLocalUserObserverInner(ctypes.Structure):
         self.local_user_observer.on_local_audio_track_state_changed(self.local_user, audio_track, state, error)
 
     def _on_local_audio_track_statistics(self, local_user_handle, stats):
-        #logger.debug("LocalUserCB _on_local_audio_track_statistics:", local_user_handle, stats)
-        #stats: pointer to LocalAudioStats
         local_audio_stats = stats.contents
         self.local_user_observer.on_local_audio_track_statistics(self.local_user, local_audio_stats)
-    #这个有点trick
-    """
-    # 在LocalUser中是通过LocalUser.sub_audio(uid) 创建的，所以这里直接用uid来获取对应的RemoteAudioTrack
-    # 也就是说从app层的视角，对audio的区分是uid，但这边的回调并没有userid，所以对app层是不太友好的
-    # 也就是需要在LocalUser层中建立一个map表，用来记录userid和handle
-    # 然后在回调中，通过handle，找到uid，然后call 给app层的是uid
-    # 这样的话，在LocalUser层，就可以直接通过uid来获取对应的RemoteAudioTrack
-    """
-    #
-    # _on_user_audio_track_subscribed:in LocalUser to do sub(userid), and in this call back it pass out with 
-    # user_id & remote_audio_track_handle, so we should construct RemoteAudioTrack with (user_id & remote_audio_track_handle
-    # and save it in local_user, then in app layer, we can get RemoteAudioTrack with userid)
+
     def _on_user_audio_track_subscribed(self, local_user_handle, user_id, remote_audio_track_handle):
         logger.debug(f"LocalUserCB _on_user_audio_track_subscribed: {local_user_handle}, {user_id}, {remote_audio_track_handle}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
@@ -282,7 +234,6 @@ class RTCLocalUserObserverInner(ctypes.Structure):
         remote_audio_track = self.local_user.get_remote_audio_map(remote_audio_track_handle)
         self.local_user_observer.on_remote_audio_track_statistics(self.local_user, remote_audio_track, audio_stats)
 
-
     def _on_user_audio_track_state_changed(self, local_user_handle, user_id, remote_audio_track_handle, state, reason, elapsed):
         logger.debug(f"LocalUserCB _on_user_audio_track_state_changed: {local_user_handle}, {user_id}, {remote_audio_track_handle}, {state}, {reason}, {elapsed}")
         user_id_str = user_id.decode('utf-8') if user_id else ""
@@ -333,7 +284,6 @@ class RTCLocalUserObserverInner(ctypes.Structure):
         local_video_track = self.local_user.get_video_map(local_video_track_handle)
         video_stats = stats.contents
         self.local_user_observer.on_local_video_track_statistics(self.local_user, local_video_track, video_stats)
-    # # #ctypes.CFUNCTYPE(None, AGORA_HANDLE, user_id_t, ctypes.POINTER(VideoTrackInfo), AGORA_HANDLE)
     def _on_user_video_track_subscribed(self, local_user_handle, user_id, video_track_info, remote_video_track_handle):
         logger.debug(f"LocalUserCB _on_user_video_track_subscribed: {local_user_handle}, {user_id}, {remote_video_track_handle}, {video_track_info}")
         user_id_str = user_id.decode('utf-8') if user_id else ""

{agora_python_server_sdk-2.0.3 → agora_python_server_sdk-2.0.4}/agora/rtc/_rtc_connection_observer.py

@@ -3,7 +3,6 @@ import ctypes
 from .agora_base import *
 from .local_user import *
 from .globals import *
-# from  .rtc_connection import *
 from .rtc_connection_observer import *
 import logging
 logger = logging.getLogger(__name__)
@@ -19,20 +18,12 @@ class RTCConnInfoInner(ctypes.Structure):
     def _convert_to_rtc_conn_info(self):
         from .rtc_connection import RTCConnInfo
         con_info = RTCConnInfo()
-
-        # 直接访问字段
         con_info.id = self.id
         con_info.channel_id = self.channel_id.decode('utf-8') if self.channel_id else ''
         con_info.state = self.state
         con_info.local_user_id = self.local_user_id.decode('utf-8') if self.local_user_id else ''
         con_info.internal_uid = self.internal_uid
-
         return con_info
-    
-    
-
-uid_t = ctypes.c_uint
-track_id_t = ctypes.c_uint
 
 ON_CONNECTED_CALLBACK = ctypes.CFUNCTYPE(None, AGORA_HANDLE, ctypes.POINTER(RTCConnInfoInner), ctypes.c_int)
 ON_DISCONNECTED_CALLBACK = ctypes.CFUNCTYPE(None, AGORA_HANDLE, ctypes.POINTER(RTCConnInfoInner), ctypes.c_int)
@@ -144,32 +135,6 @@ class RTCConnectionObserverInner(ctypes.Structure):
         self.on_encryption_error = ON_ENCRYPTION_ERROR_CALLBACK(self._on_encryption_error)
         self.on_upload_log_result = ON_UPLOAD_LOG_RESULT_CALLBACK(self._on_upload_log_result)
 
-
-        #agora_rtc_conn： handle of RTCConnection; conn_info_inner:pointer to RTCConnInfoInner 
-        #reason: int type
-        #
-        """
-        parameter type desp:
-        agora_rtc_conn： handle of RTCConnection; 
-        conn_info_inner:pointer to RTCConnInfoInner 
-        reason: int type
-        quality:int type
-
-        # note: sumary for ctypes.POINTER
-        #note: conn_info_inner is a pointer to RTCConnInfoInner, so we should do like following to ensure
-        # conn_info is a RTCConnInfo
-        # we make sure: conn_info_inner is a pointer to RTCConnInfoInner from ctypes, so 
-        # no need to do type check like isinstance(xx),just use dereferencing method to get the contents
-        if isinstance(conn_info_inner, ctypes.POINTER(RTCConnInfoInner)):
-            conn_info = conn_info_inner.contents._convert_to_rtc_conn_info()
-        else:
-            conn_info = conn_info_inner._convert_to_rtc_conn_info()
-
-        just use: 
-        conn_info = conn_info_inner.contents.()
-        
-        to 
-        """
     def _on_connected(self, agora_rtc_conn, conn_info_inner, reason):
         logger.debug(f"ConnCB _on_connected: {agora_rtc_conn}, {conn_info_inner}, {reason}")
         conn_info = conn_info_inner.contents._convert_to_rtc_conn_info()
@@ -204,16 +169,11 @@ class RTCConnectionObserverInner(ctypes.Structure):
         logger.debug(f"ConnCB _on_lastmile_quality: {agora_rtc_conn}, {quality}")
         self.conn_observer.on_lastmile_quality(self.conn, quality)
 
-    #last_mile_prob_result_ptr: ctypes.POINTER(LastmileProbeResult)) type
     def _on_lastmile_probe_result(self, agora_rtc_conn, last_mile_prob_result_ptr):
         logger.debug(f"ConnCB _on_lastmile_probe_result: {agora_rtc_conn}, {last_mile_prob_result_ptr}")
-        # result is a pointer to LastmileProbeResult
-        # we should dereference the pointer to get the LastmileProbeResult, thus we can access its fields
-        last_mile_result = last_mile_prob_result_ptr.contents
-        
+        last_mile_result = last_mile_prob_result_ptr.contents        
         self.conn_observer.on_lastmile_probe_result(self.conn, last_mile_result)
 
-    #token: ctypes.char_p
     def _on_token_privilege_will_expire(self, agora_rtc_conn, token):
         logger.debug(f"ConnCB _on_token_privilege_will_expire: {agora_rtc_conn}, {token}")
         token_str = token.decode('utf-8') #decode will generate a new object
@@ -231,7 +191,7 @@ class RTCConnectionObserverInner(ctypes.Structure):
         logger.debug(f"ConnCB _on_connection_failure: {agora_rtc_conn}, {conn_info_inner}, {reason}")
         conn_info = conn_info_inner.contents._convert_to_rtc_conn_info()
         self.conn_observer.on_connection_failure(self.conn, conn_info, reason)
-    #userid: ctyps.char_p   
+
     def _on_user_joined(self, agora_rtc_conn, user_id):
         logger.debug(f"ConnCB _on_user_joined: {agora_rtc_conn}, {user_id}")
         userid_str = user_id.decode('utf-8')
@@ -241,21 +201,12 @@ class RTCConnectionObserverInner(ctypes.Structure):
         logger.debug(f"ConnCB _on_user_left: {agora_rtc_conn}, {user_id}, {reason}")
         userid_str = user_id.decode('utf-8')
         self.conn_observer.on_user_left(self.conn, userid_str, reason)
-    #stats: ctypes.POINTER(RTCStats)
+
     def _on_transport_stats(self, agora_rtc_conn, stats):
         logger.debug(f"ConnCB _on_transport_stats: {agora_rtc_conn}, {stats}")
-        #stats is a pointer to RTCStats
-        #should dereference the pointer to get the RTCStats, thus we can access its fields
-        rtc_stats = stats.contents
-        """
-        if isinstance(stats, ctypes.POINTER(RTCStats)):
-            rtc_stats = stats.contents
-        else:
-            rtc_stats = stats
-        """
-        
+        rtc_stats = stats.contents        
         self.conn_observer.on_transport_stats(self.conn, rtc_stats)
-    #old_role/new_role: ctypes.int
+
     def _on_change_role_success(self, agora_rtc_conn, old_role, new_role):
         logger.debug(f"ConnCB _on_change_role_success: {agora_rtc_conn}, {old_role}, {new_role}")
         self.conn_observer.on_change_role_success(self.conn, old_role, new_role)
@@ -266,32 +217,25 @@ class RTCConnectionObserverInner(ctypes.Structure):
 
     def _on_user_network_quality(self, agora_rtc_conn, user_id, tx_quality, rx_quality):
         logger.debug(f"ConnCB _on_user_network_quality: {agora_rtc_conn}, {user_id}, {tx_quality}, {rx_quality}")
-        #user_id: ctypes.char_p
-        #tx_quality: ctypes.int
-        #rx_quality: ctypes.int
         userid_str = user_id.decode('utf-8') if user_id else ""
         self.conn_observer.on_user_network_quality(self.conn, userid_str, tx_quality, rx_quality)
 
     def _on_network_type_changed(self, agora_rtc_conn, network_type):
         logger.debug(f"ConnCB _on_network_type_changed: {agora_rtc_conn}, {network_type}")
-        #network_type: ctypes.int
         self.conn_observer.on_network_type_changed(self.conn, network_type)
 
     def _on_api_call_executed(self, agora_rtc_conn, error, api_type, api_params):
         logger.debug(f"ConnCB _on_api_call_executed: {agora_rtc_conn}, {error}, {api_type}, {api_params}")
-        #error: ctypes.int; api_type: ctypes.char_p; api_params: ctypes.char_p
         _api_type_str = api_type.decode('utf-8') if api_type else ""
         _api_param_str = api_params.decode('utf-8') if api_params else ""
         self.conn_observer.on_api_call_executed(self.conn, error, _api_type_str, _api_param_str)
 
     def _on_content_inspect_result(self, agora_rtc_conn, result):
         logger.debug(f"ConnCB _on_content_inspect_result: {agora_rtc_conn}, {result}")
-        #result: ctypes.int
         self.conn_observer.on_content_inspect_result(self.conn, result)
 
     def _on_snapshot_taken(self, agora_rtc_conn, channel, uid, filepath, width, height, errCode):
         logger.debug(f"ConnCB _on_snapshot_taken: {agora_rtc_conn}, {channel}, {uid}, {filepath}, {width}, {height}, {errCode}")
-        #channel: ctypes.c_char_p; uid: ctypes.c_uint32; filepath: ctypes.c_char_p; width: ctypes.c_int32; height: ctypes.c_int32; errCode: ctypes.c_int32
         _channel_str = channel.decode('utf-8') if channel else ""
         _file_path_str = filepath.decode('utf-8') if filepath else ""
         self.conn_observer.on_snapshot_taken(self.conn, _channel_str, uid, _file_path_str, width, height, errCode)
@@ -330,7 +274,6 @@ class RTCConnectionObserverInner(ctypes.Structure):
         logger.debug(f"ConnCB _on_encryption_error: {agora_rtc_conn}, {error_type}")
         self.conn_observer.on_encryption_error(self.conn, error_type)
 
-    #request_id: ctypes.c_char_p; success/reason: ctypes.int
     def _on_upload_log_result(self, agora_rtc_conn, request_id, success, reason):
         logger.debug(f"ConnCB _on_upload_log_result: {agora_rtc_conn}, {request_id}, {success}, {reason}")
         _request_id_str = request_id.decode("utf-8") if request_id else ""

{agora_python_server_sdk-2.0.3 → agora_python_server_sdk-2.0.4}/agora/rtc/_video_encoded_frame_observer.py

@@ -6,12 +6,6 @@ from .video_encoded_frame_observer import IVideoEncodedFrameObserver, EncodedVid
 import logging
 logger = logging.getLogger(__name__)
 
-# typedef struct _video_encoded_frame_observer {
-#   int (*on_encoded_video_frame)(AGORA_HANDLE agora_video_encoded_frame_observer, uid_t uid, const uint8_t* image_buffer, size_t length,
-#                                 const encoded_video_frame_info* video_encoded_frame_info);
-# } video_encoded_frame_observer;
-
-
 class EncodedVideoFrameInfoInner(ctypes.Structure):
     _fields_ = [
         ("codec_type", ctypes.c_int),

{agora_python_server_sdk-2.0.3 → agora_python_server_sdk-2.0.4}/agora/rtc/_video_frame_observer.py

@@ -52,6 +52,11 @@ class VideoFrameInner(ctypes.Structure):
 
 ON_FRAME_CALLBACK = ctypes.CFUNCTYPE(None, AGORA_HANDLE, ctypes.c_char_p, user_id_t, ctypes.POINTER(VideoFrameInner))
 
+agora_video_frame_observer_get_rotation_applied = agora_lib.agora_video_frame_observer_get_rotation_applied
+agora_video_frame_observer_get_rotation_applied.restype = ctypes.c_int
+agora_video_frame_observer_get_rotation_applied.argtypes = [AGORA_HANDLE]
+
+
 class VideoFrameObserverInner(ctypes.Structure):
     _fields_ = [
         ("on_frame", ON_FRAME_CALLBACK)
@@ -65,29 +70,5 @@ class VideoFrameObserverInner(ctypes.Structure):
 
     def _on_frame(self, agora_handle, channel_id, user_id, video_frame:VideoFrameInner):
         vf = video_frame.contents
-        # logger.debug("VideoFrameObserver _on_frame:", agora_handle, channel_id, user_id, vf.metadata_buffer, vf.metadata_size)
         self.video_frame_observer.on_frame(agora_handle, channel_id.decode() if channel_id else None, user_id.decode(), vf.to_video_frame())
-    
-
-
-
-
-
-# ON_ENCODED_VIDEO_IMAGE_RECEIVED_CALLBACK = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint8), ctypes.c_uint32, ctypes.POINTER(encoded_video_frame_info))
-
-# class VideoEncodedImageReceiverInner(ctypes.Structure):
-#     _fields_ = [
-#         ("on_encoded_video_image_received", ON_ENCODED_VIDEO_IMAGE_RECEIVED_CALLBACK)
-#     ]
-
-#     def __init__(self, video_encoded_image_receiver:'IVideoEncodedImageReceiver'):
-#         self.video_encoded_image_receiver = video_encoded_image_receiver
-#         self.on_encoded_video_image_received = ON_ENCODED_VIDEO_IMAGE_RECEIVED_CALLBACK(self._on_encoded_video_image_received)
-
-
-#     def _on_encoded_video_image_received(self, agora_handle, image_buffer, length, info):
-#         logger.debug("VideoFrameObserver _on_frame:", agora_handle, image_buffer, length, info)
-#         # self.on_encoded_video_image_received(agora_handle, image_buffer, length, info)
-#         self.video_encoded_image_receiver.on_encoded_video_image_received(agora_handle, image_buffer, length, info)
-
-
+    

{agora_python_server_sdk-2.0.3 → agora_python_server_sdk-2.0.4}/agora/rtc/agora_base.py

@@ -294,6 +294,11 @@ class AudioFrame:
         self.buffer = None
         self.render_time_ms = 0
         self.avsync_type = 0
+        self.far_field_flag = 0
+        self.rms = 0
+        self.voice_prob = 0
+        self.music_prob = 0
+        self.pitch = 0
     
 class AudioParams(ctypes.Structure):
     _fields_ = [

{agora_python_server_sdk-2.0.3 → agora_python_server_sdk-2.0.4}/agora/rtc/agora_service.py

@@ -123,6 +123,11 @@ agora_service_create_custom_video_track_frame = agora_lib.agora_service_create_c
 agora_service_create_custom_video_track_frame.restype = AGORA_HANDLE
 agora_service_create_custom_video_track_frame.argtypes = [AGORA_HANDLE, AGORA_HANDLE]
 
+agora_service_enable_extension = agora_lib.agora_service_enable_extension
+agora_service_enable_extension.restype = AGORA_API_C_INT
+agora_service_enable_extension.argtypes = [AGORA_HANDLE, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_uint]
+
+
 class SenderOptions(ctypes.Structure):
     _fields_ = [
         ("cc_mode", ctypes.c_int),
@@ -142,6 +147,8 @@ agora_service_create_custom_video_track_encoded.argtypes = [AGORA_HANDLE, AGORA_
 class AgoraService:
     def __init__(self) -> None:
         self.service_handle = agora_service_create()
+       
+        # set tag???
         self.inited = False
 
     def initialize(self, config: AgoraServiceConfig):       
@@ -153,6 +160,15 @@ class AgoraService:
             self.inited = True
         logger.debug(f'Initialization result: {result}')
 
+         # to enable plugin
+        provider = "agora.builtin"
+        generator = "agora_audio_label_generator"
+        cprovider = provider.encode('utf-8')
+        cgenerator = generator.encode('utf-8')
+        ctrak = ctypes.c_char_p(None)
+        #agora_service_enable_extension(self.service_handle, "agora.builtin", "agora_audio_label_generator", None, 1)
+        agora_service_enable_extension(self.service_handle, cprovider, cgenerator, ctrak, 1)
+
         if config.log_path:
             log_size = 512 * 1024
             if config.log_size > 0:
@@ -172,7 +188,7 @@ class AgoraService:
         self.inited = False
         self.service_handle = None
     
-    #createMediaNodeFactory	创建一个媒体节点工厂对象。
+    #createMediaNodeFactory: to create a medianode factory object
     def create_media_node_factory(self):
         if not self.inited:
             logger.error("AgoraService is not initialized. Please call initialize() first.")
@@ -193,8 +209,8 @@ class AgoraService:
         return RTCConnection(rtc_conn_handle)
 
 
-    #createCustomAudioTrackPcm	创建一个自定义音频Track。
-    def create_custom_audio_track_pcm(self, audio_pcm_data_sender:AudioPcmDataSender):
+    #createCustomAudioTrackPcm: creatae a custom audio track from pcm data sender
+    def create_custom_audio_track_pcm(self, audio_pcm_data_sender:AudioPcmDataSender) -> LocalAudioTrack | None:
         if not self.inited:
             logger.error("AgoraService is not initialized. Please call initialize() first.")
             return None

{agora_python_server_sdk-2.0.3 → agora_python_server_sdk-2.0.4}/agora/rtc/audio_encoded_frame_sender.py

@@ -6,9 +6,6 @@ logger = logging.getLogger(__name__)
 class EncodedAudioFrame:
     def __init__(
             self, 
-            # data: bytearray = None,
-            # buffer_ptr: int = 0,
-            # buffer_size: int = 0,
             capture_timems: int = 0,
             codec: AudioCodecType = AudioCodecType.AUDIO_CODEC_AACLC, 
             number_of_channels: int = 1,
@@ -17,18 +14,13 @@ class EncodedAudioFrame:
             send_even_if_empty: int = 1,
             speech: int = 1
             )->None:
-        # self.data = data        
-        # self.buffer_ptr = buffer_ptr
-        # self.buffer_size = buffer_size
-        self.capture_timems = capture_timems #int64, 音频帧的 Unix 时间戳（毫秒）
-        #int, 音频帧的编码格式; ref: https://doc.shengwang.cn/api-ref/rtc-server-sdk/cpp/namespaceagora_1_1rtc#ac211c1a503d38d504c92b5f006240053
+        self.capture_timems = capture_timems
         self.codec = codec
         self.number_of_channels = number_of_channels
         self.sample_rate = sample_rate
-        #int, 对于 aac 编码格式，默认为 1024；对于 Opus 编码格式，默认为 960
         self.samples_per_channel = samples_per_channel
-        self.send_even_if_empty = send_even_if_empty #bool value, 是否发送空音频帧,default TRUE
-        self.speech = speech #bool, 是否是语音,default TRUE
+        self.send_even_if_empty = send_even_if_empty
+        self.speech = speech
 
     def to_owned_encoded_audio_frame(self):
         info = OwnedEncodedAudioFrameInfo()
@@ -75,19 +67,10 @@ class AudioEncodedFrameSender:
     #     c_date = (ctypes.c_char * len(frame.data)).from_buffer(frame.data)
     #     ownedinfo = frame.to_owned_encoded_audio_frame()
     #     ret = agora_audio_encoded_frame_sender_send(self.sender_handle, c_date, ctypes.c_uint32(len(frame.data)), ctypes.byref(ownedinfo))
-    #     if ret < 0:
-    #         logger.error(f"Failed to send encoded audio frame with error code: {ret}")
     #     return ret
     
     def send_encoded_audio_frame(self, buffer_ptr:int, buffer_size:int, frame:EncodedAudioFrame):
         buffer_ptr = ctypes.cast(buffer_ptr, ctypes.POINTER(ctypes.c_void_p))
         ownedinfo = frame.to_owned_encoded_audio_frame()
         ret = agora_audio_encoded_frame_sender_send(self.sender_handle, buffer_ptr, ctypes.c_uint32(buffer_size), ctypes.byref(ownedinfo))
-        if ret < 0:
-            logger.error(f"Failed to send encoded audio frame with error code: {ret}")
         return ret
-
-    
-    def release(self):
-        # agora_local_audio_track_destroy(self.sender_handle)
-        pass

agora_python_server_sdk-2.0.4/agora/rtc/audio_frame_observer.py

@@ -0,0 +1,32 @@
+from .agora_base import AudioFrame, AudioParams
+
+class IAudioFrameObserver:
+    def on_record_audio_frame(self, agora_local_user, channelId, frame):
+        return 1
+
+    def on_playback_audio_frame(self, agora_local_user, channelId, frame):
+        return 1
+
+    def on_mixed_audio_frame(self, agora_local_user, channelId, frame):
+        return 1
+
+    def on_ear_monitoring_audio_frame(self, agora_local_user, frame):
+        return 1
+
+    def on_playback_audio_frame_before_mixing(self, agora_local_user, channelId, uid, frame:AudioFrame):
+        return 1
+
+    def on_get_audio_frame_position(self, agora_local_user):
+        return 1
+
+    def on_get_playback_audio_frame_param(self, agora_local_user) -> AudioParams:
+        pass
+
+    def on_get_record_audio_frame_param(self, agora_local_user) -> AudioParams:
+        pass
+
+    def on_get_mixed_audio_frame_param(self, agora_local_user) -> AudioParams:
+        pass
+
+    def on_get_ear_monitoring_audio_frame_param(self, agora_local_user) -> AudioParams:
+        pass