zhunk 2 месяцев назад
Родитель
Сommit
acb260b474

+ 1 - 1
q6_felgo_iot/CMakeLists.txt

@@ -61,7 +61,7 @@ find_package(Qt6 COMPONENTS Core Quick SerialPort Sql Multimedia Mqtt TextToSpee
 # Project identifier and version
 # More information: https://felgo.com/doc/felgo-publishing/#project-configuration
 set(PRODUCT_IDENTIFIER "com.yfkj.cb.Q6iot")
-set(PRODUCT_VERSION_NAME "1.13.49")
+set(PRODUCT_VERSION_NAME "1.13.53")
 set(PRODUCT_VERSION_CODE 130)
 
 # Set either "test" or "publish" stage:产品状态,测试?发布

+ 15 - 15
q6_felgo_iot/CMakeLists.txt.user

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE QtCreatorProject>
-<!-- Written by QtCreator 17.0.1, 2026-09-08T09:05:48. -->
+<!-- Written by QtCreator 17.0.1, 2026-09-15T16:48:20. -->
 <qtcreator>
  <data>
   <variable>EnvironmentId</variable>
@@ -108,27 +108,27 @@
     <value type="int" key="CMake.Configure.BaseEnvironment">2</value>
     <value type="bool" key="CMake.Configure.ClearSystemEnvironment">false</value>
     <valuelist type="QVariantList" key="CMake.Configure.UserEnvironmentChanges"/>
-    <value type="QString" key="CMake.Initial.Parameters">-DCMAKE_FIND_ROOT_PATH:PATH=%{Qt:QT_INSTALL_PREFIX}
+    <value type="QString" key="CMake.Initial.Parameters">-DANDROID_STL:STRING=c++_shared
 -DANDROID_USE_LEGACY_TOOLCHAIN_FILE:BOOL=OFF
--DCMAKE_BUILD_TYPE:STRING=Release
--DCMAKE_PREFIX_PATH:PATH=%{Qt:QT_INSTALL_PREFIX}
--DANDROID_ABI:STRING=arm64-v8a
--DCMAKE_GENERATOR:STRING=Ninja
--DANDROID_STL:STRING=c++_shared
+-DCMAKE_C_COMPILER:FILEPATH=%{Compiler:Executable:C}
 -DCMAKE_CXX_COMPILER:FILEPATH=%{Compiler:Executable:Cxx}
+-DQT_USE_TARGET_ANDROID_BUILD_DIR:BOOL=ON
+-DANDROID_NDK:PATH=F:/Android_Env/android_sdk/ndk/27.2.12479018
 -DANDROID_SDK_ROOT:PATH=F:/Android_Env/android_sdk
 -DQT_HOST_PATH:PATH=%{Qt:QT_HOST_PREFIX}
+-DCMAKE_COLOR_DIAGNOSTICS:BOOL=ON
+-DQT_QMAKE_EXECUTABLE:FILEPATH=%{Qt:qmakeExecutable}
+-DCMAKE_GENERATOR:STRING=Ninja
+-DCMAKE_BUILD_TYPE:STRING=Release
 -DQT_NO_GLOBAL_APK_TARGET_PART_OF_ALL:BOOL=ON
 -DCMAKE_PROJECT_INCLUDE_BEFORE:FILEPATH=%{BuildConfig:BuildDirectory:NativeFilePath}/.qtc/package-manager/auto-setup.cmake
--DANDROID_NDK:PATH=F:/Android_Env/android_sdk/ndk/27.2.12479018
--DQT_MAINTENANCE_TOOL:FILEPATH=D:/Qt/Felgo/MaintenanceTool.exe
--DQT_QMAKE_EXECUTABLE:FILEPATH=%{Qt:qmakeExecutable}
 -DCMAKE_CXX_FLAGS_INIT:STRING=%{Qt:QML_DEBUG_FLAG}
--DCMAKE_C_COMPILER:FILEPATH=%{Compiler:Executable:C}
--DCMAKE_COLOR_DIAGNOSTICS:BOOL=ON
 -DCMAKE_TOOLCHAIN_FILE:FILEPATH=F:/Android_Env/android_sdk/ndk/27.2.12479018/build/cmake/android.toolchain.cmake
--DQT_USE_TARGET_ANDROID_BUILD_DIR:BOOL=ON
--DANDROID_PLATFORM:STRING=android-23</value>
+-DANDROID_ABI:STRING=arm64-v8a
+-DANDROID_PLATFORM:STRING=android-23
+-DCMAKE_PREFIX_PATH:PATH=%{Qt:QT_INSTALL_PREFIX}
+-DCMAKE_FIND_ROOT_PATH:PATH=%{Qt:QT_INSTALL_PREFIX}
+-DQT_MAINTENANCE_TOOL:FILEPATH=D:/Qt/Felgo/MaintenanceTool.exe</value>
     <value type="QString" key="CMake.Source.Directory">F:\QT_WorkSpace\qt6_iot_all\q6_felgo_iot</value>
     <value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">F:\QT_WorkSpace\qt6_iot_all\q6_felgo_iot\build\Qt_6_8_3_android_arm64_v8a_Clang_arm64_v8a-Release</value>
     <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
@@ -205,7 +205,7 @@
       <value type="QString">armeabi-v7a</value>
       <value type="QString">armeabi</value>
      </valuelist>
-     <value type="QString" key="AndroidDeviceSerialNumber">a6ae40a48a18e289</value>
+     <value type="QString" key="AndroidDeviceSerialNumber">ee0cc712744242d9</value>
      <value type="int" key="AndroidVersion.ApiLevel">30</value>
     </valuemap>
     <valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.0">

+ 1 - 1
q6_felgo_iot/android/AndroidManifest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0"?>
-<manifest package="com.yfkj.cb.Q6iot" xmlns:android="http://schemas.android.com/apk/res/android" xmlns:dist="http://schemas.android.com/apk/distribution" xmlns:tools="http://schemas.android.com/tools" android:installLocation="auto" android:versionCode="130" android:versionName="1.13.49"> android:versionCode=&quot;0&quot; android:versionName=&quot;0&quot;&gt;
+<manifest package="com.yfkj.cb.Q6iot" xmlns:android="http://schemas.android.com/apk/res/android" xmlns:dist="http://schemas.android.com/apk/distribution" xmlns:tools="http://schemas.android.com/tools" android:installLocation="auto" android:versionCode="130" android:versionName="1.13.53"> android:versionCode=&quot;0&quot; android:versionName=&quot;0&quot;&gt;
     <!-- Enable instant app support -->
     <!-- <module dist:instant="true"/> -->
     <application android:allowBackup="true" android:allowNativeHeapPointerTagging="false" android:hardwareAccelerated="true" android:extractNativeLibs="true" android:name="com.felgo.helper.FelgoApplication" android:label="@string/app_name" android:icon="@drawable/ic_launcher" android:theme="@android:style/Theme.NoTitleBar.Fullscreen" android:preserveLegacyExternalStorage="true" android:requestLegacyExternalStorage="true">

+ 31 - 0
q6_felgo_iot/docs/Readme.md

@@ -1,3 +1,34 @@
+## 20260915
+    #define APP_VERSION "1.13.53"
+    1、【修改】视频景深融合效果差:改按"最清晰帧上下邻域"选帧融合,不再全视频等间隔取帧
+       (先定位最清晰帧,再按距其远近依次取 0,-1,+1,-2,+2... 共8帧;远离最清晰帧的帧
+       离焦或处于轴移动过程,混入会明显拉低融合质量)
+    2、【修改】锐化图左上角水印颜色由浅绿色改为红色,字号由2.2增大到3.0(基线由y=40调整到y=50);
+       视频"分析/融合"结果图片同步加同款红色文件名水印
+## 20260915
+    #define APP_VERSION "1.13.52"
+    1、【新增】原始视频流播放界面增加"分析"按钮:遍历视频全部帧,按聚焦综合评分(Laplacian方差
+       +Tenengrad+Brenner,evaluateFocusScore)选出最清晰的一帧,锐化(Unsharp Mask 2.0/3.0)+
+       对比度增强后保存为图片
+    2、【新增】原始视频流播放界面增加"融合"按钮:等间隔抽取8帧做景深(多焦点)融合
+       (OpencvFunc::fuseAdvanced),融合结果同样锐化+对比度增强后保存为图片
+    3、【命名】结果图片保存在视频所在目录,命名与拍照图片一致:<视频时间戳>z0x0_<序号>.jpg
+       (分析结果)与<视频时间戳>z0x0_sharp_<序号>.jpg(融合结果,与同序号分析结果成对),
+       序号在同一视频内自增;处理中显示遮罩与进度提示,完成/失败弹窗提示
+## 20260915
+    #define APP_VERSION "1.13.51"
+    1、【新增】测试维护页新增录制按钮(相机画面右下角,抓图按钮左侧):点击开始把相机画面录制为
+       未压缩原始视频流,再次点击停止并把视频流保存到文件系统(相机打开时创建的归档目录,文件名
+       record_yyyyMMddhhmmss.rawv);C++新增 Q_INVOKABLE Frames::startRecord()/stopRecord()
+       与 recording 属性,录制由取流线程同步写盘(内存占用恒定),停止时回填文件头(帧数/平均帧率)
+    2、【新增】图像查看页(PhotostitcherPage)支持查看播放原始视频流:新增 RawVideoPlayer
+       (Frames 0.1 模块,绑定 VideoOutput.videoSink 逐帧回放),网格中 .rawv 文件显示播放标识,
+       点击后全屏播放,支持播放/暂停/进度显示
+    3、【修复】PhotostitcherPage.qml 缺少 QtMultimedia 导入导致 "VideoOutput is not a type",
+       进而 Main.qml 加载失败(Type PhotostitcherPage unavailable),已补充导入
+    4、【修复】图像查看页识别不到录制文件(.rawv):TreeModel 归档树按 image/* 过滤文件,
+       .rawv 不会出现在树中;loadPositionFolders/loadImages 增加 .rawv 判断,与图片一样作为
+       可查看文件列出,树上单击该节点直接打开播放
 ## 20260905
     #define APP_VERSION "1.13.50"
     1、【修改】锐化图左上角水印字体大小由1.2增大到2.2,线宽由2增大到3

+ 4 - 0
q6_felgo_iot/header/TreeModel.h

@@ -120,6 +120,10 @@ private:
     };
 
     Q_INVOKABLE void loadRootFolders();
+    //判断是否为原始视频流文件(.rawv),归档树中与图片一样作为可查看文件列出
+    static bool isRawVideoFile(const QString &fileName) {
+        return fileName.endsWith(".rawv", Qt::CaseInsensitive);
+    }
     void loadMonths(TreeItem *yearItem, const QModelIndex &parentIndex);
     void loadDays(TreeItem *monthItem, const QModelIndex &parentIndex);
     void loadAlbums(TreeItem *dayItem, const QModelIndex &parentIndex);

+ 108 - 0
q6_felgo_iot/header/cameramanager.h

@@ -26,6 +26,10 @@
 #include <QQuickImageProvider>
 #include <QQmlImageProviderBase>
 #include <QImage>
+#include <QFile>
+#include <QTimer>
+#include <QElapsedTimer>
+#include <QVideoFrame>
 #include <pthread.h>
 //海康
 // #pragma pack(push, 4)
@@ -134,6 +138,7 @@ class Frames :public QObject//, public QQuickImageProvider //QObject  //
     Q_PROPERTY( bool auto_clicked READ auto_clicked WRITE setChange NOTIFY btnStatusChanged )
     Q_PROPERTY( bool camera_sw READ camera_sw WRITE setCameraSw NOTIFY cameraStaChanged )
     Q_PROPERTY(QString cam_ExposureTime READ cam_ExposureTime WRITE setExposureTime NOTIFY exposureTimeChanged)
+    Q_PROPERTY( bool recording READ recording NOTIFY recordingChanged )
 
 public:
     static void registerQmlType();
@@ -167,6 +172,10 @@ public:
     Q_INVOKABLE void captureImage();
     //抓图按钮:模拟MCU拍照指令(camera_tc=1),下一帧按序号保存/锐化/上传
     Q_INVOKABLE void manualCapture();
+    //录制原始(未压缩)视频流:开始录制;停止时回填文件头并把视频流保存到文件系统
+    Q_INVOKABLE bool startRecord();
+    Q_INVOKABLE void stopRecord();
+    bool recording() const { return m_recording; }
     //inline ImageProvider *getImageProvider() { return m_pImgProvider; }
     //ImageProvider* imageProvider() const;
     static void ImageCallBackEx(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser);
@@ -216,6 +225,9 @@ signals:
     void signal_cache_image(const QString &path);
     void signal_sharp_processed(const QString &name_sharp);  //锐化/对比度后台处理完成,回主线程统一入队入库
     void stepCountChanged(const QString step);
+    void recordingChanged();
+    //录制结束,视频流已保存到path
+    void recordFileSaved(const QString &path);
 public slots:
 
     void onMovDone(const QString stepcount){
@@ -251,6 +263,8 @@ private slots:
     void displayFrame(const QVideoFrame &frame);
     void mov_x_z_run();
     void processFrameAsync(const RawFrame& frame);
+    //录制中:把当前未压缩原始帧写入视频流文件(取流线程调用)
+    void writeRecordFrame(const cv::Mat &frame);
 private:
     Q_DISABLE_COPY( Frames )
 
@@ -310,6 +324,18 @@ private:
     //导致取流线程(handleGrab)被挤占、MV_CC_GetImageBuffer 取流超时
     QThreadPool m_sharpPool;
 
+    //原始视频流录制:录制期间由取流线程同步写入(内存占用恒定,不缓存帧),停止时回填文件头
+    bool m_recording = false;
+    QFile *m_recordFile = nullptr;
+    QString m_recordPath;
+    int m_recordWidth = 0;
+    int m_recordHeight = 0;
+    int m_recordStride = 0;
+    int m_recordFrameCount = 0;
+    QElapsedTimer m_recordElapsed;
+    //保护录制状态与文件写入,startRecord/stopRecord(UI线程)与writeRecordFrame(取流线程)互斥
+    mutable QMutex m_recordMutex;
+
     //图片归档路径
     QString picture_path_floader;
     QVector<cv::Mat> m_frame_buffer;
@@ -516,6 +542,88 @@ private:
     }
 
 }; // class Frames
+
+//! 原始视频流(.rawv)播放器:逐帧读取未压缩的原始帧并推送到 QVideoSink 播放
+class RawVideoPlayer : public QObject
+{
+    Q_OBJECT
+    QML_ELEMENT
+    Q_PROPERTY( QVideoSink* videoSink READ videoSink WRITE setVideoSink NOTIFY videoSinkChanged )
+    Q_PROPERTY( bool playing READ playing NOTIFY playingChanged )
+    Q_PROPERTY( bool loaded READ loaded NOTIFY loadedChanged )
+    Q_PROPERTY( int position READ position NOTIFY positionChanged )
+    Q_PROPERTY( int frameCount READ frameCount NOTIFY frameCountChanged )
+    Q_PROPERTY( QString source READ source NOTIFY sourceChanged )
+    Q_PROPERTY( bool busy READ busy NOTIFY busyChanged )
+
+public:
+    explicit RawVideoPlayer(QObject *parent = nullptr);
+
+    QVideoSink* videoSink() const { return m_videoSink; }
+    void setVideoSink(QVideoSink *newVideoSink);
+
+    bool playing() const { return m_playing; }
+    bool loaded() const { return m_loaded; }
+    int position() const { return m_position; }
+    int frameCount() const { return m_frameCount; }
+    QString source() const { return m_source; }
+    bool busy() const { return m_busy; }
+
+    //打开原始视频流文件,成功后可调用 play()
+    Q_INVOKABLE bool open(const QString &path);
+    Q_INVOKABLE void play();
+    //分析:识别视频帧中最清晰的一帧,锐化+对比度增强后保存为图片(与视频同目录)
+    Q_INVOKABLE void analyzeSharpestFrame();
+    //融合:对视频帧做景深融合,锐化+对比度增强后保存为图片(与视频同目录)
+    Q_INVOKABLE void fuseVideoFrames();
+    Q_INVOKABLE void pause();
+    Q_INVOKABLE void stop();
+    //定位到指定帧(立即刷新画面)
+    Q_INVOKABLE void seek(int frameIndex);
+    Q_INVOKABLE void close();
+    //判断文件是否为原始视频流(.rawv)
+    Q_INVOKABLE bool isRawVideo(const QString &path) const;
+
+signals:
+    void videoSinkChanged();
+    void playingChanged();
+    void loadedChanged();
+    void positionChanged();
+    void frameCountChanged();
+    void sourceChanged();
+    void busyChanged();
+    //分析结束:path为空表示失败,成功时图片已保存到path
+    void analyzeFinished(const QString &path);
+    //融合结束:path为空表示失败,成功时图片已保存到path
+    void fuseFinished(const QString &path);
+
+private slots:
+    void onTick();
+
+private:
+    //读取并推送当前帧,失败返回false
+    bool pushFrame();
+    void setBusy(bool busy);
+    //结果图片路径,命名与拍照图片一致:<视频时间戳>z0x0[_sharp]_<序号>.jpg
+    QString resultPath(int serial, bool sharp) const;
+
+    QFile m_file;
+    QTimer m_timer;
+    QVideoSink *m_videoSink = nullptr;
+    QString m_source;
+    int m_width = 0;
+    int m_height = 0;
+    int m_stride = 0;
+    int m_fps = 0;
+    int m_frameCount = 0;
+    int m_position = 0;
+    bool m_loaded = false;
+    bool m_playing = false;
+    //分析/融合任务进行中(进行中时不重复触发)
+    bool m_busy = false;
+    //同一视频内结果序号:分析结果与融合结果成对(_sharp_后缀)
+    int m_resultSerial = 0;
+};
 } /* namespace Qt6QCamera */
 
 Q_DECLARE_METATYPE(cv::Mat)

+ 1 - 1
q6_felgo_iot/header/main.h

@@ -37,7 +37,7 @@
 #include <opencv2/features2d/features2d.hpp>
 #include <opencv2/xfeatures2d/nonfree.hpp>
 
-#define APP_VERSION "1.13.50"
+#define APP_VERSION "1.13.53"
 
 using namespace std;
 

+ 1 - 1
q6_felgo_iot/qml/config.json

@@ -3,6 +3,6 @@
     "identifier": "com.yfkj.cb.Q6iot",
     "orientation": "auto",
     "versioncode": 130,
-    "versionname": "1.13.49",
+    "versionname": "1.13.53",
     "stage": ""
 }

