搜索插件、代码仓与 APP 分类

插件详情v3.3.3

flutter_pcm_sound

将实时PCM音频(16位整数)发送到您的设备扬声器

AndroidiOSmacOS
近 30 天下载
3.9万
喜欢数
45
Pub 分数
140

安装插件

flutter pub add flutter_pcm_sound

插件介绍

基于插件公开信息、社区数据与项目使用情况整理的选型参考。

Flutter PCM Sound 是一个 Flutter 包,可直接将原始的 16 位整数 PCM 音频数据实时播放到设备扬声器。它提供低级别音频输出,非常适合需要精确定时和极低延迟的应用程序,例如音频合成、实时信号处理或自定义音频流。该包支持 Android、iOS 和 macOS,适用于跨平台音频项目。它提供了一个简单的 API 来发送音频缓冲区,使开发者能够完全控制采样率和格式来管理音频流。基于原生音频 API 构建,确保了跨平台的高效性能。

适合场景

  • 实时音频合成
  • 实时音频信号处理
  • 自定义音频流
  • 低延迟音频播放
  • 音频可视化

主要特点

  • 支持16位整数PCM
  • 实时音频输出
  • 跨平台(Android、iOS、macOS)
  • 低延迟音频传输
  • 简单的基于缓冲区的 API

适合对象

  • 音频开发者
  • 实时信号处理
  • 游戏音频引擎
  • 需要精细控制的音乐应用程序
  • 嵌入式音频系统

使用建议

  • 需要手动管理音频缓冲区
  • 无内置音频文件解码
  • 仅限 PCM 格式
  • 可能需要特定于平台的音频配置
  • 不适用于通用音频播放

原始 README

以下为关联源码仓库的 README 原文快照,最新内容请访问源码仓库。

pub package

Logo

Send real-time PCM audio (16-bit integer) to your device speakers, from your Flutter app!

No Dependencies

FlutterPcmSound has zero dependencies besides Flutter, Android, iOS, and MacOS themselves.

For Real-Time Audio, Not Audio Files

Unlike other plugins, flutter_pcm_sound does not use audio files (For example: flutter_soloud, sound_pool).

Instead, flutter_pcm_sound is for apps that generate audio in realtime a few milliseconds before you hear it. For example, using dart_melty_soundfont.

Callback Based

In contrast to raw_sound, FlutterPcmSound uses a callback setFeedCallback to signal when to feed more samples.

You can lower the feed threshold using setFeedThreshold to achieve real time audio, or increase it to have a cushy buffer.

Event Based Feeding

Unlike traditional audio libraries which use a high-frequency timer-based audio callback, flutter_pcm_sound uses a low-frequency event-based callback. This integrates more seamlessly in the existing Flutter event loop, without necessitating an Isolate to ensure precise timing.

Your feed callback is invoked once for each of these events:

  • Low-buffer event – when the number of buffered frames falls below the threshold set with setFeedThreshold, i.e remainingFrames < threshold.
  • Zero event – when the buffer is fully drained, i.e. remainingFrames == 0.

Note: once means once per feed() — every time you feed new data, the plugin will trigger another low-buffer or zero event when necessary.

💡 Tip: By altering how many extra samples you feed beyond your threshold, you can control how often flutter_pcm_sound invokes your feed callback.

💡 Tip: You should still consider running your sound code in a Dart Isolate, so that it is decoupled from UI framedrops.

Timer Based Feeding

If you prefer, it's easy to wrap flutter_pcm_sound to simulate traditional timer-based feeding, i.e. invoking your feed callback at a specific preferrred rate, using a Dart timer.

  1. Set a large feed threshold so that flutter_pcm_sound regularly tells you its remainingFrames

  2. Start a Dart-side Timer.periodic(...) or Ticker

  3. On each timer tick, call your feed callback with the estimated remaining frames. i.e. estimatedRemainingFrames = remainingFrames - (elapsedSeconds * sampleRate)

For an example, click here
import 'dart:async';
import 'package:flutter_pcm_sound/flutter_pcm_sound.dart';

typedef FeedCallback = List<int> Function(int remainingFrames);

/// wraps FlutterPcmSound w/ timer-based feeding
class FlutterPcmTimer {
  // --- config ---
  static int _sampleRate = 48000;
  static int _channelCount = 1;
  static int _tickHz = 60;

