def __init__(self, default_device_name):
super().__init__()
self.default_device_name = default_device_name
self._pull_timer = QTimer()
self._pull_timer.setInterval(3000)
self._pull_timer.timeout.connect(self.write_to_buffer)
self._audio_input = None
self._input = None
self._audio_data_handler = None
devices = QAudioDeviceInfo.availableDevices(QAudio.AudioInput)
self._device = None
self.monitors = []
for item in devices:
dev_name = item.deviceName()
if dev_name.endswith(".monitor"):
self.monitors.append(item)
if self.default_device_name and self.default_device_name == item.deviceName(
):
self._device = item
if not self._device:
try:
self._device = self.monitors[0]
except IndexError:
self._device = QAudioDeviceInfo.defaultInputDevice()
self.initialize_audio()
self.start_audio()
def __init__(self):
super(ZeguiWindow, self).__init__()
self.setWindowTitle("Zegui")
# microphone input (placeholder for the data streams)
self.audioDevice = QAudioDeviceInfo.defaultInputDevice()
if (self.audioDevice.isNull()):
QMessageBox.warning(None, "audio", "There is no audio input device available.")
sys.exit(-1)
# File information
#self.currSession = RecordingSession('','')
# Status bar
self.status = self.statusBar()
# Menu
self.createActions()
self.createMenu()
# Window dimension
geometry = app.desktop().availableGeometry(self)
self.setFixedSize(geometry.width() * 0.8, geometry.height() * 0.7)
# Widget with panels
self.zewidget = ZeWidget(self.audioDevice)
self.setCentralWidget(self.zewidget)
def __init__(self, inference_thread):
super(Dialog, self).__init__()
self._btn = QPushButton('Record', self)
self._label = QLabel('', self)
layout = QVBoxLayout()
layout.addWidget(self._btn)
layout.addWidget(self._label)
self.setLayout(layout)
self._btn.clicked.connect(self._btn_clicked)
self._is_recording = False
self._inference_thread = inference_thread
self._inference_thread.finished.connect(
self._on_transcription_finished)
audio_format = QAudioFormat()
audio_format.setCodec('audio/pcm')
audio_format.setChannelCount(1)
audio_format.setSampleSize(16)
audio_format.setSampleRate(16000)
audio_format.setByteOrder(QAudioFormat.LittleEndian)
audio_format.setSampleType(QAudioFormat.SignedInt)
input_device_info = QAudioDeviceInfo.defaultInputDevice()
if not input_device_info.isFormatSupported(audio_format):
print('Can\'t record audio in 16kHz 16-bit signed PCM format.')
exit(1)
self._audio_input = QAudioInput(audio_format)
def __init__(self):
super(AudioTest, self).__init__()
self.m_device = QAudioDeviceInfo.defaultOutputDevice()
self.m_output = None
self.initializeWindow()
self.initializeAudio()
def __init__(self):
super(AudioTest, self).__init__()
self.m_device = QAudioDeviceInfo.defaultOutputDevice()
self.m_output = None
self.initializeWindow()
self.initializeAudio()
def change_audio_input(self, input_name):
input_devices = self.monitors
input_devices.append(QAudioDeviceInfo.defaultInputDevice())
for i in range(len(input_devices)):
if input_devices[i].deviceName() == input_name:
self._device = input_devices[i]
self.initialize_audio()
self.start_audio()
break
def initialize_audio(self):
"""Set up parameters for audio recording."""
self._format = QAudioFormat()
self._format.setSampleRate(44100)
self._format.setChannelCount(1)
self._format.setSampleSize(8)
self._format.setSampleType(QAudioFormat.UnSignedInt)
self._format.setByteOrder(QAudioFormat.LittleEndian)
self._format.setCodec("audio/pcm")
device_info = QAudioDeviceInfo(self._device)
if not device_info.isFormatSupported(self._format):
print("Default format not supported - trying to use nearest.")
self._format = device_info.nearestFormat(self._format)
self._audio_data_handler = AudioDataHandler(self._format)
self._audio_input = QAudioInput(self._device, self._format)
self._audio_data_handler.data_ready.connect(self.data_ready)
def get_input_devices(self):
devices = []
if self._device:
devices.append(self._device)
for item in self.monitors:
if item.deviceName() not in [x.deviceName() for x in devices]:
devices.append(item)
system_default = QAudioDeviceInfo.defaultInputDevice()
if system_default not in [x.deviceName() for x in devices]:
devices.append(system_default)
return devices
def __init__(self, args=None):
AudioDriver.__init__(self, args)
if args and args.audio_device:
available_devices = {}
for device in QAudioDeviceInfo.availableDevices(
QAudio.AudioOutput):
available_devices[device.deviceName()] = device
try:
device = available_devices[args.audio_device]
except KeyError:
logger.error("Unknown audio device: %r", args.audio_device)
logger.info("Available devices:")
for device_name in available_devices:
logger.info(" %r", device_name)
raise AudioDriverError("Unsupported audio device")
else:
device = QAudioDeviceInfo.defaultOutputDevice()
playback_format = device.preferredFormat()
self.decoder = QAudioDecoder()
self.decoder.setAudioFormat(playback_format)
self.output = QAudioOutput(device, playback_format)
self.device_name = device.deviceName()
self.duration = None
self.bytes_written = 0
self.last_frame = b""
self.starting = False
self.output_dev = None
self.current_file = None
self.current_buffer = None
self.current_buffer_pos = 0
self.output.stateChanged.connect(self.output_state_changed)
self.output.notify.connect(self.tick)
self.decoder.error.connect(self.decoder_error)
self.decoder.finished.connect(self.decoder_finished)
self.decoder.stateChanged.connect(self.decoder_state_changed)
self.decoder.positionChanged.connect(self.decoder_pos_changed)
self.decoder.bufferReady.connect(self.buffer_ready)
def initializeAudio(self):
self.m_pullTimer = QTimer(self)
self.m_pullTimer.timeout.connect(self.pullTimerExpired)
self.m_pullMode = True
self.m_format = QAudioFormat()
self.m_format.setSampleRate(self.DataSampleRateHz)
self.m_format.setChannelCount(1)
self.m_format.setSampleSize(16)
self.m_format.setCodec('audio/pcm')
self.m_format.setByteOrder(QAudioFormat.LittleEndian)
self.m_format.setSampleType(QAudioFormat.SignedInt)
info = QAudioDeviceInfo(QAudioDeviceInfo.defaultOutputDevice())
if not info.isFormatSupported(self.m_format):
qWarning("Default format not supported - trying to use nearest")
self.m_format = info.nearestFormat(self.m_format)
self.m_generator = Generator(self.m_format,
self.DurationSeconds * 1000000, self.ToneSampleRateHz, self)
self.createAudioOutput()
def initializeWindow(self):
layout = QVBoxLayout()
self.m_deviceBox = QComboBox()
self.m_deviceBox.activated[int].connect(self.deviceChanged)
for deviceInfo in QAudioDeviceInfo.availableDevices(
QAudio.AudioOutput):
self.m_deviceBox.addItem(deviceInfo.deviceName(), deviceInfo)
layout.addWidget(self.m_deviceBox)
self.m_modeButton = QPushButton()
self.m_modeButton.clicked.connect(self.toggleMode)
self.m_modeButton.setText(self.PUSH_MODE_LABEL)
layout.addWidget(self.m_modeButton)
self.m_suspendResumeButton = QPushButton(
clicked=self.toggleSuspendResume)
self.m_suspendResumeButton.setText(self.SUSPEND_LABEL)
layout.addWidget(self.m_suspendResumeButton)
volumeBox = QHBoxLayout()
volumeLabel = QLabel("Volume:")
self.m_volumeSlider = QSlider(Qt.Horizontal,
minimum=0,
maximum=100,
singleStep=10)
self.m_volumeSlider.valueChanged.connect(self.volumeChanged)
volumeBox.addWidget(volumeLabel)
volumeBox.addWidget(self.m_volumeSlider)
layout.addLayout(volumeBox)
window = QWidget()
window.setLayout(layout)
self.setCentralWidget(window)
def initializeWindow(self):
layout = QVBoxLayout()
self.m_deviceBox = QComboBox()
self.m_deviceBox.activated[int].connect(self.deviceChanged)
for deviceInfo in QAudioDeviceInfo.availableDevices(QAudio.AudioOutput):
self.m_deviceBox.addItem(deviceInfo.deviceName(), deviceInfo)
layout.addWidget(self.m_deviceBox)
self.m_modeButton = QPushButton()
self.m_modeButton.clicked.connect(self.toggleMode)
self.m_modeButton.setText(self.PUSH_MODE_LABEL)
layout.addWidget(self.m_modeButton)
self.m_suspendResumeButton = QPushButton(
clicked=self.toggleSuspendResume)
self.m_suspendResumeButton.setText(self.SUSPEND_LABEL)
layout.addWidget(self.m_suspendResumeButton)
volumeBox = QHBoxLayout()
volumeLabel = QLabel("Volume:")
self.m_volumeSlider = QSlider(Qt.Horizontal, minimum=0, maximum=100,
singleStep=10)
self.m_volumeSlider.valueChanged.connect(self.volumeChanged)
volumeBox.addWidget(volumeLabel)
volumeBox.addWidget(self.m_volumeSlider)
layout.addLayout(volumeBox)
window = QWidget()
window.setLayout(layout)
self.setCentralWidget(window)
def interfaces(self):
self.devices = QAudioDeviceInfo.availableDevices(QAudio.AudioInput)
self.default = QAudioDeviceInfo.defaultInputDevice()
print(self.default.supportedCodecs())
start = 0
if (availableSamples < sampleCount):
start = sampleCount - availableSamples
for s in range(start):
self.buffer[s].setY(self.buffer[s + availableSamples].y())
dataIndex = 0
for s in range(start, sampleCount):
value = (ord(data[dataIndex]) - 128) / 128
self.buffer[s].setY(value)
dataIndex = dataIndex + resolution
self.series.replace(self.buffer)
if __name__ == '__main__':
app = QApplication(sys.argv)
inputDevice = QAudioDeviceInfo.defaultInputDevice()
if (inputDevice.isNull()):
QMessageBox.warning(None, "audio",
"There is no audio input device available.")
sys.exit(-1)
mainWin = MainWindow(inputDevice)
mainWin.setWindowTitle("audio")
availableGeometry = app.desktop().availableGeometry(mainWin)
size = availableGeometry.height() * 3 / 4
mainWin.resize(size, size)
mainWin.show()
sys.exit(app.exec_())
data = self.ioDevice.readAll()
availableSamples = data.size() // resolution
start = 0
if (availableSamples < sampleCount):
start = sampleCount - availableSamples
for s in range(start):
self.buffer[s].setY(self.buffer[s + availableSamples].y())
dataIndex = 0
for s in range(start, sampleCount):
value = (ord(data[dataIndex]) - 128) / 128
self.buffer[s].setY(value)
dataIndex = dataIndex + resolution
self.series.replace(self.buffer)
if __name__ == '__main__':
app = QApplication(sys.argv)
inputDevice = QAudioDeviceInfo.defaultInputDevice()
if (inputDevice.isNull()):
QMessageBox.warning(None, "audio", "There is no audio input device available.")
sys.exit(-1)
mainWin = MainWindow(inputDevice)
mainWin.setWindowTitle("audio")
availableGeometry = app.desktop().availableGeometry(mainWin)
size = availableGeometry.height() * 3 / 4
mainWin.resize(size, size)
mainWin.show()
sys.exit(app.exec_())
