Python alsaaudio.PCM_FORMAT_S16_LE屬性代碼示例

# 需要導入模塊: import alsaaudio [as 別名]
# 或者: from alsaaudio import PCM_FORMAT_S16_LE [as 別名]
def start():
	last = GPIO.input(button)
	while True:
		val = GPIO.input(button)
		GPIO.wait_for_edge(button, GPIO.FALLING) # we wait for the button to be pressed
		GPIO.output(lights[1], GPIO.HIGH)
		inp = alsaaudio.PCM(alsaaudio.PCM_CAPTURE, alsaaudio.PCM_NORMAL, device)
		inp.setchannels(1)
		inp.setrate(16000)
		inp.setformat(alsaaudio.PCM_FORMAT_S16_LE)
		inp.setperiodsize(500)
		audio = ""
		while(GPIO.input(button)==0): # we keep recording while the button is pressed
			l, data = inp.read()
			if l:
				audio += data
		rf = open(path+'recording.wav', 'w')
		rf.write(audio)
		rf.close()
		inp = None
		alexa() 

# 需要導入模塊: import alsaaudio [as 別名]
# 或者: from alsaaudio import PCM_FORMAT_S16_LE [as 別名]
def play(f):    
    device = alsaaudio.PCM()
    device.setchannels(f.getnchannels())
    device.setrate(f.getframerate())
    if f.getsampwidth() == 1:
        device.setformat(alsaaudio.PCM_FORMAT_U8)
    # Otherwise we assume signed data, little endian
    elif f.getsampwidth() == 2:
        device.setformat(alsaaudio.PCM_FORMAT_S16_LE)
    elif f.getsampwidth() == 3:
        device.setformat(alsaaudio.PCM_FORMAT_S24_LE)
    elif f.getsampwidth() == 4:
        device.setformat(alsaaudio.PCM_FORMAT_S32_LE)
    else:
        raise ValueError('Unsupported format')
    device.setperiodsize(320)
    data = f.readframes(320)
    while data:
        # Read data from stdin
        device.write(data)
        data = f.readframes(320) 

# 需要導入模塊: import alsaaudio [as 別名]
# 或者: from alsaaudio import PCM_FORMAT_S16_LE [as 別名]
def run(self):
        # open audio file and device
        audio_file = wave.open(self.soundfile, 'rb')
        audio_device = alsaaudio.PCM(alsaaudio.PCM_PLAYBACK, alsaaudio.PCM_NORMAL, 'default')

        # we are hard coding the audio format!
        audio_device.setchannels(2)
        audio_device.setrate(44100)
        audio_device.setformat(alsaaudio.PCM_FORMAT_S16_LE)
        audio_device.setperiodsize(980)

        # play the audio
        audio_data = audio_file.readframes(980)
        while audio_data:
          audio_device.write(audio_data)
          audio_data = audio_file.readframes(980)

        audio_file.close()

# Class for blinking the leds 

# 需要導入模塊: import alsaaudio [as 別名]
# 或者: from alsaaudio import PCM_FORMAT_S16_LE [as 別名]
def acquire(self):
        if self._session.is_active():
            try:
                pcm_args = {
                    'type': alsa.PCM_PLAYBACK,
                    'mode': alsa.PCM_NORMAL,
                }
                if self._args.playback_device != 'default':
                    pcm_args['device'] = self._args.playback_device
                else:
                    pcm_args['card'] = self._args.device
                pcm = alsa.PCM(**pcm_args)

                pcm.setchannels(CHANNELS)
                pcm.setrate(RATE)
                pcm.setperiodsize(PERIODSIZE)
                pcm.setformat(alsa.PCM_FORMAT_S16_LE)

                self._device = pcm
                print "AlsaSink: device acquired"
            except alsa.ALSAAudioError as error:
                print "Unable to acquire device: ", error
                self.release() 

# 需要導入模塊: import alsaaudio [as 別名]
# 或者: from alsaaudio import PCM_FORMAT_S16_LE [as 別名]
def _record(self, cb):
        inp = None
        try:
            inp = alsaaudio.PCM(
                alsaaudio.PCM_CAPTURE,
                alsaaudio.PCM_NORMAL,
                device=self.record_device,
            )
            inp.setchannels(1)
            inp.setrate(16000)
            inp.setformat(alsaaudio.PCM_FORMAT_S16_LE)
            inp.setperiodsize(1600)  # 100ms
            finalize = False
            while not finalize:
                l, data = inp.read()
                if not self.currently_recording:
                    finalize = True
                if l or finalize:
                    # self.recorded_raw.write(data)
                    cb(data, finalize)
        except Exception:
            print(traceback.format_exc())
        finally:
            self.currently_recording = False
            if inp:
                inp.close() 

