U -eT#@s*dZdZddlZddlZddlmZmZmZddl m Z ddl m ZzeZWnek rdeZYnXddd d d d d dddd Zddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,Zddd d d d d dd-d.d/d0d1d2d3d4d5d6d7d8d9d:d;dd?d@dAdBdCdDdEdFdG"ZddHdIdJdKZdLdLdLdLdLdLdLdLdLdMdMdLdNdLdLdLdLdLdLdLdOdPdLdLdQdRZdSdTdUdVdWZzejdXkrddYlmZdZed[Zn\ejd\krdd]lmZdZedd^Zn0ejd_krddYlmZdZed`Znedaddl Z ej!"e j#Z$ej!%e$eZ&e'e&Z(Wnee)e*fk rz(e dbZ+e+dkrBedce'e+Z(Wnek rejdXkrrddZ,n&ejd\krdeZ,nejd_krdfZ,nddYlmZejdXkredgkrej!-dhrdhndiZ.e'ej!%e.e,Z(n e'e,Z(YnXYnXe/e(01djdkZ2e23dlr0e2e4dldZ2ddqdrZ5ddsdtZ6ddudvZ7Gdwdxdxe8Z9ddydzZ:d{d|Z;dd}d~ZGddde8Z?dddZ@ddZAddZBddZCddZDddZEe(jFfddZGddZHddZIddZJGdddeKZLGdddeLeMZNGdddeNZOdS)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 copyrightZsoftwareZartistcommentdateZalbumlicenseZ tracknumberZgenreiiiiiiiii i i i iiiiiiiiiii i!i"i#)WAVAIFFAURAWPAFSVXNISTVOCIRCAMW64MAT4MAT5PVFXIHTKSDSAVRWAVEXSD2FLACCAFWVEOGGMPC2KRF64MP3 !"#$012@ABCPQ`dpqrs)"ZPCM_S8PCM_16ZPCM_24ZPCM_32ZPCM_U8FLOATDOUBLEZULAWALAWZ IMA_ADPCMZMS_ADPCMZGSM610Z VOX_ADPCMZ NMS_ADPCM_16Z NMS_ADPCM_24Z NMS_ADPCM_32ZG721_32ZG723_24ZG723_40ZDWVW_12ZDWVW_16ZDWVW_24ZDWVW_NZDPCM_8DPCM_16VORBISZOPUSZALAC_16ZALAC_20ZALAC_24ZALAC_32Z MPEG_LAYER_IZ MPEG_LAYER_IIMPEG_LAYER_IIIii i0)FILEZLITTLEZBIGZCPUrJrLrNrMrOrP)rrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/doublefloatintshort)float64Zfloat32Zint32Zint16darwin)machineZ libsndfile_z.dylibwin32) architecturez.dlllinuxz.soz%no packaged library for this platformZsndfilez8sndfile library not found using ctypes.util.find_libraryzlibsndfile.dylibzlibsndfile.dllz libsndfile.soarm64z/opt/homebrew/lib/z/usr/local/lib/utf-8replacez libsndfile-rVFTc CsLt|d|| | | | | &}||||}||||||}W5QRX||jfS)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 r) SoundFile _prepare_readread samplerate)fileframesstartstopdtype always_2d fill_valueoutrdchannelsformatsubtypeendianclosefdfdatartJ/var/www/html/Darija-Ai-Train/env/lib/python3.8/site-packages/soundfile.pyrcsV rcc Cs\ddl}||}|jdkr"d}n |jd}t|d||||||} | |W5QRXdS)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)numpyZasarrayndimshaperawrite) rersrdrorprnrqnprmrrrtrtrurz$s-    rzc csVt|d| | | || |6}||||}|||||||| D] }|Vq>> import soundfile as sf >>> for block in sf.blocks('stereo_file.wav', blocksize=1024): >>> pass # do something with 'block' r`N)rarbblocks)re blocksizeoverlaprfrgrhrirjrkrlrdrmrnrorprqrrblockrtrtrur|\s3  r|c@s,eZdZdZddZeddZddZdS) _SoundFileInfozInformation about a SoundFilec Cs||_t|p}|j|_|j|_|j|_|j|_t|j|j|_|j|_|j |_ |j |_ |j |_ |j |_ |j |_ |j|_W5QRXdSN)verboseranamerdrmrfrSdurationrnrorp format_info subtype_infosections extra_info)selfrerrrrtrtru__init__s z_SoundFileInfo.__init__cCspt|jd\}}t|d\}}|dkr6d|||}n6|dkrLd||}n |dkrbd|j}n d|}|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)divmodrrnrf)rhoursrestminutessecondsrrtrtru _duration_strs z_SoundFileInfo._duration_strcCsRdddddddg}|jr4|ddd d d d g7}d |jd}|||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 )joinrrsplitrn)rinfoZindented_extra_infortrtru__repr__s(z_SoundFileInfo.__repr__N)__name__ __module__ __qualname____doc__rpropertyrrrtrtrtrurs  rcCs t||S)zReturns an object with information about a `SoundFile`. Parameters ---------- verbose : bool Whether to print additional information. )r)rerrtrtrursrcCstttjtjS)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_sndZSFC_GET_FORMAT_MAJOR_COUNTZSFC_GET_FORMAT_MAJORrtrtrtruavailable_formatssrcs$ttjtj}tfdd|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'} c3s,|]$\}}dkst|r||fVqdSr) check_format).0rorrnrtru s z%available_subtypes..)rrZSFC_GET_FORMAT_SUBTYPE_COUNTZSFC_GET_FORMAT_SUBTYPEr)rnsubtypesrtrruavailable_subtypessrc Cs2ztt|||WSttfk r,YdSXdS)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 FN)bool _format_int ValueError TypeError)rnrorprtrtrurs 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_format_default_subtypesgetupperrrtrtrudefault_subtypes rc@seZdZdZd_ddZeddZed dZed dZed dZ ed dZ ed dZ eddZ eddZ eddZeddZeddZeddZeddZeddZdZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zefd+d,Z d-d.Z!d`d2d3Z"dad4d5Z#d6d7Z$d8d9Z%d:d;Z&dbd=d>Z'dcd?d@Z(dAdBZ)dCdDZ*dEdFZ+dGdHZ,dIdJZ-dKdLZ.dMdNZ/dOdPZ0dQdRZ1dSdTZ2dUdVZ3dWdXZ4dYdZZ5d[d\Z6d]d^Z7dS)drazA sound file. For more documentation see the __init__() docstring (which is also used for the online documentation (https://python-soundfile.readthedocs.io/). r`NTc Cst|dr|n|}||_|dkr0t|dd}t|} ||_t||||||||_||| ||_ t | dr| r| dt|j tjtjtjdS)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_commandZSFC_SET_CLIPPING_ffiNULLSF_TRUE) rrerrdrmrorprnrqmode_intrtrtrur,s"^   zSoundFile.__init__cCs|jSr)rrrtrtruzSoundFile.cCs|jSr)rrrtrtrurrcCs|jjSr)rrdrrtrtrurrcCs|jjSrrrfrrtrtrurrcCs|jjSr)rrmrrtrtrurrcCst|jjtj@Sr) _format_strrrnrSF_FORMAT_TYPEMASKrrtrtrurrcCst|jjtj@Sr)rrrnrSF_FORMAT_SUBMASKrrtrtrurrcCst|jjtj@Sr)rrrnrZSF_FORMAT_ENDMASKrrtrtrurrcCst|jjtj@dSNr) _format_inforrnrrrrtrtrurscCst|jjtj@dSr)rrrnrrrrtrtrurscCs|jjSr)rrrrtrtrurrcCs |jdkSr)rrrtrtrurrcCs t|jSr)rsf_errorrrrtrtrurrcCs8tdd}t|jtj|t|t|ddS)z8Retrieve the log string generated when opening the file.zchar[]i@r]r^) rnewrrrZSFC_GET_LOG_INFOsizeofstringdecode)rrrtrtrurs   zSoundFile.extra_infocCs d|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})rrrtrtrurszSoundFile.__repr__cCs |dSrcloserrtrtru__del__szSoundFile.__del__cCs|Srrtrrtrtru __enter__szSoundFile.__enter__cGs |dSrr)rargsrtrtru__exit__szSoundFile.__exit__cCsD|tkr2|t|jt||}t|nt|||dS)z:Write text meta-data in the sound file through properties.N) _str_types_check_if_closedrZ sf_set_stringrencode _error_checkobject __setattr__)rrvalueerrrtrtrurs zSoundFile.__setattr__cCsN|tkr<|t|jt|}|r8t|ddSdStd |dS)z9Read text meta-data in the sound file through properties.r]r^z)'SoundFile' object has no attribute {0!r}N) rrr sf_get_stringrrrrAttributeErrorrn)rrrsrtrtru __getattr__szSoundFile.__getattr__cCs|jjSrrrrtrtru__len__szSoundFile.__len__cCsdS)NTrtrrtrtru__bool__szSoundFile.__bool__cCs|Sr)rrrtrtru __nonzero__szSoundFile.__nonzero__cCs|jjtjkS)z)Return True if the file supports seeking.)rrrrrrtrtrurszSoundFile.seekablecCs&|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)rrfwhencepositionrtrtrurs$ zSoundFile.seekcCs |dtS)z'Return the current read/write position.r)rrrrtrtrutell%szSoundFile.tellr_rVFcCs|dkr$|||}||||}n|dks8|t|kr@t|}|d||}t||kr||dkrp|d|}n |||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 Nrrc) _check_frames_create_empty_arraylen _array_io)rrfrirjrkrlrtrtrurc)sP   zSoundFile.readcCsT|j|dd}||}t|d||j}|d|||}||ksJtt|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)rkz[]rc)r _check_dtyperrrm _cdata_ioAssertionErrorbuffer)rrfrictypecdataZ read_framesrtrtru buffer_reads   zSoundFile.buffer_readcCs.||}|||\}}|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 rc)r _check_bufferr)rrrirrrfrtrtrubuffer_read_intos zSoundFile.buffer_read_intocCsBddl}||}|d|t|}|t|ks4t||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 rNrz)rwZascontiguousarrayrrr_update_frames)rrsr{writtenrtrtrurzs . zSoundFile.writecCsD||}|||\}}|d|||}||ks6t||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 rzN)rrrrr)rrsrirrrfrrtrtru buffer_writes   zSoundFile.buffer_writerc cs\ddl}d|jkr$d|jkr$td|dkrP|dkr>> 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) rwrSoundFileRuntimeErrorrrrrminrccopy)rr}r~rfrirjrkrlr{Zcopy_outZoverlap_memoryZ output_offsetZtoreadrrtrtrur|s@2   zSoundFile.blockscCsX|dkr|}t|jtjtd|td}|rLt|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_TRUNCATErrrrLibsndfileErrorrrf)rrfrrtrtrutruncatews     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_syncrrrtrtruflushs zSoundFile.flushcCs,|js(|t|j}d|_t|dS)z.Close the file. Can be called multiple times.N)closedrrZsf_closerr)rrrtrtrurs  zSoundFile.closecCs6t|ttfrtj|r`d|jkr6td|j n*t |j dr`t t |tjtjBtj}t|trtjdkrtj}n|t}||||j}nTt|trt|||j|}n6t||rt||||jtj}ntd|j |tjkrt |}t!|d|j d|tj"kr2d|j_#|S) z9Call the appropriate sf_open*() function from libsndfile.xzFile exists: {0!r}zw+rYzInvalid file: {0!r}zError opening {0!r}: prefixr)$ isinstance_unicodebytes_ospathisfilerOSErrorrnrrrropenO_WRONLYO_TRUNCrZsf_open_sysplatformZ sf_wchar_openrgetfilesystemencodingrrTZ sf_open_fd_has_virtual_io_attrsZsf_open_virtual_init_virtual_iorrrrr SFM_WRITErf)rrerrqZ openfunctionZfile_ptrrrtrtrurs6          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_datacurrsizerertruvio_get_filelens   z3SoundFile._init_virtual_io..vio_get_filelenZ sf_vio_seekcs||Sr)rr)offsetrrrrtruvio_seeks z,SoundFile._init_virtual_io..vio_seekZ sf_vio_readcs^zt||}|}Wn>tk rX|}t|}t||}||d|<YnX|Sr)rrreadintorrcr)ptrcountrbufZ data_readrsrrtruvio_reads   z,SoundFile._init_virtual_io..vio_readZ sf_vio_writecs2t||}|dd}|}|dkr.|}|Sr)rrrz)rrrr rsrrrtru vio_writes    z-SoundFile._init_virtual_io..vio_writeZ sf_vio_tellcsSr)r)rrrtruvio_tellsz,SoundFile._init_virtual_io..vio_tell)Z get_filelenrrcrzrzSF_VIRTUAL_IO*)rcallbackZ _virtual_ior)rrerrr!r"r#rtrrurs"  zSoundFile._init_virtual_iocCstS)zReturn all attributes used in __setattr__ and __getattr__. This is useful for auto-completion (e.g. IPython). )rrrtrtru_getAttributeNamesszSoundFile._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)rrrrtrtrurszSoundFile._check_if_closedcCsH|r4|j|}|dks.||krD|dkrD|}n|dkrDtd|S)z8Reduce frames to no more than are available in the file.rNz/frames must be specified for non-seekable files)rrfrr)rrfrkZremaining_framesrtrtrurszSoundFile._check_framescCsV|tkstt|ts$t|}tt||j t |\}}|rNt d||fS)z1Convert buffer to cdata and check for valid size.z*Data size must be a multiple of frame size) _ffi_typesvaluesrrrrZ from_bufferrrrmrr)rrsrrf remainderrtrtrurs  zSoundFile._check_buffercCs8ddl}|s|jdkr"||jf}n|f}|j||ddS)z-Create an empty array with appropriate shape.rNrC)order)rwrmempty)rrfrjrir{ryrtrtrur$s  zSoundFile._create_empty_arrayc Cs<z t|WStk r6tdtt|YnXdS)z7Check if dtype string is valid and return ctype string.z(dtype must be one of {0!r} and not {1!r}N)r&KeyErrorrrnsortedkeys)rrirtrtrur-s  zSoundFile._check_dtypecCs|jdks8|jdkr|jdks8|jdkrH|jd|jkrHtd|j|jjsXtd||jj }|jj t |ks|t t |d|jdd}|||||S) z+Check array and call low-level IO function.)rrrrzInvalid shape: {0!r}zData must be C-contiguous*rsr)rxrmryrrnflags c_contiguousrriritemsizerrrcastZ__array_interface__r)ractionarrayrfrrrtrtrur5s  zSoundFile._array_iocCsr|tkst||r(|}ttd|d|}||j||}t |j |rn| ||t |S)z.Call one of libsndfile's read/write functions.Zsf_Zf_) r&r'rrrrrrrrrrr)rr4rsrrfrfuncrtrtrurBs zSoundFile._cdata_iocCsB|r.|}|dt|j_||tn|jj|7_dS)z!Update self.frames after writing.rN)rrrrrrfr)rrrrtrtrurOs zSoundFile._update_framescCs||dkr|std|dkr0|dk r0tdt|||j\}}}||krT|}|dkrd||}|rx||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)rrrsliceindicesrfrr)rrgrhrf_rtrtrurbXs zSoundFile._prepare_readcCsBi}tD]0\}}t|j|}|r t|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]r^)ritemsrrrrrr)rstrsZstrtypeZstridrsrtrtru copy_metadatahs zSoundFile.copy_metadata)r`NNNNNT)r_rVFNN)r_N)Nrr_rVFNN)N)8rrrrrrrrrdrfrmrnrorprrrrrrrrrrrrrrrrrrrrrcrrrzrr|rrrrrr%rrrrrrrrrbr<rtrtrtrura$s m            ) ^ #!5 \  $3       rarcCs|dkrt||ddS)z+Raise LibsndfileError if there is an error.rrN)r)rrrtrtrur|srcCst|}|dkr0t|}|dkrLtd|nt|ttfsLtd|z|t|O}Wn"t k rt d|YnX|dkrd}nt|ttfstd|z|t |O}Wn"t k rt d|YnXt d}||_d |_t|tjkrt d |S) z8Return numeric ID for given format|subtype|endian combo.Nz)No default subtype for major format {0!r}zInvalid subtype: {0!r}zUnknown subtype: {0!r}rQzInvalid endian-ness: {0!r}zUnknown endian-ness: {0!r}SF_INFO*rz1Invalid combination of format, subtype and endian)rrrrnrrstr _subtypesrr,r_endiansrrrmrZsf_format_checkZSF_FALSE)rnrorpresultrrtrtrurs: rcCst|ttfstd|t|}|ds>t|t|krLtd|t| ddkrftdd|krvt j }nd|krt j }nt j }|S)z=Check if mode is valid and return its integer representation.zInvalid mode: {0!r}zxrwb+Zxrwrz&mode must contain exactly one of 'xrw'rr`)rrr>rrnr differencerr intersectionrZSFM_RDWRSFM_READr)rZmode_setrrtrtrursrc Cs|}|dkr*t||}t|ttfs2tnt|td}d|ksP|dkr|dkr`t d||_ |dkrvt d||_ t ||||_ n$tdd|||||fDrt d |S) z*Check arguments and create SF_INFO struct.Nr=r`rzsamplerate must be specifiedzchannels must be specifiedcss|]}|dk VqdSrrt)rargrtrtrursz&_create_info_struct..z\Not allowed for existing files (except 'RAW'): samplerate, channels, format, subtype, endian)_get_format_from_filenamerrr>rrrrrrrdrmrrnany) rerrdrmrnrorpZoriginal_formatrrtrtrurs.   rcCstd}t|d|}z(tj|ddd}|dd}Wntk rLYnX|tkrpd|krptd ||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). rrr_rNr]r^r`zGNo format specified and unable to get format from file extension: {0!r}) rrr splitextr Exceptionr_formatsrrn)rerrnrtrtrurFs  rFcCs:tttfD]*}|D]\}}||kr|Sqq dS)z;Return the string representation of a given numeric format.zn/aN)rJr?r@r:) format_int dictionarykvrtrtrurs rcCsRtd}||_ttj||td|j}t|j|rLt | ddndfS)z6Return the ID and short description of a given format.zSF_FORMAT_INFO*ZSF_FORMAT_INFOr]r^r) rrrnrrrrrrrr)rK format_flagrrrtrtrurs  rccsDtd}ttj||tdt|dD]}t||Vq.dS)z8Helper for available_formats() and available_subtypes().zint*rTrN)rrrrrrranger)Z count_flagrOrrKrtrtrurs rcCsTt|ttfstd|zt|}Wn"tk rNtd|YnX|S)z4Check if `format_str` is valid and return format ID.zInvalid format: {0!r}zUnknown format: {0!r}) rrr>rrnrJrr,r) format_strrKrtrtrursrcCsN|tjk}|tjk}tt|dt|dt|dp2|t|dpHt|dpH|gS)z>Check if file has all the necessary attributes for virtual IO.rrrzrcr)rrDrallr)rerreadonlyZ writeonlyrtrtrurs   rc@seZdZdZdS)SoundFileErrorz-Base class for all soundfile-specific errors.NrrrrrtrtrtrurTsrTc@seZdZdZdS)rzKsoundfile module runtime error. Errors that used to be `RuntimeError`.NrUrtrtrtrur src@s.eZdZdZd ddZeddZddZd S) rzjlibsndfile errors. Attributes ---------- code libsndfile internal error number. rcCst|||||_||_dSr)rrcoder)rrVrrtrtrur/szLibsndfileError.__init__cCs,|jr$t|j}t|ddSdSdS)zRaw libsndfile error message.r]r^z'(Garbled error message from libsndfile)N)rVrZsf_error_numberrrr)rZerr_strrtrtru error_string4s zLibsndfileError.error_stringcCs |j|jSr)rrWrrtrtru__str__@szLibsndfileError.__str__N)r)rrrrrrrWrXrtrtrtrur&s   r) r_rNrVFNNNNNNNT)NNNT)Nrr_rNrVFNNNNNNNT)F)N)NN)r)Pr __version__osrsysrrrr ctypes.utilrZ _find_libraryZ _soundfilerrunicoder NameErrorr>rrJr?r@rr&rrXZ_machineZ_packaged_libnamerZZ _architecturer Z_soundfile_datar dirname__file___pathrZ _full_pathZdlopenr ImportErrorrZ_libnameZ_explicit_libnameisdirZ _hbrew_pathrZsf_version_stringrZ__libsndfile_version__ startswithrrcrzr|rrrrrrrrarrrrrFrZSFC_GET_FORMAT_INFOrrrrrIrT RuntimeErrorrrrtrtrtrus    &              ] 8 ;4   ^