Page MenuHomePhabricator
Files F7159697

No OneTemporary
Actions

View Options

diff --git a/sipsimple/application.py b/sipsimple/application.py
index 61fcb116..beb789f3 100644
--- a/sipsimple/application.py
+++ b/sipsimple/application.py
@@ -1,513 +1,512 @@
# Copyright (C) 2008-2011 AG Projects. See LICENSE for details.
#
"""
Implements a high-level application responsable for starting and stopping
various sub-systems required to implement a fully featured SIP User Agent
application.
"""
from __future__ import absolute_import
__all__ = ["SIPApplication"]
import os
from application.notification import IObserver, NotificationCenter, NotificationData
from application.python import Null
from application.python.descriptor import classproperty
from application.python.types import Singleton
from eventlib import proc
from operator import attrgetter
from threading import RLock, Thread
from twisted.internet import reactor
from uuid import uuid4
from xcaplib import client as xcap_client
from zope.interface import implements
from sipsimple.account import AccountManager
from sipsimple.addressbook import AddressbookManager
from sipsimple.audio import AudioDevice, RootAudioBridge
from sipsimple.configuration import ConfigurationManager
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.core import AudioMixer, Engine
from sipsimple.lookup import DNSManager
from sipsimple.session import SessionManager
from sipsimple.storage import ISIPSimpleStorage, ISIPSimpleApplicationDataStorage
from sipsimple.threading import ThreadManager, run_in_thread, run_in_twisted_thread
from sipsimple.threading.green import run_in_green_thread
from sipsimple.video import VideoDevice
class ApplicationAttribute(object):
def __init__(self, value):
self.value = value
def __get__(self, obj, objtype):
return self.value
def __set__(self, obj, value):
self.value = value
def __delete__(self, obj):
raise AttributeError('cannot delete attribute')
class SIPApplication(object):
__metaclass__ = Singleton
implements(IObserver)
storage = ApplicationAttribute(value=None)
engine = ApplicationAttribute(value=None)
thread = ApplicationAttribute(value=None)
state = ApplicationAttribute(value=None)
alert_audio_device = ApplicationAttribute(value=None)
alert_audio_bridge = ApplicationAttribute(value=None)
voice_audio_device = ApplicationAttribute(value=None)
voice_audio_bridge = ApplicationAttribute(value=None)
video_device = ApplicationAttribute(value=None)
_lock = ApplicationAttribute(value=RLock())
_timer = ApplicationAttribute(value=None)
_stop_pending = ApplicationAttribute(value=False)
running = classproperty(lambda cls: cls.state == 'started')
alert_audio_mixer = classproperty(lambda cls: cls.alert_audio_bridge.mixer if cls.alert_audio_bridge else None)
voice_audio_mixer = classproperty(lambda cls: cls.voice_audio_bridge.mixer if cls.voice_audio_bridge else None)
def start(self, storage):
if not ISIPSimpleStorage.providedBy(storage):
raise TypeError("storage must implement the ISIPSimpleStorage interface")
with self._lock:
if self.state is not None:
raise RuntimeError("SIPApplication cannot be started from '%s' state" % self.state)
self.state = 'starting'
self.engine = Engine()
self.storage = storage
thread_manager = ThreadManager()
thread_manager.start()
configuration_manager = ConfigurationManager()
addressbook_manager = AddressbookManager()
account_manager = AccountManager()
# load configuration and initialize core
try:
configuration_manager.start()
SIPSimpleSettings()
account_manager.load()
addressbook_manager.load()
except:
self.engine = None
self.state = None
self.storage = None
raise
# run the reactor thread
self.thread = Thread(name='Reactor Thread', target=self._run_reactor)
self.thread.start()
def stop(self):
with self._lock:
if self.state in (None, 'stopping', 'stopped'):
return
elif self.state == 'starting':
self._stop_pending = True
return
self.state = 'stopping'
notification_center = NotificationCenter()
notification_center.post_notification('SIPApplicationWillEnd', sender=self)
self._shutdown_subsystems()
def _run_reactor(self):
from eventlib.twistedutil import join_reactor
notification_center = NotificationCenter()
notification_center.post_notification('SIPApplicationWillStart', sender=self)
with self._lock:
stop_pending = self._stop_pending
if stop_pending:
self.state = 'stopping'
if stop_pending:
notification_center.post_notification('SIPApplicationWillEnd', sender=self)
else:
self._initialize_core()
reactor.run(installSignalHandlers=False)
with self._lock:
self.state = 'stopped'
notification_center.post_notification('SIPApplicationDidEnd', sender=self)
def _initialize_core(self):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
# initialize core
options = dict(# general
user_agent=settings.user_agent,
# SIP
detect_sip_loops=True,
udp_port=settings.sip.udp_port if 'udp' in settings.sip.transport_list else None,
tcp_port=settings.sip.tcp_port if 'tcp' in settings.sip.transport_list else None,
tls_port=None,
# TLS
tls_verify_server=False,
tls_ca_file=None,
tls_cert_file=None,
tls_privkey_file=None,
# rtp
rtp_port_range=(settings.rtp.port_range.start, settings.rtp.port_range.end),
# audio
codecs=list(settings.rtp.audio_codec_list),
# video
video_codecs=list(settings.rtp.video_codec_list),
# logging
log_level=settings.logs.pjsip_level if settings.logs.trace_pjsip else 0,
trace_sip=settings.logs.trace_sip)
notification_center.add_observer(self, sender=self.engine)
self.engine.start(**options)
def _initialize_tls(self):
settings = SIPSimpleSettings()
account_manager = AccountManager()
account = account_manager.default_account
if account is not None:
try:
self.engine.set_tls_options(port=settings.sip.tls_port,
verify_server=account.tls.verify_server,
ca_file=settings.tls.ca_list.normalized if settings.tls.ca_list else None,
cert_file=account.tls.certificate.normalized if account.tls.certificate else None,
privkey_file=account.tls.certificate.normalized if account.tls.certificate else None)
except Exception, e:
notification_center = NotificationCenter()
notification_center.post_notification('SIPApplicationFailedToStartTLS', sender=self, data=NotificationData(error=e))
@run_in_green_thread
def _initialize_subsystems(self):
notification_center = NotificationCenter()
with self._lock:
stop_pending = self._stop_pending
if stop_pending:
self.state = 'stopping'
if stop_pending:
notification_center.post_notification('SIPApplicationWillEnd', sender=self)
reactor.stop()
return
account_manager = AccountManager()
addressbook_manager = AddressbookManager()
dns_manager = DNSManager()
session_manager = SessionManager()
settings = SIPSimpleSettings()
xcap_client.DEFAULT_HEADERS = {'User-Agent': settings.user_agent}
# initialize TLS
self._initialize_tls()
# initialize PJSIP internal resolver
self.engine.set_nameservers(dns_manager.nameservers)
# initialize audio objects
alert_device = settings.audio.alert_device
if alert_device not in (None, u'system_default') and alert_device not in self.engine.output_devices:
alert_device = u'system_default'
input_device = settings.audio.input_device
if input_device not in (None, u'system_default') and input_device not in self.engine.input_devices:
input_device = u'system_default'
output_device = settings.audio.output_device
if output_device not in (None, u'system_default') and output_device not in self.engine.output_devices:
output_device = u'system_default'
tail_length = settings.audio.echo_canceller.tail_length if settings.audio.echo_canceller.enabled else 0
voice_mixer = AudioMixer(input_device, output_device, settings.audio.sample_rate, tail_length)
voice_mixer.muted = settings.audio.muted
self.voice_audio_device = AudioDevice(voice_mixer)
self.voice_audio_bridge = RootAudioBridge(voice_mixer)
self.voice_audio_bridge.add(self.voice_audio_device)
alert_mixer = AudioMixer(None, alert_device, settings.audio.sample_rate, 0)
if settings.audio.silent:
alert_mixer.output_volume = 0
self.alert_audio_device = AudioDevice(alert_mixer)
self.alert_audio_bridge = RootAudioBridge(alert_mixer)
self.alert_audio_bridge.add(self.alert_audio_device)
settings.audio.input_device = voice_mixer.input_device
settings.audio.output_device = voice_mixer.output_device
settings.audio.alert_device = alert_mixer.output_device
# initialize video
self.video_device = VideoDevice(settings.video.device, settings.video.resolution, settings.video.framerate)
self.video_device.muted = settings.video.muted
settings.video.device = self.video_device.name
- self.engine.set_h264_options(settings.video.h264.profile,
- settings.video.h264.level,
- settings.video.resolution,
- settings.video.framerate,
- settings.video.max_bitrate)
+ self.engine.set_video_options(settings.video.resolution,
+ settings.video.framerate,
+ settings.video.max_bitrate)
+ self.engine.set_h264_options(settings.video.h264.profile, settings.video.h264.level)
# initialize instance id
if not settings.instance_id:
settings.instance_id = uuid4().urn
# initialize path for ZRTP cache file
if ISIPSimpleApplicationDataStorage.providedBy(self.storage):
self.engine.zrtp_cache = os.path.join(self.storage.directory, 'zrtp.db')
# save settings in case something was modified during startup
settings.save()
# initialize middleware components
dns_manager.start()
account_manager.start()
addressbook_manager.start()
session_manager.start()
notification_center.add_observer(self, name='CFGSettingsObjectDidChange')
notification_center.add_observer(self, name='DNSNameserversDidChange')
notification_center.add_observer(self, name='SystemIPAddressDidChange')
notification_center.add_observer(self, name='SystemDidWakeUpFromSleep')
with self._lock:
self.state = 'started'
stop_pending = self._stop_pending
notification_center.post_notification('SIPApplicationDidStart', sender=self)
if stop_pending:
self.stop()
@run_in_green_thread
def _shutdown_subsystems(self):
# cleanup internals
if self._timer is not None and self._timer.active():
self._timer.cancel()
self._timer = None
# shutdown middleware components
dns_manager = DNSManager()
account_manager = AccountManager()
addressbook_manager = AddressbookManager()
session_manager = SessionManager()
procs = [proc.spawn(dns_manager.stop), proc.spawn(account_manager.stop), proc.spawn(addressbook_manager.stop), proc.spawn(session_manager.stop)]
proc.waitall(procs)
# stop video device
self.video_device.producer.close()
# shutdown engine
self.engine.stop()
self.engine.join()
# stop threads
thread_manager = ThreadManager()
thread_manager.stop()
# stop the reactor
reactor.stop()
def _network_conditions_changed(self):
if self.running and self._timer is None:
def notify():
if self.running:
settings = SIPSimpleSettings()
if 'tcp' in settings.sip.transport_list:
self.engine.set_tcp_port(None)
self.engine.set_tcp_port(settings.sip.tcp_port)
if 'tls' in settings.sip.transport_list:
self._initialize_tls()
notification_center = NotificationCenter()
notification_center.post_notification('NetworkConditionsDidChange', sender=self)
self._timer = None
self._timer = reactor.callLater(5, notify)
@run_in_twisted_thread
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPEngineDidStart(self, notification):
self._initialize_subsystems()
def _NH_SIPEngineDidFail(self, notification):
with self._lock:
if self.state == 'stopping':
return
elif self.state == 'starting':
self._stop_pending = True
return
self.state = 'stopping'
notification.center.post_notification('SIPApplicationWillEnd', sender=self)
reactor.stop()
@run_in_thread('device-io')
def _NH_CFGSettingsObjectDidChange(self, notification):
settings = SIPSimpleSettings()
account_manager = AccountManager()
if notification.sender is settings:
if 'audio.sample_rate' in notification.data.modified:
alert_device = settings.audio.alert_device
if alert_device not in (None, u'system_default') and alert_device not in self.engine.output_devices:
alert_device = u'system_default'
input_device = settings.audio.input_device
if input_device not in (None, u'system_default') and input_device not in self.engine.input_devices:
input_device = u'system_default'
output_device = settings.audio.output_device
if output_device not in (None, u'system_default') and output_device not in self.engine.output_devices:
output_device = u'system_default'
tail_length = settings.audio.echo_canceller.tail_length if settings.audio.echo_canceller.enabled else 0
voice_mixer = AudioMixer(input_device, output_device, settings.audio.sample_rate, tail_length)
voice_mixer.muted = settings.audio.muted
self.voice_audio_device = AudioDevice(voice_mixer)
self.voice_audio_bridge = RootAudioBridge(voice_mixer)
self.voice_audio_bridge.add(self.voice_audio_device)
alert_mixer = AudioMixer(None, alert_device, settings.audio.sample_rate, 0)
self.alert_audio_device = AudioDevice(alert_mixer)
self.alert_audio_bridge = RootAudioBridge(alert_mixer)
self.alert_audio_bridge.add(self.alert_audio_device)
if settings.audio.silent:
alert_mixer.output_volume = 0
settings.audio.input_device = voice_mixer.input_device
settings.audio.output_device = voice_mixer.output_device
settings.audio.alert_device = alert_mixer.output_device
settings.save()
else:
if set(['audio.input_device', 'audio.output_device', 'audio.alert_device', 'audio.echo_canceller.enabled', 'audio.echo_canceller.tail_length']).intersection(notification.data.modified):
input_device = settings.audio.input_device
if input_device not in (None, u'system_default') and input_device not in self.engine.input_devices:
input_device = u'system_default'
output_device = settings.audio.output_device
if output_device not in (None, u'system_default') and output_device not in self.engine.output_devices:
output_device = u'system_default'
tail_length = settings.audio.echo_canceller.tail_length if settings.audio.echo_canceller.enabled else 0
if (input_device, output_device, tail_length) != attrgetter('input_device', 'output_device', 'ec_tail_length')(self.voice_audio_bridge.mixer):
self.voice_audio_bridge.mixer.set_sound_devices(input_device, output_device, tail_length)
settings.audio.input_device = self.voice_audio_bridge.mixer.input_device
settings.audio.output_device = self.voice_audio_bridge.mixer.output_device
settings.save()
alert_device = settings.audio.alert_device
if alert_device not in (None, u'system_default') and alert_device not in self.engine.output_devices:
alert_device = u'system_default'
if alert_device != self.alert_audio_bridge.mixer.output_device:
self.alert_audio_bridge.mixer.set_sound_devices(None, alert_device, 0)
settings.audio.alert_device = self.alert_audio_bridge.mixer.output_device
settings.save()
if 'audio.muted' in notification.data.modified:
self.voice_audio_bridge.mixer.muted = settings.audio.muted
if 'audio.silent' in notification.data.modified:
if settings.audio.silent:
self.alert_audio_bridge.mixer.output_volume = 0
else:
self.alert_audio_bridge.mixer.output_volume = 100
if 'video.muted' in notification.data.modified:
self.video_device.muted = settings.video.muted
- if {'video.device', 'video.resolution', 'video.framerate', 'video.max_bitrate', 'video.h264.profile', 'video.h264.level'}.intersection(notification.data.modified):
+ if {'video.h264.profile', 'video.h264.level'}.intersection(notification.data.modified):
+ self.engine.set_h264_options(settings.video.h264.profile, settings.video.h264.level)
+ if {'video.device', 'video.resolution', 'video.framerate', 'video.max_bitrate'}.intersection(notification.data.modified):
if {'video.device', 'video.resolution', 'video.framerate'}.intersection(notification.data.modified) or settings.video.device != self.video_device.name:
self.video_device.set_camera(settings.video.device, settings.video.resolution, settings.video.framerate)
settings.video.device = self.video_device.name
settings.save()
- self.engine.set_h264_options(settings.video.h264.profile,
- settings.video.h264.level,
- settings.video.resolution,
- settings.video.framerate,
- settings.video.max_bitrate)
+ self.engine.set_video_options(settings.video.resolution,
+ settings.video.framerate,
+ settings.video.max_bitrate)
if 'user_agent' in notification.data.modified:
self.engine.user_agent = settings.user_agent
if 'sip.udp_port' in notification.data.modified:
self.engine.set_udp_port(settings.sip.udp_port)
if 'sip.tcp_port' in notification.data.modified:
self.engine.set_tcp_port(settings.sip.tcp_port)
if set(('sip.tls_port', 'tls.ca_list', 'default_account')).intersection(notification.data.modified):
self._initialize_tls()
if 'rtp.port_range' in notification.data.modified:
self.engine.rtp_port_range = (settings.rtp.port_range.start, settings.rtp.port_range.end)
if 'rtp.audio_codec_list' in notification.data.modified:
self.engine.codecs = list(settings.rtp.audio_codec_list)
if 'logs.trace_sip' in notification.data.modified:
self.engine.trace_sip = settings.logs.trace_sip
if set(('logs.trace_pjsip', 'logs.pjsip_level')).intersection(notification.data.modified):
self.engine.log_level = settings.logs.pjsip_level if settings.logs.trace_pjsip else 0
elif notification.sender is account_manager.default_account:
if set(('tls.verify_server', 'tls.certificate')).intersection(notification.data.modified):
self._initialize_tls()
@run_in_thread('device-io')
def _NH_DefaultAudioDeviceDidChange(self, notification):
if None in (self.voice_audio_bridge, self.alert_audio_bridge):
return
settings = SIPSimpleSettings()
current_input_device = self.voice_audio_bridge.mixer.input_device
current_output_device = self.voice_audio_bridge.mixer.output_device
current_alert_device = self.alert_audio_bridge.mixer.output_device
ec_tail_length = self.voice_audio_bridge.mixer.ec_tail_length
if notification.data.changed_input and u'system_default' in (current_input_device, settings.audio.input_device):
self.voice_audio_bridge.mixer.set_sound_devices(u'system_default', current_output_device, ec_tail_length)
if notification.data.changed_output and u'system_default' in (current_output_device, settings.audio.output_device):
self.voice_audio_bridge.mixer.set_sound_devices(current_input_device, u'system_default', ec_tail_length)
if notification.data.changed_output and u'system_default' in (current_alert_device, settings.audio.alert_device):
self.alert_audio_bridge.mixer.set_sound_devices(None, u'system_default', 0)
@run_in_thread('device-io')
def _NH_AudioDevicesDidChange(self, notification):
old_devices = set(notification.data.old_devices)
new_devices = set(notification.data.new_devices)
removed_devices = old_devices - new_devices
if not removed_devices:
return
input_device = self.voice_audio_bridge.mixer.input_device
output_device = self.voice_audio_bridge.mixer.output_device
alert_device = self.alert_audio_bridge.mixer.output_device
if self.voice_audio_bridge.mixer.real_input_device in removed_devices:
input_device = u'system_default' if new_devices else None
if self.voice_audio_bridge.mixer.real_output_device in removed_devices:
output_device = u'system_default' if new_devices else None
if self.alert_audio_bridge.mixer.real_output_device in removed_devices:
alert_device = u'system_default' if new_devices else None
self.voice_audio_bridge.mixer.set_sound_devices(input_device, output_device, self.voice_audio_bridge.mixer.ec_tail_length)
self.alert_audio_bridge.mixer.set_sound_devices(None, alert_device, 0)
settings = SIPSimpleSettings()
settings.audio.input_device = self.voice_audio_bridge.mixer.input_device
settings.audio.output_device = self.voice_audio_bridge.mixer.output_device
settings.audio.alert_device = self.alert_audio_bridge.mixer.output_device
settings.save()
@run_in_thread('device-io')
def _NH_VideoDevicesDidChange(self, notification):
old_devices = set(notification.data.old_devices)
new_devices = set(notification.data.new_devices)
removed_devices = old_devices - new_devices
if not removed_devices:
return
device = self.video_device.name
if self.video_device.real_name in removed_devices:
device = u'system_default' if new_devices else None
settings = SIPSimpleSettings()
self.video_device.set_camera(device, settings.video.resolution, settings.video.framerate)
settings.video.device = self.video_device.name
settings.save()
def _NH_DNSNameserversDidChange(self, notification):
if self.running:
self.engine.set_nameservers(notification.data.nameservers)
notification.center.post_notification('NetworkConditionsDidChange', sender=self)
def _NH_SystemIPAddressDidChange(self, notification):
self._network_conditions_changed()
def _NH_SystemDidWakeupFromSleep(self, notification):
self._network_conditions_changed()
diff --git a/sipsimple/configuration/datatypes.py b/sipsimple/configuration/datatypes.py
index e07e0212..e637f215 100644
--- a/sipsimple/configuration/datatypes.py
+++ b/sipsimple/configuration/datatypes.py
@@ -1,654 +1,654 @@
# Copyright (C) 2008-2011 AG Projects. See LICENSE for details.
#
"""Definitions of datatypes for use in configuration settings"""
__all__ = [# Base datatypes
'List',
# Generic datatypes
'ContentType', 'ContentTypeList', 'CountryCode', 'NonNegativeInteger', 'PositiveInteger', 'SIPAddress',
# Custom datatypes
'PJSIPLogLevel',
# Audio datatypes
'AudioCodecList', 'SampleRate',
# Video datatypes
'H264Profile', 'VideoResolution', 'VideoCodecList',
# Address and transport datatypes
'Port', 'PortRange', 'Hostname', 'DomainList', 'EndpointAddress', 'EndpointIPAddress', 'MSRPRelayAddress',
'SIPProxyAddress', 'STUNServerAddress', 'STUNServerAddressList', 'XCAPRoot',
'MSRPConnectionModel', 'MSRPTransport', 'SIPTransport', 'SIPTransportList',
# SRTP encryption
'SRTPKeyNegotiation',
# Path datatypes
'Path']
import locale
import os
import re
import urlparse
from operator import itemgetter
## Base datatypes
class List(object):
type = unicode
def __init__(self, values=()):
self.values = [item if isinstance(item, self.type) else self.type(item) for item in values]
def __getstate__(self):
state = []
for item in self:
if item is None:
pass
elif issubclass(self.type, bool):
item = u'true' if item else u'false'
elif issubclass(self.type, (int, long, basestring)):
item = unicode(item)
elif hasattr(item, '__getstate__'):
item = item.__getstate__()
if type(item) is not unicode:
raise TypeError("Expected unicode type for list member, got %s" % item.__class__.__name__)
else:
item = unicode(item)
state.append(item)
return state
def __setstate__(self, state):
if not isinstance(state, list):
state = [state]
values = []
for item in state:
if item is None:
pass
elif issubclass(self.type, bool):
if item.lower() in ('true', 'yes', 'on', '1'):
item = True
elif item.lower() in ('false', 'no', 'off', '0'):
item = False
else:
raise ValueError("invalid boolean value: %s" % (item,))
elif issubclass(self.type, (int, long, basestring)):
item = self.type(item)
elif hasattr(self.type, '__setstate__'):
object = self.type.__new__(self.type)
object.__setstate__(item)
item = object
else:
item = self.type(item)
values.append(item)
self.values = values
def __add__(self, other):
if isinstance(other, List):
return self.__class__(self.values + other.values)
else:
return self.__class__(self.values + other)
def __radd__(self, other):
if isinstance(other, List):
return self.__class__(other.values + self.values)
else:
return self.__class__(other + self.values)
def __mul__(self, other):
return self.__class__(self.values * other)
def __rmul__(self, other):
return self.__class__(other * self.values)
def __eq__(self, other):
if isinstance(other, List):
return self.values == other.values
else:
return self.values == other
def __ne__(self, other):
return not self.__eq__(other)
__hash__ = None
def __iter__(self):
return iter(self.values)
def __contains__(self, value):
return value in self.values
def __getitem__(self, key):
return self.values[key]
def __len__(self):
return len(self.values)
def __repr__(self):
return '%s(%r)' % (self.__class__.__name__, self.values)
def __str__(self):
return ', '.join(str(item) for item in self)
def __unicode__(self):
return u', '.join(unicode(item) for item in self)
## Generic datatypes
class ContentType(str):
def __new__(cls, value):
value = str(value)
if value == '*':
return value
try:
type, subtype = value.split('/')
except ValueError:
raise ValueError("illegal content-type: %s" % value)
else:
if type == '*':
raise ValueError("illegal content-type: %s" % value)
return value
class ContentTypeList(List):
type = ContentType
class CountryCode(str):
code_pattern = re.compile(r'[1-9][0-9]*')
def __new__(cls, value):
value = str(value)
if cls.code_pattern.match(value) is None:
raise ValueError("illegal country code: %s" % value)
return value
class NonNegativeInteger(int):
def __new__(cls, value):
value = int(value)
if value < 0:
raise ValueError("non-negative int expected, found %d" % value)
return value
class PositiveInteger(int):
def __new__(cls, value):
value = int(value)
if value <= 0:
raise ValueError("positive int expected, found %d" % value)
return value
class SIPAddress(str):
def __new__(cls, address):
address = str(address)
address = address.replace('@', '%40', address.count('@')-1)
try:
username, domain = address.split('@')
Hostname(domain)
except ValueError:
raise ValueError("illegal SIP address: %s, must be in user@domain format" % address)
return str.__new__(cls, address)
username = property(lambda self: self.split('@')[0])
domain = property(lambda self: self.split('@')[1])
## Custom datatypes
class PJSIPLogLevel(int):
def __new__(cls, value):
value = int(value)
if not (0 <= value <= 5):
raise ValueError("expected an integer number between 0 and 5, found %d" % value)
return value
class CodecList(List):
type = str
available_values = None # to be defined in a subclass
def _get_values(self):
return self.__dict__['values']
def _set_values(self, values):
if not set(values).issubset(self.available_values):
raise ValueError("illegal codec values: %s" % ', '.join(values))
self.__dict__['values'] = values
values = property(_get_values, _set_values)
del _get_values, _set_values
## Audio datatypes
class AudioCodecList(CodecList):
available_values = {'opus', 'speex', 'G722', 'GSM', 'iLBC', 'PCMU', 'PCMA'}
class SampleRate(int):
valid_values = (16000, 32000, 44100, 48000)
def __new__(cls, value):
value = int(value)
if value not in cls.valid_values:
raise ValueError("illegal sample rate: %d" % value)
return value
## Video datatypes
class H264Profile(str):
valid_values = ('baseline', 'main', 'high')
def __new__(cls, value):
if value.lower() not in cls.valid_values:
raise ValueError('invalid value, must be one of %r' % cls.valid_values)
return str.__new__(cls, value.lower())
class VideoResolution(tuple):
width = property(itemgetter(0))
height = property(itemgetter(1))
def __new__(cls, value):
if isinstance(value, tuple):
width, height = tuple
elif isinstance(value, basestring):
width, height = value.split('x')
else:
raise ValueError('invalid value: %r' % value)
return tuple.__new__(cls, (int(width), int(height)))
def __repr__(self):
return '%s(%d, %d)' % (self.__class__.__name__, self.width, self.height)
def __str__(self):
return '%dx%d' % (self.width, self.height)
def __unicode__(self):
return u'%dx%d' % (self.width, self.height)
class VideoCodecList(CodecList):
- available_values = {'H264'}
+ available_values = {'H264', 'VP8'}
## Address and transport datatypes
class Port(int):
def __new__(cls, value):
value = int(value)
if not (0 <= value <= 65535):
raise ValueError("illegal port value: %s" % value)
return value
class PortRange(object):
def __init__(self, start, end):
self.start = Port(start)
self.end = Port(end)
if self.start == 0:
raise ValueError("illegal port value: 0")
if self.end == 0:
raise ValueError("illegal port value: 0")
if self.start > self.end:
raise ValueError("illegal port range: start port (%d) cannot be larger than end port (%d)" % (self.start, self.end))
def __getstate__(self):
return unicode(self)
def __setstate__(self, state):
self.__init__(*state.split('-'))
def __eq__(self, other):
if isinstance(other, PortRange):
return self.start == other.start and self.end == other.end
else:
return NotImplemented
def __ne__(self, other):
equal = self.__eq__(other)
return NotImplemented if equal is NotImplemented else not equal
__hash__ = None
def __repr__(self):
return '%s(start=%r, end=%r)' % (self.__class__.__name__, self.start, self.end)
def __str__(self):
return '%d-%d' % (self.start, self.end)
def __unicode__(self):
return u'%d-%d' % (self.start, self.end)
class Hostname(str):
_host_re = re.compile(r"^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})|([a-zA-Z0-9\-_]+(\.[a-zA-Z0-9\-_]+)*)$")
def __new__(cls, value):
value = str(value)
if not cls._host_re.match(value):
raise ValueError("illegal hostname or ip address: %s" % value)
return value
class IPAddress(str):
_ip_re = re.compile(r"^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$")
def __new__(cls, value):
value = str(value)
if not cls._ip_re.match(value):
raise ValueError("illegal IP address: %s" % value)
return value
class DomainList(List):
type = str
_domain_re = re.compile(r"^[a-zA-Z0-9\-_]+(\.[a-zA-Z0-9\-_]+)*$")
def _get_values(self):
return self.__dict__['values']
def _set_values(self, values):
for value in values:
if self._domain_re.match(value) is None:
raise ValueError("illegal domain: %s" % value)
self.__dict__['values'] = values
values = property(_get_values, _set_values)
del _get_values, _set_values
class EndpointAddress(object):
_description_re = re.compile(r"^(?P<host>(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})|([a-zA-Z0-9\-_]+(\.[a-zA-Z0-9\-_]+)*))(:(?P<port>\d+))?$")
default_port = 0
def __init__(self, host, port=None):
self.host = Hostname(host)
self.port = Port(port if port is not None else self.default_port)
if self.port == 0:
raise ValueError("illegal port value: 0")
def __getstate__(self):
return unicode(self)
def __setstate__(self, state):
match = self._description_re.match(state)
if match is None:
raise ValueError("illegal endpoint address: %s" % state)
self.__init__(**match.groupdict())
def __eq__(self, other):
if isinstance(other, EndpointAddress):
return self.host == other.host and self.port == other.port
else:
return NotImplemented
def __ne__(self, other):
equal = self.__eq__(other)
return NotImplemented if equal is NotImplemented else not equal
__hash__ = None
def __repr__(self):
return '%s(%r, %r)' % (self.__class__.__name__, self.host, self.port)
def __str__(self):
return '%s:%d' % (self.host, self.port)
def __unicode__(self):
return u'%s:%d' % (self.host, self.port)
@classmethod
def from_description(cls, description):
if not description:
return None
match = cls._description_re.match(description)
if match is None:
raise ValueError("illegal endpoint address: %s" % description)
return cls(**match.groupdict())
class EndpointIPAddress(EndpointAddress):
_description_re = re.compile(r"^(?P<host>\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})(:(?P<port>\d+))?$")
def __init__(self, host, port=None):
self.host = IPAddress(host)
self.port = Port(port if port is not None else self.default_port)
if self.port == 0:
raise ValueError("illegal port value: 0")
def __setstate__(self, state):
match = self._description_re.match(state)
if match is None:
raise ValueError("illegal value: %s, must be an IP address" % state)
self.__init__(**match.groupdict())
@classmethod
def from_description(cls, description):
if not description:
return None
match = cls._description_re.match(description)
if match is None:
raise ValueError("illegal value: %s, must be an IP address" % description)
return cls(**match.groupdict())
class MSRPRelayAddress(object):
_description_re = re.compile(r"^(?P<host>(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})|([a-zA-Z0-9\-_]+(\.[a-zA-Z0-9\-_]+)*))(:(?P<port>\d+))?(;transport=(?P<transport>.+))?$")
def __init__(self, host, port=2855, transport='tls'):
self.host = Hostname(host)
self.port = Port(port)
self.transport = MSRPTransport(transport)
def __getstate__(self):
return unicode(self)
def __setstate__(self, state):
match = self._description_re.match(state)
if match is None:
raise ValueError("illegal MSRP relay address: %s" % state)
self.__init__(**dict((k, v) for k, v in match.groupdict().iteritems() if v is not None))
def __eq__(self, other):
if isinstance(other, MSRPRelayAddress):
return self.host == other.host and self.port == other.port and self.transport == other.transport
else:
return NotImplemented
def __ne__(self, other):
equal = self.__eq__(other)
return NotImplemented if equal is NotImplemented else not equal
__hash__ = None
def __repr__(self):
return '%s(%r, port=%r, transport=%r)' % (self.__class__.__name__, self.host, self.port, self.transport)
def __str__(self):
return '%s:%d;transport=%s' % (self.host, self.port, self.transport)
def __unicode__(self):
return u'%s:%d;transport=%s' % (self.host, self.port, self.transport)
@classmethod
def from_description(cls, description):
if not description:
return None
match = cls._description_re.match(description)
if match is None:
raise ValueError("illegal MSRP relay address: %s" % description)
return cls(**dict((k, v) for k, v in match.groupdict().iteritems() if v is not None))
class SIPProxyAddress(object):
_description_re = re.compile(r"^(?P<host>(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})|([a-zA-Z0-9\-_]+(\.[a-zA-Z0-9\-_]+)*))(:(?P<port>\d+))?(;transport=(?P<transport>.+))?$")
def __init__(self, host, port=5060, transport='udp'):
self.host = Hostname(host)
self.port = Port(port)
if self.port == 0:
raise ValueError("illegal port value: 0")
self.transport = SIPTransport(transport)
def __getstate__(self):
return unicode(self)
def __setstate__(self, state):
match = self._description_re.match(state)
if match is None:
raise ValueError("illegal SIP proxy address: %s" % state)
self.__init__(**dict((k, v) for k, v in match.groupdict().iteritems() if v is not None))
def __eq__(self, other):
if isinstance(other, SIPProxyAddress):
return self.host == other.host and self.port == other.port and self.transport == other.transport
else:
return NotImplemented
def __ne__(self, other):
equal = self.__eq__(other)
return NotImplemented if equal is NotImplemented else not equal
__hash__ = None
def __repr__(self):
return '%s(%r, port=%r, transport=%r)' % (self.__class__.__name__, self.host, self.port, self.transport)
def __str__(self):
return '%s:%d;transport=%s' % (self.host, self.port, self.transport)
def __unicode__(self):
return u'%s:%d;transport=%s' % (self.host, self.port, self.transport)
@classmethod
def from_description(cls, description):
if not description:
return None
match = cls._description_re.match(description)
if match is None:
raise ValueError("illegal SIP proxy address: %s" % description)
return cls(**dict((k, v) for k, v in match.groupdict().iteritems() if v is not None))
class STUNServerAddress(object):
_description_re = re.compile(r"^(?P<host>(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})|([a-zA-Z0-9\-_]+(\.[a-zA-Z0-9\-_]+)*))(:(?P<port>\d+))?$")
default_port = 3478
def __init__(self, host, port=default_port):
self.host = Hostname(host)
self.port = Port(port)
def __getstate__(self):
return unicode(self)
def __setstate__(self, state):
match = self._description_re.match(state)
if match is None:
raise ValueError("illegal STUN server address: %s" % state)
self.__init__(**dict((k, v) for k, v in match.groupdict().iteritems() if v is not None))
def __eq__(self, other):
if isinstance(other, STUNServerAddress):
return self.host == other.host and self.port == other.port
else:
return NotImplemented
def __ne__(self, other):
equal = self.__eq__(other)
return NotImplemented if equal is NotImplemented else not equal
__hash__ = None
def __repr__(self):
return '%s(%r, port=%r)' % (self.__class__.__name__, self.host, self.port)
def __str__(self):
return '%s:%d' % (self.host, self.port)
def __unicode__(self):
return u'%s:%d' % (self.host, self.port)
@classmethod
def from_description(cls, description):
if not description:
return None
match = cls._description_re.match(description)
if match is None:
raise ValueError("illegal STUN server address: %s" % description)
return cls(**dict((k, v) for k, v in match.groupdict().iteritems() if v is not None))
class STUNServerAddressList(List):
type = STUNServerAddress
class XCAPRoot(str):
def __new__(cls, value):
value = str(value)
uri = urlparse.urlparse(value)
if uri.scheme not in (u'http', u'https'):
raise ValueError("illegal XCAP root scheme (http and https only): %s" % uri.scheme)
if uri.params:
raise ValueError("XCAP root must not contain parameters: %s" % (uri.params,))
if uri.query:
raise ValueError("XCAP root must not contain query component: %s" % (uri.query,))
if uri.fragment:
raise ValueError("XCAP root must not contain fragment component: %s" % (uri.fragment,))
# check port and hostname
Hostname(uri.hostname)
if uri.port is not None:
port = Port(uri.port)
if port == 0:
raise ValueError("illegal port value: 0")
return value
class MSRPConnectionModel(str):
available_values = ('relay', 'acm')
def __new__(cls, value):
value = str(value)
if value not in cls.available_values:
raise ValueError("illegal value for MSRP NAT model: %s" % value)
return value
class MSRPTransport(str):
available_values = ('tls', 'tcp')
def __new__(cls, value):
value = str(value)
if value not in cls.available_values:
raise ValueError("illegal value for MSRP transport: %s" % value)
return value
class SIPTransport(str):
available_values = ('udp', 'tcp', 'tls')
def __new__(cls, value):
value = str(value)
if value not in cls.available_values:
raise ValueError("illegal value for SIP transport: %s" % value)
return value
class SIPTransportList(List):
type = SIPTransport
available_values = SIPTransport.available_values
class SRTPKeyNegotiation(str):
available_values = ('opportunistic', 'sdes_optional', 'sdes_mandatory', 'zrtp')
def __new__(cls, value):
value = str(value)
if value not in cls.available_values:
raise ValueError("illegal value for SRTP key negotiation: %s" % value)
return value
## Path datatypes
class Path(unicode):
def __new__(cls, path):
return unicode.__new__(cls, os.path.normpath(path))
@property
def normalized(self):
if not self.startswith('~'):
return self
encoding = locale.getpreferredencoding() or 'ascii'
return os.path.expanduser(self.encode(encoding)).decode(encoding)
diff --git a/sipsimple/configuration/settings.py b/sipsimple/configuration/settings.py
index b1099fe0..6f699904 100644
--- a/sipsimple/configuration/settings.py
+++ b/sipsimple/configuration/settings.py
@@ -1,110 +1,110 @@
# Copyright (C) 2008-2011 AG Projects. See LICENSE for details.
#
"""
SIP SIMPLE settings.
Definition of general (non-account related) settings.
"""
from sipsimple import __version__
from sipsimple.configuration import CorrelatedSetting, RuntimeSetting, Setting, SettingsGroup, SettingsObject
from sipsimple.configuration.datatypes import NonNegativeInteger, PJSIPLogLevel
from sipsimple.configuration.datatypes import AudioCodecList, SampleRate, VideoCodecList
from sipsimple.configuration.datatypes import Port, PortRange, SIPTransportList
from sipsimple.configuration.datatypes import Path
from sipsimple.configuration.datatypes import H264Profile, VideoResolution
__all__ = ['SIPSimpleSettings']
class EchoCancellerSettings(SettingsGroup):
enabled = Setting(type=bool, default=True)
tail_length = Setting(type=NonNegativeInteger, default=2)
class AudioSettings(SettingsGroup):
alert_device = Setting(type=unicode, default=u'system_default', nillable=True)
input_device = Setting(type=unicode, default=u'system_default', nillable=True)
output_device = Setting(type=unicode, default=u'system_default', nillable=True)
sample_rate = Setting(type=SampleRate, default=44100)
muted = RuntimeSetting(type=bool, default=False)
silent = Setting(type=bool, default=False)
echo_canceller = EchoCancellerSettings
class H264Settings(SettingsGroup):
profile = Setting(type=H264Profile, default='baseline')
level = Setting(type=str, default='3.1')
class VideoSettings(SettingsGroup):
device = Setting(type=unicode, default=u'system_default', nillable=True)
resolution = Setting(type=VideoResolution, default=VideoResolution('1280x720'))
framerate = Setting(type=int, default=25)
max_bitrate = Setting(type=float, default=None, nillable=True)
muted = RuntimeSetting(type=bool, default=False)
h264 = H264Settings
class ChatSettings(SettingsGroup):
pass
class ScreenSharingSettings(SettingsGroup):
pass
class FileTransferSettings(SettingsGroup):
directory = Setting(type=Path, default=Path('~/Downloads'))
class LogsSettings(SettingsGroup):
trace_msrp = Setting(type=bool, default=False)
trace_sip = Setting(type=bool, default=False)
trace_pjsip = Setting(type=bool, default=False)
pjsip_level = Setting(type=PJSIPLogLevel, default=5)
class RTPSettings(SettingsGroup):
port_range = Setting(type=PortRange, default=PortRange(50000, 50500))
timeout = Setting(type=NonNegativeInteger, default=30)
audio_codec_list = Setting(type=AudioCodecList, default=AudioCodecList(('opus', 'G722', 'PCMU', 'PCMA')))
- video_codec_list = Setting(type=VideoCodecList, default=VideoCodecList(('H264',)))
+ video_codec_list = Setting(type=VideoCodecList, default=VideoCodecList(('H264', 'VP8')))
def sip_port_validator(port, sibling_port):
if port == sibling_port != 0:
raise ValueError("the TCP and TLS ports must be different")
class SIPSettings(SettingsGroup):
invite_timeout = Setting(type=NonNegativeInteger, default=90, nillable=True)
udp_port = Setting(type=Port, default=0)
tcp_port = CorrelatedSetting(type=Port, sibling='tls_port', validator=sip_port_validator, default=0)
tls_port = CorrelatedSetting(type=Port, sibling='tcp_port', validator=sip_port_validator, default=0)
transport_list = Setting(type=SIPTransportList, default=SIPTransportList(('tls', 'tcp', 'udp')))
class TLSSettings(SettingsGroup):
ca_list = Setting(type=Path, default=None, nillable=True)
class SIPSimpleSettings(SettingsObject):
__id__ = 'SIPSimpleSettings'
default_account = Setting(type=str, default='bonjour@local', nillable=True)
user_agent = Setting(type=str, default='sipsimple %s' % __version__)
instance_id = Setting(type=str, default='')
audio = AudioSettings
video = VideoSettings
chat = ChatSettings
screen_sharing = ScreenSharingSettings
file_transfer = FileTransferSettings
logs = LogsSettings
rtp = RTPSettings
sip = SIPSettings
tls = TLSSettings
diff --git a/sipsimple/core/_core.lib.pxi b/sipsimple/core/_core.lib.pxi
index 627edd4e..08b8d489 100644
--- a/sipsimple/core/_core.lib.pxi
+++ b/sipsimple/core/_core.lib.pxi
@@ -1,514 +1,546 @@
# Copyright (C) 2008-2011 AG Projects. See LICENSE for details.
#
import sys
# classes
cdef class PJLIB:
def __cinit__(self):
cdef int status
status = pj_init()
if status != 0:
raise PJSIPError("Could not initialize PJLIB", status)
self._init_done = 1
status = pjlib_util_init()
if status != 0:
raise PJSIPError("Could not initialize PJLIB-UTIL", status)
status = pjnath_init()
if status != 0:
raise PJSIPError("Could not initialize PJNATH", status)
def __dealloc__(self):
if self._init_done:
pj_shutdown()
cdef class PJCachingPool:
def __cinit__(self):
pj_caching_pool_init(&self._obj, &pj_pool_factory_default_policy, 0)
self._init_done = 1
def __dealloc__(self):
if self._init_done:
pj_caching_pool_destroy(&self._obj)
cdef class PJSIPEndpoint:
def __cinit__(self, PJCachingPool caching_pool, ip_address, udp_port, tcp_port, tls_port,
tls_verify_server, tls_ca_file, tls_cert_file, tls_privkey_file, int tls_timeout):
cdef pj_dns_resolver *resolver
cdef pjsip_tpmgr *tpmgr
cdef int status
if ip_address is not None and not _is_valid_ip(pj_AF_INET(), ip_address):
raise ValueError("Not a valid IPv4 address: %s" % ip_address)
self._local_ip_used = ip_address
status = pjsip_endpt_create(&caching_pool._obj.factory, "core", &self._obj)
if status != 0:
raise PJSIPError("Could not initialize PJSIP endpoint", status)
self._pool = pjsip_endpt_create_pool(self._obj, "PJSIPEndpoint", 4096, 4096)
if self._pool == NULL:
raise SIPCoreError("Could not allocate memory pool")
status = pjsip_tsx_layer_init_module(self._obj)
if status != 0:
raise PJSIPError("Could not initialize transaction layer module", status)
status = pjsip_ua_init_module(self._obj, NULL) # TODO: handle forking
if status != 0:
raise PJSIPError("Could not initialize common dialog layer module", status)
status = pjsip_evsub_init_module(self._obj)
if status != 0:
raise PJSIPError("Could not initialize event subscription module", status)
status = pjsip_100rel_init_module(self._obj)
if status != 0:
raise PJSIPError("Could not initialize 100rel module", status)
status = pjsip_replaces_init_module(self._obj)
if status != 0:
raise PJSIPError("Could not initialize replaces module", status)
status = pjsip_inv_usage_init(self._obj, &_inv_cb)
if status != 0:
raise PJSIPError("Could not initialize invitation module", status)
status = pjsip_endpt_create_resolver(self._obj, &resolver)
if status != 0:
raise PJSIPError("Could not create fake DNS resolver for endpoint", status)
status = pjsip_endpt_set_resolver(self._obj, resolver)
if status != 0:
raise PJSIPError("Could not set fake DNS resolver on endpoint", status)
tpmgr = pjsip_endpt_get_tpmgr(self._obj)
if tpmgr == NULL:
raise SIPCoreError("Could not get the transport manager")
status = pjsip_tpmgr_set_state_cb(tpmgr, _transport_state_cb)
if status != 0:
raise PJSIPError("Could not set transport state callback", status)
if udp_port is not None:
self._start_udp_transport(udp_port)
if tcp_port is not None:
self._start_tcp_transport(tcp_port)
self._tls_verify_server = int(tls_verify_server)
if tls_ca_file is not None:
self._tls_ca_file = PJSTR(tls_ca_file.encode(sys.getfilesystemencoding()))
if tls_cert_file is not None:
self._tls_cert_file = PJSTR(tls_cert_file.encode(sys.getfilesystemencoding()))
if tls_privkey_file is not None:
self._tls_privkey_file = PJSTR(tls_privkey_file.encode(sys.getfilesystemencoding()))
if tls_timeout < 0:
raise ValueError("Invalid TLS timeout value: %d" % tls_timeout)
self._tls_timeout = tls_timeout
if tls_port is not None:
self._start_tls_transport(tls_port)
cdef int _make_local_addr(self, pj_sockaddr_in *local_addr, object ip_address, int port) except -1:
cdef pj_str_t local_ip_pj
cdef pj_str_t *local_ip_p = NULL
cdef int status
if not (0 <= port <= 65535):
raise SIPCoreError("Invalid port: %d" % port)
if ip_address is not None and ip_address is not "0.0.0.0":
local_ip_p = &local_ip_pj
_str_to_pj_str(ip_address, local_ip_p)
status = pj_sockaddr_in_init(local_addr, local_ip_p, port)
if status != 0:
raise PJSIPError("Could not create local address", status)
return 0
cdef int _start_udp_transport(self, int port) except -1:
cdef pj_sockaddr_in local_addr
self._make_local_addr(&local_addr, self._local_ip_used, port)
status = pjsip_udp_transport_start(self._obj, &local_addr, NULL, 1, &self._udp_transport)
if status != 0:
raise PJSIPError("Could not create UDP transport", status)
return 0
cdef int _stop_udp_transport(self) except -1:
pjsip_transport_shutdown(self._udp_transport)
self._udp_transport = NULL
return 0
cdef int _start_tcp_transport(self, int port) except -1:
cdef pj_sockaddr_in local_addr
self._make_local_addr(&local_addr, self._local_ip_used, port)
status = pjsip_tcp_transport_start2(self._obj, &local_addr, NULL, 1, &self._tcp_transport)
if status != 0:
raise PJSIPError("Could not create TCP transport", status)
return 0
cdef int _stop_tcp_transport(self) except -1:
self._tcp_transport.destroy(self._tcp_transport)
self._tcp_transport = NULL
return 0
cdef int _start_tls_transport(self, port) except -1:
cdef pj_sockaddr_in local_addr
cdef pjsip_tls_setting tls_setting
self._make_local_addr(&local_addr, self._local_ip_used, port)
pjsip_tls_setting_default(&tls_setting)
# The following value needs to be reasonably low, as TLS negotiation hogs the PJSIP polling loop
tls_setting.timeout.sec = self._tls_timeout / 1000
tls_setting.timeout.msec = self._tls_timeout % 1000
if self._tls_ca_file is not None:
tls_setting.ca_list_file = self._tls_ca_file.pj_str
if self._tls_cert_file is not None:
tls_setting.cert_file = self._tls_cert_file.pj_str
if self._tls_privkey_file is not None:
tls_setting.privkey_file = self._tls_privkey_file.pj_str
tls_setting.method = PJSIP_SSLV23_METHOD
tls_setting.verify_server = self._tls_verify_server
status = pjsip_tls_transport_start(self._obj, &tls_setting, &local_addr, NULL, 1, &self._tls_transport)
if status in (PJSIP_TLS_EUNKNOWN, PJSIP_TLS_EINVMETHOD, PJSIP_TLS_ECACERT, PJSIP_TLS_ECERTFILE, PJSIP_TLS_EKEYFILE, PJSIP_TLS_ECIPHER, PJSIP_TLS_ECTX):
raise PJSIPTLSError("Could not create TLS transport", status)
elif status != 0:
raise PJSIPError("Could not create TLS transport", status)
return 0
cdef int _stop_tls_transport(self) except -1:
self._tls_transport.destroy(self._tls_transport)
self._tls_transport = NULL
return 0
cdef int _set_dns_nameservers(self, list servers) except -1:
cdef int num_servers = len(servers)
cdef pj_str_t *pj_servers
cdef int status
cdef pj_dns_resolver *resolver
if num_servers == 0:
return 0
resolver = pjsip_endpt_get_resolver(self._obj)
if resolver == NULL:
raise SIPCoreError("Could not get DNS resolver on endpoint")
pj_servers = <pj_str_t *> malloc(sizeof(pj_str_t)*num_servers)
if pj_servers == NULL:
raise MemoryError()
for i, ns in enumerate(servers):
_str_to_pj_str(ns, &pj_servers[i])
status = pj_dns_resolver_set_ns(resolver, num_servers, pj_servers, NULL)
free(pj_servers)
if status != 0:
raise PJSIPError("Could not set nameservers on DNS resolver", status)
return 0
def __dealloc__(self):
cdef pjsip_tpmgr *tpmgr
tpmgr = pjsip_endpt_get_tpmgr(self._obj)
if tpmgr != NULL:
pjsip_tpmgr_set_state_cb(tpmgr, NULL)
if self._udp_transport != NULL:
self._stop_udp_transport()
if self._tcp_transport != NULL:
self._stop_tcp_transport()
if self._tls_transport != NULL:
self._stop_tls_transport()
if self._pool != NULL:
pjsip_endpt_release_pool(self._obj, self._pool)
if self._obj != NULL:
pjsip_endpt_destroy(self._obj)
cdef class PJMEDIAEndpoint:
def __cinit__(self, PJCachingPool caching_pool):
cdef int status
status = pjmedia_endpt_create(&caching_pool._obj.factory, NULL, 1, &self._obj)
if status != 0:
raise PJSIPError("Could not create PJMEDIA endpoint", status)
self._pool = pjmedia_endpt_create_pool(self._obj, "PJMEDIAEndpoint", 4096, 4096)
if self._pool == NULL:
raise SIPCoreError("Could not allocate memory pool")
self._audio_subsystem_init(caching_pool)
self._video_subsystem_init(caching_pool)
def __dealloc__(self):
self._audio_subsystem_shutdown()
self._video_subsystem_shutdown()
if self._pool != NULL:
pj_pool_release(self._pool)
if self._obj != NULL:
pjmedia_endpt_destroy(self._obj)
cdef void _audio_subsystem_init(self, PJCachingPool caching_pool):
cdef int status
cdef pjmedia_audio_codec_config audio_codec_cfg
pjmedia_audio_codec_config_default(&audio_codec_cfg)
audio_codec_cfg.speex.option = PJMEDIA_SPEEX_NO_NB
audio_codec_cfg.ilbc.mode = 30
status = pjmedia_codec_register_audio_codecs(self._obj, &audio_codec_cfg)
if status != 0:
raise PJSIPError("Could not initialize audio codecs", status)
self._has_audio_codecs = 1
cdef void _audio_subsystem_shutdown(self):
pass
cdef void _video_subsystem_init(self, PJCachingPool caching_pool):
cdef int status
status = pjmedia_video_format_mgr_create(self._pool, 64, 0, NULL)
if status != 0:
raise PJSIPError("Could not initialize video format manager", status)
status = pjmedia_converter_mgr_create(self._pool, NULL)
if status != 0:
raise PJSIPError("Could not initialize converter manager", status)
status = pjmedia_event_mgr_create(self._pool, 0, NULL)
if status != 0:
raise PJSIPError("Could not initialize event manager", status)
status = pjmedia_vid_codec_mgr_create(self._pool, NULL)
if status != 0:
raise PJSIPError("Could not initialize video codec manager", status)
status = pjmedia_codec_ffmpeg_vid_init(NULL, &caching_pool._obj.factory)
if status != 0:
raise PJSIPError("Could not initialize ffmpeg video codecs", status)
self._has_ffmpeg_video = 1
+ status = pjmedia_codec_vpx_init(NULL, &caching_pool._obj.factory)
+ if status != 0:
+ raise PJSIPError("Could not initialize vpx video codecs", status)
+ self._has_vpx = 1
status = pjmedia_vid_dev_subsys_init(&caching_pool._obj.factory)
if status != 0:
raise PJSIPError("Could not initialize video subsystem", status)
self._has_video = 1
cdef void _video_subsystem_shutdown(self):
if self._has_video:
pjmedia_vid_dev_subsys_shutdown()
if self._has_ffmpeg_video:
pjmedia_codec_ffmpeg_vid_deinit()
+ if self._has_vpx:
+ pjmedia_codec_vpx_deinit()
if pjmedia_vid_codec_mgr_instance() != NULL:
pjmedia_vid_codec_mgr_destroy(NULL)
if pjmedia_event_mgr_instance() != NULL:
pjmedia_event_mgr_destroy(NULL)
if pjmedia_converter_mgr_instance() != NULL:
pjmedia_converter_mgr_destroy(NULL)
if pjmedia_video_format_mgr_instance() != NULL:
pjmedia_video_format_mgr_destroy(NULL)
cdef list _get_codecs(self):
cdef unsigned int count = PJMEDIA_CODEC_MGR_MAX_CODECS
cdef pjmedia_codec_info info[PJMEDIA_CODEC_MGR_MAX_CODECS]
cdef unsigned int prio[PJMEDIA_CODEC_MGR_MAX_CODECS]
cdef int i
cdef list retval
cdef int status
status = pjmedia_codec_mgr_enum_codecs(pjmedia_endpt_get_codec_mgr(self._obj), &count, info, prio)
if status != 0:
raise PJSIPError("Could not get available codecs", status)
retval = list()
for i from 0 <= i < count:
retval.append((prio[i], _pj_str_to_str(info[i].encoding_name), info[i].channel_cnt, info[i].clock_rate))
return retval
cdef list _get_all_codecs(self):
cdef list codecs
cdef tuple codec_data
codecs = self._get_codecs()
return list(set([codec_data[1] for codec_data in codecs]))
cdef list _get_current_codecs(self):
cdef list codecs
cdef tuple codec_data
cdef list retval
codecs = [codec_data for codec_data in self._get_codecs() if codec_data[0] > 0]
codecs.sort(reverse=True)
retval = list(set([codec_data[1] for codec_data in codecs]))
return retval
cdef int _set_codecs(self, list req_codecs) except -1:
cdef object new_codecs
cdef object all_codecs
cdef object codec_set
cdef list codecs
cdef tuple codec_data
cdef str codec
cdef int sample_rate
cdef int channel_count
cdef str codec_name
cdef int prio
cdef list codec_prio
cdef pj_str_t codec_pj
new_codecs = set(req_codecs)
if len(new_codecs) != len(req_codecs):
raise ValueError("Requested codec list contains doubles")
all_codecs = set(self._get_all_codecs())
codec_set = new_codecs.difference(all_codecs)
if len(codec_set) > 0:
raise SIPCoreError("Unknown codec(s): %s" % ", ".join(codec_set))
# reverse the codec data tuples so that we can easily sort on sample rate
# to make sure that bigger sample rates get higher priority
codecs = [list(reversed(codec_data)) for codec_data in self._get_codecs()]
codecs.sort(reverse=True)
codec_prio = list()
for codec in req_codecs:
for sample_rate, channel_count, codec_name, prio in codecs:
if codec == codec_name and channel_count == 1:
codec_prio.append("%s/%d/%d" % (codec_name, sample_rate, channel_count))
for prio, codec in enumerate(reversed(codec_prio)):
_str_to_pj_str(codec, &codec_pj)
status = pjmedia_codec_mgr_set_codec_priority(pjmedia_endpt_get_codec_mgr(self._obj), &codec_pj, prio + 1)
if status != 0:
raise PJSIPError("Could not set codec priority", status)
for sample_rate, channel_count, codec_name, prio in codecs:
if codec_name not in req_codecs or channel_count > 1:
codec = "%s/%d/%d" % (codec_name, sample_rate, channel_count)
_str_to_pj_str(codec, &codec_pj)
status = pjmedia_codec_mgr_set_codec_priority(pjmedia_endpt_get_codec_mgr(self._obj), &codec_pj, 0)
if status != 0:
raise PJSIPError("Could not set codec priority", status)
return 0
cdef list _get_video_codecs(self):
cdef unsigned int count = PJMEDIA_VID_CODEC_MGR_MAX_CODECS
cdef pjmedia_vid_codec_info info[PJMEDIA_VID_CODEC_MGR_MAX_CODECS]
cdef unsigned int prio[PJMEDIA_VID_CODEC_MGR_MAX_CODECS]
cdef int i
cdef list retval
cdef int status
status = pjmedia_vid_codec_mgr_enum_codecs(NULL, &count, info, prio)
if status != 0:
raise PJSIPError("Could not get available video codecs", status)
retval = list()
for i from 0 <= i < count:
if info[i].packings & PJMEDIA_VID_PACKING_PACKETS:
retval.append((prio[i], _pj_str_to_str(info[i].encoding_name), info[i].pt))
return retval
cdef list _get_all_video_codecs(self):
cdef list codecs
cdef tuple codec_data
codecs = self._get_video_codecs()
return list(set([codec_data[1] for codec_data in codecs]))
cdef list _get_current_video_codecs(self):
cdef list codecs
cdef tuple codec_data
cdef list retval
codecs = [codec_data for codec_data in self._get_video_codecs() if codec_data[0] > 0]
codecs.sort(reverse=True)
retval = list(set([codec_data[1] for codec_data in codecs]))
return retval
cdef int _set_video_codecs(self, list req_codecs) except -1:
cdef object new_codecs
cdef object codec_set
cdef list codecs
cdef tuple codec_data
cdef str codec
cdef int payload_type
cdef str codec_name
cdef int prio
cdef list codec_prio
cdef pj_str_t codec_pj
new_codecs = set(req_codecs)
if len(new_codecs) != len(req_codecs):
raise ValueError("Requested video codec list contains doubles")
codec_set = new_codecs.difference(set(self._get_all_video_codecs()))
if len(codec_set) > 0:
raise SIPCoreError("Unknown video codec(s): %s" % ", ".join(codec_set))
codecs = self._get_video_codecs()
codec_prio = list()
for codec in req_codecs:
for prio, codec_name, payload_type in codecs:
if codec == codec_name:
codec_prio.append("%s/%d" % (codec_name, payload_type))
for prio, codec in enumerate(reversed(codec_prio)):
_str_to_pj_str(codec, &codec_pj)
status = pjmedia_vid_codec_mgr_set_codec_priority(NULL, &codec_pj, prio + 1)
if status != 0:
raise PJSIPError("Could not set video codec priority", status)
for prio, codec_name, payload_type in codecs:
if codec_name not in req_codecs:
codec = "%s/%d" % (codec_name, payload_type)
_str_to_pj_str(codec, &codec_pj)
status = pjmedia_vid_codec_mgr_set_codec_priority(NULL, &codec_pj, 0)
if status != 0:
raise PJSIPError("Could not set video codec priority", status)
return 0
- cdef void _set_h264_options(self, str profile, int level, tuple max_resolution, int max_framerate, float max_bitrate):
+ cdef void _set_h264_options(self, str profile, int level):
global h264_profiles_map, h264_profile_level_id, h264_packetization_mode
cdef unsigned int count = PJMEDIA_VID_CODEC_MGR_MAX_CODECS
cdef pjmedia_vid_codec_info info[PJMEDIA_VID_CODEC_MGR_MAX_CODECS]
cdef pjmedia_vid_codec_param vparam
cdef unsigned int prio[PJMEDIA_VID_CODEC_MGR_MAX_CODECS]
cdef int i
cdef int status
cdef PJSTR h264_profile_level_id_value
cdef PJSTR h264_packetization_mode_value = PJSTR("1") # TODO; make it configurable?
try:
profile_n = h264_profiles_map[profile]
except KeyError:
raise ValueError("invalid profile specified: %s" % profile)
h264_profile_level_id_value = PJSTR("%xe0%x" % (profile_n, level)) # use common subset (e0)
+
+ status = pjmedia_vid_codec_mgr_enum_codecs(NULL, &count, info, prio)
+ if status != 0:
+ raise PJSIPError("Could not get available video codecs", status)
+ for i from 0 <= i < count:
+ if not (info[i].packings & PJMEDIA_VID_PACKING_PACKETS):
+ continue
+ if _pj_str_to_str(info[i].encoding_name) != 'H264':
+ continue
+ status = pjmedia_vid_codec_mgr_get_default_param(NULL, &info[i], &vparam)
+ if status != 0:
+ continue
+ # 2 format parameters are currently defined for H264: profile-level-id and packetization-mode
+ vparam.dec_fmtp.param[0].name = h264_profile_level_id.pj_str
+ vparam.dec_fmtp.param[0].val = h264_profile_level_id_value.pj_str
+ vparam.dec_fmtp.param[1].name = h264_packetization_mode.pj_str
+ vparam.dec_fmtp.param[1].val = h264_packetization_mode_value.pj_str
+ vparam.dec_fmtp.cnt = 2
+
+ status = pjmedia_vid_codec_mgr_set_default_param(NULL, &info[i], &vparam)
+ if status != 0:
+ raise PJSIPError("Could not set H264 options", status)
+
+
+ cdef void _set_video_options(self, tuple max_resolution, int max_framerate, float max_bitrate):
+ cdef unsigned int count = PJMEDIA_VID_CODEC_MGR_MAX_CODECS
+ cdef pjmedia_vid_codec_info info[PJMEDIA_VID_CODEC_MGR_MAX_CODECS]
+ cdef pjmedia_vid_codec_param vparam
+ cdef unsigned int prio[PJMEDIA_VID_CODEC_MGR_MAX_CODECS]
+ cdef int i
+ cdef int status
+
max_width, max_height = max_resolution
status = pjmedia_vid_codec_mgr_enum_codecs(NULL, &count, info, prio)
if status != 0:
raise PJSIPError("Could not get available video codecs", status)
for i from 0 <= i < count:
- if info[i].packings & PJMEDIA_VID_PACKING_PACKETS:
- if _pj_str_to_str(info[i].encoding_name) == 'H264':
- status = pjmedia_vid_codec_mgr_get_default_param(NULL, &info[i], &vparam)
- if status != 0:
- continue
- # 2 format parameters are currently defined for H264: profile-level-id and packetization-mode
- vparam.dec_fmtp.param[0].name = h264_profile_level_id.pj_str
- vparam.dec_fmtp.param[0].val = h264_profile_level_id_value.pj_str
- vparam.dec_fmtp.param[1].name = h264_packetization_mode.pj_str
- vparam.dec_fmtp.param[1].val = h264_packetization_mode_value.pj_str
- vparam.dec_fmtp.cnt = 2
- # Max resolution
- vparam.enc_fmt.det.vid.size.w = max_width
- vparam.enc_fmt.det.vid.size.h = max_height
- vparam.dec_fmt.det.vid.size.w = max_width
- vparam.dec_fmt.det.vid.size.h = max_height
- # Max framerate
- vparam.enc_fmt.det.vid.fps.num = max_framerate
- vparam.enc_fmt.det.vid.fps.denum = 1
- vparam.dec_fmt.det.vid.fps.num = 10
- vparam.dec_fmt.det.vid.fps.denum = 1
- # Average and max bitrate (set to 0 for 'unlimited')
- vparam.enc_fmt.det.vid.avg_bps = int(max_bitrate * 1e6)
- vparam.enc_fmt.det.vid.max_bps = int(max_bitrate * 1e6)
- vparam.dec_fmt.det.vid.avg_bps = 0
- vparam.dec_fmt.det.vid.max_bps = 0
-
- status = pjmedia_vid_codec_mgr_set_default_param(NULL, &info[i], &vparam)
- if status != 0:
- raise PJSIPError("Could not set H264 options", status)
+ if not (info[i].packings & PJMEDIA_VID_PACKING_PACKETS):
+ continue
+ status = pjmedia_vid_codec_mgr_get_default_param(NULL, &info[i], &vparam)
+ if status != 0:
+ continue
+ # Max resolution
+ vparam.enc_fmt.det.vid.size.w = max_width
+ vparam.enc_fmt.det.vid.size.h = max_height
+ vparam.dec_fmt.det.vid.size.w = max_width
+ vparam.dec_fmt.det.vid.size.h = max_height
+ # Max framerate
+ vparam.enc_fmt.det.vid.fps.num = max_framerate
+ vparam.enc_fmt.det.vid.fps.denum = 1
+ vparam.dec_fmt.det.vid.fps.num = 10
+ vparam.dec_fmt.det.vid.fps.denum = 1
+ # Average and max bitrate (set to 0 for 'unlimited')
+ vparam.enc_fmt.det.vid.avg_bps = int(max_bitrate * 1e6)
+ vparam.enc_fmt.det.vid.max_bps = int(max_bitrate * 1e6)
+ vparam.dec_fmt.det.vid.avg_bps = 0
+ vparam.dec_fmt.det.vid.max_bps = 0
+
+ status = pjmedia_vid_codec_mgr_set_default_param(NULL, &info[i], &vparam)
+ if status != 0:
+ raise PJSIPError("Could not set video options", status)
cdef void _transport_state_cb(pjsip_transport *tp, pjsip_transport_state state, pjsip_transport_state_info_ptr_const info) with gil:
cdef PJSIPUA ua
cdef str local_address
cdef str remote_address
cdef char buf[PJ_INET6_ADDRSTRLEN]
cdef dict event_dict
try:
ua = _get_ua()
except:
return
if pj_sockaddr_has_addr(&tp.local_addr):
pj_sockaddr_print(&tp.local_addr, buf, 512, 0)
local_address = '%s:%d' % (PyString_FromString(buf), pj_sockaddr_get_port(&tp.local_addr))
else:
local_address = None
remote_address = '%s:%d' % (_pj_str_to_str(tp.remote_name.host), tp.remote_name.port)
event_dict = dict(transport=tp.type_name.lower(), local_address=local_address, remote_address=remote_address)
if state == PJSIP_TP_STATE_CONNECTED:
_add_event("SIPEngineTransportDidConnect", event_dict)
else:
event_dict['reason'] = _pj_status_to_str(info.status)
_add_event("SIPEngineTransportDidDisconnect", event_dict)
# globals
cdef PJSTR h264_profile_level_id = PJSTR("profile-level-id")
cdef PJSTR h264_packetization_mode = PJSTR("packetization-mode")
cdef dict h264_profiles_map = dict(baseline=66, main=77, high=100)
diff --git a/sipsimple/core/_core.pxd b/sipsimple/core/_core.pxd
index 92b56046..6685c79f 100644
--- a/sipsimple/core/_core.pxd
+++ b/sipsimple/core/_core.pxd
@@ -1,2632 +1,2636 @@
# Copyright (C) 2008-2011 AG Projects. See LICENSE for details.
#
cdef extern from *:
ctypedef char *char_ptr_const "const char *"
enum:
PJ_SVN_REV "PJ_SVN_REVISION"
# system imports
from libc.stdlib cimport malloc, free
from libc.string cimport memcpy
# Python C imports
from cpython.float cimport PyFloat_AsDouble
from cpython.ref cimport Py_INCREF, Py_DECREF
from cpython.string cimport PyString_FromString, PyString_FromStringAndSize, PyString_AsString, PyString_Size
cdef extern from "Python.h":
object PyUnicode_FromString(const char *u)
# PJSIP imports
cdef extern from "pjlib.h":
# constants
enum:
PJ_ERR_MSG_SIZE
enum:
PJ_ERRNO_START_SYS
PJ_EBUG
PJ_ETOOMANY
enum:
PJ_MAX_OBJ_NAME
# init / shutdown
int pj_init() nogil
void pj_shutdown() nogil
# version
char *pj_get_version() nogil
# string
struct pj_str_t:
char *ptr
int slen
ctypedef pj_str_t *pj_str_ptr_const "const pj_str_t *"
# errors
pj_str_t pj_strerror(int statcode, char *buf, int bufsize) nogil
# logging
enum:
PJ_LOG_MAX_LEVEL
enum pj_log_decoration:
PJ_LOG_HAS_YEAR
PJ_LOG_HAS_MONTH
PJ_LOG_HAS_DAY_OF_MON
PJ_LOG_HAS_TIME
PJ_LOG_HAS_MICRO_SEC
PJ_LOG_HAS_SENDER
PJ_LOG_HAS_INDENT
void pj_log_set_decor(int decor) nogil
int pj_log_get_level() nogil
void pj_log_set_level(int level) nogil
void pj_log_set_log_func(void func(int level, char_ptr_const data, int len)) nogil
# memory management
struct pj_pool_t
struct pj_pool_factory_policy:
pass
pj_pool_factory_policy pj_pool_factory_default_policy
struct pj_pool_factory:
pass
struct pj_caching_pool:
pj_pool_factory factory
void pj_caching_pool_init(pj_caching_pool *ch_pool, pj_pool_factory_policy *policy, int max_capacity) nogil
void pj_caching_pool_destroy(pj_caching_pool *ch_pool) nogil
void *pj_pool_alloc(pj_pool_t *pool, int size) nogil
void pj_pool_reset(pj_pool_t *pool) nogil
pj_pool_t *pj_pool_create_on_buf(char *name, void *buf, int size) nogil
pj_str_t *pj_strdup2_with_null(pj_pool_t *pool, pj_str_t *dst, char *src) nogil
void pj_pool_release(pj_pool_t *pool) nogil
# threads
enum:
PJ_THREAD_DESC_SIZE
struct pj_mutex_t
struct pj_rwmutex_t
struct pj_thread_t
int pj_mutex_create_simple(pj_pool_t *pool, char *name, pj_mutex_t **mutex) nogil
int pj_mutex_create_recursive(pj_pool_t *pool, char *name, pj_mutex_t **mutex) nogil
int pj_mutex_lock(pj_mutex_t *mutex) nogil
int pj_mutex_unlock(pj_mutex_t *mutex) nogil
int pj_mutex_destroy(pj_mutex_t *mutex) nogil
int pj_rwmutex_create(pj_pool_t *pool, char *name, pj_rwmutex_t **mutex) nogil
int pj_rwmutex_lock_read(pj_rwmutex_t *mutex) nogil
int pj_rwmutex_lock_write(pj_rwmutex_t *mutex) nogil
int pj_rwmutex_unlock_read(pj_rwmutex_t *mutex) nogil
int pj_rwmutex_unlock_write(pj_rwmutex_t *mutex) nogil
int pj_rwmutex_destroy(pj_rwmutex_t *mutex) nogil
int pj_thread_is_registered() nogil
int pj_thread_register(char *thread_name, long *thread_desc, pj_thread_t **thread) nogil
# sockets
enum:
PJ_INET6_ADDRSTRLEN
struct pj_ioqueue_t
struct pj_addr_hdr:
unsigned int sa_family
struct pj_sockaddr_in:
pass
struct pj_sockaddr_in6:
pass
ctypedef union pj_sockaddr:
pj_addr_hdr addr
pj_sockaddr_in ipv4
pj_sockaddr_in6 ipv6
ctypedef pj_sockaddr *pj_sockaddr_ptr_const "const pj_sockaddr *"
int pj_AF_INET() nogil
int pj_AF_INET6() nogil
int pj_sockaddr_in_init(pj_sockaddr_in *addr, pj_str_t *cp, int port) nogil
int pj_sockaddr_get_port(pj_sockaddr *addr) nogil
char *pj_sockaddr_print(pj_sockaddr *addr, char *buf, int size, unsigned int flags) nogil
int pj_sockaddr_has_addr(pj_sockaddr *addr) nogil
int pj_sockaddr_init(int af, pj_sockaddr *addr, pj_str_t *cp, unsigned int port) nogil
int pj_inet_pton(int af, pj_str_t *src, void *dst) nogil
# dns
struct pj_dns_resolver
int pj_dns_resolver_set_ns(pj_dns_resolver *resolver, unsigned count, pj_str_t *servers, int *ports) nogil
# time
struct pj_time_val:
long sec
long msec
void pj_gettimeofday(pj_time_val *tv) nogil
void pj_time_val_normalize(pj_time_val *tv) nogil
# timers
struct pj_timer_heap_t
struct pj_timer_entry:
void *user_data
int id
pj_timer_entry *pj_timer_entry_init(pj_timer_entry *entry, int id, void *user_data,
void cb(pj_timer_heap_t *timer_heap, pj_timer_entry *entry) with gil) nogil
# lists
struct pj_list:
void *prev
void *next
void pj_list_init(pj_list *node) nogil
void pj_list_insert_after(pj_list *pos, pj_list *node) nogil
# random
void pj_srand(unsigned int seed) nogil
# maths
struct pj_math_stat:
int n
int max
int min
int last
int mean
cdef extern from "pjlib-util.h":
# init
int pjlib_util_init() nogil
cdef extern from "pjnath.h":
# init
int pjnath_init() nogil
# STUN
enum:
PJ_STUN_PORT
struct pj_stun_config:
pass
struct pj_stun_sock_cfg:
pj_sockaddr bound_addr
void pj_stun_config_init(pj_stun_config *cfg, pj_pool_factory *factory, unsigned int options,
pj_ioqueue_t *ioqueue, pj_timer_heap_t *timer_heap) nogil
# NAT detection
struct pj_stun_nat_detect_result:
int status
char *status_text
char *nat_type_name
ctypedef pj_stun_nat_detect_result *pj_stun_nat_detect_result_ptr_const "const pj_stun_nat_detect_result *"
int pj_stun_detect_nat_type(pj_sockaddr_in *server, pj_stun_config *stun_cfg, void *user_data,
void pj_stun_nat_detect_cb(void *user_data,
pj_stun_nat_detect_result_ptr_const res) with gil) nogil
# ICE
struct pj_ice_strans
struct pj_ice_sess_cand:
int type
int comp_id
int prio
pj_sockaddr addr
pj_sockaddr rel_addr
struct pj_ice_sess_check:
pj_ice_sess_cand *lcand
pj_ice_sess_cand *rcand
int state
int nominated
ctypedef pj_ice_sess_check *pj_ice_sess_check_ptr_const "const pj_ice_sess_check *"
struct pj_ice_sess_comp:
pj_ice_sess_check *valid_check
struct pj_ice_sess_checklist:
int count
pj_ice_sess_check *checks
struct pj_ice_sess:
int comp_cnt
pj_ice_sess_comp *comp
int lcand_cnt
pj_ice_sess_cand *lcand
int rcand_cnt
pj_ice_sess_cand *rcand
pj_ice_sess_checklist valid_list
struct pj_ice_strans_cfg_stun:
pj_stun_sock_cfg cfg
pj_str_t server
unsigned int port
struct pj_ice_strans_cfg:
int af
pj_stun_config stun_cfg
pj_ice_strans_cfg_stun stun
enum pj_ice_strans_op:
PJ_ICE_STRANS_OP_INIT
PJ_ICE_STRANS_OP_NEGOTIATION
enum pj_ice_strans_state:
PJ_ICE_STRANS_STATE_NULL
PJ_ICE_STRANS_STATE_INIT
PJ_ICE_STRANS_STATE_READY
PJ_ICE_STRANS_STATE_SESS_READY
PJ_ICE_STRANS_STATE_NEGO
PJ_ICE_STRANS_STATE_RUNNING
PJ_ICE_STRANS_STATE_FAILED
enum pj_ice_cand_type:
PJ_ICE_CAND_TYPE_HOST
PJ_ICE_CAND_TYPE_SRFLX
PJ_ICE_CAND_TYPE_PRFLX
PJ_ICE_CAND_TYPE_RELAYED
enum pj_ice_sess_check_state:
PJ_ICE_SESS_CHECK_STATE_FROZEN
PJ_ICE_SESS_CHECK_STATE_WAITING
PJ_ICE_SESS_CHECK_STATE_IN_PROGRESS
PJ_ICE_SESS_CHECK_STATE_SUCCEEDED
PJ_ICE_SESS_CHECK_STATE_FAILED
struct pjmedia_ice_transport_info:
int active
pj_ice_strans_state sess_state
void pj_ice_strans_cfg_default(pj_ice_strans_cfg *cfg) nogil
pj_ice_sess* pj_ice_strans_get_session(pj_ice_strans *ice_st)
pj_time_val pj_ice_strans_get_start_time(pj_ice_strans *ice_st)
pj_ice_strans_state pj_ice_strans_get_state(pj_ice_strans *ice_st)
pj_ice_sess_check_ptr_const pj_ice_strans_get_valid_pair(pj_ice_strans *ice_st, unsigned comp_id)
cdef extern from "pjmedia.h":
enum:
PJMEDIA_ENOSNDREC
PJMEDIA_ENOSNDPLAY
enum:
PJMEDIA_AUD_DEFAULT_CAPTURE_DEV
PJMEDIA_AUD_DEFAULT_PLAYBACK_DEV
PJMEDIA_AUD_DEV_CAP_EC
PJMEDIA_AUD_DEV_CAP_EC_TAIL
enum:
PJMEDIA_VID_DEFAULT_CAPTURE_DEV
PJMEDIA_VID_DEFAULT_RENDER_DEV
PJMEDIA_VID_INVALID_DEV
enum pjmedia_dir:
PJMEDIA_DIR_PLAYBACK
PJMEDIA_DIR_RENDER
PJMEDIA_DIR_CAPTURE
PJMEDIA_DIR_CAPTURE_PLAYBACK
PJMEDIA_DIR_CAPTURE_RENDER
enum pjmedia_type:
PJMEDIA_TYPE_NONE
PJMEDIA_TYPE_NONEYPE_AUDIO
PJMEDIA_TYPE_VIDEO
PJMEDIA_TYPE_APPLICATION
PJMEDIA_TYPE_UNKNOWN
struct pjmedia_rect_size:
unsigned int w
unsigned int h
struct pjmedia_ratio:
int num
int denum
# frame
struct pjmedia_frame:
void *buf
int size
ctypedef pjmedia_frame *pjmedia_frame_ptr_const "const pjmedia_frame *"
# codec manager
struct pjmedia_codec_mgr
enum:
PJMEDIA_CODEC_MGR_MAX_CODECS
struct pjmedia_codec_info:
pj_str_t encoding_name
unsigned int clock_rate
unsigned int channel_cnt
int pjmedia_codec_mgr_enum_codecs(pjmedia_codec_mgr *mgr, unsigned int *count, pjmedia_codec_info *info, unsigned int *prio) nogil
int pjmedia_codec_mgr_set_codec_priority(pjmedia_codec_mgr *mgr, pj_str_t *codec_id, unsigned int prio) nogil
# transport manager
struct pjsip_tpmgr
struct pjsip_transport_state_info:
int status
enum pjsip_transport_state:
PJSIP_TP_STATE_CONNECTED
PJSIP_TP_STATE_DISCONNECTED
ctypedef pjsip_transport_state_info *pjsip_transport_state_info_ptr_const "const pjsip_transport_state_info *"
ctypedef void (*pjsip_tp_state_callback)(pjsip_transport *tp, pjsip_transport_state state, pjsip_transport_state_info_ptr_const info) with gil
int pjsip_tpmgr_set_state_cb(pjsip_tpmgr *mgr, pjsip_tp_state_callback cb)
# formats
enum pjmedia_format_detail_type:
PJMEDIA_FORMAT_DETAIL_NONE
PJMEDIA_FORMAT_DETAIL_AUDIO
PJMEDIA_FORMAT_DETAIL_VIDEO
PJMEDIA_FORMAT_DETAIL_MAX
struct pjmedia_audio_format_detail:
unsigned int clock_rate
unsigned int channel_count
unsigned int frame_time_usec
unsigned int baseits_per_sample
unsigned int avg_bps
unsigned int max_bps
struct pjmedia_video_format_detail:
pjmedia_rect_size size
pjmedia_ratio fps
unsigned int avg_bps
unsigned int max_bps
cdef union pjmedia_format_union:
pjmedia_audio_format_detail aud
pjmedia_video_format_detail vid
char user[1]
struct pjmedia_format:
unsigned int id
pjmedia_type type
pjmedia_format_detail_type detail_type
pjmedia_format_union det
ctypedef pjmedia_format *pjmedia_format_ptr_const "const pjmedia_format *"
enum:
PJMEDIA_CODEC_MAX_FMTP_CNT
struct _param:
pj_str_t name
pj_str_t val
struct pjmedia_codec_fmtp:
int cnt
_param param[PJMEDIA_CODEC_MAX_FMTP_CNT]
# video codec parameters
enum pjmedia_vid_packing:
PJMEDIA_VID_PACKING_PACKETS
struct pjmedia_vid_codec_param:
pjmedia_dir dir
pjmedia_vid_packing packing
pjmedia_format enc_fmt
pjmedia_codec_fmtp enc_fmtp
pjmedia_format dec_fmt
pjmedia_codec_fmtp dec_fmtp
ctypedef pjmedia_vid_codec_param *pjmedia_vid_codec_param_ptr_const "const pjmedia_vid_codec_param *"
# video codec manager
enum:
PJMEDIA_VID_CODEC_MGR_MAX_CODECS
struct pjmedia_vid_codec_info:
pj_str_t encoding_name
unsigned int pt
unsigned int clock_rate
unsigned int packings
ctypedef pjmedia_vid_codec_info *pjmedia_vid_codec_info_ptr_const "const pjmedia_vid_codec_info *"
struct pjmedia_vid_codec_mgr
int pjmedia_vid_codec_mgr_create(pj_pool_t *pool, pjmedia_vid_codec_mgr **mgr) nogil
void pjmedia_vid_codec_mgr_destroy(pjmedia_vid_codec_mgr *mgr) nogil
pjmedia_vid_codec_mgr* pjmedia_vid_codec_mgr_instance() nogil
int pjmedia_vid_codec_mgr_enum_codecs(pjmedia_vid_codec_mgr *mgr, unsigned int *count, pjmedia_vid_codec_info *info, unsigned int *prio) nogil
int pjmedia_vid_codec_mgr_set_codec_priority(pjmedia_vid_codec_mgr *mgr, pj_str_t *codec_id, unsigned int prio) nogil
int pjmedia_vid_codec_mgr_get_default_param(pjmedia_vid_codec_mgr *mgr, pjmedia_vid_codec_info_ptr_const info, pjmedia_vid_codec_param *param) nogil
int pjmedia_vid_codec_mgr_set_default_param(pjmedia_vid_codec_mgr *mgr, pjmedia_vid_codec_info_ptr_const info, pjmedia_vid_codec_param_ptr_const param) nogil
# video format manager
struct pjmedia_video_format_mgr
int pjmedia_video_format_mgr_create(pj_pool_t *pool, unsigned int max_fmt, unsigned int options, pjmedia_video_format_mgr **p_mgr) nogil
void pjmedia_video_format_mgr_destroy(pjmedia_video_format_mgr *mgr) nogil
pjmedia_video_format_mgr* pjmedia_video_format_mgr_instance() nogil
# converter manager
struct pjmedia_converter_mgr
int pjmedia_converter_mgr_create(pj_pool_t *pool, pjmedia_converter_mgr **mgr) nogil
void pjmedia_converter_mgr_destroy(pjmedia_converter_mgr *mgr) nogil
pjmedia_converter_mgr* pjmedia_converter_mgr_instance() nogil
# event manager
struct pjmedia_event_mgr
enum pjmedia_event_type:
PJMEDIA_EVENT_FMT_CHANGED
PJMEDIA_EVENT_KEYFRAME_FOUND
PJMEDIA_EVENT_KEYFRAME_MISSING
PJMEDIA_EVENT_KEYFRAME_REQUESTED
struct pjmedia_event_fmt_changed_data:
pjmedia_dir dir
pjmedia_format new_fmt
cdef union pjmedia_event_data_union:
pjmedia_event_fmt_changed_data fmt_changed
void* ptr
struct pjmedia_event:
pjmedia_event_type type
pjmedia_event_data_union data
int pjmedia_event_mgr_create(pj_pool_t *pool, unsigned int options, pjmedia_event_mgr **mgr) nogil
void pjmedia_event_mgr_destroy(pjmedia_event_mgr *mgr) nogil
pjmedia_event_mgr* pjmedia_event_mgr_instance() nogil
ctypedef int pjmedia_event_cb(pjmedia_event *event, void *user_data)
int pjmedia_event_subscribe(pjmedia_event_mgr *mgr, pjmedia_event_cb *cb, void *user_data, void *epub) nogil
int pjmedia_event_unsubscribe(pjmedia_event_mgr *mgr, pjmedia_event_cb *cb, void *user_data, void *epub) nogil
# endpoint
struct pjmedia_endpt
int pjmedia_endpt_create(pj_pool_factory *pf, pj_ioqueue_t *ioqueue, int worker_cnt, pjmedia_endpt **p_endpt) nogil
pj_pool_t *pjmedia_endpt_create_pool(pjmedia_endpt *endpt, char *pool_name, int initial, int increment) nogil
int pjmedia_endpt_destroy(pjmedia_endpt *endpt) nogil
pj_ioqueue_t *pjmedia_endpt_get_ioqueue(pjmedia_endpt *endpt) nogil
pjmedia_codec_mgr *pjmedia_endpt_get_codec_mgr(pjmedia_endpt *endpt) nogil
pjsip_tpmgr* pjsip_endpt_get_tpmgr(pjsip_endpoint *endpt)
# sound devices
struct pjmedia_aud_dev_info:
char *name
int input_count
int output_count
struct pjmedia_aud_param:
pjmedia_dir dir
int play_id
int rec_id
int clock_rate
int channel_count
int samples_per_frame
int bits_per_sample
int flags
int ec_enabled
int ec_tail_ms
struct pjmedia_aud_stream
int pjmedia_aud_dev_count() nogil
int pjmedia_aud_dev_get_info(int index, pjmedia_aud_dev_info *info) nogil
int pjmedia_aud_stream_get_param(pjmedia_aud_stream *strm, pjmedia_aud_param *param) nogil
enum pjmedia_aud_dev_event:
PJMEDIA_AUD_DEV_DEFAULT_INPUT_CHANGED
PJMEDIA_AUD_DEV_DEFAULT_OUTPUT_CHANGED
PJMEDIA_AUD_DEV_LIST_WILL_REFRESH
PJMEDIA_AUD_DEV_LIST_DID_REFRESH
ctypedef void (*pjmedia_aud_dev_observer_callback)(pjmedia_aud_dev_event event)
int pjmedia_aud_dev_set_observer_cb(pjmedia_aud_dev_observer_callback cb) nogil
int pjmedia_aud_dev_default_param(int index, pjmedia_aud_param *param) nogil
int pjmedia_aud_dev_refresh() nogil
# sound port
struct pjmedia_port_info:
pjmedia_format fmt
struct pjmedia_port:
pjmedia_port_info info
struct pjmedia_snd_port
struct pjmedia_snd_port_param:
pjmedia_aud_param base
ctypedef pjmedia_snd_port_param *pjmedia_snd_port_param_ptr_const "const pjmedia_snd_port_param *"
int pjmedia_snd_port_create2(pj_pool_t *pool, pjmedia_snd_port_param_ptr_const prm, pjmedia_snd_port **p_port) nogil
void pjmedia_snd_port_param_default(pjmedia_snd_port_param *prm)
int pjmedia_snd_port_connect(pjmedia_snd_port *snd_port, pjmedia_port *port) nogil
int pjmedia_snd_port_disconnect(pjmedia_snd_port *snd_port) nogil
int pjmedia_snd_port_set_ec(pjmedia_snd_port *snd_port, pj_pool_t *pool, unsigned int tail_ms, int options) nogil
int pjmedia_snd_port_reset_ec_state(pjmedia_snd_port *snd_port) nogil
int pjmedia_snd_port_destroy(pjmedia_snd_port *snd_port) nogil
pjmedia_aud_stream *pjmedia_snd_port_get_snd_stream(pjmedia_snd_port *snd_port) nogil
int pjmedia_null_port_create(pj_pool_t *pool, unsigned int sampling_rate, unsigned int channel_count,
unsigned int samples_per_frame, unsigned int bits_per_sample, pjmedia_port **p_port) nogil
int pjmedia_mixer_port_create(pj_pool_t *pool, unsigned int sampling_rate, unsigned int channel_count,
unsigned int samples_per_frame, unsigned int bits_per_sample, pjmedia_port **p_port) nogil
# master port
struct pjmedia_master_port
int pjmedia_master_port_create(pj_pool_t *pool, pjmedia_port *u_port, pjmedia_port *d_port,
unsigned int options, pjmedia_master_port **p_m) nogil
int pjmedia_master_port_start(pjmedia_master_port *m) nogil
int pjmedia_master_port_destroy(pjmedia_master_port *m, int destroy_ports) nogil
# conference bridge
enum pjmedia_conf_option:
PJMEDIA_CONF_NO_DEVICE
struct pjmedia_conf
int pjmedia_conf_create(pj_pool_t *pool, int max_slots, int sampling_rate, int channel_count,
int samples_per_frame, int bits_per_sample, int options, pjmedia_conf **p_conf) nogil
int pjmedia_conf_destroy(pjmedia_conf *conf) nogil
pjmedia_port *pjmedia_conf_get_master_port(pjmedia_conf *conf) nogil
int pjmedia_conf_add_port(pjmedia_conf *conf, pj_pool_t *pool, pjmedia_port *strm_port,
pj_str_t *name, unsigned int *p_slot) nogil
int pjmedia_conf_remove_port(pjmedia_conf *conf, unsigned int slot) nogil
int pjmedia_conf_connect_port(pjmedia_conf *conf, unsigned int src_slot, unsigned int sink_slot, int level) nogil
int pjmedia_conf_disconnect_port(pjmedia_conf *conf, unsigned int src_slot, unsigned int sink_slot) nogil
int pjmedia_conf_adjust_rx_level(pjmedia_conf *conf, unsigned slot, int adj_level) nogil
int pjmedia_conf_adjust_tx_level(pjmedia_conf *conf, unsigned slot, int adj_level) nogil
# video devices
enum pjmedia_vid_dev_cap:
PJMEDIA_VID_DEV_CAP_OUTPUT_HIDE
PJMEDIA_VID_DEV_CAP_OUTPUT_RESIZE
PJMEDIA_VID_DEV_CAP_OUTPUT_WINDOW_FLAGS
enum pjmedia_vid_dev_wnd_flag:
PJMEDIA_VID_DEV_WND_BORDER
PJMEDIA_VID_DEV_WND_RESIZABLE
struct pjmedia_vid_dev_info:
int id
char *name
char *driver
int dir
cdef struct pjmedia_hwnd_win:
void *hwnd
cdef struct pjmedia_hwnd_x11:
void *window
void *display
cdef struct pjmedia_hwnd_cocoa:
void *window
cdef struct pjmedia_hwnd_ios:
void *window
cdef union pjmedia_hwnd_union:
pjmedia_hwnd_win win
pjmedia_hwnd_x11 x11
pjmedia_hwnd_cocoa cocoa
pjmedia_hwnd_ios ios
void *window
struct pjmedia_vid_dev_hwnd:
pjmedia_hwnd_union info
struct pjmedia_vid_dev_param:
pjmedia_dir dir
int cap_id
int rend_id
unsigned int flags
pjmedia_format fmt
pjmedia_vid_dev_hwnd window
pjmedia_rect_size disp_size
int window_hide
unsigned int window_flags
struct pjmedia_vid_dev_stream
int pjmedia_vid_dev_count() nogil
int pjmedia_vid_dev_get_info(int index, pjmedia_vid_dev_info *info) nogil
int pjmedia_vid_dev_subsys_init(pj_pool_factory *pf) nogil
int pjmedia_vid_dev_subsys_shutdown() nogil
int pjmedia_vid_dev_default_param(pj_pool_t *pool, int id, pjmedia_vid_dev_param *param) nogil
int pjmedia_vid_dev_stream_get_cap(pjmedia_vid_dev_stream *strm, pjmedia_vid_dev_cap cap, void *value) nogil
int pjmedia_vid_dev_stream_set_cap(pjmedia_vid_dev_stream *strm, pjmedia_vid_dev_cap cap, void *value) nogil
int pjmedia_vid_dev_stream_get_param(pjmedia_vid_dev_stream *strm, pjmedia_vid_dev_param *param) nogil
int pjmedia_vid_dev_refresh() nogil
int pjmedia_vid_dev_lookup(char_ptr_const drv_name, char_ptr_const dev_name, int *id)
# video stream
struct pjmedia_vid_stream_info:
pjmedia_vid_codec_param *codec_param
pjmedia_vid_codec_info codec_info
int use_ka
struct pjmedia_vid_stream
ctypedef pjmedia_vid_stream *pjmedia_vid_stream_ptr_const "const pjmedia_vid_stream *"
int pjmedia_vid_stream_get_stat(pjmedia_vid_stream_ptr_const stream, pjmedia_rtcp_stat *stat) nogil
int pjmedia_vid_stream_get_info(pjmedia_vid_stream_ptr_const stream, pjmedia_vid_stream_info *info) nogil
int pjmedia_vid_stream_info_from_sdp(pjmedia_vid_stream_info *si, pj_pool_t *pool, pjmedia_endpt *endpt,
pjmedia_sdp_session *local, pjmedia_sdp_session *remote, unsigned int stream_idx) nogil
int pjmedia_vid_stream_create(pjmedia_endpt *endpt, pj_pool_t *pool, pjmedia_vid_stream_info *info,
pjmedia_transport *tp, void *user_data, pjmedia_vid_stream **p_stream) nogil
int pjmedia_vid_stream_start(pjmedia_vid_stream *stream) nogil
int pjmedia_vid_stream_destroy(pjmedia_vid_stream *stream) nogil
int pjmedia_vid_stream_get_port(pjmedia_vid_stream *stream, pjmedia_dir dir, pjmedia_port **p_port) nogil
int pjmedia_vid_stream_pause(pjmedia_vid_stream *stream, pjmedia_dir dir) nogil
int pjmedia_vid_stream_resume(pjmedia_vid_stream *stream, pjmedia_dir dir) nogil
int pjmedia_vid_stream_send_keyframe(pjmedia_vid_stream *stream) nogil
int pjmedia_vid_stream_send_rtcp_sdes(pjmedia_vid_stream *stream) nogil
int pjmedia_vid_stream_send_rtcp_bye(pjmedia_vid_stream *stream) nogil
int pjmedia_vid_stream_send_rtcp_pli(pjmedia_vid_stream *stream) nogil
# video port
struct pjmedia_vid_port
struct pjmedia_vid_port_param:
pjmedia_vid_dev_param vidparam
int active
void pjmedia_vid_port_param_default(pjmedia_vid_port_param *prm) nogil
ctypedef pjmedia_vid_port_param *pjmedia_vid_port_param_ptr_const "const pjmedia_vid_port_param *"
int pjmedia_vid_port_create(pj_pool_t *pool, pjmedia_vid_port_param_ptr_const prm, pjmedia_vid_port **p_vp) nogil
int pjmedia_vid_port_start(pjmedia_vid_port *vid_port) nogil
int pjmedia_vid_port_is_running(pjmedia_vid_port *vid_port) nogil
int pjmedia_vid_port_stop(pjmedia_vid_port *vid_port) nogil
int pjmedia_vid_port_connect(pjmedia_vid_port *vid_port, pjmedia_port *port, int destroy) nogil
pjmedia_port *pjmedia_vid_port_get_passive_port(pjmedia_vid_port *vid_port) nogil
int pjmedia_vid_port_disconnect(pjmedia_vid_port *vid_port) nogil
void pjmedia_vid_port_destroy(pjmedia_vid_port *vid_port) nogil
pjmedia_vid_dev_stream *pjmedia_vid_port_get_stream(pjmedia_vid_port *vid_port) nogil
# video tee
int pjmedia_vid_tee_create(pj_pool_t *pool, pjmedia_format_ptr_const fmt, unsigned int max_dst_cnt, pjmedia_port **p_vid_tee) nogil
int pjmedia_vid_tee_add_dst_port2(pjmedia_port *vid_tee, unsigned int option, pjmedia_port *port) nogil
int pjmedia_vid_tee_remove_dst_port(pjmedia_port *vid_tee, pjmedia_port *port) nogil
# sdp
enum:
PJMEDIA_MAX_SDP_FMT
enum:
PJMEDIA_MAX_SDP_ATTR
enum:
PJMEDIA_MAX_SDP_MEDIA
enum:
PJMEDIA_MAX_SDP_BANDW
struct pjmedia_sdp_attr:
pj_str_t name
pj_str_t value
struct pjmedia_sdp_bandw:
pj_str_t modifier
unsigned int value
struct pjmedia_sdp_conn:
pj_str_t net_type
pj_str_t addr_type
pj_str_t addr
struct pjmedia_sdp_media_desc:
pj_str_t media
unsigned int port
unsigned int port_count
pj_str_t transport
unsigned int fmt_count
pj_str_t fmt[PJMEDIA_MAX_SDP_FMT]
struct pjmedia_sdp_media:
pjmedia_sdp_media_desc desc
pjmedia_sdp_conn *conn
unsigned int attr_count
pjmedia_sdp_attr *attr[PJMEDIA_MAX_SDP_ATTR]
unsigned int bandw_count
pjmedia_sdp_bandw *bandw[PJMEDIA_MAX_SDP_BANDW]
struct pjmedia_sdp_session_origin:
pj_str_t user
unsigned int id
unsigned int version
pj_str_t net_type
pj_str_t addr_type
pj_str_t addr
struct pjmedia_sdp_session_time:
unsigned int start
unsigned int stop
struct pjmedia_sdp_session:
pjmedia_sdp_session_origin origin
pj_str_t name
pjmedia_sdp_conn *conn
pjmedia_sdp_session_time time
unsigned int attr_count
pjmedia_sdp_attr *attr[PJMEDIA_MAX_SDP_ATTR]
unsigned int bandw_count
pjmedia_sdp_bandw *bandw[PJMEDIA_MAX_SDP_BANDW]
unsigned int media_count
pjmedia_sdp_media *media[PJMEDIA_MAX_SDP_MEDIA]
ctypedef pjmedia_sdp_session *pjmedia_sdp_session_ptr_const "const pjmedia_sdp_session *"
pjmedia_sdp_media *pjmedia_sdp_media_clone(pj_pool_t *pool, pjmedia_sdp_media *rhs) nogil
pjmedia_sdp_session *pjmedia_sdp_session_clone(pj_pool_t *pool, pjmedia_sdp_session_ptr_const sdp) nogil
int pjmedia_sdp_print(pjmedia_sdp_session_ptr_const sdp, char *buf, int length)
int pjmedia_sdp_parse(pj_pool_t *pool, char *buf, int length, pjmedia_sdp_session **p_sdp) nogil
# sdp negotiation
enum pjmedia_sdp_neg_state:
PJMEDIA_SDP_NEG_STATE_NULL
PJMEDIA_SDP_NEG_STATE_LOCAL_OFFER
PJMEDIA_SDP_NEG_STATE_REMOTE_OFFER
PJMEDIA_SDP_NEG_STATE_WAIT_NEGO
PJMEDIA_SDP_NEG_STATE_DONE
struct pjmedia_sdp_neg
int pjmedia_sdp_neg_create_w_local_offer(pj_pool_t *pool, pjmedia_sdp_session_ptr_const local, pjmedia_sdp_neg **neg) nogil
int pjmedia_sdp_neg_create_w_remote_offer(pj_pool_t *pool, pjmedia_sdp_session_ptr_const initial, pjmedia_sdp_session_ptr_const remote, pjmedia_sdp_neg **neg) nogil
int pjmedia_sdp_neg_set_local_answer(pj_pool_t *pool, pjmedia_sdp_neg *neg, pjmedia_sdp_session_ptr_const local) nogil
int pjmedia_sdp_neg_set_remote_answer(pj_pool_t *pool, pjmedia_sdp_neg *neg, pjmedia_sdp_session_ptr_const remote) nogil
int pjmedia_sdp_neg_set_remote_offer(pj_pool_t *pool, pjmedia_sdp_neg *neg, pjmedia_sdp_session_ptr_const remote) nogil
int pjmedia_sdp_neg_get_neg_remote(pjmedia_sdp_neg *neg, pjmedia_sdp_session_ptr_const *remote) nogil
int pjmedia_sdp_neg_get_neg_local(pjmedia_sdp_neg *neg, pjmedia_sdp_session_ptr_const *local) nogil
int pjmedia_sdp_neg_get_active_remote(pjmedia_sdp_neg *neg, pjmedia_sdp_session_ptr_const *remote) nogil
int pjmedia_sdp_neg_get_active_local(pjmedia_sdp_neg *neg, pjmedia_sdp_session_ptr_const *local) nogil
int pjmedia_sdp_neg_modify_local_offer (pj_pool_t *pool, pjmedia_sdp_neg *neg, pjmedia_sdp_session_ptr_const local) nogil
int pjmedia_sdp_neg_cancel_offer(pjmedia_sdp_neg *neg) nogil
int pjmedia_sdp_neg_negotiate(pj_pool_t *poll, pjmedia_sdp_neg *neg, int allow_asym) nogil
pjmedia_sdp_neg_state pjmedia_sdp_neg_get_state(pjmedia_sdp_neg *neg) nogil
char *pjmedia_sdp_neg_state_str(pjmedia_sdp_neg_state state) nogil
# transport
enum pjmedia_transport_type:
PJMEDIA_TRANSPORT_TYPE_ICE
PJMEDIA_TRANSPORT_TYPE_SRTP
PJMEDIA_TRANSPORT_TYPE_ZRTP
struct pjmedia_sock_info:
pj_sockaddr rtp_addr_name
ctypedef pjmedia_sock_info *pjmedia_sock_info_ptr_const "const pjmedia_sock_info *"
struct pjmedia_transport:
char *name
pjmedia_transport_type type
void *user_data
struct pjmedia_transport_specific_info:
pjmedia_transport_type type
char *buffer
struct pjmedia_transport_info:
pjmedia_sock_info sock_info
pj_sockaddr src_rtp_name
int specific_info_cnt
pjmedia_transport_specific_info *spc_info
void pjmedia_transport_info_init(pjmedia_transport_info *info) nogil
int pjmedia_transport_udp_create3(pjmedia_endpt *endpt, int af, char *name, pj_str_t *addr, int port,
unsigned int options, pjmedia_transport **p_tp) nogil
int pjmedia_transport_get_info(pjmedia_transport *tp, pjmedia_transport_info *info) nogil
void *pjmedia_transport_info_get_spc_info(pjmedia_transport_info *info, pjmedia_transport_type type)
int pjmedia_transport_close(pjmedia_transport *tp) nogil
int pjmedia_transport_media_create(pjmedia_transport *tp, pj_pool_t *sdp_pool, unsigned int options,
pjmedia_sdp_session *rem_sdp, unsigned int media_index) nogil
int pjmedia_transport_encode_sdp(pjmedia_transport *tp, pj_pool_t *sdp_pool, pjmedia_sdp_session *sdp,
pjmedia_sdp_session *rem_sdp, unsigned int media_index) nogil
int pjmedia_transport_media_start(pjmedia_transport *tp, pj_pool_t *tmp_pool, pjmedia_sdp_session *sdp_local,
pjmedia_sdp_session *sdp_remote, unsigned int media_index) nogil
int pjmedia_transport_media_stop(pjmedia_transport *tp) nogil
int pjmedia_endpt_create_sdp(pjmedia_endpt *endpt, pj_pool_t *pool, unsigned int stream_cnt,
pjmedia_sock_info *sock_info, pjmedia_sdp_session **p_sdp) nogil
int pjmedia_endpt_create_base_sdp(pjmedia_endpt *endpt, pj_pool_t *pool, pj_str_ptr_const sess_name,
pj_sockaddr_ptr_const origin, pjmedia_sdp_session **p_sdp) nogil
int pjmedia_endpt_create_audio_sdp(pjmedia_endpt *endpt, pj_pool_t *pool, pjmedia_sock_info_ptr_const si,
unsigned int options, pjmedia_sdp_media **p_media) nogil
int pjmedia_endpt_create_video_sdp(pjmedia_endpt *endpt, pj_pool_t *pool, pjmedia_sock_info_ptr_const si,
unsigned int options, pjmedia_sdp_media **p_media) nogil
# SRTP
struct pjmedia_srtp_crypto:
pj_str_t key
pj_str_t name
unsigned int flags
struct pjmedia_srtp_info:
int active
pjmedia_srtp_crypto tx_policy
enum pjmedia_srtp_use:
PJMEDIA_SRTP_MANDATORY
struct pjmedia_srtp_setting:
pjmedia_srtp_use use
void pjmedia_srtp_setting_default(pjmedia_srtp_setting *opt) nogil
int pjmedia_transport_srtp_create(pjmedia_endpt *endpt, pjmedia_transport *tp,
pjmedia_srtp_setting *opt, pjmedia_transport **p_tp) nogil
# ZRTP
struct pjmedia_zrtp_info:
int active
char cipher[128]
struct pjmedia_zrtp_cb:
void secure_on(pjmedia_transport *tp, char* cipher) with gil
void secure_off(pjmedia_transport *tp) with gil
void show_sas(pjmedia_transport *tp, char* sas, int verified) with gil
void confirm_go_clear(pjmedia_transport *tp) with gil
void show_message(pjmedia_transport *tp, int severity, int subCode) with gil
void negotiation_failed(pjmedia_transport *tp, int severity, int subCode) with gil
void not_supported_by_other(pjmedia_transport *tp) with gil
void ask_enrollment(pjmedia_transport *tp, int info) with gil
void inform_enrollment(pjmedia_transport *tp, int info) with gil
void sign_sas(pjmedia_transport *tp, unsigned char* sas) with gil
int check_sas_signature(pjmedia_transport *tp, unsigned char* sas) with gil
int pjmedia_transport_zrtp_create(pjmedia_endpt *endpt, pj_timer_heap_t *timer_heap, pjmedia_transport *tp,
pjmedia_transport **p_tp, int close_slave) nogil
int pjmedia_transport_zrtp_initialize(pjmedia_transport *tp, char_ptr_const zidFilename,
int autoEnable, pjmedia_zrtp_cb *zrtp_cb) nogil
void pjmedia_transport_zrtp_setSASVerified(pjmedia_transport *tp, int verified) nogil
char* pjmedia_transport_zrtp_getPeerName(pjmedia_transport *tp) nogil
void pjmedia_transport_zrtp_putPeerName(pjmedia_transport *tp, const char *name) nogil
int pjmedia_transport_zrtp_getPeerZid(pjmedia_transport *tp, unsigned char* data) nogil
void pjmedia_transport_zrtp_setEnableZrtp(pjmedia_transport *tp, int onOff) nogil
char* pjmedia_transport_zrtp_getMultiStreamParameters(pjmedia_transport *tp, int *length) nogil
void pjmedia_transport_zrtp_setMultiStreamParameters(pjmedia_transport *tp, const char *parameters, int length, pjmedia_transport *master_tp) nogil
# ICE
struct pjmedia_ice_cb:
void on_ice_complete(pjmedia_transport *tp, pj_ice_strans_op op, int status) with gil
void on_ice_state(pjmedia_transport *tp, pj_ice_strans_state prev, pj_ice_strans_state curr) with gil
void on_ice_stop(pjmedia_transport *tp, char *reason, int err) with gil
int pjmedia_ice_create2(pjmedia_endpt *endpt, char *name, unsigned int comp_cnt, pj_ice_strans_cfg *cfg,
pjmedia_ice_cb *cb, unsigned int options, pjmedia_transport **p_tp) nogil
pj_ice_strans *pjmedia_ice_get_strans(pjmedia_transport *tp) with gil
# stream
enum pjmedia_dir:
PJMEDIA_DIR_ENCODING
PJMEDIA_DIR_DECODING
struct pjmedia_codec_param_setting:
unsigned int vad
struct pjmedia_codec_param:
pjmedia_codec_param_setting setting
struct pjmedia_stream_info:
pjmedia_codec_info fmt
pjmedia_codec_param *param
unsigned int tx_event_pt
int use_ka
struct pjmedia_rtcp_stream_stat_loss_type:
unsigned int burst
unsigned int random
struct pjmedia_rtcp_stream_stat:
unsigned int pkt
unsigned int bytes
unsigned int discard
unsigned int loss
unsigned int reorder
unsigned int dup
pj_math_stat loss_period
pjmedia_rtcp_stream_stat_loss_type loss_type
pj_math_stat jitter
struct pjmedia_rtcp_stat:
pjmedia_rtcp_stream_stat tx
pjmedia_rtcp_stream_stat rx
pj_math_stat rtt
struct pjmedia_stream
int pjmedia_stream_info_from_sdp(pjmedia_stream_info *si, pj_pool_t *pool, pjmedia_endpt *endpt,
pjmedia_sdp_session *local, pjmedia_sdp_session *remote, unsigned int stream_idx) nogil
int pjmedia_stream_create(pjmedia_endpt *endpt, pj_pool_t *pool, pjmedia_stream_info *info,
pjmedia_transport *tp, void *user_data, pjmedia_stream **p_stream) nogil
int pjmedia_stream_destroy(pjmedia_stream *stream) nogil
int pjmedia_stream_get_port(pjmedia_stream *stream, pjmedia_port **p_port) nogil
int pjmedia_stream_start(pjmedia_stream *stream) nogil
int pjmedia_stream_dial_dtmf(pjmedia_stream *stream, pj_str_t *ascii_digit) nogil
int pjmedia_stream_set_dtmf_callback(pjmedia_stream *stream,
void cb(pjmedia_stream *stream, void *user_data, int digit) with gil,
void *user_data) nogil
int pjmedia_stream_pause(pjmedia_stream *stream, pjmedia_dir dir) nogil
int pjmedia_stream_resume(pjmedia_stream *stream, pjmedia_dir dir) nogil
int pjmedia_stream_get_stat(pjmedia_stream *stream, pjmedia_rtcp_stat *stat) nogil
# wav player
enum:
PJMEDIA_FILE_NO_LOOP
int pjmedia_port_destroy(pjmedia_port *port) nogil
int pjmedia_wav_player_port_create(pj_pool_t *pool, char *filename, unsigned int ptime, unsigned int flags,
unsigned int buff_size, pjmedia_port **p_port) nogil
int pjmedia_wav_player_set_eof_cb(pjmedia_port *port, void *user_data,
int cb(pjmedia_port *port, void *usr_data) with gil) nogil
int pjmedia_wav_player_port_set_pos(pjmedia_port *port, unsigned int offset) nogil
# wav recorder
enum pjmedia_file_writer_option:
PJMEDIA_FILE_WRITE_PCM
int pjmedia_wav_writer_port_create(pj_pool_t *pool, char *filename, unsigned int clock_rate,
unsigned int channel_count, unsigned int samples_per_frame,
unsigned int bits_per_sample, unsigned int flags, int buff_size,
pjmedia_port **p_port) nogil
# tone generator
enum:
PJMEDIA_TONEGEN_MAX_DIGITS
struct pjmedia_tone_desc:
short freq1
short freq2
short on_msec
short off_msec
short volume
short flags
struct pjmedia_tone_digit:
char digit
short on_msec
short off_msec
short volume
int pjmedia_tonegen_create(pj_pool_t *pool, unsigned int clock_rate, unsigned int channel_count,
unsigned int samples_per_frame, unsigned int bits_per_sample,
unsigned int options, pjmedia_port **p_port) nogil
int pjmedia_tonegen_play(pjmedia_port *tonegen, unsigned int count, pjmedia_tone_desc *tones, unsigned int options) nogil
int pjmedia_tonegen_play_digits(pjmedia_port *tonegen, unsigned int count,
pjmedia_tone_digit *digits, unsigned int options) nogil
int pjmedia_tonegen_stop(pjmedia_port *tonegen) nogil
int pjmedia_tonegen_is_busy(pjmedia_port *tonegen) nogil
cdef extern from "pjmedia_videodev.h":
ctypedef void (*pjmedia_vid_dev_fb_frame_cb)(pjmedia_frame_ptr_const frame, pjmedia_rect_size size, void *user_data)
int pjmedia_vid_dev_fb_set_callback(pjmedia_vid_dev_stream *strm, pjmedia_vid_dev_fb_frame_cb cb, void *user_data)
cdef extern from "pjmedia-codec.h":
# codecs
enum:
PJMEDIA_SPEEX_NO_NB
struct speex_options:
unsigned int option
int quality
int complexity
struct ilbc_options:
unsigned mode
struct pjmedia_audio_codec_config:
speex_options speex
ilbc_options ilbc
void pjmedia_audio_codec_config_default(pjmedia_audio_codec_config *cfg)
int pjmedia_codec_register_audio_codecs(pjmedia_endpt *endpt, const pjmedia_audio_codec_config *c) nogil
int pjmedia_codec_ffmpeg_vid_init(pjmedia_vid_codec_mgr *mgr, pj_pool_factory *pf) nogil
int pjmedia_codec_ffmpeg_vid_deinit() nogil
+ int pjmedia_codec_vpx_init(pjmedia_vid_codec_mgr *mgr, pj_pool_factory *pf) nogil
+ int pjmedia_codec_vpx_deinit() nogil
cdef extern from "pjsip.h":
# messages
enum pjsip_status_code:
PJSIP_SC_TSX_TIMEOUT
PJSIP_SC_TSX_TRANSPORT_ERROR
PJSIP_TLS_EUNKNOWN
PJSIP_TLS_EINVMETHOD
PJSIP_TLS_ECACERT
PJSIP_TLS_ECERTFILE
PJSIP_TLS_EKEYFILE
PJSIP_TLS_ECIPHER
PJSIP_TLS_ECTX
enum pjsip_uri_context_e:
PJSIP_URI_IN_CONTACT_HDR
struct pjsip_param:
pj_str_t name
pj_str_t value
struct pjsip_uri
struct pjsip_sip_uri:
pj_str_t user
pj_str_t passwd
pj_str_t host
int port
pj_str_t user_param
pj_str_t method_param
pj_str_t transport_param
int ttl_param
int lr_param
pj_str_t maddr_param
pjsip_param other_param
pjsip_param header_param
struct pjsip_name_addr:
pj_str_t display
pjsip_uri *uri
struct pjsip_media_type:
pj_str_t type
pj_str_t subtype
pjsip_param param
enum pjsip_method_e:
PJSIP_OPTIONS_METHOD
PJSIP_CANCEL_METHOD
PJSIP_OTHER_METHOD
struct pjsip_method:
pjsip_method_e id
pj_str_t name
struct pjsip_host_port:
pj_str_t host
int port
enum pjsip_hdr_e:
PJSIP_H_VIA
PJSIP_H_CALL_ID
PJSIP_H_CONTACT
PJSIP_H_CSEQ
PJSIP_H_EXPIRES
PJSIP_H_FROM
struct pjsip_hdr:
pjsip_hdr_e type
pj_str_t name
ctypedef pjsip_hdr *pjsip_hdr_ptr_const "const pjsip_hdr*"
struct pjsip_generic_array_hdr:
unsigned int count
pj_str_t *values
struct pjsip_generic_string_hdr:
pj_str_t name
pj_str_t hvalue
struct pjsip_cid_hdr:
pj_str_t id
struct pjsip_contact_hdr:
int star
pjsip_uri *uri
int q1000
int expires
pjsip_param other_param
struct pjsip_clen_hdr:
int len
struct pjsip_ctype_hdr:
pjsip_media_type media
struct pjsip_cseq_hdr:
int cseq
pjsip_method method
struct pjsip_generic_int_hdr:
int ivalue
ctypedef pjsip_generic_int_hdr pjsip_expires_hdr
struct pjsip_fromto_hdr:
pjsip_uri *uri
pj_str_t tag
pjsip_param other_param
struct pjsip_routing_hdr:
pjsip_name_addr name_addr
pjsip_param other_param
ctypedef pjsip_routing_hdr pjsip_route_hdr
struct pjsip_retry_after_hdr:
int ivalue
pjsip_param param
pj_str_t comment
struct pjsip_via_hdr:
pj_str_t transport
pjsip_host_port sent_by
int ttl_param
int rport_param
pj_str_t maddr_param
pj_str_t recvd_param
pj_str_t branch_param
pjsip_param other_param
pj_str_t comment
enum:
PJSIP_MAX_ACCEPT_COUNT
struct pjsip_msg_body:
pjsip_media_type content_type
void *data
unsigned int len
struct pjsip_request_line:
pjsip_method method
pjsip_uri *uri
struct pjsip_status_line:
int code
pj_str_t reason
union pjsip_msg_line:
pjsip_request_line req
pjsip_status_line status
enum pjsip_msg_type_e:
PJSIP_REQUEST_MSG
PJSIP_RESPONSE_MSG
struct pjsip_msg:
pjsip_msg_type_e type
pjsip_msg_line line
pjsip_hdr hdr
pjsip_msg_body *body
struct pjsip_buffer:
char *start
char *cur
struct pjsip_tx_data_tp_info:
char *dst_name
int dst_port
pjsip_transport *transport
struct pjsip_tx_data:
pjsip_msg *msg
pj_pool_t *pool
pjsip_buffer buf
pjsip_tx_data_tp_info tp_info
struct pjsip_rx_data_tp_info:
pj_pool_t *pool
pjsip_transport *transport
struct pjsip_rx_data_pkt_info:
pj_time_val timestamp
char *packet
int len
char *src_name
int src_port
struct pjsip_rx_data_msg_info:
pjsip_msg *msg
pjsip_fromto_hdr *from_hdr "from"
pjsip_fromto_hdr *to_hdr "to"
pjsip_via_hdr *via
struct pjsip_rx_data:
pjsip_rx_data_pkt_info pkt_info
pjsip_rx_data_tp_info tp_info
pjsip_rx_data_msg_info msg_info
void *pjsip_hdr_clone(pj_pool_t *pool, void *hdr) nogil
void pjsip_msg_add_hdr(pjsip_msg *msg, pjsip_hdr *hdr) nogil
void *pjsip_msg_find_hdr(pjsip_msg *msg, pjsip_hdr_e type, void *start) nogil
void *pjsip_msg_find_hdr_by_name(pjsip_msg *msg, pj_str_t *name, void *start) nogil
void *pjsip_msg_find_remove_hdr_by_name(pjsip_msg *msg, pj_str_t *name, void *start) nogil
pjsip_generic_string_hdr *pjsip_generic_string_hdr_create(pj_pool_t *pool, pj_str_t *hname, pj_str_t *hvalue) nogil
pjsip_contact_hdr *pjsip_contact_hdr_create(pj_pool_t *pool) nogil
pjsip_expires_hdr *pjsip_expires_hdr_create(pj_pool_t *pool, int value) nogil
pjsip_msg_body *pjsip_msg_body_create(pj_pool_t *pool, pj_str_t *type, pj_str_t *subtype, pj_str_t *text) nogil
pjsip_msg_body *pjsip_msg_body_clone(pj_pool_t *pool, const pjsip_msg_body *body) nogil
pjsip_route_hdr *pjsip_route_hdr_init(pj_pool_t *pool, void *mem) nogil
void pjsip_sip_uri_init(pjsip_sip_uri *url, int secure) nogil
int pjsip_tx_data_dec_ref(pjsip_tx_data *tdata) nogil
void pjsip_tx_data_add_ref(pjsip_tx_data *tdata) nogil
pj_str_t *pjsip_uri_get_scheme(pjsip_uri *uri) nogil
void *pjsip_uri_get_uri(pjsip_uri *uri) nogil
int pjsip_uri_print(pjsip_uri_context_e context, void *uri, char *buf, unsigned int size) nogil
int PJSIP_URI_SCHEME_IS_SIP(pjsip_sip_uri *uri) nogil
enum:
PJSIP_PARSE_URI_AS_NAMEADDR
pjsip_uri *pjsip_parse_uri(pj_pool_t *pool, char *buf, unsigned int size, unsigned int options) nogil
void pjsip_method_init_np(pjsip_method *m, pj_str_t *str) nogil
pj_str_t *pjsip_get_status_text(int status_code) nogil
int pjsip_print_body(pjsip_msg_body *msg_body, char **buf, int *len)
# module
enum pjsip_module_priority:
PJSIP_MOD_PRIORITY_APPLICATION
PJSIP_MOD_PRIORITY_DIALOG_USAGE
PJSIP_MOD_PRIORITY_TRANSPORT_LAYER
struct pjsip_event
struct pjsip_transaction
struct pjsip_module:
pj_str_t name
int id
int priority
int on_rx_request(pjsip_rx_data *rdata) with gil
int on_rx_response(pjsip_rx_data *rdata) with gil
int on_tx_request(pjsip_tx_data *tdata) with gil
int on_tx_response(pjsip_tx_data *tdata) with gil
void on_tsx_state(pjsip_transaction *tsx, pjsip_event *event) with gil
# endpoint
struct pjsip_endpoint
int pjsip_endpt_create(pj_pool_factory *pf, char *name, pjsip_endpoint **endpt) nogil
void pjsip_endpt_destroy(pjsip_endpoint *endpt) nogil
pj_pool_t *pjsip_endpt_create_pool(pjsip_endpoint *endpt, char *pool_name, int initial, int increment) nogil
void pjsip_endpt_release_pool(pjsip_endpoint *endpt, pj_pool_t *pool) nogil
int pjsip_endpt_handle_events(pjsip_endpoint *endpt, pj_time_val *max_timeout) nogil
int pjsip_endpt_register_module(pjsip_endpoint *endpt, pjsip_module *module) nogil
int pjsip_endpt_schedule_timer(pjsip_endpoint *endpt, pj_timer_entry *entry, pj_time_val *delay) nogil
void pjsip_endpt_cancel_timer(pjsip_endpoint *endpt, pj_timer_entry *entry) nogil
enum:
PJSIP_H_ACCEPT
PJSIP_H_ALLOW
PJSIP_H_SUPPORTED
pjsip_hdr_ptr_const pjsip_endpt_get_capability(pjsip_endpoint *endpt, int htype, pj_str_t *hname) nogil
int pjsip_endpt_add_capability(pjsip_endpoint *endpt, pjsip_module *mod, int htype,
pj_str_t *hname, unsigned count, pj_str_t *tags) nogil
int pjsip_endpt_create_response(pjsip_endpoint *endpt, pjsip_rx_data *rdata,
int st_code, pj_str_t *st_text, pjsip_tx_data **p_tdata) nogil
int pjsip_endpt_send_response2(pjsip_endpoint *endpt, pjsip_rx_data *rdata,
pjsip_tx_data *tdata, void *token, void *cb) nogil
int pjsip_endpt_respond_stateless(pjsip_endpoint *endpt, pjsip_rx_data *rdata,
int st_code, pj_str_t *st_text, pjsip_hdr *hdr_list, pjsip_msg_body *body) nogil
int pjsip_endpt_create_request(pjsip_endpoint *endpt, pjsip_method *method, pj_str_t *target, pj_str_t *frm,
pj_str_t *to, pj_str_t *contact, pj_str_t *call_id,
int cseq,pj_str_t *text, pjsip_tx_data **p_tdata) nogil
pj_timer_heap_t *pjsip_endpt_get_timer_heap(pjsip_endpoint *endpt) nogil
int pjsip_endpt_create_resolver(pjsip_endpoint *endpt, pj_dns_resolver **p_resv) nogil
int pjsip_endpt_set_resolver(pjsip_endpoint *endpt, pj_dns_resolver *resv) nogil
pj_dns_resolver* pjsip_endpt_get_resolver(pjsip_endpoint *endpt) nogil
# transports
enum pjsip_ssl_method:
PJSIP_TLSV1_METHOD
PJSIP_SSLV23_METHOD
struct pjsip_transport:
char *type_name
pj_sockaddr local_addr
pjsip_host_port local_name
pjsip_host_port remote_name
struct pjsip_tpfactory:
pjsip_host_port addr_name
int destroy(pjsip_tpfactory *factory) nogil
struct pjsip_tls_setting:
pj_str_t ca_list_file
pj_str_t cert_file
pj_str_t privkey_file
int method
int verify_server
pj_time_val timeout
enum pjsip_tpselector_type:
PJSIP_TPSELECTOR_TRANSPORT
union pjsip_tpselector_u:
pjsip_transport *transport
struct pjsip_tpselector:
pjsip_tpselector_type type
pjsip_tpselector_u u
int pjsip_transport_shutdown(pjsip_transport *tp) nogil
int pjsip_udp_transport_start(pjsip_endpoint *endpt, pj_sockaddr_in *local, pjsip_host_port *a_name,
unsigned int async_cnt, pjsip_transport **p_transport) nogil
int pjsip_tcp_transport_start2(pjsip_endpoint *endpt, pj_sockaddr_in *local, pjsip_host_port *a_name,
unsigned int async_cnt, pjsip_tpfactory **p_tpfactory) nogil
int pjsip_tls_transport_start(pjsip_endpoint *endpt, pjsip_tls_setting *opt, pj_sockaddr_in *local,
pjsip_host_port *a_name, unsigned async_cnt, pjsip_tpfactory **p_factory) nogil
void pjsip_tls_setting_default(pjsip_tls_setting *tls_opt) nogil
int pjsip_transport_shutdown(pjsip_transport *tp) nogil
# transaction layer
enum pjsip_role_e:
PJSIP_ROLE_UAC
PJSIP_ROLE_UAS
enum pjsip_tsx_state_e:
PJSIP_TSX_STATE_TRYING
PJSIP_TSX_STATE_PROCEEDING
PJSIP_TSX_STATE_COMPLETED
PJSIP_TSX_STATE_TERMINATED
struct pjsip_transaction:
int status_code
pj_str_t status_text
pjsip_role_e role
pjsip_tx_data *last_tx
pjsip_tsx_state_e state
void **mod_data
pjsip_method method
int pjsip_tsx_layer_init_module(pjsip_endpoint *endpt) nogil
int pjsip_tsx_create_key(pj_pool_t *pool, pj_str_t *key, pjsip_role_e role,
pjsip_method *method, pjsip_rx_data *rdata) nogil
pjsip_transaction *pjsip_tsx_layer_find_tsx(pj_str_t *key, int lock) nogil
int pjsip_tsx_create_uac(pjsip_module *tsx_user, pjsip_tx_data *tdata, pjsip_transaction **p_tsx) nogil
int pjsip_tsx_terminate(pjsip_transaction *tsx, int code) nogil
int pjsip_tsx_send_msg(pjsip_transaction *tsx, pjsip_tx_data *tdata) nogil
pjsip_transaction *pjsip_rdata_get_tsx(pjsip_rx_data *rdata) nogil
int pjsip_tsx_create_uas(pjsip_module *tsx_user, pjsip_rx_data *rdata, pjsip_transaction **p_tsx) nogil
void pjsip_tsx_recv_msg(pjsip_transaction *tsx, pjsip_rx_data *rdata) nogil
# event
enum pjsip_event_id_e:
PJSIP_EVENT_TSX_STATE
PJSIP_EVENT_RX_MSG
PJSIP_EVENT_TX_MSG
PJSIP_EVENT_TRANSPORT_ERROR
PJSIP_EVENT_TIMER
union pjsip_event_body_tsx_state_src:
pjsip_rx_data *rdata
pjsip_tx_data *tdata
struct pjsip_event_body_tsx_state:
pjsip_event_body_tsx_state_src src
pjsip_transaction *tsx
pjsip_event_id_e type
struct pjsip_event_body_rx_msg:
pjsip_rx_data *rdata
union pjsip_event_body:
pjsip_event_body_tsx_state tsx_state
pjsip_event_body_rx_msg rx_msg
struct pjsip_event:
pjsip_event_id_e type
pjsip_event_body body
int pjsip_endpt_send_request(pjsip_endpoint *endpt, pjsip_tx_data *tdata, int timeout,
void *token, void cb(void *token, pjsip_event *e) with gil) nogil
# auth
enum:
PJSIP_EFAILEDCREDENTIAL
enum pjsip_cred_data_type:
PJSIP_CRED_DATA_PLAIN_PASSWD
struct pjsip_cred_info:
pj_str_t realm
pj_str_t scheme
pj_str_t username
pjsip_cred_data_type data_type
pj_str_t data
struct pjsip_auth_clt_sess:
pass
int pjsip_auth_clt_init(pjsip_auth_clt_sess *sess, pjsip_endpoint *endpt, pj_pool_t *pool, unsigned int options) nogil
int pjsip_auth_clt_set_credentials(pjsip_auth_clt_sess *sess, int cred_cnt, pjsip_cred_info *c) nogil
int pjsip_auth_clt_reinit_req(pjsip_auth_clt_sess *sess, pjsip_rx_data *rdata,
pjsip_tx_data *old_request, pjsip_tx_data **new_request) nogil
# dialog layer
ctypedef pjsip_module pjsip_user_agent
struct pjsip_dlg_party:
pjsip_contact_hdr *contact
pjsip_fromto_hdr *info
struct pjsip_dialog:
pjsip_auth_clt_sess auth_sess
pjsip_cid_hdr *call_id
pj_pool_t *pool
pjsip_dlg_party local
pjsip_dlg_party remote
struct pjsip_ua_init_param:
pjsip_dialog *on_dlg_forked(pjsip_dialog *first_set, pjsip_rx_data *res) nogil
int pjsip_ua_init_module(pjsip_endpoint *endpt, pjsip_ua_init_param *prm) nogil
pjsip_user_agent *pjsip_ua_instance() nogil
int pjsip_dlg_create_uac(pjsip_user_agent *ua, pj_str_t *local_uri, pj_str_t *local_contact,
pj_str_t *remote_uri, pj_str_t *target, pjsip_dialog **p_dlg) nogil
int pjsip_dlg_set_route_set(pjsip_dialog *dlg, pjsip_route_hdr *route_set) nogil
int pjsip_dlg_create_uas(pjsip_user_agent *ua, pjsip_rx_data *rdata, pj_str_t *contact, pjsip_dialog **p_dlg) nogil
int pjsip_dlg_terminate(pjsip_dialog *dlg) nogil
int pjsip_dlg_set_transport(pjsip_dialog *dlg, pjsip_tpselector *sel) nogil
int pjsip_dlg_respond(pjsip_dialog *dlg, pjsip_rx_data *rdata, int st_code,
pj_str_t *st_text, pjsip_hdr *hdr_list, pjsip_msg_body *body) nogil
int pjsip_dlg_create_response(pjsip_dialog *dlg, pjsip_rx_data *rdata,
int st_code, pj_str_t *st_text, pjsip_tx_data **tdata) nogil
int pjsip_dlg_modify_response(pjsip_dialog *dlg, pjsip_tx_data *tdata, int st_code, pj_str_t *st_text) nogil
int pjsip_dlg_send_response(pjsip_dialog *dlg, pjsip_transaction *tsx, pjsip_tx_data *tdata) nogil
void pjsip_dlg_inc_lock(pjsip_dialog *dlg) nogil
void pjsip_dlg_dec_lock(pjsip_dialog *dlg) nogil
int pjsip_dlg_inc_session(pjsip_dialog *dlg, pjsip_module *mod) nogil
int pjsip_dlg_dec_session(pjsip_dialog *dlg, pjsip_module *mod) nogil
cdef extern from "pjsip-simple/evsub_msg.h":
struct pjsip_event_hdr:
pj_str_t event_type
pj_str_t id_param
pjsip_param other_param
struct pjsip_sub_state_hdr:
pj_str_t sub_state
pj_str_t reason_param
int expires_param
int retry_after
pjsip_param other_param
pjsip_event_hdr *pjsip_event_hdr_create(pj_pool_t *pool) nogil
cdef extern from "pjsip_simple.h":
# subscribe / notify
enum:
PJSIP_EVSUB_NO_EVENT_ID
enum pjsip_evsub_state:
PJSIP_EVSUB_STATE_PENDING
PJSIP_EVSUB_STATE_ACTIVE
PJSIP_EVSUB_STATE_TERMINATED
struct pjsip_evsub
struct pjsip_evsub_user:
void on_evsub_state(pjsip_evsub *sub, pjsip_event *event) with gil
void on_tsx_state(pjsip_evsub *sub, pjsip_transaction *tsx, pjsip_event *event) with gil
void on_rx_refresh(pjsip_evsub *sub, pjsip_rx_data *rdata, int *p_st_code, pj_str_t **p_st_text,
pjsip_hdr *res_hdr, pjsip_msg_body **p_body) with gil
void on_rx_notify(pjsip_evsub *sub, pjsip_rx_data *rdata, int *p_st_code,
pj_str_t **p_st_text,pjsip_hdr *res_hdr, pjsip_msg_body **p_body) with gil
void on_client_refresh(pjsip_evsub *sub) with gil
void on_server_timeout(pjsip_evsub *sub) with gil
int pjsip_evsub_init_module(pjsip_endpoint *endpt) nogil
int pjsip_evsub_register_pkg(pjsip_module *pkg_mod, pj_str_t *event_name,
unsigned int expires, unsigned int accept_cnt, pj_str_t *accept) nogil
int pjsip_evsub_create_uac(pjsip_dialog *dlg, pjsip_evsub_user *user_cb,
pj_str_t *event, int option, pjsip_evsub **p_evsub) nogil
int pjsip_evsub_create_uas(pjsip_dialog *dlg, pjsip_evsub_user *user_cb,
pjsip_rx_data *rdata, unsigned int option, pjsip_evsub **p_evsub) nogil
int pjsip_evsub_initiate(pjsip_evsub *sub, void *method, unsigned int expires, pjsip_tx_data **p_tdata) nogil
int pjsip_evsub_send_request(pjsip_evsub *sub, pjsip_tx_data *tdata) nogil
int pjsip_evsub_terminate(pjsip_evsub *sub, int notify) nogil
char *pjsip_evsub_get_state_name(pjsip_evsub *sub) nogil
void pjsip_evsub_set_mod_data(pjsip_evsub *sub, int mod_id, void *data) nogil
void *pjsip_evsub_get_mod_data(pjsip_evsub *sub, int mod_id) nogil
void pjsip_evsub_update_expires(pjsip_evsub *sub, int interval) nogil
void pjsip_evsub_set_timer(pjsip_evsub *sub, int timer_id, int seconds) nogil
pjsip_hdr *pjsip_evsub_get_allow_events_hdr(pjsip_module *m) nogil
int pjsip_evsub_notify(pjsip_evsub *sub, pjsip_evsub_state state,
pj_str_t *state_str, pj_str_t *reason, pjsip_tx_data **p_tdata) nogil
cdef extern from "pjsip_ua.h":
# 100rel / PRACK
int pjsip_100rel_init_module(pjsip_endpoint *endpt) nogil
# invite sessions
enum pjsip_inv_option:
PJSIP_INV_SUPPORT_100REL
enum pjsip_inv_state:
PJSIP_INV_STATE_INCOMING
PJSIP_INV_STATE_CONFIRMED
enum pjmedia_mod_offer_flag:
PJMEDIA_SDP_NEG_ALLOW_MEDIA_CHANGE
struct pjsip_inv_session:
pjsip_inv_state state
void **mod_data
pjmedia_sdp_neg *neg
unsigned sdp_neg_flags
int cause
pj_str_t cause_text
int cancelling
pjsip_transaction *invite_tsx
struct pjsip_inv_callback:
void on_state_changed(pjsip_inv_session *inv, pjsip_event *e) with gil
void on_new_session(pjsip_inv_session *inv, pjsip_event *e) with gil
void on_tsx_state_changed(pjsip_inv_session *inv, pjsip_transaction *tsx, pjsip_event *e) with gil
void on_media_update(pjsip_inv_session *inv, int status) with gil
int on_rx_reinvite(pjsip_inv_session *inv, pjmedia_sdp_session_ptr_const offer, pjsip_rx_data *rdata) with gil
int pjsip_inv_usage_init(pjsip_endpoint *endpt, pjsip_inv_callback *cb) nogil
int pjsip_inv_terminate(pjsip_inv_session *inv, int st_code, int notify) nogil
int pjsip_inv_end_session(pjsip_inv_session *inv, int st_code, pj_str_t *st_text, pjsip_tx_data **p_tdata) nogil
int pjsip_inv_cancel_reinvite(pjsip_inv_session *inv, pjsip_tx_data **p_tdata) nogil
int pjsip_inv_send_msg(pjsip_inv_session *inv, pjsip_tx_data *tdata) nogil
int pjsip_inv_verify_request(pjsip_rx_data *rdata, unsigned int *options, pjmedia_sdp_session *sdp,
pjsip_dialog *dlg, pjsip_endpoint *endpt, pjsip_tx_data **tdata) nogil
int pjsip_inv_create_uas(pjsip_dialog *dlg, pjsip_rx_data *rdata, pjmedia_sdp_session *local_sdp,
unsigned int options, pjsip_inv_session **p_inv) nogil
int pjsip_inv_initial_answer(pjsip_inv_session *inv, pjsip_rx_data *rdata, int st_code,
pj_str_t *st_text, pjmedia_sdp_session *sdp, pjsip_tx_data **p_tdata) nogil
int pjsip_inv_answer(pjsip_inv_session *inv, int st_code, pj_str_t *st_text,
pjmedia_sdp_session *local_sdp, pjsip_tx_data **p_tdata) nogil
int pjsip_inv_create_uac(pjsip_dialog *dlg, pjmedia_sdp_session *local_sdp,
unsigned int options, pjsip_inv_session **p_inv) nogil
int pjsip_inv_invite(pjsip_inv_session *inv, pjsip_tx_data **p_tdata) nogil
char *pjsip_inv_state_name(pjsip_inv_state state) nogil
int pjsip_inv_reinvite(pjsip_inv_session *inv, pj_str_t *new_contact,
pjmedia_sdp_session *new_offer, pjsip_tx_data **p_tdata) nogil
int pjsip_create_sdp_body(pj_pool_t *pool, pjmedia_sdp_session *sdp, pjsip_msg_body **p_body) nogil
# Replaces
struct pjsip_replaces_hdr:
pj_str_t call_id
pj_str_t to_tag
pj_str_t from_tag
int early_only
pjsip_param other_param
pjsip_replaces_hdr *pjsip_replaces_hdr_create(pj_pool_t *pool) nogil
int pjsip_replaces_verify_request(pjsip_rx_data *rdata, pjsip_dialog **p_dlg, int lock_dlg, pjsip_tx_data **p_tdata) nogil
int pjsip_replaces_init_module(pjsip_endpoint *endpt) nogil
# declarations
# core.util
cdef class frozenlist(object):
# attributes
cdef int initialized
cdef list list
cdef long hash
cdef class frozendict(object):
# attributes
cdef int initialized
cdef dict dict
cdef long hash
cdef class PJSTR(object):
# attributes
cdef pj_str_t pj_str
cdef object str
# core.lib
cdef class PJLIB(object):
# attributes
cdef int _init_done
cdef class PJCachingPool(object):
# attributes
cdef pj_caching_pool _obj
cdef int _init_done
cdef class PJSIPEndpoint(object):
# attributes
cdef pjsip_endpoint *_obj
cdef pj_pool_t *_pool
cdef pjsip_transport *_udp_transport
cdef pjsip_tpfactory *_tcp_transport
cdef pjsip_tpfactory *_tls_transport
cdef int _tls_verify_server
cdef PJSTR _tls_ca_file
cdef PJSTR _tls_cert_file
cdef PJSTR _tls_privkey_file
cdef object _local_ip_used
cdef int _tls_timeout
# private methods
cdef int _make_local_addr(self, pj_sockaddr_in *local_addr, object ip_address, int port) except -1
cdef int _start_udp_transport(self, int port) except -1
cdef int _stop_udp_transport(self) except -1
cdef int _start_tcp_transport(self, int port) except -1
cdef int _stop_tcp_transport(self) except -1
cdef int _start_tls_transport(self, port) except -1
cdef int _stop_tls_transport(self) except -1
cdef int _set_dns_nameservers(self, list servers) except -1
cdef class PJMEDIAEndpoint(object):
# attributes
cdef pjmedia_endpt *_obj
cdef pj_pool_t *_pool
cdef int _has_audio_codecs
cdef int _has_video
cdef int _has_ffmpeg_video
+ cdef int _has_vpx
# private methods
cdef list _get_codecs(self)
cdef list _get_all_codecs(self)
cdef list _get_current_codecs(self)
cdef int _set_codecs(self, list req_codecs) except -1
cdef list _get_video_codecs(self)
cdef list _get_all_video_codecs(self)
cdef list _get_current_video_codecs(self)
cdef int _set_video_codecs(self, list req_codecs) except -1
cdef void _audio_subsystem_init(self, PJCachingPool caching_pool)
cdef void _audio_subsystem_shutdown(self)
cdef void _video_subsystem_init(self, PJCachingPool caching_pool)
cdef void _video_subsystem_shutdown(self)
- cdef void _set_h264_options(self, str profile, int level, tuple max_resolution, int max_framerate, float max_bitrate)
+ cdef void _set_h264_options(self, str profile, int level)
+ cdef void _set_video_options(self, tuple max_resolution, int max_framerate, float max_bitrate)
# core.helper
cdef class BaseCredentials(object):
# attributes
cdef pjsip_cred_info _credentials
# private methods
cdef pjsip_cred_info* get_cred_info(self)
cdef class Credentials(BaseCredentials):
# attributes
cdef str _username
cdef str _realm
cdef str _password
cdef class FrozenCredentials(BaseCredentials):
# attributes
cdef int initialized
cdef readonly str username
cdef readonly str realm
cdef readonly str password
cdef class BaseSIPURI(object):
pass
cdef class SIPURI(BaseSIPURI):
# attributes
cdef public object user
cdef public object password
cdef public object host
cdef public bint secure
cdef public dict parameters
cdef public dict headers
cdef object _port
cdef class FrozenSIPURI(BaseSIPURI):
# attributes
cdef int initialized
cdef readonly object user
cdef readonly object password
cdef readonly object host
cdef readonly object port
cdef readonly bint secure
cdef readonly frozendict parameters
cdef readonly frozendict headers
cdef SIPURI SIPURI_create(pjsip_sip_uri *base_uri)
cdef FrozenSIPURI FrozenSIPURI_create(pjsip_sip_uri *base_uri)
# core.headers
cdef class BaseHeader(object):
pass
cdef class Header(BaseHeader):
# attributes
cdef str _name
cdef str _body
cdef class FrozenHeader(BaseHeader):
# attributes
cdef readonly str name
cdef readonly str body
cdef class BaseContactHeader(object):
pass
cdef class ContactHeader(BaseContactHeader):
# attributes
cdef SIPURI _uri
cdef unicode _display_name
cdef dict _parameters
cdef class FrozenContactHeader(BaseContactHeader):
# attributes
cdef int initialized
cdef readonly FrozenSIPURI uri
cdef readonly unicode display_name
cdef readonly frozendict parameters
cdef class BaseContentTypeHeader(object):
pass
cdef class ContentTypeHeader(BaseContentTypeHeader):
# attributes
cdef str _content_type
cdef dict _parameters
cdef class FrozenContentTypeHeader(BaseContentTypeHeader):
# attributes
cdef int initialized
cdef readonly str _content_type
cdef readonly frozendict parameters
cdef class BaseIdentityHeader(object):
pass
cdef class IdentityHeader(BaseIdentityHeader):
# attributes
cdef SIPURI _uri
cdef public unicode display_name
cdef dict _parameters
cdef class FrozenIdentityHeader(BaseIdentityHeader):
# attributes
cdef int initialized
cdef readonly FrozenSIPURI uri
cdef readonly unicode display_name
cdef readonly frozendict parameters
cdef class FromHeader(IdentityHeader):
pass
cdef class FrozenFromHeader(FrozenIdentityHeader):
pass
cdef class ToHeader(IdentityHeader):
pass
cdef class FrozenToHeader(FrozenIdentityHeader):
pass
cdef class RouteHeader(IdentityHeader):
pass
cdef class FrozenRouteHeader(FrozenIdentityHeader):
pass
cdef class RecordRouteHeader(IdentityHeader):
pass
cdef class FrozenRecordRouteHeader(FrozenIdentityHeader):
pass
cdef class BaseRetryAfterHeader(object):
pass
cdef class RetryAfterHeader(BaseRetryAfterHeader):
# attributes
cdef public int seconds
cdef public str comment
cdef dict _parameters
cdef class FrozenRetryAfterHeader(BaseRetryAfterHeader):
# attributes
cdef int initialized
cdef readonly int seconds
cdef readonly str comment
cdef readonly frozendict parameters
cdef class BaseViaHeader(object):
pass
cdef class ViaHeader(BaseViaHeader):
# attributes
cdef str _transport
cdef str _host
cdef int _port
cdef dict _parameters
cdef class FrozenViaHeader(BaseViaHeader):
# attributes
cdef int initialized
cdef readonly str transport
cdef readonly str host
cdef readonly int port
cdef readonly frozendict parameters
cdef class BaseWarningHeader(object):
pass
cdef class WarningHeader(BaseWarningHeader):
# attributes
cdef int _code
cdef str _agent
cdef str _text
cdef class FrozenWarningHeader(BaseWarningHeader):
# attributes
cdef int initialized
cdef readonly int code
cdef readonly str agent
cdef readonly str text
cdef class BaseEventHeader(object):
pass
cdef class EventHeader(BaseEventHeader):
# attributes
cdef public event
cdef dict _parameters
cdef class FrozenEventHeader(BaseEventHeader):
# attributes
cdef int initialized
cdef readonly str event
cdef readonly frozendict parameters
cdef class BaseSubscriptionStateHeader(object):
pass
cdef class SubscriptionStateHeader(BaseSubscriptionStateHeader):
# attributes
cdef public state
cdef dict _parameters
cdef class FrozenSubscriptionStateHeader(BaseSubscriptionStateHeader):
# attributes
cdef int initialized
cdef readonly str state
cdef readonly frozendict parameters
cdef class BaseReasonHeader(object):
pass
cdef class ReasonHeader(BaseReasonHeader):
# attributes
cdef public str protocol
cdef public dict parameters
cdef class FrozenReasonHeader(BaseReasonHeader):
# attributes
cdef int initialized
cdef readonly str protocol
cdef readonly frozendict parameters
cdef class BaseReferToHeader(object):
pass
cdef class ReferToHeader(BaseReferToHeader):
# attributes
cdef public str uri
cdef dict _parameters
cdef class FrozenReferToHeader(BaseReferToHeader):
# attributes
cdef int initialized
cdef readonly str uri
cdef readonly frozendict parameters
cdef class BaseSubjectHeader(object):
pass
cdef class SubjectHeader(BaseSubjectHeader):
# attributes
cdef public unicode subject
cdef class FrozenSubjectHeader(BaseSubjectHeader):
# attributes
cdef int initialized
cdef readonly unicode subject
cdef class BaseReplacesHeader(object):
pass
cdef class ReplacesHeader(BaseReplacesHeader):
# attributes
cdef public str call_id
cdef public str from_tag
cdef public str to_tag
cdef public int early_only
cdef dict _parameters
cdef class FrozenReplacesHeader(BaseReplacesHeader):
# attributes
cdef int initialized
cdef readonly str call_id
cdef readonly str from_tag
cdef readonly str to_tag
cdef readonly int early_only
cdef readonly frozendict parameters
cdef Header Header_create(pjsip_generic_string_hdr *header)
cdef FrozenHeader FrozenHeader_create(pjsip_generic_string_hdr *header)
cdef ContactHeader ContactHeader_create(pjsip_contact_hdr *header)
cdef FrozenContactHeader FrozenContactHeader_create(pjsip_contact_hdr *header)
cdef ContentTypeHeader ContentTypeHeader_create(pjsip_ctype_hdr *header)
cdef FrozenContentTypeHeader FrozenContentTypeHeader_create(pjsip_ctype_hdr *header)
cdef FromHeader FromHeader_create(pjsip_fromto_hdr *header)
cdef FrozenFromHeader FrozenFromHeader_create(pjsip_fromto_hdr *header)
cdef ToHeader ToHeader_create(pjsip_fromto_hdr *header)
cdef FrozenToHeader FrozenToHeader_create(pjsip_fromto_hdr *header)
cdef RouteHeader RouteHeader_create(pjsip_routing_hdr *header)
cdef FrozenRouteHeader FrozenRouteHeader_create(pjsip_routing_hdr *header)
cdef RecordRouteHeader RecordRouteHeader_create(pjsip_routing_hdr *header)
cdef FrozenRecordRouteHeader FrozenRecordRouteHeader_create(pjsip_routing_hdr *header)
cdef RetryAfterHeader RetryAfterHeader_create(pjsip_retry_after_hdr *header)
cdef FrozenRetryAfterHeader FrozenRetryAfterHeader_create(pjsip_retry_after_hdr *header)
cdef ViaHeader ViaHeader_create(pjsip_via_hdr *header)
cdef FrozenViaHeader FrozenViaHeader_create(pjsip_via_hdr *header)
cdef EventHeader EventHeader_create(pjsip_event_hdr *header)
cdef FrozenEventHeader FrozenEventHeader_create(pjsip_event_hdr *header)
cdef SubscriptionStateHeader SubscriptionStateHeader_create(pjsip_sub_state_hdr *header)
cdef FrozenSubscriptionStateHeader FrozenSubscriptionStateHeader_create(pjsip_sub_state_hdr *header)
cdef ReferToHeader ReferToHeader_create(pjsip_generic_string_hdr *header)
cdef FrozenReferToHeader FrozenReferToHeader_create(pjsip_generic_string_hdr *header)
cdef SubjectHeader SubjectHeader_create(pjsip_generic_string_hdr *header)
cdef FrozenSubjectHeader FrozenSubjectHeader_create(pjsip_generic_string_hdr *header)
cdef ReplacesHeader ReplacesHeader_create(pjsip_replaces_hdr *header)
cdef FrozenReplacesHeader FrozenReplacesHeader_create(pjsip_replaces_hdr *header)
# core.util
cdef int _str_to_pj_str(object string, pj_str_t *pj_str) except -1
cdef object _pj_str_to_str(pj_str_t pj_str)
cdef object _pj_status_to_str(int status)
cdef object _pj_status_to_def(int status)
cdef dict _pjsip_param_to_dict(pjsip_param *param_list)
cdef int _dict_to_pjsip_param(object params, pjsip_param *param_list, pj_pool_t *pool)
cdef int _pjsip_msg_to_dict(pjsip_msg *msg, dict info_dict) except -1
cdef int _is_valid_ip(int af, object ip) except -1
cdef int _get_ip_version(object ip) except -1
cdef int _add_headers_to_tdata(pjsip_tx_data *tdata, object headers) except -1
cdef int _remove_headers_from_tdata(pjsip_tx_data *tdata, object headers) except -1
cdef int _BaseSIPURI_to_pjsip_sip_uri(BaseSIPURI uri, pjsip_sip_uri *pj_uri, pj_pool_t *pool) except -1
cdef int _BaseRouteHeader_to_pjsip_route_hdr(BaseIdentityHeader header, pjsip_route_hdr *pj_header, pj_pool_t *pool) except -1
# core.ua
ctypedef int (*timer_callback)(object, object) except -1 with gil
cdef class Timer(object):
# attributes
cdef int _scheduled
cdef double schedule_time
cdef timer_callback callback
cdef object obj
# private methods
cdef int schedule(self, float delay, timer_callback callback, object obj) except -1
cdef int cancel(self) except -1
cdef int call(self) except -1
cdef class PJSIPThread(object):
# attributes
cdef pj_thread_t *_obj
cdef long _thread_desc[PJ_THREAD_DESC_SIZE]
cdef class PJSIPUA(object):
# attributes
cdef object _threads
cdef object _event_handler
cdef list _timers
cdef PJLIB _pjlib
cdef PJCachingPool _caching_pool
cdef PJSIPEndpoint _pjsip_endpoint
cdef PJMEDIAEndpoint _pjmedia_endpoint
cdef pjsip_module _module
cdef PJSTR _module_name
cdef pjsip_module _opus_fix_module
cdef PJSTR _opus_fix_module_name
cdef pjsip_module _trace_module
cdef PJSTR _trace_module_name
cdef pjsip_module _ua_tag_module
cdef PJSTR _ua_tag_module_name
cdef pjsip_module _event_module
cdef PJSTR _event_module_name
cdef int _trace_sip
cdef int _detect_sip_loops
cdef int _enable_colorbar_device
cdef PJSTR _user_agent
cdef object _events
cdef object _sent_messages
cdef object _ip_address
cdef int _rtp_port_start
cdef int _rtp_port_count
cdef int _rtp_port_usable_count
cdef int _rtp_port_index
cdef pj_stun_config _stun_cfg
cdef int _fatal_error
cdef set _incoming_events
cdef set _incoming_requests
cdef pj_rwmutex_t *audio_change_rwlock
cdef pj_mutex_t *video_lock
cdef list old_devices
cdef list old_video_devices
cdef object _zrtp_cache
# private methods
cdef object _get_sound_devices(self, int is_output)
cdef object _get_default_sound_device(self, int is_output)
cdef object _get_video_devices(self)
cdef object _get_default_video_device(self)
cdef int _poll_log(self) except -1
cdef int _handle_exception(self, int is_fatal) except -1
cdef int _check_self(self) except -1
cdef int _check_thread(self) except -1
cdef int _add_timer(self, Timer timer) except -1
cdef int _remove_timer(self, Timer timer) except -1
cdef int _cb_rx_request(self, pjsip_rx_data *rdata) except 0
cdef pj_pool_t* create_memory_pool(self, bytes name, int initial_size, int resize_size)
cdef void release_memory_pool(self, pj_pool_t* pool)
cdef void reset_memory_pool(self, pj_pool_t* pool)
cdef int _PJSIPUA_cb_rx_request(pjsip_rx_data *rdata) with gil
cdef void _cb_detect_nat_type(void *user_data, pj_stun_nat_detect_result_ptr_const res) with gil
cdef int _cb_opus_fix_tx(pjsip_tx_data *tdata) with gil
cdef int _cb_trace_rx(pjsip_rx_data *rdata) with gil
cdef int _cb_trace_tx(pjsip_tx_data *tdata) with gil
cdef int _cb_add_user_agent_hdr(pjsip_tx_data *tdata) with gil
cdef int _cb_add_server_hdr(pjsip_tx_data *tdata) with gil
cdef PJSIPUA _get_ua()
cdef int deallocate_weakref(object weak_ref, object timer) except -1 with gil
# core.sound
cdef class AudioMixer(object):
# attributes
cdef int _input_volume
cdef int _output_volume
cdef bint _muted
cdef pj_mutex_t *_lock
cdef pj_pool_t *_conf_pool
cdef pj_pool_t *_snd_pool
cdef pjmedia_conf *_obj
cdef pjmedia_master_port *_master_port
cdef pjmedia_port *_null_port
cdef pjmedia_snd_port *_snd
cdef list _connected_slots
cdef readonly int ec_tail_length
cdef readonly int sample_rate
cdef readonly int slot_count
cdef readonly int used_slot_count
cdef readonly unicode input_device
cdef readonly unicode output_device
cdef readonly unicode real_input_device
cdef readonly unicode real_output_device
# private methods
cdef void _start_sound_device(self, PJSIPUA ua, unicode input_device, unicode output_device, int ec_tail_length)
cdef void _stop_sound_device(self, PJSIPUA ua)
cdef int _add_port(self, PJSIPUA ua, pj_pool_t *pool, pjmedia_port *port) except -1 with gil
cdef int _remove_port(self, PJSIPUA ua, unsigned int slot) except -1 with gil
cdef int _cb_postpoll_stop_sound(self, timer) except -1
cdef class ToneGenerator(object):
# attributes
cdef int _slot
cdef int _volume
cdef pj_mutex_t *_lock
cdef pj_pool_t *_pool
cdef pjmedia_port *_obj
cdef Timer _timer
cdef readonly AudioMixer mixer
# private methods
cdef PJSIPUA _get_ua(self, int raise_exception)
cdef int _stop(self, PJSIPUA ua) except -1
cdef int _cb_check_done(self, timer) except -1
cdef class RecordingWaveFile(object):
# attributes
cdef int _slot
cdef int _was_started
cdef pj_mutex_t *_lock
cdef pj_pool_t *_pool
cdef pjmedia_port *_port
cdef readonly str filename
cdef readonly AudioMixer mixer
# private methods
cdef PJSIPUA _check_ua(self)
cdef int _stop(self, PJSIPUA ua) except -1
cdef class WaveFile(object):
# attributes
cdef object __weakref__
cdef object weakref
cdef int _slot
cdef int _volume
cdef pj_mutex_t *_lock
cdef pj_pool_t *_pool
cdef pjmedia_port *_port
cdef readonly str filename
cdef readonly AudioMixer mixer
# private methods
cdef PJSIPUA _check_ua(self)
cdef int _stop(self, PJSIPUA ua, int notify) except -1
cdef int _cb_eof(self, timer) except -1
cdef class MixerPort(object):
cdef int _slot
cdef int _was_started
cdef pj_mutex_t *_lock
cdef pj_pool_t *_pool
cdef pjmedia_port *_port
cdef readonly AudioMixer mixer
# private methods
cdef PJSIPUA _check_ua(self)
cdef int _stop(self, PJSIPUA ua) except -1
cdef int _AudioMixer_dealloc_handler(object obj) except -1
cdef int cb_play_wav_eof(pjmedia_port *port, void *user_data) with gil
# core.video
cdef class VideoFrame(object):
cdef readonly str data
cdef readonly int width
cdef readonly int height
cdef class VideoConsumer(object):
cdef pjmedia_port *consumer_port
cdef pjmedia_vid_port *_video_port
cdef pj_pool_t *_pool
cdef pj_mutex_t *_lock
cdef int _running
cdef int _closed
cdef VideoProducer _producer
cdef object __weakref__
cdef object weakref
cdef void _set_producer(self, VideoProducer producer)
cdef class VideoProducer(object):
cdef pjmedia_port *producer_port
cdef pjmedia_vid_port *_video_port
cdef pj_pool_t *_pool
cdef pj_mutex_t *_lock
cdef int _running
cdef int _started
cdef int _closed
cdef object _consumers
cdef void _add_consumer(self, VideoConsumer consumer)
cdef void _remove_consumer(self, VideoConsumer consumer)
cdef class VideoCamera(VideoProducer):
cdef pjmedia_port *_video_tee
cdef readonly unicode name
cdef readonly unicode real_name
cdef void _start(self)
cdef void _stop(self)
cdef class FrameBufferVideoRenderer(VideoConsumer):
cdef pjmedia_vid_dev_stream *_video_stream
cdef object _frame_handler
cdef _initialize(self, VideoProducer producer)
cdef void _destroy_video_port(self)
cdef void _start(self)
cdef void _stop(self)
cdef class LocalVideoStream(VideoConsumer):
cdef void _initialize(self, pjmedia_port *media_port)
cdef class RemoteVideoStream(VideoProducer):
cdef pjmedia_vid_stream *_video_stream
cdef object _event_handler
cdef void _initialize(self, pjmedia_vid_stream *stream)
cdef LocalVideoStream_create(pjmedia_vid_stream *stream)
cdef RemoteVideoStream_create(pjmedia_vid_stream *stream, format_change_handler=*)
cdef int RemoteVideoStream_on_event(pjmedia_event *event, void *user_data) with gil
cdef void _start_video_port(pjmedia_vid_port *port)
cdef void _stop_video_port(pjmedia_vid_port *port)
# core.event
cdef struct _core_event
cdef struct _handler_queue
cdef int _event_queue_append(_core_event *event)
cdef void _cb_log(int level, char_ptr_const data, int len)
cdef int _add_event(object event_name, dict params) except -1
cdef list _get_clear_event_queue()
cdef int _add_handler(int func(object obj) except -1, object obj, _handler_queue *queue) except -1
cdef int _remove_handler(object obj, _handler_queue *queue) except -1
cdef int _process_handler_queue(PJSIPUA ua, _handler_queue *queue) except -1
# core.request
cdef class EndpointAddress(object):
# attributes
cdef readonly bytes ip
cdef readonly int port
cdef class Request(object):
# attributes
cdef readonly object state
cdef PJSTR _method
cdef readonly EndpointAddress peer_address
cdef readonly FrozenCredentials credentials
cdef readonly FrozenFromHeader from_header
cdef readonly FrozenToHeader to_header
cdef readonly FrozenSIPURI request_uri
cdef readonly FrozenContactHeader contact_header
cdef readonly FrozenRouteHeader route_header
cdef PJSTR _call_id
cdef readonly int cseq
cdef readonly frozenlist extra_headers
cdef PJSTR _content_type
cdef PJSTR _content_subtype
cdef PJSTR _body
cdef pjsip_tx_data *_tdata
cdef pjsip_transaction *_tsx
cdef pjsip_auth_clt_sess _auth
cdef pjsip_route_hdr _route_header
cdef int _need_auth
cdef pj_timer_entry _timer
cdef int _timer_active
cdef int _expire_rest
cdef object _expire_time
cdef object _timeout
# private methods
cdef PJSIPUA _get_ua(self)
cdef int _cb_tsx_state(self, PJSIPUA ua, pjsip_rx_data *rdata) except -1
cdef int _cb_timer(self, PJSIPUA ua) except -1
cdef class IncomingRequest(object):
# attributes
cdef readonly str state
cdef pjsip_transaction *_tsx
cdef pjsip_tx_data *_tdata
cdef readonly EndpointAddress peer_address
# methods
cdef int init(self, PJSIPUA ua, pjsip_rx_data *rdata) except -1
cdef void _Request_cb_tsx_state(pjsip_transaction *tsx, pjsip_event *event) with gil
cdef void _Request_cb_timer(pj_timer_heap_t *timer_heap, pj_timer_entry *entry) with gil
# core.referral
cdef class Referral(object):
# attributes
cdef pjsip_evsub *_obj
cdef pjsip_dialog *_dlg
cdef pjsip_route_hdr _route_header
cdef pj_list _route_set
cdef int _create_subscription
cdef readonly object state
cdef pj_timer_entry _timeout_timer
cdef int _timeout_timer_active
cdef pj_timer_entry _refresh_timer
cdef int _refresh_timer_active
cdef readonly EndpointAddress peer_address
cdef readonly FrozenFromHeader from_header
cdef readonly FrozenToHeader to_header
cdef readonly FrozenReferToHeader refer_to_header
cdef readonly FrozenRouteHeader route_header
cdef readonly FrozenCredentials credentials
cdef readonly FrozenContactHeader local_contact_header
cdef readonly FrozenContactHeader remote_contact_header
cdef readonly int refresh
cdef readonly frozenlist extra_headers
cdef pj_time_val _request_timeout
cdef int _want_end
cdef int _term_code
cdef object _term_reason
# private methods
cdef PJSIPUA _get_ua(self)
cdef int _update_contact_header(self, BaseContactHeader contact_header) except -1
cdef int _cancel_timers(self, PJSIPUA ua, int cancel_timeout, int cancel_refresh) except -1
cdef int _send_refer(self, PJSIPUA ua, pj_time_val *timeout, FrozenReferToHeader refer_to_header, frozenlist extra_headers) except -1
cdef int _send_subscribe(self, PJSIPUA ua, int expires, pj_time_val *timeout, frozenlist extra_headers) except -1
cdef int _cb_state(self, PJSIPUA ua, object state, int code, str reason) except -1
cdef int _cb_got_response(self, PJSIPUA ua, pjsip_rx_data *rdata, str method) except -1
cdef int _cb_notify(self, PJSIPUA ua, pjsip_rx_data *rdata) except -1
cdef int _cb_timeout_timer(self, PJSIPUA ua)
cdef int _cb_refresh_timer(self, PJSIPUA ua)
cdef class IncomingReferral(object):
cdef pjsip_evsub *_obj
cdef pjsip_dialog *_dlg
cdef pjsip_tx_data *_initial_response
cdef pjsip_transaction *_initial_tsx
cdef pj_time_val _expires_time
cdef int _create_subscription
cdef readonly str state
cdef readonly EndpointAddress peer_address
cdef readonly FrozenContactHeader local_contact_header
cdef readonly FrozenContactHeader remote_contact_header
cdef PJSTR _content
cdef int init(self, PJSIPUA ua, pjsip_rx_data *rdata) except -1
cdef PJSIPUA _get_ua(self, int raise_exception)
cdef int _set_content(self, int code, str reason) except -1
cdef int _set_state(self, str state) except -1
cdef int _send_initial_response(self, int code) except -1
cdef int _send_notify(self) except -1
cdef int _terminate(self, PJSIPUA ua, int do_cleanup) except -1
cdef int _cb_rx_refresh(self, PJSIPUA ua, pjsip_rx_data *rdata) except -1
cdef int _cb_server_timeout(self, PJSIPUA ua) except -1
cdef int _cb_tsx(self, PJSIPUA ua, pjsip_event *event) except -1
cdef void _Referral_cb_state(pjsip_evsub *sub, pjsip_event *event) with gil
cdef void _Referral_cb_notify(pjsip_evsub *sub, pjsip_rx_data *rdata, int *p_st_code, pj_str_t **p_st_text, pjsip_hdr *res_hdr, pjsip_msg_body **p_body) with gil
cdef void _Referral_cb_refresh(pjsip_evsub *sub) with gil
cdef void _IncomingReferral_cb_rx_refresh(pjsip_evsub *sub, pjsip_rx_data *rdata, int *p_st_code, pj_str_t **p_st_text, pjsip_hdr *res_hdr, pjsip_msg_body **p_body) with gil
cdef void _IncomingReferral_cb_server_timeout(pjsip_evsub *sub) with gil
cdef void _IncomingReferral_cb_tsx(pjsip_evsub *sub, pjsip_transaction *tsx, pjsip_event *event) with gil
# core.subscription
cdef class Subscription(object):
# attributes
cdef pjsip_evsub *_obj
cdef pjsip_dialog *_dlg
cdef pjsip_route_hdr _route_header
cdef pj_list _route_set
cdef pj_timer_entry _timeout_timer
cdef int _timeout_timer_active
cdef pj_timer_entry _refresh_timer
cdef int _refresh_timer_active
cdef readonly object state
cdef readonly EndpointAddress peer_address
cdef readonly FrozenFromHeader from_header
cdef readonly FrozenToHeader to_header
cdef readonly FrozenContactHeader contact_header
cdef readonly object event
cdef readonly FrozenRouteHeader route_header
cdef readonly FrozenCredentials credentials
cdef readonly int refresh
cdef readonly frozenlist extra_headers
cdef readonly object body
cdef readonly object content_type
cdef readonly str call_id
cdef pj_time_val _subscribe_timeout
cdef int _want_end
cdef int _term_code
cdef object _term_reason
cdef int _expires
# private methods
cdef PJSIPUA _get_ua(self)
cdef int _cancel_timers(self, PJSIPUA ua, int cancel_timeout, int cancel_refresh) except -1
cdef int _send_subscribe(self, PJSIPUA ua, int expires, pj_time_val *timeout,
object extra_headers, object content_type, object body) except -1
cdef int _cb_state(self, PJSIPUA ua, object state, int code, object reason, dict headers) except -1
cdef int _cb_got_response(self, PJSIPUA ua, pjsip_rx_data *rdata) except -1
cdef int _cb_notify(self, PJSIPUA ua, pjsip_rx_data *rdata) except -1
cdef int _cb_timeout_timer(self, PJSIPUA ua)
cdef int _cb_refresh_timer(self, PJSIPUA ua)
cdef class IncomingSubscription(object):
# attributes
cdef pjsip_evsub *_obj
cdef pjsip_dialog *_dlg
cdef PJSTR _content_type
cdef PJSTR _content_subtype
cdef PJSTR _content
cdef pjsip_tx_data *_initial_response
cdef pjsip_transaction *_initial_tsx
cdef int _expires
cdef readonly str state
cdef readonly str event
cdef readonly str call_id
cdef readonly EndpointAddress peer_address
# methods
cdef int _set_state(self, str state) except -1
cdef PJSIPUA _get_ua(self, int raise_exception)
cdef int init(self, PJSIPUA ua, pjsip_rx_data *rdata, str event) except -1
cdef int _send_initial_response(self, int code) except -1
cdef int _send_notify(self, str reason=*) except -1
cdef int _terminate(self, PJSIPUA ua, str reason, int do_cleanup) except -1
cdef int _cb_rx_refresh(self, PJSIPUA ua, pjsip_rx_data *rdata) except -1
cdef int _cb_server_timeout(self, PJSIPUA ua) except -1
cdef int _cb_tsx(self, PJSIPUA ua, pjsip_event *event) except -1
cdef void _Subscription_cb_state(pjsip_evsub *sub, pjsip_event *event) with gil
cdef void _Subscription_cb_notify(pjsip_evsub *sub, pjsip_rx_data *rdata, int *p_st_code,
pj_str_t **p_st_text, pjsip_hdr *res_hdr, pjsip_msg_body **p_body) with gil
cdef void _Subscription_cb_refresh(pjsip_evsub *sub) with gil
cdef void _IncomingSubscription_cb_rx_refresh(pjsip_evsub *sub, pjsip_rx_data *rdata,
int *p_st_code, pj_str_t **p_st_text,
pjsip_hdr *res_hdr, pjsip_msg_body **p_body) with gil
cdef void _IncomingSubscription_cb_server_timeout(pjsip_evsub *sub) with gil
cdef void _IncomingSubscription_cb_tsx(pjsip_evsub *sub, pjsip_transaction *tsx, pjsip_event *event) with gil
# core.sdp
cdef class BaseSDPConnection(object):
# attributes
cdef pjmedia_sdp_conn _sdp_connection
# private methods
cdef pjmedia_sdp_conn* get_sdp_connection(self)
cdef class SDPConnection(BaseSDPConnection):
# attributes
cdef str _address
cdef str _net_type
cdef str _address_type
cdef class FrozenSDPConnection(BaseSDPConnection):
# attributes
cdef int initialized
cdef readonly str address
cdef readonly str net_type
cdef readonly str address_type
cdef class SDPAttributeList(list):
pass
cdef class FrozenSDPAttributeList(frozenlist):
pass
cdef class SDPBandwidthInfoList(list):
pass
cdef class FrozenSDPBandwidthInfoList(frozenlist):
pass
cdef class BaseSDPSession(object):
# attributes
cdef pjmedia_sdp_session _sdp_session
# private methods
cdef pjmedia_sdp_session* get_sdp_session(self)
cdef class SDPSession(BaseSDPSession):
# attributes
cdef str _address
cdef str _user
cdef str _net_type
cdef str _address_type
cdef str _name
cdef str _info
cdef SDPConnection _connection
cdef list _attributes
cdef list _bandwidth_info
cdef list _media
# private methods
cdef int _update(self) except -1
cdef class FrozenSDPSession(BaseSDPSession):
# attributes
cdef int initialized
cdef readonly str address
cdef readonly unsigned int id
cdef readonly unsigned int version
cdef readonly str user
cdef readonly str net_type
cdef readonly str address_type
cdef readonly str name
cdef readonly str info
cdef readonly FrozenSDPConnection connection
cdef readonly int start_time
cdef readonly int stop_time
cdef readonly FrozenSDPAttributeList attributes
cdef readonly FrozenSDPBandwidthInfoList bandwidth_info
cdef readonly frozenlist media
cdef class BaseSDPMediaStream(object):
# attributes
cdef pjmedia_sdp_media _sdp_media
# private methods
cdef pjmedia_sdp_media* get_sdp_media(self)
cdef class SDPMediaStream(BaseSDPMediaStream):
# attributes
cdef str _media
cdef str _transport
cdef list _formats
cdef list _codec_list
cdef str _info
cdef SDPConnection _connection
cdef SDPAttributeList _attributes
cdef SDPBandwidthInfoList _bandwidth_info
# private methods
cdef int _update(self, SDPMediaStream media) except -1
cdef class FrozenSDPMediaStream(BaseSDPMediaStream):
# attributes
cdef int initialized
cdef readonly str media
cdef readonly int port
cdef readonly str transport
cdef readonly int port_count
cdef readonly frozenlist formats
cdef readonly frozenlist codec_list
cdef readonly str info
cdef readonly FrozenSDPConnection connection
cdef readonly FrozenSDPAttributeList attributes
cdef readonly FrozenSDPBandwidthInfoList bandwidth_info
cdef class BaseSDPAttribute(object):
# attributes
cdef pjmedia_sdp_attr _sdp_attribute
# private methods
cdef pjmedia_sdp_attr* get_sdp_attribute(self)
cdef class SDPAttribute(BaseSDPAttribute):
# attributes
cdef str _name
cdef str _value
cdef class FrozenSDPAttribute(BaseSDPAttribute):
# attributes
cdef int initialized
cdef readonly str name
cdef readonly str value
cdef class BaseSDPBandwidthInfo(object):
# attributes
cdef pjmedia_sdp_bandw _sdp_bandwidth_info
# private methods
cdef pjmedia_sdp_bandw* get_sdp_bandwidth_info(self)
cdef class SDPBandwidthInfo(BaseSDPBandwidthInfo):
# attributes
cdef str _modifier
cdef int _value
cdef class FrozenSDPBandwidthInfo(BaseSDPBandwidthInfo):
# attributes
cdef int initialized
cdef readonly str modifier
cdef readonly int value
cdef SDPSession SDPSession_create(pjmedia_sdp_session_ptr_const pj_session)
cdef FrozenSDPSession FrozenSDPSession_create(pjmedia_sdp_session_ptr_const pj_session)
cdef SDPMediaStream SDPMediaStream_create(pjmedia_sdp_media *pj_media)
cdef FrozenSDPMediaStream FrozenSDPMediaStream_create(pjmedia_sdp_media *pj_media)
cdef SDPConnection SDPConnection_create(pjmedia_sdp_conn *pj_conn)
cdef FrozenSDPConnection FrozenSDPConnection_create(pjmedia_sdp_conn *pj_conn)
cdef SDPAttribute SDPAttribute_create(pjmedia_sdp_attr *pj_attr)
cdef FrozenSDPAttribute FrozenSDPAttribute_create(pjmedia_sdp_attr *pj_attr)
cdef SDPBandwidthInfo SDPBandwidthInfo_create(pjmedia_sdp_bandw *pj_bandw)
cdef FrozenSDPBandwidthInfo FrozenSDPBandwidthInfo_create(pjmedia_sdp_bandw *pj_bandw)
cdef class SDPNegotiator(object):
# attributes
cdef pjmedia_sdp_neg* _neg
cdef pj_pool_t *_pool
# core.invitation
cdef class SDPPayloads:
cdef readonly FrozenSDPSession proposed_local
cdef readonly FrozenSDPSession proposed_remote
cdef readonly FrozenSDPSession active_local
cdef readonly FrozenSDPSession active_remote
cdef class StateCallbackTimer(Timer):
cdef object state
cdef object sub_state
cdef object rdata
cdef object tdata
cdef object originator
cdef class SDPCallbackTimer(Timer):
cdef int status
cdef object active_local
cdef object active_remote
cdef class TransferStateCallbackTimer(Timer):
cdef object state
cdef object code
cdef object reason
cdef class TransferResponseCallbackTimer(Timer):
cdef object method
cdef object rdata
cdef class TransferRequestCallbackTimer(Timer):
cdef object rdata
cdef class Invitation(object):
# attributes
cdef object __weakref__
cdef object weakref
cdef int _sdp_neg_status
cdef int _failed_response
cdef pj_list _route_set
cdef pj_mutex_t *_lock
cdef pjsip_inv_session *_invite_session
cdef pjsip_evsub *_transfer_usage
cdef pjsip_role_e _transfer_usage_role
cdef pjsip_dialog *_dialog
cdef pjsip_route_hdr _route_header
cdef pjsip_transaction *_reinvite_transaction
cdef PJSTR _sipfrag_payload
cdef Timer _timer
cdef Timer _transfer_timeout_timer
cdef Timer _transfer_refresh_timer
cdef readonly str call_id
cdef readonly str direction
cdef readonly str remote_user_agent
cdef readonly str state
cdef readonly str sub_state
cdef readonly str transport
cdef readonly str transfer_state
cdef readonly EndpointAddress peer_address
cdef readonly FrozenCredentials credentials
cdef readonly FrozenContactHeader local_contact_header
cdef readonly FrozenContactHeader remote_contact_header
cdef readonly FrozenFromHeader from_header
cdef readonly FrozenToHeader to_header
cdef readonly FrozenSIPURI request_uri
cdef readonly FrozenRouteHeader route_header
cdef readonly SDPPayloads sdp
# private methods
cdef int init_incoming(self, PJSIPUA ua, pjsip_rx_data *rdata, unsigned int inv_options) except -1
cdef int process_incoming_transfer(self, PJSIPUA ua, pjsip_rx_data *rdata) except -1
cdef int process_incoming_options(self, PJSIPUA ua, pjsip_rx_data *rdata) except -1
cdef PJSIPUA _check_ua(self)
cdef int _do_dealloc(self) except -1
cdef int _update_contact_header(self, BaseContactHeader contact_header) except -1
cdef int _fail(self, PJSIPUA ua) except -1
cdef int _cb_state(self, StateCallbackTimer timer) except -1
cdef int _cb_sdp_done(self, SDPCallbackTimer timer) except -1
cdef int _cb_timer_disconnect(self, timer) except -1
cdef int _cb_postpoll_fail(self, timer) except -1
cdef int _start_incoming_transfer(self, timer) except -1
cdef int _terminate_transfer(self) except -1
cdef int _terminate_transfer_uac(self) except -1
cdef int _terminate_transfer_uas(self) except -1
cdef int _set_transfer_state(self, str state) except -1
cdef int _set_sipfrag_payload(self, int code, str reason) except -1
cdef int _send_notify(self) except -1
cdef int _transfer_cb_timeout_timer(self, timer) except -1
cdef int _transfer_cb_refresh_timer(self, timer) except -1
cdef int _transfer_cb_state(self, TransferStateCallbackTimer timer) except -1
cdef int _transfer_cb_response(self, TransferResponseCallbackTimer timer) except -1
cdef int _transfer_cb_notify(self, TransferRequestCallbackTimer timer) except -1
cdef int _transfer_cb_server_timeout(self, timer) except -1
cdef void _Invitation_cb_state(pjsip_inv_session *inv, pjsip_event *e) with gil
cdef void _Invitation_cb_sdp_done(pjsip_inv_session *inv, int status) with gil
cdef int _Invitation_cb_rx_reinvite(pjsip_inv_session *inv, pjmedia_sdp_session_ptr_const offer, pjsip_rx_data *rdata) with gil
cdef void _Invitation_cb_tsx_state_changed(pjsip_inv_session *inv, pjsip_transaction *tsx, pjsip_event *e) with gil
cdef void _Invitation_cb_new(pjsip_inv_session *inv, pjsip_event *e) with gil
cdef void _Invitation_transfer_cb_state(pjsip_evsub *sub, pjsip_event *event) with gil
cdef void _Invitation_transfer_cb_tsx(pjsip_evsub *sub, pjsip_transaction *tsx, pjsip_event *event) with gil
cdef void _Invitation_transfer_cb_notify(pjsip_evsub *sub, pjsip_rx_data *rdata, int *p_st_code,
pj_str_t **p_st_text, pjsip_hdr *res_hdr, pjsip_msg_body **p_body) with gil
cdef void _Invitation_transfer_cb_refresh(pjsip_evsub *sub) with gil
cdef void _Invitation_transfer_in_cb_rx_refresh(pjsip_evsub *sub, pjsip_rx_data *rdata, int *p_st_code,
pj_str_t **p_st_text, pjsip_hdr *res_hdr, pjsip_msg_body **p_body) with gil
cdef void _Invitation_transfer_in_cb_server_timeout(pjsip_evsub *sub) with gil
# core.mediatransport
cdef class ICECandidate(object):
# attributes
cdef readonly str component
cdef readonly str type
cdef readonly str address
cdef readonly int port
cdef readonly int priority
cdef readonly str rel_address
cdef class ICECheck(object):
cdef readonly ICECandidate local_candidate
cdef readonly ICECandidate remote_candidate
cdef readonly str state
cdef readonly int nominated
cdef class RTPTransport(object):
# attributes
cdef object __weakref__
cdef object weakref
cdef int _af
cdef pj_mutex_t *_lock
cdef pj_pool_t *_pool
cdef pjmedia_transport *_obj
cdef pjmedia_transport *_wrapped_transport
cdef ICECheck _rtp_valid_pair
cdef str _encryption
cdef readonly object ice_stun_address
cdef readonly object ice_stun_port
cdef readonly object state
cdef readonly object use_ice
# private methods
cdef PJSIPUA _check_ua(self)
cdef void _get_info(self, pjmedia_transport_info *info)
cdef int _init_local_sdp(self, BaseSDPSession local_sdp, BaseSDPSession remote_sdp, int sdp_index)
cdef int _ice_active(self)
cdef class MediaCheckTimer(Timer):
# attributes
cdef int media_check_interval
cdef class SDPInfo(object):
# attributes
cdef BaseSDPMediaStream _local_media
cdef BaseSDPSession _local_sdp
cdef BaseSDPSession _remote_sdp
cdef public int index
cdef class AudioTransport(object):
# attributes
cdef object __weakref__
cdef object weakref
cdef int _is_offer
cdef int _is_started
cdef int _slot
cdef int _volume
cdef unsigned int _packets_received
cdef unsigned int _vad
cdef pj_mutex_t *_lock
cdef pj_pool_t *_pool
cdef pjmedia_stream *_obj
cdef pjmedia_stream_info _stream_info
cdef Timer _timer
cdef readonly object direction
cdef readonly AudioMixer mixer
cdef readonly RTPTransport transport
cdef SDPInfo _sdp_info
# private methods
cdef PJSIPUA _check_ua(self)
cdef int _cb_check_rtp(self, MediaCheckTimer timer) except -1 with gil
cdef class VideoTransport(object):
# attributes
cdef object __weakref__
cdef object weakref
cdef int _is_offer
cdef int _is_started
cdef unsigned int _packets_received
cdef pj_mutex_t *_lock
cdef pj_pool_t *_pool
cdef pjmedia_vid_stream *_obj
cdef pjmedia_vid_stream_info _stream_info
cdef Timer _timer
cdef readonly object direction
cdef readonly RTPTransport transport
cdef SDPInfo _sdp_info
cdef readonly LocalVideoStream local_video
cdef readonly RemoteVideoStream remote_video
# private methods
cdef PJSIPUA _check_ua(self)
cdef int _cb_check_rtp(self, MediaCheckTimer timer) except -1 with gil
cdef void _RTPTransport_cb_ice_complete(pjmedia_transport *tp, pj_ice_strans_op op, int status) with gil
cdef void _RTPTransport_cb_ice_state(pjmedia_transport *tp, pj_ice_strans_state prev, pj_ice_strans_state curr) with gil
cdef void _RTPTransport_cb_ice_stop(pjmedia_transport *tp, char *reason, int err) with gil
cdef void _RTPTransport_cb_zrtp_secure_on(pjmedia_transport *tp, char* cipher) with gil
cdef void _RTPTransport_cb_zrtp_secure_off(pjmedia_transport *tp) with gil
cdef void _RTPTransport_cb_zrtp_show_sas(pjmedia_transport *tp, char* sas, int verified) with gil
cdef void _RTPTransport_cb_zrtp_confirm_goclear(pjmedia_transport *tp) with gil
cdef void _RTPTransport_cb_zrtp_show_message(pjmedia_transport *tp, int severity, int subCode) with gil
cdef void _RTPTransport_cb_zrtp_negotiation_failed(pjmedia_transport *tp, int severity, int subCode) with gil
cdef void _RTPTransport_cb_zrtp_not_supported_by_other(pjmedia_transport *tp) with gil
cdef void _RTPTransport_cb_zrtp_ask_enrollment(pjmedia_transport *tp, int info) with gil
cdef void _RTPTransport_cb_zrtp_inform_enrollment(pjmedia_transport *tp, int info) with gil
cdef void _AudioTransport_cb_dtmf(pjmedia_stream *stream, void *user_data, int digit) with gil
cdef ICECandidate ICECandidate_create(pj_ice_sess_cand *cand)
cdef ICECheck ICECheck_create(pj_ice_sess_check *check)
cdef str _ice_state_to_str(int state)
cdef dict _extract_ice_session_data(pj_ice_sess *ice_sess)
cdef object _extract_rtp_transport(pjmedia_transport *tp)
cdef dict _pj_math_stat_to_dict(pj_math_stat *stat)
cdef dict _pjmedia_rtcp_stream_stat_to_dict(pjmedia_rtcp_stream_stat *stream_stat)
diff --git a/sipsimple/core/_core.ua.pxi b/sipsimple/core/_core.ua.pxi
index 3e74dcd8..b10e1e32 100644
--- a/sipsimple/core/_core.ua.pxi
+++ b/sipsimple/core/_core.ua.pxi
@@ -1,1230 +1,1232 @@
# Copyright (C) 2008-2011 AG Projects. See LICENSE for details.
#
# python imports
import errno
import heapq
import re
import random
import sys
import time
import traceback
import os
import tempfile
# classes
cdef class Timer:
cdef int schedule(self, float delay, timer_callback callback, object obj) except -1:
cdef PJSIPUA ua = _get_ua()
if delay < 0:
raise ValueError("delay must be a non-negative number")
if callback == NULL:
raise ValueError("callback must be non-NULL")
if self._scheduled:
raise RuntimeError("already scheduled")
self.schedule_time = PyFloat_AsDouble(time.time() + delay)
self.callback = callback
self.obj = obj
ua._add_timer(self)
self._scheduled = 1
return 0
cdef int cancel(self) except -1:
cdef PJSIPUA ua = _get_ua()
if not self._scheduled:
return 0
ua._remove_timer(self)
self._scheduled = 0
return 0
cdef int call(self) except -1:
self._scheduled = 0
self.callback(self.obj, self)
def __richcmp__(self, other, op):
cdef double diff
if not isinstance(self, Timer) or not isinstance(other, Timer):
return NotImplemented
diff = (<Timer>self).schedule_time - (<Timer>other).schedule_time
if op == 0: # <
return diff < 0.0
elif op == 1: # <=
return diff <= 0.0
elif op == 2: # ==
return diff == 0.0
elif op == 3: # !=
return diff != 0.0
elif op == 4: # >
return diff > 0.0
elif op == 5: # >=
return diff >= 0.0
return
cdef class PJSIPUA:
def __cinit__(self, *args, **kwargs):
global _ua
if _ua != NULL:
raise SIPCoreError("Can only have one PJSUPUA instance at the same time")
_ua = <void *> self
self._threads = []
self._timers = list()
self._events = {}
self._incoming_events = set()
self._incoming_requests = set()
self._sent_messages = set()
def __init__(self, event_handler, *args, **kwargs):
global _event_queue_lock
cdef str event
cdef str method
cdef list accept_types
cdef int status
cdef PJSTR message_method = PJSTR("MESSAGE")
cdef PJSTR refer_method = PJSTR("REFER")
cdef PJSTR str_norefersub = PJSTR("norefersub")
cdef PJSTR str_gruu = PJSTR("gruu")
self._event_handler = event_handler
if kwargs["log_level"] < 0 or kwargs["log_level"] > PJ_LOG_MAX_LEVEL:
raise ValueError("Log level should be between 0 and %d" % PJ_LOG_MAX_LEVEL)
pj_log_set_level(kwargs["log_level"])
pj_log_set_decor(PJ_LOG_HAS_YEAR | PJ_LOG_HAS_MONTH | PJ_LOG_HAS_DAY_OF_MON |
PJ_LOG_HAS_TIME | PJ_LOG_HAS_MICRO_SEC | PJ_LOG_HAS_SENDER | PJ_LOG_HAS_INDENT)
pj_log_set_log_func(_cb_log)
self._pjlib = PJLIB()
pj_srand(random.getrandbits(32)) # rely on python seed for now
self._caching_pool = PJCachingPool()
self._pjmedia_endpoint = PJMEDIAEndpoint(self._caching_pool)
self._pjsip_endpoint = PJSIPEndpoint(self._caching_pool, kwargs["ip_address"], kwargs["udp_port"],
kwargs["tcp_port"], kwargs["tls_port"],
kwargs["tls_verify_server"], kwargs["tls_ca_file"],
kwargs["tls_cert_file"], kwargs["tls_privkey_file"], kwargs["tls_timeout"])
status = pj_mutex_create_simple(self._pjsip_endpoint._pool, "event_queue_lock", &_event_queue_lock)
if status != 0:
raise PJSIPError("Could not initialize event queue mutex", status)
self._ip_address = kwargs["ip_address"]
self.codecs = kwargs["codecs"]
self.video_codecs = kwargs["video_codecs"]
self._module_name = PJSTR("mod-core")
self._module.name = self._module_name.pj_str
self._module.id = -1
self._module.priority = PJSIP_MOD_PRIORITY_APPLICATION
self._module.on_rx_request = _PJSIPUA_cb_rx_request
self._module.on_tsx_state = _Request_cb_tsx_state
status = pjsip_endpt_register_module(self._pjsip_endpoint._obj, &self._module)
if status != 0:
raise PJSIPError("Could not load application module", status)
status = pjsip_endpt_add_capability(self._pjsip_endpoint._obj, &self._module,
PJSIP_H_ALLOW, NULL, 1, &message_method.pj_str)
if status != 0:
raise PJSIPError("Could not add MESSAGE method to supported methods", status)
status = pjsip_endpt_add_capability(self._pjsip_endpoint._obj, &self._module,
PJSIP_H_ALLOW, NULL, 1, &refer_method.pj_str)
if status != 0:
raise PJSIPError("Could not add REFER method to supported methods", status)
status = pjsip_endpt_add_capability(self._pjsip_endpoint._obj, NULL,
PJSIP_H_SUPPORTED, NULL, 1, &str_norefersub.pj_str)
if status != 0:
raise PJSIPError("Could not add 'norefsub' to Supported header", status)
status = pjsip_endpt_add_capability(self._pjsip_endpoint._obj, NULL,
PJSIP_H_SUPPORTED, NULL, 1, &str_gruu.pj_str)
if status != 0:
raise PJSIPError("Could not add 'gruu' to Supported header", status)
self._trace_sip = int(bool(kwargs["trace_sip"]))
self._detect_sip_loops = int(bool(kwargs["detect_sip_loops"]))
self._enable_colorbar_device = int(bool(kwargs["enable_colorbar_device"]))
self._opus_fix_module_name = PJSTR("mod-core-opus-fix")
self._opus_fix_module.name = self._opus_fix_module_name.pj_str
self._opus_fix_module.id = -1
self._opus_fix_module.priority = PJSIP_MOD_PRIORITY_TRANSPORT_LAYER+1
self._opus_fix_module.on_rx_request = _cb_opus_fix_rx
self._opus_fix_module.on_rx_response = _cb_opus_fix_rx
self._opus_fix_module.on_tx_request = _cb_opus_fix_tx
self._opus_fix_module.on_tx_response = _cb_opus_fix_tx
status = pjsip_endpt_register_module(self._pjsip_endpoint._obj, &self._opus_fix_module)
if status != 0:
raise PJSIPError("Could not load opus-fix module", status)
self._trace_module_name = PJSTR("mod-core-sip-trace")
self._trace_module.name = self._trace_module_name.pj_str
self._trace_module.id = -1
self._trace_module.priority = 0
self._trace_module.on_rx_request = _cb_trace_rx
self._trace_module.on_rx_response = _cb_trace_rx
self._trace_module.on_tx_request = _cb_trace_tx
self._trace_module.on_tx_response = _cb_trace_tx
status = pjsip_endpt_register_module(self._pjsip_endpoint._obj, &self._trace_module)
if status != 0:
raise PJSIPError("Could not load sip trace module", status)
self._ua_tag_module_name = PJSTR("mod-core-ua-tag")
self._ua_tag_module.name = self._ua_tag_module_name.pj_str
self._ua_tag_module.id = -1
self._ua_tag_module.priority = PJSIP_MOD_PRIORITY_TRANSPORT_LAYER+1
self._ua_tag_module.on_tx_request = _cb_add_user_agent_hdr
self._ua_tag_module.on_tx_response = _cb_add_server_hdr
status = pjsip_endpt_register_module(self._pjsip_endpoint._obj, &self._ua_tag_module)
if status != 0:
raise PJSIPError("Could not load User-Agent/Server header tagging module", status)
self._event_module_name = PJSTR("mod-core-events")
self._event_module.name = self._event_module_name.pj_str
self._event_module.id = -1
self._event_module.priority = PJSIP_MOD_PRIORITY_DIALOG_USAGE
status = pjsip_endpt_register_module(self._pjsip_endpoint._obj, &self._event_module)
if status != 0:
raise PJSIPError("Could not load events module", status)
status = pjmedia_aud_dev_set_observer_cb(_cb_audio_dev_process_event);
if status != 0:
raise PJSIPError("Could not set audio_change callbacks", status)
status = pj_rwmutex_create(self._pjsip_endpoint._pool, "ua_audio_change_rwlock", &self.audio_change_rwlock)
if status != 0:
raise PJSIPError("Could not initialize audio change rwmutex", status)
status = pj_mutex_create_recursive(self._pjsip_endpoint._pool, "ua_video_lock", &self.video_lock)
if status != 0:
raise PJSIPError("Could not initialize video mutex", status)
self._user_agent = PJSTR(kwargs["user_agent"])
for event, accept_types in kwargs["events"].iteritems():
self.add_event(event, accept_types)
for event in kwargs["incoming_events"]:
if event not in self._events.iterkeys():
raise ValueError('Event "%s" is not known' % event)
self._incoming_events.add(event)
for method in kwargs["incoming_requests"]:
method = method.upper()
if method in ("ACK", "BYE", "INVITE", "REFER", "SUBSCRIBE"):
raise ValueError('Handling incoming "%s" requests is not allowed' % method)
self._incoming_requests.add(method)
self.rtp_port_range = kwargs["rtp_port_range"]
self.zrtp_cache = kwargs["zrtp_cache"]
pj_stun_config_init(&self._stun_cfg, &self._caching_pool._obj.factory, 0,
pjmedia_endpt_get_ioqueue(self._pjmedia_endpoint._obj),
pjsip_endpt_get_timer_heap(self._pjsip_endpoint._obj))
property trace_sip:
def __get__(self):
self._check_self()
return bool(self._trace_sip)
def __set__(self, value):
self._check_self()
self._trace_sip = int(bool(value))
property detect_sip_loops:
def __get__(self):
self._check_self()
return bool(self._detect_sip_loops)
def __set__(self, value):
self._check_self()
self._detect_sip_loops = int(bool(value))
property enable_colorbar_device:
def __get__(self):
self._check_self()
return bool(self._enable_colorbar_device)
def __set__(self, value):
self._check_self()
self._enable_colorbar_device = int(bool(value))
self.refresh_video_devices()
property events:
def __get__(self):
self._check_self()
return self._events.copy()
property ip_address:
def __get__(self):
self._check_self()
return self._ip_address
def add_event(self, object event, list accept_types):
cdef pj_str_t event_pj
cdef pj_str_t accept_types_pj[PJSIP_MAX_ACCEPT_COUNT]
cdef int index
cdef object accept_type
cdef int accept_cnt = len(accept_types)
cdef int status
self._check_self()
if accept_cnt == 0:
raise SIPCoreError("Need at least one of accept_types")
if accept_cnt > PJSIP_MAX_ACCEPT_COUNT:
raise SIPCoreError("Too many accept_types")
_str_to_pj_str(event, &event_pj)
for index, accept_type in enumerate(accept_types):
_str_to_pj_str(accept_type, &accept_types_pj[index])
status = pjsip_evsub_register_pkg(&self._event_module, &event_pj, 3600, accept_cnt, accept_types_pj)
if status != 0:
raise PJSIPError("Could not register event package", status)
self._events[event] = accept_types[:]
property incoming_events:
def __get__(self):
self._check_self()
return self._incoming_events.copy()
def add_incoming_event(self, str event):
self._check_self()
if event not in self._events.iterkeys():
raise ValueError('Event "%s" is not known' % event)
self._incoming_events.add(event)
def remove_incoming_event(self, str event):
self._check_self()
if event not in self._events.iterkeys():
raise ValueError('Event "%s" is not known' % event)
self._incoming_events.discard(event)
property incoming_requests:
def __get__(self):
self._check_self()
return self._incoming_requests.copy()
def add_incoming_request(self, object value):
cdef str method
self._check_self()
method = value.upper()
if method in ("ACK", "BYE", "INVITE", "REFER", "SUBSCRIBE"):
raise ValueError('Handling incoming "%s" requests is not allowed' % method)
self._incoming_requests.add(method)
def remove_incoming_request(self, object value):
cdef str method
self._check_self()
method = value.upper()
if method in ("ACK", "BYE", "INVITE", "REFER", "SUBSCRIBE"):
raise ValueError('Handling incoming "%s" requests is not allowed' % method)
self._incoming_requests.discard(method)
cdef pj_pool_t* create_memory_pool(self, bytes name, int initial_size, int resize_size):
cdef pj_pool_t *pool
cdef char *c_pool_name
cdef pjsip_endpoint *endpoint
c_pool_name = name
endpoint = self._pjsip_endpoint._obj
with nogil:
pool = pjsip_endpt_create_pool(endpoint, c_pool_name, initial_size, resize_size)
if pool == NULL:
raise SIPCoreError("Could not allocate memory pool")
return pool
cdef void release_memory_pool(self, pj_pool_t* pool):
cdef pjsip_endpoint *endpoint
endpoint = self._pjsip_endpoint._obj
if pool != NULL:
with nogil:
pjsip_endpt_release_pool(endpoint, pool)
cdef void reset_memory_pool(self, pj_pool_t* pool):
if pool != NULL:
with nogil:
pj_pool_reset(pool)
cdef object _get_sound_devices(self, int is_output):
cdef int count
cdef pjmedia_aud_dev_info info
cdef list retval = list()
cdef int status
with nogil:
status = pj_rwmutex_lock_read(self.audio_change_rwlock)
if status != 0:
raise PJSIPError('Could not acquire audio_change_rwlock', status)
try:
for i in range(pjmedia_aud_dev_count()):
with nogil:
status = pjmedia_aud_dev_get_info(i, &info)
if status != 0:
raise PJSIPError("Could not get audio device info", status)
if is_output:
count = info.output_count
else:
count = info.input_count
if count:
retval.append(decode_device_name(info.name))
return retval
finally:
pj_rwmutex_unlock_read(self.audio_change_rwlock)
cdef object _get_default_sound_device(self, int is_output):
cdef pjmedia_aud_dev_info info
cdef int dev_id
cdef int status
with nogil:
status = pj_rwmutex_lock_read(self.audio_change_rwlock)
if status != 0:
raise SIPCoreError('Could not acquire audio_change_rwlock', status)
try:
if is_output:
dev_id = PJMEDIA_AUD_DEFAULT_PLAYBACK_DEV
else:
dev_id = PJMEDIA_AUD_DEFAULT_CAPTURE_DEV
with nogil:
status = pjmedia_aud_dev_get_info(dev_id, &info)
if status != 0:
raise PJSIPError("Could not get audio device info", status)
return decode_device_name(info.name)
finally:
pj_rwmutex_unlock_read(self.audio_change_rwlock)
property default_output_device:
def __get__(self):
self._check_self()
return self._get_default_sound_device(1)
property default_input_device:
def __get__(self):
self._check_self()
return self._get_default_sound_device(0)
property output_devices:
def __get__(self):
self._check_self()
return self._get_sound_devices(1)
property input_devices:
def __get__(self):
self._check_self()
return self._get_sound_devices(0)
property sound_devices:
def __get__(self):
self._check_self()
cdef int count
cdef pjmedia_aud_dev_info info
cdef list retval = list()
cdef int status
with nogil:
status = pj_rwmutex_lock_read(self.audio_change_rwlock)
if status != 0:
raise SIPCoreError('Could not acquire audio_change_rwlock', status)
try:
for i in range(pjmedia_aud_dev_count()):
with nogil:
status = pjmedia_aud_dev_get_info(i, &info)
if status == 0:
retval.append(decode_device_name(info.name))
return retval
finally:
pj_rwmutex_unlock_read(self.audio_change_rwlock)
def refresh_sound_devices(self):
self._check_self()
cdef int status
cdef dict event_dict
self.old_devices = self.sound_devices
with nogil:
status = pj_rwmutex_lock_write(self.audio_change_rwlock)
if status != 0:
raise SIPCoreError('Could not acquire audio_change_rwlock', status)
with nogil:
pjmedia_aud_dev_refresh()
status = pj_rwmutex_unlock_write(self.audio_change_rwlock)
if status != 0:
raise SIPCoreError('Could not release audio_change_rwlock', status)
event_dict = dict()
event_dict["old_devices"] = self.old_devices
event_dict["new_devices"] = self.sound_devices
_add_event("AudioDevicesDidChange", event_dict)
cdef object _get_video_devices(self):
cdef pjmedia_vid_dev_info info
cdef list retval = list()
cdef int direction
cdef int status
for i in range(pjmedia_vid_dev_count()):
with nogil:
status = pjmedia_vid_dev_get_info(i, &info)
if status != 0:
raise PJSIPError("Could not get video device info", status)
direction = info.dir
if direction in (PJMEDIA_DIR_CAPTURE, PJMEDIA_DIR_CAPTURE_PLAYBACK):
if (not self._enable_colorbar_device and bytes(info.driver) == "Colorbar") or bytes(info.driver) == "Null":
continue
retval.append(decode_device_name(info.name))
return retval
cdef object _get_default_video_device(self):
cdef pjmedia_vid_dev_info info
cdef int status
with nogil:
status = pjmedia_vid_dev_get_info(PJMEDIA_VID_DEFAULT_CAPTURE_DEV, &info)
if status != 0:
raise PJSIPError("Could not get default video device info", status)
if (not self._enable_colorbar_device and bytes(info.driver) == "Colorbar") or bytes(info.driver) == "Null":
raise SIPCoreError("Could not get default video device")
return decode_device_name(info.name)
def refresh_video_devices(self):
self._check_self()
cdef int status
cdef dict event_dict
self.old_video_devices = self.video_devices
with nogil:
pjmedia_vid_dev_refresh()
event_dict = dict()
event_dict["old_devices"] = self.old_video_devices
event_dict["new_devices"] = self.video_devices
_add_event("VideoDevicesDidChange", event_dict)
property default_video_device:
def __get__(self):
self._check_self()
return self._get_default_video_device()
property video_devices:
def __get__(self):
self._check_self()
return self._get_video_devices()
property available_codecs:
def __get__(self):
self._check_self()
return self._pjmedia_endpoint._get_all_codecs()
property codecs:
def __get__(self):
self._check_self()
return self._pjmedia_endpoint._get_current_codecs()
def __set__(self, value):
self._check_self()
self._pjmedia_endpoint._set_codecs(value)
property available_video_codecs:
def __get__(self):
self._check_self()
return self._pjmedia_endpoint._get_all_video_codecs()
property video_codecs:
def __get__(self):
self._check_self()
return self._pjmedia_endpoint._get_current_video_codecs()
def __set__(self, value):
self._check_self()
self._pjmedia_endpoint._set_video_codecs(value)
property udp_port:
def __get__(self):
self._check_self()
if self._pjsip_endpoint._udp_transport == NULL:
return None
return self._pjsip_endpoint._udp_transport.local_name.port
def set_udp_port(self, value):
cdef int port
self._check_self()
if value is None:
if self._pjsip_endpoint._udp_transport == NULL:
return
self._pjsip_endpoint._stop_udp_transport()
else:
port = value
if not (0 <= port <= 65535):
raise ValueError("Not a valid UDP port: %d" % value)
if self._pjsip_endpoint._udp_transport != NULL:
if port == self._pjsip_endpoint._udp_transport.local_name.port:
return
self._pjsip_endpoint._stop_udp_transport()
self._pjsip_endpoint._start_udp_transport(port)
property tcp_port:
def __get__(self):
self._check_self()
if self._pjsip_endpoint._tcp_transport == NULL:
return None
return self._pjsip_endpoint._tcp_transport.addr_name.port
def set_tcp_port(self, value):
cdef int port
self._check_self()
if value is None:
if self._pjsip_endpoint._tcp_transport == NULL:
return
self._pjsip_endpoint._stop_tcp_transport()
else:
port = value
if not (0 <= port <= 65535):
raise ValueError("Not a valid TCP port: %d" % value)
if self._pjsip_endpoint._tcp_transport != NULL:
if port == self._pjsip_endpoint._tcp_transport.addr_name.port:
return
self._pjsip_endpoint._stop_tcp_transport()
self._pjsip_endpoint._start_tcp_transport(port)
property tls_port:
def __get__(self):
self._check_self()
if self._pjsip_endpoint._tls_transport == NULL:
return None
return self._pjsip_endpoint._tls_transport.addr_name.port
property rtp_port_range:
def __get__(self):
self._check_self()
return (self._rtp_port_start, self._rtp_port_start + self._rtp_port_count)
def __set__(self, value):
cdef int _rtp_port_start
cdef int _rtp_port_stop
cdef int _rtp_port_count
cdef int _rtp_port_usable_count
cdef int port
self._check_self()
for port in value:
if not (0 <= port <= 65535):
raise SIPCoreError("RTP port range values should be between 0 and 65535")
_rtp_port_start, _rtp_port_stop = value
_rtp_port_count = _rtp_port_stop - _rtp_port_start
_rtp_port_usable_count = _rtp_port_count - _rtp_port_count % 2 # we need an even number of ports, so we won't use the last one if an odd number is provided
if _rtp_port_usable_count < 2:
raise SIPCoreError("RTP port range should contain at least 2 ports")
self._rtp_port_start = _rtp_port_start
self._rtp_port_count = _rtp_port_count
self._rtp_port_usable_count = _rtp_port_usable_count
self._rtp_port_index = 0
property user_agent:
def __get__(self):
self._check_self()
return self._user_agent.str
def __set__(self, value):
self._check_self()
self._user_agent = PJSTR("value")
property log_level:
def __get__(self):
self._check_self()
return pj_log_get_level()
def __set__(self, value):
self._check_self()
if value < 0 or value > PJ_LOG_MAX_LEVEL:
raise ValueError("Log level should be between 0 and %d" % PJ_LOG_MAX_LEVEL)
pj_log_set_level(value)
property tls_verify_server:
def __get__(self):
self._check_self()
return bool(self._pjsip_endpoint._tls_verify_server)
property tls_ca_file:
def __get__(self):
self._check_self()
if self._pjsip_endpoint._tls_ca_file is None:
return None
else:
return self._pjsip_endpoint._tls_ca_file.str
property tls_cert_file:
def __get__(self):
self._check_self()
if self._pjsip_endpoint._tls_cert_file is None:
return None
else:
return self._pjsip_endpoint._tls_cert_file.str
property tls_privkey_file:
def __get__(self):
self._check_self()
if self._pjsip_endpoint._tls_privkey_file is None:
return None
else:
return self._pjsip_endpoint._tls_privkey_file.str
property tls_timeout:
def __get__(self):
self._check_self()
return self._pjsip_endpoint._tls_timeout
def set_tls_options(self, port=None, verify_server=False,
ca_file=None, cert_file=None, privkey_file=None, int timeout=3000):
cdef int c_port
self._check_self()
if port is None:
if self._pjsip_endpoint._tls_transport == NULL:
return
self._pjsip_endpoint._stop_tls_transport()
else:
c_port = port
if not (0 <= c_port <= 65535):
raise ValueError("Not a valid TCP port: %d" % port)
if ca_file is not None and not os.path.isfile(ca_file):
raise ValueError("Cannot find the specified CA file: %s" % ca_file)
if cert_file is not None and not os.path.isfile(cert_file):
raise ValueError("Cannot find the specified certificate file: %s" % cert_file)
if privkey_file is not None and not os.path.isfile(privkey_file):
raise ValueError("Cannot find the specified private key file: %s" % privkey_file)
if timeout < 0:
raise ValueError("Invalid TLS timeout value: %d" % timeout)
if self._pjsip_endpoint._tls_transport != NULL:
self._pjsip_endpoint._stop_tls_transport()
self._pjsip_endpoint._tls_verify_server = int(bool(verify_server))
if ca_file is None:
self._pjsip_endpoint._tls_ca_file = None
else:
self._pjsip_endpoint._tls_ca_file = PJSTR(ca_file.encode(sys.getfilesystemencoding()))
if cert_file is None:
self._pjsip_endpoint._tls_cert_file = None
else:
self._pjsip_endpoint._tls_cert_file = PJSTR(cert_file.encode(sys.getfilesystemencoding()))
if privkey_file is None:
self._pjsip_endpoint._tls_privkey_file = None
else:
self._pjsip_endpoint._tls_privkey_file = PJSTR(privkey_file.encode(sys.getfilesystemencoding()))
self._pjsip_endpoint._tls_timeout = timeout
self._pjsip_endpoint._start_tls_transport(c_port)
def detect_nat_type(self, stun_server_address, stun_server_port=PJ_STUN_PORT, object user_data=None):
cdef pj_str_t stun_server_address_pj
cdef pj_sockaddr_in stun_server
cdef int status
self._check_self()
if not _is_valid_ip(pj_AF_INET(), stun_server_address):
raise ValueError("Not a valid IPv4 address: %s" % stun_server_address)
_str_to_pj_str(stun_server_address, &stun_server_address_pj)
status = pj_sockaddr_in_init(&stun_server, &stun_server_address_pj, stun_server_port)
if status != 0:
raise PJSIPError("Could not init STUN server address", status)
status = pj_stun_detect_nat_type(&stun_server, &self._stun_cfg, <void *> user_data, _cb_detect_nat_type)
if status != 0:
raise PJSIPError("Could not start NAT type detection", status)
Py_INCREF(user_data)
def set_nameservers(self, list nameservers):
self._check_self()
return self._pjsip_endpoint._set_dns_nameservers([n for n in nameservers if _re_ipv4.match(n)])
- def set_h264_options(self, profile, level, max_resolution, int max_framerate, object max_bitrate):
+ def set_h264_options(self, profile, level):
self._check_self()
- self._pjmedia_endpoint._set_h264_options(str(profile),
- int(level.replace('.', '')),
- tuple(max_resolution),
- max_framerate,
- max_bitrate or 0.0)
+ self._pjmedia_endpoint._set_h264_options(str(profile), int(level.replace('.', '')))
+
+ def set_video_options(self, max_resolution, int max_framerate, object max_bitrate):
+ self._check_self()
+ self._pjmedia_endpoint._set_video_options(tuple(max_resolution),
+ max_framerate,
+ max_bitrate or 0.0)
property zrtp_cache:
def __get__(self):
self._check_self()
return self._zrtp_cache
def __set__(self, value):
self._check_self()
if value is None:
value = os.path.join(tempfile.gettempdir(), 'zrtp_cache_%d.db' % os.getpid())
self._zrtp_cache = value
def __dealloc__(self):
self.dealloc()
def dealloc(self):
global _ua, _dealloc_handler_queue, _event_queue_lock
if _ua == NULL:
return
self._check_thread()
pjmedia_aud_dev_set_observer_cb(NULL)
if self.audio_change_rwlock != NULL:
pj_rwmutex_destroy(self.audio_change_rwlock)
if self.video_lock != NULL:
pj_mutex_destroy(self.video_lock)
_process_handler_queue(self, &_dealloc_handler_queue)
if _event_queue_lock != NULL:
pj_mutex_lock(_event_queue_lock)
pj_mutex_destroy(_event_queue_lock)
_event_queue_lock = NULL
self._pjsip_endpoint = None
self._pjmedia_endpoint = None
self._caching_pool = None
self._pjlib = None
_ua = NULL
self._poll_log()
cdef int _poll_log(self) except -1:
cdef object event_name
cdef dict event_params
cdef list events
events = _get_clear_event_queue()
for event_name, event_params in events:
self._event_handler(event_name, **event_params)
def poll(self):
global _post_poll_handler_queue
cdef int status
cdef double now
cdef object retval = None
cdef float max_timeout
cdef pj_time_val pj_max_timeout
cdef list timers
cdef Timer timer
self._check_self()
max_timeout = 0.100
while self._timers:
if not (<Timer>self._timers[0])._scheduled:
# timer was cancelled
heapq.heappop(self._timers)
else:
max_timeout = min(max((<Timer>self._timers[0]).schedule_time - time.time(), 0.0), max_timeout)
break
pj_max_timeout.sec = int(max_timeout)
pj_max_timeout.msec = int(max_timeout * 1000) % 1000
with nogil:
status = pjsip_endpt_handle_events(self._pjsip_endpoint._obj, &pj_max_timeout)
IF UNAME_SYSNAME == "Darwin":
if status not in [0, PJ_ERRNO_START_SYS + errno.EBADF]:
raise PJSIPError("Error while handling events", status)
ELSE:
if status != 0:
raise PJSIPError("Error while handling events", status)
_process_handler_queue(self, &_post_poll_handler_queue)
timers = list()
now = time.time()
while self._timers:
if not (<Timer>self._timers[0])._scheduled:
# timer was cancelled
heapq.heappop(self._timers)
elif (<Timer>self._timers[0]).schedule_time <= now:
# timer needs to be processed
timer = heapq.heappop(self._timers)
timers.append(timer)
else:
break
for timer in timers:
timer.call()
self._poll_log()
if self._fatal_error:
return True
else:
return False
cdef int _handle_exception(self, int is_fatal) except -1:
cdef object exc_type
cdef object exc_val
cdef object exc_tb
exc_type, exc_val, exc_tb = sys.exc_info()
if is_fatal:
self._fatal_error = is_fatal
_add_event("SIPEngineGotException",
dict(type=exc_type, value=exc_val,
traceback="".join(traceback.format_exception(exc_type, exc_val, exc_tb))))
return 0
cdef int _check_self(self) except -1:
global _ua
if _ua == NULL:
raise SIPCoreError("The PJSIPUA is no longer running")
self._check_thread()
cdef int _check_thread(self) except -1:
if not pj_thread_is_registered():
self._threads.append(PJSIPThread())
return 0
cdef int _add_timer(self, Timer timer) except -1:
heapq.heappush(self._timers, timer)
return 0
cdef int _remove_timer(self, Timer timer) except -1:
# Don't remove it from the heap, just mark it as not scheduled
timer._scheduled = 0
return 0
cdef int _cb_rx_request(self, pjsip_rx_data *rdata) except 0:
global _event_hdr_name
cdef int status
cdef int bad_request
cdef pjsip_tx_data *tdata = NULL
cdef pjsip_hdr_ptr_const hdr_add
cdef IncomingRequest request
cdef Invitation inv
cdef IncomingSubscription sub
cdef IncomingReferral ref
cdef list extra_headers
cdef dict event_dict
cdef dict message_params
cdef pj_str_t tsx_key
cdef pjsip_via_hdr *top_via
cdef pjsip_via_hdr *via
cdef pjsip_transaction *tsx = NULL
cdef unsigned int options = PJSIP_INV_SUPPORT_100REL
cdef pjsip_event_hdr *event_hdr
cdef object method_name = _pj_str_to_str(rdata.msg_info.msg.line.req.method.name)
if method_name != "ACK":
if self._detect_sip_loops:
# Temporarily trick PJSIP into believing the last Via header is actually the first
top_via = via = rdata.msg_info.via
while True:
rdata.msg_info.via = via
via = <pjsip_via_hdr *> pjsip_msg_find_hdr(rdata.msg_info.msg, PJSIP_H_VIA, (<pj_list *> via).next)
if via == NULL:
break
status = pjsip_tsx_create_key(rdata.tp_info.pool, &tsx_key,
PJSIP_ROLE_UAC, &rdata.msg_info.msg.line.req.method, rdata)
rdata.msg_info.via = top_via
if status != 0:
raise PJSIPError("Could not generate transaction key for incoming request", status)
tsx = pjsip_tsx_layer_find_tsx(&tsx_key, 0)
if tsx != NULL:
status = pjsip_endpt_create_response(self._pjsip_endpoint._obj, rdata, 482, NULL, &tdata)
if status != 0:
raise PJSIPError("Could not create response", status)
elif method_name in self._incoming_requests:
request = IncomingRequest()
request.init(self, rdata)
elif method_name == "OPTIONS":
status = pjsip_endpt_create_response(self._pjsip_endpoint._obj, rdata, 200, NULL, &tdata)
if status != 0:
raise PJSIPError("Could not create response", status)
for hdr_type in [PJSIP_H_ALLOW, PJSIP_H_ACCEPT, PJSIP_H_SUPPORTED]:
hdr_add = pjsip_endpt_get_capability(self._pjsip_endpoint._obj, hdr_type, NULL)
if hdr_add != NULL:
pjsip_msg_add_hdr(tdata.msg, <pjsip_hdr *> pjsip_hdr_clone(tdata.pool, hdr_add))
elif method_name == "INVITE":
status = pjsip_inv_verify_request(rdata, &options, NULL, NULL, self._pjsip_endpoint._obj, &tdata)
if status == 0:
inv = Invitation()
inv.init_incoming(self, rdata, options)
elif method_name == "SUBSCRIBE":
event_hdr = <pjsip_event_hdr *> pjsip_msg_find_hdr_by_name(rdata.msg_info.msg, &_event_hdr_name.pj_str, NULL)
if event_hdr == NULL or _pj_str_to_str(event_hdr.event_type) not in self._incoming_events:
status = pjsip_endpt_create_response(self._pjsip_endpoint._obj, rdata, 489, NULL, &tdata)
if status != 0:
raise PJSIPError("Could not create response", status)
else:
sub = IncomingSubscription()
sub.init(self, rdata, _pj_str_to_str(event_hdr.event_type))
elif method_name == "REFER":
ref = IncomingReferral()
ref.init(self, rdata)
elif method_name == "MESSAGE":
bad_request = 0
extra_headers = list()
message_params = dict()
event_dict = dict()
_pjsip_msg_to_dict(rdata.msg_info.msg, event_dict)
message_params["request_uri"] = event_dict["request_uri"]
message_params["from_header"] = event_dict["headers"].get("From", None)
message_params["to_header"] = event_dict["headers"].get("To", None)
message_params["headers"] = event_dict["headers"]
message_params["body"] = event_dict["body"]
content_type = message_params["headers"].get("Content-Type", None)
if content_type is not None:
message_params["content_type"] = content_type.content_type
if message_params["headers"].get("Content-Length", 0) > 0 and message_params["body"] is None:
bad_request = 1
extra_headers.append(WarningHeader(399, "local", "Missing body"))
else:
message_params["content_type"] = None
if message_params["headers"].get("Content-Length", 0) > 0 and message_params["body"] is None:
bad_request = 1
extra_headers.append(WarningHeader(399, "local", "Missing Content-Type header"))
if bad_request:
status = pjsip_endpt_create_response(self._pjsip_endpoint._obj, rdata, 400, NULL, &tdata)
if status != 0:
raise PJSIPError("Could not create response", status)
_add_headers_to_tdata(tdata, extra_headers)
else:
_add_event("SIPEngineGotMessage", message_params)
status = pjsip_endpt_create_response(self._pjsip_endpoint._obj, rdata, 200, NULL, &tdata)
if status != 0:
raise PJSIPError("Could not create response", status)
elif method_name != "ACK":
status = pjsip_endpt_create_response(self._pjsip_endpoint._obj, rdata, 405, NULL, &tdata)
if status != 0:
raise PJSIPError("Could not create response", status)
if tdata != NULL:
status = pjsip_endpt_send_response2(self._pjsip_endpoint._obj, rdata, tdata, NULL, NULL)
if status != 0:
pjsip_tx_data_dec_ref(tdata)
raise PJSIPError("Could not send response", status)
return 1
cdef class PJSIPThread:
def __cinit__(self):
cdef object thread_name = "python_%d" % id(self)
cdef int status
status = pj_thread_register(thread_name, self._thread_desc, &self._obj)
if status != 0:
raise PJSIPError("Error while registering thread", status)
# callback functions
cdef void _cb_audio_dev_process_event(pjmedia_aud_dev_event event) with gil:
cdef PJSIPUA ua
event_dict = dict()
try:
ua = _get_ua()
except:
return
try:
if event in (PJMEDIA_AUD_DEV_DEFAULT_INPUT_CHANGED, PJMEDIA_AUD_DEV_DEFAULT_OUTPUT_CHANGED):
event_dict["changed_input"] = event == PJMEDIA_AUD_DEV_DEFAULT_INPUT_CHANGED
event_dict["changed_output"] = event == PJMEDIA_AUD_DEV_DEFAULT_OUTPUT_CHANGED
_add_event("DefaultAudioDeviceDidChange", event_dict)
elif event == PJMEDIA_AUD_DEV_LIST_WILL_REFRESH:
ua.old_devices = ua.sound_devices
with nogil:
status = pj_rwmutex_lock_write(ua.audio_change_rwlock)
if status != 0:
raise SIPCoreError('Could not acquire audio_change_rwlock for writing', status)
elif event == PJMEDIA_AUD_DEV_LIST_DID_REFRESH:
with nogil:
status = pj_rwmutex_unlock_write(ua.audio_change_rwlock)
if status != 0:
raise SIPCoreError('Could not release the audio_change_rwlock', status)
event_dict["old_devices"] = ua.old_devices
event_dict["new_devices"] = ua.sound_devices
_add_event("AudioDevicesDidChange", event_dict)
except:
ua._handle_exception(1)
cdef void _cb_detect_nat_type(void *user_data, pj_stun_nat_detect_result_ptr_const res) with gil:
cdef PJSIPUA ua
cdef dict event_dict
cdef object user_data_obj = <object> user_data
Py_DECREF(user_data_obj)
try:
ua = _get_ua()
except:
return
try:
event_dict = dict()
event_dict["succeeded"] = res.status == 0
event_dict["user_data"] = user_data_obj
if res.status == 0:
event_dict["nat_type"] = res.nat_type_name
else:
event_dict["error"] = res.status_text
_add_event("SIPEngineDetectedNATType", event_dict)
except:
ua._handle_exception(0)
cdef int _PJSIPUA_cb_rx_request(pjsip_rx_data *rdata) with gil:
cdef PJSIPUA ua
try:
ua = _get_ua()
except:
return 0
try:
return ua._cb_rx_request(rdata)
except:
ua._handle_exception(0)
cdef int _cb_opus_fix_tx(pjsip_tx_data *tdata) with gil:
cdef PJSIPUA ua
cdef pjsip_msg_body *body
cdef pjsip_msg_body *new_body
cdef pjmedia_sdp_session *sdp
cdef pjmedia_sdp_media *media
cdef pjmedia_sdp_attr *attr
cdef int i
cdef int j
cdef pj_str_t new_value
try:
ua = _get_ua()
except:
return 0
try:
if tdata != NULL and tdata.msg != NULL:
body = tdata.msg.body
if body != NULL and _pj_str_to_str(body.content_type.type).lower() == "application" and _pj_str_to_str(body.content_type.subtype).lower() == "sdp":
new_body = pjsip_msg_body_clone(tdata.pool, body)
sdp = <pjmedia_sdp_session *> new_body.data
for i in range(sdp.media_count):
media = sdp.media[i]
if _pj_str_to_str(media.desc.media).lower() != "audio":
continue
for j in range(media.attr_count):
attr = media.attr[j]
if _pj_str_to_str(attr.name).lower() != "rtpmap":
continue
attr_value = _pj_str_to_str(attr.value).lower()
pos = attr_value.find("opus")
if pos == -1:
continue
# this is the opus rtpmap attribute
opus_line = attr_value[:pos] + "opus/48000/2"
new_value.slen = len(opus_line)
new_value.ptr = <char *> pj_pool_alloc(tdata.pool, new_value.slen)
memcpy(new_value.ptr, PyString_AsString(opus_line), new_value.slen)
attr.value = new_value
break
tdata.msg.body = new_body
except:
ua._handle_exception(0)
return 0
cdef int _cb_opus_fix_rx(pjsip_rx_data *rdata) with gil:
cdef PJSIPUA ua
cdef pjsip_msg_body *body
cdef int pos1
cdef int pos2
cdef char *body_ptr
try:
ua = _get_ua()
except:
return 0
try:
if rdata != NULL and rdata.msg_info.msg != NULL:
body = rdata.msg_info.msg.body
if body != NULL and _pj_str_to_str(body.content_type.type).lower() == "application" and _pj_str_to_str(body.content_type.subtype).lower() == "sdp":
body_ptr = <char*>body.data
body_str = PyString_FromStringAndSize(body_ptr, body.len).lower()
pos1 = body_str.find("opus/48000")
if pos1 != -1:
pos2 = body_str.find("opus/48000/2")
if pos2 != -1:
memcpy(body_ptr + pos2 + 11, '1', 1)
else:
# old opus, we must make it fail
memcpy(body_ptr + pos1 + 5, 'XXXXX', 5)
except:
ua._handle_exception(0)
return 0
cdef int _cb_trace_rx(pjsip_rx_data *rdata) with gil:
cdef PJSIPUA ua
try:
ua = _get_ua()
except:
return 0
try:
if ua._trace_sip:
_add_event("SIPEngineSIPTrace",
dict(received=True, source_ip=rdata.pkt_info.src_name, source_port=rdata.pkt_info.src_port,
destination_ip=_pj_str_to_str(rdata.tp_info.transport.local_name.host),
destination_port=rdata.tp_info.transport.local_name.port,
data=PyString_FromStringAndSize(rdata.pkt_info.packet, rdata.pkt_info.len),
transport=rdata.tp_info.transport.type_name))
except:
ua._handle_exception(0)
return 0
cdef int _cb_trace_tx(pjsip_tx_data *tdata) with gil:
cdef PJSIPUA ua
try:
ua = _get_ua()
except:
return 0
try:
if ua._trace_sip:
_add_event("SIPEngineSIPTrace",
dict(received=False,
source_ip=_pj_str_to_str(tdata.tp_info.transport.local_name.host),
source_port=tdata.tp_info.transport.local_name.port, destination_ip=tdata.tp_info.dst_name,
destination_port=tdata.tp_info.dst_port,
data=PyString_FromStringAndSize(tdata.buf.start, tdata.buf.cur - tdata.buf.start),
transport=tdata.tp_info.transport.type_name))
except:
ua._handle_exception(0)
return 0
cdef int _cb_add_user_agent_hdr(pjsip_tx_data *tdata) with gil:
cdef PJSIPUA ua
cdef pjsip_hdr *hdr
cdef void *found_hdr
try:
ua = _get_ua()
except:
return 0
try:
found_hdr = pjsip_msg_find_hdr_by_name(tdata.msg, &_user_agent_hdr_name.pj_str, NULL)
if found_hdr == NULL:
hdr = <pjsip_hdr *> pjsip_generic_string_hdr_create(tdata.pool, &_user_agent_hdr_name.pj_str,
&ua._user_agent.pj_str)
if hdr == NULL:
raise SIPCoreError('Could not add "User-Agent" header to outgoing request')
pjsip_msg_add_hdr(tdata.msg, hdr)
except:
ua._handle_exception(0)
return 0
cdef int _cb_add_server_hdr(pjsip_tx_data *tdata) with gil:
cdef PJSIPUA ua
cdef pjsip_hdr *hdr
cdef void *found_hdr
try:
ua = _get_ua()
except:
return 0
try:
found_hdr = pjsip_msg_find_hdr_by_name(tdata.msg, &_server_hdr_name.pj_str, NULL)
if found_hdr == NULL:
hdr = <pjsip_hdr *> pjsip_generic_string_hdr_create(tdata.pool, &_server_hdr_name.pj_str,
&ua._user_agent.pj_str)
if hdr == NULL:
raise SIPCoreError('Could not add "Server" header to outgoing response')
pjsip_msg_add_hdr(tdata.msg, hdr)
except:
ua._handle_exception(0)
return 0
# functions
cdef PJSIPUA _get_ua():
global _ua
cdef PJSIPUA ua
if _ua == NULL:
raise SIPCoreError("PJSIPUA is not instantiated")
ua = <object> _ua
ua._check_thread()
return ua
cdef int deallocate_weakref(object weak_ref, object timer) except -1 with gil:
Py_DECREF(weak_ref)
# globals
cdef void *_ua = NULL
cdef PJSTR _user_agent_hdr_name = PJSTR("User-Agent")
cdef PJSTR _server_hdr_name = PJSTR("Server")
cdef PJSTR _event_hdr_name = PJSTR("Event")
cdef object _re_ipv4 = re.compile(r"^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$")
diff --git a/sipsimple/core/_engine.py b/sipsimple/core/_engine.py
index 5ed2bca0..9c667f34 100644
--- a/sipsimple/core/_engine.py
+++ b/sipsimple/core/_engine.py
@@ -1,132 +1,132 @@
# Copyright (C) 2008-2011 AG Projects. See LICENSE for details.
#
"""
Implements a mechanism for starting the SIP core engine based on PJSIP
(http://pjsip.org) stack.
"""
__all__ = ["Engine"]
import sys
import traceback
import atexit
from application.notification import NotificationCenter, NotificationData
from application.python.types import Singleton
from threading import Thread, RLock
from sipsimple.core._core import PJSIPUA, PJ_VERSION, PJ_SVN_REVISION, SIPCoreError
from sipsimple import __version__
class Engine(Thread):
__metaclass__ = Singleton
default_start_options = {"ip_address": None,
"udp_port": 0,
"tcp_port": None,
"tls_port": None,
"tls_verify_server": False,
"tls_ca_file": None,
"tls_cert_file": None,
"tls_privkey_file": None,
"tls_timeout": 3000,
"user_agent": "sipsimple-%s-pjsip-%s-r%s" % (__version__, PJ_VERSION, PJ_SVN_REVISION),
"log_level": 0,
"trace_sip": False,
"detect_sip_loops": True,
"rtp_port_range": (50000, 50500),
"zrtp_cache": None,
"codecs": ["G722", "speex", "PCMU", "PCMA"],
- "video_codecs": ["H264", "H263-1998"],
+ "video_codecs": ["H264", "H263-1998", "VP8"],
"enable_colorbar_device": False,
"events": {"conference": ["application/conference-info+xml"],
"message-summary": ["application/simple-message-summary"],
"presence": ["multipart/related", "application/rlmi+xml", "application/pidf+xml"],
"presence.winfo": ["application/watcherinfo+xml"],
"dialog": ["multipart/related", "application/rlmi+xml", "application/dialog-info+xml"],
"dialog.winfo": ["application/watcherinfo+xml"],
"refer": ["message/sipfrag;version=2.0"],
"xcap-diff": ["application/xcap-diff+xml"]},
"incoming_events": set(),
"incoming_requests": set()}
def __init__(self):
self.notification_center = NotificationCenter()
self._thread_started = False
self._thread_stopping = False
self._lock = RLock()
self._options = None
atexit.register(self.stop)
super(Engine, self).__init__()
self.daemon = True
@property
def is_running(self):
return (hasattr(self, "_ua") and hasattr(self, "_thread_started")
and self._thread_started and not self._thread_stopping)
def __getattr__(self, attr):
if attr not in ["_ua", "poll"] and hasattr(self, "_ua") and attr in dir(self._ua):
return getattr(self._ua, attr)
raise AttributeError("'%s' object has no attribute '%s'" % (self.__class__.__name__, attr))
def __setattr__(self, attr, value):
if attr not in ["_ua", "poll"] and hasattr(self, "_ua") and attr in dir(self._ua):
setattr(self._ua, attr, value)
return
object.__setattr__(self, attr, value)
def start(self, **kwargs):
with self._lock:
if self._thread_started:
raise SIPCoreError("Worker thread was already started once")
self._options = kwargs
self._thread_started = True
super(Engine, self).start()
def stop(self):
with self._lock:
if self._thread_stopping:
return
if self._thread_started:
self._thread_stopping = True
# worker thread
def run(self):
self.notification_center.post_notification('SIPEngineWillStart', sender=self)
init_options = Engine.default_start_options.copy()
init_options.update(self._options)
try:
self._ua = PJSIPUA(self._handle_event, **init_options)
except Exception:
exc_type, exc_val, exc_tb = sys.exc_info()
exc_tb = "".join(traceback.format_exception(exc_type, exc_val, exc_tb))
self.notification_center.post_notification('SIPEngineGotException', sender=self, data=NotificationData(type=exc_type, value=exc_val, traceback=exc_tb))
self.notification_center.post_notification('SIPEngineDidFail', sender=self)
return
else:
self.notification_center.post_notification('SIPEngineDidStart', sender=self)
failed = False
while not self._thread_stopping:
try:
failed = self._ua.poll()
except:
exc_type, exc_val, exc_tb = sys.exc_info()
self.notification_center.post_notification('SIPEngineGotException', sender=self, data=NotificationData(type=exc_type, value=exc_val, traceback="".join(traceback.format_exception(exc_type, exc_val, exc_tb))))
failed = True
if failed:
self.notification_center.post_notification('SIPEngineDidFail', sender=self)
break
if not failed:
self.notification_center.post_notification('SIPEngineWillEnd', sender=self)
self._ua.dealloc()
del self._ua
self.notification_center.post_notification('SIPEngineDidEnd', sender=self)
def _handle_event(self, event_name, **kwargs):
sender = kwargs.pop("obj", None)
if sender is None:
sender = self
self.notification_center.post_notification(event_name, sender, NotificationData(**kwargs))

File Metadata

Mime Type
text/x-diff
Expires
Sat, Nov 23, 10:20 AM (1 d, 8 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
3409086
Default Alt Text
(237 KB)

Event Timeline