# 需要導入模塊: import alsaaudio [as 別名]
# 或者: from alsaaudio import PCM_FORMAT_S16_LE [as 別名]
def recordAudioSegments(RecordPath, BLOCKSIZE):	
	# This function is used for recording audio segments (until ctr+c is pressed)
	# ARGUMENTS:
	# - RecordPath:		the path where the wav segments will be stored
	# - BLOCKSIZE:		segment recording size (in seconds)
	# 
	# NOTE: filenames are based on clock() value
	
	print "Press Ctr+C to stop recording"
	RecordPath += os.sep
	d = os.path.dirname(RecordPath)
	if os.path.exists(d) and RecordPath!=".":
		shutil.rmtree(RecordPath)	
	os.makedirs(RecordPath)	

	inp = alsaaudio.PCM(alsaaudio.PCM_CAPTURE,alsaaudio.PCM_NONBLOCK)
	inp.setchannels(1)
	inp.setrate(Fs)
	inp.setformat(alsaaudio.PCM_FORMAT_S16_LE)
	inp.setperiodsize(512)
	midTermBufferSize = int(Fs*BLOCKSIZE)
	midTermBuffer = []
	curWindow = []
	elapsedTime = "%08.3f" % (time.time())
	while 1:
			l,data = inp.read()		   
		    	if l:
				for i in range(len(data)/2):
					curWindow.append(audioop.getsample(data, 2, i))
		
				if (len(curWindow)+len(midTermBuffer)>midTermBufferSize):
					samplesToCopyToMidBuffer = midTermBufferSize - len(midTermBuffer)
				else:
					samplesToCopyToMidBuffer = len(curWindow)

				midTermBuffer = midTermBuffer + curWindow[0:samplesToCopyToMidBuffer];
				del(curWindow[0:samplesToCopyToMidBuffer])
			

			if len(midTermBuffer) == midTermBufferSize:
				# allData = allData + midTermBuffer				
				curWavFileName = RecordPath + os.sep + str(elapsedTime) + ".wav"				
				midTermBufferArray = numpy.int16(midTermBuffer)
				wavfile.write(curWavFileName, Fs, midTermBufferArray)
				print "AUDIO  OUTPUT: Saved " + curWavFileName
				midTermBuffer = []
				elapsedTime = "%08.3f" % (time.time()) 

# 需要導入模塊: import alsaaudio [as 別名]
# 或者: from alsaaudio import PCM_FORMAT_S16_LE [as 別名]
def __test_device(device, record):
        """
            Test selected ALSA device, making sure it handles both stereo and
            mono and both 44.1KHz and 22.05KHz on output, mono and 16 kHz on
            input.

            On a typical RPI configuration, default with hifiberry card is not
            configured to do software-mono, so we'll use
            plughw:CARD=sndrpihifiberry instead.
            Likewise, on 2019 cards, hw:CARD=seeed2micvoicec is not able to run
            mono sound.

            @param device: name of the sound device
            @type device: six.text_type
            @param record: C{True} if this method is looking for recording
            device. C{False} if the device should only playback.
            @type record: bool
        """
        try:
            dev = None

            if record:
                dev = alsaaudio.PCM(alsaaudio.PCM_CAPTURE, device=device)
            else:
                dev = alsaaudio.PCM(device=device)

            if (
                dev.setformat(alsaaudio.PCM_FORMAT_S16_LE)
                != alsaaudio.PCM_FORMAT_S16_LE
            ):
                return False
            if record:
                if dev.setchannels(1) != 1:
                    return False
                if dev.setrate(16000) != 16000:
                    return False
            else:
                if dev.setchannels(2) != 2:
                    return False
                if dev.setchannels(1) != 1:
                    return False
                if dev.setrate(44100) != 44100:
                    return False
                if dev.setrate(22050) != 22050:
                    return False
        except alsaaudio.ALSAAudioError:
            return False
        finally:
            if dev:
                dev.close()
        return True