integratedwindow.cpp

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

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

#include "integratedwindow.hpp"
#include "ui_integratedwindow.h"
#include "frame_capture.hpp"
#include "base_config.hpp"
#include "ps_muxer.hpp"

#include <QFileDialog>
#include <QPushButton>
#include <QThread>

using namespace std::chrono;

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

    ui->videoPreview->setText("相机初始化中...");
    ui->videoPreview->setFont(QFont("宋体", 16, QFont::Bold));
    ui->videoPreview->setAlignment(Qt::AlignCenter);

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

    // -------------------------- 采集画面 -------------------------- //
    _frameCapturePtr = std::make_unique<FrameCapture>();
    _captureThreadPtr = std::make_unique<QThread>(this);
    _frameCapturePtr->moveToThread(_captureThreadPtr.get());

    connect(_captureThreadPtr.get(), &QThread::started, _frameCapturePtr.get(), &FrameCapture::start);
    // -------------------------- 采集画面 -------------------------- //

    // -------------------------- 预处理画面 -------------------------- //
    _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;
    // -------------------------- 预处理画面 -------------------------- //

    // -------------------------- 编码画面 -------------------------- //
    _frameEncoderPtr = std::make_unique<FrameEncoder>();
    _encodeThreadPtr = std::make_unique<QThread>(this);
    _frameEncoderPtr->moveToThread(_encodeThreadPtr.get());
    connect(_frameEncoderPtr.get(), &FrameEncoder::onFrameEncode,
            this, &IntegratedWindow::writeH264Packet,
            Qt::QueuedConnection);
    _encodeThreadPtr->start();
    // -------------------------- 编码画面 -------------------------- //

    std::cout << "连接各插件完成，启动采集线程" << std::endl;
    // 连接帧捕获信号到预览线程
    connect(_frameCapturePtr.get(), &FrameCapture::frameCaptured,
            _previewWorkerPtr.get(), &PreviewWorker::frameReceived,
            Qt::QueuedConnection);
    // 连接帧捕获信号到编码线程
    connect(_frameCapturePtr.get(), &FrameCapture::frameCaptured,
            _frameEncoderPtr.get(), &FrameEncoder::frameReceived,
            Qt::QueuedConnection);
    _captureThreadPtr->start();

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

    std::cout << "启动完成, 摄像头采集画面中" << std::endl;
}

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

void IntegratedWindow::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, &IntegratedWindow::onSipStateChanged);
    connect(_registerPtr.get(), &SipRegister::g711Received, this, &IntegratedWindow::onG711DataReceived);
    connect(_registerPtr.get(), &SipRegister::pcmReceived, this, &IntegratedWindow::onPcmDataReceived);
    _registerPtr->doRegister();
}

void IntegratedWindow::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 IntegratedWindow::writeH264Packet(const std::vector<uint8_t>& h264) const {
    if (h264.empty()) {
        return;
    }

    if (_isStartStream.load()) {
        // 计算 90kHz 时间戳（固定帧率）
        // 每帧间隔 = 90000 / 25 = 3600
        const quint32 pts_90k = _frameCount * (TIMESTAMP_BASE / VIDEO_FPS);

        PsMuxer::get()->writeVideoFrame(h264.data(), pts_90k, h264.size());
        _frameCount++;
    }
}

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

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

IntegratedWindow::~IntegratedWindow() {
    // 1. 先停止 SIP 注册（会停止内部网络线程）
    if (_registerPtr) {
        _registerPtr->unRegister();
    }

    // 2. 先停止工作对象
    if (_frameCapturePtr) {
        _frameCapturePtr->stop();
    }

    // 3. 退出线程并等待结束
    if (_captureThreadPtr) {
        _captureThreadPtr->quit();
        _captureThreadPtr->wait();
        _captureThreadPtr.reset();
    }
    _frameCapturePtr.reset();;

    if (_previewThreadPtr) {
        _previewThreadPtr->quit();
        _previewThreadPtr->wait();
        _previewThreadPtr.reset();
    }
    _previewWorkerPtr.reset();

    if (_encodeThreadPtr) {
        _encodeThreadPtr->quit();
        _encodeThreadPtr->wait();
        _encodeThreadPtr.reset();
    }
    _frameEncoderPtr.reset();

    delete ui;
}