我们从Python开源项目中，提取了以下16个代码示例，用于说明如何使用wave.Error()。
def _is_good_wave(self, filename): """ check if wav is in correct format for MARF. """ par = None try: w_file = wave.open(filename) par = w_file.getparams() w_file.close() except wave.Error as exc: print (exc) return False if par[:3] == (1, 2, 8000) and par[-1:] == ('not compressed',): return True else: return False
def test_aifc(h, f): import aifc if not h.startswith(b'FORM'): return None if h[8:12] == b'AIFC': fmt = 'aifc' elif h[8:12] == b'AIFF': fmt = 'aiff' else: return None f.seek(0) try: a = aifc.open(f, 'r') except (EOFError, aifc.Error): return None return (fmt, a.getframerate(), a.getnchannels(), a.getnframes(), 8 * a.getsampwidth())
def is_good_wave(filename): """Check if the wave is in correct format for LIUM. :type filename: string :param filename: file to check""" import wave par = None try: w_file = wave.open(filename) par = w_file.getparams() w_file.close() except wave.Error, exc: print exc return False if par[:3] == (1, 2, 16000) and par[-1:] == ('not compressed',): return True else: return False
def validate_wave(ctx, param, value): """ Validate the wave file by trying to open it and checking that its got a single channel. :param ctx:<class 'click.core.Context'> :param param:<class 'click.core.Option'> :param value:str :return:<class 'wave.Wave_read'> """ try: wave_read = wave.open(value) if wave_read.getnchannels() != 1: raise click.BadParameter('Only mono wave files are supported') return wave_read except wave.Error as e: raise click.BadParameter('Not a valid wave file. {}'.format(e.__str__()))
def play_sound(sound): try: wf = wave.open(sound, 'rb') # instantiate PyAudio (1) p = pyaudio.PyAudio() # define callback (2) def callback(in_data, frame_count, time_info, status): data = wf.readframes(frame_count) return (data, pyaudio.paContinue) # open stream using callback (3) stream = p.open(format=p.get_format_from_width(wf.getsampwidth()), channels=wf.getnchannels(), rate=wf.getframerate(), output=True, stream_callback=callback) # start the stream (4) stream.start_stream() except wave.Error: print('Warning: caught wave.Error!')
def _wave(self): """Return a wave.Wave_read instance from the ``wave`` module.""" try: return wave.open(StringIO(self.contents)) except wave.Error, err: err.message += "\nInvalid wave file: %s" % self err.args = (err.message,) raise
def __init__(self, fp, sample_rate, sample_width): self._fp = fp try: self._wavep = wave.open(self._fp, 'r') except wave.Error as e: logging.warning('error opening WAV file: %s, ' 'falling back to RAW format', e) self._fp.seek(0) self._wavep = None self._sample_rate = sample_rate self._sample_width = sample_width self._sleep_until = 0
def test_wav(h, f): import wave # 'RIFF' <len> 'WAVE' 'fmt ' <len> if not h.startswith(b'RIFF') or h[8:12] != b'WAVE' or h[12:16] != b'fmt ': return None f.seek(0) try: w = wave.openfp(f, 'r') except (EOFError, wave.Error): return None return ('wav', w.getframerate(), w.getnchannels(), w.getnframes(), 8*w.getsampwidth())
def show_protocol_selection_in_interpretation(self, start_message, start, end_message, end): cfc = self.compare_frame_controller msg_total = 0 last_sig_frame = None for protocol in cfc.protocol_list: if not protocol.show: continue n = protocol.num_messages view_type = cfc.ui.cbProtoView.currentIndex() messages = [i - msg_total for i in range(msg_total, msg_total + n) if start_message <= i <= end_message] if len(messages) > 0: try: signal_frame = next((sf for sf, pf in self.signal_protocol_dict.items() if pf == protocol)) except StopIteration: QMessageBox.critical(self, self.tr("Error"), self.tr("Could not find corresponding signal frame.")) return signal_frame.set_roi_from_protocol_analysis(min(messages), start, max(messages), end + 1, view_type) last_sig_frame = signal_frame msg_total += n focus_frame = last_sig_frame if last_sig_frame is not None: self.signal_tab_controller.ui.scrollArea.ensureWidgetVisible(last_sig_frame, 0, 0) QApplication.instance().processEvents() self.ui.tabWidget.setCurrentIndex(0) if focus_frame is not None: focus_frame.ui.txtEdProto.setFocus()
def read_wave_file(filename, use_numpy=False): try: w = wave.open(filename) a = numpy.fromstring(w.readframes(9999999999), dtype=NUMPY_DTYPE) if use_numpy: return numpy.reshape(a, (w.getnchannels(), -1), 'F') else: return [ a[i::w.getnchannels()] for i in xrange(w.getnchannels()) ] except wave.Error: print "Could not open %s" % filename raise
def setWave(self, file): try: wavestream = wave.open(str(file.toUtf8())) self.file = file self.info_lbl.setText('') except wave.Error: self.file = None self.stream = None self.info_lbl.setText('Unknown or unsupported format') self.clear_labels() self.set_valid(False) self.info_icon.setVisible(True) return except: self.file = None self.stream = None self.info_lbl.setText('') self.clear_labels() self.set_valid(False) self.info_icon.setVisible(False) return channels = wavestream.getnchannels() sampwidth = wavestream.getsampwidth() if channels == 1: chan_txt = 'Mono' elif channels == 2: chan_txt = 'Stereo' else: chan_txt = str(channels) framerate = wavestream.getframerate() frames = wavestream.getnframes() length = frames/float(framerate) self.channels_lbl.setText(chan_txt) self.sampwidth_lbl.setText('{} bit'.format(sampwidth*8)) self.framerate_lbl.setText('{} Hz'.format(framerate)) self.frames_lbl.setText(str(frames)) self.length_lbl.setText(secs2time(length)) if channels > 2: self.info_lbl.setText('Too many channels: only mono or stereo files are supported.') self.info_icon.setVisible(True) self.set_valid(False) elif sampwidth > 2: self.info_lbl.setText('Only 8bit and 16 bit sample resolutions are accepted.') self.info_icon.setVisible(True) self.set_valid(False) elif length > 60: self.info_lbl.setText('File too long, please select a file with length less than a minute.') self.info_icon.setVisible(True) self.set_valid(False) else: self.set_valid(file, wavestream)
def add_files(self, filepaths, group_id=0, enforce_sample_rate=None): num_files = len(filepaths) if num_files == 0: return for i, filename in enumerate(filepaths): if not os.path.exists(filename): continue if os.path.isdir(filename): for f in self.signal_tab_controller.signal_frames: self.close_signal_frame(f) FileOperator.RECENT_PATH = filename self.project_manager.set_project_folder(filename) return FileOperator.RECENT_PATH = os.path.split(filename)[0] if filename.endswith(".complex"): self.add_signalfile(filename, group_id, enforce_sample_rate=enforce_sample_rate) elif filename.endswith(".coco"): self.add_signalfile(filename, group_id, enforce_sample_rate=enforce_sample_rate) elif filename.endswith(".proto") or filename.endswith(".proto.xml"): self.add_protocol_file(filename) elif filename.endswith(".wav"): try: import wave w = wave.open(filename) w.close() except wave.Error as e: Errors.generic_error("Unsupported WAV type", "Only uncompressed WAVs (PCM) are supported.", str(e)) continue self.add_signalfile(filename, group_id, enforce_sample_rate=enforce_sample_rate) elif filename.endswith(".fuzz") or filename.endswith(".fuzz.xml"): self.add_fuzz_profile(filename) elif filename.endswith(".txt"): self.add_plain_bits_from_txt(filename) elif filename.endswith(".csv"): self.__import_csv(filename, group_id) continue elif os.path.basename(filename) == constants.PROJECT_FILE: self.project_manager.set_project_folder(os.path.split(filename)[0]) else: self.add_signalfile(filename, group_id, enforce_sample_rate=enforce_sample_rate) if self.project_manager.project_file is None: self.adjust_for_current_file(filename)
def __enter__(self): assert self.stream is None, "This audio source is already inside a context manager" try: # attempt to read the file as WAV self.audio_reader = wave.open(self.filename_or_fileobject, "rb") self.little_endian = True # RIFF WAV is a little-endian format (most ``audioop`` operations assume that the frames are stored in little-endian form) except wave.Error: try: # attempt to read the file as AIFF self.audio_reader = aifc.open(self.filename_or_fileobject, "rb") self.little_endian = False # AIFF is a big-endian format except aifc.Error: # attempt to read the file as FLAC if hasattr(self.filename_or_fileobject, "read"): flac_data = self.filename_or_fileobject.read() else: with open(self.filename_or_fileobject, "rb") as f: flac_data = f.read() # run the FLAC converter with the FLAC data to get the AIFF data flac_converter = get_flac_converter() process = subprocess.Popen([ flac_converter, "--stdout", "--totally-silent", # put the resulting AIFF file in stdout, and make sure it's not mixed with any program output "--decode", "--force-aiff-format", # decode the FLAC file into an AIFF file "-", # the input FLAC file contents will be given in stdin ], stdin=subprocess.PIPE, stdout=subprocess.PIPE) aiff_data, stderr = process.communicate(flac_data) aiff_file = io.BytesIO(aiff_data) try: self.audio_reader = aifc.open(aiff_file, "rb") except aifc.Error: assert False, "Audio file could not be read as WAV, AIFF, or FLAC; check if file is corrupted" self.little_endian = False # AIFF is a big-endian format assert 1 <= self.audio_reader.getnchannels() <= 2, "Audio must be mono or stereo" self.SAMPLE_WIDTH = self.audio_reader.getsampwidth() # 24-bit audio needs some special handling for old Python versions (workaround for https://bugs.python.org/issue12866) samples_24_bit_pretending_to_be_32_bit = False if self.SAMPLE_WIDTH == 3: # 24-bit audio try: audioop.bias(b"", self.SAMPLE_WIDTH, 0) # test whether this sample width is supported (for example, ``audioop`` in Python 3.3 and below don't support sample width 3, while Python 3.4+ do) except audioop.error: # this version of audioop doesn't support 24-bit audio (probably Python 3.3 or less) samples_24_bit_pretending_to_be_32_bit = True # while the ``AudioFile`` instance will outwardly appear to be 32-bit, it will actually internally be 24-bit self.SAMPLE_WIDTH = 4 # the ``AudioFile`` instance should present itself as a 32-bit stream now, since we'll be converting into 32-bit on the fly when reading self.SAMPLE_RATE = self.audio_reader.getframerate() self.CHUNK = 4096 self.FRAME_COUNT = self.audio_reader.getnframes() self.DURATION = self.FRAME_COUNT / float(self.SAMPLE_RATE) self.stream = AudioFile.AudioFileStream(self.audio_reader, self.little_endian, samples_24_bit_pretending_to_be_32_bit) return self
