sippy 2.2.3__tar.gz → 2.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sippy
-Version: 2.2.3
+Version: 2.3.0
 Summary: RFC3261 SIP Stack and Back-to-Back User Agent (B2BUA)
 Home-page: http://www.b2bua.org/
 Author: Sippy Software, Inc.
@@ -13,6 +13,8 @@ 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
 Dynamic: author

{sippy-2.2.3 → sippy-2.3.0}/requirements.txt

@@ -1,3 +1,5 @@
 ElPeriodic>=1.1
+rtpsynth>=1.3.0
+g722>=1.2.3
 pycryptodome
 websockets

{sippy-2.2.3 → sippy-2.3.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.3.0",
     packages = find_packages(),
 
     install_requires = requirements,
     include_package_data=True,
-    test_suite = 'tests',
 
     entry_points = {
         'console_scripts': [

sippy-2.3.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.3.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.3.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.3.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.3.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.3.0/sippy/Rtp/EPoint.py

@@ -0,0 +1,221 @@
+from typing import Optional, Tuple
+from uuid import uuid4, UUID
+from threading import Lock
+import errno
+
+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
+    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.writer = None
+        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_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.rtp_received, 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.send_pkt)
+        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.send_pkt)
+            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._rtp_server = (None, None)
+        if writer is not None:
+            writer.end()
+            writer.join()
+        with self.state_lock:
+            self.rserv = None
+        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__')
+
+    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)

sippy-2.3.0/sippy/Rtp/Handlers.py

@@ -0,0 +1,14 @@
+from typing import Type, Any
+
+from .OutputWorker import RTPOutputWorker
+from .Ingest import RTPInStream
+from sippy.Udp_server import Udp_server, Udp_server_opts
+from rtpsynth.RtpServer import RtpServer
+
+
+class RTPHandlers():
+    writer_cls: Type[Any] = RTPOutputWorker
+    rtp_instream_cls: Type[Any] = RTPInStream
+    rtp_server_cls: Type[Any] = RtpServer
+    udp_server_cls: Type[Any] = Udp_server
+    udp_server_opts_cls: Type[Any] = Udp_server_opts

sippy-2.3.0/sippy/Rtp/Ingest.py

@@ -0,0 +1,79 @@
+from typing import Optional, Union
+from threading import Lock
+
+from rtpsynth.RtpJBuf import RtpJBuf, RTPFrameType, RTPParseError
+
+from .Codecs.GenCodec import GenCodec
+from .Params import RTPParams
+
+
+class RTPInStream():
+    debug = False
+    out_buffer: bytes = b''
+    ob_rtime: float = 0.0
+    out_chunk_sz_samples: int
+    jb_size: int = 8
+    last_output_lseq: Optional[int] = None
+    codec: GenCodec
+    npkts: int = 0
+    def __init__(self, rtp_params:RTPParams, audio_in:callable):
+        self.jbuf = RtpJBuf(self.jb_size)
+        self.codec = rtp_params.codec()
+        self.codec.out_srate = rtp_params.out_sr
+        self.out_chunk_sz_samples = int(rtp_params.out_sr / 10) # 0.1s
+        self.ring_lock = Lock()
+        self.audio_in = audio_in
+
+    def rtp_received(self, data, address, rtime):
+        #self.dprint(f"RTP.Ingest.rtp_received: len(data) = {len(data)}")
+        with self.ring_lock:
+            self.pkt_proc(data, address, rtime)
+
+    def stream_update(self):
+        with self.ring_lock:
+            self.jbuf = RtpJBuf(self.jb_size)
+            self.last_output_lseq = None
+            return
+
+    def stream_connect(self, audio_in:callable):
+        with self.ring_lock:
+            self.audio_in = audio_in
+
+    def pkt_proc(self, data, address, rtime):
+        try:
+            res = self.jbuf.udp_in(data, rtime)
+        except RTPParseError as e:
+            self.dprint(f"RTPParseError: {e}")
+            return
+        self.npkts += 1
+        if self.npkts == 1:
+            self.dprint(f"address={address}, rtime={rtime}, len(data) = {len(data)} data={data[:40]}")
+        for pkt in res:
+            if pkt.content.type == RTPFrameType.ERS:
+                self.dprint(f"ERS packet received {pkt.content.lseq_start=}, {pkt.content.lseq_end=} {pkt.content.ts_diff=}")
+                self.last_output_lseq = pkt.content.lseq_end
+                rtp_data = self.codec.silence(pkt.content.ts_diff)
+            else:
+                if self.npkts < 10:
+                    self.dprint(f"{pkt.content.frame.rtp.lseq=}")
+                assert self.last_output_lseq is None or pkt.content.frame.rtp.lseq == self.last_output_lseq + 1
+                self.last_output_lseq = pkt.content.frame.rtp.lseq
+                if self.npkts < 10:
+                    self.dprint(f"{len(pkt.rtp_data)=}, {type(pkt.rtp_data)=}")
+                rtp_data = pkt.rtp_data
+                new_rtime = pkt.opaque - self.codec.e2t(len(self.out_buffer))
+                self.ob_rtime = new_rtime
+            self.out_buffer += rtp_data
+        while self.codec.e2d_frames(len(self.out_buffer)) >= self.out_chunk_sz_samples:
+            decode_samples = self.codec.d2e_frames(self.out_chunk_sz_samples)
+            chunk = self.codec.decode(self.out_buffer[:decode_samples])
+            chunk.rtime = self.ob_rtime
+            self.ob_rtime += self.codec.e2t(decode_samples)
+            self.out_buffer = self.out_buffer[decode_samples:]
+            self.audio_in(chunk)
+        if self.npkts < 10 and len(res) > 0:
+            self.dprint(f"{res=}")
+
+    def dprint(self, *args):
+        if self.debug:
+            print(*args)