separatedwindow.cpp

//
// Created by pengx on 2026/2/6.
//

// You may need to build the project (run Qt uic code generator) to get "ui_SeparatedWindow.h" resolved

#include "separatedwindow.hpp"
#include "ui_separatedwindow.h"

#include "base_config.hpp"
#include "ps_muxer.hpp"

#include <iostream>
#include <QAbstractSocket>
#include <QStringListModel>
#include <QtEndian>
#include <QThread>

SeparatedWindow::SeparatedWindow(QWidget* parent) : QMainWindow(parent), ui(new Ui::SeparatedWindow) {
    ui->setupUi(this);

    // 注册元类型以支持跨线程信号槽
    qRegisterMetaType<cv::Mat>("cv::Mat");
    qRegisterMetaType<uint32_t>("uint32_t");
    qRegisterMetaType<std::vector<uint8_t>>("std::vector<uint8_t>");

    ui->comboBox->addItem("TCP");
    ui->comboBox->addItem("UDP");

    _settingsPtr = std::make_unique<QSettings>("GB28181Client", "ConnectionSettings", this);
    loadConnectionHistory();
    setupAutoComplete();

    // 链接Qt控件的信号槽
    connect(ui->tcpButton, &QPushButton::clicked, this, &SeparatedWindow::onTcpButtonClicked);
    connect(ui->registerButton, &QPushButton::clicked, this, &SeparatedWindow::registerButtonClicked);
}

void SeparatedWindow::loadConnectionHistory() {
    _ipHistory = _settingsPtr->value("connection/ipHistory").toStringList();
    _portHistory = _settingsPtr->value("connection/portHistory").toStringList();

    // 如果历史记录为空，添加一些默认值
    if (_ipHistory.isEmpty()) {
        _ipHistory << "192.168.1.100" << "127.0.0.1" << "localhost";
    } else {
        ui->tcpIpLineEdit->setText(_ipHistory.first());
    }

    if (_portHistory.isEmpty()) {
        _portHistory << "9000" << "8080" << "554";
    } else {
        ui->tcpPortLineEdit->setText(_portHistory.first());
    }
}

void SeparatedWindow::setupAutoComplete() {
    // 为IP输入框设置自动补全
    _ipCompleterPtr = std::make_unique<QCompleter>(_ipHistory, this);
    _ipCompleterPtr->setCaseSensitivity(Qt::CaseInsensitive);
    _ipCompleterPtr->setFilterMode(Qt::MatchContains);
    ui->tcpIpLineEdit->setCompleter(_ipCompleterPtr.get());

    // 为端口输入框设置自动补全
    _portCompleterPtr = std::make_unique<QCompleter>(_portHistory, this);
    _portCompleterPtr->setCaseSensitivity(Qt::CaseInsensitive);
    ui->tcpPortLineEdit->setCompleter(_portCompleterPtr.get());
}

void SeparatedWindow::saveConnectionHistory(const QString& ip, const QString& port) {
    // 更新IP历史（去重并移到最前）
    _ipHistory.removeAll(ip);
    _ipHistory.prepend(ip);
    while (_ipHistory.size() > 10) {
        // 最多保存10个
        _ipHistory.removeLast();
    }

    // 更新端口历史（去重并移到最前）
    _portHistory.removeAll(port);
    _portHistory.prepend(port);
    while (_portHistory.size() > 5) {
        // 最多保存5个
        _portHistory.removeLast();
    }

    // 保存到设置
    _settingsPtr->setValue("connection/ipHistory", _ipHistory);
    _settingsPtr->setValue("connection/portHistory", _portHistory);

    // 刷新自动补全列表
    _ipCompleterPtr->setModel(new QStringListModel(_ipHistory, _ipCompleterPtr.get()));
    _portCompleterPtr->setModel(new QStringListModel(_portHistory, _portCompleterPtr.get()));
}

