sippy 2.2.3__tar.gz → 2.4.0__tar.gz

{sippy-2.2.3 → sippy-2.4.0}/MANIFEST.in

@@ -2,3 +2,4 @@ include README.md
 include requirements.txt
 include sippy/dictionary
 recursive-include sippy/UI/static *
+recursive-include sippy/UI/templates *

{sippy-2.2.3/sippy.egg-info → sippy-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sippy
-Version: 2.2.3
+Version: 2.4.0
 Summary: RFC3261 SIP Stack and Back-to-Back User Agent (B2BUA)
 Home-page: http://www.b2bua.org/
 Author: Sippy Software, Inc.
@@ -13,8 +13,12 @@ Classifier: Programming Language :: Python
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ElPeriodic>=1.1
+Requires-Dist: rtpsynth>=1.3.0
+Requires-Dist: g722>=1.2.3
 Requires-Dist: pycryptodome
 Requires-Dist: websockets
+Requires-Dist: flask
+Requires-Dist: flask-login
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

sippy-2.4.0/requirements.txt

@@ -0,0 +1,7 @@
+ElPeriodic>=1.1
+rtpsynth>=1.3.0
+g722>=1.2.3
+pycryptodome
+websockets
+flask
+flask-login

{sippy-2.2.3 → sippy-2.4.0}/setup.py

@@ -1,19 +1,22 @@
 #!/usr/bin/env python
 from setuptools import setup, find_packages
 
-requirements = [x.strip() for x in open("requirements.txt", "r").readlines()]
+requirements = [
+    line.strip()
+    for line in open("requirements.txt", "r", encoding="utf-8").readlines()
+    if line.strip() and not line.lstrip().startswith("#")
+]
 
 with open("README.md", "r") as fh:
     long_description = fh.read()
 
 setup(
     name = "sippy",
-    version = "2.2.3",
+    version = "2.4.0",
     packages = find_packages(),
 
     install_requires = requirements,
     include_package_data=True,
-    test_suite = 'tests',
 
     entry_points = {
         'console_scripts': [

{sippy-2.2.3 → sippy-2.4.0}/sippy/B2B/Route.py

@@ -40,32 +40,69 @@ DST_SIP_UA = 'sip-ua'
 DST_WSS_UA = 'wss-ua'
 
 class B2BRoute(object):
+    crt_set = False
+    params = None
+    extra_headers = None
     rnum = None
+    _ui_cats = {'auth': 'Outbound Digest Authentication', 'net': 'Network', 'lim': 'Limits',
+                      'num': 'Calling / Called Numbers', 'acct': 'Accounting'}
+    _ui_hints = {}
+#    _ui_hints['rnum'] = {'hidden': True}
     addrinfo = None
-    cld = None
-    cld_set = False
-    hostport = None
-    hostonly = None
-    credit_time = None
-    crt_set = False
-    expires = None
-    no_progress_expires = None
-    no_reply_expires = None
-    forward_on_fail = False
-    user = None
-    passw = None
+#    _ui_hints['addrinfo'] = {'readonly': True, 'category': _ui_cats['net'], 'hidden': True}
+    hostonly:str = None
+#    _ui_hints['hostonly'] = {'readonly': True, 'category': _ui_cats['net'], 'hidden': True}
+    ainfo = None
+#    _ui_hints['ainfo'] = {'readonly': True, 'category': _ui_cats['net'], 'hidden': True}
+    hostport:str = None
+    _ui_hints['hostport'] = {'name': 'Destination', 'description': 'Destination host:port',
+                                'category': _ui_cats['net']}
+    user:str = None
+    _ui_hints['user'] = {'name': 'SIP Username', 'category': _ui_cats['auth'],
+                'active': lambda o: not o.pass_auth}
+    passw:str = None
+    _ui_hints['passw'] = {'name': 'SIP Password', 'category': _ui_cats['auth'], 'password': True,
+                 'active': lambda o: not o.pass_auth}
     pass_auth = True
-    cli = None
+    _ui_hints['pass_auth'] = {'name': 'Mode', 'category': _ui_cats['auth'],
+                     'values': {False: 'Normal ("UAC")', True: 'Pass-through ("Proxy")'},}
+    _cld:str = None
+    _ui_hints['cld'] = {'name': 'Called Party (CLD)', 'description': 'Called party number',
+               'category': _ui_cats['num'], 'type': str}
+    cld_set = False
+    _ui_hints['cld_set'] = {'name': 'CLD Mode', 'description': 'Controls outbound CLD',
+                   'category': _ui_cats['num'], 'active': lambda o: not o.cld,
+                   'values': lambda o: {True: 'Erase', False: 'Pass-through'}
+                               if not o.cld else {True: 'Replace'}}
+    _cli:str = None
+    _ui_hints['cli'] = {'name': 'Calling Party (CLI)', 'description': 'Caller number',
+               'category': _ui_cats['num'], 'type': str}
     cli_set = False
-    params = None
-    ainfo = None
-    extra_headers = None
+    _ui_hints['cli_set'] = {'name': 'CLI Mode', 'description': 'Controls outbound CLI', 'category':
+                   _ui_cats['num'], 'active': lambda o: not o.cli,
+                   'values': lambda o: {True: 'Erase', False: 'Pass-through'}
+                               if not o.cli else {True: 'Replace'}}
+    credit_time:float = None
+    _ui_hints['credit_time'] = {'name': 'Credit Time', 'description': 'Allowed call duration, in seconds',
+                                   'category': _ui_cats['lim']}
+    expires:float = None
+    _ui_hints['expires'] = {'name': 'Route Expiry', 'description': 'Time to expire the route, in seconds',
+                               'category': _ui_cats['lim']}
+    no_progress_expires:float = None
+    _ui_hints['no_progress_expires'] = {'name': 'No Progress Timeout', 'category': _ui_cats['lim'],
+      'description': 'Time to expire the route if no 180 or 183 provisional response received, in seconds'}
+    no_reply_expires:float = None
+    _ui_hints['no_reply_expires'] = {'name': 'No Reply Timeout', 'category': _ui_cats['lim'],
+      'description': 'Time to expire the route if no provisional response received, in seconds'}
+    forward_on_fail = False
+    _ui_hints['forward_on_fail'] = {'name': 'Failed Calls', 'category': _ui_cats['acct'],
+                           'description': 'Emit accounting on SIP failures'}
 
     def __init__(self, sroute = None, cself = None):
         if cself != None:
             self.rnum = cself.rnum
             self.addrinfo = cself.addrinfo
-            self.cld = cself.cld
+            self._cld = cself.cld
             self.cld_set = cself.cld_set
             self.hostport = cself.hostport
             self.hostonly = cself.hostonly
@@ -78,7 +115,7 @@ class B2BRoute(object):
             self.user = cself.user
             self.passw = cself.passw
             self.pass_auth = cself.pass_auth
-            self.cli = cself.cli
+            self._cli = cself.cli
             self.cli_set = cself.cli_set
             self.params = dict(cself.params)
             self.ainfo = cself.ainfo
@@ -93,7 +130,6 @@ class B2BRoute(object):
                 # as opposed to the Routing:host, which means that CLD should be obtained
                 # from the incoming call leg.
                 self.cld = None
-            self.cld_set = True
         else:
             self.hostport = route[0]
         if not self.hostport.startswith('['):
@@ -147,7 +183,6 @@ class B2BRoute(object):
                 self.cli = v
                 if len(self.cli) == 0:
                     self.cli = None
-                self.cli_set = True
             elif a == 'cnam':
                 caller_name = unquote(v)
                 if len(caller_name) == 0:
@@ -175,9 +210,9 @@ class B2BRoute(object):
       pass_headers, max_credit_time):
         self.rnum = rnum
         if not self.cld_set:
-            self.cld = default_cld
+            self._cld = default_cld
         if not self.cli_set:
-            self.cli = default_cli
+            self._cli = default_cli
         if not self.crt_set:
             self.crt_set = default_credit_time
         if 'gt' in self.params:
@@ -210,3 +245,21 @@ class B2BRoute(object):
         if af == AF_INET6:
             return ((('[%s]' % amatch[0], amatch[1]), same_af))
         return (((amatch[0], amatch[1]), same_af))
+
+    @property
+    def cli(self):
+        return self._cli
+
+    @cli.setter
+    def cli(self, value):
+        self._cli = value
+        self.cli_set = True
+
+    @property
+    def cld(self):
+        return self._cld
+
+    @cld.setter
+    def cld(self, value):
+        self._cld = value
+        self.cld_set = True

{sippy-2.2.3 → sippy-2.4.0}/sippy/B2B/SimpleAPI.py

@@ -116,10 +116,11 @@ class B2BSimpleAPI(CLIConnectionManager):
             clim.send('OK\n')
             return False
         if cmd == 'r':
-            if len(args) != 1:
-                clim.send('ERROR: syntax error: r [<id>]\n')
+            if len(args) not in (1, 2):
+                clim.send('ERROR: syntax error: r <id> [<media-index>]\n')
                 return False
             idx = int(args[0])
+            media_index = int(args[1]) if len(args) == 2 else 0
             dlist = [x for x in ccm.ccmap if x.id == idx]
             if len(dlist) == 0:
                 clim.send('ERROR: no call with id of %d has been found\n' % idx)
@@ -128,9 +129,12 @@ class B2BSimpleAPI(CLIConnectionManager):
                 if not cc.proxied:
                     continue
                 if cc.state == CCStateConnected:
-                    cc.disconnect(MonoTime().getOffsetCopy(-60), origin = 'media_timeout')
+                    cc.disconnect(MonoTime().getOffsetCopy(-60), origin = 'media_timeout',
+                      media_index = media_index)
                     continue
                 if cc.state == CCStateARComplete:
+                    if cc.rtp_proxy_session is not None:
+                        cc.rtp_proxy_session.media_timeout_index = media_index
                     cc.uaO.disconnect(MonoTime().getOffsetCopy(-60), origin = 'media_timeout')
                     continue
             clim.send('OK\n')

{sippy-2.2.3 → sippy-2.4.0}/sippy/MyConfigParser.py

@@ -104,9 +104,13 @@ SUPPORTED_OPTIONS = { \
                              '"host:port:cert_file:key_file", where "cert_file" ' \
                              '/ "key_file" are paths to the TLS certificate ' \
                              'and key file respectively in the X.509 PEM format'),
- 'pre_auth_proc': ('S', 'internal routine to be executed before authentication '\
-                        'is being processed. E.g. "HDR2Xattrs[X-foo-hdr]."'), \
- 'xmpp_b2bua_id':     ('I', 'ID passed to the XMPP socket server')}
+ 'pre_auth_proc':     ('S', 'internal routine to be executed before authentication '\
+                             'is being processed. E.g. "HDR2Xattrs[X-foo-hdr]."'), \
+ 'xmpp_b2bua_id':     ('I', 'ID passed to the XMPP socket server'), \
+ 'ui':                ('B', 'enable Web management UI'), \
+ 'uiparams':          ('S', 'Semicolon-separated list of UI parameters corresponding to ' \
+                             'the flask\'s run() routine'), \
+}
 
 class MyConfigParser(RawConfigParser):
     _default_section = None

sippy-2.4.0/sippy/Rtp/Codecs/G711.py

@@ -0,0 +1,42 @@
+from array import array
+
+from rtpsynth.RtpUtils import linear2ulaw, ulaw2linear
+
+from ..Core.AudioChunk import AudioChunk, pcm16_from
+from .GenCodec import GenCodec
+
+class G711Codec(GenCodec):
+    ptype = 0 # G.711u
+    ename = 'PCMU'
+    chunk_cls = AudioChunk
+
+    def encode(self, chunk):
+        pcm16 = pcm16_from(chunk.audio)
+        return linear2ulaw(pcm16)
+
+    def make_chunk(self, pcm16: array, srate: int):
+        return self.chunk_cls(pcm16, srate)
+
+    def decode(self, ulaw_bytes:bytes, resample:bool=True, sample_rate:int=None):
+        pcm16 = ulaw2linear(ulaw_bytes)
+        if sample_rate is None:
+            sample_rate = self.out_srate
+        chunk = self.make_chunk(pcm16, self.srate)
+        if resample and sample_rate != self.srate:
+            chunk.resample(sample_rate)
+        return chunk
+
+    def e2d_frames(self, enframes:int, out_srate:int=None):
+        if out_srate is None:
+            out_srate = self.out_srate
+        assert out_srate % self.srate == 0
+        return enframes * out_srate // self.srate
+
+    def d2e_frames(self, dnframes:int, in_srate:int=None):
+        if in_srate is None:
+            in_srate = self.out_srate
+        assert in_srate % self.srate == 0
+        return dnframes * self.srate // in_srate
+
+    def silence(self, nframes:int):
+        return b'\xff' * nframes

sippy-2.4.0/sippy/Rtp/Codecs/G722.py

@@ -0,0 +1,53 @@
+from array import array
+
+from G722 import G722
+
+from ..Core.AudioChunk import AudioChunk, pcm16_from
+from .GenCodec import GenCodec
+
+class G722Codec(GenCodec):
+    codec:G722
+    srate:int = 8000
+    default_br:int = 64000
+    ptype:int = 9 # G.722
+    ename:str = 'G722' # encoding name
+    chunk_cls = AudioChunk
+
+    def __init__(self):
+        super().__init__()
+        self.codec = G722(self.srate, self.default_br, use_numpy=False)
+
+    def encode(self, chunk):
+        pcm16 = pcm16_from(chunk.audio)
+        return self.codec.encode(pcm16)
+
+    def make_chunk(self, pcm16: array, srate: int):
+        return self.chunk_cls(pcm16, srate)
+
+    def decode(self, audio_enc:bytes, resample:bool=True, sample_rate:int=None):
+        pcm16 = array('h', self.codec.decode(audio_enc))
+        if sample_rate is None:
+            sample_rate = self.out_srate
+        chunk = self.make_chunk(pcm16, self.srate)
+        if resample and sample_rate != self.srate:
+            chunk.resample(sample_rate)
+        return chunk
+
+    def silence(self, nframes:int):
+        pcm16 = array('h', [0]) * self.e2d_frames(nframes)
+        return self.encode(pcm16)
+
+    def e2d_frames(self, enframes:int, out_srate:int=None):
+        #assert out_srate % self.srate == 0
+        if out_srate is None:
+            out_srate = self.out_srate
+        return enframes * (1 if self.srate == 8000 else 2) * out_srate // self.srate
+
+    def d2e_frames(self, dnframes:int, in_srate:int=None):
+        #assert in_srate % self.srate == 0
+        if in_srate is None:
+            in_srate = self.out_srate
+        return dnframes * self.srate // ((1 if self.srate == 8000 else 2) * in_srate)
+
+    def e2t(self, frames:int) -> float:
+        return (frames * 8) / self.default_br

sippy-2.4.0/sippy/Rtp/Codecs/GenCodec.py

@@ -0,0 +1,18 @@
+class GenCodec():
+    srate:int = 8000 # sample rate
+    out_srate:int    # sample rate (output)
+    crate:int = 8000 # clock rate
+    ptype:int        # payload type
+    ename:str        # encoding name
+
+    def __init__(self):
+        assert self.ptype is not None and self.ename is not None
+        self.out_srate = self.srate
+
+    @classmethod
+    def rtpmap(cls):
+        assert all(hasattr(cls, attr) for attr in ('ptype', 'ename'))
+        return f'rtpmap:{cls.ptype} {cls.ename}/{cls.crate}'
+
+    def e2t(self, frames:int) -> float:
+        return frames / self.srate

sippy-2.4.0/sippy/Rtp/Conf.py

@@ -0,0 +1,8 @@
+from typing import Optional
+
+from sippy.Network_server import RTP_port_allocator
+
+class RTPConf():
+    palloc: RTP_port_allocator
+    def __init__(self, min_port=None, max_port=None):
+        self.palloc = RTP_port_allocator(min_port, max_port)

sippy-2.4.0/sippy/Rtp/Core/AudioChunk.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from array import array
+from typing import Union
+import sys
+
+from rtpsynth.RtpUtils import resample_linear
+
+PCM16Like = Union[array, bytes, bytearray, memoryview]
+
+def pcm16_from(data: PCM16Like) -> array:
+    if isinstance(data, array):
+        if data.typecode != 'h':
+            raise TypeError("PCM16 array must have typecode 'h'")
+        return data
+    else:
+        mv = memoryview(data)
+        if mv.format != 'h':
+            mv = mv.cast('h')
+        pcm = array('h', mv)
+        if sys.byteorder == 'big':
+            pcm.byteswap()
+        return pcm
+
+def pcm16_to_bytes(pcm: array) -> bytes:
+    if sys.byteorder == 'big':
+        pcm = array('h', pcm)
+        pcm.byteswap()
+    return pcm.tobytes()
+
+class AudioChunk():
+    debug: bool = False
+    samplerate: int
+    audio: array
+    rtime: float | None = None
+    def __init__(self, audio: PCM16Like, samplerate:int):
+        self.audio = pcm16_from(audio)
+        self.samplerate = samplerate
+
+    def resample(self, sample_rate:int):
+        assert sample_rate != self.samplerate
+        self.audio = resample_linear(self.audio, self.samplerate, sample_rate)
+        self.samplerate = sample_rate
+        return self
+
+    def duration(self):
+        return len(self.audio) / self.samplerate
+
+    def to_bytes(self) -> bytes:
+        return pcm16_to_bytes(self.audio)
+
+    @property
+    def nframes(self) -> int:
+        return len(self.audio)

sippy-2.4.0/sippy/Rtp/EPoint.py

@@ -0,0 +1,244 @@
+from typing import Optional, Tuple
+from uuid import uuid4, UUID
+from threading import Lock
+import errno
+import weakref
+
+from rtpsynth.RtpServer import RtpQueueFullError, RtpServer
+from sippy.Time.MonoTime import MonoTime
+
+from .Core.AudioChunk import AudioChunk
+from .Handlers import RTPHandlers
+from .Params import RTPParams
+from .Conf import RTPConf
+from .Singletons import acquire_rtp_server, release_rtp_server
+
+class RTPEPoint():
+    debug: bool = False
+    id: UUID
+    dl_file = None
+    firstframe = True
+    writer = None
+    rserv = None
+    rtp_params:RTPParams
+    state_lock: Lock
+    handlers: RTPHandlers
+    _rtp_server: Optional[RtpServer]
+    def __init__(self, rc:RTPConf, rtp_params:RTPParams, audio_in:callable,
+                 handlers:RTPHandlers=None):
+        self.id = uuid4()
+        self.rtp_params = rtp_params
+        self.handlers = handlers or RTPHandlers()
+        self._palloc = rc.palloc
+        self._rtp_server = None
+        self.state_lock = Lock()
+        self.rsess = self.make_rtp_instream(rtp_params, audio_in)
+        rserv_opts = self.make_udp_server_opts(rtp_params)
+        self.rserv = self.make_udp_server(rserv_opts)
+        if self.rtp_params.rtp_target is not None:
+            self.writer_setup()
+
+    def make_writer(self, rtp_params:RTPParams):
+        return self.handlers.writer_cls(rtp_params)
+
+    def make_rtp_instream(self, rtp_params:RTPParams, audio_in:callable):
+        return self.handlers.rtp_instream_cls(rtp_params, audio_in)
+
+    def make_udp_server_opts(self, rtp_params:RTPParams):
+        palloc = self._palloc if rtp_params.rtp_lport == 0 else rtp_params.rtp_lport
+        return (rtp_params.rtp_laddr, palloc)
+
+    def _make_rtp_received_cb(self):
+        self_ref = weakref.ref(self)
+
+        def rtp_received_cb(data, address, rtime_ns=None):
+            self = self_ref()
+            if self is None:
+                return
+            return self.rtp_received(data, address, rtime_ns)
+
+        return rtp_received_cb
+
+    def _make_send_pkt_cb(self):
+        self_ref = weakref.ref(self)
+
+        def send_pkt_cb(pkt):
+            self = self_ref()
+            if self is None:
+                return
+            return self.send_pkt(pkt)
+
+        return send_pkt_cb
+
+    def make_udp_server(self, rserv_opts):
+        rtp_laddr, palloc = rserv_opts
+        server_cls = self.handlers.rtp_server_cls
+        rtp_server = acquire_rtp_server(server_cls)
+        channel = None
+        self._rtp_server = rtp_server
+        try:
+            channel = self._bind_channel(rtp_server, rtp_laddr, palloc)
+            target = self.rtp_params.rtp_target
+            if target is not None:
+                channel.set_target(target[0], target[1])
+            return channel
+        except Exception:
+            release_rtp_server(rtp_server)
+            self._rtp_server = None
+            if channel is not None:
+                channel.close()
+            raise
+
+    def _create_channel(self, rtp_server:RtpServer, bind_host:str, bind_port:int):
+        bind_family = self.rtp_params.rtp_family
+        ch_kwargs = dict(pkt_in=self._make_rtp_received_cb(), bind_host=bind_host, bind_port=bind_port)
+        ch = rtp_server.create_channel(bind_family=bind_family, **ch_kwargs)
+        self.rtp_params.rtp_lport = bind_port
+        return ch
+
+    def _bind_channel(self, rtp_server:RtpServer, rtp_laddr:str, palloc, preferred_port:int=None):
+        if preferred_port is not None:
+            try:
+                return self._create_channel(rtp_server, rtp_laddr, preferred_port)
+            except OSError as ex:
+                if ex.errno != errno.EADDRINUSE:
+                    raise
+        if callable(palloc):
+            ntry = -1
+            while True:
+                ntry += 1
+                bind_port = int(palloc(ntry))
+                try:
+                    return self._create_channel(rtp_server, rtp_laddr, bind_port)
+                except OSError as ex:
+                    if ex.errno == errno.EADDRINUSE:
+                        continue
+                    raise
+        return self._create_channel(rtp_server, rtp_laddr, int(palloc))
+
+    def _swap_channel(self, old_channel, rtp_params:RTPParams):
+        with self.state_lock:
+            rtp_server = self._rtp_server
+            if rtp_server is None or self.rserv is not old_channel:
+                return
+        rtp_laddr, palloc = self.make_udp_server_opts(rtp_params)
+        preferred_port = old_channel.local_addr[1]
+        new_channel = self._bind_channel(rtp_server, rtp_laddr, palloc, preferred_port=preferred_port)
+        target = rtp_params.rtp_target
+        if target is not None:
+            new_channel.set_target(target[0], target[1])
+        with self.state_lock:
+            if self._rtp_server is None or self.rserv is not old_channel:
+                new_channel.close()
+                return
+            self.rserv = new_channel
+        old_channel.close()
+
+    def writer_setup(self):
+        assert self.writer is None
+        writer = self.make_writer(self.rtp_params)
+        writer.set_pkt_send_f(self._make_send_pkt_cb())
+        if self.dl_file is not None:
+            writer.enable_datalog(self.dl_file)
+        writer.start()
+        self.writer = writer
+
+    def send_pkt(self, pkt):
+        with self.state_lock:
+            channel = self.rserv
+        assert channel is not None
+        try:
+            channel.send_pkt(pkt)
+        except RtpQueueFullError:
+            return
+
+    def rtp_received(self, data, address, rtime_ns=None):
+        #self.dprint(f"RTP.Ingest.rtp_received: len(data) = {len(data)}")
+        if rtime_ns is None:
+            rtime = MonoTime().monot
+        else:
+            rtime = rtime_ns / 1_000_000_000.0
+        with self.state_lock:
+            target = self.rtp_params.rtp_target
+            if target is not None and address != target:
+                if self.debug:
+                    print(f"InfernRTPIngest.rtp_received: address mismatch {address=} {self.rtp_params.rtp_target=}")
+                return
+        self.rsess.rtp_received(data, address, rtime)
+
+    def update(self, rtp_params:RTPParams):
+        old_writer = None
+        need_new_writer = False
+        target_changed = False
+        proto_changed = False
+        with self.state_lock:
+            target_changed = self.rtp_params.rtp_target != rtp_params.rtp_target
+            proto_changed = self.rtp_params.rtp_proto != rtp_params.rtp_proto
+            self.rtp_params.rtp_proto = rtp_params.rtp_proto
+            self.rtp_params.rtp_target = rtp_params.rtp_target
+            ptime_changed = self.rtp_params.out_ptime != rtp_params.out_ptime
+            self.rtp_params.out_ptime = rtp_params.out_ptime
+            self.rtp_params.out_sr = rtp_params.out_sr
+            self.rtp_params.codec = rtp_params.codec
+            channel = self.rserv
+            if self.rtp_params.rtp_target is None:
+                old_writer = self.writer
+                self.writer = None
+            elif self.writer is None:
+                need_new_writer = True
+            elif ptime_changed or proto_changed:
+                old_writer = self.writer
+                self.writer = None
+                need_new_writer = True
+        if old_writer is not None:
+            old_writer.end()
+            old_writer.join()
+        if proto_changed and channel is not None:
+            self._swap_channel(channel, rtp_params)
+        elif target_changed and channel is not None and self.rtp_params.rtp_target is not None:
+            target = self.rtp_params.rtp_target
+            channel.set_target(target[0], target[1])
+        if need_new_writer:
+            new_writer = self.make_writer(rtp_params)
+            new_writer.set_pkt_send_f(self._make_send_pkt_cb())
+            if self.dl_file is not None:
+                new_writer.enable_datalog(self.dl_file)
+            new_writer.start()
+            with self.state_lock:
+                if self.rserv is None or self.rtp_params.rtp_target is None:
+                    # RTP endpoint has been shut down while swapping writer.
+                    new_writer.end()
+                    new_writer.join()
+                else:
+                    self.writer = new_writer
+        self.rsess.stream_update()
+
+    def connect(self, ain:callable):
+        self.rsess.stream_connect(ain)
+
+    def shutdown(self):
+        with self.state_lock:
+            writer, channel, rtp_server = self.writer, self.rserv, self._rtp_server
+            self.writer, self.rserv, self._rtp_server = (None, None, None)
+        if writer is not None:
+            writer.end()
+            writer.join()
+        if channel is not None:
+            channel.close()
+        if rtp_server is not None:
+            release_rtp_server(rtp_server)
+
+    def __del__(self):
+        if self.debug:
+            print('RTP.EPoint.__del__')
+        self.shutdown()
+
+    def soundout(self, chunk:AudioChunk):
+        if self.firstframe:
+            if self.debug:
+                nframes = chunk.nframes if hasattr(chunk, 'nframes') else len(chunk.audio)
+                print(f'RTP.EPoint.soundout[{str(self.id)[:6]}]: {nframes}')
+            self.firstframe = False
+        with self.state_lock:
+            if self.writer is None: return
+            return self.writer.soundout(chunk)