silk-python 0.2.7__cp313-cp313-win32.whl

pysilk/backends/cython/_silk.pyi

@@ -0,0 +1,27 @@
+from typing import Any, BinaryIO
+
+class SilkError(Exception):
+    def __init__(self, code) -> Any: ...
+
+def encode(
+    input: BinaryIO,
+    output: BinaryIO,
+    sample_rate: int,
+    bit_rate: int,
+    max_internal_sample_rate: int = 24000,
+    packet_loss_percentage: int = 0,
+    complexity: int = 2,
+    use_inband_fec: bool = False,
+    use_dtx: bool = False,
+    tencent: bool = True,
+) -> bytes: ...
+def decode(
+    input: BinaryIO,
+    output: BinaryIO,
+    sample_rate: int,
+    frame_size: int = 0,
+    frames_per_packet: int = 1,
+    more_internal_decoder_frames: bool = False,
+    in_band_fec_offset: int = 0,
+    loss: bool = False,
+) -> bytes: ...

pysilk/backends/cython/_silk.pyx

@@ -0,0 +1,275 @@
+# cython: language_level=3
+# cython: cdivision=True
+from cpython.bytes cimport (PyBytes_AS_STRING, PyBytes_Check,
+                            PyBytes_FromStringAndSize, PyBytes_Size)
+from cpython.mem cimport PyMem_Free, PyMem_Malloc
+from cpython.object cimport PyObject, PyObject_HasAttrString
+from libc.stdint cimport int16_t, int32_t, uint8_t
+
+from pysilk.backends.cython.silk cimport (SHOULD_SWAP,
+                                          SKP_SILK_SDK_DecControlStruct,
+                                          SKP_Silk_SDK_Decode,
+                                          SKP_SILK_SDK_EncControlStruct,
+                                          SKP_Silk_SDK_Encode,
+                                          SKP_Silk_SDK_Get_Decoder_Size,
+                                          SKP_Silk_SDK_Get_Encoder_Size,
+                                          SKP_Silk_SDK_InitDecoder,
+                                          SKP_Silk_SDK_InitEncoder, swap_i16)
+
+
+class SilkError(Exception):
+    def __init__(self, code):
+        self.code = code
+
+    def __str__(self):
+        if isinstance(self.code, int):
+            if self.code == -1:
+                return "ENC_INPUT_INVALID_NO_OF_SAMPLES"
+            elif self.code == -2:
+                return "ENC_FS_NOT_SUPPORTED"
+            elif self.code == -3:
+                return "ENC_PACKET_SIZE_NOT_SUPPORTED"
+            elif self.code == -4:
+                return "ENC_PAYLOAD_BUF_TOO_SHORT"
+            elif self.code == -5:
+                return "ENC_INVALID_LOSS_RATE"
+            elif self.code == -6:
+                return "ENC_INVALID_COMPLEXITY_SETTING"
+            elif self.code == -7:
+                return "ENC_INVALID_INBAND_FEC_SETTING"
+            elif self.code == -8:
+                return "ENC_INVALID_DTX_SETTING"
+            elif self.code == -9:
+                return "ENC_INTERNAL_ERROR"
+            elif self.code == -10:
+                return "DEC_INVALID_SAMPLING_FREQUENCY"
+            elif self.code == -11:
+                return "DEC_PAYLOAD_TOO_LARGE"
+            elif self.code == -12:
+                return "DEC_PAYLOAD_ERROR"
+            else:
+                return "Other error"
+        else:
+            return str(self.code)
+
+
+cdef inline bytes i16_to_bytes(int16_t data):
+    cdef:
+        uint8_t * p = <uint8_t *> &data
+        bytes bt = PyBytes_FromStringAndSize(NULL, 2)
+    if <PyObject*>bt == NULL:
+        raise MemoryError
+    cdef uint8_t* buf = <uint8_t*>PyBytes_AS_STRING(bt)
+    buf[0] = p[0]
+    buf[1] = p[1]
+    return bt
+
+cdef inline int16_t bytes_to_i16(bytes data):
+    cdef int16_t buf = 0
+    cdef uint8_t *p = <uint8_t *> &buf
+    p[0] = <uint8_t> data[0]
+    p[1] = <uint8_t> data[1]
+    return buf
+
+cdef inline void write_i16_le(object output, int16_t data):
+    if SHOULD_SWAP:
+        data = swap_i16(data)
+    output.write(i16_to_bytes(data))
+
+cdef inline int16_t read_i16_le(object input):
+    chunk = input.read(2)  # type: bytes
+    cdef int16_t data = bytes_to_i16(chunk)
+    if SHOULD_SWAP:
+        data = swap_i16(data)
+    return data
+
+cdef inline uint8_t PyFile_Check(object file):
+    if PyObject_HasAttrString(file, "read") and PyObject_HasAttrString(file, "write"):  # should we check seek method?
+        return 1
+    return 0
+
+def encode(object input,
+            object output,
+            int32_t sample_rate,
+            int32_t bit_rate,
+            int32_t max_internal_sample_rate = 24000,
+            int32_t packet_loss_percentage = 0,
+            int32_t complexity = 2,
+            bint use_inband_fec = False,
+            bint use_dtx = False,
+            bint tencent = True):
+    """encode(input: BinaryIO, output: BinaryIO, sample_rate: int, bit_rate: int, max_internal_sample_rate: int = 24000, packet_loss_percentage: int = 0, complexity: int = 2, use_inband_fec: bool = False, use_dtx: bool = False, tencent: bool = True) -> bytes
+    
+    encode pcm to silk
+    :param input: BytesIO or an openfile with "rb" mode
+    :param output: BytesIO or an openfile with "wb" mode
+    :param sample_rate: 
+    :param bit_rate: 
+    :param max_internal_sample_rate:
+    :param packet_loss_percentage: 
+    :param complexity: 
+    :param use_inband_fec: 
+    :param use_dtx: 
+    :param tencent: Tencent's special tag 
+    :return: None
+    """
+    if not PyFile_Check(input):
+        raise TypeError("input except a file-like object, got %s" % type(input).__name__)
+    if not PyFile_Check(output):
+        raise TypeError("output except a file-like object, got %s" % type(output).__name__)
+
+    cdef SKP_SILK_SDK_EncControlStruct enc_control
+    enc_control.API_sampleRate = sample_rate
+    enc_control.maxInternalSampleRate = max_internal_sample_rate
+    enc_control.packetSize = (20 * sample_rate) / 1000
+    enc_control.bitRate = bit_rate
+    enc_control.packetLossPercentage = packet_loss_percentage
+    enc_control.complexity = complexity
+    enc_control.useInBandFEC = use_inband_fec
+    enc_control.useDTX = use_dtx
+
+    cdef SKP_SILK_SDK_EncControlStruct enc_status
+    enc_status.API_sampleRate = 0
+    enc_status.maxInternalSampleRate = 0
+    enc_status.packetSize = 0
+    enc_status.bitRate = 0
+    enc_status.packetLossPercentage = 0
+    enc_status.complexity = 0
+    enc_status.useInBandFEC = 0
+    enc_status.useDTX = 0
+
+    cdef int32_t enc_size_bytes = 0
+    cdef int32_t code = SKP_Silk_SDK_Get_Encoder_Size(&enc_size_bytes)
+    if code != 0:
+        raise SilkError(code)
+    cdef void * enc = PyMem_Malloc(<size_t> enc_size_bytes)
+    if enc == NULL:
+        raise MemoryError
+    code = SKP_Silk_SDK_InitEncoder(enc, &enc_status)
+    if code != 0:
+        PyMem_Free(enc)
+        raise SilkError(code)
+    cdef int32_t frame_size = sample_rate / 1000 * 40
+    if tencent:
+        output.write(b"\x02#!SILK_V3")
+    else:
+        output.write(b"#!SILK_V3")
+    cdef int16_t n_bytes = 1250
+    cdef uint8_t payload[1250]
+    cdef int16_t* chunk_ptr
+    cdef int32_t chunk_size
+    try:
+        while True:
+            chunk = input.read(frame_size)  # type: bytes
+            if not PyBytes_Check(chunk):
+                raise TypeError(f"input must be a file-like rb object, got {type(input).__name__}")
+
+            n_bytes = 1250
+            if <int32_t> PyBytes_Size(chunk) < frame_size:
+                break
+            chunk_ptr = <int16_t *> PyBytes_AS_STRING(chunk)
+            chunk_size = <int32_t> (PyBytes_Size(chunk) / 2)
+            with nogil:
+                code = SKP_Silk_SDK_Encode(enc,
+                                        &enc_control,
+                                        chunk_ptr,
+                                        chunk_size,
+                                        payload,
+                                        &n_bytes)
+            if code != 0:
+                raise SilkError(code)
+
+            write_i16_le(output, n_bytes)
+            output.write(<bytes> payload[0:n_bytes])
+    finally:
+        PyMem_Free(enc)
+
+def decode(object input,
+            object output,
+            int32_t sample_rate,
+            int32_t frame_size=0,
+            int32_t frames_per_packet=1,
+            bint more_internal_decoder_frames=False,
+            int32_t in_band_fec_offset=0,
+            bint loss=False):
+    """decode(input: BinaryIO, output: BinaryIO, sample_rate: int, frame_size: int = 0, frames_per_packet: int = 1, more_internal_decoder_frames: bool = False, in_band_fec_offset: int = 0, loss: bool = False) -> bytes
+    
+    decode silk to pcm
+    :param input: 
+    :param output: 
+    :param sample_rate: 
+    :param frame_size: 
+    :param frames_per_packet: 
+    :param more_internal_decoder_frames: 
+    :param in_band_fec_offset: 
+    :param loss: 
+    :return: 
+    """
+    if not PyFile_Check(input):
+        raise TypeError("input except a file-like object, got %s" % type(input).__name__)
+    if not PyFile_Check(output):
+        raise TypeError("output except a file-like object, got %s" % type(output).__name__)
+
+    chunk = input.read(9)  # type: bytes
+    if not PyBytes_Check(chunk):
+        raise TypeError(f"input must be a file-like rb object, got {type(input).__name__}")
+    if chunk != b"#!SILK_V3" and chunk != b"\x02#!SILK_V":
+        raise SilkError("INVALID")
+    elif chunk == b"\x02#!SILK_V":
+        chunk = input.read(1)
+        if chunk != b"3":
+            raise SilkError("INVALID")
+
+    cdef SKP_SILK_SDK_DecControlStruct dec_control
+    dec_control.API_sampleRate = sample_rate
+    dec_control.frameSize = frame_size
+    dec_control.framesPerPacket = frames_per_packet
+    dec_control.moreInternalDecoderFrames = more_internal_decoder_frames
+    dec_control.inBandFECOffset = in_band_fec_offset
+    cdef int32_t dec_size = 0
+    cdef int32_t code = SKP_Silk_SDK_Get_Decoder_Size(&dec_size)
+    if code != 0:
+        raise SilkError(code)
+    cdef void *dec = PyMem_Malloc(dec_size)
+    if dec == NULL:
+        raise MemoryError
+    code = SKP_Silk_SDK_InitDecoder(dec)
+    if code != 0:
+        PyMem_Free(dec)
+        raise SilkError(code)
+    frame_size = sample_rate / 1000 * 40
+    # cdef uint8_t buf[frame_size]  # otherwise need malloc
+    cdef uint8_t *buf = <uint8_t *> PyMem_Malloc(frame_size)
+    if buf == NULL:
+        PyMem_Free(dec)
+        raise MemoryError
+    cdef int16_t n_bytes
+    cdef const uint8_t *chunk_ptr
+    try:
+        while True:
+            chunk = input.read(2)
+            if PyBytes_Size(chunk) < 2:
+                break
+            n_bytes = bytes_to_i16(chunk)
+            if SHOULD_SWAP:
+                n_bytes = swap_i16(n_bytes)
+            if n_bytes > <int16_t> frame_size:
+                raise SilkError("INVALID")
+            chunk = input.read(n_bytes)  # type: bytes
+            if <int16_t> PyBytes_Size(chunk) < n_bytes:  # not enough data
+                raise SilkError("INVALID")
+            chunk_ptr = <const uint8_t *> PyBytes_AS_STRING(chunk)
+            with nogil:
+                code = SKP_Silk_SDK_Decode(dec,
+                                        &dec_control,
+                                        loss,
+                                        chunk_ptr,
+                                        <const int32_t> n_bytes,
+                                        <int16_t *> buf,
+                                        &n_bytes)
+            if code != 0:
+                raise SilkError(code)
+            output.write(<bytes> buf[:n_bytes * 2])
+    finally:
+        PyMem_Free(buf)
+        PyMem_Free(dec)