void SeparatedWindow::onTcpButtonClicked() {
    if (_isConnected) {
        // 断开连接
        _isConnected = false;
        ui->tcpIpLineEdit->setEnabled(true);
        ui->tcpPortLineEdit->setEnabled(true);
        ui->label_connectState->setStyleSheet(R"(
            QLabel {
                    background-color: #CFCFCF;
                    border-radius: 10px;
                    border: 1px solid #CFCFCF;
                }
        )");
        ui->tcpButton->setText("连接");

        if (_tcpSocketPtr) {
            _tcpSocketPtr->disconnectFromHost();
            if (_tcpSocketPtr->state() == QAbstractSocket::ConnectedState) {
                _tcpSocketPtr->waitForDisconnected(3000); // 等待断开完成
            }
            _tcpSocketPtr->deleteLater();
            _tcpSocketPtr = nullptr;
        }

        // 清理解码器
        if (_decodeThreadPtr) {
            if (_decodeThreadPtr->isRunning()) {
                _decodeThreadPtr->quit();
                _decodeThreadPtr->wait();
            }
            _decodeThreadPtr.reset();
        }

        if (_h264DecoderPtr) {
            _h264DecoderPtr->deleteLater();
            _h264DecoderPtr = nullptr;
        }

        cleanupMediaProcess();
    } else {
        // 连接
        const QString ip = ui->tcpIpLineEdit->text().trimmed();
        if (ip.isEmpty()) {
            std::cerr << "错误：Tcp服务地址不能为空" << std::endl;
            return;
        }

        const QString portStr = ui->tcpPortLineEdit->text();
        bool ok = false;
        const uint16_t port = portStr.toUShort(&ok);
        if (!ok || port == 0) {
            std::cerr << "无效的端口号：" << portStr.toStdString() << std::endl;
            return;
        }

        _tcpSocketPtr = std::make_unique<QTcpSocket>(this);
        _tcpSocketPtr->connectToHost(ip, port);
        // 异步等待连接结果
        if (_tcpSocketPtr->waitForConnected(5000)) {
            std::cout << "连接成功" << std::endl;
            _isConnected = true;

            saveConnectionHistory(ip, portStr);

            ui->tcpIpLineEdit->setEnabled(false);
            ui->tcpPortLineEdit->setEnabled(false);
            ui->label_connectState->setStyleSheet(R"(
                QLabel {
                        background-color: #00FF7F;
                        border-radius: 10px;
                        border: 1px solid #00FF7F;
                    }
            )");
            ui->tcpButton->setText("断开");

            // -------------------------- 预处理画面 -------------------------- //
            _previewWorkerPtr = std::make_unique<PreviewWorker>(640, 360);
            _previewThreadPtr = std::make_unique<QThread>(this);
            _previewWorkerPtr->moveToThread(_previewThreadPtr.get());
            connect(_previewWorkerPtr.get(), &PreviewWorker::onPreviewReady, this, [this](const QImage& image) {
                ui->videoPreview->setPixmap(QPixmap::fromImage(image));
            }, Qt::QueuedConnection);
            _previewThreadPtr->start();
            std::cout << "预处理线程初始化完成" << std::endl;
            // -------------------------- 预处理画面 -------------------------- //

            // -------------------------- 解码H.264 -------------------------- //
            _h264DecoderPtr = std::make_unique<H264Decoder>();
            _decodeThreadPtr = std::make_unique<QThread>(this);
            _h264DecoderPtr->moveToThread(_decodeThreadPtr.get());
            connect(_h264DecoderPtr.get(), &H264Decoder::frameDecoded,
                    _previewWorkerPtr.get(), &PreviewWorker::frameReceived,
                    Qt::QueuedConnection);
            connect(this, &SeparatedWindow::h264DataReady,
                    _h264DecoderPtr.get(), &H264Decoder::decodeH264Data,
                    Qt::QueuedConnection);
            _decodeThreadPtr->start();
            std::cout << "解码线程初始化完成" << std::endl;
            // -------------------------- 解码H.264 -------------------------- //

            // -------------------------- 推流 -------------------------- //
            _streamWorkerPtr = std::make_unique<StreamWorker>(VIDEO_FPS * 2);
            _streamThreadPtr = std::make_unique<QThread>(this);
            _streamWorkerPtr->moveToThread(_streamThreadPtr.get());
            connect(this, &SeparatedWindow::streamFrameReady, _streamWorkerPtr.get(), &StreamWorker::frameReceived);
            _streamThreadPtr->start();
            std::cout << "解码线程初始化完成" << std::endl;
            // -------------------------- 推流 -------------------------- //

            // 使用信号槽接收数据 - 无阻塞
            connect(_tcpSocketPtr.get(), &QTcpSocket::readyRead, this, &SeparatedWindow::onDataReceived);
            std::cout << "启动完成, 摄像头采集画面中" << std::endl;
        } else {
            std::cerr << "连接失败:" << _tcpSocketPtr->errorString().toStdString() << std::endl;
            _isConnected = false;
        }
    }
}

