o ?n0j'@sUdZdZddlZddlZddlZddlm Z ddl m Z ddlm Z mZmZddlmZmZmZmZmZddlZddlmZdd lmZeeBeBejeBZee d <ej!e"ed fej#ej$ej%Bej&Bej'BfZ(ee d <ej!e"eefej#ej$ej%Bej&Bej'BfZ)ee d <edZ*ee d<ee d<ee d<ddddddddddd Z+ee,eefe d<iddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;dd?d@dAdBdCdDdEdFdGdHdI Z-ee,eefe dJ<idKddLddMddNddOddPddQddRddSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcddidedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~ddddddddZ.ee,eefe d<dddddZ/ee,eefe d<iddLd dLd"dLd&dLd(dLd*dLd,dLd.dLd0dLd2dQd4dQd6dLd8dsd:dLddLddLdLdLdLdSdudLdLddZ0ee,eefe d<dddddZ1ee,eefe d<ddddZ2ee,eefe d<z{ej3dkrddl3m4Z5de5dZ6nNej3dkr0ddl7Z8e89Z:e:dkrdZ6n8e:dkr!dZ6n0e:dkr)dZ6n(e;de:ej3dkrMddl3m4Z5e5dvrEdZ6n de5dZ6ne;dddle>> import soundfile as sf >>> data, samplerate = sf.read('stereo_file.wav') >>> data array([[ 0.71329652, 0.06294799], [-0.26450912, -0.38874483], ... [ 0.67398441, -0.11516333]]) >>> samplerate 44100 rN) SoundFile _prepare_readreadrk)rcrdrerfrgrhrirjrkrlrmrnrorpfdatarxP/home/wildlama/miniconda3/envs/lam_a2e/lib/python3.10/site-packages/soundfile.pyrus X rurwcompression_level bitrate_modec Csvddl} | |}|jdkrd} n|jd} t|d|| |||||| } | |WddS1s4wYdS)aWrite data to a sound file. .. note:: If *file* exists, it will be truncated and overwritten! Parameters ---------- file : str or int or file-like object The file to write to. See `SoundFile` for details. data : array_like The data to write. Usually two-dimensional (frames x channels), but one-dimensional *data* can be used for mono files. Only the data types ``'float64'``, ``'float32'``, ``'int32'`` and ``'int16'`` are supported. .. note:: The data type of *data* does **not** select the data type of the written file. Audio data will be converted to the given *subtype*. Writing int values to a float file will *not* scale the values to [-1.0, 1.0). If you write the value ``np.array([42], dtype='int32')``, to a ``subtype='FLOAT'`` file, the file will then contain ``np.array([42.], dtype='float32')``. samplerate : int The sample rate of the audio data. subtype : str, optional See `default_subtype()` for the default value and `available_subtypes()` for all possible values. Other Parameters ---------------- format, endian, closefd, compression_level, bitrate_mode See `SoundFile`. Examples -------- Write 10 frames of random data to a new file: >>> import numpy as np >>> import soundfile as sf >>> sf.write('stereo_file.wav', np.random.randn(10, 2), 44100, 'PCM_24') rNrw)numpyZasarrayndimshaperswrite) rcrwrkrnrormrprzr{nprlrvrxrxryrAs0     "r blocksizeoverlapc csht|d| | | || |}||||}|||||||| EdHWddS1s-wYdS)a8Return a generator for block-wise reading. By default, iteration starts at the beginning and stops at the end of the file. Use *start* to start at a later position and *frames* or *stop* to stop earlier. If you stop iterating over the generator before it's exhausted, the sound file is not closed. This is normally not a problem because the file is opened in read-only mode. To close the file properly, the generator's ``close()`` method can be called. Parameters ---------- file : str or int or file-like object The file to read from. See `SoundFile` for details. blocksize : int The number of frames to read per block. Either this or *out* must be given. overlap : int, optional The number of frames to rewind between each block. Yields ------ `numpy.ndarray` or type(out) Blocks of audio data. If *out* was given, and the requested frames are not an integer multiple of the length of *out*, and no *fill_value* was given, the last block will be a smaller view into *out*. Other Parameters ---------------- frames, start, stop See `read()`. dtype : {'float64', 'float32', 'int32', 'int16'}, optional See `read()`. always_2d, fill_value, out See `read()`. samplerate, channels, format, subtype, endian, closefd See `SoundFile`. Examples -------- >>> import soundfile as sf >>> for block in sf.blocks('stereo_file.wav', blocksize=1024): >>> pass # do something with 'block' rrN)rsrtblocks)rcrrrdrerfrgrhrirjrkrlrmrnrorprvrxrxryr|s 7"rc@s,eZdZdZddZeddZddZdS) _SoundFileInfozInformation about a SoundFilecCs||_t|>}|j|_|j|_|j|_|j|_t|j|j|_|j|_|j |_ |j |_ |j |_ |j |_ |j |_ |j|_WddS1sHwYdSN)verbosersnamerkrlrdrTdurationrmrnro format_info subtype_infosections extra_info)selfrcrrvrxrxry__init__s  "z_SoundFileInfo.__init__cCst|jd\}}t|d\}}|dkr#|dd|dd|dd}|S|dkr3|dd|dd }|S|dkr@|jd d }|S|d d }|S)Ni<rz.0g:z02.0gz05.3fz hz mindz samplesz.3fz s)divmodrrd)rhoursrestminutessecondsrrxrxry _duration_strs z_SoundFileInfo._duration_strc Csd|jd|jdd|jd|jd|jd|jdd |jd|jdg}|j rTd |j d}|dd |j d |j d |jdd|dg7}|S)N z samplerate: z Hzz channels: z duration: zformat: z []z subtype: z z endian: z sections: zframes: zextra_info: """z z""")joinrrkrlrrrmrrnrrsplitrorrd)rinfoZindented_extra_inforxrxry__repr__s(       z_SoundFileInfo.__repr__N)__name__ __module__ __qualname____doc__rpropertyrrrxrxrxryrs   rrcCs t||S)zReturns an object with information about a `SoundFile`. Parameters ---------- verbose : bool Whether to print additional information. )r)rcrrxrxryrs rcCstttjtjS)aReturn a dictionary of available major formats. Examples -------- >>> import soundfile as sf >>> sf.available_formats() {'FLAC': 'FLAC (FLAC Lossless Audio Codec)', 'OGG': 'OGG (OGG Container format)', 'WAV': 'WAV (Microsoft)', 'AIFF': 'AIFF (Apple/SGI)', ... 'WAVEX': 'WAVEX (Microsoft)', 'RAW': 'RAW (header-less)', 'MAT5': 'MAT5 (GNU Octave 2.1 / Matlab 5.0)'} )dict_available_formats_helperrZSFC_GET_FORMAT_MAJOR_COUNTZSFC_GET_FORMAT_MAJORrxrxrxryavailable_formatssrcs ttjtj}fdd|DS)adReturn a dictionary of available subtypes. Parameters ---------- format : str If given, only compatible subtypes are returned. Examples -------- >>> import soundfile as sf >>> sf.available_subtypes('FLAC') {'PCM_24': 'Signed 24 bit PCM', 'PCM_16': 'Signed 16 bit PCM', 'PCM_S8': 'Signed 8 bit PCM'} cs(i|]\}}dust|r||qSr) check_format).0rnrrmrxry s z&available_subtypes..)rrZSFC_GET_FORMAT_SUBTYPE_COUNTZSFC_GET_FORMAT_SUBTYPE)rmsubtypesrxrryavailable_subtypes src Cs,z tt|||WSttfyYdSw)zCheck if the combination of format/subtype/endian is valid. Examples -------- >>> import soundfile as sf >>> sf.check_format('WAV', 'PCM_24') True >>> sf.check_format('FLAC', 'VORBIS') False F)bool _format_int ValueError TypeError)rmrnrorxrxryr$s  rcCst|t|S)zReturn the default subtype for a given format. Examples -------- >>> import soundfile as sf >>> sf.default_subtype('WAV') 'PCM_16' >>> sf.default_subtype('MAT5') 'DOUBLE' ) _check_formatrRgetupperrrxrxrydefault_subtype7s rc@seZdZdZ      d}dededBdedBdedBd edBd edBd edBd ed edBdedBddfddZ e ddZ e ddZ e ddZ e ddZ e ddZ e ddZ e ddZ e ddZ e ddZ e ddZ e ddZ e ddZ e ddZ e d dZ e d!dZ e d"d#ZdZdefd$d%Zd~d&d'Zdefd(d)Zd*e ddfd+d,Z!d-ed.e ddfd/d0Z"d-ede fd1d2Z#defd3d4Z$defd5d6Z%defd7d8Z&defd9d:Z'e(fd;edZ)defd?d@Z* B  dd;edDe+dEedFedBdGe,e-BdBde,e-Bf dHdIZ.dd;edDe+dBde/fdJdKZ0dLe1e/Be BdDe+defdMdNZ2dOe,ddfdPdQZ3dOe4dDe+ddfdRdSZ5 T B  ddUedBdVed;edDe+dEedFedBdGe,e-BdBde6e,ddfe6e-ddfBfdWdXZ7dd;edBddfdYdZZ8d~d[d\Z9d~d]d^Z:e;<Z=d_d`Z>dadbZ?dcddZ@dedfZAdgdhZBdidjZCdkdlZDdmdnZEdodpZFdqdrZGdsdtZHdudvZIdeJeeffdwdxZKdydzZLd{d|ZMdS)rszA sound file. For more documentation see the __init__() docstring (which is also used for the online documentation (https://python-soundfile.readthedocs.io/). rrNTrcmoderkrlrnrormrprzr{rqc Cst|tjr t|}||_|dur t|dd}|dur tdt|} ||_| |_ | |_ t ||||||||_ | || ||_t|drP|rP|dt|jtjtjtj|j durt||j |j durv||j dSdSdS)aOpen a sound file. If a file is opened with `mode` ``'r'`` (the default) or ``'r+'``, no sample rate, channels or file format need to be given because the information is obtained from the file. An exception is the ``'RAW'`` data format, which always requires these data points. File formats consist of three case-insensitive strings: * a *major format* which is by default obtained from the extension of the file name (if known) and which can be forced with the format argument (e.g. ``format='WAVEX'``). * a *subtype*, e.g. ``'PCM_24'``. Most major formats have a default subtype which is used if no subtype is specified. * an *endian-ness*, which doesn't have to be specified at all in most cases. A `SoundFile` object is a *context manager*, which means if used in a "with" statement, `close()` is automatically called when reaching the end of the code block inside the "with" statement. Parameters ---------- file : str or int or file-like object The file to open. This can be a file name, a file descriptor or a Python file object (or a similar object with the methods ``read()``/``readinto()``, ``write()``, ``seek()`` and ``tell()``). mode : {'r', 'r+', 'w', 'w+', 'x', 'x+'}, optional Open mode. Has to begin with one of these three characters: ``'r'`` for reading, ``'w'`` for writing (truncates *file*) or ``'x'`` for writing (raises an error if *file* already exists). Additionally, it may contain ``'+'`` to open *file* for both reading and writing. The character ``'b'`` for *binary mode* is implied because all sound files have to be opened in this mode. If *file* is a file descriptor or a file-like object, ``'w'`` doesn't truncate and ``'x'`` doesn't raise an error. samplerate : int The sample rate of the file. If `mode` contains ``'r'``, this is obtained from the file (except for ``'RAW'`` files). channels : int The number of channels of the file. If `mode` contains ``'r'``, this is obtained from the file (except for ``'RAW'`` files). subtype : str, sometimes optional The subtype of the sound file. If `mode` contains ``'r'``, this is obtained from the file (except for ``'RAW'`` files), if not, the default value depends on the selected `format` (see `default_subtype()`). See `available_subtypes()` for all possible subtypes for a given `format`. endian : {'FILE', 'LITTLE', 'BIG', 'CPU'}, sometimes optional The endian-ness of the sound file. If `mode` contains ``'r'``, this is obtained from the file (except for ``'RAW'`` files), if not, the default value is ``'FILE'``, which is correct in most cases. format : str, sometimes optional The major format of the sound file. If `mode` contains ``'r'``, this is obtained from the file (except for ``'RAW'`` files), if not, the default value is determined from the file extension. See `available_formats()` for all possible values. closefd : bool, optional Whether to close the file descriptor on `close()`. Only applicable if the *file* argument is a file descriptor. compression_level : float, optional The compression level on 'write()'. The compression level should be between 0.0 (minimum compression level) and 1.0 (highest compression level). See `libsndfile document `__. bitrate_mode : {'CONSTANT', 'AVERAGE', 'VARIABLE'}, optional The bitrate mode on 'write()'. See `libsndfile document `__. Examples -------- >>> from soundfile import SoundFile Open an existing file for reading: >>> myfile = SoundFile('existing_file.wav') >>> # do something with myfile >>> myfile.close() Create a new sound file for reading and writing using a with statement: >>> with SoundFile('new_file.wav', 'x+', 44100, 2) as myfile: >>> # do something with myfile >>> # ... >>> assert not myfile.closed >>> # myfile.close() is called automatically at the end >>> assert myfile.closed Nrz6Can not get `mode` from file. provided `mode` is None.zr+r) isinstance_osPathLikefspath_namegetattrr _check_mode_mode_compression_level _bitrate_mode_create_info_struct_info_open_fileset issupersetseekableseekr sf_commandZSFC_SET_CLIPPINGrNULLSF_TRUE_set_compression_level_set_bitrate_mode) rrcrrkrlrnrormrprzr{mode_intrxrxryrOs4 h       zSoundFile.__init__cC|jSr)rrrxrxryzSoundFile.cCrr)rrrxrxryrrcC|jjSr)rrkrrxrxryrcCrrrrdrrxrxryrrcCrr)rrlrrxrxryrrcCt|jjtj@Sr) _format_strrrmrSF_FORMAT_TYPEMASKrrxrxryrcCrr)rrrmrSF_FORMAT_SUBMASKrrxrxryrrcCrr)rrrmrZSF_FORMAT_ENDMASKrrxrxryrrcCt|jjtj@dSNr) _format_inforrmrrrrxrxryr cCrr)rrrmrrrrxrxryrrcCrr)rrrrxrxryrrcCs |jduSr)rrrxrxryrs cCs t|jSr)rsf_errorrrrxrxryrs cCrr)rrrxrxryrrcCrr)rrrxrxryrrcCs8tdd}t|jtj|t|t|ddS)z8Retrieve the log string generated when opening the file.zchar[]i@r`ra) rnewrrrZSFC_GET_LOG_INFOsizeofstringdecode)rrrxrxryrs   zSoundFile.extra_infocCs||jdur d|jnd}||jdurd|jdnd7}d|jd|jd|jd|jd |jd |jd |j|d S) Nz, compression_level=z, bitrate_mode=''z SoundFile(z, mode=z , samplerate=z , channels=z , format=z , subtype=z , endian=)) rzr{rrrkrlrmrnro)rZcompression_settingrxrxryrs,   zSoundFile.__repr__cC |dSrcloserrxrxry__del__  zSoundFile.__del__cCs|Srrxrrxrxry __enter__szSoundFile.__enter__argscGrrr)rrrxrxry__exit__rzSoundFile.__exit__rvaluecCsF|tvr|t|jt||}t|dSt|||dS)z:Write text meta-data in the sound file through properties.N) r'_check_if_closedrZ sf_set_stringrencode _error_checkobject __setattr__)rrrerrrxrxryrs zSoundFile.__setattr__cCsJ|tvr|t|jt|}|rt|ddSdStd|)z9Read text meta-data in the sound file through properties.r`rarz$'SoundFile' object has no attribute ) r'rr sf_get_stringrrrrAttributeError)rrrwrxrxry __getattr__ szSoundFile.__getattr__cCrrrrrxrxry__len__*zSoundFile.__len__cCsdS)NTrxrrxrxry__bool__/szSoundFile.__bool__cCs|Sr)rrrxrxry __nonzero__4rzSoundFile.__nonzero__cCs|jjtjkS)z)Return True if the file supports seeking.)rrrrrrxrxryr9szSoundFile.seekablerdwhencecCs&|t|j||}t|j|S)aSet the read/write position. Parameters ---------- frames : int The frame index or offset to seek. whence : {SEEK_SET, SEEK_CUR, SEEK_END}, optional By default (``whence=SEEK_SET``), *frames* are counted from the beginning of the file. ``whence=SEEK_CUR`` seeks from the current position (positive and negative values are allowed for *frames*). ``whence=SEEK_END`` seeks from the end (use negative value for *frames*). Returns ------- int The new absolute read/write position in frames. Examples -------- >>> from soundfile import SoundFile, SEEK_END >>> myfile = SoundFile('stereo_file.wav') Seek to the beginning of the file: >>> myfile.seek(0) 0 Seek to the end of the file: >>> myfile.seek(0, SEEK_END) 44100 # this is the file length )rrZsf_seekrr _errorcode)rrdrpositionrxrxryr=s$ zSoundFile.seekcCs |dtS)z'Return the current read/write position.r)rrrrxrxrytellfs zSoundFile.tellrbrFrgrhrirjcCs|dur|||}||||}n|dks|t|kr t|}|d||}t||kr?|dur9|d|}|S|||d<|S)a Read from the file and return data as NumPy array. Reads the given number of frames in the given data format starting at the current read/write position. This advances the read/write position by the same number of frames. By default, all frames from the current read/write position to the end of the file are returned. Use `seek()` to move the current read/write position. Parameters ---------- frames : int, optional The number of frames to read. If ``frames < 0``, the whole rest of the file is read. dtype : {'float64', 'float32', 'int32', 'int16'}, optional Data type of the returned array, by default ``'float64'``. Floating point audio data is typically in the range from ``-1.0`` to ``1.0``. Integer data is in the range from ``-2**15`` to ``2**15-1`` for ``'int16'`` and from ``-2**31`` to ``2**31-1`` for ``'int32'``. .. note:: Reading int values from a float file will *not* scale the data to [-1.0, 1.0). If the file contains ``np.array([42.6], dtype='float32')``, you will read ``np.array([43], dtype='int32')`` for ``dtype='int32'``. Returns ------- audiodata : `numpy.ndarray` or type(out) A two-dimensional NumPy (frames x channels) array is returned. If the sound file has only one channel, a one-dimensional array is returned. Use ``always_2d=True`` to return a two-dimensional array anyway. If *out* was specified, it is returned. If *out* has more frames than available in the file (or if *frames* is smaller than the length of *out*) and no *fill_value* is given, then only a part of *out* is overwritten and a view containing all valid frames is returned. Other Parameters ---------------- always_2d : bool, optional By default, reading a mono sound file will return a one-dimensional array. With ``always_2d=True``, audio data is always returned as a two-dimensional array, even if the audio file has only one channel. fill_value : float, optional If more frames are requested than available in the file, the rest of the output is be filled with *fill_value*. If *fill_value* is not specified, a smaller array is returned. out : `numpy.ndarray` or subclass, optional If *out* is specified, the data is written into the given array instead of creating a new array. In this case, the arguments *dtype* and *always_2d* are silently ignored! If *frames* is not given, it is obtained from the length of *out*. Examples -------- >>> from soundfile import SoundFile >>> myfile = SoundFile('stereo_file.wav') Reading 3 frames from a stereo file: >>> myfile.read(3) array([[ 0.71329652, 0.06294799], [-0.26450912, -0.38874483], [ 0.67398441, -0.11516333]]) >>> myfile.close() See Also -------- buffer_read, .write Nrru) _check_frames_create_empty_arraylen _array_io)rrdrgrhrirjrxrxryruksQ    zSoundFile.readcCsT|j|dd}||}t|d||j}|d|||}||ks%Jt|S)aRead from the file and return data as buffer object. Reads the given number of *frames* in the given data format starting at the current read/write position. This advances the read/write position by the same number of frames. By default, all frames from the current read/write position to the end of the file are returned. Use `seek()` to move the current read/write position. Parameters ---------- frames : int, optional The number of frames to read. If ``frames < 0``, the whole rest of the file is read. dtype : {'float64', 'float32', 'int32', 'int16'} Audio data will be converted to the given data type. Returns ------- buffer A buffer containing the read data. See Also -------- buffer_read_into, .read, buffer_write N)riz[]ru)r _check_dtyperrrl _cdata_iobuffer)rrdrgctypecdataZ read_framesrxrxry buffer_reads    zSoundFile.buffer_readrcCs.||}|||\}}|d|||}|S)aRead from the file into a given buffer object. Fills the given *buffer* with frames in the given data format starting at the current read/write position (which can be changed with `seek()`) until the buffer is full or the end of the file is reached. This advances the read/write position by the number of frames that were read. Parameters ---------- buffer : writable buffer Audio frames from the file are written to this buffer. dtype : {'float64', 'float32', 'int32', 'int16'} The data type of *buffer*. Returns ------- int The number of frames that were read from the file. This can be less than the size of *buffer*. The rest of the buffer is not filled with meaningful data. See Also -------- buffer_read, .read ru)r _check_bufferr)rrrgrrrdrxrxrybuffer_read_intos zSoundFile.buffer_read_intorwcCsBddl}||}|d|t|}|t|ksJ||dS)aWrite audio data from a NumPy array to the file. Writes a number of frames at the read/write position to the file. This also advances the read/write position by the same number of frames and enlarges the file if necessary. Note that writing int values to a float file will *not* scale the values to [-1.0, 1.0). If you write the value ``np.array([42], dtype='int32')``, to a ``subtype='FLOAT'`` file, the file will then contain ``np.array([42.], dtype='float32')``. Parameters ---------- data : array_like The data to write. Usually two-dimensional (frames x channels), but one-dimensional *data* can be used for mono files. Only the data types ``'float64'``, ``'float32'``, ``'int32'`` and ``'int16'`` are supported. .. note:: The data type of *data* does **not** select the data type of the written file. Audio data will be converted to the given *subtype*. Writing int values to a float file will *not* scale the values to [-1.0, 1.0). If you write the value ``np.array([42], dtype='int32')``, to a ``subtype='FLOAT'`` file, the file will then contain ``np.array([42.], dtype='float32')``. Examples -------- >>> import numpy as np >>> from soundfile import SoundFile >>> myfile = SoundFile('stereo_file.wav') Write 10 frames of random data to a new file: >>> with SoundFile('stereo_file.wav', 'w', 44100, 2, 'PCM_24') as f: >>> f.write(np.random.randn(10, 2)) See Also -------- buffer_write, .read rNr)r}Zascontiguousarrayrr_update_frames)rrwrwrittenrxrxryrs . zSoundFile.writecCsD||}|||\}}|d|||}||ksJ||dS)aWrite audio data from a buffer/bytes object to the file. Writes the contents of *data* to the file at the current read/write position. This also advances the read/write position by the number of frames that were written and enlarges the file if necessary. Parameters ---------- data : buffer or bytes A buffer or bytes object containing the audio data to be written. dtype : {'float64', 'float32', 'int32', 'int16'} The data type of the audio data stored in *data*. See Also -------- .write, buffer_read rN)rr rr )rrwrgrrrdr rxrxry buffer_writeEs  zSoundFile.buffer_writerrrc cstddl}d|jvrd|jvrtd|||}|dur:|dur%td|dur+|nt||} || ||}d} n|durBtdt|}d } d} |dkr| durUd} n t| } | |d| <t|| |} || ||||| d|r| dur| || d} n || d| dd<|||kr|dur|d||}n|}| r| |n|V|| 8}|dksNdSdS) aReturn a generator for block-wise reading. By default, the generator yields blocks of the given *blocksize* (using a given *overlap*) until the end of the file is reached; *frames* can be used to stop earlier. Parameters ---------- blocksize : int The number of frames to read per block. Either this or *out* must be given. overlap : int, optional The number of frames to rewind between each block. frames : int, optional The number of frames to read. If ``frames < 0``, the file is read until the end. dtype : {'float64', 'float32', 'int32', 'int16'}, optional See `read()`. Yields ------ `numpy.ndarray` or type(out) Blocks of audio data. If *out* was given, and the requested frames are not an integer multiple of the length of *out*, and no *fill_value* was given, the last block will be a smaller view into *out*. Other Parameters ---------------- always_2d, fill_value, out See `read()`. fill_value : float, optional See `read()`. out : `numpy.ndarray` or subclass, optional If *out* is specified, the data is written into the given array instead of creating a new array. In this case, the arguments *dtype* and *always_2d* are silently ignored! Examples -------- >>> from soundfile import SoundFile >>> with SoundFile('stereo_file.wav') as f: >>> for block in f.blocks(blocksize=1024): >>> pass # do something with 'block' rNrr+z*blocks() is not allowed in write-only modez)One of {blocksize, out} must be specifiedTz-Only one of {blocksize, out} may be specifiedF) r}rSoundFileRuntimeErrorrrminrrrucopy)rrrrdrgrhrirjrZout_sizeZcopy_outZoverlap_memoryZ output_offsetZtoreadblockrxrxryr`sF4  zSoundFile.blockscCsX|dur|}t|jtjtd|td}|r&t|j}t |d||j _ dS)anTruncate the file to a given number of frames. After this command, the read/write position will be at the new end of the file. Parameters ---------- frames : int, optional Only the data before *frames* is kept, the rest is deleted. If not specified, the current read/write position is used. Nz sf_count_t*Z sf_count_tzError truncating the file) rrrrZSFC_FILE_TRUNCATErrrrLibsndfileErrorrrd)rrdrrxrxrytruncates      zSoundFile.truncatecCs|t|jdS)ajWrite unwritten data to the file system. Data written with `write()` is not immediately written to the file system but buffered in memory to be written at a later time. Calling `flush()` makes sure that all changes are actually written to the file system. This has no effect on files opened in read-only mode. N)rrZ sf_write_syncrrrxrxryflushs zSoundFile.flushcCs0|js|t|j}d|_t|dSdS)z.Close the file. Can be called multiple times.N)closedrrZsf_closerr)rrrxrxryrs   zSoundFile.closecsDt|ttfrHtj|r/djvrtdjt j dr/t t |tj tjBtj}t|trGtjdkr@tj}n(|t}n t|trTfdd}nt||r`fdd}ntdjj$|||j}|tjkrt|}t|d jd d Wd n1swY|tjkrd j_ |S)z9Call the appropriate sf_open*() function from libsndfile.xz File exists: zw+r[cst|||Sr)rZ sf_open_fdrcrr)rprxryrsz!SoundFile._open..cst|||tjSr)rZsf_open_virtual_init_virtual_iorrrrrxryrs zInvalid file: zError opening z: prefixNr)!rstrbytesrpathisfilerOSErrorrrrropenO_WRONLYO_TRUNCrZsf_open_sysplatformZ sf_wchar_openrgetfilesystemencodingrU_has_virtual_io_attrsr_sf_error_lockrrrrr SFM_WRITErd)rrcrrpZ openfunctionZfile_ptrrrx)rprryrs6         zSoundFile._opencstdfdd}tdfdd}tdfdd }td fd d }td fdd}|||||d|_td|jS)z4Initialize callback functions for sf_open_virtual().Zsf_vio_get_filelencs,}dt}|t|SNr)rrrr) user_datacurrsizercrxryvio_get_filelens   z3SoundFile._init_virtual_io..vio_get_filelenZ sf_vio_seekcs||Sr)rr)offsetrr,r/rxryvio_seek$s z,SoundFile._init_virtual_io..vio_seekZ sf_vio_readcs\zt||}|}W|Sty-|}t|}t||}||d|<Y|Swr+)rrreadintorrur)ptrcountr,bufZ data_readrwr/rxryvio_read)s    z,SoundFile._init_virtual_io..vio_readZ sf_vio_writecs2t||}|dd}|}|dur|}|Sr)rrr)r4r5r,r6rwr r/rxry vio_write6s   z-SoundFile._init_virtual_io..vio_writeZ sf_vio_tellcsSr)r)r,r/rxryvio_tell@sz,SoundFile._init_virtual_io..vio_tell)Z get_filelenrrurrzSF_VIRTUAL_IO*)rcallbackZ _virtual_ior)rrcr0r2r7r8r9rxr/ryrs"  zSoundFile._init_virtual_iocCstS)zReturn all attributes used in __setattr__ and __getattr__. This is useful for auto-completion (e.g. IPython). )r'rrxrxry_getAttributeNamesMszSoundFile._getAttributeNamescCs|jrtddS)zCheck if the file is closed and raise an error if it is. This should be used in every method that uses self._file. zI/O operation on closed fileN)rrrrxrxryrUszSoundFile._check_if_closedcCsJ|r|j|}|dks||kr|dur|}|S|dkr#td|S)z8Reduce frames to no more than are available in the file.rNz/frames must be specified for non-seekable files)rrdrr)rrdriZremaining_framesrxrxryr^szSoundFile._check_framescCsV|tvsJt|tst|}tt||jt |\}}|r't d||fS)z1Convert buffer to cdata and check for valid size.z*Data size must be a multiple of frame size) rVvaluesrrr from_bufferrrrlrr)rrwrrd remainderrxrxryr is  zSoundFile._check_buffercCs8ddl}|s |jdkr||jf}n|f}|j||ddS)z-Create an empty array with appropriate shape.rNrC)order)r}rlempty)rrdrhrgrrrxrxryrts  zSoundFile._create_empty_arraycCs6zt|WStytdttd|w)z7Check if dtype string is valid and return ctype string.zdtype must be one of z and not )rVKeyErrorrsortedkeys)rrgrxrxryr}s   zSoundFile._check_dtypecCs|jdvrtd|jd|jdkrdndd|jdkrdn|jd}||jkr9td|jd|jd |d|jjsAtd ||jj}|jj t |ksSJt |d |j d d }|||||S)z+Check array and call low-level IO function.)rrzInvalid shape: z (rz0 dimensions not supportedztoo many dimensionsrz (Expected z channels, got zData must be C-contiguous*rwr)r~rrrlflags c_contiguousrrgritemsizerrcastZ__array_interface__r)ractionarrayrdZarray_channelsrrrxrxryrs &  zSoundFile._array_iocCsv|tvsJ|d}|r|}ttd|d|}||j||}t|j |r9| ||t |S)z.Call one of libsndfile's read/write functions.rZsf_Zf_) rVr<rrrrrrrrrr)rrJrwrrdr-funcrxrxryrs zSoundFile._cdata_iocCsD|r|}|dt|j_||tdS|jj|7_dS)z!Update self.frames after writing.rN)rrrrrrdr)rr r-rxrxryr s zSoundFile._update_framescCs||dkr |s td|dkr|durtdt|||j\}}}||kr*|}|dkr2||}|r<||t|S)z)Seek to start frame and calculate length.rz(start is only allowed for seekable filesNz&Only one of {frames, stop} may be used)rrrsliceindicesrdrr)rrerfrd_rxrxryrts zSoundFile._prepare_readcCsBi}tD]\}}t|j|}|rt|dd||<q|S)a5Get all metadata present in this SoundFile Returns ------- metadata: dict[str, str] A dict with all metadata. Possible keys are: 'title', 'copyright', 'software', 'artist', 'comment', 'date', 'album', 'license', 'tracknumber' and 'genre'. r`ra)r'itemsrrrrrr)rstrsZstrtypeZstridrwrxrxry copy_metadatas zSoundFile.copy_metadatacCsf|tvsJtd}t||d<t|jtj|t|}|tjkr1t |j}t |d|dS)z,Call libsndfile's set bitrate mode function.zint[1]rzError set bitrate mode N) rXrrrrrZSFC_SET_BITRATE_MODErrrr)rr{Zpointer_bitrate_moderrxrxryrs     zSoundFile._set_bitrate_modecCszd|kr dkstdtdtd}||d<t|jtj|t|}|tjkr;t |j}t |d|dS)z1Call libsndfile's set compression level function.rrz)Compression level must be in range [0..1]z double[1]zError set compression level N) rrrrrrZSFC_SET_COMPRESSION_LEVELrrrr)rrzZpointer_compression_levelrrxrxryrs   z SoundFile._set_compression_level) rrNNNNNTNN)rqN)rbrFNN)rbN)NrrbrFNNr)NrrrrrrrUrrTrrrrrkrdrlrmrnrorrrrrrzr{rrrrr rrrrrrrrrrrrrrrru memoryviewr  bytearrayr rrrrrrrr _threadingLockr)rrr;rrr rrrrr rtrrRrrrxrxrxryrsGs               )   `#!6  _  %3      rsrcCs|dkr t||ddS)z+Raise LibsndfileError if there is an error.rrN)r)rrrxrxryrs rcCst|}|durt|}|durtd|n t|ts$td|z |t|O}Wnty<td|w|durDd}n t|tsPtd|z |t |O}Wntyhtd|wt d}||_ d |_ t|tjkrtd |S) z8Return numeric ID for given format|subtype|endian combo.Nz$No default subtype for major format zInvalid subtype: zUnknown subtype: rPzInvalid endian-ness: zUnknown endian-ness: SF_INFO*rz1Invalid combination of format, subtype and endian)rrrrrrOrrBrrQrrrmrlrZsf_format_checkZSF_FALSE)rmrnroresultrrxrxryrs@     rcCst|ts td|t|}|dst|t|kr$td|t|ddkr1tdd|vr:tj }|Sd|vrCtj }|Stj }|S)z=Check if mode is valid and return its integer representation.zInvalid mode: zxrwb+Zxrwrz&mode must contain exactly one of 'xrw'rrr) rrrr differencerr intersectionrZSFM_RDWRSFM_READr*)rZmode_setrrxrxryr s rc Cs|}|durt||}t|tsJnt|td}d|vs&|dkrE|dur.td||_|dur9td||_ t ||||_ |St dd|||||fDrWtd |S) z*Check arguments and create SF_INFO struct.NrWrrr(zsamplerate must be specifiedzchannels must be specifiedcss|]}|duVqdSrrx)rargrxrxry 1sz&_create_info_struct..z\Not allowed for existing files (except 'RAW'): samplerate, channels, format, subtype, endian) _get_format_from_filenamerrrrrrrrkrlrrmany) rcrrkrlrmrnroZoriginal_formatrrxrxryrs(    rcCsrd}t|d|}ztj|ddd}|dd}Wn ty%Ynw|tvr7d|vr7td ||S) aReturn a format string obtained from file (or file.name). If file already exists (= read mode), an empty string is returned on error. If not, an exception is raised. The return type will always be str or unicode (even if file/file.name is a bytes object). rrrbrNr`rarrzBNo format specified and unable to get format from file extension: ) rrrsplitextr Exceptionrr2r)rcrrmrxrxryr^8s  r^cCs:tttfD]}|D]\}}||kr|Sq qdS)z;Return the string representation of a given numeric format.zn/a)r2rOrQrP) format_int dictionarykvrxrxryrPs rcCsTtd}||_ttj||td|j}t|j|r't | ddfSdfS)z6Return the ID and short description of a given format.zSF_FORMAT_INFO*ZSF_FORMAT_INFOr`rar) rrrmrrrrrrrr)rb format_flagrrrxrxryrZs  rccsFtd}ttj||tdt|dD]}t||VqdS)z8Helper for available_formats() and available_subtypes().zint*rUrN)rrrrrrranger)Z count_flagrfr5rbrxrxryres  rcCsHt|ts td|z t|}W|Sty#td|w)z4Check if `format_str` is valid and return format ID.zInvalid format: zUnknown format: )rrrr2rrBr) format_strrbrxrxryrms  rcCsN|tjk}|tjk}tt|dt|dt|dp|t|dp$t|dp$|gS)z>Check if file has all the necessary attributes for virtual IO.rrrrur3)rr[r*allhasattr)rcrreadonlyZ writeonlyrxrxryr(xs   r(c@eZdZdZdS)SoundFileErrorz-Base class for all soundfile-specific errors.Nrrrrrxrxrxryrmsrmc@rl)rzKsoundfile module runtime error. Errors that used to be `RuntimeError`.Nrnrxrxrxryrsrc@sHeZdZdZd dededdfddZedefd d Zdefd d Z dS)rzjlibsndfile errors. Attributes ---------- code libsndfile internal error number. rcoderrqNcCst|||||_||_dSr)rrror)rrorrxrxryrs zLibsndfileError.__init__cCs(|jrt|j}t|ddSdS)zRaw libsndfile error message.r`raz'(Garbled error message from libsndfile))rorZsf_error_numberrrr)rZerr_strrxrxry error_strings zLibsndfileError.error_stringcCs |j|jSr)rrprrxrxry__str__rzLibsndfileError.__str__r) rrrrrUrrrrprqrxrxrxryrs  r) rbrNrFNNNNNNNT)NNNTNN)NrrbrNrFNNNNNNNT)Fr)NNrr)mr __version__osrsysr% threadingrUcollections.abcrZ ctypes.utilrZ _find_libraryrrrtypingrrr r r r}Ztyping_extensionsr Z _soundfiler rrrUrr__annotations__Zndarraytuplergrrrrrrrr'rr2rOrQrRrVrXr&rZZ_machineZ_packaged_libname sysconfig _sysconfig get_platformZ _win_machiner!Z_soundfile_datardirname__file___pathrZ _full_pathdlopenr ImportErrorrZ_libnameZ_explicit_libnameisdirZ _hbrew_pathrZsf_version_stringrZ__libsndfile_version__ startswithrrrTrurrrrrrrrrsrrrrr^rZSFC_GET_FORMAT_INFOrrrr(rarm RuntimeErrorrrrxrxrxrys     88            !"&                       a ;  =4   $