zii/JustMotion
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
83080cfe41
JustMotion/src/common.cpp

541 lines
16 KiB
C++
Raw Normal View History

v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
// This file is part of Motion Watch.
// Motion Watch is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Motion Watch is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
#include "common.h"
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
QString getParam(const QString &key, const QStringList &args)
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
{
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
// this can be used by command objects to pick out parameters
// from a command line that are pointed by a name identifier
// example: -i /etc/some_file, this function should pick out
// "/etc/some_file" from args if "-i" is passed into key.
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
QString ret;
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
int pos = args.indexOf(QRegularExpression(key, QRegularExpression::CaseInsensitiveOption));
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
if (pos != -1)
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
{
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
// key found.
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
if ((pos + 1) <= (args.size() - 1))
v2.0.t1 Completely reformed the internal workings of the application code. I brought back multi-threaded functions so there is now 5 separate threads for different tasks. recLoop() - this function calls ffmpeg to begin recording footage from the defined camera and stores the footage in hls format. It is designed to keep running for as long as the application is running and if it does stop for whatever reason, it will attempt to auto re-start. upkeep() - this function does regular cleanup and enforcement of maxDays maxLogSize and maxEvents without the need to stop recording or detecting motion. detectMo() - this function reads directly from recLoop's hls output and list all footage that has motion in it. motion detection no longer has to wait for the clip to finish recording thanks to the use of .ts containers for the video clips. this makes the motion detection for less cpu intensive now that it will now operate at the camera's fps (slower). eventLoop() - this function reads the motion list from detectMo and copies the footage pointed out by the list to an events folder, also in hls format. schLoop() - this function runs an optional user defined external command every amount of seconds defined in sch_sec. this command temporary stops motion detection without actually terminating the thread. It will also not run the command at the scheduled time if motion was detected. Benefits to this reform: - far less cpu intensive operation - multi-threaded architecture for better asynchronous operation - it has support for live streaming now that hls is being used - a buff_dir is no longer necessary
2023-03-05 16:07:07 -05:00
{
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
// check ahead to make sure pos + 1 will not go out
// of range.
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
if (!args[pos + 1].startsWith("-"))
v1.5.t4 The error checking with ffmpeg is not working. Learned that it doesn't always return 0 on success. Decided to remove the error checking altogether. Instead ffmpeg failures should be checked manually using stderr. Dirent includes .. and . so I decided to switch to the filesystem entry listing that should hopefully exclude those special directories. The camera webroot was not generating .index files. those files would only get generated if motion was detected. Copied the code that does that onto recLoop() to execute regardless of motion.
2022-12-11 12:33:56 -05:00
{
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
// the "-" used throughout this application
// indicates an argument so the above 'if'
// statement will check to make sure it does
// not return another argument as a parameter
// in case a back-to-back "-arg -arg" is
// present.
ret = args[pos + 1];
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
}
}
}
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
return ret;
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
}
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
QStringList lsFilesInDir(const QString &path, const QString &ext)
v1.5.t1 Decided to switch using opencv's builtin pixel diff motion detection via absdiff and thresh. Doing this should increase efficiency instead of using the home brewed pixel loops and threads. Added a web interface of sorts by having html files output along with the video clips. These files are designed to link together with the assumption that the output directory is a web root like /var/www/html that apache2 uses. The interface is crude at best but at least allow playback of recorded footage. Added max_clips config variable that can limit the amount of motion events that can recorded to storage on a single day.
2022-12-04 15:13:39 -05:00
{
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
QStringList filters;
v1.5.t9 The app is hard crashing now but I was able to determine the cause this time. Must functions in filesystem tend to abort if the filesystem object doesn't exists. Added protection where needed to prevent crashing
2022-12-13 21:13:10 -05:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
filters << "*" + ext;
v2.0.t13 Fixed the crashing issue by adding tcp timeout args to ffmpeg and having the app handle empty frames from a disconnected camera better. Reformed the directory structure by having live, logs and events in seperate directories. schLoop() no longer exists, postCmd is now handled by detectMoInStream() to ensure motion detection is not done while the command is running.
2023-03-26 10:32:56 -04:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
QDir dirObj(path);
v2.0.t3 Event recordings are not writing out correctly. added more log lines to help debug.
2023-03-10 19:35:44 -05:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
dirObj.setFilter(QDir::Files);
dirObj.setNameFilters(filters);
dirObj.setSorting(QDir::Name);
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
return dirObj.entryList();
}
v2.0.t1 Completely reformed the internal workings of the application code. I brought back multi-threaded functions so there is now 5 separate threads for different tasks. recLoop() - this function calls ffmpeg to begin recording footage from the defined camera and stores the footage in hls format. It is designed to keep running for as long as the application is running and if it does stop for whatever reason, it will attempt to auto re-start. upkeep() - this function does regular cleanup and enforcement of maxDays maxLogSize and maxEvents without the need to stop recording or detecting motion. detectMo() - this function reads directly from recLoop's hls output and list all footage that has motion in it. motion detection no longer has to wait for the clip to finish recording thanks to the use of .ts containers for the video clips. this makes the motion detection for less cpu intensive now that it will now operate at the camera's fps (slower). eventLoop() - this function reads the motion list from detectMo and copies the footage pointed out by the list to an events folder, also in hls format. schLoop() - this function runs an optional user defined external command every amount of seconds defined in sch_sec. this command temporary stops motion detection without actually terminating the thread. It will also not run the command at the scheduled time if motion was detected. Benefits to this reform: - far less cpu intensive operation - multi-threaded architecture for better asynchronous operation - it has support for live streaming now that hls is being used - a buff_dir is no longer necessary
2023-03-05 16:07:07 -05:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
QStringList lsDirsInDir(const QString &path)
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
{
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
QDir dirObj(path);
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
dirObj.setFilter(QDir::Dirs | QDir::NoDotAndDotDot);
dirObj.setSorting(QDir::Name);
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
return dirObj.entryList();
}
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
v3.0.t6 The Qt approach to grabbing frames from the live stream was also a failure. - decided to switch to a combination ffmpeg and imagemagic was external commands to do motion detection. this approach elimates the need for opencv altogeather so it was removed from the project. system resource usage appears to be decent and perhaps better than opencv.
2023-05-26 16:12:53 -04:00
QStringList listFacingFiles(const QString &path, const QString &ext, const QDateTime &stamp, int secs, char dir)
{
QStringList ret;
for (auto i = 0; i < secs; ++i)
{
QString filePath;
if (dir == '-') filePath = path + "/" + stamp.addSecs(-i).toString(DATETIME_FMT) + ext;
if (dir == '+') filePath = path + "/" + stamp.addSecs(i).toString(DATETIME_FMT) + ext;
if (QFile::exists(filePath))
{
if (dir == '-') ret.insert(0, filePath);
if (dir == '+') ret.append(filePath);
}
}
return ret;
}
QStringList backwardFacingFiles(const QString &path, const QString &ext, const QDateTime &stamp, int secs)
{
return listFacingFiles(path, ext, stamp, secs, '-');
}
QStringList forwardFacingFiles(const QString &path, const QString &ext, const QDateTime &stamp, int secs)
{
return listFacingFiles(path, ext, stamp, secs, '+');
}
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
void enforceMaxEvents(shared_t *share)
{
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
auto names = lsFilesInDir(share->outDir, share->recExt);
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
while (names.size() > share->maxEvents)
{
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
auto nameOnly = share->outDir + "/" + names[0];
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
nameOnly.chop(share->recExt.size());
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
auto vidFile = nameOnly + share->recExt;
auto imgFile = nameOnly + share->thumbExt;
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
QFile::remove(vidFile);
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
QFile::remove(imgFile);
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
names.removeFirst();
}
v2.1.t2 the delay on the motion detection loop slowed it down too much to the point that it falls too far behind live. I removed the delay and re-introduced the frame gap so all frames in the video files need to be decoded. post command and event timers are now seperate but still tied to a single thread so they can still be synced. fixed an issued that cuased several thmubnails to not generate. added more log lines the aid with debugging.
2023-04-20 14:52:59 -04:00
}
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
void enforceMaxImages(shared_t *share)
v3.0.t6 The Qt approach to grabbing frames from the live stream was also a failure. - decided to switch to a combination ffmpeg and imagemagic was external commands to do motion detection. this approach elimates the need for opencv altogeather so it was removed from the project. system resource usage appears to be decent and perhaps better than opencv.
2023-05-26 16:12:53 -04:00
{
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
auto names = lsFilesInDir(share->tmpDir + "/img", ".bmp");
v3.0.t6 The Qt approach to grabbing frames from the live stream was also a failure. - decided to switch to a combination ffmpeg and imagemagic was external commands to do motion detection. this approach elimates the need for opencv altogeather so it was removed from the project. system resource usage appears to be decent and perhaps better than opencv.
2023-05-26 16:12:53 -04:00
while (names.size() > MAX_IMAGES)
{
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
QFile::remove(share->tmpDir + "/img/" + names[0]);
v3.0.t6 The Qt approach to grabbing frames from the live stream was also a failure. - decided to switch to a combination ffmpeg and imagemagic was external commands to do motion detection. this approach elimates the need for opencv altogeather so it was removed from the project. system resource usage appears to be decent and perhaps better than opencv.
2023-05-26 16:12:53 -04:00
names.removeFirst();
}
}
v3.3.t1 -removed the web interface. this project will instead continue to focus on backend operations. external applications can interface with the buf/rec directories to provide frontend operations. -removed the magick binary file from the project. magick will instead be built from source on the target machine for maximum support for the target architecture. -stream codec and format are now user configurable. -recording thumbnail and video formats are now user configurable.
2023-10-08 10:09:15 -04:00
void enforceMaxVids(shared_t *share)
v3.0.t13 -removed use of evtHist. will instead allow eventLoop to que up duplicate live video clips and then remove later using QStringList::removeDuplicates(). -changed up the ffmpeg commands to utilize tcp and re-added a tcp timeout argument, removing the need for command stall checking. -added logic to pick the snapshot with the highest diff score as the event thumbnail.
2023-06-09 16:24:32 -04:00
{
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
auto names = lsFilesInDir(share->tmpDir + "/live", share->streamExt);
v3.0.t13 -removed use of evtHist. will instead allow eventLoop to que up duplicate live video clips and then remove later using QStringList::removeDuplicates(). -changed up the ffmpeg commands to utilize tcp and re-added a tcp timeout argument, removing the need for command stall checking. -added logic to pick the snapshot with the highest diff score as the event thumbnail.
2023-06-09 16:24:32 -04:00
while (names.size() > MAX_VIDEOS)
{
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
QFile::remove(share->tmpDir + "/live/" + names[0]);
v3.0.t13 -removed use of evtHist. will instead allow eventLoop to que up duplicate live video clips and then remove later using QStringList::removeDuplicates(). -changed up the ffmpeg commands to utilize tcp and re-added a tcp timeout argument, removing the need for command stall checking. -added logic to pick the snapshot with the highest diff score as the event thumbnail.
2023-06-09 16:24:32 -04:00
names.removeFirst();
}
}
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
void rdLine(const QString &param, const QString &line, QString *value)
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
{
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
if (line.startsWith(param))
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
{
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
*value = line.mid(param.size());
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
}
}
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
void rdLine(const QString &param, const QString &line, int *value)
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
{
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
if (line.startsWith(param))
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
{
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
*value = line.mid(param.size()).toInt();
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
}
}
v3.3.t1 -removed the web interface. this project will instead continue to focus on backend operations. external applications can interface with the buf/rec directories to provide frontend operations. -removed the magick binary file from the project. magick will instead be built from source on the target machine for maximum support for the target architecture. -stream codec and format are now user configurable. -recording thumbnail and video formats are now user configurable.
2023-10-08 10:09:15 -04:00
void rdLine(const QString &param, const QString &line, bool *value)
{
if (line.startsWith(param))
{
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
auto val = line.mid(param.size()).trimmed();
*value = (val == "y" || val == "Y");
v3.3.t1 -removed the web interface. this project will instead continue to focus on backend operations. external applications can interface with the buf/rec directories to provide frontend operations. -removed the magick binary file from the project. magick will instead be built from source on the target machine for maximum support for the target architecture. -stream codec and format are now user configurable. -recording thumbnail and video formats are now user configurable.
2023-10-08 10:09:15 -04:00
}
}
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
void extCorrection(QString &ext)
v3.1.t2 added a buffer directory so the actual work of image frame capture and live video recording can be moved off of main storage. also removed installation of the apache2 http server from install.sh to make this app more agnostic and leave it up to the end user to install what ever web server they want.
2023-07-18 18:47:14 -04:00
{
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
if (!ext.startsWith("."))
v3.1.t2 added a buffer directory so the actual work of image frame capture and live video recording can be moved off of main storage. also removed installation of the apache2 http server from install.sh to make this app more agnostic and leave it up to the end user to install what ever web server they want.
2023-07-18 18:47:14 -04:00
{
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
ext = "." + ext;
v3.1.t2 added a buffer directory so the actual work of image frame capture and live video recording can be moved off of main storage. also removed installation of the apache2 http server from install.sh to make this app more agnostic and leave it up to the end user to install what ever web server they want.
2023-07-18 18:47:14 -04:00
}
}
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
bool mkPath(const QString &path)
v3.3.t1 -removed the web interface. this project will instead continue to focus on backend operations. external applications can interface with the buf/rec directories to provide frontend operations. -removed the magick binary file from the project. magick will instead be built from source on the target machine for maximum support for the target architecture. -stream codec and format are now user configurable. -recording thumbnail and video formats are now user configurable.
2023-10-08 10:09:15 -04:00
{
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
auto ret = true;
if (!QDir().exists(path))
v3.3.t1 -removed the web interface. this project will instead continue to focus on backend operations. external applications can interface with the buf/rec directories to provide frontend operations. -removed the magick binary file from the project. magick will instead be built from source on the target machine for maximum support for the target architecture. -stream codec and format are now user configurable. -recording thumbnail and video formats are now user configurable.
2023-10-08 10:09:15 -04:00
{
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
ret = QDir().mkpath(path);
v3.3.t1 -removed the web interface. this project will instead continue to focus on backend operations. external applications can interface with the buf/rec directories to provide frontend operations. -removed the magick binary file from the project. magick will instead be built from source on the target machine for maximum support for the target architecture. -stream codec and format are now user configurable. -recording thumbnail and video formats are now user configurable.
2023-10-08 10:09:15 -04:00
}
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
return ret;
v3.3.t1 -removed the web interface. this project will instead continue to focus on backend operations. external applications can interface with the buf/rec directories to provide frontend operations. -removed the magick binary file from the project. magick will instead be built from source on the target machine for maximum support for the target architecture. -stream codec and format are now user configurable. -recording thumbnail and video formats are now user configurable.
2023-10-08 10:09:15 -04:00
}
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
bool rdConf(const QString &filePath, shared_t *share)
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
{
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
QFile varFile(filePath);
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
if (!varFile.open(QFile::ReadOnly))
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
{
share->retCode = ENOENT;
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
QTextStream(stderr) << "err: config file - " << filePath << " does not exists or lack read permissions." << Qt::endl;
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
}
else
{
v3.3.t1 -removed the web interface. this project will instead continue to focus on backend operations. external applications can interface with the buf/rec directories to provide frontend operations. -removed the magick binary file from the project. magick will instead be built from source on the target machine for maximum support for the target architecture. -stream codec and format are now user configurable. -recording thumbnail and video formats are now user configurable.
2023-10-08 10:09:15 -04:00
share->recordUri.clear();
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
share->postCmd.clear();
share->camName.clear();
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
auto thrCount = QThread::idealThreadCount() / 2;
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
v3.3.t1 -removed the web interface. this project will instead continue to focus on backend operations. external applications can interface with the buf/rec directories to provide frontend operations. -removed the magick binary file from the project. magick will instead be built from source on the target machine for maximum support for the target architecture. -stream codec and format are now user configurable. -recording thumbnail and video formats are now user configurable.
2023-10-08 10:09:15 -04:00
share->retCode = 0;
share->imgThresh = 8000;
share->maxEvents = 100;
share->maxLogSize = 100000;
share->skipCmd = false;
share->postSecs = 60;
share->evMaxSecs = 30;
share->conf = filePath;
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
share->buffPath = "/var/buffer";
share->recPath = "/var/footage";
v3.3.t1 -removed the web interface. this project will instead continue to focus on backend operations. external applications can interface with the buf/rec directories to provide frontend operations. -removed the magick binary file from the project. magick will instead be built from source on the target machine for maximum support for the target architecture. -stream codec and format are now user configurable. -recording thumbnail and video formats are now user configurable.
2023-10-08 10:09:15 -04:00
share->outputType = "stderr";
share->compCmd = "magick compare -metric FUZZ " + QString(PREV_IMG) + " " + QString(NEXT_IMG) + " /dev/null";
share->streamCodec = "copy";
share->streamExt = ".ts";
share->recExt = ".mp4";
share->thumbExt = ".jpg";
share->singleTenant = false;
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
share->imgThreads = thrCount;
share->recThreads = thrCount;
share->recFps = 30;
share->recScale = "1280:720";
share->imgScale = "320:240";
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
QString line;
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
do
{
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
line = QString::fromUtf8(varFile.readLine());
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
if (!line.startsWith("#"))
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
{
v3.3.t1 -removed the web interface. this project will instead continue to focus on backend operations. external applications can interface with the buf/rec directories to provide frontend operations. -removed the magick binary file from the project. magick will instead be built from source on the target machine for maximum support for the target architecture. -stream codec and format are now user configurable. -recording thumbnail and video formats are now user configurable.
2023-10-08 10:09:15 -04:00
rdLine("cam_name = ", line, &share->camName);
rdLine("recording_uri = ", line, &share->recordUri);
rdLine("buffer_path = ", line, &share->buffPath);
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
rdLine("rec_path = ", line, &share->recPath);
v3.3.t1 -removed the web interface. this project will instead continue to focus on backend operations. external applications can interface with the buf/rec directories to provide frontend operations. -removed the magick binary file from the project. magick will instead be built from source on the target machine for maximum support for the target architecture. -stream codec and format are now user configurable. -recording thumbnail and video formats are now user configurable.
2023-10-08 10:09:15 -04:00
rdLine("max_event_secs = ", line, &share->evMaxSecs);
rdLine("post_secs = ", line, &share->postSecs);
rdLine("post_cmd = ", line, &share->postCmd);
rdLine("img_thresh = ", line, &share->imgThresh);
rdLine("max_events = ", line, &share->maxEvents);
rdLine("max_log_size = ", line, &share->maxLogSize);
rdLine("img_comp_out = ", line, &share->outputType);
rdLine("img_comp_cmd = ", line, &share->compCmd);
rdLine("stream_codec = ", line, &share->streamCodec);
rdLine("stream_ext = ", line, &share->streamExt);
rdLine("rec_ext = ", line, &share->recExt);
rdLine("thumbnail_ext = ", line, &share->thumbExt);
rdLine("single_tenant = ", line, &share->singleTenant);
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
rdLine("img_threads = ", line, &share->imgThreads);
rdLine("rec_threads = ", line, &share->recThreads);
rdLine("rec_fps = ", line, &share->recFps);
rdLine("rec_scale = ", line, &share->recScale);
rdLine("img_scale = ", line, &share->imgScale);
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
}
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
} while(!line.isEmpty());
v1.5.t19 Added the ability to read multiple config files so it's now possible to load a singular global config and then load a camera specific config in another. Many elements in the web interface are coming out too small. Added meta viewport device width in hopes that the web interface will self adjust to device it is being displayed on. Changed duration to num_of_clips and added clip_len so the amount of seconds in each clip and the amount of clips to be processed for motion are now adjustable. Adjusted a several default values.
2022-12-24 13:48:51 -05:00
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
if (share->camName.isEmpty())
v1.6.t3 Added string trimming to the vid_container parameter to filter out bad user input. Added detection_stream url to the config file and made it so the application can now use a smaller/lower bit rate stream for motion detection separate from the recording stream. This can significantly lower CPU usage. Moved away from using system() and the explicit timeout command. Instead opted to using popen() and cancelable pthreads. Doing this pulls back more control over ffmpeg than before and the app will now properly respond term signals and even the CTRL-C keyboard interrupt.
2023-02-05 14:05:56 -05:00
{
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
share->camName = QFileInfo(share->conf).fileName();
v1.6.t3 Added string trimming to the vid_container parameter to filter out bad user input. Added detection_stream url to the config file and made it so the application can now use a smaller/lower bit rate stream for motion detection separate from the recording stream. This can significantly lower CPU usage. Moved away from using system() and the explicit timeout command. Instead opted to using popen() and cancelable pthreads. Doing this pulls back more control over ffmpeg than before and the app will now properly respond term signals and even the CTRL-C keyboard interrupt.
2023-02-05 14:05:56 -05:00
}
v3.3.t1 -removed the web interface. this project will instead continue to focus on backend operations. external applications can interface with the buf/rec directories to provide frontend operations. -removed the magick binary file from the project. magick will instead be built from source on the target machine for maximum support for the target architecture. -stream codec and format are now user configurable. -recording thumbnail and video formats are now user configurable.
2023-10-08 10:09:15 -04:00
extCorrection(share->streamExt);
extCorrection(share->recExt);
extCorrection(share->thumbExt);
if (share->singleTenant)
{
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
share->outDir = QDir().cleanPath(share->recPath);
v3.3.t1 -removed the web interface. this project will instead continue to focus on backend operations. external applications can interface with the buf/rec directories to provide frontend operations. -removed the magick binary file from the project. magick will instead be built from source on the target machine for maximum support for the target architecture. -stream codec and format are now user configurable. -recording thumbnail and video formats are now user configurable.
2023-10-08 10:09:15 -04:00
share->tmpDir = QDir().cleanPath(share->buffPath);
}
else
{
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
share->outDir = QDir().cleanPath(share->recPath) + "/" + share->camName;
v3.3.t1 -removed the web interface. this project will instead continue to focus on backend operations. external applications can interface with the buf/rec directories to provide frontend operations. -removed the magick binary file from the project. magick will instead be built from source on the target machine for maximum support for the target architecture. -stream codec and format are now user configurable. -recording thumbnail and video formats are now user configurable.
2023-10-08 10:09:15 -04:00
share->tmpDir = QDir().cleanPath(share->buffPath) + "/" + share->camName;
}
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
auto servDir = QString("/var/") + APP_BIN + QString("_serv");
share->retCode = EACCES;
if (!mkPath(servDir))
{
QTextStream(stderr) << "err: failed to create service directory - " << servDir << " check for write permissions." << Qt::endl;
}
else if (!mkPath(share->recPath))
{
QTextStream(stderr) << "err: failed to create root recording directory - " << share->recPath << " check for write permissions." << Qt::endl;
}
else if (!mkPath(share->buffPath))
{
QTextStream(stderr) << "err: failed to create root buffer directory - " << share->buffPath << " check for write permissions." << Qt::endl;
}
else if (!mkPath(share->outDir))
{
QTextStream(stderr) << "err: failed to create recording directory - " << share->outDir << " check for write permissions." << Qt::endl;
}
else if (!mkPath(share->tmpDir))
{
QTextStream(stderr) << "err: failed to create buffer directory - " << share->tmpDir << " check for write permissions." << Qt::endl;
}
else if (!mkPath(share->tmpDir + "/live"))
{
QTextStream(stderr) << "err: failed to create 'live' in the buffer directory - " << share->tmpDir << "/live" << " check for write permissions." << Qt::endl;
}
else if (!mkPath(share->tmpDir + "/logs"))
{
QTextStream(stderr) << "err: failed to create 'logs' in the buffer directory - " << share->tmpDir << "/logs" << " check for write permissions." << Qt::endl;
}
else if (!mkPath(share->tmpDir + "/img"))
{
QTextStream(stderr) << "err: failed to create 'img' in the buffer directory - " << share->tmpDir << "/img" << " check for write permissions." << Qt::endl;
}
else
{
share->retCode = 0;
share->servPath = QString("/var/") + APP_BIN + QString("_serv/") + APP_BIN + "." + share->camName + ".service";
}
v1.3 Update Broken down the code into multiple files instead having it all in main.cpp. Also detached recording from detection by having them now run in separate threads instead of having motion detection inline with recording. this will hopefully make it so there is less missed motion events due to processing overhead. The recording loop now take advantage of FFMPEG's "-f segment" option instead of generating the clips implicitly in separated FFMPEG calls. again, all in hope to reduce missed motion events. This application have the tendency to detect motion of small insects. to prevent this it was determined with there will need to be some means of identifying objects via machine vision. there is an object detection function but it doesn't currently do anything at this time. this is something that I will be working on in the near future. created a test branch in the repository. all early, testing code will now go in this branch going forward. only fully tested, stable code will be committed to master going forward.
2022-09-22 20:57:46 -04:00
}
v3.0.t1 Completely re-written the project to use the QT API. By using Qt, I've open up use of useful tools like QCryptographicHash, QString, QByteArray, QFile, etc.. In the future I could even make use of slots/signals. The code is also in general much more readable and thread management is by far much easier. General operation of the app should be the same, this commit just serves as a base for the migration over to QT.
2023-05-15 15:29:47 -04:00
return share->retCode == 0;
v2.0.t1 Completely reformed the internal workings of the application code. I brought back multi-threaded functions so there is now 5 separate threads for different tasks. recLoop() - this function calls ffmpeg to begin recording footage from the defined camera and stores the footage in hls format. It is designed to keep running for as long as the application is running and if it does stop for whatever reason, it will attempt to auto re-start. upkeep() - this function does regular cleanup and enforcement of maxDays maxLogSize and maxEvents without the need to stop recording or detecting motion. detectMo() - this function reads directly from recLoop's hls output and list all footage that has motion in it. motion detection no longer has to wait for the clip to finish recording thanks to the use of .ts containers for the video clips. this makes the motion detection for less cpu intensive now that it will now operate at the camera's fps (slower). eventLoop() - this function reads the motion list from detectMo and copies the footage pointed out by the list to an events folder, also in hls format. schLoop() - this function runs an optional user defined external command every amount of seconds defined in sch_sec. this command temporary stops motion detection without actually terminating the thread. It will also not run the command at the scheduled time if motion was detected. Benefits to this reform: - far less cpu intensive operation - multi-threaded architecture for better asynchronous operation - it has support for live streaming now that hls is being used - a buff_dir is no longer necessary
2023-03-05 16:07:07 -05:00
}
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
void rmServices()
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
{
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
auto path = QString("/var/") + APP_BIN + QString("_serv");
auto files = lsFilesInDir(path, ".service");
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
for (auto &&serv : files)
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
{
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
QProcess::execute("systemctl", {"stop", serv});
QProcess::execute("systemctl", {"disable", serv});
QFile::remove(QString("/lib/systemd/system/") + serv);
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
QFile::remove(path + "/" + serv);
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
}
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
QProcess::execute("systemctl", {"daemon-reload"});
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
}
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
void listServices()
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
{
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
auto path = QString("/var/") + APP_BIN + QString("_serv");
auto files = lsFilesInDir(path, ".service");
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
for (auto &&serv : files)
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
{
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
QTextStream(stdout) << serv << ": "; QProcess::execute("systemctl", {"is-active", serv});
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
}
}
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
int loadServices(const QStringList &args)
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
{
auto ret = ENOENT;
v3.0.t3 Got the app up to "not failing immediately" state. However, for some reason DetectLoop is failing hard via opencv being unable to open the stream clips. I'll continue deep diving this. For now everything else works.
2023-05-17 17:10:39 -04:00
auto path = QDir().cleanPath(getParam("-d", args));
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
auto files = lsFilesInDir(path);
if (!QDir(path).exists())
{
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
QTextStream(stderr) << "err: the supplied directory in -d '" << path << "' does not exists or is not a directory." << Qt::endl;
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
}
else if (files.isEmpty())
{
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
QTextStream(stderr) << "err: no config files found in '" << path << "'" << Qt::endl;
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
}
else
{
v3.0.t3 Got the app up to "not failing immediately" state. However, for some reason DetectLoop is failing hard via opencv being unable to open the stream clips. I'll continue deep diving this. For now everything else works.
2023-05-17 17:10:39 -04:00
ret = 0;
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
QTextStream(stdout) << "loading conf files from dir: " << path << Qt::endl;
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
for (auto &&conf : files)
{
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
shared_t shared;
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
if (!rdConf(path + "/" + conf, &shared))
{
ret = shared.retCode; break;
}
else
{
QTextStream(stdout) << conf << " --" << Qt::endl;
QFile file(shared.servPath);
if (!file.open(QFile::ReadWrite | QFile::Truncate))
{
QTextStream(stderr) << "err: failed to open service file: " << shared.servPath << " for writing. reason: " << file.errorString();
ret = EACCES; file.close(); break;
}
else
{
file.write("[Unit]\n");
file.write("Description=" + QByteArray(APP_NAME) + " Camera - " + shared.camName.toUtf8() + "\n");
file.write("After=network.target\n\n");
file.write("[Service]\n");
file.write("Type=simple\n");
file.write("User=" + QByteArray(APP_BIN) + "\n");
file.write("Restart=always\n");
file.write("RestartSec=5\n");
file.write("TimeoutStopSec=infinity\n");
file.write("ExecStart=/usr/bin/env " + QByteArray(APP_BIN) + " -c " + shared.conf.toUtf8() + "\n\n");
file.write("[Install]\n");
file.write("WantedBy=multi-user.target");
file.close();
auto servName = QFileInfo(shared.servPath).fileName();
if (!QFile::link(shared.servPath, "/lib/systemd/system/" + servName))
{
ret = EACCES; break;
}
else
{
if (ret == 0) ret = QProcess::execute("systemctl", {"daemon-reload"});
if (ret == 0) ret = QProcess::execute("systemctl", {"enable", servName});
if (ret == 0) ret = QProcess::execute("systemctl", {"start", servName});
if (ret != 0)
{
break;
}
else
{
QTextStream(stdout) << "Successfully loaded camera service: " << servName << Qt::endl;
v3.3.t1 -removed the web interface. this project will instead continue to focus on backend operations. external applications can interface with the buf/rec directories to provide frontend operations. -removed the magick binary file from the project. magick will instead be built from source on the target machine for maximum support for the target architecture. -stream codec and format are now user configurable. -recording thumbnail and video formats are now user configurable.
2023-10-08 10:09:15 -04:00
if (shared.singleTenant) break;
v3.2.t1 -the -d option will no longer directly run camera instances. it will instead utilize systemd to install camera services. -added -i, -l and -r options to manage camera services. -the app will now default work and output directories in the /var/opt directory instead of /var/www/html and /tmp, making it a better neighbour in the fact that it won't overwrite existing websites or tmp files. -install.sh will now create an unprivileged mow user that will be used to run camera services. all in effort to make the app a good neighour and follow good security practice.
2023-07-31 11:16:07 -04:00
}
}
}
}
v3.0.t2 Added the much need code in Camera object to actual start all of the threads. Added multi instance support via the -d option. Made the Loop object loop structure slot-signal compatible so all objects using it can interupt the main loop to run other slots.
2023-05-17 15:06:58 -04:00
}
}
return ret;
}
v3.2.t2 -fixed the -i option that was using /etc instaead of /etc/mow -the externalized image comparison executable is now configurable in the config file. -moved the main index.html and theme.css files to the buffer dir, moving even more io to the buffer dir.
2023-08-06 10:17:10 -04:00
v3.3.t2 -pixel sizes for video and thumbnails are now configurable -the amount of recording and snapshot threads are now configurable -changed the default buffer and recording directories to drop the application name and also drop a level -service files are now stored in a dedicated dir -fixed logging so it will capture errors better -moved folder structure building to rdConfig() and added more error capturing -recording fps is now configurable
2023-10-19 15:04:39 -04:00
QString buildThreadCount(int count)
{
QString ret = "0";
for (auto i = 1; i < count; ++i)
{
ret.append(","); ret.append(QString::number(i));
}
return ret;
}
v3.2.t2 -fixed the -i option that was using /etc instaead of /etc/mow -the externalized image comparison executable is now configurable in the config file. -moved the main index.html and theme.css files to the buffer dir, moving even more io to the buffer dir.
2023-08-06 10:17:10 -04:00
QStringList parseArgs(const QByteArray &data, int maxArgs, int *pos)
{
QStringList ret;
QString arg;
auto line = QString::fromUtf8(data);
auto inDQuotes = false;
auto inSQuotes = false;
auto escaped = false;
if (pos != nullptr) *pos = 0;
for (int i = 0; i < line.size(); ++i)
{
if (pos != nullptr) *pos += 1;
if ((line[i] == '\'') && !inDQuotes && !escaped)
{
// single quote '
inSQuotes = !inSQuotes;
}
else if ((line[i] == '\"') && !inSQuotes && !escaped)
{
// double quote "
inDQuotes = !inDQuotes;
}
else
{
escaped = false;
if (line[i].isSpace() && !inDQuotes && !inSQuotes)
{
// space
if (!arg.isEmpty())
{
ret.append(arg);
arg.clear();
}
}
else
{
if ((line[i] == '\\') && ((i + 1) < line.size()))
{
if ((line[i + 1] == '\'') || (line[i + 1] == '\"'))
{
escaped = true;
}
else
{
arg.append(line[i]);
}
}
else
{
arg.append(line[i]);
}
}
}
if ((ret.size() >= maxArgs) && (maxArgs != -1))
{
break;
}
}
if (!arg.isEmpty() && !inDQuotes && !inSQuotes)
{
ret.append(arg);
}
return ret;
}
Reference in New Issue Copy Permalink