############################################################ # Opus license: # ############################################################ """ Copyright 2001-2011 Xiph.Org, Skype Limited, Octasic, Jean-Marc Valin, Timothy B. Terriberry, CSIRO, Gregory Maxwell, Mark Borgerding, Erik de Castro Lopo 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. - Neither the name of Internet Society, IETF or IETF Trust, nor the names of specific contributors, may be used to endorse or promote products derived from this software without specific prior written permission. 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 OWNER 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. Opus is subject to the royalty-free patent licenses which are specified at: Xiph.Org Foundation: https://datatracker.ietf.org/ipr/1524/ Microsoft Corporation: https://datatracker.ietf.org/ipr/1914/ Broadcom Corporation: https://datatracker.ietf.org/ipr/1526/ """ ############################################################ # Opusfile license: # ############################################################ """ Copyright (c) 1994-2013 Xiph.Org Foundation and contributors 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. - Neither the name of the Xiph.Org Foundation nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. 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 FOUNDATION 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. """ ############################################################ # Opusenc license: # ############################################################ """ Copyright (c) 1994-2013 Xiph.Org Foundation and contributors Copyright (c) 2017 Jean-Marc Valin 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. - Neither the name of the Xiph.Org Foundation nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. 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 FOUNDATION 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. """ import ctypes import ctypes.util import os from traceback import print_exc as _print_exc from .ogg import * from .library_loader import ExternalLibrary, ExternalLibraryError __here = os.getcwd() libopus = None try: libopus = ExternalLibrary.load("opus", tests = [lambda lib: hasattr(lib, "opus_encoder_get_size")]) except ExternalLibraryError: pass except: _print_exc() libopusfile = None try: libopusfile = ExternalLibrary.load("opusfile", tests = [lambda lib: hasattr(lib, "opus_head_parse")]) except ExternalLibraryError: pass except: _print_exc() libopusenc = None try: libopusenc = ExternalLibrary.load("opusenc", tests = [lambda lib: hasattr(lib, "ope_comments_create")]) except ExternalLibraryError: pass except: _print_exc() if libopus: PYOGG_OPUS_AVAIL = True else: PYOGG_OPUS_AVAIL = False if libopusfile: PYOGG_OPUS_FILE_AVAIL = True else: PYOGG_OPUS_FILE_AVAIL = False if libopusenc: PYOGG_OPUS_ENC_AVAIL = True else: PYOGG_OPUS_ENC_AVAIL = False if PYOGG_OPUS_AVAIL and PYOGG_OPUS_FILE_AVAIL: # all definitions OPE_API_VERSION =0 OPE_OK =0 OPE_BAD_ARG =-11 OPE_INTERNAL_ERROR =-13 OPE_UNIMPLEMENTED =-15 OPE_ALLOC_FAIL =-17 OPE_CANNOT_OPEN =-30 OPE_TOO_LATE =-31 OPE_UNRECOVERABLE =-32 OPE_INVALID_PICTURE =-33 OPE_INVALID_ICON =-34 OPUS_OK =0 OPUS_BAD_ARG =-1 OPUS_BUFFER_TOO_SMALL =-2 OPUS_INTERNAL_ERROR =-3 OPUS_INVALID_PACKET =-4 OPUS_UNIMPLEMENTED =-5 OPUS_INVALID_STATE =-6 OPUS_ALLOC_FAIL =-7 OP_FALSE =(-1) OP_EOF =(-2) OP_HOLE =(-3) OP_EREAD =(-128) OP_EFAULT =(-129) OP_EIMPL =(-130) OP_EINVAL =(-131) OP_ENOTFORMAT =(-132) OP_EBADHEADER =(-133) OP_EVERSION =(-134) OP_ENOTAUDIO =(-135) OP_EBADPACKET =(-136) OP_EBADLINK =(-137) OP_ENOSEEK =(-138) OP_EBADTIMESTAMP =(-139) OP_PIC_FORMAT_UNKNOWN =(-1) OP_PIC_FORMAT_URL =(0) OP_PIC_FORMAT_JPEG =(1) OP_PIC_FORMAT_PNG =(2) OP_PIC_FORMAT_GIF =(3) OPUS_CHANNEL_COUNT_MAX =(255) OPUS_SET_APPLICATION_REQUEST =4000 OPUS_GET_APPLICATION_REQUEST =4001 OPUS_SET_BITRATE_REQUEST =4002 OPUS_GET_BITRATE_REQUEST =4003 OPUS_SET_MAX_BANDWIDTH_REQUEST =4004 OPUS_GET_MAX_BANDWIDTH_REQUEST =4005 OPUS_SET_VBR_REQUEST =4006 OPUS_GET_VBR_REQUEST =4007 OPUS_SET_BANDWIDTH_REQUEST =4008 OPUS_GET_BANDWIDTH_REQUEST =4009 OPUS_SET_COMPLEXITY_REQUEST =4010 OPUS_GET_COMPLEXITY_REQUEST =4011 OPUS_SET_INBAND_FEC_REQUEST =4012 OPUS_GET_INBAND_FEC_REQUEST =4013 OPUS_SET_PACKET_LOSS_PERC_REQUEST =4014 OPUS_GET_PACKET_LOSS_PERC_REQUEST =4015 OPUS_SET_DTX_REQUEST =4016 OPUS_GET_DTX_REQUEST =4017 OPUS_SET_VBR_CONSTRAINT_REQUEST =4020 OPUS_GET_VBR_CONSTRAINT_REQUEST =4021 OPUS_SET_FORCE_CHANNELS_REQUEST =4022 OPUS_GET_FORCE_CHANNELS_REQUEST =4023 OPUS_SET_SIGNAL_REQUEST =4024 OPUS_GET_SIGNAL_REQUEST =4025 OPUS_GET_LOOKAHEAD_REQUEST =4027 OPUS_GET_SAMPLE_RATE_REQUEST =4029 OPUS_GET_FINAL_RANGE_REQUEST =4031 OPUS_GET_PITCH_REQUEST =4033 OPUS_SET_GAIN_REQUEST =4034 OPUS_GET_GAIN_REQUEST =4045 OPUS_SET_LSB_DEPTH_REQUEST =4036 OPUS_GET_LSB_DEPTH_REQUEST =4037 OPUS_GET_LAoe_pACKET_DURATION_REQUEST =4039 OPUS_SET_EXPERT_FRAME_DURATION_REQUEST =4040 OPUS_GET_EXPERT_FRAME_DURATION_REQUEST =4041 OPUS_SET_PREDICTION_DISABLED_REQUEST =4042 OPUS_GET_PREDICTION_DISABLED_REQUEST =4043 OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST =4046 OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST =4047 OPUS_AUTO =-1000 OPUS_BITRATE_MAX = -1 OPUS_APPLICATION_VOIP = 2048 OPUS_APPLICATION_AUDIO = 2049 OPUS_APPLICATION_RESTRICTED_LOWDELAY =2051 OPUS_SIGNAL_VOICE =3001 OPUS_SIGNAL_MUSIC =3002 OPUS_BANDWIDTH_NARROWBAND =1101 OPUS_BANDWIDTH_MEDIUMBAND =1102 OPUS_BANDWIDTH_WIDEBAND =1103 OPUS_BANDWIDTH_SUPERWIDEBAND =1104 OPUS_BANDWIDTH_FULLBAND =1105 OPUS_FRAMESIZE_ARG =5000 OPUS_FRAMESIZE_2_5_MS =5001 OPUS_FRAMESIZE_5_MS =5002 OPUS_FRAMESIZE_10_MS =5003 OPUS_FRAMESIZE_20_MS =5004 OPUS_FRAMESIZE_40_MS =5005 OPUS_FRAMESIZE_60_MS =5006 OPUS_FRAMESIZE_80_MS =5007 OPUS_FRAMESIZE_100_MS =5008 OPUS_FRAMESIZE_120_MS =5009 OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST =5120 OPUS_MULTISTREAM_GET_DECODER_STATE_REQUEST =5122 OP_SSL_SKIP_CERTIFICATE_CHECK_REQUEST =(6464) OP_HTTP_PROXY_HOST_REQUEST =(6528) OP_HTTP_PROXY_PORT_REQUEST =(6592) OP_HTTP_PROXY_USER_REQUEST =(6656) OP_HTTP_PROXY_PASS_REQUEST =(6720) OP_GET_SERVER_INFO_REQUEST =(6784) OP_DEC_FORMAT_SHORT =(7008) OP_DEC_FORMAT_FLOAT =(7040) OP_DEC_USE_DEFAULT =(6720) OP_HEADER_GAIN =(0) OP_ALBUM_GAIN =(3007) OP_TRACK_GAIN =(3008) OP_ABSOLUTE_GAIN =(3009) OPUS_RESET_STATE =4028 OPE_SET_DECISION_DELAY_REQUEST =14000 OPE_GET_DECISION_DELAY_REQUEST =14001 OPE_SET_MUXING_DELAY_REQUEST =14002 OPE_GET_MUXING_DELAY_REQUEST =14003 OPE_SET_COMMENT_PADDING_REQUEST =14004 OPE_GET_COMMENT_PADDING_REQUEST =14005 OPE_SET_SERIALNO_REQUEST =14006 OPE_GET_SERIALNO_REQUEST =14007 OPE_SET_PACKET_CALLBACK_REQUEST =14008 OPE_SET_HEADER_GAIN_REQUEST =14010 OPE_GET_HEADER_GAIN_REQUEST =14011 # opus_types opus_int16 = c_int16 opus_int16_p = POINTER(c_int16) opus_uint16 = c_uint16 opus_int32 = c_int32 opus_int32_p = POINTER(opus_int32) opus_uint32 = c_uint32 opus_int = c_int opus_int64= c_longlong opus_int8= c_int8 opus_uint= c_uint opus_uint64 = c_ulonglong opus_uint8 = c_int8 # /opus_types # opus class OpusEncoder(ctypes.Structure): _fields_ = [("dummy", ctypes.c_int)] oe_p = POINTER(OpusEncoder) libopus.opus_encoder_get_size.restype = c_int libopus.opus_encoder_get_size.argtypes = [c_int] def opus_encoder_get_size(channels): return libopus.opus_encoder_get_size(channels) libopus.opus_encoder_create.restype = oe_p libopus.opus_encoder_create.argtypes = [opus_int32, c_int, c_int, c_int_p] def opus_encoder_create(Fs, channels, application, error): return libopus.opus_encoder_create(Fs, channels, application, error) libopus.opus_encoder_init.restype = c_int libopus.opus_encoder_init.argtypes = [oe_p, opus_int32, c_int, c_int] def opus_encoder_init(st, Fs, channels, applications): return libopus.opus_encoder_init(st, Fs, channels, applications) libopus.opus_encode.restype = opus_int32 libopus.opus_encode.argtypes = [oe_p, opus_int16_p, c_int, c_uchar_p, opus_int32] def opus_encode(st, pcm, frame_size, data, max_data_bytes): return libopus.opus_encode(st, pcm, frame_size, data, max_data_bytes) libopus.opus_encode_float.restype = opus_int32 libopus.opus_encode_float.argtypes = [oe_p, c_float_p, c_int, c_uchar_p, opus_int32] def opus_encode_float(st, pcm, frame_size, data, max_data_bytes): return libopus.opus_encode_float(st, pcm, frame_size, data, max_data_bytes) libopus.opus_encoder_destroy.restype = None libopus.opus_encoder_destroy.argtypes = [oe_p] def opus_encoder_destroy(st): return libopus.opus_encoder_destroy(st) libopus.opus_encoder_ctl.restype = c_int libopus.opus_encoder_ctl.argtypes = [oe_p, c_int] def opus_encoder_ctl(st, request, *args): return libopus.opus_encoder_ctl(st, request, *args) class OpusDecoder(ctypes.Structure): _fields_ = [("dummy", c_int)] od_p = POINTER(OpusDecoder) libopus.opus_decoder_get_size.restype = c_int libopus.opus_decoder_get_size.argtypes = [c_int] def opus_decoder_get_size(channels): return libopus.opus_decoder_get_size(channels) libopus.opus_decoder_create.restype = od_p libopus.opus_decoder_create.argtypes = [opus_int32, c_int, c_int_p] def opus_decoder_create(Fs, channels, error): return libopus.opus_decoder_create(Fs, channels, error) libopus.opus_decoder_init.restype = c_int libopus.opus_decoder_init.argtypes = [od_p, opus_int32, c_int] def opus_decoder_init(st, Fs, channels): return libopus.opus_decoder_init(st, Fs, channels) libopus.opus_decode.restype = c_int libopus.opus_decode.argtypes = [od_p, c_uchar_p, opus_int32, opus_int16_p, c_int, c_int] def opus_decode(st, data, len, pcm, frame_size, decode_fec): return libopus.opus_decode(st, data, len, pcm, frame_size, decode_fec) libopus.opus_decode_float.restype = c_int libopus.opus_decode_float.argtypes = [od_p, c_uchar_p, opus_int32, c_float_p, c_int, c_int] def opus_decode_float(st, data, len, pcm, frame_size, decode_fec): return libopus.opus_decode_float(st, data, len, pcm, frame_size, decode_fec) libopus.opus_decoder_ctl.restype = c_int libopus.opus_decoder_ctl.argtypes = [od_p, c_int] def opus_decoder_ctl(st, request, *args): return libopus.opus_decoder_ctl(st, request, *args) libopus.opus_decoder_destroy.restype = None libopus.opus_decoder_destroy.argtypes = [od_p] def opus_decoder_destroy(st): return libopus.opus_decoder_destroy(st) libopus.opus_packet_parse.restype = c_int libopus.opus_packet_parse.argtypes = [c_uchar_p, opus_int32, c_uchar_p, c_uchar_p*48, opus_int16*48, c_int_p] def opus_packet_parse(data, len, out_toc, frames, size, payload_offset): return libopus.opus_packet_parse(data, len, out_toc, frames, size, payload_offset) libopus.opus_packet_get_bandwidth.restype = c_int libopus.opus_packet_get_bandwidth.argtypes = [c_uchar_p] def opus_packet_get_bandwidth(data): return libopus.opus_packet_get_bandwidth(data) libopus.opus_packet_get_samples_per_frame.restype = c_int libopus.opus_packet_get_samples_per_frame.argtypes = [c_uchar_p, opus_int32] def opus_packet_get_samples_per_frame(data, Fs): return libopus.opus_packet_get_samples_per_frame(data, Fs) libopus.opus_packet_get_nb_channels.restype = c_int libopus.opus_packet_get_nb_channels.argtypes = [c_uchar_p] def opus_packet_get_nb_channels(data): return libopus.opus_packet_get_nb_channels(data) libopus.opus_packet_get_nb_frames.restype = c_int libopus.opus_packet_get_nb_frames.argtypes = [c_uchar*0, opus_int32] def opus_packet_get_nb_frames(packet, len): return libopus.opus_packet_get_nb_frames(packet, len) libopus.opus_packet_get_nb_samples.restype = c_int libopus.opus_packet_get_nb_samples.argtypes = [c_uchar*0, opus_int32, opus_int32] def opus_packet_get_nb_samples(packet, len, Fs): return libopus.opus_packet_get_nb_samples(packet, len, Fs) libopus.opus_decoder_get_nb_samples.restype = c_int libopus.opus_decoder_get_nb_samples.argtypes = [od_p, c_uchar*0, opus_int32] def opus_decoder_get_nb_samples(dec, packet, len): return libopus.opus_decoder_get_nb_samples(dec, packet, len) libopus.opus_pcm_soft_clip.restype = None libopus.opus_pcm_soft_clip.argtypes = [c_float_p, c_int, c_int, c_float_p] def opus_pcm_soft_clip(pcm, frame_size, channels, softclip_mem): return libopus.opus_pcm_soft_clip(pcm, frame_size, channels, softclip_mem) class OpusRepacketizer(ctypes.Structure): _fields_ = [("dummy", c_int)] or_p = POINTER(OpusRepacketizer) libopus.opus_repacketizer_get_size.restype = c_int libopus.opus_repacketizer_get_size.argtypes = None def opus_repacketizer_get_size(): return libopus.opus_repacketizer_get_size() libopus.opus_repacketizer_init.restype = or_p libopus.opus_repacketizer_init.argtypes = [or_p] def opus_repacketizer_init(rp): return libopus.opus_repacketizer_init(rp) libopus.opus_repacketizer_create.restype = or_p libopus.opus_repacketizer_create.argtypes = None def opus_repacketizer_create(): return libopus.opus_repacketizer_create() libopus.opus_repacketizer_destroy.restype = None libopus.opus_repacketizer_destroy.argtypes = [or_p] def opus_repacketizer_destroy(rp): return libopus.opus_repacketizer_destroy(rp) libopus.opus_repacketizer_cat.restype = c_int libopus.opus_repacketizer_cat.argtypes = [or_p, c_uchar_p, opus_int32] def opus_repacketizer_cat(rp, data, len): return libopus.opus_repacketizer_cat(rp, data, len) libopus.opus_repacketizer_out_range.restype = opus_int32 libopus.opus_repacketizer_out_range.argtypes = [or_p, c_int, c_int, c_uchar_p, opus_int32] def opus_repacketizer_out_range(rp, begin, end, data, maxlen): return libopus.opus_repacketizer_out_range(rp, begin, end, data, maxlen) libopus.opus_repacketizer_get_nb_frames.restype = c_int libopus.opus_repacketizer_get_nb_frames.argtypes = [or_p] def opus_repacketizer_get_nb_frames(rp): return libopus.opus_repacketizer_get_nb_frames(rp) libopus.opus_repacketizer_out.restype = opus_int32 libopus.opus_repacketizer_out.argtypes = [or_p, c_uchar_p, opus_int32] def opus_repacketizer_out(rp, data, maxlen): return libopus.opus_repacketizer_out(rp, data, maxlen) libopus.opus_packet_pad.restype = c_int libopus.opus_packet_pad.argtypes = [c_uchar_p, opus_int32, opus_int32] def opus_packet_pad(data, len, new_len): return libopus.opus_packet_pad(data, len, new_len) libopus.opus_packet_unpad.restype = opus_int32 libopus.opus_packet_unpad.argtypes = [c_uchar_p, opus_int32] def opus_packet_unpad(data, len): return libopus.opus_packet_unpad(data, len) libopus.opus_multistream_packet_pad.restype = c_int libopus.opus_multistream_packet_pad.argtypes = [c_uchar_p, opus_int32, opus_int32, c_int] def opus_multistream_packet_pad(data, len, new_len, nb_streams): return libopus.opus_multistream_packet_pad(data, len, new_len, nb_streams) libopus.opus_multistream_packet_unpad.restype = opus_int32 libopus.opus_multistream_packet_unpad.argtypes = [c_uchar_p, opus_int32, c_int] def opus_multistream_packet_unpad(data, len, nb_streams): return libopus.opus_multistream_packet_unpad(data, len, nb_streams) libopus.opus_strerror.restype = c_char_p libopus.opus_strerror.argtypes = [c_int] def opus_strerror(error): return libopus.opus_strerror(error) libopus.opus_get_version_string.restype = c_char_p libopus.opus_get_version_string.argtypes = None def opus_get_version_string(): return libopus.opus_get_version_string() # /opus # opus_multistream class OpusMSEncoder(ctypes.Structure): _fields_ = [("dummy", c_int)] omse_p = POINTER(OpusMSEncoder) class OpusMSDecoder(ctypes.Structure): _fields_ = [("dummy", c_int)] omsd_p = POINTER(OpusMSDecoder) libopus.opus_multistream_encoder_get_size.restype = opus_int32 libopus.opus_multistream_encoder_get_size.argtypes = [c_int, c_int] def opus_multistream_encoder_get_size(streams, coupled_streams): return libopus.opus_multistream_encoder_get_size(streams, coupled_streams) libopus.opus_multistream_surround_encoder_get_size.restype = opus_int32 libopus.opus_multistream_surround_encoder_get_size.argtypes = [c_int, c_int] def opus_multistream_surround_encoder_get_size(channels, mapping_family): return libopus.opus_multistream_surround_encoder_get_size(channels, mapping_family) libopus.opus_multistream_encoder_create.restype = omse_p libopus.opus_multistream_encoder_create.argtypes = [opus_int32, c_int, c_int, c_int, c_uchar_p, c_int, c_int_p] def opus_multistream_encoder_create(Fs, channels,streams,coupled_streams, mapping, application, error): return libopus.opus_multistream_encoder_create(Fs, channels,streams,coupled_streams, mapping, application, error) libopus.opus_multistream_surround_encoder_create.restype = omse_p libopus.opus_multistream_surround_encoder_create.argtypes = [opus_int32, c_int, c_int, c_int_p, c_int_p, c_uchar_p, c_int, c_int_p] def opus_multistream_surround_encoder_create(Fs, channels, mapping_family, streams, coupled_streams, mapping, application, error): return libopus.opus_multistream_surround_encoder_create(Fs, channels, mapping_family, streams, coupled_streams, mapping, application, error) libopus.opus_multistream_encoder_init.restype = c_int libopus.opus_multistream_encoder_init.argtypes = [omse_p, opus_int32, c_int, c_int, c_int, c_uchar_p, c_int] def opus_multistream_encoder_init(st, Fs, channels, streams, coupled_streams, mapping, application): return libopus.opus_multistream_encoder_init(st, Fs, channels, streams, coupled_streams, mapping, application) libopus.opus_multistream_surround_encoder_init.restype = c_int libopus.opus_multistream_surround_encoder_init.argtypes = [omse_p, opus_int32, c_int, c_int, c_int_p, c_int_p, c_uchar_p, c_int] def opus_multistream_surround_encoder_init(st, Fs, channels, mapping_family, streams, coupled_streams, mapping, application): return libopus.opus_multistream_surround_encoder_init(st, Fs, channels, mapping_family, streams, coupled_streams, mapping, application) libopus.opus_multistream_encode.restype = c_int libopus.opus_multistream_encode.argtypes = [omse_p, opus_int16_p, c_int, c_uchar_p, opus_int32] def opus_multistream_encode(st, pcm, frame_size, data, max_data_bytes): return libopus.opus_multistream_encode(st, pcm, frame_size, data, max_data_bytes) libopus.opus_multistream_encode_float.restype = c_int libopus.opus_multistream_encode_float.argtypes = [omse_p, c_float_p, c_int, c_uchar_p, opus_int32] def opus_multistream_encode_float(st, pcm, frame_size, data, max_data_bytes): return libopus.opus_multistream_encode_float(st, pcm, frame_size, data, max_data_bytes) libopus.opus_multistream_encoder_destroy.restype = None libopus.opus_multistream_encoder_destroy.argtypes = [omse_p] def opus_multistream_encoder_destroy(st): return libopus.opus_multistream_encoder_destroy(st) libopus.opus_multistream_encoder_ctl.restype = c_int libopus.opus_multistream_encoder_ctl.argtypes = [omse_p, c_int] def opus_multistream_encoder_ctl(st, request, *args): return libopus.opus_multistream_encoder_ctl(st, request, *args) libopus.opus_multistream_decoder_get_size.restype = opus_int32 libopus.opus_multistream_decoder_get_size.argtypes = [c_int, c_int] def opus_multistream_decoder_get_size(streams, coupled_streams): return libopus.opus_multistream_decoder_get_size(streams, coupled_streams) libopus.opus_multistream_decoder_create.restype = omsd_p libopus.opus_multistream_decoder_create.argtypes = [opus_int32, c_int, c_int, c_int, c_uchar_p, c_int_p] def opus_multistream_decoder_create(Fs, channels, streams, coupled_streams, mapping, error): return libopus.opus_multistream_decoder_create(Fs, channels, streams, coupled_streams, mapping, error) libopus.opus_multistream_decoder_init.restype = c_int libopus.opus_multistream_decoder_init.argtypes = [omsd_p, opus_int32, c_int, c_int, c_int, c_uchar_p] def opus_multistream_decoder_init(st, Fs, channels, streams, coupled_streams, mapping): return libopus.opus_multistream_decoder_init(st, Fs, channels, streams, coupled_streams, mapping) libopus.opus_multistream_decode.restype = c_int libopus.opus_multistream_decode.argtypes = [omsd_p, c_uchar_p, opus_int32, opus_int16_p, c_int, c_int] def opus_multistream_decode(st, data, len, pcm, frame_size, decode_fec): return libopus.opus_multistream_decode(st, data, len, pcm, frame_size, decode_fec) libopus.opus_multistream_decode_float.restype = c_int libopus.opus_multistream_decode_float.argtypes = [omsd_p, c_uchar_p, opus_int32, c_float_p, c_int, c_int] def opus_multistream_decode_float(st, data, len, pcm, frame_size, decode_fec): return libopus.opus_multistream_decode_float(st, data, len, pcm, frame_size, decode_fec) libopus.opus_multistream_decoder_ctl.restype = c_int libopus.opus_multistream_decoder_ctl.argtypes = [omsd_p, c_int] def opus_multistream_decoder_ctl(st, request, *args): return libopus.opus_multistream_decoder_ctl(st, request, *args) libopus.opus_multistream_decoder_destroy.restype = None libopus.opus_multistream_decoder_destroy.argtypes = [omsd_p] def opus_multistream_decoder_destroy(st): return libopus.opus_multistream_decoder_destroy(st) # /opus_multistream # opusfile class OggOpusFile(ctypes.Structure): _fields_ = [("dummy", c_int)] oof_p = POINTER(OggOpusFile) class OpusHead(ctypes.Structure): _fields_ = [("version", c_int), ("channel_count", c_int), ("pre_skip", c_uint), ("input_sample_rate", opus_uint32), ("output_gain", c_int), ("mapping_family", c_int), ("stream_count", c_int), ("coupled_count", c_int), ("mapping", c_uchar * OPUS_CHANNEL_COUNT_MAX)] oh_p = POINTER(OpusHead) class OpusTags(ctypes.Structure): _fields_ = [("user_comments", c_char_p_p), ("comment_lengths", c_int_p), ("comments", c_int), ("vendor", c_char_p)] ot_p = POINTER(OpusTags) class OpusPictureTag(ctypes.Structure): _fields_ = [("type", opus_int32), ("mime_type", c_char_p), ("description", c_char_p), ("width", opus_uint32), ("height", opus_uint32), ("depth", opus_uint32), ("colors", opus_uint32), ("data_length", opus_uint32), ("data", c_uchar_p), ("format", c_int)] opt_p = POINTER(OpusPictureTag) libopusfile.opus_head_parse.restype = c_int libopusfile.opus_head_parse.argtypes = [oh_p, c_uchar_p, c_size_t] def opus_head_parse(_head, _data, _len): return libopusfile.opus_head_parse(_head, _data, _len) libopusfile.opus_granule_sample.restype = ogg_int64_t libopusfile.opus_granule_sample.argtypes = [oh_p, ogg_int64_t] def opus_granule_sample(_head, _gp): return libopusfile.opus_granule_sample(_head, _gp) libopusfile.opus_tags_parse.restype = c_int libopusfile.opus_tags_parse.argtypes = [ot_p, c_uchar_p, c_size_t] def opus_tags_parse(_tags, _data, _len): return libopusfile.opus_tags_parse(_tags, _data, _len) libopusfile.opus_tags_copy.restype = c_int libopusfile.opus_tags_copy.argtypes = [ot_p, ot_p] def opus_tags_copy(_dst, _src): return libopusfile.opus_tags_copy(_dst, _src) libopusfile.opus_tags_init.restype = None libopusfile.opus_tags_init.argtypes = [ot_p] def opus_tags_init(_tags): return libopusfile.opus_tags_init(_tags) libopusfile.opus_tags_add.restype = c_int libopusfile.opus_tags_add.argtypes = [ot_p, c_char_p, c_char_p] def opus_tags_add(_tags, _tag, _value): return libopusfile.opus_tags_add(_tags, _tag, _value) libopusfile.opus_tags_add_comment.restype = c_int libopusfile.opus_tags_add_comment.argtypes = [ot_p, c_char_p] def opus_tags_add_comment(_tags, _comment): return libopusfile.opus_tags_add_comment(_tags, _comment) libopusfile.opus_tags_set_binary_suffix.restype = c_int libopusfile.opus_tags_set_binary_suffix.argtypes = [ot_p, c_uchar_p, c_int] def opus_tags_set_binary_suffix(_tags, _data, _len): return libopusfile.opus_tags_set_binary_suffix(_tags, _data, _len) libopusfile.opus_tags_query.restype = c_char_p libopusfile.opus_tags_query.argtypes = [ot_p, c_char_p, c_int] def opus_tags_query(_tags, _tag, _count): return libopusfile.opus_tags_query(_tags, _tag, _count) libopusfile.opus_tags_query_count.restype = c_int libopusfile.opus_tags_query_count.argtypes = [ot_p, c_char_p] def opus_tags_query_count(_tags, _tag): return libopusfile.opus_tags_query_count(_tags, _tag) libopusfile.opus_tags_get_binary_suffix.restype = c_uchar_p libopusfile.opus_tags_get_binary_suffix.argtypes = [ot_p, c_int_p] def opus_tags_get_binary_suffix(_tags, _len): return libopusfile.opus_tags_get_binary_suffix(_tags, _len) libopusfile.opus_tags_get_album_gain.restype = c_int libopusfile.opus_tags_get_album_gain.argtypes = [ot_p, c_int_p] def opus_tags_get_album_gain(_tags, _gain_q8): return libopusfile.opus_tags_get_album_gain(_tags, _gain_q8) libopusfile.opus_tags_get_track_gain.restype = c_int libopusfile.opus_tags_get_track_gain.argtypes = [ot_p, c_int_p] def opus_tags_get_track_gain(_tags, _gain_q8): return libopusfile.opus_tags_get_track_gain(_tags, _gain_q8) libopusfile.opus_tags_clear.restype = None libopusfile.opus_tags_clear.argtypes = [ot_p] def opus_tags_clear(_tags): return libopusfile.opus_tags_clear(_tags) libopusfile.opus_tagcompare.restype = c_int libopusfile.opus_tagcompare.argtypes = [c_char_p, c_char_p] def opus_tagcompare(_tag_name, _comment): return libopusfile.opus_tagcompare(_tag_name, _comment) libopusfile.opus_tagncompare.restype = c_int libopusfile.opus_tagncompare.argtypes = [c_char_p, c_int, c_char_p] def opus_tagncompare(_tag_name, _tag_len, _comment): return libopusfile.opus_tagncompare(_tag_name, _tag_len, _comment) libopusfile.opus_picture_tag_parse.restype = c_int libopusfile.opus_picture_tag_parse.argtypes = [opt_p, c_char_p] def opus_picture_tag_parse(_pic, _tag): return libopusfile.opus_picture_tag_parse(_pic, _tag) libopusfile.opus_picture_tag_init.restype = None libopusfile.opus_picture_tag_init.argtypes = [opt_p] def opus_picture_tag_init(_pic): return libopusfile.opus_picture_tag_init(_pic) libopusfile.opus_picture_tag_clear.restype = None libopusfile.opus_picture_tag_clear.argtypes = [opt_p] def opus_picture_tag_clear(_pic): return libopusfile.opus_picture_tag_clear(_pic) class OpusServerInfo(ctypes.Structure): _fields_ = [("name", c_char_p), ("description", c_char_p), ("genre", c_char_p), ("url", c_char_p), ("server", c_char_p), ("content_type", c_char_p), ("bitrate_kbps", opus_int32), ("is_public", c_int), ("is_ssl", c_int)] osi_p = POINTER(OpusServerInfo) try: libopusfile.opus_server_info_init.restype = None libopusfile.opus_server_info_init.argtypes = [osi_p] def opus_server_info_init(_info): return libopusfile.opus_server_info_init(_info) libopusfile.opus_server_info_clear.restype = None libopusfile.opus_server_info_clear.argtypes = [osi_p] def opus_server_info_clear(_info): return libopusfile.opus_server_info_clear(_info) except: pass op_read_func = ctypes.CFUNCTYPE(c_int, c_void_p, c_uchar_p, c_int) op_seek_func = ctypes.CFUNCTYPE(c_int, c_void_p, opus_int64, c_int) op_tell_func = ctypes.CFUNCTYPE(opus_int64, c_void_p) op_close_func = ctypes.CFUNCTYPE(c_int, c_void_p) class OpusFileCallbacks(ctypes.Structure): _fields_ = [("read", op_read_func), ("seek", op_seek_func), ("tell", op_tell_func), ("close", op_close_func)] ofc_p = POINTER(OpusFileCallbacks) libopusfile.op_fopen.restype = c_void_p libopusfile.op_fopen.argtypes = [ofc_p, c_char_p, c_char_p] def op_fopen(_cb, _path, _mode): return libopusfile.op_fopen(_cb, _path, _mode) libopusfile.op_fdopen.restype = c_void_p libopusfile.op_fdopen.argtypes = [ofc_p, c_int, c_char_p] def op_fdopen(_cb, _fd, _mode): return libopusfile.op_fdopen(_cb, _fd, _mode) libopusfile.op_freopen.restype = c_void_p libopusfile.op_freopen.argtypes = [ofc_p, c_char_p, c_char_p, c_void_p] def op_freopen(_cb, _path, _mode, _stream): return libopusfile.op_freopen(_cb, _path, _mode, _stream) libopusfile.op_mem_stream_create.restype = c_void_p libopusfile.op_mem_stream_create.argtypes = [ofc_p, c_uchar_p, c_size_t] def op_mem_stream_create(_cb, _data, _size): return libopusfile.op_mem_stream_create(_cb, _data, _size) libopusfile.op_test.restype = c_int libopusfile.op_test.argtypes = [oh_p, c_uchar_p, c_size_t] def op_test(_head, _initial_data, _initial_bytes): return libopusfile.op_test(_head, _initial_data, _initial_bytes) libopusfile.op_open_file.restype = oof_p libopusfile.op_open_file.argtypes = [c_char_p, c_int_p] def op_open_file(_path, _error): return libopusfile.op_open_file(_path, _error) libopusfile.op_open_memory.restype = oof_p libopusfile.op_open_memory.argtypes = [c_uchar_p, c_size_t, c_int_p] def op_open_memory(_data, _size, _error): return libopusfile.op_open_memory(_data, _size, _error) libopusfile.op_open_callbacks.restype = oof_p libopusfile.op_open_callbacks.argtypes = [c_void_p, ofc_p, c_uchar_p, c_size_t, c_int_p] def op_open_callbacks(_source, _cb, _initial_data, _initial_bytes, _error): return libopusfile.op_open_callbacks(_source, _cb, _initial_data, _initial_bytes, _error) libopusfile.op_test_file.restype = oof_p libopusfile.op_test_file.argtypes = [c_char_p, c_int_p] def op_test_file(_path, _error): return libopusfile.op_test_file(_path, _error) libopusfile.op_test_memory.restype = oof_p libopusfile.op_test_memory.argtypes = [c_uchar_p, c_size_t, c_int_p] def op_test_memory(_data, _size, _error): return libopusfile.op_test_memory(_data, _size, _error) libopusfile.op_test_callbacks.restype = oof_p libopusfile.op_test_callbacks.argtypes = [c_void_p, ofc_p, c_uchar_p, c_size_t, c_int_p] def op_test_callbacks(_source, _cb, _initial_data, _initial_bytes, _error): return libopusfile.op_test_callbacks(_source, _cb, _initial_data, _initial_bytes, _error) libopusfile.op_test_open.restype = c_int libopusfile.op_test_open.argtypes = [oof_p] def op_test_open(_of): return libopusfile.op_test_open(_of) libopusfile.op_free.restype = None libopusfile.op_free.argtypes = [oof_p] def op_free(_of): return libopusfile.op_free(_of) libopusfile.op_seekable.restype = c_int libopusfile.op_seekable.argtypes = [oof_p] def op_seekable(_of): return libopusfile.op_seekable(_of) libopusfile.op_link_count.restype = c_int libopusfile.op_link_count.argtypes = [oof_p] def op_link_count(_of): return libopusfile.op_link_count(_of) libopusfile.op_serialno.restype = opus_uint32 libopusfile.op_serialno.argtypes = [oof_p, c_int] def op_serialno(_of, _li): return libopusfile.op_serialno(_of, _li) libopusfile.op_channel_count.restype = c_int libopusfile.op_channel_count.argtypes = [oof_p, c_int] def op_channel_count(_of, _li): return libopusfile.op_channel_count(_of, _li) libopusfile.op_raw_total.restype = opus_int64 libopusfile.op_raw_total.argtypes = [oof_p, c_int] def op_raw_total(_of, _li): return libopusfile.op_raw_total(_of, _li) libopusfile.op_pcm_total.restype = ogg_int64_t libopusfile.op_pcm_total.argtypes = [oof_p, c_int] def op_pcm_total(_of, _li): return libopusfile.op_pcm_total(_of, _li) libopusfile.op_head.restype = oh_p libopusfile.op_head.argtypes = [oof_p, c_int] def op_head(_of, _li): return libopusfile.op_head(_of, _li) libopusfile.op_tags.restype = ot_p libopusfile.op_tags.argtypes = [oof_p, c_int] def op_tags(_of, _li): return libopusfile.op_tags(_of, _li) libopusfile.op_current_link.restype = c_int libopusfile.op_current_link.argtypes = [oof_p] def op_current_link(_of): return libopusfile.op_current_link(_of) libopusfile.op_bitrate.restype = opus_int32 libopusfile.op_bitrate.argtypes = [oof_p, c_int] def op_bitrate(_of, _li): return libopusfile.op_bitrate(_of, _li) libopusfile.op_bitrate_instant.restype = opus_int32 libopusfile.op_bitrate_instant.argtypes = [oof_p] def op_bitrate_instant(_of): return libopusfile.op_bitrate_instant(_of) libopusfile.op_raw_tell.restype = opus_int64 libopusfile.op_raw_tell.argtypes = [oof_p] def op_raw_tell(_of): return libopusfile.op_raw_tell(_of) libopusfile.op_pcm_tell.restype = ogg_int64_t libopusfile.op_pcm_tell.argtypes = [oof_p] def op_pcm_tell(_of): return libopusfile.op_pcm_tell(_of) libopusfile.op_raw_seek.restype = c_int libopusfile.op_raw_seek.argtypes = [oof_p, opus_int64] def op_raw_seek(_of, _byte_offset): return libopusfile.op_raw_seek(_of, _byte_offset) libopusfile.op_pcm_seek.restype = c_int libopusfile.op_pcm_seek.argtypes = [oof_p,ogg_int64_t] def op_pcm_seek(_of, _pcm_offset): return libopusfile.op_pcm_seek(_of, _pcm_offset) op_decode_cb_func = ctypes.CFUNCTYPE(c_int, c_void_p, omsd_p, c_void_p, op_p, c_int, c_int, c_int, c_int) libopusfile.op_set_decode_callback.restype = None libopusfile.op_set_decode_callback.argtypes = [oof_p, op_decode_cb_func, c_void_p] def op_set_decode_callback(_of, _decode_cb, _ctx): return libopusfile.op_set_decode_callback(_of, _decode_cb, _ctx) libopusfile.op_set_gain_offset.restype = c_int libopusfile.op_set_gain_offset.argtypes = [oof_p, c_int, opus_int32] def op_set_gain_offset(_of, _gain_type, _gain_offset_q8): return libopusfile.op_set_gain_offset(_of, _gain_type, _gain_offset_q8) libopusfile.op_set_dither_enabled.restype = None libopusfile.op_set_dither_enabled.argtypes = [oof_p, c_int] def op_set_dither_enabled(_of, _enabled): return libopusfile.op_set_dither_enabled(_of, _enabled) libopusfile.op_read.restype = c_int libopusfile.op_read.argtypes = [oof_p, opus_int16_p, c_int, c_int_p] def op_read(_of, _pcm, _buf_size, _li): return libopusfile.op_read(_of, _pcm, _buf_size, _li) libopusfile.op_read_float.restype = c_int libopusfile.op_read_float.argtypes = [oof_p, c_float_p, c_int, c_int_p] def op_read_float(_of, _pcm, _buf_size, _li): return libopusfile.op_read_float(_of, _pcm, _buf_size, _li) libopusfile.op_read_stereo.restype = c_int libopusfile.op_read_stereo.argtypes = [oof_p, opus_int16_p, c_int] def op_read_stereo(_of, _pcm, _buf_size): return libopusfile.op_read_stereo(_of, _pcm, _buf_size) libopusfile.op_read_float_stereo.restype = c_int libopusfile.op_read_float_stereo.argtypes = [oof_p, c_float_p, c_int] def op_read_float_stereo(_of, _pcm, _buf_size): return libopusfile.op_read_float_stereo(_of, _pcm, _buf_size) if PYOGG_OPUS_ENC_AVAIL: ope_write_func = ctypes.CFUNCTYPE(c_int, c_void_p, c_uchar_p, opus_int32) ope_close_func = ctypes.CFUNCTYPE(c_int, c_void_p) ope_packet_func = ctypes.CFUNCTYPE(c_int, c_void_p, c_uchar_p, opus_int32, opus_uint32) class OpusEncCallbacks(ctypes.Structure): _fields_ = [("write", ope_write_func), ("close", ope_close_func)] oec_p = POINTER(OpusEncCallbacks) class OggOpusComments(ctypes.Structure): _fields_ = [("dummy", c_int)] ooc_p = POINTER(OggOpusComments) class OggOpusEnc(ctypes.Structure): _fields_ = [("dummy", c_int)] ooe_p = POINTER(OggOpusEnc) libopusenc.ope_comments_create.restype = ooc_p libopusenc.ope_comments_create.argtypes = None def ope_comments_create(): return libopusenc.ope_comments_create() libopusenc.ope_comments_copy.restype = ooc_p libopusenc.ope_comments_copy.argtypes = [ooc_p] def ope_comments_copy(comments): return libopusenc.ope_comments_copy(comments) libopusenc.ope_comments_destroy.restype = None libopusenc.ope_comments_destroy.argtypes = [ooc_p] def ope_comments_destroy(comments): return libopusenc.ope_comments_destroy(comments) libopusenc.ope_comments_add.restype = c_int libopusenc.ope_comments_add.argtypes = [ooc_p, c_char_p, c_char_p] def ope_comments_add(comments, tag, val): return libopusenc.ope_comments_add(comments, tag, val) libopusenc.ope_comments_add_string.restype = c_int libopusenc.ope_comments_add_string.argtypes = [ooc_p, c_char_p] def ope_comments_add_string(comments, tag_and_val): return libopusenc.ope_comments_add_string(comments, tag_and_val) libopusenc.ope_comments_add_picture.restype = c_int libopusenc.ope_comments_add_picture.argtypes = [ooc_p, c_char_p, c_int, c_char_p] def ope_comments_add_picture(comments, filename, picture_type, description): return libopusenc.ope_comments_add_picture(comments, filename, picture_type, description) libopusenc.ope_encoder_create_file.restype = ooe_p libopusenc.ope_encoder_create_file.argtypes = [c_char_p, ooc_p, opus_int32, c_int, c_int, c_int_p] def ope_encoder_create_file(path, comments, rate, channels, family, error): return libopusenc.ope_encoder_create_file(path, comments, rate, channels, family, error) libopusenc.ope_encoder_create_callbacks.restype = ooe_p libopusenc.ope_encoder_create_callbacks.argtypes = [oec_p, c_void_p, ooc_p, opus_int32, c_int, c_int, c_int_p] def ope_encoder_create_callbacks(callbacks, user_data, comments, rate, channels, family, error): return libopusenc.ope_encoder_create_callbacks(callbacks, user_data, comments, rate, channels, family, error) libopusenc.ope_encoder_create_pull.restype = ooe_p libopusenc.ope_encoder_create_pull.argtypes = [ooc_p, opus_int32, c_int, c_int, c_int_p] def ope_encoder_create_pull(comments, rate, channels, family, error): return libopusenc.ope_encoder_create_pull(comments, rate, channels, family, error) libopusenc.ope_encoder_write_float.restype = c_int libopusenc.ope_encoder_write_float.argtypes = [ooe_p, c_float_p, c_int] def ope_encoder_write_float(enc, pcm, samples_per_channel): return libopusenc.ope_encoder_write_float(enc, pcm, samples_per_channel) libopusenc.ope_encoder_write.restype = c_int libopusenc.ope_encoder_write.argtypes = [ooe_p, opus_int16_p, c_int] def ope_encoder_write(enc, pcm, samples_per_channel): return libopusenc.ope_encoder_write(enc, pcm, samples_per_channel) libopusenc.ope_encoder_get_page.restype = c_int libopusenc.ope_encoder_get_page.argtypes = [ooe_p, POINTER(c_uchar_p), opus_int32_p, c_int] def ope_encoder_get_page(enc, page, len, flush): return libopusenc.ope_encoder_get_page(enc, page, len, flush) libopusenc.ope_encoder_drain.restype = c_int libopusenc.ope_encoder_drain.argtypes = [ooe_p] def ope_encoder_drain(enc): return libopusenc.ope_encoder_drain(enc) libopusenc.ope_encoder_destroy.restype = None libopusenc.ope_encoder_destroy.argtypes = [ooe_p] def ope_encoder_destroy(enc): return libopusenc.ope_encoder_destroy(enc) libopusenc.ope_encoder_chain_current.restype = c_int libopusenc.ope_encoder_chain_current.argtypes = [ooe_p, ooc_p] def ope_encoder_chain_current(enc, comments): return libopusenc.ope_encoder_chain_current(enc, comments) libopusenc.ope_encoder_continue_new_file.restype = c_int libopusenc.ope_encoder_continue_new_file.argtypes = [ooe_p, c_char_p, ooc_p] def ope_encoder_continue_new_file(enc,path, comments): return libopusenc.ope_encoder_continue_new_file(enc,path, comments) libopusenc.ope_encoder_continue_new_callbacks.restype = c_int libopusenc.ope_encoder_continue_new_callbacks.argtypes = [ooe_p, c_void_p, ooc_p] def ope_encoder_continue_new_callbacks(enc,user_data, comments): return libopusenc.ope_encoder_continue_new_callbacks(enc,user_data, comments) libopusenc.ope_encoder_flush_header.restype = c_int libopusenc.ope_encoder_flush_header.argtypes = [ooe_p] def ope_encoder_flush_header(enc): return libopusenc.ope_encoder_flush_header(enc) libopusenc.ope_encoder_ctl.restype = c_int libopusenc.ope_encoder_ctl.argtypes = [ooe_p, c_int] def ope_encoder_ctl(enc, request, *args): return libopusenc.ope_encoder_ctl(enc, request, *args) libopusenc.ope_strerror.restype = c_char_p libopusenc.ope_strerror.argtypes = [c_int] def ope_strerror(error): return libopusenc.ope_strerror(error) libopusenc.ope_get_version_string.restype = c_char_p libopusenc.ope_get_version_string.argtypes = None def ope_get_version_string(): return libopusenc.ope_get_version_string() libopusenc.ope_get_abi_version.restype = c_int libopusenc.ope_get_abi_version.argtypes = None def ope_get_abi_version(): return libopusenc.ope_get_abi_version()