如何使用Qt UDP Socket收发MP3数据并按指定速率发送MP3文件

没问题，我来一步步帮你搞定Qt UDP传输MP3的事儿——核心就是把MP3文件拆成UDP数据包发送，接收端再重组，重点是速率控制和UDP特性的适配（毕竟UDP本身不可靠，但MP3是流媒体，少量丢包影响不大）。

一、发送端实现 #

发送端的核心逻辑是：读取MP3文件，按固定大小拆分数据包，通过精确的时间计算控制发送速率，确保每秒发送16KiB（对应128Kibps的MP3）。

1. 核心成员变量 #

首先在发送类里定义必要的成员：

#include <QUdpSocket>
#include <QFile>
#include <QTimer>
#include <QElapsedTimer>

class Mp3UdpSender : public QObject
{
    Q_OBJECT
private:
    QUdpSocket *m_udpSocket;
    QFile m_mp3File;
    QTimer *m_sendTimer;
    QElapsedTimer m_elapsedTimer; // 用于精确控制速率
    qint64 m_totalSentBytes;      // 已发送总字节数
    QHostAddress m_targetAddr;    // 接收端IP
    quint16 m_targetPort;         // 接收端端口
    const qint64 m_targetRate = 16 * 1024; // 目标速率：16KiB/s
    const qint64 m_maxPacketSize = 1400;   // UDP单包最大字节（避免MTU分片）

public:
    explicit Mp3UdpSender(QObject *parent = nullptr);
    void startSending(const QString &mp3FilePath, const QString &targetIp, quint16 port);

private slots:
    void sendNextPacket();
};

2. 初始化与启动逻辑 #

在构造函数里初始化Socket和定时器，绑定发送触发的槽函数：

Mp3UdpSender::Mp3UdpSender(QObject *parent) : QObject(parent)
{
    m_udpSocket = new QUdpSocket(this);
    m_sendTimer = new QTimer(this);
    connect(m_sendTimer, &QTimer::timeout, this, &Mp3UdpSender::sendNextPacket);
}

void Mp3UdpSender::startSending(const QString &mp3FilePath, const QString &targetIp, quint16 port)
{
    // 关闭已打开的文件
    if (m_mp3File.isOpen()) {
        m_mp3File.close();
    }
    // 打开MP3文件
    m_mp3File.setFileName(mp3FilePath);
    if (!m_mp3File.open(QIODevice::ReadOnly)) {
        qDebug() << "Failed to open MP3 file: " << mp3FilePath;
        return;
    }
    // 设置目标地址和端口
    m_targetAddr = QHostAddress(targetIp);
    m_targetPort = port;
    // 重置速率控制相关变量
    m_totalSentBytes = 0;
    m_elapsedTimer.start();
    // 启动定时器（1ms间隔，用于精确控制）
    m_sendTimer->start(1);
}

3. 速率控制与数据包发送 #

这部分是核心，通过QElapsedTimer计算已流逝时间，对比预期发送字节数，控制每次发送的数据包大小：

void Mp3UdpSender::sendNextPacket()
{
    // 如果文件已读完，停止发送
    if (!m_mp3File.isOpen() || m_mp3File.atEnd()) {
        m_sendTimer->stop();
        m_mp3File.close();
        qDebug() << "MP3 file sent completely!";
        return;
    }

    // 计算当前时间点应该发送的总字节数
    qint64 elapsedMs = m_elapsedTimer.elapsed();
    qint64 expectedTotal = (m_targetRate * elapsedMs) / 1000;
    qint64 needToSend = expectedTotal - m_totalSentBytes;

    // 如果还没到发送时机，等待1ms后再检查
    if (needToSend <= 0) {
        m_sendTimer->start(1);
        return;
    }

    // 每次发送不超过最大包大小，也不超过需要发送的字节数
    qint64 sendSize = qMin(needToSend, m_maxPacketSize);
    QByteArray data = m_mp3File.read(sendSize);

    if (data.isEmpty()) {
        m_sendTimer->stop();
        m_mp3File.close();
        qDebug() << "Failed to read MP3 data, stopping send.";
        return;
    }

    // 发送UDP数据包
    m_udpSocket->writeDatagram(data, m_targetAddr, m_targetPort);
    m_totalSentBytes += data.size();

    // 立即触发下一次检查
    m_sendTimer->start(1);
}

二、接收端实现 #

接收端的逻辑相对简单：绑定端口，接收UDP数据包，直接写入本地文件即可。由于MP3是流媒体，少量丢包只会导致短暂杂音，无需复杂的重传机制。

1. 核心成员变量 #

#include <QUdpSocket>
#include <QFile>

class Mp3UdpReceiver : public QObject
{
    Q_OBJECT
private:
    QUdpSocket *m_udpSocket;
    QFile m_saveFile;

public:
    explicit Mp3UdpReceiver(QObject *parent = nullptr);
    void startReceiving(const QString &saveFilePath, quint16 listenPort);

private slots:
    void readPendingDatagrams();
};

2. 初始化与接收逻辑 #

Mp3UdpReceiver::Mp3UdpReceiver(QObject *parent) : QObject(parent)
{
    m_udpSocket = new QUdpSocket(this);
    connect(m_udpSocket, &QUdpSocket::readyRead, this, &Mp3UdpReceiver::readPendingDatagrams);
}

void Mp3UdpReceiver::startReceiving(const QString &saveFilePath, quint16 listenPort)
{
    // 关闭已打开的文件
    if (m_saveFile.isOpen()) {
        m_saveFile.close();
    }
    // 创建并打开保存文件
    m_saveFile.setFileName(saveFilePath);
    if (!m_saveFile.open(QIODevice::WriteOnly)) {
        qDebug() << "Failed to create save file: " << saveFilePath;
        return;
    }
    // 绑定监听端口
    if (!m_udpSocket->bind(QHostAddress::Any, listenPort)) {
        qDebug() << "Failed to bind port " << listenPort;
        m_saveFile.close();
        return;
    }
    qDebug() << "Listening for MP3 data on port " << listenPort;
}

void Mp3UdpReceiver::readPendingDatagrams()
{
    if (!m_saveFile.isOpen()) {
        return;
    }

    // 读取所有待处理的UDP数据包
    while (m_udpSocket->hasPendingDatagrams()) {
        QByteArray datagram;
        datagram.resize(m_udpSocket->pendingDatagramSize());
        QHostAddress senderAddr;
        quint16 senderPort;

        m_udpSocket->readDatagram(datagram.data(), datagram.size(), &senderAddr, &senderPort);
        // 写入文件并立即刷新（避免数据缓存）
        m_saveFile.write(datagram);
        m_saveFile.flush();
    }
}

三、关键注意事项 #

• UDP数据包大小：建议控制在1400字节以内，避免超过以太网MTU（1500字节）导致IP分片，分片会增加丢包概率。
• 速率控制精度：用QElapsedTimer代替固定间隔定时器，能更好地适配系统负载波动，保证速率稳定。
• UDP不可靠性：如果对音质要求极高，可以给每个数据包添加序号，接收端检测丢包后请求重传，但会增加复杂度，流媒体场景一般不需要。
• 文件操作：发送/接收前务必检查文件是否成功打开，避免程序崩溃。

内容的提问来源于stack exchange，提问作者Jeferson Juliani