rtpsynth 1.0__tar.gz

rtpsynth-1.0/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2018, Sippy Labs
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

rtpsynth-1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include setup/__init__.py setup/RunCTest.py
+include src/rsth_timeops.h src/rtp.h src/rtp_info.h src/rtpjbuf.h src/rtpsynth.h src/Symbol.map
+include README.md

rtpsynth-1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.1
+Name: rtpsynth
+Version: 1.0
+Summary: Library optimized to generate/process sequence of the RTP packets
+Home-page: https://github.com/sippy/librtpsynth.git
+Author: Maksym Sobolyev
+Author-email: sobomax@gmail.com
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# librtpsynth
+
+Low-level library optimized to generate and/or consume sequence of the RTP
+packets. Based on some code and ideas from the RTPProxy projects.
+
+Originally designed to supplement Python code to do low-level bits shuffling
+for the proof of concept IoT implementation.
+
+Reasonably fast, 100-200x real-time (i.e. 100-200K packets per second) when
+used from the Python code. 100x of that (10-20M PPS) if used from C code
+directly.
+
+## RTP Generation
+
+Generate continuous sequence of RTP packets of the same payload type.
+
+### C API Functions
+
+`#include <rtpsynth.h>`
+
+- `void *rsynth_ctor(int srate, int ptime);`
+  Initializes the RTP synthesizer with given sample rate and packet time.
+  Returns a handle to be used in other calls.
+
+- `void *rsynth_next_pkt(void *ri, int plen, int pt);`
+  Generates the next RTP packet. Takes the handle, packet length, and
+  payload type as parameters. Returns a pointer to the generated packet.
+
+- `int rsynth_next_pkt_pa(void *ri, int plen, int pt, char *buf, unsigned int blen, int pa);`
+  Similar to `rsynth_next_pkt` but allows pre-allocated buffer and packet
+  attributes. Returns the length of the packet generated.
+
+- `void rsynth_pkt_free(void *rnp);`
+  Frees the allocated packet. Takes a pointer to the packet as parameter.
+
+- `void rsynth_dtor(void *ri);`
+  Destroys the RTP synthesizer and frees resources. Takes the handle as
+  parameter.
+
+- `unsigned int rsynth_set_mbt(void *ri, unsigned int new_st);`
+  Sets a new marker bit toggle state. Takes the handle and the new state
+  as parameters. Returns the old state.
+
+- `void rsynth_resync(void *ri, struct rsynth_seq *rsp);`
+  Resynchronizes the RTP packet sequence. Takes the handle and optionally
+  a sequence structure as parameters. Use this function when a time
+  discontinuity is expected in packet generation, such as when VAD (Voice
+  Activity Detection) is active. The library will recalculate the timestamp
+  for the next packet based on the current system clock and the time the
+  last packet was generated.
+
+### RtpGen (Python)
+
+## RTP Parser & Validator / Jitter Buffer
+
+Simple RTP parser and validator to process incoming UDP datagrams,
+parse & validate RTP headers. Resulting RTP stream is passed through
+fixed-size jitter buffer to de-duplicate and re-order packets if
+needed.
+
+### rtpjbuf (c)
+
+### RtpJBuf (Python)

rtpsynth-1.0/README.md

@@ -0,0 +1,63 @@
+# librtpsynth
+
+Low-level library optimized to generate and/or consume sequence of the RTP
+packets. Based on some code and ideas from the RTPProxy projects.
+
+Originally designed to supplement Python code to do low-level bits shuffling
+for the proof of concept IoT implementation.
+
+Reasonably fast, 100-200x real-time (i.e. 100-200K packets per second) when
+used from the Python code. 100x of that (10-20M PPS) if used from C code
+directly.
+
+## RTP Generation
+
+Generate continuous sequence of RTP packets of the same payload type.
+
+### C API Functions
+
+`#include <rtpsynth.h>`
+
+- `void *rsynth_ctor(int srate, int ptime);`
+  Initializes the RTP synthesizer with given sample rate and packet time.
+  Returns a handle to be used in other calls.
+
+- `void *rsynth_next_pkt(void *ri, int plen, int pt);`
+  Generates the next RTP packet. Takes the handle, packet length, and
+  payload type as parameters. Returns a pointer to the generated packet.
+
+- `int rsynth_next_pkt_pa(void *ri, int plen, int pt, char *buf, unsigned int blen, int pa);`
+  Similar to `rsynth_next_pkt` but allows pre-allocated buffer and packet
+  attributes. Returns the length of the packet generated.
+
+- `void rsynth_pkt_free(void *rnp);`
+  Frees the allocated packet. Takes a pointer to the packet as parameter.
+
+- `void rsynth_dtor(void *ri);`
+  Destroys the RTP synthesizer and frees resources. Takes the handle as
+  parameter.
+
+- `unsigned int rsynth_set_mbt(void *ri, unsigned int new_st);`
+  Sets a new marker bit toggle state. Takes the handle and the new state
+  as parameters. Returns the old state.
+
+- `void rsynth_resync(void *ri, struct rsynth_seq *rsp);`
+  Resynchronizes the RTP packet sequence. Takes the handle and optionally
+  a sequence structure as parameters. Use this function when a time
+  discontinuity is expected in packet generation, such as when VAD (Voice
+  Activity Detection) is active. The library will recalculate the timestamp
+  for the next packet based on the current system clock and the time the
+  last packet was generated.
+
+### RtpGen (Python)
+
+## RTP Parser & Validator / Jitter Buffer
+
+Simple RTP parser and validator to process incoming UDP datagrams,
+parse & validate RTP headers. Resulting RTP stream is passed through
+fixed-size jitter buffer to de-duplicate and re-order packets if
+needed.
+
+### rtpjbuf (c)
+
+### RtpJBuf (Python)

