Skip to content
  • Categories
  • Recent
  • Tags
  • Popular
  • Users
  • Groups
  • Search
  • Get Qt Extensions
  • Unsolved
Collapse
Brand Logo
  1. Home
  2. Qt Development
  3. Qt for Python
  4. Working with audio multimedia in pyqt5
Forum Updated to NodeBB v4.3 + New Features

Working with audio multimedia in pyqt5

Scheduled Pinned Locked Moved Unsolved Qt for Python
2 Posts 2 Posters 439 Views 2 Watching
  • Oldest to Newest
  • Newest to Oldest
  • Most Votes
Reply
  • Reply as topic
Log in to reply
This topic has been deleted. Only users with topic management privileges can see it.
  • P Offline
    P Offline
    papinhio
    wrote on last edited by
    #1

    I am trying to make a mp3 player for e-radio.

    I want to manage audio stream in real-time (volume,speed,time position).

    For the microphone, i have found/make this:

    import data
    from PyQt5 import QtCore, QtGui, QtWidgets, QtMultimedia
    
    class MicrophoneDeck():
    	def __init__(self,ui,MainWindow):
    		self.microphone_on = False
    		ui.speakers_deck_open_or_close_microphone.setText("Click to talk - Now off")
    	
    		self.default_primary_output_device = data.read_setting("primary output device")[0]["current value"]
    		self.default_input_device = data.read_setting("input device")[0]["current value"]
    		
    		self.input_devices_qt  = QtMultimedia.QAudioDeviceInfo.availableDevices(QtMultimedia.QAudio.AudioInput)
    		self.output_devices_qt = QtMultimedia.QAudioDeviceInfo.availableDevices(QtMultimedia.QAudio.AudioOutput)
    		
    		self.input_device_index = 0
    		self.output_device_index = 0
    		
    		counter = 0
    		for input_device in self.input_devices_qt:
    			if(input_device.deviceName()==self.default_input_device):
    				self.input_device_index = counter
    				break
    			counter = counter+1
    			
    		counter = 0
    		for output_device in self.output_devices_qt:
    			if(output_device.deviceName()==self.default_primary_output_device):
    				self.output_device_index = counter
    				break
    			counter = counter+1
    			
    		self.play_from_microphone(ui,MainWindow)
    		
    		#self.start_player(ui,MainWindow)
    		
    		ui.speakers_deck_open_or_close_microphone.clicked.connect(lambda state:self.change_microphone_status(ui,MainWindow))
    		ui.speakers_deck_click_to_talk.pressed.connect(lambda:self.microphone_pressed(ui,MainWindow))
    		ui.speakers_deck_click_to_talk.released.connect(lambda:self.microphone_released(ui,MainWindow))
    		ui.speakes_deck_volume_control.valueChanged.connect(lambda volume:self.microphone_volume_changed(volume,ui,MainWindow))
    		
    		self.microphone_volume_changed(100,ui,MainWindow)
    		
    	def microphone_volume_changed(self,volume,ui,MainWindow):
    		vol = volume/100
    		self.m_audio_input.setVolume(vol)
    		
    		vol_text = round(vol,1)
    		ui.speakers_deck_volume_label.setText(str(vol_text)+"/1.0")
    	
    	def microphone_pressed(self,ui,MainWindow):
    		if self.microphone_on==False:
    			self.microphone_on = True
    			ui.speakers_deck_open_or_close_microphone.setText("Click to talk - Now On")
    			self.start_player(ui,MainWindow)
    			ui.speakers_deck_open_or_close_microphone.setEnabled(False)
    		
    	def microphone_released(self,ui,MainWindow):
    		self.microphone_on = False
    		ui.speakers_deck_open_or_close_microphone.setText("Click to talk - Now off")
    		self.stop_player(ui,MainWindow)
    		ui.speakers_deck_open_or_close_microphone.setEnabled(True)
    	
    	def change_microphone_status(self,ui,MainWindow):
    		if self.microphone_on:
    			self.microphone_on = False
    			ui.speakers_deck_open_or_close_microphone.setText("Click to talk - Now off")
    			self.stop_player(ui,MainWindow)
    			ui.speakers_deck_click_to_talk.setEnabled(True)
    		else:
    			self.microphone_on = True
    			ui.speakers_deck_open_or_close_microphone.setText("Click to talk - Now On")
    			self.start_player(ui,MainWindow)
    			ui.speakers_deck_click_to_talk.setEnabled(False)
    
    	def play_from_microphone(self,ui,MainWindow):
    		self.buffer_min_value = 0
    		self.buffer_max_value = 0
    			
    			
    		self.mid_strength = 0
    		self.min_value = -25
    		self.max_value = 25
    			
    		self.m_play_called = False	
    		self.m_buffer = QtCore.QByteArray()
    			
    
    			
    		self.m_buffer_requested = True
    		#self.m_time_to_buffer = 1000
    		#self.MAX_BUFFERED_TIME = 1000
    		self.m_time_to_buffer = 50
    		self.MAX_BUFFERED_TIME = 100
    			
    		self.m_input_device_info = QtMultimedia.QAudioDeviceInfo.defaultInputDevice()
    		self.m_output_device_info = QtMultimedia.QAudioDeviceInfo.defaultOutputDevice()
    						
    			
    		self.format = QtMultimedia.QAudioFormat()
    		self.format.setCodec("audio/pcm")
    		self.format.setSampleRate(44100)
    		self.format.setChannelCount(1)
    		self.format.setSampleSize(16)
    		self.format.setByteOrder(QtMultimedia.QAudioFormat.LittleEndian)
    		self.format.setSampleType(QtMultimedia.QAudioFormat.SignedInt)
    			
    		self.m_audio_input = QtMultimedia.QAudioInput(self.input_devices_qt[int(self.input_device_index)],self.format)
    			
    		#self.m_input_device = self.m_audio_input.start()
    		#self.m_audio_input.resume()
    		
    		self.m_audio_input.setNotifyInterval(100)
    		self.m_audio_input.notify.connect(lambda: self.send_input_to_buffer(MainWindow,ui))
    		
    			
    			
    		if (self.format.sampleRate() >= 44100):
    			self.internal_buffer_size = (1024 * 10) * self.format.channelCount()
    		elif (self.format.sampleRate() >= 24000):
    			self.internal_buffer_size = (1024 * 6) * self.format.channelCount()
    		else:
    			self.internal_buffer_size = (1024 * 4) * self.format.channelCount()
    				
    		self.m_audio_output = QtMultimedia.QAudioOutput(self.output_devices_qt[self.output_device_index], self.format)
    		#self.m_audio_output = QtMultimedia.QAudioOutput(self.output_devices_qt[0], self.format)
    		self.m_audio_output.setBufferSize(self.internal_buffer_size)
    			
    		self.m_size_to_buffer = int(self.timeToSize_1())
    			
    		self.m_max_size_to_buffer = self.m_size_to_buffer + int(self.timeToSize_2())
    		
    		#self.m_output_device = self.m_audio_output.start()
    		
    		self.timer_play = QtCore.QTimer(MainWindow)
    		self.timer_play.setTimerType(QtCore.Qt.PreciseTimer)
    		self.timer_play.timeout.connect(lambda:self.preplay(MainWindow))
    		self.timer_play.start(10)
    		
    		self.timer_verifier = QtCore.QTimer(MainWindow)
    		self.timer_verifier.timeout.connect(self.verifier)
    		self.timer_verifier.start(max(self.m_time_to_buffer, 10))
    		
    		#ui.stop_push_button.setEnabled(True)
    		
    	def verifier(self):
    		if (self.m_buffer.size() >= self.m_max_size_to_buffer):
    			self.m_buffer.clear()
    					
    	def timeToSize_1(self):
    		return ((self.format.channelCount() * (self.format.sampleSize() / 8) * self.format.sampleRate()) * self.m_time_to_buffer / 1000)
    		
    	def timeToSize_2(self):
    		return ((self.format.channelCount() * (self.format.sampleSize() / 8) * self.format.sampleRate()) * self.MAX_BUFFERED_TIME / 1000)
    			
    	def send_input_to_buffer(self,MainWindow,ui):
    		bytes_ready = self.m_audio_input.bytesReady()
    		if(type(bytes_ready) == int and bytes_ready>0):
    			data = self.m_input_device.readAll()
    			self.m_buffer.append(data)
    			#self.plot_buffer.append(data)
    			#self.calculate_mid_strength(ui)
    			self.preplay(MainWindow)
    			
    	def preplay(self,MainWindow):
    		if(self.m_play_called==False):
    			self.m_play_called = True
    			self.timer = QtCore.QTimer(MainWindow)
    			self.timer.setSingleShot(True)
    			self.timer.singleShot(0, self.sound_microphone)
    			
    	def sound_microphone(self):
    		self.m_play_called = False
    		if self.m_buffer.isEmpty():
    			self.m_buffer_requested = True
    			return
    		elif self.m_buffer.size() < self.m_size_to_buffer:
    			if self.m_buffer_requested:
    				return
    		else:
    			self.m_buffer_requested = False
    			
    		readlen = int(self.m_audio_output.periodSize())
    		chunks = int(self.m_audio_output.bytesFree() / readlen)
    		
    		while (chunks>0):
    			samples = self.m_buffer.mid(0, readlen)
    			len = samples.size()
    			self.m_buffer.remove(0, len)
    
    			if (len>0):
    				if(self.m_audio_output.state()!=2):
    					self.m_output_device.write(samples)
    				else:
    					return 1
    
    			if (len != readlen):
    				break;
    
    			chunks = chunks - 1
    			
    	def stop_player(self,ui,MainWindow):
    		self.m_audio_input.stop()
    		self.m_audio_output.stop()
    		
    	def start_player(self,ui,MainWindow):
    		self.m_input_device = self.m_audio_input.start()
    		self.m_audio_input.resume()
    		
    		self.m_output_device = self.m_audio_output.start()
    

    For the first deck i have made this:

    from PyQt5 import QtCore, QtGui, QtWidgets, QtMultimedia
    from PyQt5 import QtCore, QtMultimedia, QtWidgets
    from PyQt5.QtTest import QSignalSpy
    from PyQt5.QtCore import QObject, pyqtSlot, pyqtSignal, QByteArray, QIODevice, QFileInfo
    from PyQt5.QtMultimedia import QAudioDecoder, QAudioFormat, QMediaObject, QAudioBuffer, QAudioOutput, QAudio
    import data
    
    class Deck1():
    	def __init__(self,ui,MainWindow):
    		self.output_devices_qt = QtMultimedia.QAudioDeviceInfo.availableDevices(QtMultimedia.QAudio.AudioOutput)
    		self.decode_test_sound(r"C:\Users\Χρήστος\Desktop\Papinhio player\project\disket box\mp3 files\ΑΓΙΑ ΚΥΡΙΑΚΗ.mp3",ui,MainWindow)
    		ui.deck_1_volume_control.valueChanged.connect(lambda volume:self.change_deck_1_volume(volume,ui,MainWindow))
    		
    	def change_deck_1_volume(self,volume,ui,MainWindow):
    		vol = volume/100
    		vol_text = round(vol,1)
    		ui.deck_1_volume_label.setText(str(vol_text)+"/1.0")
    		self.m_audio_output.setVolume(vol)
    			
    	def decode_test_sound(self,file_path,ui,MainWindow):
    		self.desiredFormat = QtMultimedia.QAudioFormat()
    		self.desiredFormat.setCodec("audio/pcm")
    		self.desiredFormat.setSampleRate(44100)
    		self.desiredFormat.setChannelCount(1)
    		self.desiredFormat.setSampleSize(16)
    		self.desiredFormat.setByteOrder(QtMultimedia.QAudioFormat.LittleEndian)
    		self.desiredFormat.setSampleType(QtMultimedia.QAudioFormat.SignedInt)
    		
    		self.m_buffer = QByteArray()
    		self.m_buffer_copy = QByteArray()
    		
    		self.decoder = QAudioDecoder()
    		self.decoder.bufferReady.connect(lambda:self.readBuffer(ui,MainWindow))
    		self.decoder.setAudioFormat(self.desiredFormat)
    		self.decoder.setSourceFilename(file_path)	
    		self.decoder.start()
    		
    		
    		
    		#self.start_player(ui,MainWindow)
    		self.play_status = 0
    		
    	def readBuffer(self,ui,MainWindow):
    		buffer = self.decoder.read()
    		count = buffer.byteCount()
    		if(count>0):
    			buffer_data = buffer.constData().asstring(count)
    			self.m_buffer.append(buffer_data)
    			if(self.play_status!=1):
    				self.start_player(ui,MainWindow)
    				self.play_status = 1
    		else:
    			return 1
    			
    	def timeToSize_1(self):
    		return ((self.desiredFormat.channelCount() * (self.desiredFormat.sampleSize() / 8) * self.desiredFormat.sampleRate()) * self.m_time_to_buffer / 1000)
    	
    	def timeToSize_2(self):
    
    		return ((self.desiredFormat.channelCount() * (self.desiredFormat.sampleSize() / 8) * self.desiredFormat.sampleRate()) * self.MAX_BUFFERED_TIME / 1000)
    	
    			
    	def preplay(self,ui,MainWindow):
    		if(self.play_status!=0):
    			if(self.m_play_called==False):
    				self.m_play_called = True
    				self.timer = QtCore.QTimer(MainWindow)
    				self.timer.setSingleShot(True)
    				self.timer.singleShot(0,lambda:self.sound_mp3(ui,MainWindow))
    			
    	def sound_mp3(self,ui,MainWindow):
    		if(self.play_status!=0):
    			self.m_play_called = False
    			if self.m_buffer.isEmpty():
    				self.stop_player(ui,MainWindow)
    				self.m_buffer_requested = True
    				return
    			elif self.m_buffer.size() < self.m_size_to_buffer:
    				if self.m_buffer_requested:
    					return
    			else:
    				self.m_buffer_requested = False
    				
    			readlen = int(self.m_audio_output.periodSize())
    			chunks = int(self.m_audio_output.bytesFree() / readlen)
    			
    			
    			while (chunks>0):
    				samples = self.m_buffer.mid(0, readlen)
    				len = samples.size()
    				self.m_buffer.remove(0, len)
    				
    				samples_data = samples.data()
    				print(samples_data)
    				if (len>0):
    					if(self.m_audio_output.state()!=2):
    						self.m_output_device.write(samples)
    					else:
    						return 1
    
    				if (len != readlen):
    					break
    
    				chunks = chunks - 1
    	
    	def start_player(self,ui,MainWindow):
    		self.m_play_called = False
    		self.m_buffer_requested = True
    		self.m_time_to_buffer = 50
    		self.MAX_BUFFERED_TIME = 100
    		
    		if (self.desiredFormat.sampleRate() >= 44100):
    			self.internal_buffer_size = (1024 * 10) * self.desiredFormat.channelCount()
    		elif (self.desiredFormat.sampleRate() >= 24000):
    			self.internal_buffer_size = (1024 * 6) * self.desiredFormat.channelCount()
    		else:
    			self.internal_buffer_size = (1024 * 4) * self.desiredFormat.channelCount()
    			
    		#self.m_audio_output = QtMultimedia.QAudioOutput(self.output_devices_qt[self.output_device_index], self.desiredFormat)
    		self.m_audio_output = QtMultimedia.QAudioOutput(self.output_devices_qt[0], self.desiredFormat)
    		self.m_audio_output.setBufferSize(self.internal_buffer_size)
    		
    		self.m_size_to_buffer = int(self.timeToSize_1())
    		
    		self.m_max_size_to_buffer = self.m_size_to_buffer + int(self.timeToSize_2())
    		
    		self.m_output_device = self.m_audio_output.start()
    		
    		self.timer_play = QtCore.QTimer(MainWindow)
    		self.timer_play.setTimerType(QtCore.Qt.PreciseTimer)
    		self.timer_play.timeout.connect(lambda:self.preplay(ui,MainWindow))
    		self.timer_play.start(10)
    		
    	def stop_player(self,ui,MainWindow):
    		self.play_status = 0
    		self.m_audio_output.stop()
    		self.timer_play.stop()
    

    I want:

    1. change the strength of audio bit rate (deck 1,microphone),
    2. change the speed of audio bit rate (deck 1)
    3. change the time position of audio bit rate (deck 1)

    Any advice would be useful.

    Kent-DorfmanK 1 Reply Last reply
    0
    • P papinhio

      I am trying to make a mp3 player for e-radio.

      I want to manage audio stream in real-time (volume,speed,time position).

      For the microphone, i have found/make this:

      import data
      from PyQt5 import QtCore, QtGui, QtWidgets, QtMultimedia
      
      class MicrophoneDeck():
      	def __init__(self,ui,MainWindow):
      		self.microphone_on = False
      		ui.speakers_deck_open_or_close_microphone.setText("Click to talk - Now off")
      	
      		self.default_primary_output_device = data.read_setting("primary output device")[0]["current value"]
      		self.default_input_device = data.read_setting("input device")[0]["current value"]
      		
      		self.input_devices_qt  = QtMultimedia.QAudioDeviceInfo.availableDevices(QtMultimedia.QAudio.AudioInput)
      		self.output_devices_qt = QtMultimedia.QAudioDeviceInfo.availableDevices(QtMultimedia.QAudio.AudioOutput)
      		
      		self.input_device_index = 0
      		self.output_device_index = 0
      		
      		counter = 0
      		for input_device in self.input_devices_qt:
      			if(input_device.deviceName()==self.default_input_device):
      				self.input_device_index = counter
      				break
      			counter = counter+1
      			
      		counter = 0
      		for output_device in self.output_devices_qt:
      			if(output_device.deviceName()==self.default_primary_output_device):
      				self.output_device_index = counter
      				break
      			counter = counter+1
      			
      		self.play_from_microphone(ui,MainWindow)
      		
      		#self.start_player(ui,MainWindow)
      		
      		ui.speakers_deck_open_or_close_microphone.clicked.connect(lambda state:self.change_microphone_status(ui,MainWindow))
      		ui.speakers_deck_click_to_talk.pressed.connect(lambda:self.microphone_pressed(ui,MainWindow))
      		ui.speakers_deck_click_to_talk.released.connect(lambda:self.microphone_released(ui,MainWindow))
      		ui.speakes_deck_volume_control.valueChanged.connect(lambda volume:self.microphone_volume_changed(volume,ui,MainWindow))
      		
      		self.microphone_volume_changed(100,ui,MainWindow)
      		
      	def microphone_volume_changed(self,volume,ui,MainWindow):
      		vol = volume/100
      		self.m_audio_input.setVolume(vol)
      		
      		vol_text = round(vol,1)
      		ui.speakers_deck_volume_label.setText(str(vol_text)+"/1.0")
      	
      	def microphone_pressed(self,ui,MainWindow):
      		if self.microphone_on==False:
      			self.microphone_on = True
      			ui.speakers_deck_open_or_close_microphone.setText("Click to talk - Now On")
      			self.start_player(ui,MainWindow)
      			ui.speakers_deck_open_or_close_microphone.setEnabled(False)
      		
      	def microphone_released(self,ui,MainWindow):
      		self.microphone_on = False
      		ui.speakers_deck_open_or_close_microphone.setText("Click to talk - Now off")
      		self.stop_player(ui,MainWindow)
      		ui.speakers_deck_open_or_close_microphone.setEnabled(True)
      	
      	def change_microphone_status(self,ui,MainWindow):
      		if self.microphone_on:
      			self.microphone_on = False
      			ui.speakers_deck_open_or_close_microphone.setText("Click to talk - Now off")
      			self.stop_player(ui,MainWindow)
      			ui.speakers_deck_click_to_talk.setEnabled(True)
      		else:
      			self.microphone_on = True
      			ui.speakers_deck_open_or_close_microphone.setText("Click to talk - Now On")
      			self.start_player(ui,MainWindow)
      			ui.speakers_deck_click_to_talk.setEnabled(False)
      
      	def play_from_microphone(self,ui,MainWindow):
      		self.buffer_min_value = 0
      		self.buffer_max_value = 0
      			
      			
      		self.mid_strength = 0
      		self.min_value = -25
      		self.max_value = 25
      			
      		self.m_play_called = False	
      		self.m_buffer = QtCore.QByteArray()
      			
      
      			
      		self.m_buffer_requested = True
      		#self.m_time_to_buffer = 1000
      		#self.MAX_BUFFERED_TIME = 1000
      		self.m_time_to_buffer = 50
      		self.MAX_BUFFERED_TIME = 100
      			
      		self.m_input_device_info = QtMultimedia.QAudioDeviceInfo.defaultInputDevice()
      		self.m_output_device_info = QtMultimedia.QAudioDeviceInfo.defaultOutputDevice()
      						
      			
      		self.format = QtMultimedia.QAudioFormat()
      		self.format.setCodec("audio/pcm")
      		self.format.setSampleRate(44100)
      		self.format.setChannelCount(1)
      		self.format.setSampleSize(16)
      		self.format.setByteOrder(QtMultimedia.QAudioFormat.LittleEndian)
      		self.format.setSampleType(QtMultimedia.QAudioFormat.SignedInt)
      			
      		self.m_audio_input = QtMultimedia.QAudioInput(self.input_devices_qt[int(self.input_device_index)],self.format)
      			
      		#self.m_input_device = self.m_audio_input.start()
      		#self.m_audio_input.resume()
      		
      		self.m_audio_input.setNotifyInterval(100)
      		self.m_audio_input.notify.connect(lambda: self.send_input_to_buffer(MainWindow,ui))
      		
      			
      			
      		if (self.format.sampleRate() >= 44100):
      			self.internal_buffer_size = (1024 * 10) * self.format.channelCount()
      		elif (self.format.sampleRate() >= 24000):
      			self.internal_buffer_size = (1024 * 6) * self.format.channelCount()
      		else:
      			self.internal_buffer_size = (1024 * 4) * self.format.channelCount()
      				
      		self.m_audio_output = QtMultimedia.QAudioOutput(self.output_devices_qt[self.output_device_index], self.format)
      		#self.m_audio_output = QtMultimedia.QAudioOutput(self.output_devices_qt[0], self.format)
      		self.m_audio_output.setBufferSize(self.internal_buffer_size)
      			
      		self.m_size_to_buffer = int(self.timeToSize_1())
      			
      		self.m_max_size_to_buffer = self.m_size_to_buffer + int(self.timeToSize_2())
      		
      		#self.m_output_device = self.m_audio_output.start()
      		
      		self.timer_play = QtCore.QTimer(MainWindow)
      		self.timer_play.setTimerType(QtCore.Qt.PreciseTimer)
      		self.timer_play.timeout.connect(lambda:self.preplay(MainWindow))
      		self.timer_play.start(10)
      		
      		self.timer_verifier = QtCore.QTimer(MainWindow)
      		self.timer_verifier.timeout.connect(self.verifier)
      		self.timer_verifier.start(max(self.m_time_to_buffer, 10))
      		
      		#ui.stop_push_button.setEnabled(True)
      		
      	def verifier(self):
      		if (self.m_buffer.size() >= self.m_max_size_to_buffer):
      			self.m_buffer.clear()
      					
      	def timeToSize_1(self):
      		return ((self.format.channelCount() * (self.format.sampleSize() / 8) * self.format.sampleRate()) * self.m_time_to_buffer / 1000)
      		
      	def timeToSize_2(self):
      		return ((self.format.channelCount() * (self.format.sampleSize() / 8) * self.format.sampleRate()) * self.MAX_BUFFERED_TIME / 1000)
      			
      	def send_input_to_buffer(self,MainWindow,ui):
      		bytes_ready = self.m_audio_input.bytesReady()
      		if(type(bytes_ready) == int and bytes_ready>0):
      			data = self.m_input_device.readAll()
      			self.m_buffer.append(data)
      			#self.plot_buffer.append(data)
      			#self.calculate_mid_strength(ui)
      			self.preplay(MainWindow)
      			
      	def preplay(self,MainWindow):
      		if(self.m_play_called==False):
      			self.m_play_called = True
      			self.timer = QtCore.QTimer(MainWindow)
      			self.timer.setSingleShot(True)
      			self.timer.singleShot(0, self.sound_microphone)
      			
      	def sound_microphone(self):
      		self.m_play_called = False
      		if self.m_buffer.isEmpty():
      			self.m_buffer_requested = True
      			return
      		elif self.m_buffer.size() < self.m_size_to_buffer:
      			if self.m_buffer_requested:
      				return
      		else:
      			self.m_buffer_requested = False
      			
      		readlen = int(self.m_audio_output.periodSize())
      		chunks = int(self.m_audio_output.bytesFree() / readlen)
      		
      		while (chunks>0):
      			samples = self.m_buffer.mid(0, readlen)
      			len = samples.size()
      			self.m_buffer.remove(0, len)
      
      			if (len>0):
      				if(self.m_audio_output.state()!=2):
      					self.m_output_device.write(samples)
      				else:
      					return 1
      
      			if (len != readlen):
      				break;
      
      			chunks = chunks - 1
      			
      	def stop_player(self,ui,MainWindow):
      		self.m_audio_input.stop()
      		self.m_audio_output.stop()
      		
      	def start_player(self,ui,MainWindow):
      		self.m_input_device = self.m_audio_input.start()
      		self.m_audio_input.resume()
      		
      		self.m_output_device = self.m_audio_output.start()
      

      For the first deck i have made this:

      from PyQt5 import QtCore, QtGui, QtWidgets, QtMultimedia
      from PyQt5 import QtCore, QtMultimedia, QtWidgets
      from PyQt5.QtTest import QSignalSpy
      from PyQt5.QtCore import QObject, pyqtSlot, pyqtSignal, QByteArray, QIODevice, QFileInfo
      from PyQt5.QtMultimedia import QAudioDecoder, QAudioFormat, QMediaObject, QAudioBuffer, QAudioOutput, QAudio
      import data
      
      class Deck1():
      	def __init__(self,ui,MainWindow):
      		self.output_devices_qt = QtMultimedia.QAudioDeviceInfo.availableDevices(QtMultimedia.QAudio.AudioOutput)
      		self.decode_test_sound(r"C:\Users\Χρήστος\Desktop\Papinhio player\project\disket box\mp3 files\ΑΓΙΑ ΚΥΡΙΑΚΗ.mp3",ui,MainWindow)
      		ui.deck_1_volume_control.valueChanged.connect(lambda volume:self.change_deck_1_volume(volume,ui,MainWindow))
      		
      	def change_deck_1_volume(self,volume,ui,MainWindow):
      		vol = volume/100
      		vol_text = round(vol,1)
      		ui.deck_1_volume_label.setText(str(vol_text)+"/1.0")
      		self.m_audio_output.setVolume(vol)
      			
      	def decode_test_sound(self,file_path,ui,MainWindow):
      		self.desiredFormat = QtMultimedia.QAudioFormat()
      		self.desiredFormat.setCodec("audio/pcm")
      		self.desiredFormat.setSampleRate(44100)
      		self.desiredFormat.setChannelCount(1)
      		self.desiredFormat.setSampleSize(16)
      		self.desiredFormat.setByteOrder(QtMultimedia.QAudioFormat.LittleEndian)
      		self.desiredFormat.setSampleType(QtMultimedia.QAudioFormat.SignedInt)
      		
      		self.m_buffer = QByteArray()
      		self.m_buffer_copy = QByteArray()
      		
      		self.decoder = QAudioDecoder()
      		self.decoder.bufferReady.connect(lambda:self.readBuffer(ui,MainWindow))
      		self.decoder.setAudioFormat(self.desiredFormat)
      		self.decoder.setSourceFilename(file_path)	
      		self.decoder.start()
      		
      		
      		
      		#self.start_player(ui,MainWindow)
      		self.play_status = 0
      		
      	def readBuffer(self,ui,MainWindow):
      		buffer = self.decoder.read()
      		count = buffer.byteCount()
      		if(count>0):
      			buffer_data = buffer.constData().asstring(count)
      			self.m_buffer.append(buffer_data)
      			if(self.play_status!=1):
      				self.start_player(ui,MainWindow)
      				self.play_status = 1
      		else:
      			return 1
      			
      	def timeToSize_1(self):
      		return ((self.desiredFormat.channelCount() * (self.desiredFormat.sampleSize() / 8) * self.desiredFormat.sampleRate()) * self.m_time_to_buffer / 1000)
      	
      	def timeToSize_2(self):
      
      		return ((self.desiredFormat.channelCount() * (self.desiredFormat.sampleSize() / 8) * self.desiredFormat.sampleRate()) * self.MAX_BUFFERED_TIME / 1000)
      	
      			
      	def preplay(self,ui,MainWindow):
      		if(self.play_status!=0):
      			if(self.m_play_called==False):
      				self.m_play_called = True
      				self.timer = QtCore.QTimer(MainWindow)
      				self.timer.setSingleShot(True)
      				self.timer.singleShot(0,lambda:self.sound_mp3(ui,MainWindow))
      			
      	def sound_mp3(self,ui,MainWindow):
      		if(self.play_status!=0):
      			self.m_play_called = False
      			if self.m_buffer.isEmpty():
      				self.stop_player(ui,MainWindow)
      				self.m_buffer_requested = True
      				return
      			elif self.m_buffer.size() < self.m_size_to_buffer:
      				if self.m_buffer_requested:
      					return
      			else:
      				self.m_buffer_requested = False
      				
      			readlen = int(self.m_audio_output.periodSize())
      			chunks = int(self.m_audio_output.bytesFree() / readlen)
      			
      			
      			while (chunks>0):
      				samples = self.m_buffer.mid(0, readlen)
      				len = samples.size()
      				self.m_buffer.remove(0, len)
      				
      				samples_data = samples.data()
      				print(samples_data)
      				if (len>0):
      					if(self.m_audio_output.state()!=2):
      						self.m_output_device.write(samples)
      					else:
      						return 1
      
      				if (len != readlen):
      					break
      
      				chunks = chunks - 1
      	
      	def start_player(self,ui,MainWindow):
      		self.m_play_called = False
      		self.m_buffer_requested = True
      		self.m_time_to_buffer = 50
      		self.MAX_BUFFERED_TIME = 100
      		
      		if (self.desiredFormat.sampleRate() >= 44100):
      			self.internal_buffer_size = (1024 * 10) * self.desiredFormat.channelCount()
      		elif (self.desiredFormat.sampleRate() >= 24000):
      			self.internal_buffer_size = (1024 * 6) * self.desiredFormat.channelCount()
      		else:
      			self.internal_buffer_size = (1024 * 4) * self.desiredFormat.channelCount()
      			
      		#self.m_audio_output = QtMultimedia.QAudioOutput(self.output_devices_qt[self.output_device_index], self.desiredFormat)
      		self.m_audio_output = QtMultimedia.QAudioOutput(self.output_devices_qt[0], self.desiredFormat)
      		self.m_audio_output.setBufferSize(self.internal_buffer_size)
      		
      		self.m_size_to_buffer = int(self.timeToSize_1())
      		
      		self.m_max_size_to_buffer = self.m_size_to_buffer + int(self.timeToSize_2())
      		
      		self.m_output_device = self.m_audio_output.start()
      		
      		self.timer_play = QtCore.QTimer(MainWindow)
      		self.timer_play.setTimerType(QtCore.Qt.PreciseTimer)
      		self.timer_play.timeout.connect(lambda:self.preplay(ui,MainWindow))
      		self.timer_play.start(10)
      		
      	def stop_player(self,ui,MainWindow):
      		self.play_status = 0
      		self.m_audio_output.stop()
      		self.timer_play.stop()
      

      I want:

      1. change the strength of audio bit rate (deck 1,microphone),
      2. change the speed of audio bit rate (deck 1)
      3. change the time position of audio bit rate (deck 1)

      Any advice would be useful.

      Kent-DorfmanK Offline
      Kent-DorfmanK Offline
      Kent-Dorfman
      wrote on last edited by Kent-Dorfman
      #2

      @papinhio said in Working with audio multimedia in pyqt5:

      Any advice would be useful.

      Start experimenting...Oh, and read class docs.

      1 Reply Last reply
      1

      • Login

      • Login or register to search.
      • First post
        Last post
      0
      • Categories
      • Recent
      • Tags
      • Popular
      • Users
      • Groups
      • Search
      • Get Qt Extensions
      • Unsolved