JDierkse/CameraRecorder
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add MultiSnapshot

Browse Source
This commit is contained in:
JDierkse
2020-05-11 21:55:34 +02:00
parent ea15817e53
commit 6afdf1a387
21 changed files with 904 additions and 714 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Recorder/DigooRecorder.cpp
+38 -32
View File
@@ -1,32 +1,38 @@
#include "DigooRecorder.h"
#include <HttpClient.h>
#include <Logging.h>
namespace CameraRecorder {
namespace Recorder {
DigooRecorder::DigooRecorder(Http::HttpClient* pHttpClient, const Settings& settings) :
m_pHttpClient(pHttpClient),
m_settings(settings)
{
}
DigooRecorder::~DigooRecorder()
{
}
std::string DigooRecorder::Snapshot(ctpl::thread_pool* pThreadPool)
{
Logging::Log(Logging::Severity::Debug, "DigooRecorder Snapshot");
return std::string();
}
std::string DigooRecorder::Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg)
{
Logging::Log(Logging::Severity::Debug, "DigooRecorder Video");
return std::string();
}
} // namespace Recorder
} // namespace CameraRecorder
#include "DigooRecorder.h"
#include <HttpClient.h>
#include <Logging.h>
namespace CameraRecorder {
namespace Recorder {
DigooRecorder::DigooRecorder(Http::HttpClient* pHttpClient, const Settings& settings) :
m_pHttpClient(pHttpClient),
m_settings(settings)
{
}
DigooRecorder::~DigooRecorder()
{
}
std::string DigooRecorder::Snapshot(ctpl::thread_pool* pThreadPool)
{
Logging::Log(Logging::Severity::Debug, "DigooRecorder Snapshot");
return std::string();
}
std::string DigooRecorder::MultiSnapshot(ctpl::thread_pool* pThreadPool, int numberOfImages)
{
Logging::Log(Logging::Severity::Debug, "DigooRecorder MultiSnapshot");
return std::string();
}
std::string DigooRecorder::Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg)
{
Logging::Log(Logging::Severity::Debug, "DigooRecorder Video");
return std::string();
}
} // namespace Recorder
} // namespace CameraRecorder
Recorder/DigooRecorder.h
+35 -34
View File
@@ -1,34 +1,35 @@
#ifndef RECORDER_DIGOORECORDER_H
#define RECORDER_DIGOORECORDER_H
#include "Recorder.h"
#include "Settings.h"
namespace Http {
class HttpClient;
} // namespace Http
namespace CameraRecorder {
namespace Recorder {
class DigooRecorder : public virtual Recorder
{
public:
DigooRecorder(Http::HttpClient* pHttpClient, const Settings& settings);
~DigooRecorder();
virtual std::string Snapshot(ctpl::thread_pool* pThreadPool) override;
virtual std::string Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg) override;
private:
Http::HttpClient* m_pHttpClient;
Settings m_settings;
};
} // namespace Recorder
} // namespace CameraRecorder
#endif // RECORDER_DIGOORECORDER_H
#ifndef RECORDER_DIGOORECORDER_H
#define RECORDER_DIGOORECORDER_H
#include "Recorder.h"
#include "Settings.h"
namespace Http {
class HttpClient;
} // namespace Http
namespace CameraRecorder {
namespace Recorder {
class DigooRecorder : public virtual Recorder
{
public:
DigooRecorder(Http::HttpClient* pHttpClient, const Settings& settings);
~DigooRecorder();
virtual std::string Snapshot(ctpl::thread_pool* pThreadPool) override;
virtual std::string MultiSnapshot(ctpl::thread_pool* pThreadPool, int numberOfImages) override;
virtual std::string Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg) override;
private:
Http::HttpClient* m_pHttpClient;
Settings m_settings;
};
} // namespace Recorder
} // namespace CameraRecorder
#endif // RECORDER_DIGOORECORDER_H
Recorder/FoscamRecorder.cpp
+118 -71
View File
@@ -1,71 +1,118 @@
#include "FoscamRecorder.h"
#include "Util.h"
#include <HttpClient.h>
#include <Logging.h>
#include <fstream>
#include <sstream>
#include <thread>
namespace CameraRecorder {
namespace Recorder {
FoscamRecorder::FoscamRecorder(Http::HttpClient* pHttpClient, const Settings& settings) :
m_pHttpClient(pHttpClient),
m_settings(settings)
{
}
FoscamRecorder::~FoscamRecorder()
{
}
std::string FoscamRecorder::Snapshot(ctpl::thread_pool* pThreadPool)
{
Logging::Log(Logging::Severity::Debug, "FoscamRecorder Snapshot");
std::stringstream url;
url << "http://" << m_settings.IpAddress << ":" << m_settings.Port << "/cgi-bin/CGIProxy.fcgi?cmd=snapPicture2&usr=" << m_settings.Username << "&pwd=" << m_settings.Password;
std::stringstream fileName;
fileName << m_settings.Path << "/" << m_settings.IpAddress << "/" << GetDateTimeString() << ".jpg";
try
{
std::ofstream file(fileName.str());
file << m_pHttpClient->GetUrlContents(url.str());
file.close();
}
catch (const std::exception& e)
{
std::stringstream ss;
ss << "CameraDevice::PerformFoscamAction() - Error: " << e.what() << std::endl;
Logging::Log(Logging::Severity::Error, ss.str());
return std::string();
}
return fileName.str();
}
std::string FoscamRecorder::Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg)
{
Logging::Log(Logging::Severity::Debug, "FoscamRecorder Video");
int port = 65534;
std::stringstream url;
url << "rtsp://" << m_settings.Username << ":" << m_settings.Password << "@" << m_settings.IpAddress << ":" << port << "/videoSub";
std::stringstream fileName;
fileName << m_settings.Path << "/" << m_settings.IpAddress << "/" << GetDateTimeString() << ".mp4";
std::stringstream command;
command << ffmpeg << " -i \"" << url.str() << "\" -t 30 -c:v copy -an -strict experimental " << fileName.str() << " > /dev/null 2>&1";
std::string cmd(command.str());
Logging::Log(Logging::Severity::Debug, cmd);
pThreadPool->push( [cmd](int) { int retval = std::system(cmd.c_str()); } );
return fileName.str();
}
} // namespace Recorder
} // namespace CameraRecorder
#include "FoscamRecorder.h"
#include "Util.h"
#include <HttpClient.h>
#include <JpegImageCollection.h>
#include <Logging.h>
#include <filesystem/path.h>
#include <fstream>
#include <sstream>
#include <thread>
namespace CameraRecorder {
namespace Recorder {
FoscamRecorder::FoscamRecorder(Http::HttpClient* pHttpClient, const Settings& settings) :
m_pHttpClient(pHttpClient),
m_settings(settings)
{
}
FoscamRecorder::~FoscamRecorder()
{
}
std::string FoscamRecorder::Snapshot(ctpl::thread_pool* pThreadPool)
{
Logging::Log(Logging::Severity::Debug, "FoscamRecorder Snapshot");
std::string dateTimeString = GetDateTimeString();
std::string fileName = GetFileName(m_settings, "jpg", dateTimeString);
Http::HttpClient* pHttpClient = m_pHttpClient;
Settings settings = m_settings;
pThreadPool->push( [pHttpClient, settings, dateTimeString](int) { FoscamRecorder::Snapshots(pHttpClient, settings, dateTimeString, 1); } );
return fileName;
}
std::string FoscamRecorder::MultiSnapshot(ctpl::thread_pool* pThreadPool, int numberOfImages)
{
Logging::Log(Logging::Severity::Debug, "FoscamRecorder MultiSnapshot");
std::string dateTimeString = GetDateTimeString();
std::string fileName = GetFileName(m_settings, "jpg", dateTimeString);
Http::HttpClient* pHttpClient = m_pHttpClient;
Settings settings = m_settings;
pThreadPool->push( [pHttpClient, settings, dateTimeString, numberOfImages](int) { FoscamRecorder::Snapshots(pHttpClient, settings, dateTimeString, numberOfImages); } );
return fileName;
}
std::string FoscamRecorder::Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg)
{
Logging::Log(Logging::Severity::Debug, "FoscamRecorder Video");
int port = 65534;
std::stringstream url;
url << "rtsp://" << m_settings.Username << ":" << m_settings.Password << "@" << m_settings.IpAddress << ":" << port << "/videoSub";
std::string dateTimeString = GetDateTimeString();
std::string fileName = GetFileName(m_settings, "mp4", dateTimeString);
std::stringstream command;
command << ffmpeg << " -i \"" << url.str() << "\" -t 30 -c:v copy -an -strict experimental " << fileName << " > /dev/null 2>&1";
std::string cmd(command.str());
Logging::Log(Logging::Severity::Debug, cmd);
pThreadPool->push( [cmd](int) { int retval = std::system(cmd.c_str()); } );
return fileName;
}
std::string FoscamRecorder::GetFileName(const Settings& settings, const std::string& extension, const std::string& dateTimeString)
{
filesystem::path fileLocation(settings.Path);
fileLocation = fileLocation / filesystem::path(settings.IpAddress);
std::string fileName = std::string(dateTimeString).append(".").append(extension);
filesystem::path fullFileName = fileLocation / filesystem::path(fileName);
return fullFileName.str();
}
void FoscamRecorder::Snapshots(Http::HttpClient* pHttpClient, const Settings& settings, std::string dateTimeString, int numberOfImages)
{
std::vector<Image::JpegImage> images;
for (int i = 0; i < numberOfImages; ++i)
images.push_back(FoscamRecorder::Snapshot(pHttpClient, settings));
Image::JpegImageCollection collection(images);
collection.Save(FoscamRecorder::GetFileName(settings, "jpg", dateTimeString));
}
Image::JpegImage FoscamRecorder::Snapshot(Http::HttpClient* pHttpClient, const Settings& settings)
{
std::stringstream url;
url << "http://" << settings.IpAddress << ":" << settings.Port << "/cgi-bin/CGIProxy.fcgi?cmd=snapPicture2&usr=" << settings.Username << "&pwd=" << settings.Password;
Image::JpegImage image;
try
{
image.SetImageData(pHttpClient->GetUrlContents(url.str()));
}
catch (const std::exception& e)
{
std::stringstream ss;
ss << "FoscamRecorder::Snapshot() - Error: " << e.what() << std::endl;
Logging::Log(Logging::Severity::Error, ss.str());
}
return image;
}
} // namespace Recorder
} // namespace CameraRecorder
Recorder/FoscamRecorder.h
+41 -34
View File
@@ -1,34 +1,41 @@
#ifndef RECORDER_FOSCAMRECORDER_H
#define RECORDER_FOSCAMRECORDER_H
#include "Recorder.h"
#include "Settings.h"
namespace Http {
class HttpClient;
} // namespace Http
namespace CameraRecorder {
namespace Recorder {
class FoscamRecorder : public virtual Recorder
{
public:
FoscamRecorder(Http::HttpClient* pHttpClient, const Settings& settings);
~FoscamRecorder();
virtual std::string Snapshot(ctpl::thread_pool* pThreadPool) override;
virtual std::string Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg) override;
private:
Http::HttpClient* m_pHttpClient;
Settings m_settings;
};
} // namespace Recorder
} // namespace CameraRecorder
#endif // RECORDER_FOSCAMRECORDER_H
#ifndef RECORDER_FOSCAMRECORDER_H
#define RECORDER_FOSCAMRECORDER_H
#include "Recorder.h"
#include "Settings.h"
#include <JpegImage.h>
namespace Http {
class HttpClient;
} // namespace Http
namespace CameraRecorder {
namespace Recorder {
class FoscamRecorder : public virtual Recorder
{
public:
FoscamRecorder(Http::HttpClient* pHttpClient, const Settings& settings);
~FoscamRecorder();
virtual std::string Snapshot(ctpl::thread_pool* pThreadPool) override;
virtual std::string MultiSnapshot(ctpl::thread_pool* pThreadPool, int numberOfImages) override;
virtual std::string Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg) override;
private:
static std::string GetFileName(const Settings& settings, const std::string& extension, const std::string& dateTimeString);
static void Snapshots(Http::HttpClient* pHttpClient, const Settings& settings, std::string dateTimeString, int numberOfImages);
static Image::JpegImage Snapshot(Http::HttpClient* pHttpClient, const Settings& settings);
private:
Http::HttpClient* m_pHttpClient;
Settings m_settings;
};
} // namespace Recorder
} // namespace CameraRecorder
#endif // RECORDER_FOSCAMRECORDER_H
Recorder/Recorder.cpp
+16 -16
View File
@@ -1,16 +1,16 @@
#include "Recorder.h"
namespace CameraRecorder {
namespace Recorder {
Recorder::Recorder()
{
}
Recorder::~Recorder()
{
}
} // namespace Recorder
} // namespace CameraRecorder
#include "Recorder.h"
namespace CameraRecorder {
namespace Recorder {
Recorder::Recorder()
{
}
Recorder::~Recorder()
{
}
} // namespace Recorder
} // namespace CameraRecorder
Recorder/Recorder.h
+25 -24
View File
@@ -1,24 +1,25 @@
#ifndef RECORDER_RECORDER_H
#define RECORDER_RECORDER_H
#include <ctpl_stl.h>
#include <string>
namespace CameraRecorder {
namespace Recorder {
class Recorder
{
public:
Recorder();
~Recorder();
virtual std::string Snapshot(ctpl::thread_pool* pThreadPool) = 0;
virtual std::string Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg) = 0;
};
} // namespace Recorder
} // namespace CameraRecorder
#endif // RECORDER_RECORDER_H
#ifndef RECORDER_RECORDER_H
#define RECORDER_RECORDER_H
#include <ctpl_stl.h>
#include <string>
namespace CameraRecorder {
namespace Recorder {
class Recorder
{
public:
Recorder();
~Recorder();
virtual std::string Snapshot(ctpl::thread_pool* pThreadPool) = 0;
virtual std::string MultiSnapshot(ctpl::thread_pool* pThreadPool, int numberOfImages) = 0;
virtual std::string Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg) = 0;
};
} // namespace Recorder
} // namespace CameraRecorder
#endif // RECORDER_RECORDER_H
Recorder/Settings.h
+22 -22
View File
@@ -1,22 +1,22 @@
#ifndef RECORDER_SETTINGS_H
#define RECORDER_SETTINGS_H
#include <string>
namespace CameraRecorder {
namespace Recorder {
struct Settings
{
std::string Path;
std::string IpAddress;
std::string Port;
std::string Username;
std::string Password;
};
} // namespace Recorder
} // namespace CameraRecorder
#endif // RECORDER_SETTINGS_H
#ifndef RECORDER_SETTINGS_H
#define RECORDER_SETTINGS_H
#include <string>
namespace CameraRecorder {
namespace Recorder {
struct Settings
{
std::string Path;
std::string IpAddress;
std::string Port;
std::string Username;
std::string Password;
};
} // namespace Recorder
} // namespace CameraRecorder
#endif // RECORDER_SETTINGS_H
Recorder/Util.cpp
+25 -25
View File
@@ -1,25 +1,25 @@
#include "Util.h"
#include <array>
#include <ctime>
namespace CameraRecorder {
namespace Recorder {
std::string GetDateTimeString(bool omitSeparator)
{
std::array<char, 17> buffer;
buffer.fill(0);
std::time_t t = std::time(nullptr);
std::tm* tm = std::localtime(&t);
if (omitSeparator)
strftime(buffer.data(), sizeof(buffer), "%Y%m%d%H%M%S", tm);
else
strftime(buffer.data(), sizeof(buffer), "%Y%m%d-%H%M%S", tm);
return buffer.data();
}
} // namespace Recorder
} // namespace CameraRecorder
#include "Util.h"
#include <array>
#include <ctime>
namespace CameraRecorder {
namespace Recorder {
std::string GetDateTimeString(bool omitSeparator)
{
std::array<char, 17> buffer;
buffer.fill(0);
std::time_t t = std::time(nullptr);
std::tm* tm = std::localtime(&t);
if (omitSeparator)
strftime(buffer.data(), sizeof(buffer), "%Y%m%d%H%M%S", tm);
else
strftime(buffer.data(), sizeof(buffer), "%Y%m%d-%H%M%S", tm);
return buffer.data();
}
} // namespace Recorder
} // namespace CameraRecorder
Recorder/Util.h
+15 -15
View File
@@ -1,15 +1,15 @@
#ifndef RECORDER_UTIL_H
#define RECORDER_UTIL_H
#include <string>
namespace CameraRecorder {
namespace Recorder {
std::string GetDateTimeString(bool omitSeparator = false);
} // namespace Recorder
} // namespace CameraRecorder
#endif // RECORDER_UTIL_H
#ifndef RECORDER_UTIL_H
#define RECORDER_UTIL_H
#include <string>
namespace CameraRecorder {
namespace Recorder {
std::string GetDateTimeString(bool omitSeparator = false);
} // namespace Recorder
} // namespace CameraRecorder
#endif // RECORDER_UTIL_H
Recorder/VStarCamRecorder.cpp
+108 -74
View File
@@ -1,74 +1,108 @@
#include "VStarCamRecorder.h"
#include "Util.h"
#include <HttpClient.h>
#include <Logging.h>
#include <fstream>
#include <sstream>
namespace CameraRecorder {
namespace Recorder {
VStarCamRecorder::VStarCamRecorder(Http::HttpClient* pHttpClient, const Settings& settings) :
m_pHttpClient(pHttpClient),
m_settings(settings)
{
}
VStarCamRecorder::~VStarCamRecorder()
{
}
std::string VStarCamRecorder::Snapshot(ctpl::thread_pool* pThreadPool)
{
Logging::Log(Logging::Severity::Debug, "VStarCamRecorder Snapshot");
std::stringstream url;
url << "http://" << m_settings.Username << ":" << m_settings.Password << "@" << m_settings.IpAddress << ":" << m_settings.Port << "/img/snapshot.cgi?res=0";
std::stringstream fileName;
fileName << m_settings.Path << "/" << m_settings.IpAddress << "/VSTA000000XXXXX_0_" << GetDateTimeString(true);
int i = 0;
while (i < 3)
{
try
{
std::ofstream file(fileName.str() + "_" + std::to_string(i) + ".jpg");
file << m_pHttpClient->GetUrlContents(url.str());
file.close();
}
catch (const std::exception& e)
{
std::stringstream ss;
ss << "CameraDevice::PerformVStarCamAction() - Error: " << e.what() << std::endl;
Logging::Log(Logging::Severity::Error, ss.str());
}
++i;
}
return fileName.str() + "_0.jpg";
}
std::string VStarCamRecorder::Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg)
{
Logging::Log(Logging::Severity::Debug, "VStarCamRecorder Video");
int port = 10554;
std::stringstream url;
url << "rtsp://" << m_settings.Username << ":" << m_settings.Password << "@" << m_settings.IpAddress << ":" << port << "/udp/av0_0";
std::stringstream fileName;
fileName << m_settings.Path << "/" << m_settings.IpAddress << "/VSTA000000XXXXX_0_" << GetDateTimeString(true) << ".mp4";
std::stringstream command;
command << ffmpeg << " -i \"" << url.str() << "\" -t 30 -c:v copy -c:a aac -strict experimental " << fileName.str() << " > /dev/null 2>&1";
std::string cmd(command.str());
Logging::Log(Logging::Severity::Debug, cmd);
pThreadPool->push( [cmd](int) { int retval = std::system(cmd.c_str()); } );
return fileName.str();
}
} // namespace Recorder
} // namespace CameraRecorder
#include "VStarCamRecorder.h"
#include "Util.h"
#include <HttpClient.h>
#include <Logging.h>
#include <fstream>
#include <sstream>
namespace CameraRecorder {
namespace Recorder {
VStarCamRecorder::VStarCamRecorder(Http::HttpClient* pHttpClient, const Settings& settings) :
m_pHttpClient(pHttpClient),
m_settings(settings)
{
}
VStarCamRecorder::~VStarCamRecorder()
{
}
std::string VStarCamRecorder::Snapshot(ctpl::thread_pool* pThreadPool)
{
Logging::Log(Logging::Severity::Debug, "VStarCamRecorder Snapshot");
std::string dateTimeString = GetDateTimeString(true);
std::string fileName = GetFileName(m_settings, "jpg", dateTimeString, 0);
Http::HttpClient* pHttpClient = m_pHttpClient;
Settings settings = m_settings;
pThreadPool->push( [pHttpClient, settings, dateTimeString](int) { VStarCamRecorder::Snapshots(pHttpClient, settings, dateTimeString, 1); } );
return fileName;
}
std::string VStarCamRecorder::MultiSnapshot(ctpl::thread_pool* pThreadPool, int numberOfImages)
{
Logging::Log(Logging::Severity::Debug, "VStarCamRecorder MultiSnapshot");
std::string dateTimeString = GetDateTimeString(true);
std::string fileName = GetFileName(m_settings, "jpg", dateTimeString, 0);
Http::HttpClient* pHttpClient = m_pHttpClient;
Settings settings = m_settings;
pThreadPool->push( [pHttpClient, settings, dateTimeString, numberOfImages](int) { VStarCamRecorder::Snapshots(pHttpClient, settings, dateTimeString, numberOfImages); } );
return fileName;
}
std::string VStarCamRecorder::Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg)
{
Logging::Log(Logging::Severity::Debug, "VStarCamRecorder Video");
int port = 10554;
std::stringstream url;
url << "rtsp://" << m_settings.Username << ":" << m_settings.Password << "@" << m_settings.IpAddress << ":" << port << "/udp/av0_0";
std::string dateTimeString = GetDateTimeString(true);
std::string fileName = GetFileName(m_settings, "mp4", dateTimeString, 0);
std::stringstream command;
command << ffmpeg << " -i \"" << url.str() << "\" -t 30 -c:v copy -c:a aac -strict experimental " << fileName << " > /dev/null 2>&1";
std::string cmd(command.str());
Logging::Log(Logging::Severity::Debug, cmd);
pThreadPool->push( [cmd](int) { int retval = std::system(cmd.c_str()); } );
return fileName;
}
std::string VStarCamRecorder::GetFileName(const Settings& settings, const std::string& extension, const std::string& dateTimeString, int imageIndex)
{
filesystem::path fileLocation(settings.Path);
fileLocation = fileLocation / filesystem::path(settings.IpAddress);
std::string fileName = std::string("VSTA000000XXXXX_0_").append(dateTimeString).append("_").append(std::to_string(imageIndex)).append(".").append(extension);
filesystem::path fullFileName = fileLocation / filesystem::path(fileName);
return fullFileName.str();
}
void VStarCamRecorder::Snapshots(Http::HttpClient* pHttpClient, const Settings& settings, std::string dateTimeString, int numberOfImages)
{
for (int i = 0; i < numberOfImages; ++i)
VStarCamRecorder::Snapshot(pHttpClient, settings, VStarCamRecorder::GetFileName(settings, "jpg", dateTimeString, i));
}
void VStarCamRecorder::Snapshot(Http::HttpClient* pHttpClient, const Settings& settings, const filesystem::path& fileName)
{
std::stringstream url;
url << "http://" << settings.Username << ":" << settings.Password << "@" << settings.IpAddress << ":" << settings.Port << "/img/snapshot.cgi?res=0";
try
{
std::ofstream file(fileName.str());
file << pHttpClient->GetUrlContents(url.str());
file.close();
}
catch (const std::exception& e)
{
std::stringstream ss;
ss << "VStarCamRecorder::Snapshot() - Error: " << e.what() << std::endl;
Logging::Log(Logging::Severity::Error, ss.str());
}
}
} // namespace Recorder
} // namespace CameraRecorder
Recorder/VStarCamRecorder.h
+41 -34
View File
@@ -1,34 +1,41 @@
#ifndef RECORDER_VSTARCAMRECORDER_H
#define RECORDER_VSTARCAMRECORDER_H
#include "Recorder.h"
#include "Settings.h"
namespace Http {
class HttpClient;
} // namespace Http
namespace CameraRecorder {
namespace Recorder {
class VStarCamRecorder : public virtual Recorder
{
public:
VStarCamRecorder(Http::HttpClient* pHttpClient, const Settings& settings);
~VStarCamRecorder();
virtual std::string Snapshot(ctpl::thread_pool* pThreadPool) override;
virtual std::string Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg) override;
private:
Http::HttpClient* m_pHttpClient;
Settings m_settings;
};
} // namespace Recorder
} // namespace CameraRecorder
#endif // RECORDER_VSTARCAMRECORDER_H
#ifndef RECORDER_VSTARCAMRECORDER_H
#define RECORDER_VSTARCAMRECORDER_H
#include "Recorder.h"
#include "Settings.h"
#include <filesystem/path.h>
namespace Http {
class HttpClient;
} // namespace Http
namespace CameraRecorder {
namespace Recorder {
class VStarCamRecorder : public virtual Recorder
{
public:
VStarCamRecorder(Http::HttpClient* pHttpClient, const Settings& settings);
~VStarCamRecorder();
virtual std::string Snapshot(ctpl::thread_pool* pThreadPool) override;
virtual std::string MultiSnapshot(ctpl::thread_pool* pThreadPool, int numberOfImages) override;
virtual std::string Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg) override;
private:
static std::string GetFileName(const Settings& settings, const std::string& extension, const std::string& dateTimeString, int imageIndex);
static void Snapshots(Http::HttpClient* pHttpClient, const Settings& settings, std::string dateTimeString, int numberOfImages);
static void Snapshot(Http::HttpClient* pHttpClient, const Settings& settings, const filesystem::path& fileName);
private:
Http::HttpClient* m_pHttpClient;
Settings m_settings;
};
} // namespace Recorder
} // namespace CameraRecorder
#endif // RECORDER_VSTARCAMRECORDER_H
Recorder/WatchBotRecorder.cpp
+117 -69
View File
@@ -1,69 +1,117 @@
#include "WatchBotRecorder.h"
#include "Util.h"
#include <HttpClient.h>
#include <Logging.h>
#include <fstream>
#include <sstream>
namespace CameraRecorder {
namespace Recorder {
WatchBotRecorder::WatchBotRecorder(Http::HttpClient* pHttpClient, const Settings& settings) :
m_pHttpClient(pHttpClient),
m_settings(settings)
{
}
WatchBotRecorder::~WatchBotRecorder()
{
}
std::string WatchBotRecorder::Snapshot(ctpl::thread_pool* pThreadPool)
{
Logging::Log(Logging::Severity::Debug, "WatchBotRecorder Snapshot");
std::stringstream url;
url << "http://" << m_settings.IpAddress << ":" << m_settings.Port << "/snapshot.cgi?user=" << m_settings.Username << "&pwd=" << m_settings.Password;
std::stringstream fileName;
fileName << m_settings.Path << "/" << m_settings.IpAddress << "/" << GetDateTimeString() << ".jpg";
try
{
std::ofstream file(fileName.str());
file << m_pHttpClient->GetUrlContents(url.str());
file.close();
}
catch (const std::exception& e)
{
std::stringstream ss;
ss << "CameraDevice::PerformWatchBotAction() - Error: " << e.what() << std::endl;
Logging::Log(Logging::Severity::Error, ss.str());
return std::string();
}
return fileName.str();
}
std::string WatchBotRecorder::Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg)
{
Logging::Log(Logging::Severity::Debug, "WatchBotRecorder Video");
std::stringstream url;
url << "http://" << m_settings.IpAddress << ":" << m_settings.Port << "/videostream.asf?user=" << m_settings.Username << "&pwd=" << m_settings.Password;
std::stringstream fileName;
fileName << m_settings.Path << "/" << m_settings.IpAddress << "/" << GetDateTimeString() << ".mp4";
std::stringstream command;
command << ffmpeg << " -i \"" << url.str() << "\" -t 30 -c:v libx264 -pix_fmt yuv420p -profile:v main -level:v 3.1 -c:a aac -strict experimental " << fileName.str() << " > /dev/null 2>&1";
std::string cmd(command.str());
Logging::Log(Logging::Severity::Debug, cmd);
pThreadPool->push( [cmd](int) { int retval = std::system(cmd.c_str()); } );
return fileName.str();
}
} // namespace Recorder
} // namespace CameraRecorder
#include "WatchBotRecorder.h"
#include "Util.h"
#include <HttpClient.h>
#include <JpegImageCollection.h>
#include <Logging.h>
#include <filesystem/path.h>
#include <fstream>
#include <sstream>
#include <vector>
namespace CameraRecorder {
namespace Recorder {
WatchBotRecorder::WatchBotRecorder(Http::HttpClient* pHttpClient, const Settings& settings) :
m_pHttpClient(pHttpClient),
m_settings(settings)
{
}
WatchBotRecorder::~WatchBotRecorder()
{
}
std::string WatchBotRecorder::Snapshot(ctpl::thread_pool* pThreadPool)
{
Logging::Log(Logging::Severity::Debug, "WatchBotRecorder Snapshot");
std::string dateTimeString = GetDateTimeString();
std::string fileName = GetFileName(m_settings, "jpg", dateTimeString);
Http::HttpClient* pHttpClient = m_pHttpClient;
Settings settings = m_settings;
pThreadPool->push( [pHttpClient, settings, dateTimeString](int) { WatchBotRecorder::Snapshots(pHttpClient, settings, dateTimeString, 1); } );
return fileName;
}
std::string WatchBotRecorder::MultiSnapshot(ctpl::thread_pool* pThreadPool, int numberOfImages)
{
Logging::Log(Logging::Severity::Debug, "WatchBotRecorder MultiSnapshot");
std::string dateTimeString = GetDateTimeString();
std::string fileName = GetFileName(m_settings, "jpg", dateTimeString);
Http::HttpClient* pHttpClient = m_pHttpClient;
Settings settings = m_settings;
pThreadPool->push( [pHttpClient, settings, dateTimeString, numberOfImages](int) { WatchBotRecorder::Snapshots(pHttpClient, settings, dateTimeString, numberOfImages); } );
return fileName;
}
std::string WatchBotRecorder::Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg)
{
Logging::Log(Logging::Severity::Debug, "WatchBotRecorder Video");
std::stringstream url;
url << "http://" << m_settings.IpAddress << ":" << m_settings.Port << "/videostream.asf?user=" << m_settings.Username << "&pwd=" << m_settings.Password;
std::string dateTimeString = GetDateTimeString();
std::string fileName = GetFileName(m_settings, "mp4", dateTimeString);
std::stringstream command;
command << ffmpeg << " -i \"" << url.str() << "\" -t 30 -c:v libx264 -pix_fmt yuv420p -profile:v main -level:v 3.1 -c:a aac -strict experimental " << fileName << " > /dev/null 2>&1";
std::string cmd(command.str());
Logging::Log(Logging::Severity::Debug, cmd);
pThreadPool->push( [cmd](int) { int retval = std::system(cmd.c_str()); } );
return fileName;
}
std::string WatchBotRecorder::GetFileName(const Settings& settings, const std::string& extension, const std::string& dateTimeString)
{
filesystem::path fileLocation(settings.Path);
fileLocation = fileLocation / filesystem::path(settings.IpAddress);
std::string fileName = std::string(dateTimeString).append(".").append(extension);
filesystem::path fullFileName = fileLocation / filesystem::path(fileName);
return fullFileName.str();
}
void WatchBotRecorder::Snapshots(Http::HttpClient* pHttpClient, const Settings& settings, std::string dateTimeString, int numberOfImages)
{
std::vector<Image::JpegImage> images;
for (int i = 0; i < numberOfImages; ++i)
images.push_back(WatchBotRecorder::Snapshot(pHttpClient, settings));
Image::JpegImageCollection collection(images);
collection.Save(WatchBotRecorder::GetFileName(settings, "jpg", dateTimeString));
}
Image::JpegImage WatchBotRecorder::Snapshot(Http::HttpClient* pHttpClient, const Settings& settings)
{
std::stringstream url;
url << "http://" << settings.IpAddress << ":" << settings.Port << "/snapshot.cgi?user=" << settings.Username << "&pwd=" << settings.Password;
Image::JpegImage image;
try
{
image.SetImageData(pHttpClient->GetUrlContents(url.str()));
}
catch (const std::exception& e)
{
std::stringstream ss;
ss << "WatchBotRecorder::Snapshot() - Error: " << e.what() << std::endl;
Logging::Log(Logging::Severity::Error, ss.str());
}
return image;
}
} // namespace Recorder
} // namespace CameraRecorder
Recorder/WatchBotRecorder.h
+41 -34
View File
@@ -1,34 +1,41 @@
#ifndef RECORDER_WATCHBOTRECORDER_H
#define RECORDER_WATCHBOTRECORDER_H
#include "Recorder.h"
#include "Settings.h"
namespace Http {
class HttpClient;
} // namespace Http
namespace CameraRecorder {
namespace Recorder {
class WatchBotRecorder : public virtual Recorder
{
public:
WatchBotRecorder(Http::HttpClient* pHttpClient, const Settings& settings);
~WatchBotRecorder();
virtual std::string Snapshot(ctpl::thread_pool* pThreadPool) override;
virtual std::string Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg) override;
private:
Http::HttpClient* m_pHttpClient;
Settings m_settings;
};
} // namespace Recorder
} // namespace CameraRecorder
#endif // RECORDER_WATCHBOTRECORDER_H
#ifndef RECORDER_WATCHBOTRECORDER_H
#define RECORDER_WATCHBOTRECORDER_H
#include "Recorder.h"
#include "Settings.h"
#include <JpegImage.h>
namespace Http {
class HttpClient;
} // namespace Http
namespace CameraRecorder {
namespace Recorder {
class WatchBotRecorder : public virtual Recorder
{
public:
WatchBotRecorder(Http::HttpClient* pHttpClient, const Settings& settings);
~WatchBotRecorder();
virtual std::string Snapshot(ctpl::thread_pool* pThreadPool) override;
virtual std::string MultiSnapshot(ctpl::thread_pool* pThreadPool, int numberOfImages) override;
virtual std::string Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg) override;
private:
static std::string GetFileName(const Settings& settings, const std::string& extension, const std::string& dateTimeString);
static void Snapshots(Http::HttpClient* pHttpClient, const Settings& settings, std::string dateTimeString, int numberOfImages);
static Image::JpegImage Snapshot(Http::HttpClient* pHttpClient, const Settings& settings);
private:
Http::HttpClient* m_pHttpClient;
Settings m_settings;
};
} // namespace Recorder
} // namespace CameraRecorder
#endif // RECORDER_WATCHBOTRECORDER_H
Recorder/ZModoRecorder.cpp
+38 -32
View File
@@ -1,32 +1,38 @@
#include "ZModoRecorder.h"
#include <HttpClient.h>
#include <Logging.h>
namespace CameraRecorder {
namespace Recorder {
ZModoRecorder::ZModoRecorder(Http::HttpClient* pHttpClient, const Settings& settings) :
m_pHttpClient(pHttpClient),
m_settings(settings)
{
}
ZModoRecorder::~ZModoRecorder()
{
}
std::string ZModoRecorder::Snapshot(ctpl::thread_pool* pThreadPool)
{
Logging::Log(Logging::Severity::Debug, "ZModoRecorder Snapshot");
return std::string();
}
std::string ZModoRecorder::Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg)
{
Logging::Log(Logging::Severity::Debug, "ZModoRecorder Video");
return std::string();
}
} // namespace Recorder
} // namespace CameraRecorder
#include "ZModoRecorder.h"
#include <HttpClient.h>
#include <Logging.h>
namespace CameraRecorder {
namespace Recorder {
ZModoRecorder::ZModoRecorder(Http::HttpClient* pHttpClient, const Settings& settings) :
m_pHttpClient(pHttpClient),
m_settings(settings)
{
}
ZModoRecorder::~ZModoRecorder()
{
}
std::string ZModoRecorder::Snapshot(ctpl::thread_pool* pThreadPool)
{
Logging::Log(Logging::Severity::Debug, "ZModoRecorder Snapshot");
return std::string();
}
std::string ZModoRecorder::MultiSnapshot(ctpl::thread_pool* pThreadPool, int numberOfImages)
{
Logging::Log(Logging::Severity::Debug, "ZModoRecorder MultiSnapshot");
return std::string();
}
std::string ZModoRecorder::Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg)
{
Logging::Log(Logging::Severity::Debug, "ZModoRecorder Video");
return std::string();
}
} // namespace Recorder
} // namespace CameraRecorder
Recorder/ZModoRecorder.h
+35 -34
View File
@@ -1,34 +1,35 @@
#ifndef RECORDER_ZMODORECORDER_H
#define RECORDER_ZMODORECORDER_H
#include "Recorder.h"
#include "Settings.h"
namespace Http {
class HttpClient;
} // namespace Http
namespace CameraRecorder {
namespace Recorder {
class ZModoRecorder : public virtual Recorder
{
public:
ZModoRecorder(Http::HttpClient* pHttpClient, const Settings& settings);
~ZModoRecorder();
virtual std::string Snapshot(ctpl::thread_pool* pThreadPool) override;
virtual std::string Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg) override;
private:
Http::HttpClient* m_pHttpClient;
Settings m_settings;
};
} // namespace Recorder
} // namespace CameraRecorder
#endif // RECORDER_ZMODORECORDER_H
#ifndef RECORDER_ZMODORECORDER_H
#define RECORDER_ZMODORECORDER_H
#include "Recorder.h"
#include "Settings.h"
namespace Http {
class HttpClient;
} // namespace Http
namespace CameraRecorder {
namespace Recorder {
class ZModoRecorder : public virtual Recorder
{
public:
ZModoRecorder(Http::HttpClient* pHttpClient, const Settings& settings);
~ZModoRecorder();
virtual std::string Snapshot(ctpl::thread_pool* pThreadPool) override;
virtual std::string MultiSnapshot(ctpl::thread_pool* pThreadPool, int numberOfImages) override;
virtual std::string Video(ctpl::thread_pool* pThreadPool, const std::string& ffmpeg) override;
private:
Http::HttpClient* m_pHttpClient;
Settings m_settings;
};
} // namespace Recorder
} // namespace CameraRecorder
#endif // RECORDER_ZMODORECORDER_H