pysilk/backends/cython/silk.pxd

@@ -0,0 +1,72 @@
+# cython: language_level=3
+# cython: cdivision=True
+from libc.stdint cimport int16_t, int32_t, uint8_t
+
+
+cdef extern from "SKP_Silk_control.h" nogil:
+    ctypedef struct SKP_SILK_SDK_EncControlStruct:
+        int32_t API_sampleRate
+        int32_t maxInternalSampleRate
+        int32_t packetSize
+        int32_t bitRate
+        int32_t packetLossPercentage
+        int32_t complexity
+        int32_t useInBandFEC
+        int32_t useDTX
+    ctypedef struct SKP_SILK_SDK_DecControlStruct:
+        int32_t API_sampleRate
+        int32_t frameSize
+        int32_t framesPerPacket
+        int32_t moreInternalDecoderFrames
+        int32_t inBandFECOffset
+
+
+cdef extern  from "SKP_Silk_SDK_API.h" nogil:
+    int32_t SKP_Silk_SDK_Get_Encoder_Size(int32_t *encSizeBytes)
+    int32_t SKP_Silk_SDK_InitEncoder(void *encState, SKP_SILK_SDK_EncControlStruct *encStatus)
+    int32_t SKP_Silk_SDK_Encode(void *encState,
+                                const SKP_SILK_SDK_EncControlStruct *encControl,
+                                const int16_t *samplesIn,
+                                int32_t nSamplesIn,
+                                uint8_t *outData,
+                                int16_t *nBytesOut)
+    int32_t SKP_Silk_SDK_Get_Decoder_Size(int32_t *decSizeBytes)
+    int32_t SKP_Silk_SDK_InitDecoder(void *decState)
+    int32_t SKP_Silk_SDK_Decode(void * decState,
+                                SKP_SILK_SDK_DecControlStruct *decControl,
+                                int32_t lostFlag,
+                                const uint8_t *inData,
+                                const int32_t nBytesIn,
+                                int16_t *samplesOut,
+                                int16_t *nSamplesOut)
+
+cdef extern  from * nogil:
+    """
+/*
+void swap_i16(int16_t *data)
+{
+    int8_t *p = (int8_t *)data;
+    int8_t tmp = p[0];
+    p[0] = p[1];
+    p[1] = tmp;
+}
+*/
+uint8_t is_le()
+{
+    uint16_t data=1;
+    return *(uint8_t*)&data;
+}
+#if defined(_WIN64) || defined(_WIN32)
+    #define swap_i16 _byteswap_ushort
+#else
+    #define swap_i16 __builtin_bswap16
+#endif /* _WIN32 */
+#ifdef WORDS_BIGENDIAN
+    #define SHOULD_SWAP 1
+#else
+    #define SHOULD_SWAP 0
+#endif
+    """
+    int16_t swap_i16(int16_t data)
+    uint8_t is_le()
+    int SHOULD_SWAP

