o "Øh`ýã @s¦dZdZddlZddlZddlmZmZmZddl m Z ddl m ZzeZWn ey1eZYnwddd d d d d ddddœ Zidd“dd“dd“dd“dd“dd“dd“d d!“d"d#“d$d%“d&d'“d(d)“d*d+“d,d-“d.d/“d0d1“d2d3“d4d5d6d7d8d9d:d;dd“d?d“d@d “dAd “dBd “dCd “dDd “dEd“dFdG“dHdI“dJdK“dLdM“dNdO“dPdQ“dRdS“dTdU“dVdW“idXdY“dZd[“d\d]“d^d_“d`da“dbdc“ddde“dfdg“dhdi“djdk“dldm“dndo“dpdq“drds“dtdu“dvdw“dxdy“¥Zddzd{d|d}œZidd?“dd?“dd?“dd?“dd?“dd?“d d?“d"d?“d$d?“d&dD“d(dD“d*d?“d,df“d.d?“d0d?“d2d?“d~d?“d?d?d?dFdhd?d?dxdœ¥Zd€dd‚dƒd„œZdddd…œZz€ejd†krSdd‡lmZdˆeƒd‰ZnSejdŠkr…dd‹lmZdd‡lmZeƒddŒkrpdZn6eƒddŽkr{dZn+e d !eƒeƒ¡ƒ‚ejd‘kr¢dd‡lmZeƒd’vršd“Zn dˆeƒd”Zne d•ƒ‚ddl"Z"ej# $e"j%¡Z&ej# 'e&e¡Z(e )e(¡Z*Wnue e+e,fy3ze d–ƒZ-e-dur×e d—ƒ‚e )e-¡Z*WnSe y0ejd†krîd˜Z.nejdŠkr÷d™Z.n ejd‘krdšZ.n‚dd‡lmZejd†kr)eƒd›kr)ej# /dœ¡rdœndZ0e )ej# 'e0e.¡¡Z*ne )e.¡Z*YnwYnwe 1e* 2¡¡ 3dždŸ¡Z4e4 5d ¡rMe4e6d ƒd…Z4 £  ¤dÔd¥d¦„Z7  dÕd§d¨„Z8    ¤dÖd©dª„Z9Gd«d¬„d¬e:ƒZ;d×d­d®„ZdÙd³d´„Z?dµd¶„Z@Gd·d¸„d¸e:ƒZAdÚdºd»„ZBd¼d½„ZCd¾d¿„ZDdÀdÁ„ZEdÂdÄZFdÄdÅ„ZGe*jHfdÆdÇ„ZIdÈdÉ„ZJdÊdË„ZKdÌdÍ„ZLGdÎdÏ„dÏeMƒZNGdÐdÑ„dÑeNeOƒZPGdÒdÓ„dÓePƒZQdS)Û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.13.1éN)ÚSEEK_SETÚSEEK_CURÚSEEK_END)Ú find_library)Úffiééééééééé é) ÚtitleÚ copyrightÚsoftwareÚartistÚcommentÚdateÚalbumÚlicenseÚ tracknumberÚgenreÚWAViÚAIFFiÚAUiÚRAWiÚPAFiÚSVXiÚNISTiÚVOCiÚIRCAMi ÚW64i ÚMAT4i ÚMAT5i ÚPVFiÚXIiÚHTKiÚSDSiÚAVRiiiiiii i!i"i#) ÚWAVEXÚSD2ÚFLACÚCAFÚWVEÚOGGÚMPC2KÚRF64ÚMP3ÚPCM_S8ÚPCM_16ÚPCM_24ÚPCM_32ÚPCM_U8ÚFLOATÚDOUBLEÚULAWÚALAWéÚ IMA_ADPCMéÚMS_ADPCMéÚGSM610é Ú VOX_ADPCMé!Ú NMS_ADPCM_16é"Ú NMS_ADPCM_24é#Ú NMS_ADPCM_32é$ÚG721_32é0ÚG723_24é1ÚG723_40é2ÚDWVW_12é@ÚDWVW_16éAÚDWVW_24éBÚDWVW_NéCÚDPCM_8éPÚDPCM_16éQÚVORBISé`ÚOPUSédÚALAC_16épÚALAC_20éqÚALAC_24érÚALAC_32ésÚ MPEG_LAYER_Ié€Ú MPEG_LAYER_IIéÚMPEG_LAYER_IIIé‚ii i0)ÚFILEÚLITTLEÚBIGÚCPUr,)r-r.r/r0r1r2r3r4ÚdoubleÚfloatÚintÚshort)Úfloat64Úfloat32Úint32Úint16)ÚCONSTANTÚAVERAGEÚVARIABLEÚdarwin)ÚmachineÚ libsndfile_z.dylibÚwin32)Ú architectureÚ64bitzlibsndfile_x64.dllÚ32bitzlibsndfile_x86.dllz%no packaged library for Windows {} {}Úlinux)Úaarch64Ú aarch64_beÚarmv8bÚarmv8lzlibsndfile_arm64.soz.soz%no packaged library for this platformÚsndfilez8sndfile library not found using ctypes.util.find_libraryzlibsndfile.dylibzlibsndfile.dllz libsndfile.soÚarm64z/opt/homebrew/lib/z/usr/local/lib/úutf-8Úreplacez libsndfile-éÿÿÿÿryFTc Cs`t|d|| | | | | ƒ}| |||¡}| |||||¡}Wdƒn1s&wY||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 ÚrN)Ú SoundFileÚ _prepare_readÚreadÚ samplerate)ÚfileÚframesÚstartÚstopÚdtypeÚ always_2dÚ fill_valueÚoutr•ÚchannelsÚformatÚsubtypeÚendianÚclosefdÚfÚdata©r¥úg/var/www/eduai.edurigo.com/doc_train/edurigo_ai/Puru/tts/venv/lib/python3.10/site-packages/soundfile.pyr”Ûs Vÿý r”c Csvddl} |  |¡}|jdkrd} n|jd} t|d|| ||||||ƒ } |  |¡WdƒdS1s4wYdS)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') rNrÚw)ÚnumpyÚasarrayÚndimÚshaper’Úwrite) r–r¤r•r r¡rŸr¢Úcompression_levelÚ bitrate_modeÚnpržr£r¥r¥r¦r¬8s-    þ "ýr¬c csnt|d| | | || |ƒ!}| |||¡}| ||||||| ¡D]}|VqWdƒdS1s0wYdS)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' r‘N)r’r“Úblocks)r–Ú blocksizeÚoverlapr—r˜r™ršr›rœrr•ržrŸr r¡r¢r£Úblockr¥r¥r¦r°qs€ 3ÿ ÿþ"ýr°c@s,eZdZdZdd„Zedd„ƒZdd„ZdS) Ú_SoundFileInfozInformation about a SoundFilecCsž||_t|ƒ>}|j|_|j|_|j|_|j|_t|jƒ|j|_|j|_|j |_ |j |_ |j |_ |j |_ |j |_ |j|_WdƒdS1sHwYdS©N)Úverboser’Únamer•ržr—rvÚdurationrŸr r¡Ú format_infoÚ subtype_infoÚsectionsÚ extra_info)Úselfr–r¶r£r¥r¥r¦Ú__init__¯s  "ôz_SoundFileInfo.__init__cCsvt|jdƒ\}}t|dƒ\}}|dkrd |||¡}|S|dkr(d ||¡}|S|dkr4d |j¡}|Sd |¡}|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)Údivmodr¸rŸr—)r½ÚhoursÚrestÚminutesÚsecondsr¸r¥r¥r¦Ú _duration_str¿sú ü  ÿz_SoundFileInfo._duration_strcCsDd gd¢¡}|jr|d gd¢¡7}d |j d¡¡}| ||¡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 )Újoinr¶r¼ÚsplitrŸ)r½ÚinfoÚindented_extra_infor¥r¥r¦Ú__repr__Ísÿÿ z_SoundFileInfo.__repr__N)Ú__name__Ú __module__Ú __qualname__Ú__doc__r¾ÚpropertyrÅrËr¥r¥r¥r¦r´¬s   r´cCs t||ƒS)zŸReturns an object with information about a `SoundFile`. Parameters ---------- verbose : bool Whether to print additional information. )r´)r–r¶r¥r¥r¦rÉàs rÉcCstttjtjƒƒS)a©Return 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Ú_sndÚSFC_GET_FORMAT_MAJOR_COUNTÚSFC_GET_FORMAT_MAJORr¥r¥r¥r¦Úavailable_formatsësÿrÖcs$ttjtjƒ}t‡fdd„|DƒƒS)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.|]\}}ˆdustˆ|ƒr||fVqdSrµ)Ú check_format)Ú.0r r·©rŸr¥r¦Ú s € ÿÿz%available_subtypes..)rÒrÓÚSFC_GET_FORMAT_SUBTYPE_COUNTÚSFC_GET_FORMAT_SUBTYPErÑ)rŸÚsubtypesr¥rÙr¦Úavailable_subtypessÿrÞc Cs,z tt|||ƒƒWSttfyYdSw)záCheck 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)rŸr r¡r¥r¥r¦r×s  ÿr×cCst|ƒt | ¡¡S)zÍReturn 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_subtypesÚgetÚupperrÙr¥r¥r¦Údefault_subtype)s rçc@s6eZdZdZ   dedd„Zedd„ƒZ ed d„ƒZ ed d„ƒZ ed d„ƒZ ed d„ƒZ ed d„ƒZ edd„ƒZ edd„ƒZ edd„ƒZ edd„ƒZ edd„ƒZ edd„ƒZ edd„ƒZ edd„ƒZ edd„ƒZ edd„ƒZdZdd„Zdd„Zdd„Zdd „Zd!d"„Zd#d$„Zd%d&„Zd'd(„Zd)d*„Zd+d,„Z e!fd-d.„Z"d/d0„Z# 3 dfd4d5„Z$dgd6d7„Z%d8d9„Z&d:d;„Z'd`__. 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 Ú __fspath__NÚmodezr+r)ÚhasattrrèÚ_nameÚgetattrÚ _check_modeÚ_modeÚ_compression_levelÚ _bitrate_modeÚ_create_info_structÚ_infoÚ_openÚ_fileÚsetÚ issupersetÚseekableÚseekrÓÚ sf_commandÚSFC_SET_CLIPPINGÚ_ffiÚNULLÚSF_TRUEÚ_set_compression_levelÚ_set_bitrate_mode) r½r–rér•ržr r¡rŸr¢r­r®Úmode_intr¥r¥r¦r¾As.g  ÿ ÿ   üzSoundFile.__init__cCó|jSrµ)rë©r½r¥r¥r¦ÚÀózSoundFile.cCrrµ)rîrr¥r¥r¦rÂrcCó|jjSrµ)ròr•rr¥r¥r¦rÄócCrrµ©ròr—rr¥r¥r¦rÆrcCrrµ)ròržrr¥r¥r¦rÈrcCót|jjtj@ƒSrµ)Ú _format_strròrŸrÓÚSF_FORMAT_TYPEMASKrr¥r¥r¦rËócCrrµ)r ròrŸrÓÚSF_FORMAT_SUBMASKrr¥r¥r¦rÎr cCrrµ)r ròrŸrÓÚSF_FORMAT_ENDMASKrr¥r¥r¦rÑr cCót|jjtj@ƒdS©Nr)Ú _format_inforòrŸrÓr rr¥r¥r¦rÔó ÿÿcCrr)rròrŸrÓr rr¥r¥r¦rØrcCrrµ)ròr»rr¥r¥r¦rÛrcCs |jduSrµ)rôrr¥r¥r¦rÝs cCs t |j¡Srµ)rÓÚsf_errorrôrr¥r¥r¦rßs cCrrµ)rïrr¥r¥r¦rárcCrrµ)rðrr¥r¥r¦rãrcCs8t dd¡}t |jtj|t |¡¡t |¡ dd¡S)z8Retrieve the log string generated when opening the file.zchar[]i@rŽr) rûÚnewrÓrùrôÚSFC_GET_LOG_INFOÚsizeofÚstringÚdecode)r½rÉr¥r¥r¦r¼æs   ÿzSoundFile.extra_infocCsD|jdur d |j¡nd}||jdurd |j¡nd7}d ||¡S)Nz, compression_level={0}Úz, bitrate_mode='{0}'zœSoundFile({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}{1}))r­rŸr®)r½Úcompression_settingr¥r¥r¦rËñs  ÿÿ  ÿÿýzSoundFile.__repr__cCó | ¡dSrµ©Úcloserr¥r¥r¦Ú__del__ûó zSoundFile.__del__cCs|Srµr¥rr¥r¥r¦Ú __enter__þszSoundFile.__enter__cGrrµr)r½Úargsr¥r¥r¦Ú__exit__rzSoundFile.__exit__cCsF|tvr| ¡t |jt|| ¡¡}t|ƒdSt |||¡dS)z:Write text meta-data in the sound file through properties.N) Ú _str_typesÚ_check_if_closedrÓÚ sf_set_stringrôÚencodeÚ _error_checkÚobjectÚ __setattr__)r½r·ÚvalueÚerrr¥r¥r¦r(sÿ zSoundFile.__setattr__cCsJ|tvr| ¡t |jt|¡}|rt |¡ dd¡SdStd  |¡ƒ‚)z9Read text meta-data in the sound file through properties.rŽrrz)'SoundFile' object has no attribute {0!r}) r"r#rÓÚ sf_get_stringrôrûrrÚAttributeErrorrŸ)r½r·r¤r¥r¥r¦Ú __getattr__sÿzSoundFile.__getattr__cCrrµrrr¥r¥r¦Ú__len__ózSoundFile.__len__cCsdS)NTr¥rr¥r¥r¦Ú__bool__szSoundFile.__bool__cCs| ¡Srµ)r0rr¥r¥r¦Ú __nonzero__"r/zSoundFile.__nonzero__cCs|jjtjkS)z)Return True if the file supports seeking.)ròr÷rÓrýrr¥r¥r¦r÷'szSoundFile.seekablecCs&| ¡t |j||¡}t|jƒ|S)aÜSet 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#rÓÚsf_seekrôr&Ú _errorcode)r½r—ÚwhenceÚpositionr¥r¥r¦rø+s$ zSoundFile.seekcCs | dt¡S)z'Return the current read/write position.r)rørrr¥r¥r¦ÚtellTs zSoundFile.tellrryFcCs‚|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 Nrr”)Ú _check_framesÚ_create_empty_arrayÚlenÚ _array_io)r½r—ršr›rœrr¥r¥r¦r”XsP    ÿzSoundFile.readcCsT|j|dd}| |¡}t |d||j¡}| d|||¡}||ks%J‚t |¡S)a‘Read 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)rœz[]r”)r7Ú _check_dtyperûrržÚ _cdata_ioÚbuffer)r½r—ršÚctypeÚcdataÚ read_framesr¥r¥r¦Ú buffer_read¶s    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 r”)r;Ú _check_bufferr<)r½r=ršr>r?r—r¥r¥r¦Úbuffer_read_intoÙs zSoundFile.buffer_read_intocCsBddl}| |¡}| d|t|ƒ¡}|t|ƒksJ‚| |¡dS)aøWrite 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¨Úascontiguousarrayr:r9Ú_update_frames)r½r¤r¯Úwrittenr¥r¥r¦r¬ús . zSoundFile.writecCsD| |¡}| ||¡\}}| d|||¡}||ksJ‚| |¡dS)a€Write 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 r¬N)r;rBr<rE)r½r¤ršr>r?r—rFr¥r¥r¦Ú buffer_write0s  zSoundFile.buffer_writerc cstddl}d|jvrd|jvrtdƒ‚| ||¡}|dur:|dur%tdƒ‚|dur+|nt||ƒ} | | ||¡}d} n|durBtdƒ‚t|ƒ}d } d} |dkr¸| durUd} n t| ƒ} | |d| …<t|| |ƒ} | | ||||| d…¡|r| dur„|  || d…¡} n || d…| dd…<|||kr¢|dur¢|d||…}n|}| r«|  |¡n|V|| 8}|dksNdSdS) aÆReturn 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) r¨réÚSoundFileRuntimeErrorr7râÚminr8r9r”Úcopy)r½r±r²r—ršr›rœrr¯Úout_sizeÚcopy_outÚoverlap_memoryÚ output_offsetÚtoreadr³r¥r¥r¦r°KsF€2 ÿ ëzSoundFile.blockscCsX|dur| ¡}t |jtjt d|¡t d¡¡}|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*Ú sf_count_tzError truncating the file) r6rÓrùrôÚSFC_FILE_TRUNCATErûrrrÚLibsndfileErrorròr—)r½r—r*r¥r¥r¦Útruncate¨s   þ   zSoundFile.truncatecCs| ¡t |j¡dS)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_syncrôrr¥r¥r¦ÚflushÀs zSoundFile.flushcCs0|js| ¡t |j¡}d|_t|ƒdSdS)z.Close the file. Can be called multiple times.N)ÚclosedrVrÓÚsf_closerôr&)r½r*r¥r¥r¦rÎs   ûzSoundFile.closecCs0t|ttfƒrOtj |¡r/d|jvrtd |j ¡ƒ‚t |jƒ  d¡r/t  t  |tjtjB¡¡tj}t|tƒrGtjdkr@tj}n| t ¡¡}||||jƒ}n*t|tƒr^t |||j|¡}nt||ƒrqt | |¡||jtj¡}ntd |j ¡ƒ‚|tjkrt  |¡}t!|d |j ¡d‚|tj"kr–d|j_#|S) z9Call the appropriate sf_open*() function from libsndfile.ÚxzFile exists: {0!r}zw+rƒzInvalid file: {0!r}zError opening {0!r}: ©Úprefixr)$Ú isinstanceÚ_unicodeÚbytesÚ_osÚpathÚisfileréÚOSErrorrŸr·rõrörÚopenÚO_WRONLYÚO_TRUNCrÓÚsf_openÚ_sysÚplatformÚ sf_wchar_openr%ÚgetfilesystemencodingròrwÚ sf_open_fdÚ_has_virtual_io_attrsÚsf_open_virtualÚ_init_virtual_iorûrürârrSÚ SFM_WRITEr—)r½r–rr¢Ú openfunctionÚfile_ptrr*r¥r¥r¦ró×s2        ÿ   zSoundFile._opencsŽt d¡‡fdd„ƒ}t d¡‡fdd„ƒ}t d¡‡fdd „ƒ}t d ¡‡fd d „ƒ}t d ¡‡fdd„ƒ}|||||dœ|_t d|j¡S)z4Initialize callback functions for sf_open_virtual().Úsf_vio_get_filelencs,ˆ ¡}ˆ dt¡ˆ ¡}ˆ |t¡|S©Nr)r6rørr)Ú user_dataÚcurrÚsize©r–r¥r¦Úvio_get_filelenýs   z3SoundFile._init_virtual_io..vio_get_filelenÚ sf_vio_seekcsˆ ||¡ˆ ¡Srµ)rør6)Úoffsetr4rtrwr¥r¦Úvio_seeks z,SoundFile._init_virtual_io..vio_seekÚ sf_vio_readcs\zt ||¡}ˆ |¡}W|Sty-ˆ |¡}t|ƒ}t ||¡}||d|…<Y|Swrs)rûr=Úreadintor,r”r9)ÚptrÚcountrtÚbufÚ data_readr¤rwr¥r¦Úvio_read s   û  ûz,SoundFile._init_virtual_io..vio_readÚ sf_vio_writecs2t ||¡}|dd…}ˆ |¡}|dur|}|Srµ)rûr=r¬)r~rrtr€r¤rFrwr¥r¦Ú vio_writes   z-SoundFile._init_virtual_io..vio_writeÚ sf_vio_tellcsˆ ¡Srµ)r6)rtrwr¥r¦Úvio_tell!sz,SoundFile._init_virtual_io..vio_tell)Ú get_filelenrør”r¬r6zSF_VIRTUAL_IO*)rûÚcallbackÚ _virtual_ior)r½r–rxr{r‚r„r†r¥rwr¦rnûs"  üzSoundFile._init_virtual_iocCstS)z€Return all attributes used in __setattr__ and __getattr__. This is useful for auto-completion (e.g. IPython). )r"rr¥r¥r¦Ú_getAttributeNames.szSoundFile._getAttributeNamescCs|jrtdƒ‚dS)z…Check 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)rWrIrr¥r¥r¦r#6sÿzSoundFile._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)r÷r—r6rá)r½r—rœÚremaining_framesr¥r¥r¦r7?sþzSoundFile._check_framescCsV|t ¡vsJ‚t|tƒst |¡}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) Ú _ffi_typesÚvaluesr\r^rûÚ from_bufferrÀr9ržrrá)r½r¤r>r—Ú remainderr¥r¥r¦rBJs  ÿzSoundFile._check_buffercCs8ddl}|s |jdkr||jf}n|f}|j||ddS)z-Create an empty array with appropriate shape.rNrÚC)Úorder)r¨ržÚempty)r½r—r›ršr¯r«r¥r¥r¦r8Us  zSoundFile._create_empty_arrayc Cs2zt|WStytd tt ¡ƒ|¡ƒ‚w)z7Check if dtype string is valid and return ctype string.z(dtype must be one of {0!r} and not {1!r})rŒÚKeyErrorrárŸÚsortedÚkeys)r½ršr¥r¥r¦r;^s   ÿÿzSoundFile._check_dtypecCsÄ|jdvrtd |j|jdkrd¡ƒ‚d¡ƒ‚|jdkrdn|jd}||jkr3td |j|j|¡ƒ‚|jjs;tdƒ‚| |jj ¡}|jj t   |¡ksMJ‚t   |d|jd d ¡}| ||||¡S) z+Check array and call low-level IO function.)rrzInvalid shape: {0!r} ({1})rz0 dimensions not supportedztoo many dimensionsz5Invalid shape: {0!r} (Expected {1} channels, got {2})zData must be C-contiguousÚ*r¤r)rªrárŸr«ržÚflagsÚ c_contiguousr;ršr·ÚitemsizerûrÚcastÚ__array_interface__r<)r½ÚactionÚarrayr—Úarray_channelsr>r?r¥r¥r¦r:fs $ zSoundFile._array_iocCsr|t ¡vsJ‚| ¡| ¡r| ¡}ttd|d|ƒ}||j||ƒ}t|j ƒ| ¡r7|  ||t ¡|S)z.Call one of libsndfile's read/write functions.Úsf_Úf_) rŒrr#r÷r6rìrÓrôr&r3rør)r½rœr¤r>r—ruÚfuncr¥r¥r¦r<ts zSoundFile._cdata_iocCsD| ¡r| ¡}| dt¡|j_| |t¡dS|jj|7_dS)z!Update self.frames after writing.rN)r÷r6rørròr—r)r½rFrur¥r¥r¦rEs zSoundFile._update_framescCs||dkr | ¡s tdƒ‚|dkr|durtdƒ‚t||ƒ |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)r÷rárâÚsliceÚindicesr—rør)r½r˜r™r—Ú_r¥r¥r¦r“Šs zSoundFile._prepare_readcCsBi}t ¡D]\}}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Žr)r"ÚitemsrÓr+rôrûrr)r½ÚstrsÚstrtypeÚstridr¤r¥r¥r¦Ú copy_metadatašs €zSoundFile.copy_metadatacCsf|tvsJ‚t d¡}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) Ú_bitrate_modesrûrrÓrùrôÚSFC_SET_BITRATE_MODErrýrrS)r½r®Úpointer_bitrate_moder*r¥r¥r¦rÿ¬s     þzSoundFile._set_bitrate_modecCszd|kr dkstdƒ‚tdƒ‚t d¡}||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) rárûrrÓrùrôÚSFC_SET_COMPRESSION_LEVELrrýrrS)r½r­Úpointer_compression_levelr*r¥r¥r¦rþ¸sÿ   þz SoundFile._set_compression_level) r‘NNNNNTNN)rryFNN)rN)NrrryFNNrµ)t d |¡ƒ‚w|durFd}nt|ttfƒsTtd |¡ƒ‚z |t | ¡O}Wnt ylt d |¡ƒ‚wt   d¡}||_d |_t |¡tjkr„t 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)rãrçrârŸr\r]ÚstrÚ _subtypesrær“ráÚ_endiansrûrržrÓÚsf_format_checkÚSF_FALSE)rŸr r¡ÚresultrÉr¥r¥r¦ràËs@ÿÿ ÿ ÿ ÿràcCs”t|ttfƒstd |¡ƒ‚t|ƒ}| d¡st|ƒt|ƒkr&td |¡ƒ‚t|  d¡ƒdkr3tdƒ‚d|vr.z\Not allowed for existing files (except 'RAW'): samplerate, channels, format, subtype, endian)Ú_get_format_from_filenamer\r]r°rãrûrrærâr•ržràrŸÚany) r–rér•ržrŸr r¡Úoriginal_formatrÉr¥r¥r¦rñþs(  ü  ÿrñcCsrd}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). rr·rrNrŽrr‘zGNo format specified and unable to get format from file extension: {0!r}) rìr_r`ÚsplitextrÚ ExceptionræÚ_formatsrârŸ)r–rérŸr¥r¥r¦r½s  ÿÿr½cCs:tttfD]}| ¡D]\}}||kr|Sq qdS)z;Return the string representation of a given numeric format.zn/a)rÂr±r²r¥)Ú format_intÚ dictionaryÚkÚvr¥r¥r¦r 1s ÿÿr cCsTt d¡}||_t tj||t d¡¡|j}t|jƒ|r't  |¡  dd¡fSdfS)z6Return the ID and short description of a given format.zSF_FORMAT_INFO*ÚSF_FORMAT_INFOrŽrr) rûrrŸrÓrùrürr·r rr)rÃÚ format_flagr¹r·r¥r¥r¦r;s  ÿÿÿrccsFt d¡}t tj||t d¡¡t|dƒD]}t||ƒVqdS)z8Helper for available_formats() and available_subtypes().zint*rwrN)rûrrÓrùrürÚranger)Ú count_flagrÈrrÃr¥r¥r¦rÒFs € ÿrÒcCsLt|ttfƒstd |¡ƒ‚z t| ¡}W|Sty%td |¡ƒ‚w)z4Check if `format_str` is valid and return format ID.zInvalid format: {0!r}zUnknown format: {0!r}) r\r]r°rârŸrÂrær“rá)Ú format_strrÃr¥r¥r¦rãNs þÿrãcCsN|tjk}|tjk}tt|dƒt|dƒt|dƒp|t|dƒp$t|dƒp$|gƒS)z>Check if file has all the necessary attributes for virtual IO.rør6r¬r”r})rÓrºroÚallrê)r–rÚreadonlyÚ writeonlyr¥r¥r¦rlYs   ürlc@óeZdZdZdS)ÚSoundFileErrorz-Base class for all soundfile-specific errors.N©rÌrÍrÎrÏr¥r¥r¥r¦rÐesrÐc@rÏ)rIzKsoundfile module runtime error. Errors that used to be `RuntimeError`.NrÑr¥r¥r¥r¦rIisrIc@s.eZdZdZd dd„Zedd„ƒZdd„Zd S) rSzjlibsndfile errors. Attributes ---------- code libsndfile internal error number. rcCst |||¡||_||_dSrµ)rIr¾Úcoder[)r½rÒr[r¥r¥r¦r¾xs zLibsndfileError.__init__cCs(|jrt |j¡}t |¡ dd¡SdS)zRaw libsndfile error message.rŽrz'(Garbled error message from libsndfile))rÒrÓÚsf_error_numberrûrr)r½Úerr_strr¥r¥r¦Ú error_string}s zLibsndfileError.error_stringcCs |j|jSrµ)r[rÕrr¥r¥r¦Ú__str__‰rzLibsndfileError.__str__N©r)rÌrÍrÎrÏr¾rÐrÕrÖr¥r¥r¥r¦rSos    rS) rrNryFNNNNNNNT)NNNTNN)NrrrNryFNNNNNNNT)Frµ)NNr×)RrÏÚ __version__Úosr_ÚsysrgrrrÚ ctypes.utilrÚ _find_libraryÚ _soundfilerrûÚunicoder]Ú NameErrorr°r"rÂr±r²rärŒrªrhrÚ_machineÚ_packaged_libnamer„Ú _architecturerbrŸÚ_soundfile_datar`ÚdirnameÚ__file__Ú_pathrÇÚ _full_pathÚdlopenrÓÚ ImportErrorrâÚ_libnameÚ_explicit_libnameÚisdirÚ _hbrew_pathrÚsf_version_stringrÚ__libsndfile_version__Ú startswithr9r”r¬r°r'r´rÉrÖrÞr×rçr’r&ràrírñr½r ÚSFC_GET_FORMAT_INFOrrÒrãrlrÁrÐÚ RuntimeErrorrIrSr¥r¥r¥r¦Ús<    ÿö ÿþýüûúùø ÷ ö õ ô óòñðïæÿþýüûúùø ÷ ö õ ô óòñðïîíìëêéèçæåäãâá à!ß"Þ&üÿþýûúùø ÷ ö õ ô óòñðïîæüý      ÿ        ÿ €í€ù  þ] ÿ9 ý; 4