rtpsynth-1.0/python/RtpJBuf.py

@@ -0,0 +1,162 @@
+from ctypes import c_void_p, c_int, c_size_t, c_uint32, c_uint16, c_uint64, \
+  POINTER, Union, Structure, create_string_buffer, addressof, string_at, cast
+
+from .RtpSynth import _rsth
+
+class RTPInfo(Structure):
+    _fields_ = [
+        ("data_size", c_size_t),
+        ("data_offset", c_int),
+        ("nsamples", c_int),
+        ("ts", c_uint32),
+        ("seq", c_uint16),
+        ("ssrc", c_uint32),
+        ("appendable", c_int),
+        ("rtp_profile", c_void_p)  # replace with actual type
+    ]
+
+class RTPPacket(Structure):
+    _fields_ = [
+        ("info", RTPInfo),
+        ("lseq", c_uint64),
+        ("data", c_void_p)
+    ]
+
+class ERSFrame(Structure):
+    _fields_ = [
+        ("lseq_start", c_uint64),
+        ("lseq_end", c_uint64),
+        ("ts_diff", c_uint32),
+    ]
+
+class RTPFrameType():
+    RTP = 0
+    ERS = 1
+
+class RTPFrameUnion(Union):
+    _fields_ = [
+        ("rtp", RTPPacket),
+        ("ers", ERSFrame)
+    ]
+
+class RTPFrame(Structure):
+    pass
+
+RTPFrame._fields_ = [
+        ("type", c_int),
+        ("frame", RTPFrameUnion),
+        ("next", POINTER(RTPFrame))
+    ]
+
+class RJBUdpInR(Structure):
+    _fields_ = [
+        ("error", c_int),
+        ("ready", POINTER(RTPFrame)),
+        ("drop", POINTER(RTPFrame)),
+    ]
+
+_rsth.rtpjbuf_ctor.argtypes = [c_int]
+_rsth.rtpjbuf_ctor.restype = c_void_p
+_rsth.rtpjbuf_dtor.argtypes = [c_void_p,]
+_rsth.rtpjbuf_frame_dtor.argtypes = [c_void_p,]
+_rsth.rtpjbuf_udp_in.argtypes = [c_void_p, c_void_p, c_size_t]
+_rsth.rtpjbuf_udp_in.restype = RJBUdpInR
+_rsth.rtpjbuf_flush.argtypes = [c_void_p]
+_rsth.rtpjbuf_flush.restype = RJBUdpInR
+
+class ERSFrame():
+    lseq_start: int
+    lseq_end: int
+    ts_diff: int
+    type = RTPFrameType.ERS
+
+    def __init__(self, content):
+        self.lseq_start = content.frame.ers.lseq_start
+        self.lseq_end = content.frame.ers.lseq_end
+        self.ts_diff = content.frame.ers.ts_diff
+
+class RTPParseError(Exception):
+    pass
+
+class FrameWrapper():
+    _rsth = None
+    content = None
+    data = None
+    rtp_data: bytes
+
+    def __init__(self, _rsth, content: RTPFrame, data):
+        self._rsth = _rsth
+        if content.type == RTPFrameType.ERS:
+            self.content = ERSFrame(content)
+        else:
+            self.content = content
+            rtp_data = cast(content.frame.rtp.data + content.frame.rtp.info.data_offset, c_void_p)
+            self.rtp_data = string_at(rtp_data, content.frame.rtp.info.data_size)
+        self.data = data
+
+    def __del__(self):
+        if self.content.type == RTPFrameType.RTP:
+            self._rsth.rtpjbuf_frame_dtor(addressof(self.content))
+
+    def __str__(self):
+        if self.content.type == RTPFrameType.RTP:
+            return f'RTP_Frame(seq={self.content.frame.rtp.lseq})'
+        return f'RTP_Erasure(seq_range={self.content.lseq_start} ' + \
+          f'-- {self.content.lseq_end})'
+
+    def __repr__(self):
+        return self.__str__()
+
+RTP_PARSER_OK = 1
+
+class RtpJBuf(object):
+    _hndl = None
+    _rsth = None
+    _ref_cache = None
+
+    def __init__(self, capacity):
+        self._rsth = _rsth
+        self._hndl = self._rsth.rtpjbuf_ctor(capacity)
+        if not bool(self._hndl):
+            raise Exception('rtpjbuf_ctor() failed')
+        self._ref_cache = {}
+
+    def udp_in(self, data):
+        buffer = create_string_buffer(data)
+        size = len(data)
+        rval = self._rsth.rtpjbuf_udp_in(self._hndl, buffer, size)
+        return self._proc_RJBUdpInR(rval, (buffer, data))
+
+    def _proc_RJBUdpInR(self, rval, bdata = None):
+        if rval.error != 0:
+            if rval.error < RTP_PARSER_OK:
+                raise RTPParseError(f'rtpjbuf_udp_in(): error {rval.error}')
+            raise RuntimeError(f'rtpjbuf_udp_in(): error {rval.error}')
+        if bdata is not None:
+            self._ref_cache[addressof(bdata[0])] = bdata
+        ready = []
+        for i, bucket in enumerate((rval.ready, rval.drop)):
+            while bool(bucket):
+                current = bucket.contents
+                if current.type == RTPFrameType.RTP:
+                    buffer, data = self._ref_cache.pop(current.frame.rtp.data)
+                else:
+                    data = None
+                if i == 0:
+                    ready.append(FrameWrapper(self._rsth, current, data))
+                else:
+                    assert current.type == RTPFrameType.RTP
+                    self._rsth.rtpjbuf_frame_dtor(addressof(current))
+                #print(current.frame.rtp.data, addressof(buffer))
+                bucket = current.next
+        return ready
+
+    def flush(self):
+        rval = self._rsth.rtpjbuf_flush(self._hndl)
+        rval = self._proc_RJBUdpInR(rval)
+        assert len(self._ref_cache.keys()) == 0
+        return rval
+
+    def __del__(self):
+        if bool(self._hndl):
+            self._rsth.rtpjbuf_dtor(self._hndl)