void SeparatedWindow::onDataReceived() {
    // TCP 是流式协议，不保留消息边界，先把数据存入缓冲区
    _receiveBuffer.append(_tcpSocketPtr->readAll());

    while (_receiveBuffer.size() >= 8) {
        // 读取2字节payload大小（大端序）
        const auto payloadSize = qFromBigEndian<quint32>(_receiveBuffer.constData());

        // 总包大小 = 2字节size + payload
        const int totalPacketSize = 4 + static_cast<int>(payloadSize);

        // 缓冲区内数据还不够一个完整包，等待更多数据
        if (_receiveBuffer.size() < totalPacketSize) {
            break;
        }

        // 解析 pts（跳过前2字节size，读取4字节pts）
        const auto pts = qFromBigEndian<quint32>(_receiveBuffer.constData() + 4);

        // 提取H.264数据（跳过2字节size + 4字节pts）
        const int h264Size = static_cast<int>(payloadSize) - 4;
        QByteArray h264Data = _receiveBuffer.mid(8, h264Size);

        if (h264Size < 4 ||
            (static_cast<uint8_t>(h264Data[0]) != 0x00) ||
            (static_cast<uint8_t>(h264Data[1]) != 0x00) ||
            (static_cast<uint8_t>(h264Data[2]) != 0x00) ||
            (static_cast<uint8_t>(h264Data[3]) != 0x01)) {
            qWarning() << "Invalid H.264 start code at pts:" << pts
                    << ", payloadSize:" << payloadSize
                    << ", clearing buffer";
            _receiveBuffer.clear(); // 清空缓冲区，重新开始
            return;
        }

        // 将QByteArray转换为vector<uint8_t>并发射到解码器
        std::vector<uint8_t> h264Vector(reinterpret_cast<uint8_t*>(h264Data.data()),
                                        reinterpret_cast<uint8_t*>(h264Data.data()) + h264Data.size());

        // 通过信号发射到解码器（跨线程）
        emit h264DataReady(h264Vector, pts);

        if (_isStartStream.load()) {
            emit streamFrameReady(h264Vector, pts);
        }

        // 移除已处理的包
        _receiveBuffer.remove(0, totalPacketSize);
    }
}

void SeparatedWindow::registerButtonClicked() {
    if (!_isRegistered) {
        doRegister();
    } else {
        if (_registerPtr != nullptr) {
            _registerPtr->unRegister();
            _registerPtr.reset();
        }
        _isRegistered = false;
        ui->registerButton->setText("注册");
    }
}

