修复向下的兼容性

AvPlayer2/read_thread.cpp

@@ -268,7 +268,6 @@ int ReadThread::loop_read()
                 }
             }
             // 错误处理已经统一到上面的逻辑中
-
             std::unique_lock<std::mutex> lock(m_mutex);
             m_cv.wait_for(lock, std::chrono::milliseconds(10), [this, is] { return isExit() || is->abort_request; });
             continue;

AvRecorder/ui/opengl_video_widget.cpp

@@ -137,6 +137,7 @@ void OpenGLVideoWidget::initializeGL()
         R"Raw(
         varying vec2 textureOut;
         uniform sampler2D texture;
+        uniform vec2 uTextureSize;
         uniform bool uGray;
         uniform bool uThreshold;
         uniform float uThresholdValue;
@@ -171,7 +172,7 @@ void OpenGLVideoWidget::initializeGL()
             }
             // 简单3x3均值模糊
             if (uBlur) {
-                vec2 tex_offset = vec2(1.0) / vec2(textureSize2D(texture, 0));
+                vec2 tex_offset = vec2(1.0) / uTextureSize;
                 vec4 sum = vec4(0.0);
                 for (int dx = -1; dx <= 1; ++dx)
                 for (int dy = -1; dy <= 1; ++dy)
@@ -290,6 +291,7 @@ void OpenGLVideoWidget::paintGL()
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_frameWidth, m_frameHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_frameData);
     m_program->bind();
     m_program->setUniformValue("texture", 0);
+    m_program->setUniformValue("uTextureSize", QVector2D(m_frameWidth, m_frameHeight));
     m_program->setUniformValue("uGray", m_gray);
     m_program->setUniformValue("uThreshold", m_threshold);
     m_program->setUniformValue("uThresholdValue", m_thresholdValue);

LearningSmartClient.pro

@@ -1,7 +1,7 @@
 QT       += core gui network svg
 QT += multimedia websockets
 greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
-CONFIG += console
+# CONFIG += console
 CONFIG += c++17
 LIBS += -lshell32
 QT += opengl

network/networkaccessmanager.cpp

@@ -7,6 +7,8 @@
 #include <QFile>
 #include <QJsonDocument>
 #include <QJsonObject>
+#include <QMetaObject>
+#include <QPromise>
 #include <QUrlQuery>
 #include <QtConcurrent>
 
@@ -236,27 +238,92 @@ HttpResponse RequestClient::upload(const QString& url, QHttpMultiPart* multiPart
 
 QFuture<HttpResponse> RequestClient::getAsync(const QString& url, const QVariantMap& params)
 {
-    return QtConcurrent::run([this, url, params] { return get(url, params); });
+    auto promise = std::make_shared<QPromise<HttpResponse>>();
+    auto future = promise->future();
+    
+    QMetaObject::invokeMethod(QCoreApplication::instance(), [this, url, params, promise]() {
+        try {
+            auto result = get(url, params);
+            promise->addResult(result);
+            promise->finish();
+        } catch (...) {
+            promise->finish();
+        }
+    }, Qt::QueuedConnection);
+    
+    return future;
 }
 
 QFuture<HttpResponse> RequestClient::postAsync(const QString& url, const QJsonDocument& data)
 {
-    return QtConcurrent::run([this, url, data] { return post(url, data); });
+    auto promise = std::make_shared<QPromise<HttpResponse>>();
+    auto future = promise->future();
+    
+    QMetaObject::invokeMethod(QCoreApplication::instance(), [this, url, data, promise]() {
+        try {
+            auto result = post(url, data);
+            promise->addResult(result);
+            promise->finish();
+        } catch (...) {
+            promise->finish();
+        }
+    }, Qt::QueuedConnection);
+    
+    return future;
 }
 
 QFuture<HttpResponse> RequestClient::putAsync(const QString& url, const QJsonDocument& data)
 {
-    return QtConcurrent::run([this, url, data] { return put(url, data); });
+    auto promise = std::make_shared<QPromise<HttpResponse>>();
+    auto future = promise->future();
+    
+    QMetaObject::invokeMethod(QCoreApplication::instance(), [this, url, data, promise]() {
+        try {
+            auto result = put(url, data);
+            promise->addResult(result);
+            promise->finish();
+        } catch (...) {
+            promise->finish();
+        }
+    }, Qt::QueuedConnection);
+    
+    return future;
 }
 
 QFuture<HttpResponse> RequestClient::deleteAsync(const QString& url)
 {
-    return QtConcurrent::run([this, url] { return deleteResource(url); });
+    auto promise = std::make_shared<QPromise<HttpResponse>>();
+    auto future = promise->future();
+    
+    QMetaObject::invokeMethod(QCoreApplication::instance(), [this, url, promise]() {
+        try {
+            auto result = deleteResource(url);
+            promise->addResult(result);
+            promise->finish();
+        } catch (...) {
+            promise->finish();
+        }
+    }, Qt::QueuedConnection);
+    
+    return future;
 }
 
 QFuture<HttpResponse> RequestClient::uploadAsync(const QString& url, QHttpMultiPart* multiPart)
 {
-    return QtConcurrent::run([this, url, multiPart] { return upload(url, multiPart); });
+    auto promise = std::make_shared<QPromise<HttpResponse>>();
+    auto future = promise->future();
+    
+    QMetaObject::invokeMethod(QCoreApplication::instance(), [this, url, multiPart, promise]() {
+        try {
+            auto result = upload(url, multiPart);
+            promise->addResult(result);
+            promise->finish();
+        } catch (...) {
+            promise->finish();
+        }
+    }, Qt::QueuedConnection);
+    
+    return future;
 }
 
 bool RequestClient::download(const QString& url, const QString& saveFilePath)
@@ -282,7 +349,20 @@ bool RequestClient::download(const QString& url, const QString& saveFilePath)
 
 QFuture<bool> RequestClient::downloadAsync(const QString& url, const QString& saveFilePath)
 {
-    return QtConcurrent::run([this, url, saveFilePath] { return download(url, saveFilePath); });
+    auto promise = std::make_shared<QPromise<bool>>();
+    auto future = promise->future();
+    
+    QMetaObject::invokeMethod(QCoreApplication::instance(), [this, url, saveFilePath, promise]() {
+        try {
+            auto result = download(url, saveFilePath);
+            promise->addResult(result);
+            promise->finish();
+        } catch (...) {
+            promise->finish();
+        }
+    }, Qt::QueuedConnection);
+    
+    return future;
 }
 
 QNetworkReply* RequestClient::sendGetRequest(const QString& url, const QVariantMap& params)