rtpsynth-1.0/python/RtpSynth.py

@@ -0,0 +1,118 @@
+# Copyright (c) 2018 Sippy Software, Inc. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from ctypes import cdll, c_void_p, c_int, create_string_buffer, c_uint
+from math import modf
+import sys, os, site, sysconfig
+
+from .env import RSTH_MOD_NAME
+
+_esuf = sysconfig.get_config_var('EXT_SUFFIX')
+if not _esuf:
+    _esuf = '.so'
+try:
+    import pathlib
+    _ROOT = str(pathlib.Path(__file__).parent.absolute())
+except ImportError:
+    _ROOT = os.path.abspath(os.path.dirname(__file__))
+#print('ROOT: ' + str(_ROOT))
+modloc = site.getsitepackages()
+modloc.insert(0, os.path.join(_ROOT, ".."))
+for p in modloc:
+   try:
+       #print("Trying %s" % os.path.join(p, RSTH_MOD_NAME + _esuf))
+       _rsth = cdll.LoadLibrary(os.path.join(p, RSTH_MOD_NAME + _esuf))
+   except:
+       continue
+   break
+else:
+   _rsth = cdll.LoadLibrary('librtpsynth.so')
+
+_rsth.rsynth_ctor.argtypes = [c_int, c_int]
+_rsth.rsynth_ctor.restype = c_void_p
+_rsth.rsynth_dtor.argtypes = [c_void_p,]
+_rsth.rsynth_next_pkt.restype = c_void_p
+_rsth.rsynth_next_pkt.argtypes = [c_void_p, c_int, c_int]
+_rsth.rsynth_next_pkt_pa.restype = c_int
+_rsth.rsynth_next_pkt_pa.argtypes = [c_void_p, c_int, c_int, c_void_p, c_uint, c_int]
+_rsth.rsynth_set_mbt.argtypes = [c_void_p, c_uint]
+_rsth.rsynth_set_mbt.restype = c_uint
+_rsth.rsynth_resync.argtypes = [c_void_p, c_void_p]
+_rsth.rsynth_skip.argtypes = [c_void_p, c_int]
+
+_rsth.rsynth_pkt_free.argtypes = [c_void_p,]
+
+
+class RtpSynth(object):
+    _hndl = None
+    _rsth = None
+
+    def __init__(self, srate, ptime):
+        self._rsth = _rsth
+        self._hndl = self._rsth.rsynth_ctor(srate, ptime)
+        if not bool(self._hndl):
+            raise Exception('rsynth_ctor() failed')
+
+    def next_pkt(self, plen, pt, pload = None):
+        pktlen = plen + 32
+        if pload != None:
+            pkt = create_string_buffer(pload, pktlen)
+            filled = 1
+        else:
+            pkt = create_string_buffer(pktlen)
+            filled = 0
+        plen = self._rsth.rsynth_next_pkt_pa(self._hndl, plen, pt, pkt, pktlen, filled)
+        return (pkt.raw[:plen])
+
+    def pkt_free(self, pkt):
+        self._rsth.rsynth_pkt_free(pkt)
+
+    def set_mbt(self, mbt):
+        return self._rsth.rsynth_set_mbt(self._hndl, mbt)
+
+    def resync(self):
+        self._rsth.rsynth_resync(self._hndl, None)
+
+    def skip(self, n):
+        self._rsth.rsynth_skip(self._hndl, n)
+
+    def __del__(self):
+        if bool(self._hndl):
+            self._rsth.rsynth_dtor(self._hndl)
+
+if __name__ == '__main__':
+    from time import monotonic
+    i = 0
+    rs = RtpSynth(8000, 30)
+    stime = monotonic()
+    while monotonic() - stime < 5.0:
+        if i % 43 == 0:
+            rs.resync()
+        rp = rs.next_pkt(170, 0)
+        i += 1
+        if i % 4242 == 0:
+            res = rs.set_mbt(1)
+            assert res == 0
+            res = rs.set_mbt(0)
+            assert res == 1
+    del rs