void SeparatedWindow::doRegister() {
    const QString host = ui->hostLineEdit->text().trimmed();
    if (host.isEmpty()) {
        std::cerr << "错误：服务器地址不能为空" << std::endl;
        return;
    }

    const QString deviceCode = ui->deviceCodeLineEdit->text().trimmed();
    if (deviceCode.isEmpty()) {
        std::cerr << "错误：设备编码不能为空" << std::endl;
        return;
    }

    const QString portStr = ui->portLineEdit->text();
    bool ok = false;
    const uint16_t port = portStr.toUShort(&ok);
    if (!ok || port == 0) {
        std::cerr << "无效的端口号：" << portStr.toStdString() << std::endl;
        return;
    }

    const QString password = ui->passwordLineEdit->text();
    if (password.isEmpty()) {
        std::cerr << "警告：密码为空" << std::endl;
        return;
    }

    if (!_registerPtr) {
        _registerPtr = std::make_unique<SipRegister>(std::string("192.168.3.131"),
                                                     host.toStdString(),
                                                     port,
                                                     ui->serverIdLineEdit->text().toStdString(),
                                                     ui->domainLineEdit->text().toStdString(),
                                                     deviceCode.toStdString(),
                                                     std::string(""),
                                                     ui->deviceNameLineEdit->text().toStdString(),
                                                     password.toStdString(),
                                                     116.3975,
                                                     39.9085);
    }
    // 连接信号到槽
    connect(_registerPtr.get(), &SipRegister::stateChanged, this, &SeparatedWindow::onSipStateChanged);
    connect(_registerPtr.get(), &SipRegister::g711Received, this, &SeparatedWindow::onG711DataReceived);
    connect(_registerPtr.get(), &SipRegister::pcmReceived, this, &SeparatedWindow::onPcmDataReceived);
    _registerPtr->doRegister();
}

void SeparatedWindow::onSipStateChanged(const int code, const QString& content) {
    std::cout << "响应码：" << code << "，" << content.toStdString() << std::endl;
    if (code == 200) {
        _isRegistered = true;
        ui->registerButton->setText("注销");
    } else if (code == 201) {
        _isRegistered = false;
        ui->registerButton->setText("注册");
    } else if (code == 1000) {
        _isStartStream = true;
    } else if (code == 1001) {
        _isStartStream = false;
    }
}

void SeparatedWindow::onG711DataReceived(const QByteArray& g711) {}

void SeparatedWindow::onPcmDataReceived(const std::vector<int16_t>& pcm) {}

void SeparatedWindow::cleanupMediaProcess() {
    // 清理接收缓冲区
    _receiveBuffer.clear();

    // 停止推流线程
    if (_streamThreadPtr) {
        if (_streamThreadPtr->isRunning()) {
            _streamThreadPtr->quit();
            _streamThreadPtr->wait();
        }
        _streamThreadPtr.reset();
    }

    // 停止解码线程
    if (_decodeThreadPtr) {
        if (_decodeThreadPtr->isRunning()) {
            _decodeThreadPtr->quit();
            _decodeThreadPtr->wait();
        }
        _decodeThreadPtr.reset();
    }

    // 停止预览线程
    if (_previewThreadPtr) {
        if (_previewThreadPtr->isRunning()) {
            _previewThreadPtr->quit();
            _previewThreadPtr->wait();
        }
        _previewThreadPtr.reset();
    }

    if (_streamWorkerPtr) {
        _streamWorkerPtr.reset();
    }

    if (_h264DecoderPtr) {
        _h264DecoderPtr.reset();
    }

    if (_previewWorkerPtr) {
        _previewWorkerPtr.reset();
    }
}

SeparatedWindow::~SeparatedWindow() {
    // 1. 先停止 SIP 注册
    if (_registerPtr) {
        _registerPtr->unRegister();
        _registerPtr.reset();
    }

    // 2. 清理TCP连接
    if (_tcpSocketPtr) {
        _tcpSocketPtr->disconnectFromHost();
        _tcpSocketPtr->deleteLater();
        _tcpSocketPtr = nullptr;
    }

    // 3. 清理媒体处理资源
    cleanupMediaProcess();

    delete ui;
}