2

我正在编写一个 Python 应用程序来将音频录制为 WAV 文件，直到用户按下pause或stop。暂停音频后，用户还应该能够恢复录制。此外：

  • 该应用程序无法预先知道录音会持续多长时间
  • 该应用程序应避免内存不足（因为录音可能很长）。例如，它可以实时写入 WAV 文件，以防止将不断增长的录音存储在内存中。

解决这个问题的好方法是什么？您能否为您的解决方案提供一些代码片段？

使用python-sounddevice，我可以stop()和start()流来模仿“暂停”功能。我可以指定一个 numpy 数组作为记录的输出。但：

  • 我不知道阵列有多大（因为我不知道记录时长）
  • 当数组填满时我会怎么做？

python-sounddevice 和 sound-file可以在不知道大小的情况下支持录音。但：

  • 我将如何结合“暂停”和“恢复”功能？声音文件只有read和write方法。
  • 有没有比使用 a 更好的方法来停止流KeyBoardInterrupt？
  • 我可以在每次“暂停”后创建不同的录音并在用户单击“停止”后合并 WAV 文件吗？
  • 我尝试使用Threading.Event()阻止录制线程来模仿暂停功能，但录制一直在写入文件

sound-device我的尝试

paused = False

def record():
    self.recording = ? # create numpy.ndarray of the correct size 
                       # (not sure the best way to do this without 
                       # knowing the recording duration)
    with sd.InputStream(samplerate=44100, device=mic, channels=1, 
        callback=self.callback):

            while self.paused:
            sd.stop()
        sd.rec(out=recording) # but what happens if 
                              # recording is very long
                              # or numpy array fills up?

def stop_and_save():
    sd.stop()
    scipy.io.wavfile.write("recording.wav", 44100, self.recording)

和sound-device方法sound-file：

with sf.SoundFile(args.filename, mode='x', samplerate=args.samplerate,
                      channels=args.channels, subtype=args.subtype) as file:
        with sd.InputStream(samplerate=args.samplerate, device=args.device,
                            channels=args.channels, callback=callback):
            print('press Ctrl+C to stop the recording')
            while True:
                file.write(q.get())  # but how do you stop writing when 'paused'?

except KeyboardInterrupt:
    print('\nRecording finished: ' + repr(args.filename))
    parser.exit(0)
except Exception as e:
    parser.exit(type(e).__name__ + ': ' + str(e))
4

1 回答 1

1

我想出了这个暂停/恢复功能的解决方案，它利用sound-deviceand方法，只要用户点击暂停sound-file，当前录制就会停止，并且在Resume上开始新的录制。然后，用户点击Stop后，所有 WAV 文件按顺序组合在一起。

（Matthias 的代码看起来也是一个很好的解决方案，它更多地利用了线程。）

要开始录制音频：

    def record(self):
        try:
            with sf.SoundFile(self.filepath,
                                       mode='x', samplerate=self.SAMPLE_RATE,
                                       channels=self.CHANNELS, subtype=None) as file:
                with sd.InputStream(samplerate=self.SAMPLE_RATE, device=self.mic_id,
                                           channels=self.CHANNELS, callback=self.callback):
                    logger.info(f"New recording started: {self.sound_file.name}")
                    try:
                        while True:
                            file.write(self.mic_queue.get())

                    except RuntimeError as re:
                        logger.debug(f"{re}. If recording was stopped by the user, then this can be ignored")

回调record()：


    def callback(self, indata, frames, time, status):
        """This is called (from a separate thread) for each audio block."""
        if status:
            print(status, file=sys.stderr)
        self.mic_queue.put(indata.copy())

暂停：_

    def pause_recording(self):
        """Mimics a 'pause' functionality by writing the current sound file changes to disk.
        Upon 'resume' a new recording will be made. Note: close() is not called here, because
        that would kill the recording thread
        """
        self.sound_file.flush()
        logger.info(f"'Paused' (closed) recording: {self.sound_file.name}")

恢复：_

    def resume_recording(self):
        """
        Mimics 'resuming' by starting a new recording, which will be merged with the others
        when the user selects Stop & Save (or deleted upon Stop & Delete)
        Note: get_full_sound_file_name() outputs a new recording with the same base name as the first, but appends a `_part2` or `_part3` etc. to the suffix to distinguish it from the first and maintain order.
        """
        self.sound_file = self.get_full_sound_file_name()
        self.record()

停止录制：

    def stop_mic_recording(self):
        try:
            self.sound_file.flush()
            self.sound_file.close()
            logger.info(f"Stopped and closed recording: {self.sound_file.name}")

        except RuntimeError as e:
            logger.info(f"Error stopping/saving {self.sound_file.name}. Make sure the file exists and can be modified")
            logger.info(f"RunTimeError: \n{e}")

合并音频（在 之后调用stop_recording()）：

   def combine_recordings_if_needed(self):
        """
        If recording was paused, combines all sections in alphabetical order into a new audio file
        """
        if self.section_count > 1:   # this is incremented when a recording is paused/resumed
            combined_audio = AudioSegment.empty()
            files_combined = []
            for rec in glob.glob(os.path.join(RECORDING_DIR, "*" + self.FILE_EXT)):
                combined_audio = combined_audio + AudioSegment.from_wav(rec) # this is why alphabetical order is important
                files_combined.append(rec)

            combined_file_name = os.path.join(RECORDING_DIR, self.base_filename + "_combined" + self.FILE_EXT)
            combined_audio.export(out_f=combined_file_name, format="wav")
            logger.info(f"Combined the following recordings into {combined_file_name}:"
                        f"\n {files_combined}")
于 2019-07-29T14:57:03.443 回答