rtpsynth-1.0/python/env.py

@@ -0,0 +1,24 @@
+# Copyright (c) 2023 Sippy Software, Inc. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+RSTH_MOD_NAME = '_rtpsynth'

rtpsynth-1.0/rtpsynth.egg-info/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.1
+Name: rtpsynth
+Version: 1.0
+Summary: Library optimized to generate/process sequence of the RTP packets
+Home-page: https://github.com/sippy/librtpsynth.git
+Author: Maksym Sobolyev
+Author-email: sobomax@gmail.com
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# librtpsynth
+
+Low-level library optimized to generate and/or consume sequence of the RTP
+packets. Based on some code and ideas from the RTPProxy projects.
+
+Originally designed to supplement Python code to do low-level bits shuffling
+for the proof of concept IoT implementation.
+
+Reasonably fast, 100-200x real-time (i.e. 100-200K packets per second) when
+used from the Python code. 100x of that (10-20M PPS) if used from C code
+directly.
+
+## RTP Generation
+
+Generate continuous sequence of RTP packets of the same payload type.
+
+### C API Functions
+
+`#include <rtpsynth.h>`
+
+- `void *rsynth_ctor(int srate, int ptime);`
+  Initializes the RTP synthesizer with given sample rate and packet time.
+  Returns a handle to be used in other calls.
+
+- `void *rsynth_next_pkt(void *ri, int plen, int pt);`
+  Generates the next RTP packet. Takes the handle, packet length, and
+  payload type as parameters. Returns a pointer to the generated packet.
+
+- `int rsynth_next_pkt_pa(void *ri, int plen, int pt, char *buf, unsigned int blen, int pa);`
+  Similar to `rsynth_next_pkt` but allows pre-allocated buffer and packet
+  attributes. Returns the length of the packet generated.
+
+- `void rsynth_pkt_free(void *rnp);`
+  Frees the allocated packet. Takes a pointer to the packet as parameter.
+
+- `void rsynth_dtor(void *ri);`
+  Destroys the RTP synthesizer and frees resources. Takes the handle as
+  parameter.
+
+- `unsigned int rsynth_set_mbt(void *ri, unsigned int new_st);`
+  Sets a new marker bit toggle state. Takes the handle and the new state
+  as parameters. Returns the old state.
+
+- `void rsynth_resync(void *ri, struct rsynth_seq *rsp);`
+  Resynchronizes the RTP packet sequence. Takes the handle and optionally
+  a sequence structure as parameters. Use this function when a time
+  discontinuity is expected in packet generation, such as when VAD (Voice
+  Activity Detection) is active. The library will recalculate the timestamp
+  for the next packet based on the current system clock and the time the
+  last packet was generated.
+
+### RtpGen (Python)
+
+## RTP Parser & Validator / Jitter Buffer
+
+Simple RTP parser and validator to process incoming UDP datagrams,
+parse & validate RTP headers. Resulting RTP stream is passed through
+fixed-size jitter buffer to de-duplicate and re-order packets if
+needed.
+
+### rtpjbuf (c)
+
+### RtpJBuf (Python)

