Hello community, here is the log from the commit of package python-PyOgg for openSUSE:Factory checked in at 2019-03-05 12:24:54 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-PyOgg (Old) and /work/SRC/openSUSE:Factory/.python-PyOgg.new.28833 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-PyOgg" Tue Mar 5 12:24:54 2019 rev:3 rq:681516 version:0.6.7a1 Changes: -------- --- /work/SRC/openSUSE:Factory/python-PyOgg/python-PyOgg.changes 2019-01-24 14:02:50.976090228 +0100 +++ /work/SRC/openSUSE:Factory/.python-PyOgg.new.28833/python-PyOgg.changes 2019-03-05 12:24:57.132848193 +0100 @@ -1,0 +2,6 @@ +Mon Mar 4 16:46:04 UTC 2019 - Tomáš Chvátal <[email protected]> + +- Update to 0.6.7a1: + * no upstream changelog + +------------------------------------------------------------------- Old: ---- PyOgg-0.6.4a1.tar.gz New: ---- PyOgg-0.6.7a1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-PyOgg.spec ++++++ --- /var/tmp/diff_new_pack.fuSQwl/_old 2019-03-05 12:24:57.692848022 +0100 +++ /var/tmp/diff_new_pack.fuSQwl/_new 2019-03-05 12:24:57.696848021 +0100 @@ -1,7 +1,7 @@ # # spec file for package python-PyOgg # -# Copyright (c) 2018 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2019 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -18,15 +18,16 @@ %{?!python_module:%define python_module() python-%{**} python3-%{**}} Name: python-PyOgg -Version: 0.6.4a1 +Version: 0.6.7a1 Release: 0 Summary: Python bindings for Xiphorg's Ogg Vorbis, Opus and FLAC License: BSD-3-Clause Group: Development/Languages/Python -Url: https://github.com/Zuzu-Typ/PyOgg +URL: https://github.com/Zuzu-Typ/PyOgg Source: https://files.pythonhosted.org/packages/source/P/PyOgg/PyOgg-%{version}.tar.gz BuildRequires: %{python_module setuptools} BuildRequires: fdupes +BuildRequires: pkgconfig BuildRequires: python-rpm-macros BuildRequires: pkgconfig(libopusenc) BuildRequires: pkgconfig(ogg) @@ -34,8 +35,6 @@ BuildRequires: pkgconfig(opusfile) BuildRequires: pkgconfig(vorbisenc) BuildRequires: pkgconfig(vorbisfile) -Recommends: libflac -Recommends: libvorbis # Automatically get so numbers Recommends: %( ls %{_libdir}/libogg.so.*.*.* | sed -r 's/.*(libogg\.so\.[0-9]*)\..*/\1/g' ) Recommends: %( ls %{_libdir}/libopus.so.*.*.* | sed -r 's/.*(libopus\.so\.[0-9]*)\..*/\1/g' ) @@ -43,8 +42,9 @@ Recommends: %( ls %{_libdir}/libopusfile.so.*.*.* | sed -r 's/.*(libopusfile\.so\.[0-9]*)\..*/\1/g' ) Recommends: %( ls %{_libdir}/libvorbisenc.so.*.*.* | sed -r 's/.*(libvorbisenc\.so\.[0-9]*)\..*/\1/g' ) Recommends: %( ls %{_libdir}/libvorbisfile.so.*.*.* | sed -r 's/.*(libvorbisfile\.so\.[0-9]*)\..*/\1/g' ) +Recommends: libflac +Recommends: libvorbis BuildArch: noarch - %python_subpackages %description ++++++ PyOgg-0.6.4a1.tar.gz -> PyOgg-0.6.7a1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/PyOgg-0.6.4a1/PKG-INFO new/PyOgg-0.6.7a1/PKG-INFO --- old/PyOgg-0.6.4a1/PKG-INFO 2018-06-25 14:59:15.000000000 +0200 +++ new/PyOgg-0.6.7a1/PKG-INFO 2019-03-01 11:42:07.000000000 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 2.1 Name: PyOgg -Version: 0.6.4a1 +Version: 0.6.7a1 Summary: Xiph.org's Ogg Vorbis, Opus and FLAC for Python Home-page: https://github.com/Zuzu-Typ/PyOgg Author: Zuzu_Typ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/PyOgg-0.6.4a1/PyOgg.egg-info/PKG-INFO new/PyOgg-0.6.7a1/PyOgg.egg-info/PKG-INFO --- old/PyOgg-0.6.4a1/PyOgg.egg-info/PKG-INFO 2018-06-25 14:59:15.000000000 +0200 +++ new/PyOgg-0.6.7a1/PyOgg.egg-info/PKG-INFO 2019-03-01 11:42:07.000000000 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 2.1 Name: PyOgg -Version: 0.6.4a1 +Version: 0.6.7a1 Summary: Xiph.org's Ogg Vorbis, Opus and FLAC for Python Home-page: https://github.com/Zuzu-Typ/PyOgg Author: Zuzu_Typ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/PyOgg-0.6.4a1/pyogg/__init__.py new/PyOgg-0.6.7a1/pyogg/__init__.py --- old/PyOgg-0.6.4a1/pyogg/__init__.py 2018-05-02 19:59:30.000000000 +0200 +++ new/PyOgg-0.6.7a1/pyogg/__init__.py 2018-12-22 09:29:31.000000000 +0100 @@ -210,10 +210,15 @@ self.ptr_init = self.ptr.contents.value def get_buffer(self): + if not hasattr(self, 'ptr'): + return None + samples_read = ctypes.c_int(0) while True: self.ptr.contents.value = self.ptr_init + samples_read.value*self.channels*2 ns = opus.op_read(self.of, self.buffer , PYOGG_STREAM_BUFFER_SIZE*self.channels,ogg.c_int_p()) + if ns == 0: + break samples_read.value += ns if samples_read.value*self.channels*2 + ns >= PYOGG_STREAM_BUFFER_SIZE: break @@ -231,7 +236,7 @@ return(buf, samples_read.value*self.channels*2) def clean_up(self): - self.ptr.contents.value = ptr_init + self.ptr.contents.value = self.ptr_init del self.ptr diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/PyOgg-0.6.4a1/pyogg/flac.py new/PyOgg-0.6.7a1/pyogg/flac.py --- old/PyOgg-0.6.4a1/pyogg/flac.py 2018-06-25 14:29:26.000000000 +0200 +++ new/PyOgg-0.6.7a1/pyogg/flac.py 2019-03-01 11:40:24.000000000 +0100 @@ -42,15 +42,15 @@ from .ogg import * -from . import library_loader as ExternalLibrary +from .library_loader import ExternalLibrary, ExternalLibraryError __here = os.getcwd() libflac = None try: - libflac = ExternalLibrary.load("flac") -except ExternalLibrary.NotFoundError: + libflac = ExternalLibrary.load("FLAC", tests = [lambda lib: hasattr(lib, "FLAC__EntropyCodingMethodTypeString")]) +except ExternalLibraryError: pass except: _print_exc() @@ -146,37 +146,15 @@ FLAC__MAX_RICE_PARTITION_ORDER =(15) FLAC__SUBSET_MAX_RICE_PARTITION_ORDER =(8) - libflac.FLAC__VERSION_STRING.restype = c_char_p - libflac.FLAC__VERSION_STRING.argtypes = None + FLAC__VERSION_STRING = c_char_p.in_dll(libflac, "FLAC__VERSION_STRING") - def FLAC__VERSION_STRING(): - return libflac.FLAC__VERSION_STRING() + FLAC__VENDOR_STRING = c_char_p.in_dll(libflac, "FLAC__VENDOR_STRING") - libflac.FLAC__VENDOR_STRING.restype = c_char_p - libflac.FLAC__VENDOR_STRING.argtypes = None - - def FLAC__VENDOR_STRING(): - return libflac.FLAC__VENDOR_STRING() - - libflac.FLAC__STREAM_SYNC_STRING.restype = FLAC__byte * 4 - libflac.FLAC__STREAM_SYNC_STRING.argtypes = None - - def FLAC__STREAM_SYNC_STRING(): - return libflac.FLAC__STREAM_SYNC_STRING() - - libflac.FLAC__STREAM_SYNC.restype = c_uint - libflac.FLAC__STREAM_SYNC.argtypes = None - - def FLAC__STREAM_SYNC(): - return libflac.FLAC__STREAM_SYNC() - - libflac.FLAC__STREAM_SYNC_LEN.restype = c_uint - libflac.FLAC__STREAM_SYNC_LEN.argtypes = None - - def FLAC__STREAM_SYNC_LEN(): - return libflac.FLAC__STREAM_SYNC_LEN() + FLAC__STREAM_SYNC_STRING = (FLAC__byte * 4).in_dll(libflac, "FLAC__STREAM_SYNC_STRING") + FLAC__STREAM_SYNC = c_uint.in_dll(libflac, "FLAC__STREAM_SYNC") + FLAC__STREAM_SYNC_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_SYNC_LEN") FLAC__STREAM_SYNC_LENGTH =(4) @@ -208,36 +186,15 @@ ("contents", POINTER(FLAC__EntropyCodingMethod_PartitionedRiceContents))] + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN = c_uint.in_dll(libflac, "FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN") - libflac.FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN.restype = c_uint - libflac.FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN.argtypes = None - - def FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN(): - return libflac.FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN() - - libflac.FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN.restype = c_uint - libflac.FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN.argtypes = None - - def FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN(): - return libflac.FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN() - - libflac.FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN.restype = c_uint - libflac.FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN.argtypes = None - - def FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN(): - return libflac.FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN() - - libflac.FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN.restype = c_uint - libflac.FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN.argtypes = None + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN = c_uint.in_dll(libflac, "FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN") - def FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN(): - return libflac.FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN() + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN = c_uint.in_dll(libflac, "FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN") - libflac.FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER.restype = c_uint - libflac.FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER.argtypes = None + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN = c_uint.in_dll(libflac, "FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN") - def FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER(): - return libflac.FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER() + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER = c_uint.in_dll(libflac, "FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER") class FLAC__EntropyCodingMethod_data(Union): @@ -246,13 +203,8 @@ class FLAC__EntropyCodingMethod(Structure): _fields_ = [("type", POINTER(FLAC__EntropyCodingMethodType)), ("data", FLAC__EntropyCodingMethod_data)] - - - libflac.FLAC__ENTROPY_CODING_METHOD_TYPE_LEN.restype = c_uint - libflac.FLAC__ENTROPY_CODING_METHOD_TYPE_LEN.argtypes = None - def FLAC__ENTROPY_CODING_METHOD_TYPE_LEN(): - return libflac.FLAC__ENTROPY_CODING_METHOD_TYPE_LEN() + FLAC__ENTROPY_CODING_METHOD_TYPE_LEN = c_uint.in_dll(libflac, "FLAC__ENTROPY_CODING_METHOD_TYPE_LEN") @@ -297,17 +249,9 @@ ("residual", FLAC__int32_p)] - libflac.FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN.restype = c_uint - libflac.FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN.argtypes = None - - def FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN(): - return libflac.FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN() + FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN = c_uint.in_dll(libflac, "FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN") - libflac.FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN.restype = c_uint - libflac.FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN.argtypes = None - - def FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN(): - return libflac.FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN() + FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN = c_uint.in_dll(libflac, "FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN") @@ -323,49 +267,19 @@ ("wasted_bits", c_uint)] - libflac.FLAC__SUBFRAME_ZERO_PAD_LEN.restype = c_uint - libflac.FLAC__SUBFRAME_ZERO_PAD_LEN.argtypes = None - - def FLAC__SUBFRAME_ZERO_PAD_LEN(): - return libflac.FLAC__SUBFRAME_ZERO_PAD_LEN() - - libflac.FLAC__SUBFRAME_TYPE_LEN.restype = c_uint - libflac.FLAC__SUBFRAME_TYPE_LEN.argtypes = None - - def FLAC__SUBFRAME_TYPE_LEN(): - return libflac.FLAC__SUBFRAME_TYPE_LEN() - - libflac.FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN.restype = c_uint - libflac.FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN.argtypes = None - - def FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN(): - return libflac.FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN() - - - - libflac.FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK.restype = c_uint - libflac.FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK.argtypes = None - - def FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK(): - return libflac.FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK() - - libflac.FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK.restype = c_uint - libflac.FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK.argtypes = None + FLAC__SUBFRAME_ZERO_PAD_LEN = c_uint.in_dll(libflac, "FLAC__SUBFRAME_ZERO_PAD_LEN") + + FLAC__SUBFRAME_TYPE_LEN = c_uint.in_dll(libflac, "FLAC__SUBFRAME_TYPE_LEN") - def FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK(): - return libflac.FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK() + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN = c_uint.in_dll(libflac, "FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN") - libflac.FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK.restype = c_uint - libflac.FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK.argtypes = None + FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK = c_uint.in_dll(libflac, "FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK") - def FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK(): - return libflac.FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK() + FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK = c_uint.in_dll(libflac, "FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK") - libflac.FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK.restype = c_uint - libflac.FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK.argtypes = None + FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK = c_uint.in_dll(libflac, "FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK") - def FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK(): - return libflac.FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK() + FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK = c_uint.in_dll(libflac, "FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK") FLAC__ChannelAssignment = c_int @@ -408,77 +322,30 @@ ("crc", FLAC__uint8)] - libflac.FLAC__FRAME_HEADER_SYNC.restype = c_uint - libflac.FLAC__FRAME_HEADER_SYNC.argtypes = None - - def FLAC__FRAME_HEADER_SYNC(): - return libflac.FLAC__FRAME_HEADER_SYNC() - - libflac.FLAC__FRAME_HEADER_SYNC_LEN.restype = c_uint - libflac.FLAC__FRAME_HEADER_SYNC_LEN.argtypes = None - - def FLAC__FRAME_HEADER_SYNC_LEN(): - return libflac.FLAC__FRAME_HEADER_SYNC_LEN() - - libflac.FLAC__FRAME_HEADER_RESERVED_LEN.restype = c_uint - libflac.FLAC__FRAME_HEADER_RESERVED_LEN.argtypes = None - - def FLAC__FRAME_HEADER_RESERVED_LEN(): - return libflac.FLAC__FRAME_HEADER_RESERVED_LEN() - - libflac.FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN.restype = c_uint - libflac.FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN.argtypes = None - - def FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN(): - return libflac.FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN() - - libflac.FLAC__FRAME_HEADER_BLOCK_SIZE_LEN.restype = c_uint - libflac.FLAC__FRAME_HEADER_BLOCK_SIZE_LEN.argtypes = None - - def FLAC__FRAME_HEADER_BLOCK_SIZE_LEN(): - return libflac.FLAC__FRAME_HEADER_BLOCK_SIZE_LEN() + FLAC__FRAME_HEADER_SYNC = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_SYNC") - libflac.FLAC__FRAME_HEADER_SAMPLE_RATE_LEN.restype = c_uint - libflac.FLAC__FRAME_HEADER_SAMPLE_RATE_LEN.argtypes = None + FLAC__FRAME_HEADER_RESERVED_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_RESERVED_LEN") - def FLAC__FRAME_HEADER_SAMPLE_RATE_LEN(): - return libflac.FLAC__FRAME_HEADER_SAMPLE_RATE_LEN() + FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN") - libflac.FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN.restype = c_uint - libflac.FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN.argtypes = None + FLAC__FRAME_HEADER_BLOCK_SIZE_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_BLOCK_SIZE_LEN") - def FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN(): - return libflac.FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN() + FLAC__FRAME_HEADER_SAMPLE_RATE_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_SAMPLE_RATE_LEN") - libflac.FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN.restype = c_uint - libflac.FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN.argtypes = None + FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN") - def FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN(): - return libflac.FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN() + FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN") - libflac.FLAC__FRAME_HEADER_ZERO_PAD_LEN.restype = c_uint - libflac.FLAC__FRAME_HEADER_ZERO_PAD_LEN.argtypes = None + FLAC__FRAME_HEADER_ZERO_PAD_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_ZERO_PAD_LEN") - def FLAC__FRAME_HEADER_ZERO_PAD_LEN(): - return libflac.FLAC__FRAME_HEADER_ZERO_PAD_LEN() - - libflac.FLAC__FRAME_HEADER_CRC_LEN.restype = c_uint - libflac.FLAC__FRAME_HEADER_CRC_LEN.argtypes = None - - def FLAC__FRAME_HEADER_CRC_LEN(): - return libflac.FLAC__FRAME_HEADER_CRC_LEN() + FLAC__FRAME_HEADER_CRC_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_CRC_LEN") class FLAC__FrameFooter(Structure): _fields_ = [("crc", FLAC__uint16)] - - libflac.FLAC__FRAME_FOOTER_CRC_LEN.restype = c_uint - libflac.FLAC__FRAME_FOOTER_CRC_LEN.argtypes = None - - def FLAC__FRAME_FOOTER_CRC_LEN(): - return libflac.FLAC__FRAME_FOOTER_CRC_LEN() + FLAC__FRAME_FOOTER_CRC_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_FOOTER_CRC_LEN") @@ -529,60 +396,24 @@ ("total_samples", FLAC__uint64), ("md5sum", FLAC__byte*16)] - libflac.FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN.argtypes = None - - def FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN(): - return libflac.FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN() - - libflac.FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN.argtypes = None - - def FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN(): - return libflac.FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN() - - libflac.FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN.argtypes = None - - def FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN(): - return libflac.FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN() - - libflac.FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN.argtypes = None - - def FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN(): - return libflac.FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN() - + FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN") - libflac.FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN.argtypes = None + FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN") - def FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN(): - return libflac.FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN() + FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN") - libflac.FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN.argtypes = None + FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN") - def FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN(): - return libflac.FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN() + FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN") - libflac.FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN.argtypes = None - def FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN(): - return libflac.FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN() + FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN") - libflac.FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN.argtypes = None + FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN") - def FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN(): - return libflac.FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN() + FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN") - libflac.FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN.argtypes = None - - def FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN(): - return libflac.FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN() + FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN") FLAC__STREAM_METADATA_STREAMINFO_LENGTH =(34) @@ -596,45 +427,24 @@ _fields_ = [("id", FLAC__byte*4), ("data", FLAC__byte_p)] - - libflac.FLAC__STREAM_METADATA_APPLICATION_ID_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_APPLICATION_ID_LEN.argtypes = None - - def FLAC__STREAM_METADATA_APPLICATION_ID_LEN(): - return libflac.FLAC__STREAM_METADATA_APPLICATION_ID_LEN() - + FLAC__STREAM_METADATA_APPLICATION_ID_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_APPLICATION_ID_LEN") + class FLAC__StreamMetadata_SeekPoint(Structure): _fields_ = [("sample_number", FLAC__uint64), ("stream_offset", FLAC__uint64), ("frame_samples", c_uint)] - libflac.FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN.argtypes = None - - def FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN(): - return libflac.FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN() - - libflac.FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN.argtypes = None + FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN") - def FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN(): - return libflac.FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN() + FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN") - libflac.FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN.argtypes = None - - def FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN(): - return libflac.FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN() + FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN") FLAC__STREAM_METADATA_SEEKPOINT_LENGTH =(18) - libflac.FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER.restype = FLAC__uint64 - libflac.FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER.argtypes = None - - def FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER(): - return libflac.FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER() + FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER = FLAC__uint64.in_dll(libflac, "FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER") class FLAC__StreamMetadata_SeekTable(Structure): _fields_ = [("num_points", c_uint), @@ -644,12 +454,7 @@ _fields_ = [("length", FLAC__uint32), ("entry", FLAC__byte_p)] - - libflac.FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN.argtypes = None - - def FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN(): - return libflac.FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN() + FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN") class FLAC__StreamMetadata_VorbisComment(Structure): @@ -657,36 +462,19 @@ ("num_comments", FLAC__uint32), ("comments", POINTER(FLAC__StreamMetadata_VorbisComment_Entry))] - - libflac.FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN.argtypes = None - - def FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN(): - return libflac.FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN() + FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN") class FLAC__StreamMetadata_CueSheet_Index(Structure): _fields_ = [("offset", FLAC__uint64), ("number", FLAC__byte)] + + FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN") + + FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN") - libflac.FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN.argtypes = None - - def FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN(): - return libflac.FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN() - - libflac.FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN.argtypes = None - - def FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN(): - return libflac.FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN() - - libflac.FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN.argtypes = None - - def FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN(): - return libflac.FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN() + FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN") class FLAC__StreamMetadata_CueSheet_Track(Structure): @@ -697,49 +485,20 @@ ("pre_emphasis", c_uint), ("num_indices", FLAC__byte), ("indices", POINTER(FLAC__StreamMetadata_CueSheet_Index))] - - libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN.argtypes = None - - def FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN(): - return libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN() - - libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN.argtypes = None - - def FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN(): - return libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN() - - libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN.argtypes = None - def FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN(): - return libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN() - - libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN.argtypes = None - - def FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN(): - return libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN() - - libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN.argtypes = None - - def FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN(): - return libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN() + FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN") + + FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN") - libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN.argtypes = None + FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN") - def FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN(): - return libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN() + FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN") - libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN.argtypes = None + FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN") - def FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN(): - return libflac.FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN() + FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN") + FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN") class FLAC__StreamMetadata_CueSheet(Structure): @@ -748,37 +507,17 @@ ("is_cd", FLAC__bool), ("num_tracks", c_uint), ("tracks", POINTER(FLAC__StreamMetadata_CueSheet_Track))] - - libflac.FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN.argtypes = None - - def FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN(): - return libflac.FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN() - - libflac.FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN.argtypes = None - - def FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN(): - return libflac.FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN() - - libflac.FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN.argtypes = None - - def FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN(): - return libflac.FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN() + FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN") + - libflac.FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN.argtypes = None + FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN") - def FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN(): - return libflac.FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN() + FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN") - libflac.FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN.argtypes = None + FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN") - def FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN(): - return libflac.FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN() + FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN") FLAC__StreamMetadata_Picture_Type = c_int @@ -822,55 +561,23 @@ ("colors", FLAC__uint32), ("data_length", FLAC__uint32), ("data", FLAC__byte)] - - libflac.FLAC__STREAM_METADATA_PICTURE_TYPE_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_PICTURE_TYPE_LEN.argtypes = None - - def FLAC__STREAM_METADATA_PICTURE_TYPE_LEN(): - return libflac.FLAC__STREAM_METADATA_PICTURE_TYPE_LEN() - - libflac.FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN.argtypes = None - - def FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN(): - return libflac.FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN() - - libflac.FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN.argtypes = None - - def FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN(): - return libflac.FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN() - libflac.FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN.argtypes = None + FLAC__STREAM_METADATA_PICTURE_TYPE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_PICTURE_TYPE_LEN") - def FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN(): - return libflac.FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN() + FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN") + FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN") - libflac.FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN.argtypes = None + FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN") - def FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN(): - return libflac.FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN() + FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN") - libflac.FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN.argtypes = None - def FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN(): - return libflac.FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN() + FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN") - libflac.FLAC__STREAM_METADATA_PICTURE_COLORS_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_PICTURE_COLORS_LEN.argtypes = None + FLAC__STREAM_METADATA_PICTURE_COLORS_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_PICTURE_COLORS_LEN") - def FLAC__STREAM_METADATA_PICTURE_COLORS_LEN(): - return libflac.FLAC__STREAM_METADATA_PICTURE_COLORS_LEN() - - libflac.FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN.argtypes = None - - def FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN(): - return libflac.FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN() + FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN") class FLAC__StreamMetadata_Unknown(Structure): @@ -893,24 +600,11 @@ ("length", c_uint), ("data", FLAC__StreamMetadata_data)] + FLAC__STREAM_METADATA_IS_LAST_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_IS_LAST_LEN") - libflac.FLAC__STREAM_METADATA_IS_LAST_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_IS_LAST_LEN.argtypes = None - - def FLAC__STREAM_METADATA_IS_LAST_LEN(): - return libflac.FLAC__STREAM_METADATA_IS_LAST_LEN() - - libflac.FLAC__STREAM_METADATA_TYPE_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_TYPE_LEN.argtypes = None - - def FLAC__STREAM_METADATA_TYPE_LEN(): - return libflac.FLAC__STREAM_METADATA_TYPE_LEN() - - libflac.FLAC__STREAM_METADATA_LENGTH_LEN.restype = c_uint - libflac.FLAC__STREAM_METADATA_LENGTH_LEN.argtypes = None + FLAC__STREAM_METADATA_TYPE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_TYPE_LEN") - def FLAC__STREAM_METADATA_LENGTH_LEN(): - return libflac.FLAC__STREAM_METADATA_LENGTH_LEN() + FLAC__STREAM_METADATA_LENGTH_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_LENGTH_LEN") FLAC__STREAM_METADATA_HEADER_LENGTH =(4) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/PyOgg-0.6.4a1/pyogg/library_loader.py new/PyOgg-0.6.7a1/pyogg/library_loader.py --- old/PyOgg-0.6.4a1/pyogg/library_loader.py 2018-06-25 14:22:39.000000000 +0200 +++ new/PyOgg-0.6.7a1/pyogg/library_loader.py 2019-03-01 11:41:21.000000000 +0100 @@ -5,101 +5,86 @@ _here = os.path.dirname(__file__) -class ExternalLibraryNotFoundError(Exception): +class ExternalLibraryError(Exception): pass -class ExternalLibraryNotSupportedError(Exception): - pass - -NotFoundError = ExternalLibraryNotFoundError - -NotSupportedError = ExternalLibraryNotSupportedError - architecture = platform.architecture()[0] -windows_styles = ["{}", "{}.dll", "lib{}.dll", "lib{}_dynamic.dll", "{}_dynamic.dll"] +_windows_styles = ["{}", "lib{}", "lib{}_dynamic", "{}_dynamic"] -other_styles = ["{}.lib", "lib{}.lib", "{}.a", "lib{}.a", "{}.so", "lib{}.so", "{}.la", "lib{}.la"] +_other_styles = ["{}", "lib{}"] if architecture == "32bit": for arch_style in ["32bit", "32" "86", "win32", "x86", "_x86", "_32", "_win32", "_32bit"]: - for style in ["{}.dll", "lib{}.dll"]: - windows_styles.append(style.format("{}"+arch_style)) + for style in ["{}", "lib{}"]: + _windows_styles.append(style.format("{}"+arch_style)) elif architecture == "64bit": for arch_style in ["64bit", "64" "86_64", "amd64", "win_amd64", "x86_64", "_x86_64", "_64", "_amd64", "_64bit"]: - for style in ["{}.dll", "lib{}.dll"]: - windows_styles.append(style.format("{}"+arch_style)) + for style in ["{}", "lib{}"]: + _windows_styles.append(style.format("{}"+arch_style)) +_loaded_libraries = {} -def load(name, paths = None): - if sys.platform == "win32": - return load_windows(name, paths) - else: - return load_other(name, paths) - - -def load_other(name, paths = None): - library = ctypes.util.find_library(name) - if library: - return ctypes.CDLL(library) - - if paths: - for path in paths: - for style in other_styles: - candidate = os.path.join(path, style.format(name)) - if os.path.exists(candidate): - try: - return ctypes.CDLL(candidate) - except: - pass - else: - for path in [os.getcwd(), _here]: - for style in other_styles: - candidate = os.path.join(path, style.format(name)) - if os.path.exists(candidate): - try: - return ctypes.CDLL(candidate) - except: - pass - - -def load_windows(name, paths = None): - not_supported = [] # libraries that were found, but are not supported - for style in windows_styles: - candidate = style.format(name) - try: - return ctypes.CDLL(candidate) - except WindowsError: - pass - except OSError: - not_supported.append(candidate) - - if paths: - for path in paths: - for style in windows_styles: - candidate = os.path.join(path, style.format(name)) - if os.path.exists(candidate): - try: - return ctypes.CDLL(candidate) - except OSError: - not_supported.append(candidate) +run_tests = lambda lib, tests: [f(lib) for f in tests] - else: - for path in [os.getcwd(), _here]: - for style in windows_styles: - candidate = os.path.join(path, style.format(name)) - if os.path.exists(candidate): - try: - return ctypes.CDLL(candidate) - except OSError: +class ExternalLibrary: + @staticmethod + def load(name, paths = None, tests=[]): + if name in _loaded_libraries: + return _loaded_libraries[name] + if sys.platform == "win32": + lib = ExternalLibrary.load_windows(name, paths, tests) + _loaded_libraries[name] = lib + return lib + else: + lib = ExternalLibrary.load_other(name, paths, tests) + _loaded_libraries[name] = lib + return lib + + @staticmethod + def load_other(name, paths = None, tests=[]): + os.environ["PATH"] += ";" + ";".join((os.getcwd(), _here)) + if paths: os.environ["PATH"] += ";" + ";".join(paths) + + for style in _other_styles: + for name in (name.upper(), name.lower()): + candidate = style.format(name) + library = ctypes.util.find_library(candidate) + try: + lib = ctypes.CDLL(library) + if all(run_tests(lib,tests)): + return lib + except: + pass + + @staticmethod + def load_windows(name, paths = None, tests=[]): + os.environ["PATH"] += ";" + ";".join((os.getcwd(), _here)) + if paths: os.environ["PATH"] += ";" + ";".join(paths) + + not_supported = [] # libraries that were found, but are not supported + for style in _windows_styles: + candidate = style.format(name) + library = ctypes.util.find_library(candidate) + if library: + try: + lib = ctypes.CDLL(candidate) + if all(run_tests(lib,tests)): + return lib + else: not_supported.append(candidate) + except WindowsError: + pass + except OSError: + not_supported.append(candidate) + - if not_supported: - raise ExternalLibraryNotSupportedError("library '{}' couldn't be loaded, because the following candidates were not supported:".format(name) - + ("\n{}" * len(not_supported)).format(*not_supported)) + if not_supported: + raise ExternalLibraryError("library '{}' couldn't be loaded, because the following candidates were not supported:".format(name) + + ("\n{}" * len(not_supported)).format(*not_supported)) - raise ExternalLibraryNotFoundError("library '{}' couldn't be found".format(name)) + raise ExternalLibraryError("library '{}' couldn't be loaded".format(name)) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/PyOgg-0.6.4a1/pyogg/ogg.py new/PyOgg-0.6.7a1/pyogg/ogg.py --- old/PyOgg-0.6.4a1/pyogg/ogg.py 2018-06-25 14:29:10.000000000 +0200 +++ new/PyOgg-0.6.7a1/pyogg/ogg.py 2019-01-14 16:35:52.000000000 +0100 @@ -39,7 +39,7 @@ from traceback import print_exc as _print_exc import os -from . import library_loader as ExternalLibrary +from .library_loader import ExternalLibrary, ExternalLibraryError class PyOggError(Exception): pass @@ -54,8 +54,8 @@ libogg = None try: - libogg = ExternalLibrary.load("ogg") -except ExternalLibrary.NotFoundError: + libogg = ExternalLibrary.load("ogg", tests = [lambda lib: hasattr(lib, "oggpack_writeinit")]) +except ExternalLibraryError: pass except: _print_exc() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/PyOgg-0.6.4a1/pyogg/opus.py new/PyOgg-0.6.7a1/pyogg/opus.py --- old/PyOgg-0.6.4a1/pyogg/opus.py 2018-06-25 14:29:15.000000000 +0200 +++ new/PyOgg-0.6.7a1/pyogg/opus.py 2019-01-14 16:32:47.000000000 +0100 @@ -124,14 +124,14 @@ from .ogg import * -from . import library_loader as ExternalLibrary +from .library_loader import ExternalLibrary, ExternalLibraryError __here = os.getcwd() libopus = None try: - libopus = ExternalLibrary.load("opus") -except ExternalLibrary.NotFoundError: + libopus = ExternalLibrary.load("opus", tests = [lambda lib: hasattr(lib, "opus_encoder_get_size")]) +except ExternalLibraryError: pass except: _print_exc() @@ -139,8 +139,8 @@ libopusfile = None try: - libopusfile = ExternalLibrary.load("opusfile") -except ExternalLibrary.NotFoundError: + libopusfile = ExternalLibrary.load("opusfile", tests = [lambda lib: hasattr(lib, "opus_head_parse")]) +except ExternalLibraryError: pass except: _print_exc() @@ -148,8 +148,8 @@ libopusenc = None try: - libopusenc = ExternalLibrary.load("opusenc") -except ExternalLibrary.NotFoundError: + libopusenc = ExternalLibrary.load("opusenc", tests = [lambda lib: hasattr(lib, "ope_comments_create")]) +except ExternalLibraryError: pass except: _print_exc() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/PyOgg-0.6.4a1/pyogg/vorbis.py new/PyOgg-0.6.7a1/pyogg/vorbis.py --- old/PyOgg-0.6.4a1/pyogg/vorbis.py 2018-06-25 14:29:21.000000000 +0200 +++ new/PyOgg-0.6.7a1/pyogg/vorbis.py 2019-01-14 16:37:17.000000000 +0100 @@ -45,15 +45,15 @@ from .ogg import * -from . import library_loader as ExternalLibrary +from .library_loader import ExternalLibrary, ExternalLibraryError __here = os.getcwd() libvorbis = None try: - libvorbis = ExternalLibrary.load("vorbis") -except ExternalLibrary.NotFoundError: + libvorbis = ExternalLibrary.load("vorbis", tests = [lambda lib: hasattr(lib, "vorbis_info_init")]) +except ExternalLibraryError: pass except: _print_exc() @@ -61,8 +61,8 @@ libvorbisfile = None try: - libvorbisfile = ExternalLibrary.load("vorbisfile") -except ExternalLibrary.NotFoundError: + libvorbisfile = ExternalLibrary.load("vorbisfile", tests = [lambda lib: hasattr(lib, "ov_clear")]) +except ExternalLibraryError: pass except: _print_exc() @@ -70,8 +70,8 @@ libvorbisenc = None try: - libvorbisenc = ExternalLibrary.load("vorbisenc") -except ExternalLibrary.NotFoundError: + libvorbisenc = ExternalLibrary.load("vorbisenc", tests = [lambda lib: hasattr(lib, "vorbis_encode_init")]) +except ExternalLibraryError: pass except: _print_exc() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/PyOgg-0.6.4a1/setup.py new/PyOgg-0.6.7a1/setup.py --- old/PyOgg-0.6.4a1/setup.py 2018-06-25 14:56:15.000000000 +0200 +++ new/PyOgg-0.6.7a1/setup.py 2019-03-01 11:41:59.000000000 +0100 @@ -28,7 +28,7 @@ # Versions should comply with PEP440. For a discussion on single-sourcing # the version across setup.py and the project code, see # https://packaging.python.org/en/latest/single_source_version.html - version='0.6.4a1', + version='0.6.7a1', description='Xiph.org\'s Ogg Vorbis, Opus and FLAC for Python',