+ 235 - 1
q6_felgo_iot/qml/pages/PhotostitcherPage.qml

@@ -2,8 +2,12 @@ import Felgo
 import QtQuick
 import QtQuick.Controls
 import QtQuick.Layouts
+import QtMultimedia
 import "../controls"
 import "../common"
+
+import Frames 0.1
+
 AppPage {
     id: photoArchivePage
     navigationBarHidden: true
@@ -265,6 +269,191 @@ AppPage {
         fullscreenPopup.open()
     }
 
+    // ===== 原始视频流(.rawv)播放 =====
+    RawVideoPlayer {
+        id: rawPlayer
+        videoSink: videoOutput.videoSink
+    }
+
+    // 分析/融合结果(与视频同目录,命名与拍照图片一致)
+    Connections {
+        target: rawPlayer
+
+        function onAnalyzeFinished(path) {
+            if (path) {
+                console.log("分析完成:", path)
+                nativeUtils.displayMessageBox("提示", "分析完成,已保存:\n" + path.split("/").pop(), 1)
+            } else {
+                console.error("分析失败")
+                nativeUtils.displayMessageBox("提示", "分析失败,请重试!", 1)
+            }
+        }
+
+        function onFuseFinished(path) {
+            if (path) {
+                console.log("融合完成:", path)
+                nativeUtils.displayMessageBox("提示", "融合完成,已保存:\n" + path.split("/").pop(), 1)
+            } else {
+                console.error("融合失败")
+                nativeUtils.displayMessageBox("提示", "融合失败,请重试!", 1)
+            }
+        }
+    }
+
+    // 打开原始视频流文件并开始播放
+    function openVideo(filePath) {
+        console.log("播放原始视频流:", filePath)
+        if (rawPlayer.open(filePath)) {
+            videoPopup.videoTitle = filePath.split("/").pop()
+            videoPopup.open()
+            rawPlayer.play()
+        } else {
+            nativeUtils.displayMessageBox("提示", "无法播放该视频流文件!", 1)
+        }
+    }
+
+    function closeVideo() {
+        rawPlayer.stop()
+        rawPlayer.close()
+        videoPopup.close()
+    }
+
+    Popup {
+        id: videoPopup
+        width: parent.width
+        height: parent.height
+        modal: true
+        closePolicy: Popup.NoAutoClose
+
+        property string videoTitle: ""
+
+        background: Rectangle {
+            color: "#000000"
+        }
+
+        VideoOutput {
+            id: videoOutput
+            anchors.fill: parent
+            anchors.bottomMargin: dp(80)
+            fillMode: VideoOutput.PreserveAspectFit
+        }
+
+        // 标题与播放进度
+        Column {
+            anchors.top: parent.top
+            anchors.topMargin: dp(12)
+            anchors.horizontalCenter: parent.horizontalCenter
+            spacing: dp(4)
+
+            Text {
+                anchors.horizontalCenter: parent.horizontalCenter
+                text: videoPopup.videoTitle
+                color: "white"
+                font.bold: true
+                font.pixelSize: 14
+            }
+
+            Text {
+                anchors.horizontalCenter: parent.horizontalCenter
+                text: rawPlayer.position + " / " + rawPlayer.frameCount + " 帧"
+                color: "#28a779"
+                font.pixelSize: 12
+            }
+        }
+
+        // 播放/暂停 + 分析(最清晰帧) + 融合(景深融合) + 关闭
+        Row {
+            anchors.bottom: parent.bottom
+            anchors.bottomMargin: dp(16)
+            anchors.horizontalCenter: parent.horizontalCenter
+            spacing: dp(16)
+
+            AppButton {
+                text: rawPlayer.playing ? "暂停" : "播放"
+                textColor: "white"
+                backgroundColor: "#28a779"
+                flat: false
+                enabled: !rawPlayer.busy
+                minimumHeight: dp(40)
+                minimumWidth: dp(80)
+                onClicked: {
+                    if (rawPlayer.playing) {
+                        rawPlayer.pause()
+                    } else {
+                        rawPlayer.play()
+                    }
+                }
+            }
+
+            // 分析:识别视频帧中最清晰的一帧,锐化+对比度增强后保存为图片
+            AppButton {
+                text: "分析"
+                textColor: "white"
+                backgroundColor: "#3b82f6"
+                flat: false
+                enabled: !rawPlayer.busy
+                minimumHeight: dp(40)
+                minimumWidth: dp(80)
+                onClicked: {
+                    rawPlayer.pause()
+                    rawPlayer.analyzeSharpestFrame()
+                }
+            }
+
+            // 融合:对视频帧做景深融合,锐化+对比度增强后保存为图片
+            AppButton {
+                text: "融合"
+                textColor: "white"
+                backgroundColor: "#8b5cf6"
+                flat: false
+                enabled: !rawPlayer.busy
+                minimumHeight: dp(40)
+                minimumWidth: dp(80)
+                onClicked: {
+                    rawPlayer.pause()
+                    rawPlayer.fuseVideoFrames()
+                }
+            }
+
+            AppButton {
+                text: "关闭"
+                textColor: "white"
+                backgroundColor: "#e74c3c"
+                flat: false
+                minimumHeight: dp(40)
+                minimumWidth: dp(80)
+                onClicked: closeVideo()
+            }
+        }
+
+        // 分析/融合处理中提示
+        Rectangle {
+            anchors.fill: parent
+            visible: rawPlayer.busy
+            color: "#99000000"
+            z: 10
+
+            Column {
+                anchors.centerIn: parent
+                spacing: dp(10)
+
+                BusyIndicator {
+                    anchors.horizontalCenter: parent.horizontalCenter
+                    running: rawPlayer.busy
+                    width: dp(48)
+                    height: dp(48)
+                }
+
+                Text {
+                    anchors.horizontalCenter: parent.horizontalCenter
+                    text: "正在处理,请稍候..."
+                    color: "white"
+                    font.pixelSize: 15
+                }
+            }
+        }
+    }
+
     // 重置缩放为初始大小并居中
     function resetTransform() {
         image.scale = 1.0
@@ -325,6 +514,9 @@ AppPage {
                 width: imageGridView.cellWidth - 5
                 height: imageGridView.cellHeight - 5
 
+                // 是否为原始视频流文件(.rawv)
+                readonly property bool isVideo: model.filePath ? rawPlayer.isRawVideo(model.filePath) : false
+
                 Rectangle {
                     anchors.fill: parent
                     anchors.margins: 2
@@ -343,7 +535,7 @@ AppPage {
                         sourceSize.height: 200
                         fillMode: Image.PreserveAspectFit
                         cache: true
-                        visible: model.filePath !== ""
+                        visible: model.filePath !== "" && !isVideo
 
                         BusyIndicator {
                             anchors.centerIn: parent
@@ -353,6 +545,37 @@ AppPage {
                         }
                     }
 
+                    // 视频流文件占位:显示播放标识与文件名
+                    Rectangle {
+                        anchors.fill: parent
+                        anchors.margins: 2
+                        visible: isVideo
+                        color: "#1b1b1b"
+                        radius: 3
+
+                        Column {
+                            anchors.centerIn: parent
+                            spacing: 2
+
+                            Text {
+                                anchors.horizontalCenter: parent.horizontalCenter
+                                text: "▶"
+                                color: "#28a779"
+                                font.pixelSize: 20
+                            }
+
+                            Text {
+                                width: imageGridView.cellWidth - 15
+                                anchors.horizontalCenter: parent.horizontalCenter
+                                text: model.filePath ? model.filePath.split("/").pop() : ""
+                                color: "white"
+                                font.pixelSize: 9
+                                elide: Text.ElideMiddle
+                                horizontalAlignment: Text.AlignHCenter
+                            }
+                        }
+                    }
+
                     // 缺图占位提示
                     Text {
                         anchors.centerIn: parent
@@ -406,6 +629,11 @@ AppPage {
                     enabled: model.filePath !== ""
                     onClicked: {
                         if (!model.filePath) return
+                        // 视频流文件直接播放
+                        if (isVideo) {
+                            openVideo(model.filePath)
+                            return
+                        }
                         if (isSelecting) {
                             toggleImageSelection(model.filePath)
                         } else {
@@ -415,6 +643,7 @@ AppPage {
                     }
                     onPressAndHold: {
                         if (!model.filePath) return
+                        if (isVideo) return
                         toggleImageSelection(model.filePath)
                     }
                 }
@@ -497,6 +726,11 @@ AppPage {
                             TapHandler{
                                 onSingleTapped: {
                                     if(root.type===6){
+                                        // 原始视频流文件(.rawv):直接打开播放
+                                        if (rawPlayer.isRawVideo(model.path)) {
+                                            openVideo(model.path)
+                                            return
+                                        }
                                         imageListModel.clear()
                                         imageListModel.append({filePath: model.path})
                                     }else{

+ 53 - 1
q6_felgo_iot/qml/pages/TestPage.qml

@@ -1,4 +1,4 @@
-import QtQuick
+import QtQuick
 import Felgo
 import QtMultimedia
 import QtQuick.Controls
@@ -229,6 +229,15 @@ AppPage {
         }
     }
 
+    // 录制结束:视频流已保存到文件系统
+    Connections {
+        target: frames
+        function onRecordFileSaved(path) {
+            console.log("录制视频流已保存:", path)
+            apptext_res.text = "录制已保存:" + path.split("/").pop()
+        }
+    }
+
     Connections{
         target: serial
         onTakephotodone:{
@@ -481,6 +490,49 @@ AppPage {
                     }
                 }
             }
+
+            // 录制按钮:仅相机打开时显示,画面右下角(抓图按钮左侧)
+            // 点击开始录制原始(未压缩)视频流,再次点击停止并把视频流保存到相机打开时创建的文件夹
+            Rectangle {
+                id: recordBtn
+                visible: frames.camera_sw
+                width: dp(56)
+                height: dp(56)
+                radius: width / 2
+                color: "transparent"
+                border.color: frames.recording ? "#e74c3c" : "#80ffffff"
+                border.width: dp(2)
+                anchors.right: captureBtn.left
+                anchors.bottom: parent.bottom
+                anchors.rightMargin: dp(12)
+                anchors.bottomMargin: dp(12)
+
+                // 未录制:红色圆点(开始);录制中:红色方块(停止)
+                Rectangle {
+                    anchors.centerIn: parent
+                    width: frames.recording ? dp(22) : dp(26)
+                    height: frames.recording ? dp(22) : dp(26)
+                    radius: frames.recording ? dp(3) : width / 2
+                    color: "#e74c3c"
+                }
+
+                MouseArea {
+                    anchors.fill: parent
+                    onClicked: {
+                        if(frames.recording){
+                            console.log("停止录制视频流")
+                            frames.stopRecord()
+                        }else{
+                            console.log("开始录制视频流")
+                            if(frames.startRecord()){
+                                apptext_res.text = "开始录制视频流"
+                            }else{
+                                nativeUtils.displayMessageBox("提示","录制失败,请先打开相机!",1)
+                            }
+                        }
+                    }
+                }
+            }
         }
 
         ScrollView

+ 2 - 2
q6_felgo_iot/src/TreeModel.cpp

@@ -343,7 +343,7 @@ void TreeModel::loadPositionFolders(TreeItem *albumItem, const QModelIndex &pare
             }
         } else {
             QMimeType mime = m_mimeDb.mimeTypeForFile(info);
-            if (mime.name().startsWith("image/")) {
+            if (mime.name().startsWith("image/") || isRawVideoFile(info.fileName())) {
                 directImages.append(info);
             }
         }
@@ -397,7 +397,7 @@ void TreeModel::loadImages(TreeItem *albumItem, const QModelIndex &parentIndex)
     QList<QFileInfo> images;
     for (const QFileInfo &info : entries) {
         QMimeType mime = m_mimeDb.mimeTypeForFile(info);
-        if (mime.name().startsWith("image/")) {
+        if (mime.name().startsWith("image/") || isRawVideoFile(info.fileName())) {
             images.append(info);
         }
     }

+ 558 - 4
q6_felgo_iot/src/cameramanager.cpp

@@ -58,6 +58,179 @@ SenderCustom sender_custom;
 cv::Mat cv_frame;
 
 
+//原始视频流(.rawv)文件格式:未压缩,逐帧顺序存放原始RGBA数据
+//文件头(32字节) + N帧原始帧数据,每帧 stride*height 字节
+namespace {
+
+const int kRawHeaderSize = 32;
+const quint32 kRawVersion = 1;
+
+//写入视频流文件头,frameCount/fps 在录制结束时回填
+void writeRawHeader(QFile *file, int width, int height, int stride, int fps, int frameCount)
+{
+    QByteArray header(kRawHeaderSize, '\0');
+    memcpy(header.data(), "RAWV", 4);
+    auto put = [&header](int offset, quint32 value) {
+        memcpy(header.data() + offset, &value, sizeof(quint32));
+    };
+    put(4, kRawVersion);
+    put(8, static_cast<quint32>(width));
+    put(12, static_cast<quint32>(height));
+    put(16, static_cast<quint32>(stride));
+    put(20, static_cast<quint32>(fps));
+    put(24, static_cast<quint32>(frameCount));
+    if (file->seek(0)) {
+        file->write(header);
+    }
+}
+
+//读取视频流文件头字段
+quint32 readHeaderValue(const QByteArray &header, int offset)
+{
+    quint32 value = 0;
+    memcpy(&value, header.constData() + offset, sizeof(quint32));
+    return value;
+}
+
+//原始视频流的帧元信息(分析与融合的后台任务用,避免跨线程访问播放器成员)
+struct RawVideoMeta {
+    QString path;
+    int width = 0;
+    int height = 0;
+    int stride = 0;
+    int frameCount = 0;
+};
+
+//读取第index帧原始数据为BGRA的cv::Mat
+bool readRawVideoFrame(QFile &file, const RawVideoMeta &meta, int index, cv::Mat &out)
+{
+    const qint64 frameBytes = static_cast<qint64>(meta.stride) * meta.height;
+    if(!file.seek(kRawHeaderSize + frameBytes * index)) return false;
+    const QByteArray buffer = file.read(frameBytes);
+    if(buffer.size() < frameBytes) return false;
+    out.create(meta.height, meta.width, CV_8UC4);
+    const int copyBytes = qMin(meta.stride, meta.width * 4);
+    for(int y = 0; y < meta.height; y++){
+        memcpy(out.ptr(y), buffer.constData() + static_cast<qint64>(y) * meta.stride, copyBytes);
+    }
+    return true;
+}
+
+//遍历全部帧,返回聚焦评分(综合Laplacian方差/Tenengrad/Brenner)最高的帧序号,失败返回-1
+int findSharpestFrameIndex(const RawVideoMeta &meta, OpencvFunc &func)
+{
+    QFile file(meta.path);
+    if(!file.open(QIODevice::ReadOnly)){
+        ERROR("findSharpestFrameIndex: 打开视频流文件失败:{}",meta.path.toStdString());
+        return -1;
+    }
+    int bestIndex = -1;
+    double bestScore = -1.0;
+    cv::Mat frame, small;
+    //降采样后再评分:清晰度是相对量,分辨率降低可大幅减少CPU耗时
+    const cv::Size smallSize(qMax(1, meta.width / 4), qMax(1, meta.height / 4));
+    for(int i = 0; i < meta.frameCount; i++){
+        if(!readRawVideoFrame(file, meta, i, frame)) continue;
+        cv::resize(frame, small, smallSize, 0, 0, cv::INTER_AREA);
+        const double score = func.evaluateFocusScore(small).combinedScore;
+        if(score > bestScore){
+            bestScore = score;
+            bestIndex = i;
+        }
+    }
+    if(bestIndex < 0){
+        ERROR("findSharpestFrameIndex: 未读到有效帧:{}",meta.path.toStdString());
+        return -1;
+    }
+    LOG("findSharpestFrameIndex: 最清晰帧={} 评分={} 总帧数={}",bestIndex,bestScore,meta.frameCount);
+    return bestIndex;
+}
+
+//读取视频中最清晰的一帧
+bool findSharpestFrame(const RawVideoMeta &meta, OpencvFunc &func, cv::Mat &out, int &bestIndex)
+{
+    bestIndex = findSharpestFrameIndex(meta, func);
+    if(bestIndex < 0) return false;
+    QFile file(meta.path);
+    if(!file.open(QIODevice::ReadOnly)) return false;
+    return readRawVideoFrame(file, meta, bestIndex, out);
+}
+
+//融合:以最清晰帧为中心,向上/下邻域取帧做景深(多焦点)融合
+//离最清晰帧越远的帧越离焦(或处于轴移动过程),混入会明显拉低融合质量,故只取最清晰帧邻域
+bool fuseRawVideoFrames(const RawVideoMeta &meta, OpencvFunc &func, cv::Mat &out, int maxFrames)
+{
+    const int center = findSharpestFrameIndex(meta, func);
+    if(center < 0) return false;
+    //按距最清晰帧的远近依次取帧:0,-1,+1,-2,+2...
+    std::vector<int> indices;
+    indices.reserve(maxFrames);
+    indices.push_back(center);
+    for(int d = 1; static_cast<int>(indices.size()) < maxFrames; d++){
+        if(center - d >= 0) indices.push_back(center - d);
+        if(static_cast<int>(indices.size()) >= maxFrames) break;
+        if(center + d < meta.frameCount) indices.push_back(center + d);
+        if(center - d < 0 && center + d >= meta.frameCount) break;
+    }
+    QFile file(meta.path);
+    if(!file.open(QIODevice::ReadOnly)){
+        ERROR("fuseRawVideoFrames: 打开视频流文件失败:{}",meta.path.toStdString());
+        return false;
+    }
+    std::vector<cv::Mat> frames;
+    frames.reserve(indices.size());
+    for(int index : indices){
+        cv::Mat frame, bgr;
+        if(!readRawVideoFrame(file, meta, index, frame)) continue;
+        cv::cvtColor(frame, bgr, cv::COLOR_BGRA2BGR);
+        frames.push_back(bgr);
+    }
+    if(frames.empty()) return false;
+    if(frames.size() == 1){
+        out = frames.front();
+        return true;
+    }
+    LOG("fuseRawVideoFrames: 融合中心帧={} 参与融合帧数={} (总帧数={})",
+        center,(int)frames.size(),meta.frameCount);
+    //outDir传空:融合输入拷贝不再额外落盘,结果由调用方按归档命名保存
+    out = func.fuseAdvanced(frames, QString());
+    return !out.empty();
+}
+
+//结果图片统一后处理:锐化(Unsharp Mask)+对比度增强,与拍照锐化图参数一致
+cv::Mat enhanceResultImage(OpencvFunc &func, const cv::Mat &image)
+{
+    cv::Mat bgr;
+    if(image.channels() == 4) cv::cvtColor(image, bgr, cv::COLOR_BGRA2BGR);
+    else bgr = image;
+    cv::Mat sharp = func.unsharpMask(bgr, 2.0, 3.0);
+    return func.enhanceContrast(sharp, 0);
+}
+
+//保存结果图片(jpg,质量95,与拍照图片一致):左上角红色文件名水印
+bool saveResultImage(const QString &path, const cv::Mat &image)
+{
+    QDir().mkpath(QFileInfo(path).absolutePath());
+    cv::Mat out = image.clone();
+    cv::putText(out,
+                QFileInfo(path).fileName().toStdString(),
+                cv::Point(15, 50),
+                cv::FONT_HERSHEY_SIMPLEX,
+                3.0,        //增大水印字体大小
+                cv::Scalar(0,0,255),  //红色 red
+                3);
+    std::vector<int> params = {cv::IMWRITE_JPEG_QUALITY, 95};
+    if(!cv::imwrite(path.toStdString(), out, params)){
+        ERROR("saveResultImage: 保存失败:{}",path.toStdString());
+        return false;
+    }
+    LOG("saveResultImage: 已保存:{}",path.toStdString());
+    return true;
+}
+
+} // namespace
+
+
 FPSTimer::FPSTimer(QObject *parent) : QObject(parent)
 {
     m_timer = new QTimer(this);
@@ -158,6 +331,21 @@ Frames::Frames(QObject * parent)
 Frames::~Frames()
 {
     qDebug() << "=== Frames Destructor Start ===";
+    // 0. 若仍在录制,回填文件头并关闭视频流文件(析构期间不回发信号,避免触发QML逻辑)
+    if (m_recording) {
+        m_recording = false;
+        if (m_recordFile) {
+            if (m_recordFrameCount > 0) {
+                const qint64 elapsed_ms = m_recordElapsed.elapsed();
+                int fps = elapsed_ms > 0 ? qRound(m_recordFrameCount * 1000.0 / elapsed_ms) : 0;
+                writeRawHeader(m_recordFile, m_recordWidth, m_recordHeight, m_recordStride,
+                               fps > 0 ? fps : 1, m_recordFrameCount);
+            }
+            m_recordFile->close();
+            delete m_recordFile;
+            m_recordFile = nullptr;
+        }
+    }
     // 1. 先停止所有定时器
     if (m_1s && m_1s->isActive()) {
         m_1s->stop();
@@ -497,6 +685,8 @@ Frames::setCameraSw(bool stat_cam)
 #endif
         }
     }else{  //关闭相机
+        //关闭相机前先结束录制,保证已录制的视频流落盘
+        stopRecord();
         if(param::camera_type.contains("qcamera")){
 
         }else if(param::camera_type.contains("uvc")){
@@ -753,13 +943,13 @@ Frames::saveMatAsJpeg(const QVideoFrame &frame){
                 cv::Mat fused_sharp = m_opencvfunc.unsharpMask(image, 2.0, 3.0);
                 //对比度
                 cv::Mat Contrast_Image = m_opencvfunc.enhanceContrast(fused_sharp,0);
-                //左上角水印:浅绿色字体,文字为图片名称(不含目录)
+                //左上角水印:红色字体,文字为图片名称(不含目录)
                 cv::putText(Contrast_Image,
                             QFileInfo(name_sharp).fileName().toStdString(),
-                            cv::Point(15, 40),
+                            cv::Point(15, 50),
                             cv::FONT_HERSHEY_SIMPLEX,
-                            2.2,        //增大水印字体大小
-                            cv::Scalar(144,238,144),  //浅绿色 lightgreen
+                            3.0,        //增大水印字体大小
+                            cv::Scalar(0,0,255),  //红色 red
                             3);
                 std::vector<int> jpegParams = {cv::IMWRITE_JPEG_QUALITY, 95};
                 if (!cv::imwrite(name_sharp.toStdString(), Contrast_Image, jpegParams)) {
@@ -820,6 +1010,10 @@ Frames::processFrameAsync(const RawFrame& frame){
     default:
         return;
     }
+    //录制中:把未压缩的原始帧写入视频流文件(与实时显示使用同一份数据)
+    if (m_recording) {
+        writeRecordFrame(m_frame);
+    }
     QVideoFrameFormat vfmt(
         QSize(m_frame.cols, m_frame.rows),
         QVideoFrameFormat::Format_RGBA8888
@@ -938,6 +1132,7 @@ void
 Frames::registerQmlType()
 {
     qmlRegisterType< Qt6QCamera::Frames > ( "Frames", 0, 1, "Frames" );
+    qmlRegisterType< Qt6QCamera::RawVideoPlayer > ( "Frames", 0, 1, "RawVideoPlayer" );
 }
 
 int
@@ -1078,5 +1273,364 @@ Frames::manualCapture(){
     LOG("manualCapture: 收到抓图指令!");
 }
 
+//*录制按钮:开始录制原始(未压缩)视频流,存放到相机打开时创建的归档目录*/
+bool
+Frames::startRecord(){
+    if(m_recording) return true;
+    if(!camera_sw()){
+        WARN("startRecord: 相机未打开,无法录制!");
+        return false;
+    }
+    if(picture_path_floader.isEmpty()){
+        ERROR("startRecord: 归档目录不存在,无法录制!");
+        return false;
+    }
+    createFolder(picture_path_floader);
+    QString path = picture_path_floader + "/record_" +
+                   QDateTime::currentDateTime().toString("yyyyMMddhhmmss") + ".rawv";
+    QFile *file = new QFile(path);
+    if(!file->open(QIODevice::WriteOnly | QIODevice::Truncate)){
+        ERROR("startRecord: 创建视频流文件失败:{}",path.toStdString());
+        delete file;
+        return false;
+    }
+    //先写入占位文件头,停止录制时回填帧数与帧率
+    writeRawHeader(file, 0, 0, 0, 0, 0);
+    {
+        QMutexLocker locker(&m_recordMutex);
+        m_recordFile = file;
+        m_recordPath = path;
+        m_recordWidth = 0;
+        m_recordHeight = 0;
+        m_recordStride = 0;
+        m_recordFrameCount = 0;
+        m_recordElapsed.start();
+        m_recording = true;
+    }
+    LOG("startRecord: 开始录制原始视频流:{}",path.toStdString());
+    emit recordingChanged();
+    return true;
+}
+
+//*停止录制:回填文件头并关闭文件,视频流保存到文件系统*/
+void
+Frames::stopRecord(){
+    QFile *file = nullptr;
+    QString path;
+    int width = 0, height = 0, stride = 0, frameCount = 0;
+    {
+        QMutexLocker locker(&m_recordMutex);
+        if(!m_recording) return;
+        m_recording = false;
+        file = m_recordFile;
+        m_recordFile = nullptr;
+        path = m_recordPath;
+        width = m_recordWidth;
+        height = m_recordHeight;
+        stride = m_recordStride;
+        frameCount = m_recordFrameCount;
+    }
+    if(file){
+        //写入过程中若因写盘失败被关闭,这里重新打开以便回填文件头
+        if(!file->isOpen()){
+            file->open(QIODevice::ReadWrite);
+        }
+        const qint64 elapsed_ms = m_recordElapsed.elapsed();
+        if(frameCount > 0){
+            //按实际录制时长换算平均帧率,播放时按该帧率回放
+            int fps = elapsed_ms > 0 ? qRound(frameCount * 1000.0 / elapsed_ms) : 0;
+            if(fps <= 0) fps = 1;
+            writeRawHeader(file, width, height, stride, fps, frameCount);
+        }
+        file->close();
+        delete file;
+        //没有录制到任何有效帧时删除空文件
+        if(frameCount <= 0) QFile::remove(path);
+    }
+    LOG("stopRecord: 录制结束,共{}帧,文件:{}",frameCount,path.toStdString());
+    emit recordingChanged();
+    if(frameCount > 0) emit recordFileSaved(path);
+}
+
+//*取流线程:把当前未压缩原始帧写入视频流文件*/
+void
+Frames::writeRecordFrame(const cv::Mat &frame){
+    QMutexLocker locker(&m_recordMutex);
+    if(!m_recording || !m_recordFile || frame.empty() || !frame.isContinuous()) return;
+    const int stride = frame.cols * static_cast<int>(frame.elemSize());
+    if(m_recordWidth == 0){
+        //以第一帧确定录制尺寸
+        m_recordWidth = frame.cols;
+        m_recordHeight = frame.rows;
+        m_recordStride = stride;
+    }
+    //尺寸变化(如分辨率切换)的帧直接跳过,保证文件内每帧大小一致
+    if(frame.cols != m_recordWidth || frame.rows != m_recordHeight) return;
+    //之前写入失败已关闭文件,不再继续尝试
+    if(!m_recordFile->isOpen()) return;
+    const qint64 size = static_cast<qint64>(stride) * frame.rows;
+    if(m_recordFile->write(reinterpret_cast<const char*>(frame.data), size) != size){
+        ERROR("writeRecordFrame: 写入视频流失败,停止写入:{}",m_recordPath.toStdString());
+        m_recordFile->close();
+        return;
+    }
+    m_recordFrameCount++;
+}
+
+
+//
+// RawVideoPlayer
+//
+
+RawVideoPlayer::RawVideoPlayer(QObject *parent)
+    : QObject(parent)
+{
+    m_timer.setTimerType(Qt::PreciseTimer);
+    connect(&m_timer, &QTimer::timeout, this, &RawVideoPlayer::onTick);
+}
+
+void
+RawVideoPlayer::setVideoSink(QVideoSink *newVideoSink)
+{
+    if(m_videoSink == newVideoSink) return;
+    m_videoSink = newVideoSink;
+    emit videoSinkChanged();
+}
+
+bool
+RawVideoPlayer::isRawVideo(const QString &path) const
+{
+    return path.endsWith(".rawv", Qt::CaseInsensitive);
+}
+
+//*打开原始视频流文件,读取文件头并定位到第一帧*/
+bool
+RawVideoPlayer::open(const QString &path)
+{
+    close();
+    m_file.setFileName(path);
+    if(!m_file.open(QIODevice::ReadOnly)){
+        ERROR("RawVideoPlayer: 打开视频流文件失败:{}",path.toStdString());
+        return false;
+    }
+    const QByteArray header = m_file.read(kRawHeaderSize);
+    if(header.size() != kRawHeaderSize || memcmp(header.constData(), "RAWV", 4) != 0){
+        ERROR("RawVideoPlayer: 不是有效的原始视频流文件:{}",path.toStdString());
+        m_file.close();
+        return false;
+    }
+    m_width      = static_cast<int>(readHeaderValue(header, 8));
+    m_height     = static_cast<int>(readHeaderValue(header, 12));
+    m_stride     = static_cast<int>(readHeaderValue(header, 16));
+    m_fps        = static_cast<int>(readHeaderValue(header, 20));
+    m_frameCount = static_cast<int>(readHeaderValue(header, 24));
+    if(m_width <= 0 || m_height <= 0 || m_stride <= 0 || m_frameCount <= 0){
+        ERROR("RawVideoPlayer: 视频流文件内容为空:{}",path.toStdString());
+        m_file.close();
+        return false;
+    }
+    //未记录到有效帧率时按10fps回放
+    if(m_fps <= 0) m_fps = 10;
+    m_timer.setInterval(qMax(1, qRound(1000.0 / m_fps)));
+    m_source = path;
+    m_position = 0;
+    m_loaded = true;
+    emit sourceChanged();
+    emit loadedChanged();
+    emit frameCountChanged();
+    emit positionChanged();
+    LOG("RawVideoPlayer: 打开视频流成功:{} 尺寸:{}x{} 帧数:{} 帧率:{}",
+        path.toStdString(),m_width,m_height,m_frameCount,m_fps);
+    return true;
+}
+
+//*播放:从当前帧开始按录制帧率回放*/
+void
+RawVideoPlayer::play()
+{
+    if(!m_loaded) return;
+    if(m_position >= m_frameCount) seek(0);
+    if(!m_timer.isActive()) m_timer.start();
+    if(!m_playing){
+        m_playing = true;
+        emit playingChanged();
+    }
+}
+
+void
+RawVideoPlayer::pause()
+{
+    if(m_timer.isActive()) m_timer.stop();
+    if(m_playing){
+        m_playing = false;
+        emit playingChanged();
+    }
+}
+
+void
+RawVideoPlayer::stop()
+{
+    pause();
+    seek(0);
+}
+
+//*定位到指定帧并立即刷新画面*/
+void
+RawVideoPlayer::seek(int frameIndex)
+{
+    if(!m_loaded) return;
+    m_position = qBound(0, frameIndex, m_frameCount - 1);
+    const qint64 frameBytes = static_cast<qint64>(m_stride) * m_height;
+    if(m_file.seek(kRawHeaderSize + frameBytes * m_position)){
+        pushFrame();
+    }
+    emit positionChanged();
+}
+
+void
+RawVideoPlayer::close()
+{
+    m_timer.stop();
+    if(m_file.isOpen()) m_file.close();
+    m_loaded = false;
+    m_playing = false;
+    m_source.clear();
+    m_width = 0;
+    m_height = 0;
+    m_stride = 0;
+    m_fps = 0;
+    m_frameCount = 0;
+    m_position = 0;
+    m_resultSerial = 0;
+    emit playingChanged();
+    emit loadedChanged();
+    emit sourceChanged();
+    emit frameCountChanged();
+    emit positionChanged();
+}
+
+void
+RawVideoPlayer::setBusy(bool busy)
+{
+    if(m_busy == busy) return;
+    m_busy = busy;
+    emit busyChanged();
+}
+
+//*结果图片路径:命名与拍照图片一致 <时间戳>z<z>x<x>[_sharp]_<序号>.jpg*/
+QString
+RawVideoPlayer::resultPath(int serial, bool sharp) const
+{
+    const QFileInfo info(m_source);
+    //视频文件名 record_20260915165728.rawv → 时间戳 20260915165728
+    QString ts = info.completeBaseName();
+    const int us = ts.lastIndexOf('_');
+    if(us >= 0) ts = ts.mid(us + 1);
+    //视频不含电机步数,统一以 z0x0 命名
+    return info.absolutePath() + "/" + ts + "z0x0" +
+           (sharp ? "_sharp" : "") + "_" + QString::number(serial) + ".jpg";
+}
+
+//*分析:识别视频帧中最清晰的一帧,锐化+对比度增强后保存为图片*/
+void
+RawVideoPlayer::analyzeSharpestFrame()
+{
+    if(m_busy || !m_loaded) return;
+    //序号在主线程自增,后台任务只使用快照,避免跨线程访问成员
+    const QString outPath = resultPath(++m_resultSerial, false);
+    const RawVideoMeta meta{m_source, m_width, m_height, m_stride, m_frameCount};
+    setBusy(true);
+    LOG("analyzeSharpestFrame: 开始分析最清晰帧:{}",m_source.toStdString());
+    QtConcurrent::run([this, meta, outPath]() {
+        QString result;
+        cv::Mat sharpest;
+        int bestIndex = -1;
+        OpencvFunc func;
+        if(findSharpestFrame(meta, func, sharpest, bestIndex)){
+            if(saveResultImage(outPath, enhanceResultImage(func, sharpest))){
+                result = outPath;
+            }
+        }
+        QMetaObject::invokeMethod(this, [this, result]() {
+            setBusy(false);
+            emit analyzeFinished(result);
+        }, Qt::QueuedConnection);
+    });
+}
+
+//*融合:对视频帧做景深融合,锐化+对比度增强后保存为图片*/
+void
+RawVideoPlayer::fuseVideoFrames()
+{
+    if(m_busy || !m_loaded) return;
+    //融合结果与最近一次分析结果成对(_sharp_后缀,便于与原图对比);
+    //若该序号已存在则另开一组,避免覆盖
+    int serial = m_resultSerial > 0 ? m_resultSerial : ++m_resultSerial;
+    QString outPath = resultPath(serial, true);
+    while(QFile::exists(outPath)){
+        serial = ++m_resultSerial;
+        outPath = resultPath(serial, true);
+    }
+    const RawVideoMeta meta{m_source, m_width, m_height, m_stride, m_frameCount};
+    setBusy(true);
+    LOG("fuseVideoFrames: 开始景深融合:{}",m_source.toStdString());
+    QtConcurrent::run([this, meta, outPath]() {
+        QString result;
+        cv::Mat fused;
+        OpencvFunc func;
+        //等间隔抽取帧参与融合:帧数过多时内存与耗时增长明显,取8帧覆盖焦面
+        if(fuseRawVideoFrames(meta, func, fused, 8)){
+            if(saveResultImage(outPath, enhanceResultImage(func, fused))){
+                result = outPath;
+            }
+        }
+        QMetaObject::invokeMethod(this, [this, result]() {
+            setBusy(false);
+            emit fuseFinished(result);
+        }, Qt::QueuedConnection);
+    });
+}
+
+void
+RawVideoPlayer::onTick()
+{
+    if(!m_loaded) return;
+    if(m_position >= m_frameCount){
+        //播放到文件末尾,停在最后一帧
+        pause();
+        return;
+    }
+    if(!pushFrame()){
+        ERROR("RawVideoPlayer: 读取视频流帧失败,停止播放:{}",m_source.toStdString());
+        pause();
+        return;
+    }
+    m_position++;
+    emit positionChanged();
+}
+
+//*读取当前帧并推送到QVideoSink显示*/
+bool
+RawVideoPlayer::pushFrame()
+{
+    if(!m_file.isOpen()) return false;
+    const qint64 frameBytes = static_cast<qint64>(m_stride) * m_height;
+    const QByteArray buffer = m_file.read(frameBytes);
+    if(buffer.size() < frameBytes) return false;
+    if(!m_videoSink) return true;   //没有绑定显示sink时只推进帧序号
+    QVideoFrameFormat vfmt(QSize(m_width, m_height), QVideoFrameFormat::Format_RGBA8888);
+    QVideoFrame frame(vfmt);
+    if(!frame.map(QVideoFrame::WriteOnly)) return false;
+    const int dstStride = frame.bytesPerLine(0);
+    for(int y = 0; y < m_height; y++){
+        memcpy(frame.bits(0) + static_cast<qint64>(y) * dstStride,
+               buffer.constData() + static_cast<qint64>(y) * m_stride,
+               qMin(m_stride, dstStride));
+    }
+    frame.unmap();
+    m_videoSink->setVideoFrame(frame);
+    return true;
+}
+
 
 } /* namespace Qt6QCamera */