  // --- state ---
  static FeedCallback? _onFeed;
  static bool _isSetup = false;
  static bool _playing = false;
  static Timer? _timer;

  // last native event snapshot
  static int _lastEventFrames = 0;
  static int _lastEventMicros = 0; // timestamp

  // for UI
  static bool get isPlaying => _playing;

  static Future<void> setup({
    int sampleRate = 48000,
    int channelCount = 1,
    int tickHz = 60,
    IosAudioCategory iosAudioCategory = IosAudioCategory.playback,
    bool iosAllowBackgroundAudio = false,
  }) async {
    _sampleRate = sampleRate;
    _channelCount = channelCount;
    _tickHz = tickHz;

    await FlutterPcmSound.setup(
      sampleRate: _sampleRate,
      channelCount: _channelCount,
      iosAudioCategory: iosAudioCategory,
      iosAllowBackgroundAudio: iosAllowBackgroundAudio,
    );

    // Huge threshold → plugin regularly reports `remainingFrames`.
    await FlutterPcmSound.setFeedThreshold(_sampleRate * 60 * 60 * 24 * 365);

    FlutterPcmSound.setFeedCallback((remaining) {
      _lastEventFrames = remaining;
      _lastEventMicros = _nowMicros();
      if (remaining == 0 && _playing) {
        // Refill ASAP, but outside the native callback.
        scheduleMicrotask(_tick);
      }
    });

    _isSetup = true;
  }
  
  static void setFeedCallback(FeedCallback? cb) => _onFeed = cb;

  static void start() {
    if (!_isSetup) throw StateError('Call SoundTimer.setup(...) first.');
    if (_playing) return;

    _playing = true;
    FlutterPcmSound.start();

    final period = Duration(milliseconds: (1000 / _tickHz).round());
    _timer ??= Timer.periodic(period, (_) => _tick());
  }

  static void stop() {
    if (!_playing && _timer == null) return;
    _playing = false;
    _timer?.cancel();
    _timer = null;
  }

  // --- internals ---

  static void _tick() async {
    if (!_playing) return;

    final estRemaining = _estimatedRemainingFramesNow();
    if (_onFeed == null) return;

    final samples = _onFeed!(estRemaining);
    if (samples.isEmpty) return;

    if (!_playing) return; // guard before async
    await FlutterPcmSound.feed(PcmArrayInt16.fromList(samples));
  }

  static int _estimatedRemainingFramesNow() {
    final lastFrames = _lastEventFrames;
    final lastMicros = _lastEventMicros;
    if (lastMicros == 0) return 0;

    final elapsedMicros = _nowMicros() - lastMicros;
    final elapsedFrames = ((elapsedMicros / 1e6) * _sampleRate).round();
    final est = lastFrames - elapsedFrames;
    return est > 0 ? est : 0;
  }

  static int _nowMicros() => DateTime.now().microsecondsSinceEpoch;
}

One-Pedal Driving

To play audio, just keep calling feed.

To stop audio, just stop calling feed.

💡 Tip: If you prefer a traditional timer-based API with start() and stop(), I recommend wrapping flutter_pcm_sound as described in Timer Based Feeding.

Is Playing?

When your feed callback hits remainingFrames=0 you know playing stopped.

Usage

// for testing purposes, a C-Major scale 
MajorScale scale = MajorScale(sampleRate: 44100, noteDuration: 0.25);

// invoked whenever we need to feed more samples to the platform
void onFeed(int remainingFrames) async {
    // you could use 'remainingFrames' to feed very precisely.
    // But here we just load a few thousand samples everytime we run low.
    List<int> frame = scale.generate(periods: 20);
    await FlutterPcmSound.feed(PcmArrayInt16.fromList(frame));
}

await FlutterPcmSound.setup(sampleRate: 44100, channelCount: 1);
await FlutterPcmSound.setFeedThreshold(8000); 
FlutterPcmSound.setFeedCallback(onFeed);
FlutterPcmSound.start(); // for convenience. Equivalent to calling onFeed(0);

⭐ Stars ⭐

Please star this repo & on pub.dev. We all benefit from having a larger community.

Example App

Enable the platforms you need.

cd ./example                      
flutter config --enable-macos-desktop                                                      
flutter config --enable-android 
flutter config --enable-ios 
flutter create .
flutter run

所属分类

源码仓库

使用此插件的项目