Batch Forum Index
RegisterSearchFAQMemberlistUsergroupsLog in
Reply to topic Page 2 of 2
Goto page: <  1, 2
[R] Création de son sur mesure avec Python
Author Message
Reply with quote
Post [R] Création de son sur mesure avec Python 
Previous post review:

Corrigé Okay
Les chemins Windows sont de ce syle : path\vers\fichier
Tandis que pour Mac, ils sont comme ça : path/vers/fichier

j'ai update les codes, je remet ici :

Code:
[lang=python][scroll]# Windows
def _playwaveWin(Frequency = 440, Amplitude = 0.5, Duration = 1, Block = True, SampleRate = 44100):
    import math, struct, tempfile, random, os, threading, time, sys, ctypes
    data = []
    for i in range(int(SampleRate*Duration)):
        data.append(int(Amplitude * 32767 * math.sin(2 * i/int(SampleRate*Duration)*Duration * math.pi * Frequency)))
    binary = b''
    for i in range(len(data)):
        binary+=data[i].to_bytes(2, 'little', signed=True)
    stream = tempfile.gettempdir()+'\\'+str(random.random())+'.wav'
    WAVE_FORMAT_PCM = 0x0001
    NumChannels = 1
    bit_depth = 16
    bytes_per_second = SampleRate * (bit_depth // 8) * NumChannels
    block_align = NumChannels * (bit_depth // 8)
    header_data = b''
    header_data += b'RIFF'
    header_data += b'\x00\x00\x00\x00'
    header_data += b'WAVE'
    header_data += b'fmt '
    fmt_chunk_data = struct.pack(
        '<HHIIHH',
        WAVE_FORMAT_PCM,
        NumChannels,
        SampleRate,
        bytes_per_second,
        block_align,
        bit_depth
    )
    header_data += struct.pack('<I', len(fmt_chunk_data))
    header_data += fmt_chunk_data
    wave = open(stream, "wb")
    wave.write(header_data)
    wave.write(b'data')
    wave.write(struct.pack('<I', len(binary)*8))
    wave.write(bytes(bytearray(binary)))
    size = wave.tell()
    wave.seek(4)
    wave.write(struct.pack('<I', size-8))
    wave.seek(0)
    wave.close()
    def play(d,a,s):
        def winCommand(command):
            buf = ctypes.c_buffer(255)
            ctypes.windll.winmm.mciSendStringA(command.encode(sys.getfilesystemencoding()), buf, 254, 0)
        DurationMs = d*1000
        winCommand(f'open "{s}" alias {a}')
        winCommand(f'set {a} time format milliseconds')
        winCommand(f'play {a} from 0 to {DurationMs}')
        time.sleep(d)
        winCommand(f'close {a}')
        time.sleep(1)
        if os.path.exists(s):
            os.remove(s)
    threading.Thread(target=play,args=[Duration,'playsound_' + str(random.random()),stream]).start()
    if Block:
        time.sleep(Duration)





# MacOS
def _playwaveOSX(Frequency = 440, Amplitude = 0.5, Duration = 1, Block = True, SampleRate = 44100):
    from AppKit     import NSSound
    from Foundation import NSURL
    import math, struct, tempfile, random, os, threading, time, sys, ctypes
    data = []
    for i in range(int(SampleRate*Duration)):
        data.append(int(Amplitude * 32767 * math.sin(2 * i/int(SampleRate*Duration)*Duration * math.pi * Frequency)))
    binary = b''
    for i in range(len(data)):
        binary+=data[i].to_bytes(2, 'little', signed=True)
    stream = tempfile.gettempdir()+'/'+str(random.random())+'.wav'
    WAVE_FORMAT_PCM = 0x0001
    NumChannels = 1
    bit_depth = 16
    bytes_per_second = SampleRate * (bit_depth // 8) * NumChannels
    block_align = NumChannels * (bit_depth // 8)
    header_data = b''
    header_data += b'RIFF'
    header_data += b'\x00\x00\x00\x00'
    header_data += b'WAVE'
    header_data += b'fmt '
    fmt_chunk_data = struct.pack(
        '<HHIIHH',
        WAVE_FORMAT_PCM,
        NumChannels,
        SampleRate,
        bytes_per_second,
        block_align,
        bit_depth
    )
    header_data += struct.pack('<I', len(fmt_chunk_data))
    header_data += fmt_chunk_data
    wave = open(stream, "wb")
    wave.write(header_data)
    wave.write(b'data')
    wave.write(struct.pack('<I', len(binary)*8))
    wave.write(bytes(bytearray(binary)))
    size = wave.tell()
    wave.seek(4)
    wave.write(struct.pack('<I', size-8))
    wave.seek(0)
    wave.close()
    def play(d,a,s):
        if '://' not in s:
            if not s.startswith('/'):
                from os import getcwd
                s = getcwd() + '/' + s
            s = 'file://' + s
        url   = NSURL.URLWithString_(s)
        nssound = NSSound.alloc().initWithContentsOfURL_byReference_(url, True)
        if not nssound:
            raise IOError('Unable to load sound named: ' + s)
        nssound.play()
        time.sleep(d)
        time.sleep(1)
        if os.path.exists(s):
            os.remove(s)
    threading.Thread(target=play,args=[Duration,'playsound_' + str(random.random()),stream]).start()
    if Block:
        time.sleep(Duration)






# Unix
def _playwaveNix(Frequency = 440, Amplitude = 0.5, Duration = 1, Block = True, SampleRate = 44100):
    if not Block:
        raise NotImplementedError("block=False cannot be used on this platform yet")
    import math, struct, tempfile, random, os, threading, time, sys, ctypes
    data = []
    for i in range(int(SampleRate*Duration)):
        data.append(int(Amplitude * 32767 * math.sin(2 * i/int(SampleRate*Duration)*Duration * math.pi * Frequency)))
    binary = b''
    for i in range(len(data)):
        binary+=data[i].to_bytes(2, 'little', signed=True)
    stream = tempfile.gettempdir()+'/'+str(random.random())+'.wav'
    WAVE_FORMAT_PCM = 0x0001
    NumChannels = 1
    bit_depth = 16
    bytes_per_second = SampleRate * (bit_depth // 8) * NumChannels
    block_align = NumChannels * (bit_depth // 8)
    header_data = b''
    header_data += b'RIFF'
    header_data += b'\x00\x00\x00\x00'
    header_data += b'WAVE'
    header_data += b'fmt '
    fmt_chunk_data = struct.pack(
        '<HHIIHH',
        WAVE_FORMAT_PCM,
        NumChannels,
        SampleRate,
        bytes_per_second,
        block_align,
        bit_depth
    )
    header_data += struct.pack('<I', len(fmt_chunk_data))
    header_data += fmt_chunk_data
    wave = open(stream, "wb")
    wave.write(header_data)
    wave.write(b'data')
    wave.write(struct.pack('<I', len(binary)*8))
    wave.write(bytes(bytearray(binary)))
    size = wave.tell()
    wave.seek(4)
    wave.write(struct.pack('<I', size-8))
    wave.seek(0)
    wave.close()
    try:
        from urllib.request import pathname2url
    except ImportError:
        # python 2
        from urllib import pathname2url
    import gi
    gi.require_version('Gst', '1.0')
    from gi.repository import Gst
    Gst.init(None)
    playbin = Gst.ElementFactory.make('playbin', 'playbin')
    if wave.startswith(('http://', 'https://')):
        playbin.props.uri = stream
    else:
        playbin.props.uri = 'file://' + pathname2url(os.path.abspath(wave))
    set_result = playbin.set_state(Gst.State.PLAYING)
    if set_result != Gst.StateChangeReturn.ASYNC:
        raise "playbin.set_state returned " + repr(set_result)
    bus = playbin.get_bus()
    bus.poll(Gst.MessageType.EOS, Gst.CLOCK_TIME_NONE)
    playbin.set_state(Gst.State.NULL)







# On sélectionne la bonne fonction suivant l'OS
from platform import system
system = system()
if system == 'Windows':
    PlayWave = _playwaveWin
elif system == 'Darwin':
    PlayWave = _playwaveOSX
else:
    PlayWave = _playwaveNix
del system




# TADAAAAAM
PlayWave()


batch.bat wrote:
et c'est quoi un thread Embarassed

Le processeur lit le programme ligne par ligne, et ça, c'est un thread. Donc, si tu lance un thread, le processeur va lire le thread principale (celui qui a lancé le second thread) et en même temps va lire ligne par ligne le code du second thread. Ce qui permet d'exécuter des fonctions en-même temps ce qui n'est pas possible avec "une seule tête de lecture".
Pourquoi avoir fait ça ? Bah..tu joue ton fichier audio mais le problème c'est le code python ne continuera pas tant que le son n'aura fini de jouer (en gros, si tu créé pas un second thread, tu peux pas jouer 2 sons en même temps)

batch.bat wrote:
j'ai pas trop comprit le principe d'utiliser une variable sans qu'elle y soit etc

Bah...justement c'était ça l'erreur Okay


(j'espère que c'est la dernière erreur mdr)

Visit poster’s website
Post Publicité 
PublicitéSupprimer les publicités ?


Reply with quote
Post [R] Création de son sur mesure avec Python 
merci par contre ce n'était pas dernière erreur mdrtu as modifier les "s" en "a" dans la fonction play() , du coup j'ai remodifier et c'est reglé mais corrige ton code ^^

et merci pour les threads j'avais jamais entendu parler ça a l'air pratique ^^

en tout cas merci de ton temps Okay

et voilà le code et j'ai un peu remanié au niveau des arguments :

Code:
[lang=python][scroll]
# Windows
import math, struct, tempfile, random, os, threading, time, sys, ctypes, random as rdm   
S=[]

def _playwaveWin(Frequency = 110,L = [2,0.5,True,44100]):
    global S
    S+=[Frequency]
    print(Frequency)
    Duration,Amplitude,Block,SampleRate = L[0],L[1],L[2],L[3]
    # Duration = 1, Amplitude = 0.5, Block = True, SampleRate = 44100
    import math, struct, tempfile, random, random as rdm, os, threading, time, sys, ctypes
    data = []
    for i in range(int(SampleRate*Duration)):
        data.append(int(Amplitude * 32767 * math.sin(2 * i/int(SampleRate*Duration)*Duration * math.pi * Frequency)))
    binary = b''
    for i in range(len(data)):
        binary+=data[i].to_bytes(2, 'little', signed=True)
    namm=random.random()
    stream = tempfile.gettempdir()+'\\'+str(namm)+'.wav'
    WAVE_FORMAT_PCM = 0x0001
    NumChannels = 1
    bit_depth = 16
    bytes_per_second = SampleRate * (bit_depth // 8) * NumChannels
    block_align = NumChannels * (bit_depth // 8)
    header_data = b''
    header_data += b'RIFF'
    header_data += b'\x00\x00\x00\x00'
    header_data += b'WAVE'
    header_data += b'fmt '
    fmt_chunk_data = struct.pack(
        '<HHIIHH',
        WAVE_FORMAT_PCM,
        NumChannels,
        SampleRate,
        bytes_per_second,
        block_align,
        bit_depth
    )
    header_data += struct.pack('<I', len(fmt_chunk_data))
    header_data += fmt_chunk_data
    wave = open(stream, "wb")
    wave.write(header_data)
    wave.write(b'data')
    wave.write(struct.pack('<I', len(binary)*8))
    wave.write(bytes(bytearray(binary)))
    size = wave.tell()
    wave.seek(4)
    wave.write(struct.pack('<I', size-8))
    wave.seek(0)
    wave.close()
    def play(d,a,s):
        def winCommand(command):
            buf = ctypes.c_buffer(255)
            ctypes.windll.winmm.mciSendStringA(command.encode(sys.getfilesystemencoding()), buf, 254, 0)
        DurationMs = d*1000
        winCommand(f'open "{s}" alias {a}')
        winCommand(f'set {a} time format milliseconds')
        winCommand(f'play {a} from 0 to {DurationMs}')
        time.sleep(d)
        winCommand(f'close {a}')
        time.sleep(1)
        if os.path.exists(s):
            os.remove(s)
    threading.Thread(target=play,args=[Duration,'playsound_' + str(random.random()),stream]).start()
    if Block:
        time.sleep(1)





# MacOS
def _playwaveOSX(Frequency = 110,L = [2,0.5,True,44100]):
    global S
    S+=[Frequency]
    print(Frequency)
    # Duration = 1, Amplitude = 0.5, Block = True, SampleRate = 44100
    Duration,Amplitude,Block,SampleRate = L[0],L[1],L[2],L[3]
    from AppKit     import NSSound
    from Foundation import NSURL
    import math, struct, tempfile, random, os, threading, time, sys, ctypes
    data = []
    for i in range(int(SampleRate*Duration)):
        data.append(int(Amplitude * 32767 * math.sin(2 * i/int(SampleRate*Duration)*Duration * math.pi * Frequency)))
    binary = b''
    for i in range(len(data)):
        binary+=data[i].to_bytes(2, 'little', signed=True)
    stream = tempfile.gettempdir()+'/'+str(random.random())+'.wav'
    WAVE_FORMAT_PCM = 0x0001
    NumChannels = 1
    bit_depth = 16
    bytes_per_second = SampleRate * (bit_depth // 8) * NumChannels
    block_align = NumChannels * (bit_depth // 8)
    header_data = b''
    header_data += b'RIFF'
    header_data += b'\x00\x00\x00\x00'
    header_data += b'WAVE'
    header_data += b'fmt '
    fmt_chunk_data = struct.pack(
        '<HHIIHH',
        WAVE_FORMAT_PCM,
        NumChannels,
        SampleRate,
        bytes_per_second,
        block_align,
        bit_depth
    )
    header_data += struct.pack('<I', len(fmt_chunk_data))
    header_data += fmt_chunk_data
    wave = open(stream, "wb")
    wave.write(header_data)
    wave.write(b'data')
    wave.write(struct.pack('<I', len(binary)*8))
    wave.write(bytes(bytearray(binary)))
    size = wave.tell()
    wave.seek(4)
    wave.write(struct.pack('<I', size-8))
    wave.seek(0)
    wave.close()
    def play(d,a,s):
        if '://' not in s:
            if not s.startswith('/'):
                from os import getcwd
                s = getcwd() + '/' + s
            s = 'file://' + s
        url   = NSURL.URLWithString_(s)
        nssound = NSSound.alloc().initWithContentsOfURL_byReference_(url, True)
        if not nssound:
            raise IOError('Unable to load sound named: ' + s)
        nssound.play()
        time.sleep(d)
        time.sleep(1)
        if os.path.exists(s):
            os.remove(s)
    threading.Thread(target=play,args=[Duration,'playsound_' + str(random.random()),stream]).start()
    if Block:
        time.sleep(1)






# Unix
def _playwaveNix(Frequency = 110,L = [2,0.5,True,44100]):
    global S
    S+=[Frequency]
    print(Frequency)
    # Duration = 1, Amplitude = 0.5, Block = True, SampleRate = 44100
    Duration,Amplitude,Block,SampleRate = L[0],L[1],L[2],L[3]
   
    if not Block:
        raise NotImplementedError("block=False cannot be used on this platform yet")
    import math, struct, tempfile, random, os, threading, time, sys, ctypes
    data = []
    for i in range(int(SampleRate*Duration)):
        data.append(int(Amplitude * 32767 * math.sin(2 * i/int(SampleRate*Duration)*Duration * math.pi * Frequency)))
    binary = b''
    for i in range(len(data)):
        binary+=data[i].to_bytes(2, 'little', signed=True)
    stream = tempfile.gettempdir()+'/'+str(random.random())+'.wav'
    WAVE_FORMAT_PCM = 0x0001
    NumChannels = 1
    bit_depth = 16
    bytes_per_second = SampleRate * (bit_depth // 8) * NumChannels
    block_align = NumChannels * (bit_depth // 8)
    header_data = b''
    header_data += b'RIFF'
    header_data += b'\x00\x00\x00\x00'
    header_data += b'WAVE'
    header_data += b'fmt '
    fmt_chunk_data = struct.pack(
        '<HHIIHH',
        WAVE_FORMAT_PCM,
        NumChannels,
        SampleRate,
        bytes_per_second,
        block_align,
        bit_depth
    )
    header_data += struct.pack('<I', len(fmt_chunk_data))
    header_data += fmt_chunk_data
    wave = open(stream, "wb")
    wave.write(header_data)
    wave.write(b'data')
    wave.write(struct.pack('<I', len(binary)*8))
    wave.write(bytes(bytearray(binary)))
    size = wave.tell()
    wave.seek(4)
    wave.write(struct.pack('<I', size-8))
    wave.seek(0)
    wave.close()
    try:
        from urllib.request import pathname2url
    except ImportError:
        # python 2
        from urllib import pathname2url
    import gi
    gi.require_version('Gst', '1.0')
    from gi.repository import Gst
    Gst.init(None)
    playbin = Gst.ElementFactory.make('playbin', 'playbin')
    if wave.startswith(('http://', 'https://')):
        playbin.props.uri = stream
    else:
        playbin.props.uri = 'file://' + pathname2url(os.path.abspath(wave))
    set_result = playbin.set_state(Gst.State.PLAYING)
    if set_result != Gst.StateChangeReturn.ASYNC:
        raise "playbin.set_state returned " + repr(set_result)
    bus = playbin.get_bus()
    bus.poll(Gst.MessageType.EOS, Gst.CLOCK_TIME_NONE)
    playbin.set_state(Gst.State.NULL)







# On sélectionne la bonne fonction suivant l'OS
from platform import system
system = system()
if system == 'Windows':
    PlayWave = _playwaveWin
elif system == 'Darwin':
    PlayWave = _playwaveOSX
else:
    PlayWave = _playwaveNix
del system




# TADAAAAAM
PlayWave()
[/scroll]



Last edited by batch.bat on Wed 29 Apr 2020 - 21:17; edited 3 times in total

______________________________________________________
baaaatch c'est moi !!!
Skype
Reply with quote
Post [R] Création de son sur mesure avec Python 
du coup voilà ton code corrigé et j'ai modifié quelques trucs pour que ce soit moins lourd

Code:
[lang=python][scroll]# Windows
import math, struct, tempfile, random, os, threading, time, sys, ctypes, random as rdm   
S=[]

def _playwaveWin(Frequency = 110,L = [2,0.5,True,44100]):
    global S
    S+=[Frequency]
    print(Frequency)
    Duration,Amplitude,Block,SampleRate = L[0],L[1],L[2],L[3]
    # Duration = 1, Amplitude = 0.5, Block = True, SampleRate = 44100
    import math, struct, tempfile, random, random as rdm, os, threading, time, sys, ctypes
    data = []
    for i in range(int(SampleRate*Duration)):
        data.append(int(Amplitude * 32767 * math.sin(2 * i/int(SampleRate*Duration)*Duration * math.pi * Frequency)))
    binary = b''
    for i in range(len(data)):
        binary+=data[i].to_bytes(2, 'little', signed=True)
    namm=random.random()
    stream = tempfile.gettempdir()+'\\'+str(namm)+'.wav'
    WAVE_FORMAT_PCM = 0x0001
    NumChannels = 1
    bit_depth = 16
    bytes_per_second = SampleRate * (bit_depth // 8) * NumChannels
    block_align = NumChannels * (bit_depth // 8)
    header_data = b''
    header_data += b'RIFF'
    header_data += b'\x00\x00\x00\x00'
    header_data += b'WAVE'
    header_data += b'fmt '
    fmt_chunk_data = struct.pack(
        '<HHIIHH',
        WAVE_FORMAT_PCM,
        NumChannels,
        SampleRate,
        bytes_per_second,
        block_align,
        bit_depth
    )
    header_data += struct.pack('<I', len(fmt_chunk_data))
    header_data += fmt_chunk_data
    wave = open(stream, "wb")
    wave.write(header_data)
    wave.write(b'data')
    wave.write(struct.pack('<I', len(binary)*8))
    wave.write(bytes(bytearray(binary)))
    size = wave.tell()
    wave.seek(4)
    wave.write(struct.pack('<I', size-8))
    wave.seek(0)
    wave.close()
    def play(d,a,s):
        def winCommand(command):
            buf = ctypes.c_buffer(255)
            ctypes.windll.winmm.mciSendStringA(command.encode(sys.getfilesystemencoding()), buf, 254, 0)
        DurationMs = d*1000
        winCommand(f'open "{s}" alias {a}')
        winCommand(f'set {a} time format milliseconds')
        winCommand(f'play {a} from 0 to {DurationMs}')
        time.sleep(d)
        winCommand(f'close {a}')
        time.sleep(1)
        if os.path.exists(s):
            os.remove(s)
    threading.Thread(target=play,args=[Duration,'playsound_' + str(random.random()),stream]).start()
    if Block:
        time.sleep(1)





# MacOS
def _playwaveOSX(Frequency = 110,L = [2,0.5,True,44100]):
    global S
    S+=[Frequency]
    print(Frequency)
    # Duration = 1, Amplitude = 0.5, Block = True, SampleRate = 44100
    Duration,Amplitude,Block,SampleRate = L[0],L[1],L[2],L[3]
    from AppKit     import NSSound
    from Foundation import NSURL
    import math, struct, tempfile, random, os, threading, time, sys, ctypes
    data = []
    for i in range(int(SampleRate*Duration)):
        data.append(int(Amplitude * 32767 * math.sin(2 * i/int(SampleRate*Duration)*Duration * math.pi * Frequency)))
    binary = b''
    for i in range(len(data)):
        binary+=data[i].to_bytes(2, 'little', signed=True)
    stream = tempfile.gettempdir()+'/'+str(random.random())+'.wav'
    WAVE_FORMAT_PCM = 0x0001
    NumChannels = 1
    bit_depth = 16
    bytes_per_second = SampleRate * (bit_depth // 8) * NumChannels
    block_align = NumChannels * (bit_depth // 8)
    header_data = b''
    header_data += b'RIFF'
    header_data += b'\x00\x00\x00\x00'
    header_data += b'WAVE'
    header_data += b'fmt '
    fmt_chunk_data = struct.pack(
        '<HHIIHH',
        WAVE_FORMAT_PCM,
        NumChannels,
        SampleRate,
        bytes_per_second,
        block_align,
        bit_depth
    )
    header_data += struct.pack('<I', len(fmt_chunk_data))
    header_data += fmt_chunk_data
    wave = open(stream, "wb")
    wave.write(header_data)
    wave.write(b'data')
    wave.write(struct.pack('<I', len(binary)*8))
    wave.write(bytes(bytearray(binary)))
    size = wave.tell()
    wave.seek(4)
    wave.write(struct.pack('<I', size-8))
    wave.seek(0)
    wave.close()
    def play(d,a,s):
        if '://' not in s:
            if not s.startswith('/'):
                from os import getcwd
                s = getcwd() + '/' + s
            s = 'file://' + s
        url   = NSURL.URLWithString_(s)
        nssound = NSSound.alloc().initWithContentsOfURL_byReference_(url, True)
        if not nssound:
            raise IOError('Unable to load sound named: ' + s)
        nssound.play()
        time.sleep(d)
        time.sleep(1)
        if os.path.exists(s):
            os.remove(s)
    threading.Thread(target=play,args=[Duration,'playsound_' + str(random.random()),stream]).start()
    if Block:
        time.sleep(1)






# Unix
def _playwaveNix(Frequency = 110,L = [2,0.5,True,44100]):
    global S
    S+=[Frequency]
    print(Frequency)
    # Duration = 1, Amplitude = 0.5, Block = True, SampleRate = 44100
    Duration,Amplitude,Block,SampleRate = L[0],L[1],L[2],L[3]
   
    if not Block:
        raise NotImplementedError("block=False cannot be used on this platform yet")
    import math, struct, tempfile, random, os, threading, time, sys, ctypes
    data = []
    for i in range(int(SampleRate*Duration)):
        data.append(int(Amplitude * 32767 * math.sin(2 * i/int(SampleRate*Duration)*Duration * math.pi * Frequency)))
    binary = b''
    for i in range(len(data)):
        binary+=data[i].to_bytes(2, 'little', signed=True)
    stream = tempfile.gettempdir()+'/'+str(random.random())+'.wav'
    WAVE_FORMAT_PCM = 0x0001
    NumChannels = 1
    bit_depth = 16
    bytes_per_second = SampleRate * (bit_depth // 8) * NumChannels
    block_align = NumChannels * (bit_depth // 8)
    header_data = b''
    header_data += b'RIFF'
    header_data += b'\x00\x00\x00\x00'
    header_data += b'WAVE'
    header_data += b'fmt '
    fmt_chunk_data = struct.pack(
        '<HHIIHH',
        WAVE_FORMAT_PCM,
        NumChannels,
        SampleRate,
        bytes_per_second,
        block_align,
        bit_depth
    )
    header_data += struct.pack('<I', len(fmt_chunk_data))
    header_data += fmt_chunk_data
    wave = open(stream, "wb")
    wave.write(header_data)
    wave.write(b'data')
    wave.write(struct.pack('<I', len(binary)*8))
    wave.write(bytes(bytearray(binary)))
    size = wave.tell()
    wave.seek(4)
    wave.write(struct.pack('<I', size-8))
    wave.seek(0)
    wave.close()
    try:
        from urllib.request import pathname2url
    except ImportError:
        # python 2
        from urllib import pathname2url
    import gi
    gi.require_version('Gst', '1.0')
    from gi.repository import Gst
    Gst.init(None)
    playbin = Gst.ElementFactory.make('playbin', 'playbin')
    if wave.startswith(('http://', 'https://')):
        playbin.props.uri = stream
    else:
        playbin.props.uri = 'file://' + pathname2url(os.path.abspath(wave))
    set_result = playbin.set_state(Gst.State.PLAYING)
    if set_result != Gst.StateChangeReturn.ASYNC:
        raise "playbin.set_state returned " + repr(set_result)
    bus = playbin.get_bus()
    bus.poll(Gst.MessageType.EOS, Gst.CLOCK_TIME_NONE)
    playbin.set_state(Gst.State.NULL)







# On sélectionne la bonne fonction suivant l'OS
from platform import system
system = system()
if system == 'Windows':
    PlayWave = _playwaveWin
elif system == 'Darwin':
    PlayWave = _playwaveOSX
else:
    PlayWave = _playwaveNix
del system




# TADAAAAAM
PlayWave()






______________________________________________________
baaaatch c'est moi !!!
Skype
Reply with quote
Post [R] Création de son sur mesure avec Python 
Nickel Mr. Green

Si jamais tu veux "faire plus léger", tu peux faire ça :

Code:
[lang=python][scroll]import math, struct, tempfile, random, os, threading, time, sys, ctypes, random as rdm   
S=[]


def __create_wave(Frequency = 440,L = [2,0.5,True,44100]):
    global S
    S+=[Frequency]
    print(Frequency)
    Duration,Amplitude,Block,SampleRate = L[0],L[1],L[2],L[3]
    # Duration = 1, Amplitude = 0.5, Block = True, SampleRate = 44100
    data = []
    for i in range(int(SampleRate*Duration)):
        data.append(int(Amplitude * 32767 * math.sin(2 * i/int(SampleRate*Duration)*Duration * math.pi * Frequency)))
    binary = b''
    for i in range(len(data)):
        binary+=data[i].to_bytes(2, 'little', signed=True)
    namm=random.random()
    stream = tempfile.gettempdir()+'\\'+str(namm)+'.wav'
    WAVE_FORMAT_PCM = 0x0001
    NumChannels = 1
    bit_depth = 16
    bytes_per_second = SampleRate * (bit_depth // 8) * NumChannels
    block_align = NumChannels * (bit_depth // 8)
    header_data = b''
    header_data += b'RIFF'
    header_data += b'\x00\x00\x00\x00'
    header_data += b'WAVE'
    header_data += b'fmt '
    fmt_chunk_data = struct.pack(
        '<HHIIHH',
        WAVE_FORMAT_PCM,
        NumChannels,
        SampleRate,
        bytes_per_second,
        block_align,
        bit_depth
    )
    header_data += struct.pack('<I', len(fmt_chunk_data))
    header_data += fmt_chunk_data
    wave = open(stream, "wb")
    wave.write(header_data)
    wave.write(b'data')
    wave.write(struct.pack('<I', len(binary)*8))
    wave.write(bytes(bytearray(binary)))
    size = wave.tell()
    wave.seek(4)
    wave.write(struct.pack('<I', size-8))
    wave.seek(0)
    wave.close()
    return stream
   

# Windows
def _playwaveWin(Frequency = 440,L = [2,0.5,True,44100]):
    stream = __create_wave(Frequency,L)
    Duration,Amplitude,Block,SampleRate = L[0],L[1],L[2],L[3]
    def play(d,a,s):
        def winCommand(command):
            buf = ctypes.c_buffer(255)
            ctypes.windll.winmm.mciSendStringA(command.encode(sys.getfilesystemencoding()), buf, 254, 0)
        DurationMs = d*1000
        winCommand(f'open "{s}" alias {a}')
        winCommand(f'set {a} time format milliseconds')
        winCommand(f'play {a} from 0 to {DurationMs}')
        time.sleep(d)
        winCommand(f'close {a}')
        time.sleep(1)
        if os.path.exists(s):
            os.remove(s)
    threading.Thread(target=play,args=[Duration,'playsound_' + str(random.random()),stream]).start()
    if Block:
        time.sleep(1)





# MacOS
def _playwaveOSX(Frequency = 440,L = [2,0.5,True,44100]):
    stream = __create_wave(Frequency,L)
    Duration,Amplitude,Block,SampleRate = L[0],L[1],L[2],L[3]
    from AppKit     import NSSound
    from Foundation import NSURL
    def play(d,a,s):
        if '://' not in s:
            if not s.startswith('/'):
                from os import getcwd
                s = getcwd() + '/' + s
            s = 'file://' + s
        url   = NSURL.URLWithString_(s)
        nssound = NSSound.alloc().initWithContentsOfURL_byReference_(url, True)
        if not nssound:
            raise IOError('Unable to load sound named: ' + s)
        nssound.play()
        time.sleep(d)
        time.sleep(1)
        if os.path.exists(s):
            os.remove(s)
    threading.Thread(target=play,args=[Duration,'playsound_' + str(random.random()),stream]).start()
    if Block:
        time.sleep(1)






# Unix
def _playwaveNix(Frequency = 440,L = [2,0.5,True,44100]):
    stream = __create_wave(Frequency,L)
    Duration,Amplitude,Block,SampleRate = L[0],L[1],L[2],L[3]
    if not Block:
        raise NotImplementedError("block=False cannot be used on this platform yet")
    try:
        from urllib.request import pathname2url
    except ImportError:
        # python 2
        from urllib import pathname2url
    import gi
    gi.require_version('Gst', '1.0')
    from gi.repository import Gst
    Gst.init(None)
    playbin = Gst.ElementFactory.make('playbin', 'playbin')
    if wave.startswith(('http://', 'https://')):
        playbin.props.uri = stream
    else:
        playbin.props.uri = 'file://' + pathname2url(os.path.abspath(wave))
    set_result = playbin.set_state(Gst.State.PLAYING)
    if set_result != Gst.StateChangeReturn.ASYNC:
        raise "playbin.set_state returned " + repr(set_result)
    bus = playbin.get_bus()
    bus.poll(Gst.MessageType.EOS, Gst.CLOCK_TIME_NONE)
    playbin.set_state(Gst.State.NULL)







# On sélectionne la bonne fonction suivant l'OS
from platform import system
system = system()
if system == 'Windows':
    PlayWave = _playwaveWin
elif system == 'Darwin':
    PlayWave = _playwaveOSX
else:
    PlayWave = _playwaveNix
del system




# TADAAAAAM
PlayWave()





______________________________________________________
la vie est trop courte pour retirer le périphérique USB en toute sécurité...
Si la statue de la liberté lève le bras depuis 125 ans, c'est parce qu'elle cherche du réseau sur son Blackberry Torches...
Grâce à mon nouveau correcteur automatiste sur mon téléphage, je ne fais plus aucune faute d'orthodontie.
Quelqu'un a t il déjà demandé au drapeau japonais ce qu'il enregistre depuis tout ce temps ?
Visit poster’s website
Reply with quote
Post [R] Création de son sur mesure avec Python 
je te dérange une toute derniere fois Laughing
tu pourrais me donner quelques indications pour que je modifie le programme pour :
-qu'il garde en mémoire les fichiers sons
--qu'il stocke dans une liste la fréquence et la durée du son en les associants au nom du fichier
pour éviter de les regénérer 10 fois quand j'ai besoin de plusieurs fois la meme fréquence et durée




______________________________________________________
baaaatch c'est moi !!!
Skype
Reply with quote
Post [R] Création de son sur mesure avec Python 
batch.bat wrote:
je te dérange une toute derniere fois Laughing
tu pourrais me donner quelques indications pour que je modifie le programme pour :
-qu'il garde en mémoire les fichiers sons
--qu'il stocke dans une liste la fréquence et la durée du son en les associants au nom du fichier
pour éviter de les regénérer 10 fois quand j'ai besoin de plusieurs fois la meme fréquence et durée


Bah...tu met la fréquence et la durée dans le nom de fichier, tu met ça dans un dossier, ensuite avant de générer un son du teste si le fichier existe Okay




ça se fait en 3 lignes Rolling Eyes :

Code:
[lang=python]stream = os.path.join(tempfile.gettempdir(),str(Frequency)+'.'+str(Duration)+'.wav')
if os.path.exists(stream):
    return stream


Ce qui donne (j'ai modifié que la fonction "__create_wave") :

Code:
[lang=python]def __create_wave(Frequency = 440,L = [2,0.5,True,44100]):
    Duration,Amplitude,Block,SampleRate = L[0],L[1],L[2],L[3]
    # Duration = 1, Amplitude = 0.5, Block = True, SampleRate = 44100
    stream = os.path.join(tempfile.gettempdir(),str(Frequency)+'.'+str(Duration)+'.wav')
    if os.path.exists(stream):
        return stream
    data = []
    for i in range(int(SampleRate*Duration)):
        data.append(int(Amplitude * 32767 * math.sin(2 * i/int(SampleRate*Duration)*Duration * math.pi * Frequency)))
    binary = b''
    for i in range(len(data)):
        binary+=data[i].to_bytes(2, 'little', signed=True)
    WAVE_FORMAT_PCM = 0x0001
    NumChannels = 1
    bit_depth = 16
    bytes_per_second = SampleRate * (bit_depth // 8) * NumChannels
    block_align = NumChannels * (bit_depth // 8)
    header_data = b''
    header_data += b'RIFF'
    header_data += b'\x00\x00\x00\x00'
    header_data += b'WAVE'
    header_data += b'fmt '
    fmt_chunk_data = struct.pack(
        '<HHIIHH',
        WAVE_FORMAT_PCM,
        NumChannels,
        SampleRate,
        bytes_per_second,
        block_align,
        bit_depth
    )
    header_data += struct.pack('<I', len(fmt_chunk_data))
    header_data += fmt_chunk_data
    wave = open(stream, "wb")
    wave.write(header_data)
    wave.write(b'data')
    wave.write(struct.pack('<I', len(binary)*8))
    wave.write(bytes(bytearray(binary)))
    size = wave.tell()
    wave.seek(4)
    wave.write(struct.pack('<I', size-8))
    wave.seek(0)
    wave.close()
    return stream





______________________________________________________
la vie est trop courte pour retirer le périphérique USB en toute sécurité...
Si la statue de la liberté lève le bras depuis 125 ans, c'est parce qu'elle cherche du réseau sur son Blackberry Torches...
Grâce à mon nouveau correcteur automatiste sur mon téléphage, je ne fais plus aucune faute d'orthodontie.
Quelqu'un a t il déjà demandé au drapeau japonais ce qu'il enregistre depuis tout ce temps ?
Visit poster’s website
Reply with quote
Post [R] Création de son sur mesure avec Python 
je me suis prit la tête à creer une liste avec tout les chemins au nom random associés à la frequence et la durée ... et au final ça n'a meme pas marché..

du coup ton code doit être un ancien pck dans la derniere version compatibles OS X il n'y a pas de fonction _creat_wave et je galère à l'incruster...




______________________________________________________
baaaatch c'est moi !!!
Skype
Reply with quote
Post [R] Création de son sur mesure avec Python 
Code:
[lang=python][scroll]import math, struct, tempfile, random, os, threading, time, sys, ctypes, random as rdm   


def __create_wave(Frequency = 440,L = [2,0.5,True,44100]):
    Duration,Amplitude,Block,SampleRate = L[0],L[1],L[2],L[3]
    # Duration = 1, Amplitude = 0.5, Block = True, SampleRate = 44100
    stream = os.path.join(tempfile.gettempdir(),str(Frequency)+'.'+str(Duration)+'.wav')
    if os.path.exists(stream):
        return stream
    data = []
    for i in range(int(SampleRate*Duration)):
        data.append(int(Amplitude * 32767 * math.sin(2 * i/int(SampleRate*Duration)*Duration * math.pi * Frequency)))
    binary = b''
    for i in range(len(data)):
        binary+=data[i].to_bytes(2, 'little', signed=True)
    WAVE_FORMAT_PCM = 0x0001
    NumChannels = 1
    bit_depth = 16
    bytes_per_second = SampleRate * (bit_depth // 8) * NumChannels
    block_align = NumChannels * (bit_depth // 8)
    header_data = b''
    header_data += b'RIFF'
    header_data += b'\x00\x00\x00\x00'
    header_data += b'WAVE'
    header_data += b'fmt '
    fmt_chunk_data = struct.pack(
        '<HHIIHH',
        WAVE_FORMAT_PCM,
        NumChannels,
        SampleRate,
        bytes_per_second,
        block_align,
        bit_depth
    )
    header_data += struct.pack('<I', len(fmt_chunk_data))
    header_data += fmt_chunk_data
    wave = open(stream, "wb")
    wave.write(header_data)
    wave.write(b'data')
    wave.write(struct.pack('<I', len(binary)*8))
    wave.write(bytes(bytearray(binary)))
    size = wave.tell()
    wave.seek(4)
    wave.write(struct.pack('<I', size-8))
    wave.seek(0)
    wave.close()
    return stream
   

# Windows
def _playwaveWin(Frequency = 440,L = [2,0.5,True,44100]):
    stream = __create_wave(Frequency,L)
    Duration,Amplitude,Block,SampleRate = L[0],L[1],L[2],L[3]
    def play(d,a,s):
        def winCommand(command):
            buf = ctypes.c_buffer(255)
            ctypes.windll.winmm.mciSendStringA(command.encode(sys.getfilesystemencoding()), buf, 254, 0)
        DurationMs = d*1000
        winCommand(f'open "{s}" alias {a}')
        winCommand(f'set {a} time format milliseconds')
        winCommand(f'play {a} from 0 to {DurationMs}')
        time.sleep(d)
        winCommand(f'close {a}')
        time.sleep(1)
        if os.path.exists(s):
            os.remove(s)
    threading.Thread(target=play,args=[Duration,'playsound_' + str(random.random()),stream]).start()
    if Block:
        time.sleep(1)





# MacOS
def _playwaveOSX(Frequency = 440,L = [2,0.5,True,44100]):
    stream = __create_wave(Frequency,L)
    Duration,Amplitude,Block,SampleRate = L[0],L[1],L[2],L[3]
    from AppKit     import NSSound
    from Foundation import NSURL
    def play(d,a,s):
        if '://' not in s:
            if not s.startswith('/'):
                from os import getcwd
                s = getcwd() + '/' + s
            s = 'file://' + s
        url   = NSURL.URLWithString_(s)
        nssound = NSSound.alloc().initWithContentsOfURL_byReference_(url, True)
        if not nssound:
            raise IOError('Unable to load sound named: ' + s)
        nssound.play()
        time.sleep(d)
        time.sleep(1)
        if os.path.exists(s):
            os.remove(s)
    threading.Thread(target=play,args=[Duration,'playsound_' + str(random.random()),stream]).start()
    if Block:
        time.sleep(1)






# Unix
def _playwaveNix(Frequency = 440,L = [2,0.5,True,44100]):
    stream = __create_wave(Frequency,L)
    Duration,Amplitude,Block,SampleRate = L[0],L[1],L[2],L[3]
    if not Block:
        raise NotImplementedError("block=False cannot be used on this platform yet")
    try:
        from urllib.request import pathname2url
    except ImportError:
        # python 2
        from urllib import pathname2url
    import gi
    gi.require_version('Gst', '1.0')
    from gi.repository import Gst
    Gst.init(None)
    playbin = Gst.ElementFactory.make('playbin', 'playbin')
    if wave.startswith(('http://', 'https://')):
        playbin.props.uri = stream
    else:
        playbin.props.uri = 'file://' + pathname2url(os.path.abspath(wave))
    set_result = playbin.set_state(Gst.State.PLAYING)
    if set_result != Gst.StateChangeReturn.ASYNC:
        raise "playbin.set_state returned " + repr(set_result)
    bus = playbin.get_bus()
    bus.poll(Gst.MessageType.EOS, Gst.CLOCK_TIME_NONE)
    playbin.set_state(Gst.State.NULL)







# On sélectionne la bonne fonction suivant l'OS
from platform import system
system = system()
if system == 'Windows':
    PlayWave = _playwaveWin
elif system == 'Darwin':
    PlayWave = _playwaveOSX
else:
    PlayWave = _playwaveNix
del system




# TADAAAAAM
PlayWave()





______________________________________________________
la vie est trop courte pour retirer le périphérique USB en toute sécurité...
Si la statue de la liberté lève le bras depuis 125 ans, c'est parce qu'elle cherche du réseau sur son Blackberry Torches...
Grâce à mon nouveau correcteur automatiste sur mon téléphage, je ne fais plus aucune faute d'orthodontie.
Quelqu'un a t il déjà demandé au drapeau japonais ce qu'il enregistre depuis tout ce temps ?
Visit poster’s website
Reply with quote
Post [R] Création de son sur mesure avec Python 
Okay Okay




______________________________________________________
baaaatch c'est moi !!!
Skype
Display posts from previous:
Reply to topic Page 2 of 2
Goto page: <  1, 2
  



Index | Getting a forum | Free support forum | Free forums directory | Report a violation | Cookies | Charte | Conditions générales d'utilisation
Copyright 2008 - 2016 // Batch