{KgT dZdZddlZddlZddlmZmZmZddl m Z ddl m Z eZddd d d d d dddd Ziddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;ddd?dd@d dAd dBd dCd dDd dEddFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWidXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdyZddzd{d|d}Zidd?dd?dd?dd?dd?dd?d d?d"d?d$d?d&dDd(dDd*d?d,dfd.d?d0d?d2d?d~d?d?d?d?dFdhd?d?dxdZdddddZ ej2dk(rddlmZdezdzZnQej2dk(rddlmZdedzdzZn+ej2dk(rddlmZdezdzZnedddl Z ejBjEe jFZ$ejBjKe$eZ&ejNe&Z(ej^e(jajcddZ2e2jgdr e2e4ddZ2 ddZ5 ddZ6 ddZ7Gdde8Z9ddZ:dZ;ddZGdde8Z?ddZ@dZAdZBdZCdZDdZEe(jfdZGdZHdZIdZJGddeKZLGddeLeMZNGddeNZOy#e$reZYwxYw#ee)e*f$r e dZ+e+edejNe+Z(n#e$rej2dk(rdZ,n%ej2dk(rdZ,nej2dk(rdZ,nddlmZej2dk(rVedk(rLejBj[drdndZ.ejNejBjKe.e,Z(nejNe,Z(YnwxYwYwxYw)akpython-soundfile is an audio library based on libsndfile, CFFI and NumPy. Sound files can be read or written directly using the functions `read()` and `write()`. To read a sound file in a block-wise fashion, use `blocks()`. Alternatively, sound files can be opened as `SoundFile` objects. For further information, see https://python-soundfile.readthedocs.io/. z0.12.1N)SEEK_SETSEEK_CURSEEK_END) find_library)ffi ) title copyrightsoftwareartistcommentdatealbumlicense tracknumbergenreWAViAIFFiAUiRAWiPAFiSVXiNISTiVOCiIRCAMi W64i MAT4i MAT5i PVFiXIiHTKiSDSiAVRiiiiiii i!i"i#) WAVEXSD2FLACCAFWVEOGGMPC2KRF64MP3PCM_S8PCM_16PCM_24PCM_32PCM_U8FLOATDOUBLEULAWALAW IMA_ADPCMMS_ADPCMGSM610 VOX_ADPCM! NMS_ADPCM_16" NMS_ADPCM_24# NMS_ADPCM_32$G721_320G723_241G723_402DWVW_12@DWVW_16ADWVW_24BDWVW_NCDPCM_8PDPCM_16QVORBIS`OPUSdALAC_16pALAC_20qALAC_24rALAC_32s MPEG_LAYER_I MPEG_LAYER_IIMPEG_LAYER_IIIii i0)FILELITTLEBIGCPUr-)r.r/r0r1r2r3r4r5doublefloatintshort)float64float32int32int16darwin)machine libsndfile_z.dylibwin32) architecturez.dlllinuxz.soz%no packaged library for this platformsndfilez8sndfile library not found using ctypes.util.find_libraryzlibsndfile.dylibzlibsndfile.dllz libsndfile.soarm64z/opt/homebrew/lib/z/usr/local/lib/utf-8replacez libsndfile-c t|d|| | | | | 5}|j|||}|j|||||}dddjfS#1swYxYw)aProvide audio data from a sound file as NumPy array. By default, the whole file is read from the beginning, but the position to start reading can be specified with *start* and the number of frames to read can be specified with *frames*. Alternatively, a range can be specified with *start* and *stop*. If there is less data left in the file than requested, the rest of the frames are filled with *fill_value*. If no *fill_value* is specified, a smaller array is returned. Parameters ---------- file : str or int or file-like object The file to read from. See `SoundFile` for details. frames : int, optional The number of frames to read. If *frames* is negative, the whole rest of the file is read. Not allowed if *stop* is given. start : int, optional Where to start reading. A negative value counts from the end. stop : int, optional The index after the last frame to be read. A negative value counts from the end. Not allowed if *frames* is given. 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 (frames x channels) NumPy 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. samplerate : int The sample rate of the audio file. 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*. samplerate, channels, format, subtype, endian, closefd See `SoundFile`. Examples -------- >>> 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_readread samplerate)fileframesstartstopdtype always_2d fill_valueoutrchannelsformatsubtypeendianclosefdfdatas M/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/soundfile.pyrrsjl 4j(FFG 589f5vvfeY C@ 5    5 5s )AAc ddl}|j|}|jdk(rd}n|jd}t |d||||||5} | j |dddy#1swYyxYw)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 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)numpyasarrayndimshaperwrite) rrrrrrrnprrs rrr$sjZ ::d D yyA~::a= 4j(FFG 589   5 5 5s A$$A-c #Kt|d| | | || |5}|j|||}|j||||||| D]}| dddy#1swYyxYww)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' rN)rrblocks)r blocksizeoverlaprrrrrrrrrrrrrrblocks rrr\sof 4j(FFG 589f5XXi&#Y CAEKA 5 5 5sA4A AAAc,eZdZdZdZedZdZy)_SoundFileInfozInformation about a SoundFilec||_t|5}|j|_|j|_|j|_|j |_t |j |jz |_|j|_|j|_ |j|_ |j|_ |j|_ |j|_ |j|_dddy#1swYyxYwN)verbosernamerrrrwdurationrrr format_info subtype_infosections extra_info)selfrrrs r__init__z_SoundFileInfo.__init__s t_DIllDOJJDM((DK!$++.q||;DM((DK99DL((DK }}D  !D JJDMllDO__s C#C??Dc"t|jd\}}t|d\}}|dk\rdj|||}|S|dk\rdj||}|S|dkrdj|j}|Sdj|}|S)Ni<rz{0:.0g}:{1:02.0g}:{2:05.3f} hz{0:02.0g}:{1:05.3f} minz {0:d} samplesz {0:.3f} s)divmodrrr)rhoursrestminutessecondsrs r _duration_strz_SoundFileInfo._duration_strsT]]D1 t!$+ A:6==eWgVH \077IH  \&--dkk:H#))'2Hcdjgd}|jr|djgdz }dj|jjd}|j ||S)N )z{0.name}zsamplerate: {0.samplerate} Hzzchannels: {0.channels}zduration: {0._duration_str}z$format: {0.format_info} [{0.format}]z'subtype: {0.subtype_info} [{0.subtype}])z endian: {0.endian}zsections: {0.sections}zframes: {0.frames}zextra_info: """z {1}"""z )joinrrsplitr)rinfoindented_extra_infos r__repr__z_SoundFileInfo.__repr__slyy 89 << DII  D *//0E0Ed0KL{{4!455rN)__name__ __module__ __qualname____doc__rpropertyrrrrrrs#'+   6rrct||S)zReturns an object with information about a `SoundFile`. Parameters ---------- verbose : bool Whether to print additional information. )r)rrs rrrs $ ((rcdtttjtjS)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_helper_sndSFC_GET_FORMAT_MAJOR_COUNTSFC_GET_FORMAT_MAJORrrravailable_formatsrs-" )$*I*I*.*C*CE FFrc|ttjtj}t fd|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'} c3HK|]\}} t|r||fywr) check_format).0rrrs r z%available_subtypes..s.DXMGT>\&'%B$Xs")rrSFC_GET_FORMAT_SUBTYPE_COUNTSFC_GET_FORMAT_SUBTYPEr)rsubtypess` ravailable_subtypesrs>"))J)J)-)D)DFH DXD DDrcZ tt|||S#ttf$rYywxYw)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)rrrs rrrs2K899  "s **c^t|tj|jS)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_format_default_subtypesgetupperrs rdefault_subtypers#&   00rceZdZdZ d4dZedZ edZ edZ edZ edZ ed Z ed Z ed Z ed Z ed Z edZ edZ edZ edZdZdZdZdZdZdZdZdZdZdZdZefdZ dZ! d5dZ"d6dZ#d Z$d!Z%d"Z& d7d#Z'd8d$Z(d%Z)d&Z*d'Z+d(Z,d)Z-d*Z.d+Z/d,Z0d-Z1d.Z2d/Z3d0Z4d1Z5d2Z6d3Z7y)9rzA sound file. For more documentation see the __init__() docstring (which is also used for the online documentation (https://python-soundfile.readthedocs.io/). Nc t|dr|jn|}||_| t|dd}t |} ||_t ||||||||_|j|| ||_ t|jdr!|jr|jdtj|jtj t"j$tj&y)a{Open 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. 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 __fspath__Nmodezr+r)hasattrr_namegetattr _check_mode_mode_create_info_struct_info_open_fileset issupersetseekableseekr sf_commandSFC_SET_CLIPPING_ffiNULLSF_TRUE) rrrrrrrrrmode_ints rrzSoundFile.__init__,s|%,D,$?t T <4.Dt$ (tZ)/&B ZZh8 t9   %$--/ IIaL  D$9$9499  &rc|jSr)rrs rzSoundFile.rc|jSr)rrs rrzSoundFile.rrc.|jjSr)rrrs rrzSoundFile.stzz'<'s4::#4#4rc.|jjSr)rrrs rrzSoundFile.TZZ%8%8rcbt|jjtjzSr) _format_strrrrSF_FORMAT_TYPEMASKrs rrzSoundFile.s[!2!2T5L5L!LMrcbt|jjtjzSr)r rrrSF_FORMAT_SUBMASKrs rrzSoundFile.[!2!2T5K5K!KLrcbt|jjtjzSr)r rrrSF_FORMAT_ENDMASKrs rrzSoundFile.rrcht|jjtjzdSNr) _format_inforrrrrs rrzSoundFile.s+\$**"3"3"&"9"9#:;;<>rcht|jjtjzdSr)rrrrrrs rrzSoundFile.s+\$**"3"3"&"8"8#9::;=rc.|jjSr)rrrs rrzSoundFile.r rc|jduSr)rrs rrzSoundFile.s 4::#5rc@tj|jSr)rsf_errorrrs rrzSoundFile.st}}TZZ'@rctjdd}tj|jtj |tj |tj|jddS)z8Retrieve the log string generated when opening the file.zchar[]i@rr) rnewrrrSFC_GET_LOG_INFOsizeofstringdecode)rrs rrzSoundFile.extra_infosXxx%(  D$9$9dkk$/ 1{{4 '';;rc$dj|S)NzSoundFile({0.name!r}, mode={0.mode!r}, samplerate={0.samplerate}, channels={0.channels}, format={0.format!r}, subtype={0.subtype!r}, endian={0.endian!r})rrs rrzSoundFile.__repr__s'(.vd| 5rc$|jyrclosers r__del__zSoundFile.__del__  rc|Srrrs r __enter__zSoundFile.__enter__s rc$|jyrr$)rargss r__exit__zSoundFile.__exit__r'rc|tvrR|jtj|jt||j }t |ytj|||y)z:Write text meta-data in the sound file through properties.N) _str_types_check_if_closedr sf_set_stringrencode _error_checkobject __setattr__)rrvalueerrs rr4zSoundFile.__setattr__sV :   ! ! #$$TZZD1A%*\\^5C     tT5 1rc|tvr`|jtj|jt|}|r%t j |jddSdStdj|)z9Read text meta-data in the sound file through properties.rrz)'SoundFile' object has no attribute {0!r}) r.r/r sf_get_stringrrr r!AttributeErrorr)rrrs r __getattr__zSoundFile.__getattr__sq :   ! ! #%%djj*T2BCDCG4;;t$++GY? OR O ;BB4HJ Jrc.|jjSrr rs r__len__zSoundFile.__len__szz   rcy)NTrrs r__bool__zSoundFile.__bool__src"|jSr)r?rs r __nonzero__zSoundFile.__nonzero__s}}rcP|jjtjk(S)z)Return True if the file supports seeking.)rrrrrs rrzSoundFile.seekableszz""dll22rc|jtj|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 )r/rsf_seekrr2 _errorcode)rrwhencepositions rrzSoundFile.seeks8H << FF;T__%rc.|jdtS)z'Return the current read/write position.r)rrrs rtellzSoundFile.tell%syyH%%rc|&|j||}|j|||}n|dks|t|kDr t|}|jd||}t||kDr||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 Nrr) _check_frames_create_empty_arraylen _array_io)rrrrrrs rrzSoundFile.read)s` ;'' ;F**69eDCzVc#h.SV4 s8f !'6l  *FG  rc|j|d}|j|}tj|dz||jz}|j d|||}||k(sJtj |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)rz[]r)rK _check_dtyperrr _cdata_iobuffer)rrrctypecdata read_framess r buffer_readzSoundFile.buffer_readsw8##Ft#<!!%(v '=>nnVUE6B f$$${{5!!rcz|j|}|j||\}}|jd|||}|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 r)rP _check_bufferrQ)rrRrrSrTrs rbuffer_read_intozSoundFile.buffer_read_intosC8!!%(**659 vuf= rcddl}|j|}|jd|t|}|t|k(sJ|j |y)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)rascontiguousarrayrNrM_update_frames)rrrwrittens rrzSoundFile.writesN\ ##D)..$D :#d)### G$rc|j|}|j||\}}|jd|||}||k(sJ|j|y)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)rPrXrQr\)rrrrSrTrr]s r buffer_writezSoundFile.buffer_writesZ*!!%(**47 v..%?&    G$rc #@Kddl}d|jvrd|jvr td|#| td|j |||}d} n| tdt |}d } d} |j ||}|dkDr| d} nt | } | |d| t|| z |} |j| ||||| d|r!| |j|| d} n || d| dd|||zkDr | |d||z} n|} | r|j| n| || z}|dkDryyw) 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' rNr+z*blocks() is not allowed in write-only modez)One of {blocksize, out} must be specifiedTz-Only one of {blocksize, out} may be specifiedF) rrSoundFileRuntimeErrorrrLrMrKminrcopy)rrrrrrrrrcopy_outoverlap_memory output_offsettoreadrs rrzSoundFile.blockssod  dii Ctyy$8'(TU U ;  KLL**9iGCH$CEECIH##FJ7qj% ! #N 3 &4N]#]2F;F IIfeY C YY[Foodjj$*@*@"hh}f="kk,79 -- +C!#'BC C" rcb|jtj|jy)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)r/r sf_write_syncrrs rflushzSoundFile.flushs"  4::&rc|jsB|jtj|j}d|_t |yy)z.Close the file. Can be called multiple times.N)closedrprsf_closerr2)rr6s rr%zSoundFile.closes8{{ JJL-- +CDJ   rct|ttfr9tjj |rd|j vr$tdj|jt|j jdrHtjtj|tjtjzt j"}t|trGt$j&dk(rt j(}n#|j+t%j,}||||j.}nt|t0r#t j3|||j.|}npt5||r@t j7|j9|||j.t:j<}n$t?dj|j|t:j<k(r;t jA|}tC|dj|j|t jDk(rd|j._#|S) z9Call the appropriate sf_open*() function from libsndfile.xzFile exists: {0!r}zw+rzInvalid file: {0!r}zError opening {0!r}: prefixr)$ isinstance_unicodebytes_ospathisfilerOSErrorrrrrr%openO_WRONLYO_TRUNCrsf_open_sysplatform sf_wchar_openr1getfilesystemencodingrrx sf_open_fd_has_virtual_io_attrssf_open_virtual_init_virtual_iorrrrrl SFM_WRITEr)rrrr openfunctionfile_ptrr6s rrzSoundFile._opens dXu- .xxt$$))#!"6"="=dii"HII^..t4IIchhtS\\CKK-GHI<.vio_get_filelens:99;D IIa "99;D IIdH %Kr sf_vio_seekcHj||jSr)rrI)offsetrFrrs rvio_seekz,SoundFile._init_virtual_io..vio_seeks IIff %99; r sf_vio_readc tj||}j|}|S#t$r;j |}t |}tj||}||d|Y|SwxYwr)rrRreadintor:rrM)ptrcountrbuf data_readrrs rvio_readz,SoundFile._init_virtual_io..vio_readsx (kk#u- MM#.   " (yy'I kk#y1#'Ai    (s',AA0/A0 sf_vio_writechtj||}|dd}j|}||}|Sr)rrRr)rrrrrr]rs r vio_writez-SoundFile._init_virtual_io..vio_writes9++c5)Cq6Djj&GNr sf_vio_tellc$jSr)rI)rrs rvio_tellz,SoundFile._init_virtual_io..vio_tells99; r) get_filelenrrrrIzSF_VIRTUAL_IO*)rcallback _virtual_ior)rrrrrrrs ` rrzSoundFile._init_virtual_ios + ,  -  } %  &  } %  &  ~ &  '  } %  & ,;$,$,%.$, . xx($*:*:;;rctS)zReturn all attributes used in __setattr__ and __getattr__. This is useful for auto-completion (e.g. IPython). )r.rs r_getAttributeNameszSoundFile._getAttributeNamess rc2|jr tdy)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)rrrbrs rr/zSoundFile._check_if_closeds ;;'(FG G rc|jr-|j|jz }|dks||kDr||}|S|dkr td|S)z8Reduce frames to no more than are available in the file.rz/frames must be specified for non-seekable files)rrrIr)rrrremaining_framess rrKzSoundFile._check_framess[ ==?#{{TYY[8 zf'77(0) aZNO O rc|tjvsJt|tst j |}t t||jt j|z\}}|r td||fS)z1Convert buffer to cdata and check for valid size.z*Data size must be a multiple of frame size) _ffi_typesvaluesrxrzr from_bufferrrMrrr)rrrSr remainders rrXzSoundFile._check_buffersw ))++++$&##D)D"3t9#'==4;;u3E#EG IJ JV|rcxddl}|s|jdkDr||jf}n|f}|j||dS)z-Create an empty array with appropriate shape.rNrC)order)rrempty)rrrrrrs rrLzSoundFile._create_empty_array$s=  )DMM)EGExxuCx00rc  t|S#t$r7tdjt tj |wxYw)z7Check if dtype string is valid and return ctype string.z(dtype must be one of {0!r} and not {1!r})rKeyErrorrrsortedkeys)rrs rrPzSoundFile._check_dtype-sM 3e$ $ 3GNNz()523 3 3s  AA cZ|jdvsI|jdk(r|jdk7s+|jdk(r@|jd|jk7r$tdj |j|j j s td|j|jj}|jjtj|k(sJtj|dz|jdd}|j||||S) z+Check array and call low-level IO function.)rr rr zInvalid shape: {0!r}zData must be C-contiguous*rr)rrrrrflags c_contiguousrPrritemsizerrcast__array_interface__rQ)ractionarrayrrSrTs rrNzSoundFile._array_io5s JJf $ aDMMQ$6 aEKKNdmm$C3::5;;GH H{{''89 9!!%++"2"23{{##t{{5'9999 %#+u'@'@'H'KL~~feUF;;rcl|tjvsJ|j|jr|j }t t d|zdz|z}||j||}t|j|jr|j|zt|S)z.Call one of libsndfile's read/write functions.sf_f_) rrr/rrIrrrr2rErr)rrrrSrrfuncs rrQzSoundFile._cdata_ioBs ))++++  ==?99;DtUV^d2U:;djj$/T__% ==? IIdVmX . rc|jrL|j}|jdt|j_|j|t y|jxj |z c_y)z!Update self.frames after writing.rN)rrIrrrrr)rr]rs rr\zSoundFile._update_framesOsP ==?99;D $ !X 6DJJ  IIdH % JJ   ( rc*|dk7r|js td|dk\r | tdt||j |j \}}}||kr|}|dkr||z }|jr|j |t|S)z)Seek to start frame and calculate length.rz(start is only allowed for seekable filesz&Only one of {frames, stop} may be used)rrrsliceindicesrrr)rrrr_s rrzSoundFile._prepare_readXs A:dmmoGH H Q;4+DE Eud+33DKK@tQ %<D A:E\F ==? IIeX & rci}tjD]P\}}tj|j|}|s)t j |jdd||<R|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'. rr)r.itemsrr9rrr r!)rstrsstrtypestridrs r copy_metadatazSoundFile.copy_metadatahs_(..0NGU%%djj%8D $ D 1 8 8) LW 1 r)rNNNNNT)rzFNN)rN)NrrrzFNNr)8rrrrrrrrrrrrrrrrrrrrErrrr&r)r,r4r;r=r?rArrrrIrrVrYrr_rrmrpr%rrrr/rKrXrLrPrNrQr\rrrrrrr$sBFAEk&Z + ,D* + ,D7<=J, 4 5F189H3 MOF-LNG4 LNF8 >?K? =>L:89H3 5 6F2@AJ' << E5 2J!   3#+'R&:?"&\|!"FB3%j%6BK59Zx#0 '"H1** 88J DDKDM D!T]]2 ?A A M# C188ABBC F5<> Orc|}|$t||}t|ttfs Jt |t j d}d|vs|jdk(r<| td||_ | td||_ t||||_ |Std|||||fDr td|S)z*Check arguments and create SF_INFO struct.rrrzsamplerate must be specifiedzchannels must be specifiedc3$K|]}|du ywrr)rargs rrz&_create_info_struct..s I+H3s$+Hsz\Not allowed for existing files (except 'RAW'): samplerate, channels, format, subtype, endian)_get_format_from_filenamerxryrrrrrrrrrrany) rrrrrrroriginal_formatrs rrrsO ~*46&8S/222f 88J D $&,,.E1  :; ;$  89 9  !&'6: K IHow+HI ILM M Krcd}t|d|} tjj|ddd}|j dd}|j tvrd|vrtd j||S#t $rYAwxYw) 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). r8rrrNrrrzGNo format specified and unable to get format from file extension: {0!r}) rr{r|splitextr! Exceptionr_formatsrr)rrrs rrrsF 4 &D ""4(,QR0w 2||~X%#T/006t > > M    s7A>> B  B cvtttfD]%}|jD]\}}||k(s |ccS'y)z;Return the string representation of a given numeric format.zn/a)rrrr) format_int dictionarykvs rr r s; 83 $$&DAqJ'4 rcBtjd}||_tj tj ||tj d|j}t|j|r&tj|jddfSdfS)z6Return the ID and short description of a given format.zSF_FORMAT_INFO*SF_FORMAT_INFOrrr8) rrrrrrrrr r r!)r format_flagrrs rrrs((,-K#KOODII{KKK 013   D  ** +<@DKK  $ $Wi 8 JJFH JJrc#Ktjd}tjtj||tj dt |dD]}t||yw)z8Helper for available_formats() and available_subtypes().zint*rxrN)rrrrrrranger) count_flagrrrs rrrsR HHV EOODIIz5$++e2DEE!Ho :{33&sA1A3ct|ttfstdj | t |j }|S#t$rtdj |wxYw)z4Check if `format_str` is valid and return format ID.zInvalid format: {0!r}zUnknown format: {0!r}) rxryrrrrrrr) format_strrs rrrsr j8S/ 2/66zBCCEj..01   E077 CDDEs A $A/c |tjk(}|tjk(}tt |dt |dt |dxs|t |dxst |dxs|gS)z>Check if file has all the necessary attributes for virtual IO.rrIrrr)rrrallr)rrreadonly writeonlys rrrsn4==(HDNN*I ffg*(fGz!:Gi  rceZdZdZy)SoundFileErrorz-Base class for all soundfile-specific errors.Nrrrrrrrrrs7rrceZdZdZy)rbzKsoundfile module runtime error. Errors that used to be `RuntimeError`.Nrrrrrbrb s . rrbc.eZdZdZddZedZdZy)rlzjlibsndfile errors. Attributes ---------- code libsndfile internal error number. cNtj|||||_||_yr)rbrcoderw)rrrws rrzLibsndfileError.__init__/s"&&tT6:  rc|jrDtj|j}tj|j ddSy)zRaw libsndfile error message.rrz'(Garbled error message from libsndfile))rrsf_error_numberrr r!)rerr_strs r error_stringzLibsndfileError.error_string4s@ 99**4995G;;w'..w B B =rc4|j|jzSr)rwr rs r__str__zLibsndfileError.__str__@s{{T....rNr8)rrrrrrr r rrrrlrl&s%  = =/rrl) rrNrzFNNNNNNNT)NNNT)NrrrNrzFNNNNNNNT)Fr)NNr)Pr __version__osr{sysrrrr ctypes.utilr _find_library _soundfilerrunicodery NameErrorrr.rrrrrrr_machine_packaged_libnamer _architecturer~_soundfile_datar|dirname__file___pathr _full_pathdlopenr ImportErrorr_libname_explicit_libnameisdir _hbrew_pathr sf_version_stringr!__libsndfile_version__ startswithrMrrrr3rrrrrrrr2rrrrr SFC_GET_FORMAT_INFOrrrrrr RuntimeErrorrbrlrrrr*s  ++5"H     X  X  X  X    X    X   X  X  X  X  X  X  X  X  X   X! " X# $        5 :#  f#  f#  f#  f #   f #   f #  f#  f#  f# f# f#  f# f# f# f#  f!# "f## $f%# &f'# (f)# *f+# ,f-# . f/# 0 f1# 2f3# 4 f5# 6 f7# 8f9# :f;# <f=# >f?# @fA# BfC# DfE#  L   X X X  X   X  X X X X X X X Y X  X!" X#$ X%&       5<    ,2 }} 0)HJ6A ' !:)MOA,>>G ' !0)HJ6>=>> HH  _55 6Eu&78J 4;;z "D<%T%;%;%=>EEgyY$$]33C 4F4GHJO>B9=ZzEI5pFJBF%);?8v16V16h)F*D.$ 1 T T p2 @&60*.)A)AJ4  Y  NL /+/c0Hb i(22 +  TU Ut{{8$ 2 ==H $ 2  ]]g % 0  ]]g % /   1 ==H $w)>25((..AU2V.& 4;;sxx}}[:KLMD4;;01D'22sIK-C KKKO&$L  O B9OOOO O