silk_python-0.2.7.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: silk-python
+Version: 0.2.7
+Summary: silk encode and decode
+Home-page: https://github.com/synodriver/pysilk
+Author: synodriver
+Author-email: diguohuangjiajinweijun@gmail.com
+License: BSD
+Keywords: silk,encode,decode,pcm,audio
+Classifier: Development Status :: 4 - Beta
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: cffi>=1.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+<h1 align="center"><i>✨ pysilk ✨ </i></h1>
+
+<h3 align="center">The python binding for <a href="https://github.com/kn007/silk-v3-decoder">silk-v3-decoder</a> </h3>
+
+[![pypi](https://img.shields.io/pypi/v/silk-python.svg)](https://pypi.org/project/silk-python/)
+![python](https://img.shields.io/pypi/pyversions/silk-python)
+![implementation](https://img.shields.io/pypi/implementation/silk-python)
+![wheel](https://img.shields.io/pypi/wheel/silk-python)
+![license](https://img.shields.io/github/license/synodriver/pysilk.svg)
+![action](https://img.shields.io/github/workflow/status/synodriver/pysilk/build%20wheel)
+
+## 安装
+```bash
+pip install silk-python
+```
+
+
+## 使用
+- encode
+```python
+import pysilk
+
+with open("verybiginput.pcm", "rb") as pcm, open("output.silk", "wb") as silk:
+    pysilk.encode(pcm, silk, 24000, 24000)
+```
+
+- decode
+
+```python
+import pysilk
+
+with open("verybiginput.silk", "rb") as silk, open("output.pcm", "wb") as pcm:
+    pysilk.decode(silk, pcm, 24000)
+```
+
+## 支持功能
+- 接受任何二进制的```file-like object```，比如```BytesIO```，可以流式解码大文件
+- 包装了silk的全部C接口的参数，当然他们都有合理的默认值
+- 基于```Cython```， [关键部位](https://github.com/synodriver/pysilk/blob/stream/pysilk/silk.pxd#L43-L65) 内联C函数，高性能
+
+
+## 公开函数
+```python
+from typing import BinaryIO
+
+def encode(input: BinaryIO, output: BinaryIO, sample_rate: int, bit_rate: int, max_internal_sample_rate: int = 24000, packet_loss_percentage: int = 0, complexity: int = 2, use_inband_fec: bool = False, use_dtx: bool = False, tencent: bool = True) -> None: ...
+def decode(input: BinaryIO, output: BinaryIO, sample_rate: int, frame_size: int = 0, frames_per_packet: int = 1, more_internal_decoder_frames: bool = False, in_band_fec_offset: int = 0, loss: bool = False) -> None: ...
+```
+
+## 公开异常
+```python
+class SilkError(Exception):
+    pass
+```
+
+### ✨v0.2.0✨
+合并了[CFFI](https://github.com/synodriver/pysilk-cffi) 的工作
+
+### 本机编译
+```
+python -m pip install setuptools wheel cython cffi
+git clone https://github.com/synodriver/pysilk
+cd pysilk
+git submodule update --init --recursive
+python setup.py bdist_wheel --use-cython --use-cffi
+```
+
+### 后端选择
+默认由py实现决定，在cpython上自动选择cython后端，在pypy上自动选择cffi后端，使用```SILK_USE_CFFI```环境变量可以强制选择cffi

silk_python-0.2.7.dist-info/RECORD

@@ -0,0 +1,15 @@
+pysilk/__init__.py,sha256=51ILaDOKD4UUQk0w6FjBXTjTSF8kqkOyxXNleBoUTqw,417
+pysilk/backends/__init__.py,sha256=XywP1BY8lg5-vwoQw0cKnqhB-lP27C5UiVRg25FP64c,69
+pysilk/backends/cffi/__init__.py,sha256=MDJqE3f01r8ahQFQH_8MFmMtHD89yhDeTmbhUuUx6Lw,8977
+pysilk/backends/cffi/_silk.pyd,sha256=YHwyjEPCxW_TrePYy1Hn0kyRzEVimbLt0spiF3iVu8I,139776
+pysilk/backends/cffi/build.py,sha256=dWh6JFs02S4du75NQyIGdzAmCO4uRCbh-rgKf4FdXjQ,3690
+pysilk/backends/cython/__init__.py,sha256=6TA0vr_27_mdZ22s5_ZEJR0M7HcJUzPVrcMyIPRcFQ0,113
+pysilk/backends/cython/_silk.c,sha256=ixNIgNj2JjwxfB9RvX-IyIiZaKdeN0MJmBzLykyevKk,571618
+pysilk/backends/cython/_silk.pyd,sha256=VSo4QKHBhueuFsF7akuC9Ka63DbG5ARCGZND0utGR8Q,181248
+pysilk/backends/cython/_silk.pyi,sha256=3Y39NJhDIe4ehO0HHzu9P8y0cCVC5aTUbDCgxFKks1k,690
+pysilk/backends/cython/_silk.pyx,sha256=6mJ1MrKjVcKabWg-YDrNiawhKa9hzBVBC76Xt0Hn6AU,10705
+pysilk/backends/cython/silk.pxd,sha256=9SKUDcJeDDIeTsScrerq1rtwSWqZLP_yaWp_N2HEOUE,2328
+silk_python-0.2.7.dist-info/METADATA,sha256=pCACDqPqLMlWUiXGRTFccl8S4gbRUG_ANYmrr8m5vo4,3869
+silk_python-0.2.7.dist-info/WHEEL,sha256=0ABLuJ37exXk5N_efmYNs2NU9NK1K2Qlod_6bYkofEA,97
+silk_python-0.2.7.dist-info/top_level.txt,sha256=tcB-cCbL6OMj8uspHFAz4kJ8ObWLz--nuLQ1wVc0GRY,7
+silk_python-0.2.7.dist-info/RECORD,,

silk_python-0.2.7.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win32
+

silk_python-0.2.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+pysilk