10 examples of 'convert mp3 to wav python' in Python

27
def convert_to_music(bytes):
28
    song = AudioSegment.from_file(io.BytesIO(bytes), format="mp3")
29
    output = io.StringIO()
30
    song.export(output, format="mp3", bitrate="192k")
31
    converted_sound = AudioSegment.from_mp3(cwd + "/music/copy.mp3")
32
    print("Done")

37
def DecodeFlacToWav(input_bytes):
38
  """Decode a FLAC byte string to WAV."""
39
  p = subprocess.Popen(
40
      ['sox', '-t', 'flac', '-', '-t', 'wav', '-'],
41
      stdin=subprocess.PIPE,
42
      stdout=subprocess.PIPE,
43
      stderr=subprocess.PIPE)
44
  out, err = p.communicate(input=input_bytes)
45
  assert p.returncode == 0, err
46
  return out

146
def raw16b_from_wav(wav):
147
    data = array.array('h',[x for m_x in zip(*wav) for x in m_x])
148
    if sys.byteorder == 'big':
149
        data.byteswap()
150
    return data.tobytes()

11
def play_file(wavfile):
12
    audio_file = open(wavfile, "rb")
13
    wav = audioio.WaveFile(audio_file)
14
    speaker.play(wav)
15
    while speaker.playing:
16
        pass

37
def play_file(wavfile):
38
    f = open(wavfile, "rb")
39
    wav = audioio.WaveFile(f)
40
    a.play(wav)

29
def read_wav(wavfile):
30
    """Reads the wav file and downsamples to 11025 Hz if needed.
31
32
        @param wavfile string: Path to the wave file.
33
        @return x np.array: Array of samples of the audio file.
34
        @return fs int: Sampling frequency.
35
    """
36
    assert os.path.isfile(wavfile), \
37
        'ERROR: wivefile file %s does not exist' % wavfile
38
39
    x, fs, enc = audiolab.wavread(wavfile)
40
    if len(x.shape) >= 2:
41
        x = x[:, 0]  # Make mono
42
43
    assert fs == 44100, \
44
        "ERROR: File %s is not sampled at 44100 Hz" % wavfile
45
46
    return x, fs

141
def audio_convert(cfn, subdir, fn, audiodir, wav16_dir):
142
    # global mfcc_dir
143
144
    # convert audio if not done yet
145
146
    w16filename = "%s/%s.wav" % (wav16_dir, cfn)
147
148
    if not os.path.isfile(w16filename):
149
150
        wavfilename = "%s/%s/wav/%s.wav" % (audiodir, subdir, fn)
151
152
        if not os.path.isfile(wavfilename):
153
            # flac ?
154
            flacfilename = "%s/%s/flac/%s.flac" % (audiodir, subdir, fn)
155
156
            if not os.path.isfile(flacfilename):
157
                print "   WAV file '%s' does not exist, neither does FLAC file '%s' => skipping submission." % (
158
                wavfilename, flacfilename)
159
                return False
160
161
            print "%-20s: converting %s => %s (16kHz mono)" % (
162
            cfn, flacfilename, w16filename)
163
            os.system(
164
                "sox '%s' -r 16000 -b 16 -c 1 %s" % (flacfilename, w16filename))
165
166
        else:
167
168
            print "%-20s: converting %s => %s (16kHz mono)" % (
169
            cfn, wavfilename, w16filename)
170
            os.system(
171
                "sox '%s' -r 16000 -b 16 -c 1 %s" % (wavfilename, w16filename))
172
173
    return True

90
def buffer_to_wav(profile: Dict[str, Any], buffer: bytes) -> bytes:
91
    """Wraps a buffer of raw audio data in a WAV"""
92
    rate = int(pydash.get(profile, "audio.format.sample-rate-hertz", 16000))
93
    width = int(pydash.get(profile, "audio.format.sample-width-bits", 16)) // 8
94
    channels = int(pydash.get(profile, "audio.format.channel-count", 1))
95
96
    with io.BytesIO() as wav_buffer:
97
        with wave.open(wav_buffer, mode="wb") as wav_file:
98
            wav_file.setframerate(rate)
99
            wav_file.setsampwidth(width)
100
            wav_file.setnchannels(channels)
101
            wav_file.writeframesraw(buffer)
102
103
        return wav_buffer.getvalue()

57
def play_wav(self, wav_path):
58
    """Play audio from the given WAV file.
59
60
    The file should be mono and small enough to load into memory.
61
    Args:
62
      wav_path: path to the wav file
63
    """
64
    with wave.open(wav_path, 'r') as wav:
65
        if wav.getnchannels() != 1:
66
            raise ValueError(wav_path + ' is not a mono file')
67
68
        frames = wav.readframes(wav.getnframes())
69
        self.play_bytes(frames, wav.getframerate(), wav.getsampwidth())

23
def nwa2wav(self, data):
24
    (channels, depth, rate, u1, u2, u3, data_size, u4, samples) = \
25
            struct.unpack(self.nwa_fmt, data[0:struct.calcsize(self.nwa_fmt)])
26
    riff_size = 36 + samples*(depth/8)
27
    # 16 = size of "fmt" section
28
    # 1 = PCM format
29
    header = struct.pack(self.wav_fmt, "RIFF", riff_size, "WAVE",
30
                         "fmt ", 16, 1, channels, rate,
31
                         rate*(depth/8), rate*(depth/8)*channels, depth, "data", data_size)
32
    return header + data[struct.calcsize(self.nwa_fmt):]