Flutter音频编码插件dart_lame的使用

功能

• 将WAV（PCM-16 或 PCM IEEE Double）编码为MP3。

开始使用

要使用此库，您必须在系统上安装libmp3lame。请确保以下库在您的系统上可用或将其放置在程序的工作目录下：

• Windows: mp3lame.dll
• Linux: libmp3lame.so
• macOS: libmp3lame.dylib

另外，您可以手动加载libmp3lame:

import 'dart:ffi' as ffi;
import 'package:dart_lame/dart_lame.dart' as lame;

class CustomLoader extends lame.LameLibraryLoader {
  @override
  ffi.DynamicLibrary load() {
    return ffi.DynamicLibrary.open("path_to_libmp3lame");
  }
}

lame.lameLoader = CustomLoader(); 

对于Flutter用户，请使用flutter_lame代替。

使用示例

import 'dart:io';
import 'dart:typed_data';

import 'package:dart_lame/dart_lame.dart';

final File f = File("output.mp3");
final IOSink sink = f.openWrite();
final LameMp3Encoder encoder = LameMp3Encoder(sampleRate: 44100, numChannels: 2);

Float64List leftChannelSamples;
Float64List rightChannelSamples;
// 获取来自文件或麦克风的样本。

final mp3Frame = await encoder.encode(
  leftChannel: leftChannelSamples,
  rightChannel: rightChannelSamples);
sink.add(mp3Frame);
// 继续直到所有样本已编码

// 最后，刷新编码器缓冲区
final lastMp3Frame = await encoder.flush();
sink.add(lastMp3Frame);

完整示例

对于完整的示例，请查看/example文件夹中的代码。

示例代码

import 'dart:async';
import 'dart:io';
import 'dart:typed_data';

import 'package:args/args.dart';
import 'package:dart_lame/dart_lame.dart';
import 'package:wav/wav.dart';

void main(List<String> arguments) async {
  print("dart_lame example");

  final parser = ArgParser()
    ..addOption("format",
        abbr: "f",
        allowed: ["wav", "pcm16"],
        help:
            "输入文件格式。注意：如果格式为pcm16，则仅接受单声道文件",
        defaultsTo: "wav")
    ..addOption("sample-rate",
        abbr: "s",
        help:
            "输入文件的采样率。如果输入格式为pcm16，则为必需项")
    ..addOption("input", abbr: "i", help: "输入文件", mandatory: true)
    ..addOption("output",
        abbr: "o", help: "输出mp3文件", defaultsTo: "output.mp3");
  final argResults = parser.parse(arguments);
  print('LAME版本: ${getLameVersion()}');

  final String inputPath = argResults["input"];
  print("输入文件: $inputPath");

  print("编码中...");

  final String outputPath = argResults["output"];
  final File f = File(outputPath);
  final IOSink sink = f.openWrite();
  try {
    if (argResults["format"] == "wav") {
      final wav = await Wav.readFile(inputPath);
      await encodeWav(wav, sink);
    } else {
      String? sampleRate = argResults["sample-rate"];
      if (sampleRate == null) {
        throw ArgumentError("--sample-rate 是必需的");
      }
      await encodePcm(inputPath, sink, int.parse(sampleRate));
    }
  } finally {
    sink.close();
  }

  print("成功编码mp3文件: ${f.absolute}");
}

Future encodeWav(Wav wav, IOSink sink) async {
  final encoder = LameMp3Encoder(
      sampleRate: wav.samplesPerSecond, numChannels: wav.channels.length);
  try {
    final left = wav.channels[0];
    Float64List? right;
    if (wav.channels.length > 1) {
      right = wav.channels[1];
    }

    for (int i = 0; i < left.length; i += wav.samplesPerSecond) {
      final mp3Frame = await encoder.encodeDouble(
          leftChannel: left.sublist(i, i + wav.samplesPerSecond),
          rightChannel: right?.sublist(i, i + wav.samplesPerSecond));
      sink.add(mp3Frame);
    }
    sink.add(await encoder.flush());
  } finally {
    encoder.close();
  }
}

Future encodePcm(String inputPath, IOSink sink, int sampleRate) async {
  final encoder = LameMp3Encoder(sampleRate: sampleRate, numChannels: 1);

  final File inputFile = File(inputPath);
  final Completer readCompleter = Completer();
  final Completer encodeCompleter = Completer();

  int counter = 0;

  final StreamSubscription<List<int>> sub = inputFile.openRead().listen(
      (event) async {
    counter++;
    final Uint8List mp3frame = await encoder.encode(
        leftChannel: Uint8List.fromList(event).buffer.asInt16List());
    sink.add(mp3frame);
    counter--;

    if (readCompleter.isCompleted) {
      if (counter == 0) {
        encodeCompleter.complete();
      }
    }
  },
      onDone: () => readCompleter.complete(),
      onError: (e) => readCompleter.completeError(e));

  try {
    await readCompleter.future;
    await encodeCompleter.future;
    final lastMp3Frame = await encoder.flush();
    sink.add(lastMp3Frame);
  } finally {
    sub.cancel();
    encoder.close();
  }
}