Convert WAV To MP3

[studionexus-lk]

add to pubspec.yaml

flutter_lame: ^1.0.3

AudioConverter.dart

import 'dart:io';
import 'dart:typed_data';
import 'package:flutter_lame/flutter_lame.dart';
import 'package:path/path.dart' as path;

class AudioConverter {
  static Future<String?> convertWavToMp3(String wavFilePath, {int bitRate = 128}) async {
    try {
      final File wavFile = File(wavFilePath);
      if (!await wavFile.exists()) {
        throw Exception('WAV file not found');
      }

      // Read WAV file header
      final bytes = await wavFile.readAsBytes();
      if (bytes.length < 44) {
        throw Exception('Invalid WAV file');
      }

      // Parse WAV header
      final ByteData headerData = bytes.buffer.asByteData(0, 44);
      final sampleRate = headerData.getUint32(24, Endian.little);
      final numChannels = headerData.getUint16(22, Endian.little);

      // Create output file path
      final directory = path.dirname(wavFilePath);
      final fileName = path.basenameWithoutExtension(wavFilePath);
      final mp3FilePath = path.join(directory, '$fileName.mp3');
      final outputFile = File(mp3FilePath);
      final sink = outputFile.openWrite();

      // Initialize encoder
      final encoder = LameMp3Encoder(
        sampleRate: sampleRate,
        numChannels: numChannels,
        bitRate: bitRate,
      );

      // Process PCM data in chunks
      final pcmData = bytes.sublist(44); // Skip WAV header
      const chunkSize = 4096; // Process 4KB at a time

      // Convert PCM data to int16 samples
      List<Int16List> audioChannels = _extractChannels(pcmData, headerData);

      // Encode in chunks
      for (int i = 0; i < audioChannels[0].length; i += chunkSize) {
        final end = (i + chunkSize < audioChannels[0].length) ? i + chunkSize : audioChannels[0].length;
        final leftChunk = audioChannels[0].sublist(i, end);
        final rightChunk = audioChannels.length > 1
            ? audioChannels[1].sublist(i, end)
            : leftChunk; // For mono, use same data for both channels

        final mp3Frame = await encoder.encode(
          leftChannel: leftChunk,
          rightChannel: rightChunk,
        );

        if (mp3Frame != null && mp3Frame.isNotEmpty) {
          sink.add(mp3Frame);
        }
      }

      // Flush encoder and close file
      final lastFrame = await encoder.flush();
      if (lastFrame != null && lastFrame.isNotEmpty) {
        sink.add(lastFrame);
      }
      await sink.close();

      return mp3FilePath;
    } catch (e) {
      print('Error converting WAV to MP3: $e');
      return null;
    }
  }

  static List<Int16List> _extractChannels(Uint8List pcmData, ByteData header) {
    final bitsPerSample = header.getUint16(34, Endian.little);
    final numChannels = header.getUint16(22, Endian.little);
    final samplesPerChannel = (pcmData.length ~/ (bitsPerSample ~/ 8)) ~/ numChannels;

    List<Int16List> audioChannels = List.generate(
        numChannels,
            (_) => Int16List(samplesPerChannel)
    );

    final pcmBytes = ByteData.sublistView(pcmData);
    int sampleIndex = 0;

    for (int i = 0; i < pcmData.length; i += (bitsPerSample ~/ 8) * numChannels) {
      for (int channelIndex = 0; channelIndex < numChannels; channelIndex++) {
        int sample;
        if (bitsPerSample == 16) {
          sample = pcmBytes.getInt16(i + channelIndex * 2, Endian.little);
        } else if (bitsPerSample == 24) {
          int value = pcmBytes.getInt8(i + channelIndex * 3) |
          (pcmBytes.getInt8(i + channelIndex * 3 + 1) << 8) |
          (pcmBytes.getInt8(i + channelIndex * 3 + 2) << 16);
          if (value & 0x800000 != 0) value |= ~0xFFFFFF;
          // Convert 24-bit to 16-bit
          sample = (value >> 8).clamp(-32768, 32767);
        } else if (bitsPerSample == 32) {
          // Convert 32-bit float to 16-bit int
          double floatSample = pcmBytes.getFloat32(i + channelIndex * 4, Endian.little);
          sample = (floatSample * 32767).round().clamp(-32768, 32767);
        } else {
          throw Exception('Unsupported bits per sample: $bitsPerSample');
        }

        audioChannels[channelIndex][sampleIndex] = sample;
      }
      sampleIndex++;
    }

    return audioChannels;
  }
}

Usage

  final mp3FilePath = await AudioConverter.convertWavToMp3(
        _currentAudioFilePath!,
        bitRate: 192, // Higher quality MP3
      );

[csukuangfj]

Please describe in text what your issue is.

[studionexus-lk]

 OutlinedButton(
  child: Text("Generate"),
  onPressed: () async {
    await _init();
    await _player?.stop();

    setState(() {
      _maxSpeakerID = _tts?.numSpeakers ?? 0;
      if (_maxSpeakerID > 0) {
        _maxSpeakerID -= 1;
      }
    });

    if (_tts == null) {
      _controller_hint.value = TextEditingValue(
        text: 'Failed to initialize tts',
      );
      return;
    }

    _controller_hint.value = TextEditingValue(
      text: '',
    );

    final text = _controller_text_input.text.trim();
    if (text == '') {
      _controller_hint.value = TextEditingValue(
        text: 'Please first input your text to generate',
      );
      return;
    }

    final sid = int.tryParse(_controller_sid.text.trim()) ?? 0;

    final stopwatch = Stopwatch();
    stopwatch.start();
    final audio = _tts!.generate(text: text, sid: sid, speed: _speed);
    final suffix = '-sid-$sid-speed-${_speed.toStringAsPrecision(2)}';
    final filename = await generateWaveFilename(suffix);

    final ok = sherpa_onnx.writeWave(
      filename: filename,
      samples: audio.samples,
      sampleRate: audio.sampleRate,
    );

    if (ok) {
      stopwatch.stop();
      double elapsed = stopwatch.elapsed.inMilliseconds.toDouble();

      double waveDuration = audio.samples.length.toDouble() / audio.sampleRate.toDouble();

      _controller_hint.value = TextEditingValue(
        text: 'Saved to\n$filename\n'
            'Elapsed: ${(elapsed / 1000).toStringAsPrecision(4)} s\n'
            'Wave duration: ${waveDuration.toStringAsPrecision(4)} s\n'
            'RTF: ${(elapsed / 1000).toStringAsPrecision(4)}/${waveDuration.toStringAsPrecision(4)} '
            '= ${(elapsed / 1000 / waveDuration).toStringAsPrecision(3)} ',
      );
      _lastFilename = filename;

      **// Convert WAV to MP3
      final mp3Filename = await AudioConverter.convertWavToMp3(_lastFilename);
      if (mp3Filename != null) {
        await _player?.play(DeviceFileSource(mp3Filename));
      } else {
        _controller_hint.value = TextEditingValue(
          text: 'Failed to convert WAV to MP3',
        );
      }**
    } else {
      _controller_hint.value = TextEditingValue(
        text: 'Failed to save generated audio',
      );
    }
  },
),

Got it, its working now! instead wav, i can play mp3

 final mp3Filename = await AudioConverter.convertWavToMp3(_lastFilename);
      if (mp3Filename != null) {
        await _player?.play(DeviceFileSource(mp3Filename));

[csukuangfj]

Great!