Flutter音频流播放插件icecast_flutter的使用

Icecast Flutter 插件 📻

一个用于将音频流传输到Icecast服务器的Flutter插件。该插件允许用户从输入设备捕获音频，传输到Icecast，并通过方法通道与原生平台代码进行通信。

特性

• 将音频流传输到Icecast服务器。
• 支持写入原始音频数据到流。
• 启动/停止流式传输，可自定义设置如比特率、声道数、采样率等。

安装

要使用此插件，在你的pubspec.yaml文件中添加icecast_flutter作为依赖项：

运行以下命令以获取插件：

flutter pub get

使用

导入库

在你的Dart文件中导入插件：

import 'package:icecast_flutter/icecast_flutter.dart';

初始化

使用startStream方法开始向Icecast服务器传输音频流。你可以通过提供比特率、采样率、声道数以及Icecast服务器凭据等详细信息来配置流。

_icecastFlutterPlugin = IcecastFlutter(
    password: password,
    userName: username,
    serverAddress: serverAddress,
    mount: mount,
    port: serverPort,
    bitrate: bitRate,
    sampleRate: sampleRate,
    numChannels: numChannels,
    onError: (error) {
      print("Streaming Error: $error");
    },
    onComplete: () {
      print("Streaming Completed 🟢");
    },
);

开始流式传输

void startIcecastStream() async {
  await _icecastFlutterPlugin.startStream(outputStream.stream);
}

停止流式传输

要停止正在进行的音频流：

void stopIcecastStream() async {
  await _icecastFlutterPlugin.stopStream();
}

写入音频数据到流

// 写入流管道
outputStream.add(yourPcmByteArray);

平台支持

• Android: 支持
• iOS: 即将推出

完整示例

以下是一个完整的示例代码，演示了如何使用icecast_flutter插件进行音频流传输。

import 'dart:async';

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:icecast_flutter/icecast_flutter.dart';
import 'package:record/record.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatefulWidget {
  const MyApp({super.key});

  [@override](/user/override)
  State<MyApp> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  bool isStreaming = false;
  late AudioRecorder record;
  late StreamController<List<int>> outputStream;
  late final IcecastFlutter _icecastFlutterPlugin;
  final int bitRate = 128;
  final int sampleRate = 44100;
  final int numChannels = 2;

  [@override](/user/override)
  void initState() {
    record = AudioRecorder();

    _icecastFlutterPlugin = IcecastFlutter(
      password: "your_password",
      userName: "your_username",
      serverAddress: "your_server_address",
      mount: "your_mount_point",
      port: 8000,
      bitrate: bitRate,
      sampleRate: sampleRate,
      numChannels: numChannels,
      onError: (error) {
        print("Streaming Error: $error");
      },
      onComplete: () {
        print("Streaming Completed 🟢");
      },
    );
    super.initState();
  }

  [@override](/user/override)
  void dispose() {
    record.dispose();
    super.dispose();
  }

  [@override](/user/override)
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: const Text('Plugin example app'),
        ),
        body: Center(
          child: ElevatedButton(
              onPressed: () async {
                if (!isStreaming) {
                  outputStream = StreamController.broadcast();

                  await _icecastFlutterPlugin.startStream(
                    outputStream.stream,
                  );

                  startStreaming();

                  setState(() {
                    isStreaming = true;
                  });
                } else {
                  var response = await _icecastFlutterPlugin.stopStream();
                  if (response == null) {
                    stopStream();
                  } else {
                    debugPrint("Stop Error: $response");
                  }

                  setState(() {
                    isStreaming = false;
                  });
                }
              },
              child: Text(isStreaming ? '停止流式传输' : '开始流式传输')),
        ),
      ),
    );
  }

  void startStreaming() async {
    List<int> byteBuffer = [];
    final bufferSize = ((sampleRate * 16 * numChannels) ~/ 8).toInt();

    var stream = await record.startStream(
      RecordConfig(
        encoder: AudioEncoder.pcm16bits,
        bitRate: bitRate,
        numChannels: numChannels,
        sampleRate: sampleRate,
        noiseSuppress: true,
        echoCancel: true,
      ),
    );

    stream.listen((Uint8List bytes) {
      if (!isStreaming) return;

      try {
        List<int> pcm16Chunk = AudioRecorder().convertBytesToInt16(bytes);
        byteBuffer.addAll(pcm16Chunk);
        if (byteBuffer.length >= bufferSize) {
          var currentChunk = byteBuffer.sublist(0, bufferSize);
          // 更新缓冲区
          byteBuffer = byteBuffer.sublist(bufferSize, byteBuffer.length);

          outputStream.add(currentChunk);
          // debugPrint("Audio Chunk $currentChunk");

          // debugPrint("Chunk 1 $chunk1");
        }
      } catch (e) {
        List<int> silenceChunk = IcecastFlutter.generateSilentBytes(1, 44100, 2);
        outputStream.add(silenceChunk);

        debugPrint('Streaming error: $e');
      }
    });
  }

  void stopStream() {
    outputStream.close();
    record.stop();
  }
}