763 lines
24 KiB
C++
763 lines
24 KiB
C++
|
#include "ANSFilePlayer_CV.h"
|
|||
|
|
#include "ANSMatRegistry.h"
|
|||
|
|
#include <memory>
|
|||
|
|
#include <cstdint>
|
|||
|
|
#include <libswscale/swscale.h>
|
|||
|
|
#include <libavutil/imgutils.h>
|
|||
|
|
#include <libavutil/frame.h>
|
|||
|
|
#include "media_codec.h"
|
|||
|
|
static bool ansfileplayerLicenceValid = false;
|
|||
|
|
// Global once_flag to protect license checking
|
|||
|
|
static std::once_flag ansfileplayerLicenseOnceFlag;
|
|||
|
|
namespace ANSCENTER {
|
|||
|
|
#define CHECK_CUDA(call) do { \
|
|||
|
|
cudaError_t err = call; \
|
|||
|
|
if (err != cudaSuccess) { \
|
|||
|
|
std::cout<<"CUDA error: " + std::string(cudaGetErrorString(err)); \
|
|||
|
|
} \
|
|||
|
|
} while (0)
|
|||
|
|
#define CHECK_NVJPEG(call) do { \
|
|||
|
|
nvjpegStatus_t status = call; \
|
|||
|
|
if (status != NVJPEG_STATUS_SUCCESS) { \
|
|||
|
|
std::cout <<"nvJPEG error: " + std::to_string(status); \
|
|||
|
|
} \
|
|||
|
|
} while (0)
|
|||
|
|
|
|||
|
|
ANSFILEPLAYER_CV::ANSFILEPLAYER_CV() :_stopThread(std::make_shared<std::atomic<bool>>(false))
|
|||
|
|
{
|
|||
|
|
_resWidth = 0;
|
|||
|
|
_resHeight = 0;
|
|||
|
|
m_bPaused = false;
|
|||
|
|
_crop = false;
|
|||
|
|
_isPlaying = false;
|
|||
|
|
_lastJpegImage = "";
|
|||
|
|
_bbox = cv::Rect(0, 0, 0, 0);
|
|||
|
|
_jpegCompressor = nullptr;
|
|||
|
|
_previousPTS = 0;
|
|||
|
|
_totalFrames = 0;
|
|||
|
|
}
|
|||
|
|
ANSFILEPLAYER_CV::~ANSFILEPLAYER_CV() noexcept {
|
|||
|
|
try {
|
|||
|
|
StopTimerThread();
|
|||
|
|
Destroy();
|
|||
|
|
}
|
|||
|
|
catch (...) {}
|
|||
|
|
}
|
|||
|
|
void ANSFILEPLAYER_CV::Destroy() {
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
try {
|
|||
|
|
_previousImage.release();
|
|||
|
|
_lastJpegImage = "";
|
|||
|
|
_isPlaying = false;
|
|||
|
|
_resWidth = 0;
|
|||
|
|
_resHeight = 0;
|
|||
|
|
_currentFrame = 0;
|
|||
|
|
_previousPTS = 0;
|
|||
|
|
if (cap.isOpened()) {
|
|||
|
|
cap.release();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
_logger.LogError("ANSFILEPLAYER_CV::Destroy. Exception:", e.what(), __FILE__, __LINE__);
|
|||
|
|
}
|
|||
|
|
catch (...) {
|
|||
|
|
_logger.LogError("ANSFILEPLAYER_CV::Destroy.", "Unknown exception", __FILE__, __LINE__);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void VerifyGlobalANSFPLicense(const std::string& licenseKey) {
|
|||
|
|
try {
|
|||
|
|
ansfileplayerLicenceValid = ANSCENTER::ANSLicenseHelper::LicenseVerification(licenseKey, 1007, "ANSCV");//Default productId=1005
|
|||
|
|
if (!ansfileplayerLicenceValid) { // we also support ANSTS license
|
|||
|
|
ansfileplayerLicenceValid = ANSCENTER::ANSLicenseHelper::LicenseVerification(licenseKey, 1003, "ANSVIS");//Default productId=1003 (ANSVIS)
|
|||
|
|
}
|
|||
|
|
if (!ansfileplayerLicenceValid) { // we also support ANSTS license
|
|||
|
|
ansfileplayerLicenceValid = ANSCENTER::ANSLicenseHelper::LicenseVerification(licenseKey, 1008, "ANSTS");//Default productId=1008 (ANSTS)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
catch (std::exception& e) {
|
|||
|
|
ansfileplayerLicenceValid = false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
void ANSFILEPLAYER_CV::CheckLicense() {
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
try {
|
|||
|
|
// Check once globally
|
|||
|
|
std::call_once(ansfileplayerLicenseOnceFlag, [this]() {
|
|||
|
|
VerifyGlobalANSFPLicense(_licenseKey);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
// Update this instance's local license flag
|
|||
|
|
_licenseValid = ansfileplayerLicenceValid;
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
this->_logger.LogFatal("ANSFILEPLAYER_CV::CheckLicense. Error:", e.what(), __FILE__, __LINE__);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
bool ANSFILEPLAYER_CV::Init(std::string licenseKey, std::string url) {
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
_licenseKey = licenseKey;
|
|||
|
|
CheckLicense();
|
|||
|
|
if (!_licenseValid) {
|
|||
|
|
_logger.LogError("ANSFILEPLAYER_CV::Init.", "Invalid license", __FILE__, __LINE__);
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
_url = url;
|
|||
|
|
return Setup();
|
|||
|
|
}
|
|||
|
|
bool ANSFILEPLAYER_CV::Setup() {
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
_currentFrame = 0;
|
|||
|
|
if (cap.isOpened()) return true;
|
|||
|
|
cap.open(_url, cv::CAP_FFMPEG); // USe FFMPEG for better codec support
|
|||
|
|
if (!cap.isOpened()) {
|
|||
|
|
cap.open(_url, cv::CAP_ANY);
|
|||
|
|
if (!cap.isOpened())return false;
|
|||
|
|
}
|
|||
|
|
try {
|
|||
|
|
_resWidth = static_cast<int>(cap.get(cv::CAP_PROP_FRAME_WIDTH));
|
|||
|
|
_resHeight = static_cast<int>(cap.get(cv::CAP_PROP_FRAME_HEIGHT));
|
|||
|
|
_totalFrames = static_cast<int64_t>(cap.get(cv::CAP_PROP_FRAME_COUNT));
|
|||
|
|
_fps = cap.get(cv::CAP_PROP_FPS);
|
|||
|
|
cap.set(cv::CAP_PROP_POS_FRAMES, _currentFrame);
|
|||
|
|
if (_fps > 0) {
|
|||
|
|
if (_timerThread && _timerThread->joinable()) return true; // Exit if the thread is already running
|
|||
|
|
int interval_ms = static_cast<int>(1000 / _fps);
|
|||
|
|
*_stopThread = false;
|
|||
|
|
_timerThread = std::make_shared<std::thread>(&ANSFILEPLAYER_CV::StartTimer, this, _stopThread, interval_ms);
|
|||
|
|
}
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
catch (std::exception& e) {
|
|||
|
|
this->_logger.LogError("ANSFILEPLAYER_CV::Setup:", e.what(), __FILE__, __LINE__);
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
void ANSFILEPLAYER_CV::StartTimer(std::shared_ptr<std::atomic<bool>> stopFlag, int interval_ms) {
|
|||
|
|
while (!stopFlag->load()) {
|
|||
|
|
std::unique_lock<std::mutex> lock(_cvMutex);
|
|||
|
|
// Wait for the specified interval or until stopFlag is set
|
|||
|
|
if (_cv.wait_for(lock, std::chrono::milliseconds(interval_ms), [&]() {
|
|||
|
|
return stopFlag->load();
|
|||
|
|
})) {
|
|||
|
|
break; // Exit the loop if stopFlag is true
|
|||
|
|
}
|
|||
|
|
lock.unlock(); // Unlock to avoid deadlocks in further operations
|
|||
|
|
int delayMs = 0;
|
|||
|
|
int actualSleepTime = interval_ms;
|
|||
|
|
{
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
auto start = std::chrono::system_clock::now();
|
|||
|
|
if (_isPlaying) {
|
|||
|
|
try {
|
|||
|
|
_currentFrame = static_cast<int64_t>(cap.get(cv::CAP_PROP_POS_FRAMES));
|
|||
|
|
// Add check for _stopThread before blocking operations
|
|||
|
|
if (!cap.grab() || _currentFrame >= _totalFrames - 1) {
|
|||
|
|
if (cap.isOpened()) {
|
|||
|
|
cap.release();
|
|||
|
|
cap.open(_url, cv::CAP_FFMPEG); // USe FFMPEG for better codec support
|
|||
|
|
if (!cap.isOpened()) {
|
|||
|
|
cap.open(_url, cv::CAP_ANY);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (cap.isOpened()) {
|
|||
|
|
cap.set(cv::CAP_PROP_POS_FRAMES, 0);
|
|||
|
|
_currentFrame = 0;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
this->_logger.LogError("ANSFILEPLAYER_CV::StartTimer. Exception occurred:", e.what(), __FILE__, __LINE__);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
auto end = std::chrono::system_clock::now();
|
|||
|
|
delayMs = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
|
|||
|
|
// Calculate actual sleep time based on any delay introduced
|
|||
|
|
actualSleepTime = interval_ms - delayMs;
|
|||
|
|
if (actualSleepTime < 1) actualSleepTime = 1;
|
|||
|
|
}
|
|||
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(actualSleepTime));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
void ANSFILEPLAYER_CV::StopTimerThread() {
|
|||
|
|
*_stopThread = true; // Signal to stop the thread
|
|||
|
|
_cv.notify_all(); // Notify the condition variable to unblock the thread
|
|||
|
|
if (_timerThread && _timerThread->joinable()) {
|
|||
|
|
_timerThread->join(); // Join the timer thread to ensure cleanup
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
bool ANSFILEPLAYER_CV::Reconnect() {
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
try {
|
|||
|
|
_currentFrame = 0;
|
|||
|
|
if (cap.isOpened()) {
|
|||
|
|
cap.release();
|
|||
|
|
}
|
|||
|
|
Setup();
|
|||
|
|
_isPlaying = cap.isOpened() && cap.grab();
|
|||
|
|
return _isPlaying;
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
this->_logger.LogError("ANSFILEPLAYER_CV::Reconnect. Exception occurred:", e.what(), __FILE__, __LINE__);
|
|||
|
|
_currentFrame = 0;
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
bool ANSFILEPLAYER_CV::Start() {
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
try {
|
|||
|
|
if (!cap.isOpened()) {
|
|||
|
|
cap.open(_url, cv::CAP_FFMPEG);
|
|||
|
|
if (!cap.isOpened()) {
|
|||
|
|
cap.open(_url, cv::CAP_ANY);
|
|||
|
|
}
|
|||
|
|
if (!cap.isOpened()) {
|
|||
|
|
this->_logger.LogError("ANSFILEPLAYER_CV::Start. Exception occurred:", "Failed to open video source: ", __FILE__, __LINE__);
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
try {
|
|||
|
|
if (!cap.set(cv::CAP_PROP_POS_FRAMES, _currentFrame)) {
|
|||
|
|
this->_logger.LogError("ANSFILEPLAYER_CV::Start. Exception occurred:", "Warning: Unable to seek to frame", __FILE__, __LINE__);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
this->_logger.LogError("ANSFILEPLAYER_CV::Start. Exception occurred:", e.what(), __FILE__, __LINE__);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
_isPlaying = cap.isOpened() && cap.grab();
|
|||
|
|
return _isPlaying;
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
this->_logger.LogError("ANSFILEPLAYER_CV::Start. Exception occurred:", e.what(), __FILE__, __LINE__);
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
bool ANSFILEPLAYER_CV::Stop() {
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
try {
|
|||
|
|
if (cap.isOpened()) {
|
|||
|
|
try {
|
|||
|
|
double frame_pos = cap.get(cv::CAP_PROP_POS_FRAMES);
|
|||
|
|
if (frame_pos >= 0) {
|
|||
|
|
_currentFrame = static_cast<int64_t>(frame_pos);
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
_currentFrame = 0;
|
|||
|
|
this->_logger.LogError("ANSFILEPLAYER_CV::Stop. Exception occurred:", "Unable to retrieve current frame position", __FILE__, __LINE__);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
this->_logger.LogError("ANSFILEPLAYER_CV::Stop. Exception occurred:", e.what(), __FILE__, __LINE__);
|
|||
|
|
_currentFrame = 0;
|
|||
|
|
}
|
|||
|
|
cap.release();
|
|||
|
|
}
|
|||
|
|
_isPlaying = false;
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
this->_logger.LogError("ANSFILEPLAYER_CV::Stop. Exception occurred:", e.what(), __FILE__, __LINE__);
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
void ANSFILEPLAYER_CV::SetBBox(cv::Rect bbox) {
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
_bbox = bbox;
|
|||
|
|
}
|
|||
|
|
void ANSFILEPLAYER_CV::SetCrop(bool crop) {
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
_crop = crop;
|
|||
|
|
}
|
|||
|
|
bool ANSFILEPLAYER_CV::IsPaused() {
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
return !cap.isOpened();
|
|||
|
|
}
|
|||
|
|
bool ANSFILEPLAYER_CV::IsPlaying() {
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
return cap.isOpened();
|
|||
|
|
}
|
|||
|
|
bool ANSFILEPLAYER_CV::IsRecording() {
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
return false;// do not support recording for webcam
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
cv::Mat ANSFILEPLAYER_CV::GetImage(int& width, int& height, int64_t& pts) {
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
|
|||
|
|
if (!_isPlaying) {
|
|||
|
|
if (!_previousImage.empty()) {
|
|||
|
|
width = _previousImage.cols;
|
|||
|
|
height = _previousImage.rows;
|
|||
|
|
pts = _previousPTS;
|
|||
|
|
return _previousImage;
|
|||
|
|
}
|
|||
|
|
return cv::Mat();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
try {
|
|||
|
|
if (!cap.isOpened()) {
|
|||
|
|
if (!_previousImage.empty()) {
|
|||
|
|
width = _previousImage.cols;
|
|||
|
|
height = _previousImage.rows;
|
|||
|
|
pts = _previousPTS;
|
|||
|
|
return _previousImage;
|
|||
|
|
}
|
|||
|
|
return cv::Mat();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
cv::Mat frame;
|
|||
|
|
if (!cap.read(frame) || frame.empty()) {
|
|||
|
|
// Return last good frame if available
|
|||
|
|
if (!_previousImage.empty()) {
|
|||
|
|
width = _previousImage.cols;
|
|||
|
|
height = _previousImage.rows;
|
|||
|
|
pts = _previousPTS;
|
|||
|
|
return _previousImage;
|
|||
|
|
}
|
|||
|
|
return cv::Mat();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
cv::Mat result;
|
|||
|
|
|
|||
|
|
// Apply cropping if enabled
|
|||
|
|
if (_crop) {
|
|||
|
|
// Validate and clamp crop region
|
|||
|
|
_bbox.x = std::clamp(_bbox.x, 0, frame.cols - 1);
|
|||
|
|
_bbox.y = std::clamp(_bbox.y, 0, frame.rows - 1);
|
|||
|
|
_bbox.width = std::min(_bbox.width, frame.cols - _bbox.x);
|
|||
|
|
_bbox.height = std::min(_bbox.height, frame.rows - _bbox.y);
|
|||
|
|
|
|||
|
|
if (_bbox.width > 0 && _bbox.height > 0) {
|
|||
|
|
// CRITICAL: Clone to avoid dangling reference
|
|||
|
|
result = frame(_bbox).clone();
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
result = frame.clone();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
result = frame.clone();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Apply rotation if specified
|
|||
|
|
if (_imageRotateDeg > 0) {
|
|||
|
|
// Fast path for 90-degree rotations
|
|||
|
|
if (std::abs(_imageRotateDeg - 90.0) < 0.01) {
|
|||
|
|
cv::rotate(result, result, cv::ROTATE_90_CLOCKWISE);
|
|||
|
|
}
|
|||
|
|
else if (std::abs(_imageRotateDeg - 180.0) < 0.01) {
|
|||
|
|
cv::rotate(result, result, cv::ROTATE_180);
|
|||
|
|
}
|
|||
|
|
else if (std::abs(_imageRotateDeg - 270.0) < 0.01) {
|
|||
|
|
cv::rotate(result, result, cv::ROTATE_90_COUNTERCLOCKWISE);
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
// Arbitrary angle rotation
|
|||
|
|
const cv::Point2f center(result.cols / 2.0f, result.rows / 2.0f);
|
|||
|
|
cv::Mat rotationMatrix = cv::getRotationMatrix2D(center, _imageRotateDeg, 1.0);
|
|||
|
|
|
|||
|
|
cv::Mat rotated;
|
|||
|
|
// Use INTER_LINEAR instead of INTER_CUBIC (2-3x faster, minimal quality loss)
|
|||
|
|
cv::warpAffine(result, rotated, rotationMatrix, result.size(),
|
|||
|
|
cv::INTER_LINEAR, cv::BORDER_CONSTANT, cv::Scalar());
|
|||
|
|
result = rotated;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Update PTS (presentation timestamp)
|
|||
|
|
if (_previousPTS < INT64_MAX) {
|
|||
|
|
_previousPTS++;
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
_previousPTS = 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Update cached frame
|
|||
|
|
_previousImage = result;
|
|||
|
|
|
|||
|
|
// Set output parameters
|
|||
|
|
width = result.cols;
|
|||
|
|
height = result.rows;
|
|||
|
|
pts = _previousPTS;
|
|||
|
|
|
|||
|
|
return result;
|
|||
|
|
}
|
|||
|
|
catch (const cv::Exception& e) {
|
|||
|
|
this->_logger.LogError("ANSFILEPLAYER_CV::GetImage. OpenCV exception:", e.what(), __FILE__, __LINE__);
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
this->_logger.LogError("ANSFILEPLAYER_CV::GetImage. Exception:", e.what(), __FILE__, __LINE__);
|
|||
|
|
}
|
|||
|
|
catch (...) {
|
|||
|
|
this->_logger.LogError("ANSFILEPLAYER_CV::GetImage. Unknown exception", "", __FILE__, __LINE__);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return cv::Mat();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void ANSFILEPLAYER_CV::EnableAudio(bool status) {
|
|||
|
|
// please support audio enable for webcam
|
|||
|
|
}
|
|||
|
|
void ANSFILEPLAYER_CV::SetAudioVolume(int volume) {
|
|||
|
|
// support audio volumne
|
|||
|
|
}
|
|||
|
|
std::string ANSFILEPLAYER_CV::encodeJpegString(const cv::Mat& img, int quality) {
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
if (!_isPlaying) return _lastJpegImage;
|
|||
|
|
unsigned char* jpegBuf = nullptr;
|
|||
|
|
tjhandle jpegCompressor = nullptr;
|
|||
|
|
try {
|
|||
|
|
// Initialize TurboJPEG compressor
|
|||
|
|
jpegCompressor = tjInitCompress();
|
|||
|
|
if (!jpegCompressor) {
|
|||
|
|
this->_logger.LogError("Failed to initialize TurboJPEG compressor.", tjGetErrorStr(), __FILE__, __LINE__);
|
|||
|
|
return _lastJpegImage;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int maxBufferSize = img.cols * img.rows * 3;
|
|||
|
|
jpegBuf = tjAlloc(maxBufferSize);
|
|||
|
|
if (!jpegBuf) {
|
|||
|
|
this->_logger.LogError("Failed to allocate memory for JPEG buffer.", tjGetErrorStr(), __FILE__, __LINE__);
|
|||
|
|
tjDestroy(jpegCompressor);
|
|||
|
|
return _lastJpegImage;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
long unsigned int jpegSize = maxBufferSize;
|
|||
|
|
int subsamp = TJSAMP_444;
|
|||
|
|
int pixelFormat = img.channels() == 3 ? TJPF_BGR : TJPF_GRAY;
|
|||
|
|
|
|||
|
|
// Compress the image
|
|||
|
|
if (tjCompress2(jpegCompressor, img.data, img.cols, 0, img.rows, pixelFormat,
|
|||
|
|
&jpegBuf, &jpegSize, subsamp, quality, TJFLAG_FASTDCT) != 0) {
|
|||
|
|
this->_logger.LogError("Compression error:", tjGetErrorStr(), __FILE__, __LINE__);
|
|||
|
|
tjFree(jpegBuf);
|
|||
|
|
tjDestroy(jpegCompressor);
|
|||
|
|
return _lastJpegImage;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Create string from JPEG buffer
|
|||
|
|
std::string jpegString(reinterpret_cast<char*>(jpegBuf), jpegSize);
|
|||
|
|
_lastJpegImage = jpegString;
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
this->_logger.LogError("Exception occurred:", e.what(), __FILE__, __LINE__);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Cleanup resources
|
|||
|
|
if (jpegBuf) tjFree(jpegBuf);
|
|||
|
|
if (jpegCompressor) tjDestroy(jpegCompressor);
|
|||
|
|
|
|||
|
|
return _lastJpegImage;
|
|||
|
|
}
|
|||
|
|
std::string ANSFILEPLAYER_CV::MatToBinaryData(const cv::Mat& image) {
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
// Check if the image is empty or has invalid data
|
|||
|
|
if (!_isPlaying) return _lastJpegImage;
|
|||
|
|
if (image.empty() || !image.data || !image.u) {
|
|||
|
|
return _lastJpegImage;
|
|||
|
|
}
|
|||
|
|
try {
|
|||
|
|
// Encode the image to a memory buffer
|
|||
|
|
return encodeJpegString(image, 85);
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
this->_logger.LogFatal("ANSFILEPLAYER_CV::MatToBinaryData. Exception occurred:", e.what(), __FILE__, __LINE__);
|
|||
|
|
}
|
|||
|
|
catch (...) {
|
|||
|
|
this->_logger.LogFatal("ANSFILEPLAYER_CV::MatToBinaryData.", "Unknown exception occurred.", __FILE__, __LINE__);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Return an empty string in case of failure
|
|||
|
|
return _lastJpegImage;
|
|||
|
|
}
|
|||
|
|
std::string ANSFILEPLAYER_CV::GetJpegStringImage(int& width, int& height, int64_t& pts) {
|
|||
|
|
std::lock_guard<std::recursive_mutex> lock(_mutex);
|
|||
|
|
if (!_isPlaying) return _lastJpegImage;
|
|||
|
|
try {
|
|||
|
|
cv::Mat image = GetImage(width, height, pts);
|
|||
|
|
std::string jpegString = MatToBinaryData(image);
|
|||
|
|
image.release();
|
|||
|
|
return jpegString;
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
this->_logger.LogError("ANSFILEPLAYER_CV::GetJpegStringImage. Exception occurred:", e.what(), __FILE__, __LINE__);
|
|||
|
|
return _lastJpegImage;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
extern "C" __declspec(dllexport) int CreateANSFileCVPlayerHandle(ANSCENTER::ANSFILEPLAYER_CV** Handle, const char* licenseKey, const char* url) {
|
|||
|
|
if (!Handle || !licenseKey || !url) return -1;
|
|||
|
|
try {
|
|||
|
|
auto ptr = std::make_unique<ANSCENTER::ANSFILEPLAYER_CV>();
|
|||
|
|
bool result = ptr->Init(licenseKey, url);
|
|||
|
|
if (result) {
|
|||
|
|
*Handle = ptr.release();
|
|||
|
|
extern void anscv_unregister_handle(void*);
|
|||
|
|
extern void anscv_register_handle(void*, void(*)(void*));
|
|||
|
|
anscv_register_handle(*Handle, [](void* p) {
|
|||
|
|
auto* h = static_cast<ANSCENTER::ANSFILEPLAYER_CV*>(p);
|
|||
|
|
try { h->Stop(); } catch (...) {}
|
|||
|
|
try { h->Destroy(); } catch (...) {}
|
|||
|
|
try { delete h; } catch (...) {}
|
|||
|
|
});
|
|||
|
|
return 1;
|
|||
|
|
}
|
|||
|
|
*Handle = nullptr;
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
catch (...) { return 0; }
|
|||
|
|
}
|
|||
|
|
extern "C" __declspec(dllexport) int ReleaseANSFileCVPlayerHandle(ANSCENTER::ANSFILEPLAYER_CV** Handle) {
|
|||
|
|
if (Handle == nullptr || *Handle == nullptr) return -1;
|
|||
|
|
try {
|
|||
|
|
extern void anscv_unregister_handle(void*);
|
|||
|
|
anscv_unregister_handle(*Handle);
|
|||
|
|
// Destructor calls Destroy() <20> no need to call it explicitly (avoids double-destroy)
|
|||
|
|
std::unique_ptr<ANSCENTER::ANSFILEPLAYER_CV> ptr(*Handle);
|
|||
|
|
*Handle = nullptr;
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
catch (...) {
|
|||
|
|
if (Handle) *Handle = nullptr;
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
extern "C" __declspec(dllexport) int GetFileCVPlayerStrImage(ANSCENTER::ANSFILEPLAYER_CV** Handle, int& width, int& height, int64_t& timeStamp, std::string& jpegImage) {
|
|||
|
|
if (Handle == nullptr || *Handle == nullptr) return -1;
|
|||
|
|
try {
|
|||
|
|
jpegImage = (*Handle)->GetJpegStringImage(width, height, timeStamp);
|
|||
|
|
if (!jpegImage.empty()) return 1;
|
|||
|
|
else return 0;
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
std::cerr << "Error getting image data from FilePlayer client: " << e.what() << std::endl;
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
catch (...) {
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
extern "C" __declspec(dllexport) int GetFileCVPlayerImage(ANSCENTER::ANSFILEPLAYER_CV** Handle, int& width, int& height, int64_t& timeStamp, LStrHandle jpegImage) {
|
|||
|
|
if (Handle == nullptr || *Handle == nullptr) return -1;
|
|||
|
|
try {
|
|||
|
|
std::string jpegString = (*Handle)->GetJpegStringImage(width, height, timeStamp);
|
|||
|
|
int size = jpegString.length();
|
|||
|
|
if (size > 0) {
|
|||
|
|
MgErr error;
|
|||
|
|
// Resize the jpegImage handle to hold the image data
|
|||
|
|
error = DSSetHandleSize(jpegImage, sizeof(int32) + size * sizeof(uChar));
|
|||
|
|
// Check if resizing the handle was successful
|
|||
|
|
if (error == noErr) {
|
|||
|
|
// Set the size of the image in the handle
|
|||
|
|
(*jpegImage)->cnt = size;
|
|||
|
|
// Use memcpy to copy the data from the std::string to the LStrHandle's str buffer
|
|||
|
|
memcpy((*jpegImage)->str, jpegString.c_str(), size);
|
|||
|
|
// Return success
|
|||
|
|
return 1;
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
// Return failure if there was an error in resizing the handle
|
|||
|
|
std::cerr << "Error resizing jpegImage handle: " << error << std::endl;
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
// If the JPEG image string is empty, return failure
|
|||
|
|
std::cerr << "No image data retrieved from FilePlayer client." << std::endl;
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
std::cerr << "Error getting image data from FilePlayer client: " << e.what() << std::endl;
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
catch (...) {
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
extern "C" __declspec(dllexport) int GetFileCVPlayerCVImage(ANSCENTER::ANSFILEPLAYER_CV** Handle, int& width, int& height, int64_t& timeStamp, cv::Mat** image) {
|
|||
|
|
if (!Handle || !(*Handle) || !image) {
|
|||
|
|
std::cerr << "Error: Invalid input parameters in GetFilePlayerCVImage." << std::endl;
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
try {
|
|||
|
|
cv::Mat img = (*Handle)->GetImage(width, height, timeStamp);
|
|||
|
|
if (img.empty()) {
|
|||
|
|
return 0; // No valid image retrieved
|
|||
|
|
}
|
|||
|
|
// anscv_mat_replace has its own internal registry_mutex <20> no global mutex needed
|
|||
|
|
anscv_mat_replace(image, std::move(img));
|
|||
|
|
|
|||
|
|
return 1; // Success
|
|||
|
|
}
|
|||
|
|
catch (const cv::Exception& e) {
|
|||
|
|
std::cerr << "OpenCV exception in GetFilePlayerCVImage: " << e.what() << std::endl;
|
|||
|
|
return -2;
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
std::cerr << "Exception in GetFilePlayerCVImage: " << e.what() << std::endl;
|
|||
|
|
return -2;
|
|||
|
|
}
|
|||
|
|
catch (...) {
|
|||
|
|
std::cerr << "Unknown exception in GetFilePlayerCVImage" << std::endl;
|
|||
|
|
return -2;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
extern "C" __declspec(dllexport) int StartFileCVPlayer(ANSCENTER::ANSFILEPLAYER_CV** Handle) {
|
|||
|
|
if (Handle == nullptr || *Handle == nullptr) return -1;
|
|||
|
|
try {
|
|||
|
|
bool result = (*Handle)->Start();
|
|||
|
|
if (result) return 1;
|
|||
|
|
else return 0;
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
std::cerr << "Error starting file player: " << e.what() << std::endl;
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
catch (...) {
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
extern "C" __declspec(dllexport) int ReconnectFileCVPlayer(ANSCENTER::ANSFILEPLAYER_CV** Handle) {
|
|||
|
|
if (Handle == nullptr || *Handle == nullptr) return -1;
|
|||
|
|
try {
|
|||
|
|
bool result = (*Handle)->Reconnect();
|
|||
|
|
if (result) return 1;
|
|||
|
|
else return 0;
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
std::cerr << "Error reconnecting file player: " << e.what() << std::endl;
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
catch (...) {
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
extern "C" __declspec(dllexport) int StopFileCVPlayer(ANSCENTER::ANSFILEPLAYER_CV** Handle) {
|
|||
|
|
if (Handle == nullptr || *Handle == nullptr) return -1;
|
|||
|
|
try {
|
|||
|
|
bool result = (*Handle)->Stop();
|
|||
|
|
if (result) return 1;
|
|||
|
|
else return 0;
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
std::cerr << "Error stopping file player: " << e.what() << std::endl;
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
catch (...) {
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
extern "C" __declspec(dllexport) int IsFileCVPlayerPaused(ANSCENTER::ANSFILEPLAYER_CV** Handle) {
|
|||
|
|
if (Handle == nullptr || *Handle == nullptr) return -1;
|
|||
|
|
try {
|
|||
|
|
bool result = (*Handle)->IsPaused();
|
|||
|
|
if (result) return 1;
|
|||
|
|
else return 0;
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
std::cerr << "Error checking if file player is paused: " << e.what() << std::endl;
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
catch (...) {
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
extern "C" __declspec(dllexport) int IsFileCVPlayerRunning(ANSCENTER::ANSFILEPLAYER_CV** Handle) {
|
|||
|
|
if (Handle == nullptr || *Handle == nullptr) return -1;
|
|||
|
|
try {
|
|||
|
|
bool result = (*Handle)->IsPlaying();
|
|||
|
|
if (result) return 1;
|
|||
|
|
else return 0;
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
std::cerr << "Error checking if file player is running: " << e.what() << std::endl;
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
catch (...) {
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
extern "C" __declspec(dllexport) int IsFileCVPlayerRecording(ANSCENTER::ANSFILEPLAYER_CV** Handle) {
|
|||
|
|
if (Handle == nullptr || *Handle == nullptr) return -1;
|
|||
|
|
try {
|
|||
|
|
bool result = (*Handle)->IsRecording();
|
|||
|
|
if (result) return 1;
|
|||
|
|
else return 0;
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
std::cerr << "Error checking if file player is recording: " << e.what() << std::endl;
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
catch (...) {
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
extern "C" __declspec(dllexport) void SetFileCVPlayerAudioVolume(ANSCENTER::ANSFILEPLAYER_CV** Handle, int volume)
|
|||
|
|
{
|
|||
|
|
if (Handle == nullptr || *Handle == nullptr) return;
|
|||
|
|
try {
|
|||
|
|
(*Handle)->SetAudioVolume(volume);
|
|||
|
|
}
|
|||
|
|
catch (...) {}
|
|||
|
|
}
|
|||
|
|
extern "C" __declspec(dllexport) void EnableFileCVPlayerAudioVolume(ANSCENTER::ANSFILEPLAYER_CV** Handle, int status)
|
|||
|
|
{
|
|||
|
|
if (Handle == nullptr || *Handle == nullptr) return;
|
|||
|
|
try {
|
|||
|
|
bool audioStatus = false;
|
|||
|
|
if (status == 1)audioStatus = true;
|
|||
|
|
(*Handle)->EnableAudio(audioStatus);
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
std::cerr << "Error enabling audio for file player: " << e.what() << std::endl;
|
|||
|
|
}
|
|||
|
|
catch (...) {}
|
|||
|
|
}
|
|||
|
|
extern "C" __declspec(dllexport) void SetFileCVPlayerImageRotation(ANSCENTER::ANSFILEPLAYER_CV** Handle, double rotationAngle) {
|
|||
|
|
if (Handle == nullptr || *Handle == nullptr) return;
|
|||
|
|
try {
|
|||
|
|
(*Handle)->SetImageRotate(rotationAngle);
|
|||
|
|
}
|
|||
|
|
catch (...) {}
|
|||
|
|
}
|
|||
|
|
extern "C" __declspec(dllexport) int SetBBoxFileCVPlayer(ANSCENTER::ANSFILEPLAYER_CV** Handle, int x, int y, int width, int height) {
|
|||
|
|
if (Handle == nullptr || *Handle == nullptr) return -1;
|
|||
|
|
try {
|
|||
|
|
cv::Rect bbox(x, y, width, height);
|
|||
|
|
(*Handle)->SetBBox(bbox);
|
|||
|
|
return 1;
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
std::cerr << "Error setting bounding box for file player: " << e.what() << std::endl;
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
catch (...) {
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
extern "C" __declspec(dllexport) int SetCropFlagFileCVPlayer(ANSCENTER::ANSFILEPLAYER_CV** Handle, int cropFlag) {
|
|||
|
|
if (Handle == nullptr || *Handle == nullptr) return -1;
|
|||
|
|
try {
|
|||
|
|
bool crop = false;
|
|||
|
|
if (cropFlag == 1)crop = true;
|
|||
|
|
(*Handle)->SetCrop(crop);
|
|||
|
|
return 1;
|
|||
|
|
}
|
|||
|
|
catch (const std::exception& e) {
|
|||
|
|
std::cerr << "Error setting crop flag for file player: " << e.what() << std::endl;
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
catch (...) {
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|