rtpsynth-1.0/rtpsynth.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+python/RtpJBuf.py
+python/RtpSynth.py
+python/__init__.py
+python/env.py
+rtpsynth.egg-info/PKG-INFO
+rtpsynth.egg-info/SOURCES.txt
+rtpsynth.egg-info/dependency_links.txt
+rtpsynth.egg-info/top_level.txt
+setup/RunCTest.py
+setup/__init__.py
+src/Symbol.map
+src/rsth_timeops.h
+src/rtp.c
+src/rtp.h
+src/rtp_info.h
+src/rtpjbuf.c
+src/rtpjbuf.h
+src/rtpsynth.c
+src/rtpsynth.h
+tests/test_jbuf.py

rtpsynth-1.0/rtpsynth.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rtpsynth-1.0/rtpsynth.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+_rtpsynth
+rtpsynth

rtpsynth-1.0/setup/RunCTest.py

@@ -0,0 +1,27 @@
+from distutils.core import Command
+
+class RunCTest(Command):
+    description = "Run C test"
+    user_options = []
+    extra_compile_args = []
+    extra_link_args = []
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+    def run(self):
+        from distutils.ccompiler import new_compiler
+        import distutils.sysconfig as sysconfig
+
+        compiler = new_compiler()
+
+        # Compile and link
+        obj_files = compiler.compile(['src/rtpsynth.c', 'tests/test_synth.c'],
+          extra_preargs=self.extra_compile_args + ['-Isrc',])
+        compiler.link_executable(obj_files, 'build/test_synth', extra_postargs=self.extra_link_args)
+
+        import subprocess
+        subprocess.run(['./build/test_synth'])

rtpsynth-1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rtpsynth-1.0/setup.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+
+import os
+
+from distutils.core import setup
+from distutils.core import Extension
+
+from python.env import RSTH_MOD_NAME
+from setup.RunCTest import RunCTest
+
+rs_srcs = ['src/rtpsynth.c', 'src/rtp.c', 'src/rtpjbuf.c']
+
+extra_compile_args = ['--std=c11', '-Wno-zero-length-array', '-Wall', '-pedantic', '-flto']
+extra_link_args = ['-flto']
+debug_opts = (('-g3', '-O0'))
+nodebug_opts = (('-march=native', '-O3'))
+if False:
+    extra_compile_args.extend(debug_opts)
+    extra_link_args.extend(debug_opts)
+else:
+    extra_compile_args.extend(nodebug_opts)
+    extra_link_args.extend(nodebug_opts)
+
+module1 = Extension(RSTH_MOD_NAME, sources = rs_srcs, \
+    extra_link_args = extra_link_args, \
+    extra_compile_args = extra_compile_args)
+
+RunCTest.extra_link_args = extra_link_args.copy()
+RunCTest.extra_compile_args = extra_compile_args
+
+extra_link_args.append('-Wl,--version-script=src/Symbol.map')
+
+def get_ex_mod():
+    if 'NO_PY_EXT' in os.environ:
+        return None
+    return [module1]
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+kwargs = {'name':'rtpsynth',
+      'version':'1.0',
+      'description':'Library optimized to generate/process sequence of the RTP packets',
+      'long_description': long_description,
+      'long_description_content_type': "text/markdown",
+      'author':'Maksym Sobolyev',
+      'author_email':'sobomax@gmail.com',
+      'url':'https://github.com/sippy/librtpsynth.git',
+      'packages':['rtpsynth',],
+      'package_dir':{'rtpsynth':'python'},
+      'ext_modules': get_ex_mod(),
+      'cmdclass': {'runctest': RunCTest},
+      'classifiers': [
+            'License :: OSI Approved :: BSD License',
+            'Operating System :: POSIX',
+            'Programming Language :: C',
+            'Programming Language :: Python'
+      ]
+     }
+
+if __name__ == '__main__':
+    setup(**kwargs)