919 lines
26 KiB
C++
919 lines
26 KiB
C++
#include "SingleLensReflexCameraWindow.h"
|
||
#include <QMessageBox>
|
||
#include <QCoreApplication>
|
||
#include <QBuffer>
|
||
|
||
// 全局变量用于回调函数访问
|
||
static SingleLensReflexCameraOperation* g_cameraOperation = nullptr;
|
||
|
||
SingleLensReflexCameraWindow::SingleLensReflexCameraWindow(QWidget* parent)
|
||
: QDialog(parent)
|
||
, m_isCapturing(false)
|
||
{
|
||
ui.setupUi(this);
|
||
|
||
m_SLRCameraThread = new QThread();
|
||
m_SingleLensReflexCameraOperation = new SingleLensReflexCameraOperation();
|
||
m_SingleLensReflexCameraOperation->moveToThread(m_SLRCameraThread);
|
||
m_SLRCameraThread->start();
|
||
|
||
// 基本连接
|
||
connect(ui.openSLRCamera_btn, &QPushButton::clicked, this, &SingleLensReflexCameraWindow::openSLRCamera);
|
||
connect(this, &SingleLensReflexCameraWindow::openSLRCameraSignal, m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::OpenSLRCamera);
|
||
connect(ui.closeSLRCamera_btn, &QPushButton::clicked, this, &SingleLensReflexCameraWindow::closeSLRCamera);
|
||
connect(this, &SingleLensReflexCameraWindow::closeSLRCameraSignal, m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::CloseSLRCamera);
|
||
|
||
connect(ui.takePhoto_btn, &QPushButton::clicked, this, &SingleLensReflexCameraWindow::takePhoto);
|
||
connect(this, &SingleLensReflexCameraWindow::takePhotoSignal, m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::takePhoto);
|
||
connect(ui.stopTakePhoto_btn, &QPushButton::clicked, this, &SingleLensReflexCameraWindow::stopTakePhoto);
|
||
connect(this, &SingleLensReflexCameraWindow::stopTakePhotoSignal, m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::stopTakePhoto);
|
||
|
||
connect(m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::CamOpenedSignal, this, &SingleLensReflexCameraWindow::onCamOpened);
|
||
connect(m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::CamClosedSignal, this, &SingleLensReflexCameraWindow::onCamClosed);
|
||
|
||
connect(m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::PlotSignal, this, &SingleLensReflexCameraWindow::PlotSLRImageSignal);
|
||
connect(m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::CamClosedSignal, this, &SingleLensReflexCameraWindow::SLRCamClosedSignal);
|
||
|
||
connect(this->ui.dataFolderBtn, SIGNAL(clicked()), this, SLOT(onSelectDataFolder()));
|
||
|
||
// 新增信号连接
|
||
connect(m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::ImageCapturedSignal, this, &SingleLensReflexCameraWindow::onImageCaptured);
|
||
connect(m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::ErrorSignal, this, &SingleLensReflexCameraWindow::onError);
|
||
|
||
// 实时取景信号连接
|
||
connect(m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::LiveViewImageReady, this, &SingleLensReflexCameraWindow::LiveViewImageReady, Qt::QueuedConnection);
|
||
connect(m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::LiveViewStarted, this, &SingleLensReflexCameraWindow::LiveViewStarted);
|
||
connect(m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::LiveViewStopped, this, &SingleLensReflexCameraWindow::LiveViewStopped);
|
||
|
||
// 拍照状态信号连接
|
||
connect(m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::CaptureStartedSignal, this, &SingleLensReflexCameraWindow::onCaptureStarted);
|
||
connect(m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::CaptureStoppedSignal, this, &SingleLensReflexCameraWindow::onCaptureStopped);
|
||
|
||
// 拍照控制信号连接
|
||
connect(this, &SingleLensReflexCameraWindow::startCaptureSignal, m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::startCapture);
|
||
connect(this, &SingleLensReflexCameraWindow::stopCaptureSignal, m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::stopCapture);
|
||
connect(this, &SingleLensReflexCameraWindow::captureOnceSignal, m_SingleLensReflexCameraOperation, &SingleLensReflexCameraOperation::captureOnce);
|
||
|
||
// 初始化按钮状态
|
||
ui.closeSLRCamera_btn->setEnabled(false);
|
||
|
||
// 初始化数据保存路径显示（从 AppSettings 恢复或使用默认）
|
||
ui.dataFolderLineEdit->setText(AppSettings::instance().slrDataFolder());
|
||
}
|
||
|
||
SingleLensReflexCameraWindow::~SingleLensReflexCameraWindow()
|
||
{
|
||
// 先停止拍照
|
||
if (m_SingleLensReflexCameraOperation->getRecordStatus())
|
||
{
|
||
m_SingleLensReflexCameraOperation->CloseSLRCamera();
|
||
}
|
||
|
||
m_SLRCameraThread->quit();
|
||
m_SLRCameraThread->wait();
|
||
delete m_SingleLensReflexCameraOperation;
|
||
m_SingleLensReflexCameraOperation = nullptr;
|
||
}
|
||
|
||
void SingleLensReflexCameraWindow::onSelectDataFolder()
|
||
{
|
||
QString dir = QFileDialog::getExistingDirectory(this,
|
||
QString::fromLocal8Bit("选择数据保存路径"),
|
||
ui.dataFolderLineEdit->text());
|
||
|
||
if (!dir.isEmpty())
|
||
{
|
||
ui.dataFolderLineEdit->setText(dir);
|
||
|
||
m_SingleLensReflexCameraOperation->setSavePath(dir);
|
||
|
||
// 保存路径到 AppSettings
|
||
AppSettings::instance().setSlrDataFolder(dir);
|
||
}
|
||
}
|
||
|
||
void SingleLensReflexCameraWindow::openSLRCamera()
|
||
{
|
||
if (!m_SingleLensReflexCameraOperation->getRecordStatus())
|
||
{
|
||
emit openSLRCameraSignal();
|
||
}
|
||
}
|
||
|
||
void SingleLensReflexCameraWindow::takePhoto()
|
||
{
|
||
if (m_SingleLensReflexCameraOperation->getRecordStatus())
|
||
{
|
||
emit takePhotoSignal();
|
||
}
|
||
}
|
||
|
||
void SingleLensReflexCameraWindow::stopTakePhoto()
|
||
{
|
||
if (m_SingleLensReflexCameraOperation->getRecordStatus())
|
||
{
|
||
emit stopTakePhotoSignal();
|
||
}
|
||
}
|
||
|
||
void SingleLensReflexCameraWindow::onCamOpened()
|
||
{
|
||
ui.openSLRCamera_btn->setEnabled(false);
|
||
ui.closeSLRCamera_btn->setEnabled(true);
|
||
ui.openSLRCamera_btn->setText(QString::fromLocal8Bit("已打开"));
|
||
}
|
||
|
||
void SingleLensReflexCameraWindow::closeSLRCamera()
|
||
{
|
||
emit closeSLRCameraSignal();
|
||
//m_SingleLensReflexCameraOperation->CloseSLRCamera();
|
||
}
|
||
|
||
void SingleLensReflexCameraWindow::onCamClosed()
|
||
{
|
||
ui.openSLRCamera_btn->setEnabled(true);
|
||
ui.closeSLRCamera_btn->setEnabled(false);
|
||
ui.openSLRCamera_btn->setText(QString::fromLocal8Bit("打 开"));
|
||
m_isCapturing = false;
|
||
}
|
||
|
||
void SingleLensReflexCameraWindow::onCaptureStarted()
|
||
{
|
||
ui.takePhoto_btn->setEnabled(false);
|
||
ui.stopTakePhoto_btn->setEnabled(true);
|
||
|
||
m_btnOldText = ui.takePhoto_btn->text();
|
||
ui.takePhoto_btn->setText(QString::fromLocal8Bit("采集中"));
|
||
}
|
||
|
||
void SingleLensReflexCameraWindow::onCaptureStopped()
|
||
{
|
||
ui.takePhoto_btn->setEnabled(true);
|
||
ui.stopTakePhoto_btn->setEnabled(false);
|
||
ui.takePhoto_btn->setText(m_btnOldText);
|
||
}
|
||
|
||
void SingleLensReflexCameraWindow::onImageCaptured(const QString& filePath)
|
||
{
|
||
std::cout << "Image captured: " << filePath.toStdString() << std::endl;
|
||
// 可以在这里更新UI显示最新拍摄的图片
|
||
}
|
||
|
||
void SingleLensReflexCameraWindow::onError(const QString& errorMsg)
|
||
{
|
||
QMessageBox::warning(this, QString::fromLocal8Bit("相机错误"), errorMsg);
|
||
}
|
||
|
||
void SingleLensReflexCameraWindow::onStartCapture()
|
||
{
|
||
if (!m_isCapturing)
|
||
{
|
||
m_isCapturing = true;
|
||
emit startCaptureSignal();
|
||
}
|
||
}
|
||
|
||
void SingleLensReflexCameraWindow::onStopCapture()
|
||
{
|
||
if (m_isCapturing)
|
||
{
|
||
m_isCapturing = false;
|
||
emit stopCaptureSignal();
|
||
}
|
||
}
|
||
|
||
void SingleLensReflexCameraWindow::onCaptureOnce()
|
||
{
|
||
emit captureOnceSignal();
|
||
}
|
||
|
||
//-------------------------------------------------------------------------------------------------------------------------------
|
||
// SingleLensReflexCameraOperation 实现
|
||
//-------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
SingleLensReflexCameraOperation::SingleLensReflexCameraOperation()
|
||
{
|
||
m_func = nullptr;
|
||
m_isRecord = false;
|
||
m_camera = nullptr;
|
||
m_isSDKInitialized = false;
|
||
m_isSessionOpen = false;
|
||
m_isLiveViewActive = false;
|
||
m_imageCounter = 0;
|
||
|
||
// 设置保存路径（从 AppSettings 获取，如果为空则使用默认的 CapturedImages 目录）
|
||
m_savePath = AppSettings::instance().slrDataFolder();
|
||
|
||
// 创建保存目录
|
||
QDir dir;
|
||
if (!dir.exists(m_savePath))
|
||
{
|
||
dir.mkpath(m_savePath);
|
||
}
|
||
|
||
// 创建定时器
|
||
m_captureTimer = new QTimer(this);
|
||
connect(m_captureTimer, &QTimer::timeout, this, &SingleLensReflexCameraOperation::onCaptureTimer);
|
||
|
||
m_liveViewTimer = new QTimer(this);
|
||
connect(m_liveViewTimer, &QTimer::timeout, this, &SingleLensReflexCameraOperation::onLiveViewTimer);
|
||
|
||
g_cameraOperation = this;
|
||
}
|
||
|
||
SingleLensReflexCameraOperation::~SingleLensReflexCameraOperation()
|
||
{
|
||
if (m_isRecord)
|
||
{
|
||
CloseSLRCamera();
|
||
}
|
||
g_cameraOperation = nullptr;
|
||
|
||
// 销毁定时器
|
||
if (m_captureTimer)
|
||
{
|
||
m_captureTimer->stop();
|
||
m_captureTimer->deleteLater();
|
||
m_captureTimer = nullptr;
|
||
}
|
||
if (m_liveViewTimer)
|
||
{
|
||
m_liveViewTimer->stop();
|
||
m_liveViewTimer->deleteLater();
|
||
m_liveViewTimer = nullptr;
|
||
}
|
||
}
|
||
|
||
void SingleLensReflexCameraOperation::setSavePath(const QString& path)
|
||
{
|
||
m_savePath = path;
|
||
if (!m_savePath.endsWith('/') && !m_savePath.endsWith('\\'))
|
||
{
|
||
m_savePath += '/';
|
||
}
|
||
|
||
QDir dir;
|
||
if (!dir.exists(m_savePath))
|
||
{
|
||
dir.mkpath(m_savePath);
|
||
}
|
||
}
|
||
|
||
QImage SingleLensReflexCameraOperation::getCurrentLiveViewImage()
|
||
{
|
||
QMutexLocker locker(&m_liveViewMutex);
|
||
return m_liveViewImage.copy();
|
||
}
|
||
|
||
EdsError SingleLensReflexCameraOperation::initializeSDK()
|
||
{
|
||
EdsError err = EdsInitializeSDK();
|
||
if (err == EDS_ERR_OK)
|
||
{
|
||
m_isSDKInitialized = true;
|
||
std::cout << "EDSDK initialized successfully" << std::endl;
|
||
}
|
||
else
|
||
{
|
||
std::cout << "Failed to initialize EDSDK, error: " << err << std::endl;
|
||
}
|
||
return err;
|
||
}
|
||
|
||
EdsError SingleLensReflexCameraOperation::terminateSDK()
|
||
{
|
||
if (m_isSDKInitialized)
|
||
{
|
||
EdsError err = EdsTerminateSDK();
|
||
m_isSDKInitialized = false;
|
||
std::cout << "EDSDK terminated" << std::endl;
|
||
return err;
|
||
}
|
||
return EDS_ERR_OK;
|
||
}
|
||
|
||
EdsError SingleLensReflexCameraOperation::openCamera()
|
||
{
|
||
EdsError err = EDS_ERR_OK;
|
||
EdsCameraListRef cameraList = nullptr;
|
||
EdsUInt32 count = 0;
|
||
|
||
// 获取相机列表
|
||
err = EdsGetCameraList(&cameraList);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to get camera list, error: " << err << std::endl;
|
||
return err;
|
||
}
|
||
|
||
// 获取相机数量
|
||
err = EdsGetChildCount(cameraList, &count);
|
||
if (err != EDS_ERR_OK || count == 0)
|
||
{
|
||
std::cout << "No camera found" << std::endl;
|
||
EdsRelease(cameraList);
|
||
return EDS_ERR_DEVICE_NOT_FOUND;
|
||
}
|
||
|
||
std::cout << "Found " << count << " camera(s)" << std::endl;
|
||
|
||
// 获取第一台相机
|
||
err = EdsGetChildAtIndex(cameraList, 0, &m_camera);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to get camera, error: " << err << std::endl;
|
||
EdsRelease(cameraList);
|
||
return err;
|
||
}
|
||
|
||
// 释放相机列表
|
||
EdsRelease(cameraList);
|
||
|
||
// 设置事件回调
|
||
err = EdsSetObjectEventHandler(m_camera, kEdsObjectEvent_All, handleObjectEvent, this);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to set object event handler, error: " << err << std::endl;
|
||
}
|
||
|
||
err = EdsSetPropertyEventHandler(m_camera, kEdsPropertyEvent_All, handlePropertyEvent, this);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to set property event handler, error: " << err << std::endl;
|
||
}
|
||
|
||
err = EdsSetCameraStateEventHandler(m_camera, kEdsStateEvent_All, handleStateEvent, this);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to set state event handler, error: " << err << std::endl;
|
||
}
|
||
|
||
// 打开会话
|
||
err = EdsOpenSession(m_camera);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to open session, error: " << err << std::endl;
|
||
EdsRelease(m_camera);
|
||
m_camera = nullptr;
|
||
return err;
|
||
}
|
||
|
||
m_isSessionOpen = true;
|
||
std::cout << "Camera session opened successfully" << std::endl;
|
||
|
||
return EDS_ERR_OK;
|
||
}
|
||
|
||
EdsError SingleLensReflexCameraOperation::closeCamera()
|
||
{
|
||
EdsError err = EDS_ERR_OK;
|
||
|
||
if (m_isSessionOpen && m_camera != nullptr)
|
||
{
|
||
err = EdsCloseSession(m_camera);
|
||
m_isSessionOpen = false;
|
||
std::cout << "Camera session closed" << std::endl;
|
||
}
|
||
|
||
if (m_camera != nullptr)
|
||
{
|
||
EdsRelease(m_camera);
|
||
m_camera = nullptr;
|
||
}
|
||
|
||
return err;
|
||
}
|
||
|
||
EdsError SingleLensReflexCameraOperation::setupSaveToHost()
|
||
{
|
||
EdsError err = EDS_ERR_OK;
|
||
|
||
// 设置保存到PC
|
||
EdsUInt32 saveTo = kEdsSaveTo_Host;
|
||
err = EdsSetPropertyData(m_camera, kEdsPropID_SaveTo, 0, sizeof(saveTo), &saveTo);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to set SaveTo property, error: " << err << std::endl;
|
||
return err;
|
||
}
|
||
|
||
// 设置PC容量（告诉相机PC有足够空间）
|
||
EdsCapacity capacity;
|
||
capacity.numberOfFreeClusters = 0x7FFFFFFF;
|
||
capacity.bytesPerSector = 0x1000;
|
||
capacity.reset = true;
|
||
err = EdsSetCapacity(m_camera, capacity);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to set capacity, error: " << err << std::endl;
|
||
return err;
|
||
}
|
||
|
||
std::cout << "Save to host configured successfully" << std::endl;
|
||
return EDS_ERR_OK;
|
||
}
|
||
|
||
EdsError SingleLensReflexCameraOperation::startLiveView()
|
||
{
|
||
EdsError err = EDS_ERR_OK;
|
||
|
||
if (m_camera == nullptr || !m_isSessionOpen)
|
||
{
|
||
return EDS_ERR_DEVICE_NOT_FOUND;
|
||
}
|
||
|
||
// 获取当前输出设备设置
|
||
EdsUInt32 device = 0;
|
||
err = EdsGetPropertyData(m_camera, kEdsPropID_Evf_OutputDevice, 0, sizeof(device), &device);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to get Evf_OutputDevice, error: " << err << std::endl;
|
||
// 某些相机可能不支持获取，继续尝试设置
|
||
}
|
||
|
||
// 设置PC为实时取景输出设备
|
||
device |= kEdsEvfOutputDevice_PC;
|
||
err = EdsSetPropertyData(m_camera, kEdsPropID_Evf_OutputDevice, 0, sizeof(device), &device);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to set Evf_OutputDevice, error: " << err << std::endl;
|
||
return err;
|
||
}
|
||
|
||
m_isLiveViewActive = true;
|
||
std::cout << "Live view started" << std::endl;
|
||
|
||
emit LiveViewStarted();
|
||
|
||
return EDS_ERR_OK;
|
||
}
|
||
|
||
EdsError SingleLensReflexCameraOperation::stopLiveView()
|
||
{
|
||
EdsError err = EDS_ERR_OK;
|
||
|
||
if (m_camera == nullptr || !m_isSessionOpen)
|
||
{
|
||
m_isLiveViewActive = false;
|
||
return EDS_ERR_OK;
|
||
}
|
||
|
||
// 获取当前输出设备设置
|
||
EdsUInt32 device = 0;
|
||
err = EdsGetPropertyData(m_camera, kEdsPropID_Evf_OutputDevice, 0, sizeof(device), &device);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to get Evf_OutputDevice, error: " << err << std::endl;
|
||
}
|
||
|
||
// 从输出设备中移除PC
|
||
device &= ~kEdsEvfOutputDevice_PC;
|
||
err = EdsSetPropertyData(m_camera, kEdsPropID_Evf_OutputDevice, 0, sizeof(device), &device);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to clear Evf_OutputDevice, error: " << err << std::endl;
|
||
}
|
||
|
||
m_isLiveViewActive = false;
|
||
std::cout << "Live view stopped" << std::endl;
|
||
|
||
emit LiveViewStopped();
|
||
|
||
return EDS_ERR_OK;
|
||
}
|
||
|
||
EdsError SingleLensReflexCameraOperation::downloadEvfImage()
|
||
{
|
||
EdsError err = EDS_ERR_OK;
|
||
EdsStreamRef stream = nullptr;
|
||
EdsEvfImageRef evfImage = nullptr;
|
||
|
||
if (m_camera == nullptr || !m_isLiveViewActive)
|
||
{
|
||
return EDS_ERR_DEVICE_NOT_FOUND;
|
||
}
|
||
|
||
// 创建内存流
|
||
err = EdsCreateMemoryStream(0, &stream);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to create memory stream, error: " << err << std::endl;
|
||
return err;
|
||
}
|
||
|
||
// 创建实时取景图像引用
|
||
err = EdsCreateEvfImageRef(stream, &evfImage);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to create evf image ref, error: " << err << std::endl;
|
||
EdsRelease(stream);
|
||
return err;
|
||
}
|
||
|
||
// 下载实时取景图像
|
||
err = EdsDownloadEvfImage(m_camera, evfImage);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
// EDS_ERR_OBJECT_NOTREADY 是正常的，表示图像还没准备好
|
||
if (err != EDS_ERR_OBJECT_NOTREADY)
|
||
{
|
||
std::cout << "Failed to download evf image, error: " << err << std::endl;
|
||
}
|
||
EdsRelease(evfImage);
|
||
EdsRelease(stream);
|
||
return err;
|
||
}
|
||
|
||
// 获取流数据
|
||
EdsVoid* pData = nullptr;
|
||
EdsUInt64 length = 0;
|
||
|
||
err = EdsGetPointer(stream, &pData);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
EdsRelease(evfImage);
|
||
EdsRelease(stream);
|
||
return err;
|
||
}
|
||
|
||
err = EdsGetLength(stream, &length);
|
||
if (err != EDS_ERR_OK || length == 0)
|
||
{
|
||
EdsRelease(evfImage);
|
||
EdsRelease(stream);
|
||
return err;
|
||
}
|
||
|
||
// 将JPEG数据转换为QImage
|
||
QImage image;
|
||
if (image.loadFromData(static_cast<const uchar*>(pData), static_cast<int>(length), "JPEG"))
|
||
{
|
||
QMutexLocker locker(&m_liveViewMutex);
|
||
m_liveViewImage = image.copy();
|
||
locker.unlock();
|
||
|
||
// 发送信号通知图像已准备好
|
||
emit LiveViewImageReady(image);
|
||
}
|
||
|
||
// 释放资源
|
||
EdsRelease(evfImage);
|
||
EdsRelease(stream);
|
||
|
||
return EDS_ERR_OK;
|
||
}
|
||
|
||
EdsError SingleLensReflexCameraOperation::takePicture()
|
||
{
|
||
EdsError err = EDS_ERR_OK;
|
||
|
||
if (m_camera == nullptr || !m_isSessionOpen)
|
||
{
|
||
return EDS_ERR_DEVICE_NOT_FOUND;
|
||
}
|
||
|
||
// 按下快门
|
||
err = EdsSendCommand(m_camera, kEdsCameraCommand_PressShutterButton, kEdsCameraCommand_ShutterButton_Completely);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to press shutter button, error: " << err << std::endl;
|
||
return err;
|
||
}
|
||
|
||
// 释放快门
|
||
err = EdsSendCommand(m_camera, kEdsCameraCommand_PressShutterButton, kEdsCameraCommand_ShutterButton_OFF);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to release shutter button, error: " << err << std::endl;
|
||
return err;
|
||
}
|
||
|
||
std::cout << "Picture taken" << std::endl;
|
||
return EDS_ERR_OK;
|
||
}
|
||
|
||
EdsError SingleLensReflexCameraOperation::downloadImage(EdsDirectoryItemRef directoryItem)
|
||
{
|
||
EdsError err = EDS_ERR_OK;
|
||
EdsStreamRef stream = nullptr;
|
||
EdsDirectoryItemInfo dirItemInfo;
|
||
|
||
// 获取文件信息
|
||
err = EdsGetDirectoryItemInfo(directoryItem, &dirItemInfo);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to get directory item info, error: " << err << std::endl;
|
||
return err;
|
||
}
|
||
|
||
// 生成保存文件名（使用时间戳）
|
||
QString timestamp = QDateTime::currentDateTime().toString("yyyyMMdd_HHmmss_zzz");
|
||
QString fileName = m_savePath + QDir::separator() + "IMG_" + timestamp + "_" + QString::fromLocal8Bit(dirItemInfo.szFileName);
|
||
|
||
std::cout << "Downloading image to: " << fileName.toStdString() << std::endl;
|
||
|
||
// 创建文件流
|
||
err = EdsCreateFileStream(fileName.toLocal8Bit().constData(),
|
||
kEdsFileCreateDisposition_CreateAlways,
|
||
kEdsAccess_ReadWrite, &stream);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to create file stream, error: " << err << std::endl;
|
||
return err;
|
||
}
|
||
|
||
// 下载图像
|
||
err = EdsDownload(directoryItem, dirItemInfo.size, stream);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to download image, error: " << err << std::endl;
|
||
EdsRelease(stream);
|
||
return err;
|
||
}
|
||
|
||
// 通知下载完成
|
||
err = EdsDownloadComplete(directoryItem);
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to complete download, error: " << err << std::endl;
|
||
}
|
||
|
||
// 释放流
|
||
EdsRelease(stream);
|
||
|
||
std::cout << "Image downloaded successfully: " << fileName.toStdString() << std::endl;
|
||
|
||
// 发送信号通知图片已保存
|
||
emit ImageCapturedSignal(fileName);
|
||
|
||
return EDS_ERR_OK;
|
||
}
|
||
|
||
// 静态回调函数实现
|
||
EdsError EDSCALLBACK SingleLensReflexCameraOperation::handleObjectEvent(EdsObjectEvent event, EdsBaseRef object, EdsVoid* context)
|
||
{
|
||
SingleLensReflexCameraOperation* pThis = static_cast<SingleLensReflexCameraOperation*>(context);
|
||
|
||
switch (event)
|
||
{
|
||
case kEdsObjectEvent_DirItemRequestTransfer:
|
||
// 有图像需要传输
|
||
if (pThis != nullptr)
|
||
{
|
||
pThis->downloadImage(object);
|
||
}
|
||
break;
|
||
|
||
case kEdsObjectEvent_DirItemCreated:
|
||
std::cout << "New file created on camera" << std::endl;
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
// 释放对象
|
||
if (object)
|
||
{
|
||
EdsRelease(object);
|
||
}
|
||
|
||
return EDS_ERR_OK;
|
||
}
|
||
|
||
EdsError EDSCALLBACK SingleLensReflexCameraOperation::handlePropertyEvent(EdsPropertyEvent event, EdsPropertyID property, EdsUInt32 param, EdsVoid* context)
|
||
{
|
||
switch (event)
|
||
{
|
||
case kEdsPropertyEvent_PropertyChanged:
|
||
// 属性已更改
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
return EDS_ERR_OK;
|
||
}
|
||
|
||
EdsError EDSCALLBACK SingleLensReflexCameraOperation::handleStateEvent(EdsStateEvent event, EdsUInt32 parameter, EdsVoid* context)
|
||
{
|
||
SingleLensReflexCameraOperation* pThis = static_cast<SingleLensReflexCameraOperation*>(context);
|
||
|
||
switch (event)
|
||
{
|
||
case kEdsStateEvent_Shutdown:
|
||
std::cout << "Camera disconnected" << std::endl;
|
||
if (pThis != nullptr && pThis->m_isRecord)
|
||
{
|
||
pThis->CloseSLRCamera();
|
||
}
|
||
break;
|
||
|
||
case kEdsStateEvent_WillSoonShutDown:
|
||
// 相机即将自动关机，延长计时器
|
||
if (pThis != nullptr && pThis->m_camera != nullptr)
|
||
{
|
||
EdsSendCommand(pThis->m_camera, kEdsCameraCommand_ExtendShutDownTimer, 0);
|
||
}
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
return EDS_ERR_OK;
|
||
}
|
||
|
||
void SingleLensReflexCameraOperation::OpenSLRCamera()
|
||
{
|
||
std::cout << "SingleLensReflexCameraOperation::OpenSLRCamera, 打开单反相机" << std::endl;
|
||
|
||
EdsError err = EDS_ERR_OK;
|
||
|
||
// 初始化SDK
|
||
err = initializeSDK();
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
emit ErrorSignal(QString::fromLocal8Bit("初始化SDK失败，错误码: %1").arg(err));
|
||
return;
|
||
}
|
||
|
||
// 打开相机
|
||
err = openCamera();
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
terminateSDK();
|
||
emit ErrorSignal(QString::fromLocal8Bit("打开相机失败，错误码: %1").arg(err));
|
||
return;
|
||
}
|
||
|
||
// 设置保存到PC
|
||
err = setupSaveToHost();
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
closeCamera();
|
||
terminateSDK();
|
||
emit ErrorSignal(QString::fromLocal8Bit("设置保存位置失败，错误码: %1").arg(err));
|
||
return;
|
||
}
|
||
|
||
// 启动实时取景
|
||
err = startLiveView();
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Warning: Failed to start live view, error: " << err << std::endl;
|
||
// 实时取景启动失败不是致命错误，继续执行
|
||
}
|
||
|
||
m_isRecord = true;
|
||
|
||
// 启动实时取景定时器（约30fps）
|
||
if (m_liveViewTimer && !m_liveViewTimer->isActive()) {
|
||
m_liveViewTimer->start(33); // 约30fps
|
||
}
|
||
|
||
emit CamOpenedSignal();
|
||
|
||
std::cout << "Camera opened, live view started." << std::endl;
|
||
}
|
||
|
||
void SingleLensReflexCameraOperation::takePhoto()
|
||
{
|
||
// 启动拍照定时器（每3秒拍一张）
|
||
if (m_captureTimer && !m_captureTimer->isActive())
|
||
{
|
||
m_captureTimer->start(3000);
|
||
std::cout << "capture timer started (1 photo 3 second)" << std::endl;
|
||
|
||
emit CaptureStartedSignal();
|
||
}
|
||
}
|
||
|
||
void SingleLensReflexCameraOperation::stopTakePhoto()
|
||
{
|
||
if (m_captureTimer && m_captureTimer->isActive())
|
||
{
|
||
m_captureTimer->stop();
|
||
std::cout << "capture timer stopped" << std::endl;
|
||
|
||
emit CaptureStoppedSignal();
|
||
}
|
||
}
|
||
|
||
void SingleLensReflexCameraOperation::OpenSLRCamera_callback()
|
||
{
|
||
// 不使用信号而使用回调函数来通知界面刷新视频
|
||
}
|
||
|
||
void SingleLensReflexCameraOperation::setCallback(void(*func)())
|
||
{
|
||
m_func = func;
|
||
}
|
||
|
||
void SingleLensReflexCameraOperation::onLiveViewTimer()
|
||
{
|
||
if (!m_isRecord || !m_isLiveViewActive)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// 处理相机事件
|
||
EdsGetEvent();
|
||
|
||
// 下载实时取景图像
|
||
downloadEvfImage();
|
||
}
|
||
|
||
void SingleLensReflexCameraOperation::onCaptureTimer()
|
||
{
|
||
if (!m_isRecord)
|
||
{
|
||
return;
|
||
}
|
||
|
||
QMutexLocker locker(&m_mutex);
|
||
|
||
// 拍照
|
||
EdsError err = takePicture();
|
||
if (err != EDS_ERR_OK)
|
||
{
|
||
std::cout << "Failed to take picture, error: " << err << std::endl;
|
||
// 如果是设备忙，不发送错误信号，等待下次重试
|
||
if (err != EDS_ERR_DEVICE_BUSY)
|
||
{
|
||
emit ErrorSignal(QString::fromLocal8Bit("拍照失败，错误码: %1").arg(err));
|
||
}
|
||
}
|
||
|
||
m_imageCounter++;
|
||
std::cout << "Total pictures taken: " << m_imageCounter << std::endl;
|
||
}
|
||
|
||
void SingleLensReflexCameraOperation::startCapture()
|
||
{
|
||
if (m_captureTimer && !m_captureTimer->isActive())
|
||
{
|
||
m_captureTimer->start(1000);
|
||
std::cout << "Capture timer started" << std::endl;
|
||
emit CaptureStartedSignal();
|
||
}
|
||
}
|
||
|
||
void SingleLensReflexCameraOperation::stopCapture()
|
||
{
|
||
if (m_captureTimer && m_captureTimer->isActive())
|
||
{
|
||
m_captureTimer->stop();
|
||
std::cout << "Capture timer stopped" << std::endl;
|
||
emit CaptureStoppedSignal();
|
||
}
|
||
}
|
||
|
||
void SingleLensReflexCameraOperation::captureOnce()
|
||
{
|
||
if (m_isRecord)
|
||
{
|
||
QMutexLocker locker(&m_mutex);
|
||
takePicture();
|
||
}
|
||
}
|
||
|
||
void SingleLensReflexCameraOperation::CloseSLRCamera()
|
||
{
|
||
std::cout << "SingleLensReflexCameraOperation::CloseSLRCamera，关闭单反相机" << std::endl;
|
||
|
||
QMutexLocker locker(&m_mutex);
|
||
|
||
m_isRecord = false;
|
||
|
||
// 停止定时器
|
||
if (m_captureTimer != nullptr)
|
||
{
|
||
m_captureTimer->stop();
|
||
}
|
||
|
||
if (m_liveViewTimer != nullptr)
|
||
{
|
||
m_liveViewTimer->stop();
|
||
}
|
||
|
||
// 停止实时取景
|
||
stopLiveView();
|
||
|
||
// 处理剩余事件
|
||
for (int i = 0; i < 10; i++)
|
||
{
|
||
EdsGetEvent();
|
||
QThread::msleep(100);
|
||
}
|
||
|
||
// 关闭相机
|
||
closeCamera();
|
||
|
||
// 终止SDK
|
||
terminateSDK();
|
||
|
||
std::cout << "Camera closed, total pictures: " << m_imageCounter << std::endl;
|
||
m_imageCounter = 0;
|
||
|
||
emit CamClosedSignal();
|
||
}
|