#define _CRT_SECURE_NO_WARNINGS
#include <stdio
.h>
#include <Windows
.h>
#include <process
.h>
#include <conio
.h>
#include <thread>
#include <atomic>
#include <mutex>
#include <string>
#include <
chrono>
#include <vector>
#include <queue>
#include <condition_variable>
// OpenCV
#include <opencv2/opencv
.hpp>
// 海康 SDK
#include "MvCameraControl
.h"
#pragma comment
(lib, "MvCameraControl
.lib"
)
#pragma comment
(lib, "opencv_world
480
.lib"
) // 修改为你的版本
//
==================== 配置参数
====================
const char* const DESKTOP_TEST_DIR
= "C
:\\Users\\guolin12\\Desktop\\test";
const double RECORD_
DURATION_
SECONDS = 10
.0; // 想录几秒？
const size_t MAX_QUEUE_SIZE
= 30; // 最大队列长度（防内存溢出）
//
========================================
// 图像数据结构
//
========================================
struct ImageFrame
{
std
::vector<uint
8_t> data;
MV_FRAME_OUT_INFO_EX info;
std
::chrono::steady_clock
::time_point timestamp; // 用于调试时间间隔
};
//
========================================
// 全局
变量
//
========================================
std
::atomic<bool> g_bExit
(false
);
std
::atomic<bool> g_b
IsRecording
(false
);
std
::mutex g_queueMutex;
std
::queue<ImageFrame> g_frameQueue;
std
::condition_variable g_cvQueue;
int g_width
= 0, g_height
= 0;
float g_fps
= 25
.0f; // 将从设备读取实际值
// 获取临时路径
std
::string GetTempPathStr
()
{
char path[MAX_PATH]
= { 0 };
GetTempPathA
(MAX_PATH, path
);
return std
::string
(path
);
}
bool CreateDirectoryRecursive
(const std
::string& dir
)
{
if
(CreateDirectoryA
(dir
.c_str
(), nullptr
) || GetLastError
() == ERROR_ALREADY_EX
ISTS
)
return true;
size_t pos
= dir
.find_last_of
("\\/"
);
if
(pos !
= std
::string
::npos
)
{
std
::string parent
= dir
.substr
(0, pos
);
if
(CreateDirectoryRecursive
(parent
))
{
return CreateDirectoryA
(dir
.c_str
(), nullptr
) || GetLastError
() == ERROR_ALREADY_EX
ISTS;
}
}
return false;
}
bool
IsDirectoryWritable
(const std
::string& dir
)
{
if
(!CreateDirectoryRecursive
(dir
)) return false;
std
::string testFile
= dir + "\\__test_write__
.tmp";
FILE* f
= nullptr;
errno_t err
= fopen_s
(&f, testFile
.c_str
(), "w"
);
if
(err
== 0 && f
)
{
fclose
(f
);
DeleteFileA
(testFile
.c_str
());
return true;
}
return false;
}
std
::string GetOutputDirectory
()
{
std
::string target
(DESKTOP_TEST_DIR
);
if
(IsDirectoryWritable
(target
))
{
printf
("✅ Using output directory
: %s\n", target
.c_str
());
return target;
}
else
{
printf
("❌ Cannot write to %s\n", target
.c_str
());
std
::string temp
= GetTempPathStr
();
if
(IsDirectoryWritable
(temp
))
{
printf
("💡 Falling back to
: %s\n", temp
.c_str
());
return temp;
}
printf
("❌ All paths unwritable!\n"
);
return "";
}
}
void PrintDeviceInfo
(MV_CC_DEVICE_INFO* pstDevInfo
)
{
if
(pstDevInfo->nTLayerType
== MV_GIGE_DEVICE
)
{
unsigned int ip
= pstDevInfo->SpecialInfo
.stGigEInfo
.nCurrentIp;
printf
("IP
: %d
.%d
.%d
.%d\n",
(ip >> 2
4) & 0xFF,
(ip >> 16
) & 0xFF,
(ip >>
8) & 0xFF, ip & 0xFF
);
printf
("Model
: %s\n", pstDevInfo->SpecialInfo
.stGigEInfo
.chModelName
);
}
else if
(pstDevInfo->nTLayerType
== MV_USB_DEVICE
)
{
printf
("Model
: %s\n", pstDevInfo->SpecialInfo
.stUsb3VInfo
.chModelName
);
printf
("Serial
: %s\n", pstDevInfo->SpecialInfo
.stUsb3VInfo
.chSerialNumber
);
}
}
int SetMono
8Format
(void* handle
)
{
int nRet
= MV_CC_SetEnumValue
(handle, "PixelFormat", PixelType_G
vsp_Mono
8);
if
(nRet !
= MV_OK
)
{
printf
("❌ Failed to set PixelFormat to Mono
8! [0x%x]\n", nRet
);
return nRet;
}
printf
("✅ Pixel format set to Mono
8.\n"
);
return MV_OK;
}
bool AlignImageSize
(void* handle, int& width, int& height
)
{
MVCC_INTVALUE stValue
= { 0 };
if
(MV_CC_GetIntValue
(handle, "Width", &stValue
) !
= MV_OK
)
{
printf
("❌ Failed to get Width\n"
);
return false;
}
width
= (stValue
.nCurValue / 32
) * 32;
MV_CC_SetIntValue
(handle, "Width", width
);
printf
("🔧 Set Width to %d\n", width
);
if
(MV_CC_GetIntValue
(handle, "Height", &stValue
) !
= MV_OK
)
{
printf
("❌ Failed to get Height\n"
);
return false;
}
height
= (stValue
.nCurValue / 2
) * 2;
MV_CC_SetIntValue
(handle, "Height", height
);
printf
("🔧 Set Height to %d\n", height
);
return true;
}
// ✅ 修改：传入真实帧率作为输出 fps
void RecordFromQueue
(const std
::string& filePath, int width, int height, int targetFrameCount, float outputFps
)
{
printf
("🎥 Recording started
: %s\n", filePath
.c_str
());
printf
("🎯 Target frames
: %d, Output FPS
: %
.3f →
Duration: %
.2f sec\n",
targetFrameCount, outputFps, targetFrameCount / outputFps
);
// ✅ 关键修改：使用真实帧率！
cv
::VideoWriter writer
(filePath, cv
::VideoWriter
::fourcc
('M', 'J', 'P', 'G'
), outputFps,
cv
::Size
(width, height
), true
);
if
(!writer
.isOpened
())
{
printf
("❌ Failed to open VideoWriter
: %s\n", filePath
.c_str
());
g_b
IsRecording
= false;
return;
}
int recorded
= 0;
auto start
= std
::chrono::steady_clock
::now
();
try
{
while
(g_b
IsRecording && !g_bExit && recorded < targetFrameCount
)
{
std
::unique_lock<std
::mutex> lock
(g_queueMutex
);
auto timeout
= std
::chrono::steady_clock
::now
() + std
::chrono::seconds(3
); // 更长等待时间
if
(g_frameQueue
.empty
())
{
if
(g_cvQueue
.wait_until
(lock, timeout
) == std
::cv_status
::timeout
)
{
printf
("📹 Timeout waiting for frame during recording
.\n"
);
break;
}
}
if
(!g_frameQueue
.empty
())
{
ImageFrame frame
= std
::move
(g_frameQueue
.front
());
g_frameQueue
.pop
();
lock
.unlock
(); // 尽早释放锁
if
(frame
.info
.enPixelType
== PixelType_G
vsp_Mono
8)
{
cv
::Mat gray
(frame
.info
.nHeight, frame
.info
.nWidth, CV_
8UC1, frame
.data
.data
());
cv
::Mat bgr;
cv
::cvtColor
(gray, bgr, cv
::COLOR_GRAY2BGR
);
writer
.write
(bgr
);
recorded++;
}
}
}
}
catch
(const std
::exception& e
)
{
printf
("❌ Exception during recording
: %s\n", e
.what
());
}
catch
(...)
{
printf
("❌ Unknown error during recording
.\n"
);
}
writer
.release
();
auto
durationMs
= std
::chrono::duration_cast<std
::chrono::mill
iseconds>
(
std
::chrono::steady_clock
::now
() - start
).count
();
printf
("⏹️ Saved video
: %s\n", filePath
.c_str
());
printf
("📊 Wrote %d frames at %
.3f FPS → Play time
: %
.2f sec\n",
recorded, outputFps, recorded / outputFps
);
printf
("⏱️ Actual process time
: %
.3f sec\n",
durationMs / 1000
.0
);
g_b
IsRecording
= false;
}
// 主工作线程：唯一调用 GetImageBuffer 的地方
unsigned int __stdcall WorkThread
(void* pUser
)
{
void* handle
= pUser;
cv
::namedWindow
("Live View", cv
::WINDOW_AUTOSIZE
);
MV_FRAME_OUT stImageInfo
= { 0 };
int nRet
= MV_OK;
// 初始化分辨率和帧率
AlignImageSize
(handle, g_width, g_height
);
MVCC_FLOATVALUE stFloat
= { 0 };
if
(MV_CC_GetFloatValue
(handle, "ResultingFrameRate", &stFloat
) == MV_OK
)
{
g_fps
= stFloat
.fCurValue;
printf
("🎯 Actual Camera FPS
: %
.3f\n", g_fps
);
}
else
{
printf
("⚠️ Could not get FPS, using default %
.2f\n", g_fps
);
}
std
::string outputDir
= GetOutputDirectory
();
while
(!g_bExit
)
{
nRet
= MV_CC_GetImageBuffer
(handle, &stImageInfo, 1000
);
if
(nRet
== MV_OK
)
{
MV_FRAME_OUT_INFO_EX* pInfo
= &stImageInfo
.stFrameInfo;
// 👉 统一拷贝图像数据
std
::vector<uint
8_t> imgData
(stImageInfo
.pBufAddr,
stImageInfo
.pBufAddr + pInfo->nFrameLen
);
// 显示处理
cv
::Mat gray
(pInfo->nHeight, pInfo->nWidth, CV_
8UC1, imgData
.data
());
cv
::Mat bgr;
cv
::cvtColor
(gray, bgr, cv
::COLOR_GRAY2BGR
);
std
::string status
= g_b
IsRecording ? "🔴 RECORDING
..."
: "✅ LIVE STREAM";
cv
::putText
(bgr, status, cv
::Point
(20,
40
),
cv
::FONT_HERSHEY_SIMPLEX, 1
.0,
cv
::Scalar
(0, 255, 0
), 2
);
cv
::imshow
("Live View", bgr
);
int key
= cv
::waitKey
(1
);
if
(key
== 27 || key
== 'q' || key
== 'Q'
)
{
g_bExit
= true;
}
else if
((key
== 'r' || key
== 'R'
) && !g_b
IsRecording
)
{
if
(outputDir
.empty
())
{
printf
("❌ No valid output directory!\n"
);
}
else
{
g_b
IsRecording
= true;
// ✅ 使用真实帧率计算目标帧数
int targetFrameCount
= static_cast<int>
(RECORD_
DURATION_
SECONDS * g_fps
);
printf
("🎯 Start recording
: %
.3f FPS × %
.1f sec
= %d frames\n",
g_fps, RECORD_
DURATION_
SECONDS, targetFrameCount
);
// 生成文件名（含毫秒）
auto now
= std
::chrono::system_clock
::now
();
auto ms
= std
::chrono::duration_cast<std
::chrono::mill
iseconds>
(now
.time_since_epoch
()) % 1000;
std
::time_t t
= std
::chrono::system_clock
::to_time_t
(now
);
struct tm tm;
localtime_s
(&tm, &t
);
char filePath[512];
sprintf_s
(filePath, "%s\\rec_%0
4d%02d%02d_%02d%02d%02d_%03dms
.avi",
outputDir
.c_str
(),
tm
.tm_year + 1900, tm
.tm_mon + 1, tm
.tm_mday,
tm
.tm_hour, tm
.tm_min, tm
.tm_sec,
(int
)ms
.count
());
// 启动录像线程，传入真实帧率
try
{
std
::thread t
(RecordFromQueue,
std
::string
(filePath
),
g_width, g_height,
targetFrameCount,
g_fps
); // ✅ 把真实帧率传进去
t
.detach
();
}
catch
(const std
::exception& e
)
{
printf
("❌ Failed to start thread
: %s\n", e
.what
());
g_b
IsRecording
= false;
}
}
}
// 👉 如果正在录像，则入队
if
(g_b
IsRecording
)
{
std
::lock_guard<std
::mutex> lock
(g_queueMutex
);
// 控制队列大小，防止内存暴涨
while
(g_frameQueue
.size
() >
= MAX_QUEUE_SIZE
)
{
g_frameQueue
.pop
();
}
ImageFrame frame;
frame
.data
= std
::move
(imgData
);
frame
.info
= *pInfo;
frame
.timestamp
= std
::chrono::steady_clock
::now
();
g_frameQueue
.push
(std
::move
(frame
));
g_cvQueue
.notify_one
(); // 唤醒录像线程
}
// ✅ 必须释放缓冲区
MV_CC_FreeImageBuffer
(handle, &stImageInfo
);
}
else
{
printf
("⚠️ Timeout getting frame from camera
.\n"
);
}
}
// 结束前通知所有等待线程退出
{
std
::lock_guard<std
::mutex> lock
(g_queueMutex
);
g_b
IsRecording
= false;
}
g_cvQueue
.notify_all
();
cv
::destroyAllWindows
();
return 0;
}
// 主函数
int main
()
{
int nRet
= MV_OK;
void* handle
= nullptr;
HANDLE hThread
= nullptr;
do {
nRet
= MV_CC_Initialize
();
if
(nRet !
= MV_OK
)
{
printf
("❌ Initialize SDK failed! [0x%x]\n", nRet
);
break;
}
MV_CC_DEVICE_INFO_L
IST stDevL
ist
= { 0 };
nRet
= MV_CC_EnumDevices
(MV_GIGE_DEVICE | MV_USB_DEVICE, &stDevL
ist
);
if
(nRet !
= MV_OK || stDevL
ist
.nDeviceNum
== 0
)
{
printf
("❌ No devices found! [0x%x]\n", nRet
);
break;
}
printf
("✅ Found %d device
(s
):\n", stDevL
ist
.nDeviceNum
);
for
(unsigned int i
= 0; i < stDevL
ist
.nDeviceNum; ++i
)
{
printf
(" [%d]
: ", i
);
PrintDeviceInfo
(stDevL
ist
.pDeviceInfo[i]
);
}
unsigned int index
= 0;
printf
("👉 Input camera index
(0-%d
): ", stDevL
ist
.nDeviceNum - 1
);
scanf_s
("%d", &index
);
if
(index >
= stDevL
ist
.nDeviceNum
)
{
printf
("❌ Invalid index!\n"
);
break;
}
nRet
= MV_CC_CreateHandle
(&handle, stDevL
ist
.pDeviceInfo[index]
);
if
(nRet !
= MV_OK
)
{
printf
("❌ CreateHandle failed! [0x%x]\n", nRet
);
break;
}
nRet
= MV_CC_OpenDevice
(handle
);
if
(nRet !
= MV_OK
)
{
printf
("❌ OpenDevice failed! [0x%x]\n", nRet
);
break;
}
if
(stDevL
ist
.pDeviceInfo[index]->nTLayerType
== MV_GIGE_DEVICE
)
{
int packetSize
= MV_CC_GetOptimalPacketSize
(handle
);
if
(packetSize > 0
)
{
MV_CC_SetIntValueEx
(handle, "Ge
vSCPSPacketSize", packetSize
);
}
}
MV_CC_SetEnumValue
(handle, "TriggerMode", 0
);
if
(SetMono
8Format
(handle
) !
= MV_OK
) break;
nRet
= MV_CC_StartGrabbing
(handle
);
if
(nRet !
= MV_OK
)
{
printf
("❌ StartGrabbing failed! [0x%x]\n", nRet
);
break;
}
unsigned int threadId
= 0;
hThread
= (HANDLE
)_beginthreadex
(nullptr, 0, WorkThread, handle, 0, &threadId
);
if
(!hThread
)
{
printf
("❌ Failed to create work thread!\n"
);
break;
}
printf
("\n📌 Instructions
:\n"
);
printf
(" ➡ Press 'R' to record %
.1f
seconds video\n", RECORD_
DURATION_
SECONDS);
printf
(" ➡ Live preview will NOT freeze!\n"
);
printf
(" ➡ Output FPS matches actual camera FPS\n"
);
printf
(" ➡ File name includes mill
iseconds to avoid overwrite\n"
);
printf
(" ➡ Press 'Q' or ESC to exit\n\n"
);
while
(!g_bExit
)
{
Sleep
(100
);
}
} while
(false
);
// 清理资源
g_bExit
= true;
if
(hThread
)
{
WaitForSingleObject
(hThread, 5000
);
CloseHandle
(hThread
);
}
if
(handle
)
{
MV_CC_StopGrabbing
(handle
);
MV_CC_CloseDevice
(handle
);
MV_CC_DestroyHandle
(handle
);
}
MV_CC_Finalize
();
printf
("👋 Program exited
. Press any key to close
.\n"
);
_getch
();
return 0;
}
无法打开#include <opencv2/opencv
.hpp>
扫一扫
191
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
