├── .eslintrc.json
├── .github
└── workflows
│ └── codeql-analysis.yml
├── .gitignore
├── .npmignore
├── .prettierrc.json
├── CHANGELOG.md
├── LICENSE
├── Logo.afphoto
├── NVRJS.js
├── README.md
├── core
└── MP4Frag.js
├── demo.png
├── nvrjs.config.example.js
├── package.json
├── readme.png
└── web
├── dash.html
├── index.html
└── static
├── css
├── default.css
├── font-awesome.min.css
├── fonts
│ ├── FontAwesome.otf
│ ├── Roboto-Light.ttf
│ ├── fontawesome-webfont.eot
│ ├── fontawesome-webfont.svg
│ ├── fontawesome-webfont.ttf
│ ├── fontawesome-webfont.woff
│ └── fontawesome-webfont.woff2
├── images
│ ├── ui-icons_444444_256x240.png
│ ├── ui-icons_555555_256x240.png
│ ├── ui-icons_777620_256x240.png
│ ├── ui-icons_777777_256x240.png
│ ├── ui-icons_cc0000_256x240.png
│ └── ui-icons_ffffff_256x240.png
└── jquery-ui.min.css
├── images
├── CPU.png
├── HDD.png
├── LogoSmall.png
├── RAM.png
└── logo.png
└── js
├── canvas2image.js
├── customParseFormat.js
├── dayjs.min.js
├── jquery-3.6.0.min.js
├── jquery-ui.min.js
├── scripts.js
├── socket.io.min.js
├── vis-timeline-graph2d.min.css
└── vis-timeline-graph2d.min.js
/.eslintrc.json:
--------------------------------------------------------------------------------
1 | {
2 | "parserOptions": {
3 | "ecmaVersion": 12,
4 | "sourceType": "module"
5 | },
6 | "env": {
7 | "node": true,
8 | "es2021": true
9 | },
10 | "rules": {
11 | "prefer-const":"error",
12 | "constructor-super": 2,
13 | "for-direction": 2,
14 | "getter-return": 2,
15 | "no-async-promise-executor": 2,
16 | "no-class-assign": 2,
17 | "no-compare-neg-zero": 2,
18 | "no-cond-assign": 2,
19 | "no-const-assign": 2,
20 | "no-constant-condition": 2,
21 | "no-control-regex": 2,
22 | "no-debugger": 2,
23 | "no-delete-var": 2,
24 | "no-dupe-args": 2,
25 | "no-dupe-class-members": 2,
26 | "no-dupe-else-if": 2,
27 | "no-dupe-keys": 2,
28 | "no-duplicate-case": 2,
29 | "no-empty": 2,
30 | "no-empty-character-class": 2,
31 | "no-empty-pattern": 2,
32 | "no-ex-assign": 2,
33 | "no-extra-boolean-cast": 2,
34 | "no-extra-semi": 2,
35 | "no-fallthrough": 2,
36 | "no-func-assign": 2,
37 | "no-global-assign": 2,
38 | "no-import-assign": 2,
39 | "no-inner-declarations": 2,
40 | "no-invalid-regexp": 2,
41 | "no-irregular-whitespace": 2,
42 | "no-misleading-character-class": 2,
43 | "no-mixed-spaces-and-tabs": 2,
44 | "no-new-symbol": 2,
45 | "no-obj-calls": 2,
46 | "no-octal": 2,
47 | "no-prototype-builtins": 1,
48 | "no-redeclare": 2,
49 | "no-regex-spaces": 2,
50 | "no-self-assign": 2,
51 | "no-setter-return": 2,
52 | "no-shadow-restricted-names": 2,
53 | "no-sparse-arrays": 2,
54 | "no-this-before-super": 2,
55 | "no-undef": 2,
56 | "no-unexpected-multiline": 2,
57 | "no-unreachable": 2,
58 | "no-unsafe-finally": 2,
59 | "no-unsafe-negation": 2,
60 | "no-unused-labels": 2,
61 | "no-unused-vars": 2,
62 | "no-useless-catch": 2,
63 | "no-useless-escape": 2,
64 | "no-with": 2,
65 | "require-yield": 2,
66 | "use-isnan": 2,
67 | "valid-typeof": 2,
68 | "no-case-declarations": 1
69 | }
70 | }
71 |
--------------------------------------------------------------------------------
/.github/workflows/codeql-analysis.yml:
--------------------------------------------------------------------------------
1 | # For most projects, this workflow file will not need changing; you simply need
2 | # to commit it to your repository.
3 | #
4 | # You may wish to alter this file to override the set of languages analyzed,
5 | # or to provide custom queries or build logic.
6 | #
7 | # ******** NOTE ********
8 | # We have attempted to detect the languages in your repository. Please check
9 | # the `language` matrix defined below to confirm you have the correct set of
10 | # supported CodeQL languages.
11 | #
12 | name: "CodeQL"
13 |
14 | on:
15 | push:
16 | branches: [ "main" ]
17 | pull_request:
18 | # The branches below must be a subset of the branches above
19 | branches: [ "main" ]
20 | schedule:
21 | - cron: '35 14 * * 3'
22 |
23 | jobs:
24 | analyze:
25 | name: Analyze
26 | runs-on: ubuntu-latest
27 | permissions:
28 | actions: read
29 | contents: read
30 | security-events: write
31 |
32 | strategy:
33 | fail-fast: false
34 | matrix:
35 | language: [ 'javascript' ]
36 | # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
37 | # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
38 |
39 | steps:
40 | - name: Checkout repository
41 | uses: actions/checkout@v3
42 |
43 | # Initializes the CodeQL tools for scanning.
44 | - name: Initialize CodeQL
45 | uses: github/codeql-action/init@v2
46 | with:
47 | languages: ${{ matrix.language }}
48 | # If you wish to specify custom queries, you can do so here or in a config file.
49 | # By default, queries listed here will override any specified in a config file.
50 | # Prefix the list here with "+" to use these queries and those in the config file.
51 |
52 | # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
53 | # queries: security-extended,security-and-quality
54 |
55 |
56 | # Autobuild attempts to build any compiled languages (C/C++, C#, or Java).
57 | # If this step fails, then you should remove it and run the build manually (see below)
58 | - name: Autobuild
59 | uses: github/codeql-action/autobuild@v2
60 |
61 | # ℹ️ Command-line programs to run using the OS shell.
62 | # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
63 |
64 | # If the Autobuild fails above, remove it and uncomment the following three lines.
65 | # modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
66 |
67 | # - run: |
68 | # echo "Run, Build Application using script"
69 | # ./location_of_script_within_repo/buildscript.sh
70 |
71 | - name: Perform CodeQL Analysis
72 | uses: github/codeql-action/analyze@v2
73 | with:
74 | category: "/language:${{matrix.language}}"
75 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | .vscode
3 | node_modules
4 | package-lock.json
--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | .vscode
3 | node_modules
4 | .github
5 | package-lock.json
6 | .eslintrc.json
7 | .prettierrc.json
8 |
--------------------------------------------------------------------------------
/.prettierrc.json:
--------------------------------------------------------------------------------
1 | {
2 | "arrowParens": "always",
3 | "printWidth": 80,
4 | "semi": true,
5 | "singleQuote": true,
6 | "tabWidth": 2,
7 | "trailingComma":"none",
8 | "useTabs": true,
9 | "endOfLine": "lf",
10 | "bracketSpacing": true
11 | }
12 |
--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
1 | # NVR-JS Change Log
2 |
3 | - 2.0.0
4 |
5 | **Breaking Changes**
6 | - NVR system folders have been renamed. rename them to continue with your current data.
7 | - system -> NVRJS_SYSTEM
8 | - cameras -> NVRJS_CAMERA_RECORDINGS
9 | - API Access no longer uses the UI password, it uses its own API key, as configured in the config file.
10 | Add a new value named **apiKey** in the **system** section - this should be a bcript value of your chosen API key
11 | - Username is now requied in the login page.
12 | Add a new value named **username** in the **system** section to set it - this should be plain text
13 | - API is now accessed via the /api/ URI
14 |
15 | **Changes**
16 | - Dependency updates.
17 | - Clean/polish up the UI.
18 | - Re-worked ffmpeg stream pipes.
19 | - SQL data writes are now queued.
20 | - Rate Limiting is now applied to the the HTTP application.
21 |
22 | **New Features**
23 | - New API functions (URI's)
24 | - **/systeminfo**
25 | - **/cameras**
26 | - **/snapshot/:CameraID/:Width**
27 | - **/geteventdata/:CameraID/:Start/:End**
28 |
29 | - 1.0.2
30 |
31 | **Fixes**
32 | - Fix directory creation
33 |
34 | - 1.0.1
35 |
36 | **Fixes**
37 | - Correct drive space usage query.
38 |
39 | - 1.0.0
40 |
41 | **Initial Release**
42 |
43 |
44 |
45 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2019 Marcus Davies
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
--------------------------------------------------------------------------------
/Logo.afphoto:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/marcus-j-davies/nvr-js/8f8922eb6c7303b72d431aebdc23e1e15ae5a606/Logo.afphoto
--------------------------------------------------------------------------------
/NVRJS.js:
--------------------------------------------------------------------------------
1 | const express = require('express');
2 | const cookieparser = require('cookie-parser');
3 | const cookie = require('cookie');
4 | const bcrypt = require('bcrypt');
5 | const http = require('http');
6 | const io = require('socket.io');
7 | const handlebars = require('handlebars');
8 | const childprocess = require('child_process');
9 | const MP4Frag = require('./core/MP4Frag');
10 | const fs = require('fs');
11 | const os = require('os');
12 | const path = require('path');
13 | const sql = require('sqlite3');
14 | const osu = require('node-os-utils');
15 | const dayjs = require('dayjs');
16 | const queue = require('queue-fifo');
17 | const customParseFormat = require('dayjs/plugin/customParseFormat');
18 | dayjs.extend(customParseFormat);
19 | const RateLimiter = require('express-rate-limit');
20 |
21 | console.log(' - Checking config.');
22 | if (!fs.existsSync(path.join(os.homedir(), 'nvrjs.config.js'))) {
23 | fs.copyFileSync(
24 | path.join(__dirname, 'nvrjs.config.example.js'),
25 | path.join(os.homedir(), 'nvrjs.config.js')
26 | );
27 | console.log(
28 | ' - New config created: ' + path.join(os.homedir(), 'nvrjs.config.js')
29 | );
30 | console.log(' - Edit config to suite and restart!');
31 | process.exit(0);
32 | }
33 | const config = require(path.join(os.homedir(), 'nvrjs.config.js'));
34 | console.log(' - Config loaded: ' + path.join(os.homedir(), 'nvrjs.config.js'));
35 |
36 | let SQL;
37 | const SensorTimestamps = {};
38 |
39 | console.log(' - Checking volumes and ffmpeg.');
40 |
41 | if (!fs.existsSync(config.system.storageVolume)) {
42 | console.log(' - Storage volume does not exist');
43 | process.exit();
44 | } else {
45 | try {
46 | if (
47 | !fs.existsSync(path.join(config.system.storageVolume, 'NVRJS_SYSTEM'))
48 | ) {
49 | fs.mkdirSync(path.join(config.system.storageVolume, 'NVRJS_SYSTEM'));
50 | }
51 | if (
52 | !fs.existsSync(
53 | path.join(config.system.storageVolume, 'NVRJS_CAMERA_RECORDINGS')
54 | )
55 | ) {
56 | fs.mkdirSync(
57 | path.join(config.system.storageVolume, 'NVRJS_CAMERA_RECORDINGS')
58 | );
59 | }
60 | } catch (e) {
61 | console.log('Error creating system directories.');
62 | console.log(e.message);
63 | process.exit(0);
64 | }
65 | }
66 |
67 | if (!fs.existsSync(config.system.ffmpegLocation)) {
68 | console.log(
69 | 'ffmpeg not found in specifed location: ' + config.system.ffmpegLocation
70 | );
71 | process.exit(0);
72 | }
73 |
74 | CreateOrConnectSQL(() => {
75 | console.log(' - Starting purge interval.');
76 | setInterval(
77 | purgeContinuous,
78 | 1000 * 3600 * config.system.continuousPurgeIntervalHours
79 | );
80 | purgeContinuous();
81 | });
82 |
83 | console.log(' - Starting data write queue.');
84 | const FIFO = new queue();
85 | function Commit() {
86 | if (!FIFO.isEmpty()) {
87 | const Query = FIFO.dequeue();
88 | const STMT = SQL.prepare(Query.statement, () => {
89 | STMT.run(Query.params, () => {
90 | STMT.finalize();
91 | Commit();
92 | });
93 | });
94 | } else {
95 | setTimeout(Commit, 10000);
96 | }
97 | }
98 | setTimeout(Commit, 10000);
99 |
100 | const IOLimiter = RateLimiter({
101 | windowMs: 2000,
102 | max: 100
103 | });
104 |
105 | console.log(' - Creating express application.');
106 | const App = new express();
107 | App.use(IOLimiter);
108 | App.use(express.json());
109 | App.use(cookieparser(config.system.cookieKey));
110 | const HTTP = new http.Server(App);
111 |
112 | console.log(' - Compiling pages.');
113 | const CompiledPages = {};
114 | const Pages = {
115 | Dash: path.join(__dirname, 'web', 'dash.html'),
116 | Index: path.join(__dirname, 'web', 'index.html')
117 | };
118 | Object.keys(Pages).forEach((PS) => {
119 | CompiledPages[PS] = handlebars.compile(fs.readFileSync(Pages[PS], 'utf8'));
120 | });
121 |
122 | // Static
123 | App.use('/static', express.static(path.join(__dirname, 'web', 'static')));
124 |
125 | // UI
126 | App.get('/', (req, res) => {
127 | res.type('text/html');
128 | res.status(200);
129 | res.end(CompiledPages.Index());
130 | });
131 | App.post('/login', (req, res) => {
132 | const Data = req.body;
133 | const Password = Data.password;
134 | const Username = Data.username;
135 |
136 | if (
137 | bcrypt.compareSync(Password, config.system.password) &&
138 | config.system.username === Username
139 | ) {
140 | res.cookie('Authentication', 'Success', {
141 | signed: true
142 | });
143 | res.status(204);
144 | res.end();
145 | } else {
146 | res.status(401);
147 | res.end();
148 | }
149 | });
150 |
151 | App.get('/dashboard', CheckAuthMW, (req, res) => {
152 | res.type('text/html');
153 | res.status(200);
154 | res.end(CompiledPages.Dash(config));
155 | });
156 |
157 | // System Info
158 | App.get('/api/:APIKey/systeminfo', (req, res) => {
159 | if (bcrypt.compareSync(req.params.APIKey, config.system.apiKey)) {
160 | getSystemInfo(req, res);
161 | } else {
162 | res.status(401);
163 | res.end();
164 | }
165 | });
166 | App.get('/systeminfo', CheckAuthMW, (req, res) => {
167 | getSystemInfo(req, res);
168 | });
169 |
170 | function getSystemInfo(req, res) {
171 | osu.cpu.usage().then((CPU) => {
172 | osu.drive.info(config.system.storageVolume).then((DISK) => {
173 | osu.mem.info().then((MEM) => {
174 | const Info = {
175 | CPU: CPU,
176 | DISK: DISK,
177 | MEM: MEM
178 | };
179 | res.type('application/json');
180 | res.status(200);
181 | res.end(JSON.stringify(Info));
182 | });
183 | });
184 | });
185 | }
186 |
187 | // get Cameras
188 | App.get('/api/:APIKey/cameras', (req, res) => {
189 | if (bcrypt.compareSync(req.params.APIKey, config.system.apiKey)) {
190 | const Cams = [];
191 |
192 | Object.keys(config.cameras).forEach((ID) => {
193 | const Cam = config.cameras[ID];
194 | Cams.push({ id: ID, name: Cam.name, continuous: Cam.continuous });
195 | });
196 |
197 | res.type('application/json');
198 | res.status(200);
199 | res.end(JSON.stringify(Cams));
200 | } else {
201 | res.status(401);
202 | res.end();
203 | }
204 | });
205 |
206 | // Event Creation
207 | App.post('/api/:APIKey/event/:CameraID', (req, res) => {
208 | if (bcrypt.compareSync(req.params.APIKey, config.system.apiKey)) {
209 | if (config.cameras[req.params.CameraID].continuous) {
210 | if (!SensorTimestamps.hasOwnProperty(req.body.sensorId)) {
211 | FIFO.enqueue({
212 | statement:
213 | 'INSERT INTO Events(EventID,CameraID,Name,SensorID,Date) VALUES(?,?,?,?,?)',
214 | params: [
215 | generateUUID(),
216 | req.params.CameraID,
217 | req.body.name,
218 | req.body.sensorId,
219 | req.body.date
220 | ]
221 | });
222 | res.status(204);
223 | res.end();
224 |
225 | SensorTimestamps[req.body.sensorId] = dayjs().unix();
226 |
227 | setTimeout(() => {
228 | delete SensorTimestamps[req.body.sensorId];
229 | }, 1000 * config.system.eventSensorIdCoolOffSeconds);
230 |
231 | return;
232 | } else {
233 | res.status(429);
234 | res.end();
235 | }
236 | } else {
237 | res.status(501);
238 | res.end();
239 | }
240 | } else {
241 | res.status(401);
242 | res.end();
243 | }
244 | });
245 |
246 | // Snapshot
247 | App.get('/snapshot/:CameraID/:Width', CheckAuthMW, (req, res) => {
248 | getSnapShot(res, req.params.CameraID, req.params.Width);
249 | });
250 |
251 | App.get('/api/:APIKey/snapshot/:CameraID/:Width', (req, res) => {
252 | if (bcrypt.compareSync(req.params.APIKey, config.system.apiKey)) {
253 | getSnapShot(res, req.params.CameraID, req.params.Width);
254 | } else {
255 | res.status(401);
256 | res.end();
257 | }
258 | });
259 |
260 | function getSnapShot(Res, CameraID, Width) {
261 | const CommandArgs = [];
262 | const Cam = config.cameras[CameraID];
263 |
264 | Object.keys(Cam.inputConfig).forEach((inputConfigKey) => {
265 | CommandArgs.push('-' + inputConfigKey);
266 | if (Cam.inputConfig[inputConfigKey].length > 0) {
267 | CommandArgs.push(Cam.inputConfig[inputConfigKey]);
268 | }
269 | });
270 |
271 | CommandArgs.push('-i');
272 | CommandArgs.push(Cam.input);
273 | CommandArgs.push('-vf');
274 | CommandArgs.push('scale=' + Width + ':-1');
275 | CommandArgs.push('-vframes');
276 | CommandArgs.push('1');
277 | CommandArgs.push('-f');
278 | CommandArgs.push('image2');
279 | CommandArgs.push('-');
280 |
281 | const Process = childprocess.spawn(
282 | config.system.ffmpegLocation,
283 | CommandArgs,
284 | { env: process.env, stderr: 'ignore' }
285 | );
286 |
287 | let imageBuffer = Buffer.alloc(0);
288 |
289 | Process.stdout.on('data', function (data) {
290 | imageBuffer = Buffer.concat([imageBuffer, data]);
291 | });
292 |
293 | Process.on('exit', (Code, Signal) => {
294 | const _Error = FFMPEGExitDueToError(Code, Signal);
295 | if (!_Error) {
296 | Res.type('image/jpeg');
297 | Res.status(200);
298 | Res.end(Buffer.from(imageBuffer, 'binary'));
299 | } else {
300 | Res.status(500);
301 | Res.end();
302 | }
303 | });
304 | }
305 |
306 | // Get Event Data
307 | App.get('/api/:APIKey/geteventdata/:CameraID/:Start/:End', (req, res) => {
308 | if (bcrypt.compareSync(req.params.APIKey, config.system.apiKey)) {
309 | GetEventData(res, req.params.CameraID, req.params.Start, req.params.End);
310 | } else {
311 | res.status(401);
312 | res.end();
313 | }
314 | });
315 |
316 | App.get('/geteventdata/:CameraID/:Start/:End', CheckAuthMW, (req, res) => {
317 | GetEventData(res, req.params.CameraID, req.params.Start, req.params.End);
318 | });
319 |
320 | function GetEventData(res, CameraID, Start, End) {
321 | const Data = {};
322 |
323 | let STMT = SQL.prepare(
324 | 'SELECT * FROM Segments WHERE CameraID = ? AND Start >= ? AND End <= ?'
325 | );
326 | STMT.all([CameraID, parseInt(Start), parseInt(End)], (err, rows) => {
327 | Data.segments = rows;
328 | STMT.finalize();
329 | STMT = SQL.prepare(
330 | 'SELECT * FROM Events WHERE CameraID = ? AND Date >= ? AND Date <= ?'
331 | );
332 | STMT.all([CameraID, parseInt(Start), parseInt(End)], (err, rows) => {
333 | Data.events = rows;
334 | STMT.finalize();
335 | res.type('application/json');
336 | res.status(200);
337 | res.end(JSON.stringify(Data));
338 | });
339 | });
340 | }
341 |
342 | const Processors = {};
343 | const Cameras = Object.keys(config.cameras);
344 | Cameras.forEach((cameraID) => {
345 | const Cam = config.cameras[cameraID];
346 | InitCamera(Cam, cameraID);
347 | });
348 |
349 | function CreateOrConnectSQL(CB) {
350 | const Path = path.join(
351 | config.system.storageVolume,
352 | 'NVRJS_SYSTEM',
353 | 'data.db'
354 | );
355 |
356 | if (!fs.existsSync(Path)) {
357 | console.log(' - Creating db structure.');
358 | SQL = new sql.Database(Path, () => {
359 | SQL.run(
360 | 'CREATE TABLE Segments(SegmentID TEXT, CameraID TEXT, FileName TEXT, Start NUMERIC, End NUMERIC)',
361 | () => {
362 | SQL.run(
363 | 'CREATE TABLE Events(EventID TEXT,CameraID TEXT, Name TEXT, SensorID TEXT, Date NUMERIC)',
364 | () => {
365 | SQL.close();
366 | console.log(' - Connecting to db.');
367 | SQL = new sql.Database(Path, CB);
368 | }
369 | );
370 | }
371 | );
372 | });
373 | } else {
374 | console.log(' - Connecting to db.');
375 | SQL = new sql.Database(Path, CB);
376 | }
377 | }
378 |
379 | function FFMPEGExitDueToError(Code, Signal) {
380 | if (Code == null && Signal === 'SIGKILL') {
381 | return false;
382 | }
383 | if (Code === 255 && Signal == null) {
384 | return false;
385 | }
386 | if (Code > 0 && Code < 255 && Signal == null) {
387 | return true;
388 | }
389 | }
390 |
391 | function InitCamera(Cam, cameraID) {
392 | console.log(' - Configuring camera: ' + Cam.name);
393 |
394 | const CommandArgs = [];
395 |
396 | Object.keys(Cam.inputConfig).forEach((inputConfigKey) => {
397 | if (inputConfigKey !== 'i') {
398 | CommandArgs.push('-' + inputConfigKey);
399 | if (Cam.inputConfig[inputConfigKey].length > 0) {
400 | CommandArgs.push(Cam.inputConfig[inputConfigKey]);
401 | }
402 | }
403 | });
404 |
405 | CommandArgs.push('-i');
406 | CommandArgs.push(Cam.input);
407 |
408 | App.use(
409 | '/segments/' + cameraID,
410 | CheckAuthMW,
411 | express.static(
412 | path.join(
413 | config.system.storageVolume,
414 | 'NVRJS_CAMERA_RECORDINGS',
415 | cameraID
416 | ),
417 | { acceptRanges: true }
418 | )
419 | );
420 |
421 | const Path = path.join(
422 | config.system.storageVolume,
423 | 'NVRJS_CAMERA_RECORDINGS',
424 | cameraID
425 | );
426 | if (!fs.existsSync(Path)) {
427 | fs.mkdirSync(Path);
428 | }
429 |
430 | if (Cam.continuous !== undefined && Cam.continuous) {
431 | CommandArgs.push('-c:v');
432 | CommandArgs.push('copy');
433 | CommandArgs.push('-c:a');
434 | CommandArgs.push('copy');
435 | CommandArgs.push('-f');
436 | CommandArgs.push('segment');
437 | CommandArgs.push('-movflags');
438 | CommandArgs.push('+faststart');
439 | CommandArgs.push('-segment_atclocktime');
440 | CommandArgs.push('1');
441 | CommandArgs.push('-reset_timestamps');
442 | CommandArgs.push('1');
443 | CommandArgs.push('-strftime');
444 | CommandArgs.push('1');
445 | CommandArgs.push('-segment_list');
446 | CommandArgs.push('pipe:4');
447 | CommandArgs.push('-segment_time');
448 | CommandArgs.push(60 * config.system.continuousSegTimeMinutes);
449 | CommandArgs.push(path.join(Path, '%Y-%m-%dT%H-%M-%S.mp4'));
450 | }
451 |
452 | Object.keys(Cam.liveConfig.streamConfig).forEach((streamingConfigKey) => {
453 | CommandArgs.push('-' + streamingConfigKey);
454 | if (Cam.liveConfig.streamConfig[streamingConfigKey].length > 0) {
455 | CommandArgs.push(Cam.liveConfig.streamConfig[streamingConfigKey]);
456 | }
457 | });
458 |
459 | CommandArgs.push('-metadata');
460 | CommandArgs.push('title="NVR JS Stream"');
461 | CommandArgs.push('pipe:3');
462 |
463 | const Options = {
464 | detached: true,
465 | stdio: ['ignore', 'ignore', 'ignore', 'pipe', 'pipe']
466 | };
467 | const respawn = (Spawned) => {
468 | const MP4F = new MP4Frag();
469 |
470 | const IOptions = {
471 | path: '/streams/' + cameraID
472 | };
473 | const Socket = io(HTTP, IOptions);
474 | Socket.on('connection', (ClientSocket) => {
475 | if (CheckAuthMW(ClientSocket)) {
476 | ClientSocket.emit('segment', MP4F.initialization);
477 | }
478 | });
479 |
480 | MP4F.on('segment', (data) => {
481 | Socket.sockets.sockets.forEach((ClientSocket) => {
482 | ClientSocket.emit('segment', data);
483 | });
484 | });
485 |
486 | Spawned.on('close', () => {
487 | console.log(
488 | ' - Camera: ' +
489 | Cam.name +
490 | ' was terminated, respawning after 10 seconds...'
491 | );
492 | Spawned.kill();
493 | MP4F.destroy();
494 | setTimeout(() => {
495 | respawn(
496 | childprocess.spawn(config.system.ffmpegLocation, CommandArgs, Options)
497 | );
498 | }, 10000);
499 | });
500 |
501 | Spawned.stdio[3].on('data', (data) => {
502 | MP4F.write(data, 'binary');
503 | });
504 | Spawned.stdio[4].on('data', (FN) => {
505 | if (Processors[cameraID] !== undefined) {
506 | const FileName = FN.toString().trim().replace(/\n/g, '');
507 | const Start = dayjs(
508 | FileName.replace(/.mp4/g, ''),
509 | 'YYYY-MM-DDTHH-mm-ss'
510 | ).unix();
511 | const End = dayjs().unix();
512 | FIFO.enqueue({
513 | statement:
514 | 'INSERT INTO Segments(SegmentID,CameraID,FileName,Start,End) VALUES(?,?,?,?,?)',
515 | params: [generateUUID(), cameraID, FileName, Start, End]
516 | });
517 | }
518 | });
519 | };
520 |
521 | respawn(
522 | childprocess.spawn(config.system.ffmpegLocation, CommandArgs, Options)
523 | );
524 |
525 | Processors[cameraID] = {
526 | CameraInfo: Cam
527 | };
528 | }
529 | function generateUUID() {
530 | var d = new Date().getTime();
531 | var d2 =
532 | (typeof performance !== 'undefined' &&
533 | performance.now &&
534 | performance.now() * 1000) ||
535 | 0;
536 | return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
537 | var r = Math.random() * 16;
538 | if (d > 0) {
539 | r = (d + r) % 16 | 0;
540 | d = Math.floor(d / 16);
541 | } else {
542 | r = (d2 + r) % 16 | 0;
543 | d2 = Math.floor(d2 / 16);
544 | }
545 | return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
546 | });
547 | }
548 |
549 | function CheckAuthMW(req, res, next) {
550 | if (res === undefined && next === undefined) {
551 | if (req.handshake.headers.cookie !== undefined) {
552 | const CS = cookie.parse(req.handshake.headers.cookie);
553 | const Signed = cookieparser.signedCookies(CS, config.system.cookieKey);
554 | if (
555 | Signed.Authentication === undefined ||
556 | Signed.Authentication !== 'Success'
557 | ) {
558 | req.disconnect();
559 | return false;
560 | } else {
561 | return true;
562 | }
563 | } else {
564 | req.disconnect();
565 | return false;
566 | }
567 | } else {
568 | if (
569 | req.signedCookies.Authentication === undefined ||
570 | req.signedCookies.Authentication !== 'Success'
571 | ) {
572 | res.status(401);
573 | res.end();
574 | } else {
575 | next();
576 | }
577 | }
578 | }
579 |
580 | async function purgeContinuous() {
581 | console.log(' - Purging data.');
582 | const Date = dayjs().subtract(config.system.continuousDays, 'day').unix();
583 | const STMT = SQL.prepare('SELECT * FROM Segments WHERE Start <= ?');
584 | STMT.all([Date], (err, rows) => {
585 | rows.forEach((S) => {
586 | fs.unlinkSync(
587 | path.join(
588 | config.system.storageVolume,
589 | 'NVRJS_CAMERA_RECORDINGS',
590 | S.CameraID,
591 | S.FileName
592 | )
593 | );
594 | });
595 | FIFO.enqueue({
596 | statement: `DELETE FROM Segments WHERE Start <= ${Date}`,
597 | params: []
598 | });
599 | FIFO.enqueue({
600 | statement: `DELETE FROM Events WHERE Date <= ${Date}`,
601 | params: []
602 | });
603 | });
604 | }
605 |
606 | HTTP.listen(config.system.interfacePort);
607 | console.log(' - NVR JS is Ready!');
608 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | 
2 |
3 | # nvr-js
4 | 
5 | 
6 | [](https://lgtm.com/projects/g/marcus-j-davies/nvr-js/context:javascript)
7 | 
8 | 
9 |
10 | NVR JS is a simple, very lightweight and efficient CCTV NVR based on Node JS.
11 | it's primarily aimed for 24/7 recording and live viewing.
12 |
13 | Under the hood it uses ffmpeg, node js, websockets and sqlite, all wrapped in a web based user interface.
14 | The NVR has an API that allows to create events and timestamp them on the 24/7 recordings.
15 |
16 | The 24/7 recordings can be reviewed using a timeline UI where the events are also time aligned on that same timeline.
17 |
18 | 
19 |
20 | ### Inspired by shinobi.video
21 | [Shinobi](https://shinobi.video) is a fully featured, jam packed NVR, also built using Node JS.
22 | I was using Shinobi and thought it was amazing! - however, it had sooo much to it, and was too overkill for my needs.
23 |
24 | You can think of NVR-JS as a very slimed down version of shinobi video, built from the ground up.
25 | the table below, shows how slimmed down it is.
26 |
27 | | Feature | Shinobi | NVR JS |
28 | |-------------------|---------|---------------------|
29 | | Motion Dectection | ✓ | |
30 | | Object Detection | ✓ | |
31 | | 24/7 Recording | ✓ | ✓ |
32 | | Event Creation | ✓ | ✓ (API Only) |
33 | | Notifications | ✓ | |
34 | | Live Streaming | ✓ | ✓ (Websocket) |
35 | | Configuration UI | ✓ | Manual Editing |
36 | | Mobile Support | ✓ | |
37 |
38 | As you can see, NVR JS does not pack the same features as Shinobi Video, but that's the intention.
39 | NVR JS is designed for 24/7 recording with access to live footage, and the 24/7 recordings.
40 |
41 | ### Configuration.
42 | The first time you start NVR JS, it will create a config file at **/%home%/nvrjs.config.js**,
43 | it will then terminate allowing you to start adjusting your system, before starting it up again.
44 |
45 | ```javascript
46 | module.exports = {
47 | /* System Settings */
48 | system: {
49 | /* Username */
50 | username: "admin",
51 | /* bcrypt password (default: admin) */
52 | password: '$2a$10$CnOx/6vFY2ehRDf68yqd..aLlv0UM.zeBLKnRjuU8YykCsC2Ap3iG',
53 | /* bcrypt API Key (default: x7Te9m38JHQq6ddv) */
54 | apiKey: '$2a$10$N53ci.EIQ7JCu6u1HlOjoO//W0Bmp3GrRruyK1Jysr01CQ1rDrVQK',
55 | /* Any random string */
56 | cookieKey: 'f3gi6FLhIPVV31d1TBQUPEAngrI3wAoP',
57 | interfacePort: 7878,
58 | /* location used for 24/7 recording and database generation */
59 | /* This should be the root of a mount point i.e a dedicated HDD for 24/7 recordings */
60 | storageVolume: '/Volumes/CCTV',
61 | /* Continuous recording settings */
62 | ffmpegLocation: 'ffmpeg',
63 | continuousSegTimeMinutes: 15,
64 | continuousDays: 14,
65 | continuousPurgeIntervalHours: 24,
66 | /* event throttle per sensorId */
67 | eventSensorIdCoolOffSeconds: 60
68 | },
69 | /* Cameras */
70 | cameras: {
71 | '66e39d21-72c4-405c-a838-05a8e8fe0742': {
72 | name: 'Garage',
73 | /* Input Source Config */
74 | /* The keys and values represent the ffmpeg options */
75 | inputConfig: {
76 | use_wallclock_as_timestamps: '1',
77 | fflags: '+igndts',
78 | analyzeduration: '1000000',
79 | probesize: '1000000',
80 | rtsp_transport: 'tcp',
81 | stimeout: '30000000'
82 | },
83 | /* Input Address */
84 | input: 'rtsp://user:password@ip:port/live0',
85 | /* Recording 24/7 */
86 | /* Disabling continuous recording, will disable the ability to create events */
87 | continuous: true,
88 | /* Live streaming config */
89 | /* These settings should be good enough for a low delay live stream, providing your camera produces h264 frames */
90 | /* streaming is achieved with websockets and MP4 fragments */
91 | liveConfig: {
92 | codecString: 'video/mp4; codecs="avc1.64001f"',
93 | streamConfig: {
94 | an: '',
95 | vcodec: 'copy',
96 | f: 'mp4',
97 | movflags: '+frag_keyframe+empty_moov+default_base_moof',
98 | reset_timestamps: '1'
99 | }
100 | }
101 | }
102 | }
103 | };
104 | ```
105 |
106 |
107 | ### The Event API.
108 | To create events one only needs to send the following JSON payload.
109 |
110 | The view here, is that you create events from various sensors in your setup, this effectively acts as your motion detector
111 | or some other key event - It's really up to you.
112 |
113 | ```javascript
114 | {
115 | "name": "Motion Detected" | "Door Opened" | "Some Other Event" | "Of Your Choice",
116 | "sensorId": "HUEN849",
117 | "date": 1636194611
118 | }
119 | ```
120 |
121 | You **POST** this payload to the API as follows:
122 | http://IP:7878/api/{APIKey}/event/{camera-id}
123 | Example: http://IP:7878/api/x7Te9m38JHQq6ddv/event/66e39d21-72c4-405c-a838-05a8e8fe0742
124 |
125 | ### Anyway
126 | I built this for my needs, it's very DIY and will likely have some faults in some places.
127 | But if you want to use it, change it, build on it, feel free - I welcome PR's.
128 |
129 | ```
130 | npm install nvr-js
131 | cd ./node_modules/nvr-js
132 | pm2 start NVRJS.js
133 | pm2 save
134 | ```
135 |
136 | [Change Log](./CHANGELOG.md)
137 |
--------------------------------------------------------------------------------
/core/MP4Frag.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const { Transform } = require('stream');
4 |
5 | const _FTYP = Buffer.from([0x66, 0x74, 0x79, 0x70]); // ftyp
6 | const _MOOV = Buffer.from([0x6d, 0x6f, 0x6f, 0x76]); // moov
7 | const _MOOF = Buffer.from([0x6d, 0x6f, 0x6f, 0x66]); // moof
8 | const _MFRA = Buffer.from([0x6d, 0x66, 0x72, 0x61]); // mfra
9 | const _MDAT = Buffer.from([0x6d, 0x64, 0x61, 0x74]); // mdat
10 | const _MP4A = Buffer.from([0x6d, 0x70, 0x34, 0x61]); // mp4a
11 | const _AVCC = Buffer.from([0x61, 0x76, 0x63, 0x43]); // avcC
12 |
13 | /**
14 | * @fileOverview Creates a stream transform for piping a fmp4 (fragmented mp4) from ffmpeg.
15 | * Can be used to generate a fmp4 m3u8 HLS playlist and compatible file fragments.
16 | * Can also be used for storing past segments of the mp4 video in a buffer for later access.
17 | * Must use the following ffmpeg flags -movflags +frag_keyframe+empty_moov to generate a fmp4
18 | * with a compatible file structure : ftyp+moov -> moof+mdat -> moof+mdat -> moof+mdat ...
19 | * @requires stream.Transform
20 | */
21 | class Mp4Frag extends Transform {
22 | /**
23 | * @constructor
24 | * @param {Object} [options] - Configuration options.
25 | * @param {String} [options.hlsBase] - Base name of files in fmp4 m3u8 playlist. Affects the generated m3u8 playlist by naming file fragments. Must be set to generate m3u8 playlist.
26 | * @param {Number} [options.hlsListSize] - Number of segments to keep in fmp4 m3u8 playlist. Must be an integer ranging from 2 to 10. Defaults to 4 if hlsBase is set and hlsListSize is not set.
27 | * @param {Boolean} [options.hlsListInit] - Indicates that m3u8 playlist should be generated after init segment is created and before media segments are created. Defaults to false.
28 | * @param {Number} [options.bufferListSize] - Number of segments to keep buffered. Must be an integer ranging from 2 to 10. Not related to HLS settings.
29 | * @returns {Mp4Frag} this - Returns reference to new instance of Mp4Frag for chaining event listeners.
30 | */
31 | constructor(options) {
32 | super(options);
33 | if (options) {
34 | if (typeof options.hlsBase === 'string' && /^[a-z0-9]+$/i.exec(options.hlsBase)) {
35 | const hlsListSize = parseInt(options.hlsListSize);
36 | this._hlsListInit = options.hlsListInit === true;
37 | if (isNaN(hlsListSize)) {
38 | this._hlsListSize = 4;
39 | } else if (hlsListSize < 2) {
40 | this._hlsListSize = 2;
41 | } else if (hlsListSize > 10) {
42 | this._hlsListSize = 10;
43 | } else {
44 | this._hlsListSize = hlsListSize;
45 | }
46 | this._hlsList = [];
47 | this._hlsBase = options.hlsBase;
48 | this._sequence = -1;
49 | }
50 | if (options.hasOwnProperty('bufferListSize')) {
51 | const bufferListSize = parseInt(options.bufferListSize);
52 | if (isNaN(bufferListSize) || bufferListSize < 2) {
53 | this._bufferListSize = 2;
54 | } else if (bufferListSize > 10) {
55 | this._bufferListSize = 10;
56 | } else {
57 | this._bufferListSize = bufferListSize;
58 | }
59 | this._bufferList = [];
60 | }
61 | }
62 | this._parseChunk = this._findFtyp;
63 | return this;
64 | }
65 |
66 | /**
67 | * @readonly
68 | * @property {String} mime
69 | * - Returns the mime codec information as a String.
70 | *
71 | * - Returns Null if requested before [initialized event]{@link Mp4Frag#event:initialized}.
72 | * @returns {String}
73 | */
74 | get mime() {
75 | return this._mime || null;
76 | }
77 |
78 | /**
79 | * @readonly
80 | * @property {Buffer} initialization
81 | * - Returns the mp4 initialization fragment as a Buffer.
82 | *
83 | * - Returns Null if requested before [initialized event]{@link Mp4Frag#event:initialized}.
84 | * @returns {Buffer}
85 | */
86 | get initialization() {
87 | return this._initialization || null;
88 | }
89 |
90 | /**
91 | * @readonly
92 | * @property {Buffer} segment
93 | * - Returns the latest Mp4 segment as a Buffer.
94 | *
95 | * - Returns Null if requested before first [segment event]{@link Mp4Frag#event:segment}.
96 | * @returns {Buffer}
97 | */
98 | get segment() {
99 | return this._segment || null;
100 | }
101 |
102 | /**
103 | * @readonly
104 | * @property {Number} timestamp
105 | * - Returns the timestamp of the latest Mp4 segment as an Integer(milliseconds).
106 | *
107 | * - Returns -1 if requested before first [segment event]{@link Mp4Frag#event:segment}.
108 | * @returns {Number}
109 | */
110 | get timestamp() {
111 | return this._timestamp || -1;
112 | }
113 |
114 | /**
115 | * @readonly
116 | * @property {Number} duration
117 | * - Returns the duration of latest Mp4 segment as a Float(seconds).
118 | *
119 | * - Returns -1 if requested before first [segment event]{@link Mp4Frag#event:segment}.
120 | * @returns {Number}
121 | */
122 | get duration() {
123 | return this._duration || -1;
124 | }
125 |
126 | /**
127 | * @readonly
128 | * @property {String} m3u8
129 | * - Returns the fmp4 HLS m3u8 playlist as a String.
130 | *
131 | * - Returns Null if requested before [initialized event]{@link Mp4Frag#event:initialized}.
132 | * @returns {String}
133 | */
134 | get m3u8() {
135 | return this._m3u8 || null;
136 | }
137 |
138 | /**
139 | * @readonly
140 | * @property {Number} sequence
141 | * - Returns the latest sequence of the fmp4 HLS m3u8 playlist as an Integer.
142 | *
143 | * - Returns -1 if requested before first [segment event]{@link Mp4Frag#event:segment}.
144 | * @returns {Number}
145 | */
146 | get sequence() {
147 | return Number.isInteger(this._sequence) ? this._sequence : -1;
148 | }
149 |
150 | /**
151 | * @readonly
152 | * @property {Array} bufferList
153 | * - Returns the buffered mp4 segments as an Array.
154 | *
155 | * - Returns Null if requested before first [segment event]{@link Mp4Frag#event:segment}.
156 | * @returns {Array}
157 | */
158 | get bufferList() {
159 | if (this._bufferList && this._bufferList.length > 0) {
160 | return this._bufferList;
161 | }
162 | return null;
163 | }
164 |
165 | /**
166 | * @readonly
167 | * @property {Buffer} bufferListConcat
168 | * - Returns the [Mp4Frag.bufferList]{@link Mp4Frag#bufferList} concatenated as a Buffer.
169 | *
170 | * - Returns Null if requested before first [segment event]{@link Mp4Frag#event:segment}.
171 | * @returns {Buffer}
172 | */
173 | get bufferListConcat() {
174 | if (this._bufferList && this._bufferList.length > 0) {
175 | return Buffer.concat(this._bufferList);
176 | }
177 | return null;
178 | }
179 |
180 | /**
181 | * @readonly
182 | * @property {Buffer} bufferConcat
183 | * - Returns the [Mp4Frag.initialization]{@link Mp4Frag#initialization} and [Mp4Frag.bufferList]{@link Mp4Frag#bufferList} concatenated as a Buffer.
184 | *
185 | * - Returns Null if requested before first [segment event]{@link Mp4Frag#event:segment}.
186 | * @returns {Buffer}
187 | */
188 | get bufferConcat() {
189 | if (this._initialization && this._bufferList && this._bufferList.length > 0) {
190 | return Buffer.concat([this._initialization, ...this._bufferList]);
191 | }
192 | return null;
193 | }
194 |
195 | /**
196 | * @param {Number|String} sequence
197 | * - Returns the Mp4 segment that corresponds to the HLS numbered sequence as a Buffer.
198 | *
199 | * - Returns Null if there is no .m4s segment that corresponds to sequence number.
200 | * @returns {Buffer}
201 | */
202 | getHlsSegment(sequence) {
203 | return this.getHlsNamedSegment(`${this._hlsBase}${sequence}.m4s`);
204 | }
205 |
206 | /**
207 | * @param {String} name
208 | * - Returns the Mp4 segment that corresponds to the HLS named sequence as a Buffer.
209 | *
210 | * - Returns Null if there is no .m4s segment that corresponds to sequence name.
211 | * @returns {Buffer}
212 | */
213 | getHlsNamedSegment(name) {
214 | if (name && this._hlsList && this._hlsList.length > 0) {
215 | for (let i = 0; i < this._hlsList.length; i++) {
216 | if (this._hlsList[i].name === name) {
217 | return this._hlsList[i].segment;
218 | }
219 | }
220 | }
221 | return null;
222 | }
223 |
224 | /**
225 | * Search buffer for ftyp.
226 | * @private
227 | */
228 | _findFtyp(chunk) {
229 | const chunkLength = chunk.length;
230 | if (chunkLength < 8 || chunk.indexOf(_FTYP) !== 4) {
231 | this.emit('error', new Error(`${_FTYP.toString()} not found.`));
232 | return;
233 | }
234 | this._ftypLength = chunk.readUInt32BE(0, true);
235 | if (this._ftypLength < chunkLength) {
236 | this._ftyp = chunk.slice(0, this._ftypLength);
237 | this._parseChunk = this._findMoov;
238 | this._parseChunk(chunk.slice(this._ftypLength));
239 | } else if (this._ftypLength === chunkLength) {
240 | this._ftyp = chunk;
241 | this._parseChunk = this._findMoov;
242 | } else {
243 | //should not be possible to get here because ftyp is approximately 24 bytes
244 | //will have to buffer this chunk and wait for rest of it on next pass
245 | this.emit('error', new Error(`ftypLength:${this._ftypLength} > chunkLength:${chunkLength}`));
246 | //return;
247 | }
248 | }
249 |
250 | /**
251 | * Search buffer for moov.
252 | * @private
253 | */
254 | _findMoov(chunk) {
255 | const chunkLength = chunk.length;
256 | if (chunkLength < 8 || chunk.indexOf(_MOOV) !== 4) {
257 | this.emit('error', new Error(`${_MOOV.toString()} not found.`));
258 | return;
259 | }
260 | const moovLength = chunk.readUInt32BE(0, true);
261 | if (moovLength < chunkLength) {
262 | this._parseMoov(Buffer.concat([this._ftyp, chunk], this._ftypLength + moovLength));
263 | delete this._ftyp;
264 | delete this._ftypLength;
265 | this._parseChunk = this._findMoof;
266 | this._parseChunk(chunk.slice(moovLength));
267 | } else if (moovLength === chunkLength) {
268 | this._parseMoov(Buffer.concat([this._ftyp, chunk], this._ftypLength + moovLength));
269 | delete this._ftyp;
270 | delete this._ftypLength;
271 | this._parseChunk = this._findMoof;
272 | } else {
273 | //probably should not arrive here here because moov is typically < 800 bytes
274 | //will have to store chunk until size is big enough to have entire moov piece
275 | //ffmpeg may have crashed before it could output moov and got us here
276 | this.emit('error', new Error(`moovLength:${moovLength} > chunkLength:${chunkLength}`));
277 | //return;
278 | }
279 | }
280 |
281 | /**
282 | * Parse moov for mime.
283 | * @fires Mp4Frag#initialized
284 | * @private
285 | */
286 | _parseMoov(value) {
287 | this._initialization = value;
288 | let audioString = '';
289 | if (this._initialization.indexOf(_MP4A) !== -1) {
290 | audioString = ', mp4a.40.2';
291 | }
292 | let index = this._initialization.indexOf(_AVCC);
293 | if (index === -1) {
294 | this.emit('error', new Error(`${_AVCC.toString()} codec info not found.`));
295 | return;
296 | }
297 | index += 5;
298 | this._mime = `video/mp4; codecs="avc1.${this._initialization
299 | .slice(index, index + 3)
300 | .toString('hex')
301 | .toUpperCase()}${audioString}"`;
302 | this._timestamp = Date.now();
303 | if (this._hlsList && this._hlsListInit) {
304 | let m3u8 = '#EXTM3U\n';
305 | m3u8 += '#EXT-X-VERSION:7\n';
306 | //m3u8 += '#EXT-X-ALLOW-CACHE:NO\n';
307 | m3u8 += `#EXT-X-TARGETDURATION:1\n`;
308 | m3u8 += `#EXT-X-MEDIA-SEQUENCE:0\n`;
309 | m3u8 += `#EXT-X-MAP:URI="init-${this._hlsBase}.mp4"\n`;
310 | this._m3u8 = m3u8;
311 | }
312 | /**
313 | * Fires when the init fragment of the Mp4 is parsed from the piped data.
314 | * @event Mp4Frag#initialized
315 | * @type {Event}
316 | * @property {Object} Object
317 | * @property {String} Object.mime - [Mp4Frag.mime]{@link Mp4Frag#mime}
318 | * @property {Buffer} Object.initialization - [Mp4Frag.initialization]{@link Mp4Frag#initialization}
319 | * @property {String} Object.m3u8 - [Mp4Frag.m3u8]{@link Mp4Frag#m3u8}
320 | */
321 | this.emit('initialized', { mime: this._mime, initialization: this._initialization, m3u8: this._m3u8 || null });
322 | }
323 |
324 | /**
325 | * Find moof after miss due to corrupt data in pipe.
326 | * @private
327 | */
328 | _moofHunt(chunk) {
329 | if (this._moofHunts < this._moofHuntsLimit) {
330 | this._moofHunts++;
331 | //console.warn(`MOOF hunt attempt number ${this._moofHunts}.`);
332 | const index = chunk.indexOf(_MOOF);
333 | if (index > 3 && chunk.length > index + 3) {
334 | delete this._moofHunts;
335 | delete this._moofHuntsLimit;
336 | this._parseChunk = this._findMoof;
337 | this._parseChunk(chunk.slice(index - 4));
338 | }
339 | } else {
340 | this.emit('error', new Error(`${_MOOF.toString()} hunt failed after ${this._moofHunts} attempts.`));
341 | //return;
342 | }
343 | }
344 |
345 | /**
346 | * Search buffer for moof.
347 | * @private
348 | */
349 | _findMoof(chunk) {
350 | if (this._moofBuffer) {
351 | this._moofBuffer.push(chunk);
352 | const chunkLength = chunk.length;
353 | this._moofBufferSize += chunkLength;
354 | if (this._moofLength === this._moofBufferSize) {
355 | //todo verify this works
356 | this._moof = Buffer.concat(this._moofBuffer, this._moofLength);
357 | delete this._moofBuffer;
358 | delete this._moofBufferSize;
359 | this._parseChunk = this._findMdat;
360 | } else if (this._moofLength < this._moofBufferSize) {
361 | this._moof = Buffer.concat(this._moofBuffer, this._moofLength);
362 | const sliceIndex = chunkLength - (this._moofBufferSize - this._moofLength);
363 | delete this._moofBuffer;
364 | delete this._moofBufferSize;
365 | this._parseChunk = this._findMdat;
366 | this._parseChunk(chunk.slice(sliceIndex));
367 | }
368 | } else {
369 | const chunkLength = chunk.length;
370 | if (chunkLength < 8 || chunk.indexOf(_MOOF) !== 4) {
371 | //ffmpeg occasionally pipes corrupt data, lets try to get back to normal if we can find next MOOF box before attempts run out
372 | const mfraIndex = chunk.indexOf(_MFRA);
373 | if (mfraIndex !== -1) {
374 | //console.log(`MFRA was found at ${mfraIndex}. This is expected at the end of stream.`);
375 | return;
376 | }
377 | //console.warn('Failed to find MOOF. Starting MOOF hunt. Ignore this if your file stream input has ended.');
378 | this._moofHunts = 0;
379 | this._moofHuntsLimit = 40;
380 | this._parseChunk = this._moofHunt;
381 | this._parseChunk(chunk);
382 | return;
383 | }
384 | this._moofLength = chunk.readUInt32BE(0, true);
385 | if (this._moofLength === 0) {
386 | this.emit('error', new Error(`Bad data from input stream reports ${_MOOF.toString()} length of 0.`));
387 | return;
388 | }
389 | if (this._moofLength < chunkLength) {
390 | this._moof = chunk.slice(0, this._moofLength);
391 | this._parseChunk = this._findMdat;
392 | this._parseChunk(chunk.slice(this._moofLength));
393 | } else if (this._moofLength === chunkLength) {
394 | //todo verify this works
395 | this._moof = chunk;
396 | this._parseChunk = this._findMdat;
397 | } else {
398 | this._moofBuffer = [chunk];
399 | this._moofBufferSize = chunkLength;
400 | }
401 | }
402 | }
403 |
404 | /**
405 | * Process current segment.
406 | * @fires Mp4Frag#segment
407 | * @param chunk {Buffer}
408 | * @private
409 | */
410 | _setSegment(chunk) {
411 | this._segment = chunk;
412 | const currentTime = Date.now();
413 | this._duration = Math.max((currentTime - this._timestamp) / 1000, 1);
414 | this._timestamp = currentTime;
415 | if (this._hlsList) {
416 | this._hlsList.push({
417 | sequence: ++this._sequence,
418 | name: `${this._hlsBase}${this._sequence}.m4s`,
419 | segment: this._segment,
420 | duration: this._duration
421 | });
422 | while (this._hlsList.length > this._hlsListSize) {
423 | this._hlsList.shift();
424 | }
425 | let m3u8 = '#EXTM3U\n';
426 | m3u8 += '#EXT-X-VERSION:7\n';
427 | //m3u8 += '#EXT-X-ALLOW-CACHE:NO\n';
428 | m3u8 += `#EXT-X-TARGETDURATION:${Math.round(this._duration)}\n`;
429 | m3u8 += `#EXT-X-MEDIA-SEQUENCE:${this._hlsList[0].sequence}\n`;
430 | m3u8 += `#EXT-X-MAP:URI="init-${this._hlsBase}.mp4"\n`;
431 | for (let i = 0; i < this._hlsList.length; i++) {
432 | m3u8 += `#EXTINF:${this._hlsList[i].duration.toFixed(6)},\n`;
433 | m3u8 += `${this._hlsList[i].name}\n`;
434 | }
435 | this._m3u8 = m3u8;
436 | }
437 | if (this._bufferList) {
438 | this._bufferList.push(this._segment);
439 | while (this._bufferList.length > this._bufferListSize) {
440 | this._bufferList.shift();
441 | }
442 | }
443 | if (this._readableState.pipesCount > 0) {
444 | this.push(this._segment);
445 | }
446 | /**
447 | * Fires when the latest Mp4 segment is parsed from the piped data.
448 | * @event Mp4Frag#segment
449 | * @type {Event}
450 | * @property {Buffer} segment - [Mp4Frag.segment]{@link Mp4Frag#segment}
451 | */
452 | this.emit('segment', this._segment);
453 | }
454 |
455 | /**
456 | * Search buffer for mdat.
457 | * @private
458 | */
459 | _findMdat(chunk) {
460 | if (this._mdatBuffer) {
461 | this._mdatBuffer.push(chunk);
462 | const chunkLength = chunk.length;
463 | this._mdatBufferSize += chunkLength;
464 | if (this._mdatLength === this._mdatBufferSize) {
465 | this._setSegment(Buffer.concat([this._moof, ...this._mdatBuffer], this._moofLength + this._mdatLength));
466 | delete this._moof;
467 | delete this._mdatBuffer;
468 | delete this._mdatBufferSize;
469 | delete this._mdatLength;
470 | delete this._moofLength;
471 | this._parseChunk = this._findMoof;
472 | } else if (this._mdatLength < this._mdatBufferSize) {
473 | this._setSegment(Buffer.concat([this._moof, ...this._mdatBuffer], this._moofLength + this._mdatLength));
474 | const sliceIndex = chunkLength - (this._mdatBufferSize - this._mdatLength);
475 | delete this._moof;
476 | delete this._mdatBuffer;
477 | delete this._mdatBufferSize;
478 | delete this._mdatLength;
479 | delete this._moofLength;
480 | this._parseChunk = this._findMoof;
481 | this._parseChunk(chunk.slice(sliceIndex));
482 | }
483 | } else {
484 | const chunkLength = chunk.length;
485 | if (chunkLength < 8 || chunk.indexOf(_MDAT) !== 4) {
486 | this.emit('error', new Error(`${_MDAT.toString()} not found.`));
487 | return;
488 | }
489 | this._mdatLength = chunk.readUInt32BE(0, true);
490 | if (this._mdatLength > chunkLength) {
491 | this._mdatBuffer = [chunk];
492 | this._mdatBufferSize = chunkLength;
493 | } else if (this._mdatLength === chunkLength) {
494 | this._setSegment(Buffer.concat([this._moof, chunk], this._moofLength + chunkLength));
495 | delete this._moof;
496 | delete this._moofLength;
497 | delete this._mdatLength;
498 | this._parseChunk = this._findMoof;
499 | } else {
500 | this._setSegment(Buffer.concat([this._moof, chunk], this._moofLength + this._mdatLength));
501 | const sliceIndex = this._mdatLength;
502 | delete this._moof;
503 | delete this._moofLength;
504 | delete this._mdatLength;
505 | this._parseChunk = this._findMoof;
506 | this._parseChunk(chunk.slice(sliceIndex));
507 | }
508 | }
509 | }
510 |
511 | /**
512 | * Required for stream transform.
513 | * @private
514 | */
515 | _transform(chunk, encoding, callback) {
516 | this._parseChunk(chunk);
517 | callback();
518 | }
519 |
520 | /**
521 | * Run cleanup when unpiped.
522 | * @private
523 | */
524 | _flush(callback) {
525 | this.resetCache();
526 | callback();
527 | }
528 |
529 | /**
530 | * Clear cached values
531 | */
532 | resetCache() {
533 | this._parseChunk = this._findFtyp;
534 | delete this._mime;
535 | delete this._initialization;
536 | delete this._segment;
537 | delete this._timestamp;
538 | delete this._duration;
539 | delete this._moof;
540 | delete this._mdatBuffer;
541 | delete this._moofLength;
542 | delete this._mdatLength;
543 | delete this._mdatBufferSize;
544 | delete this._ftyp;
545 | delete this._ftypLength;
546 | delete this._m3u8;
547 | if (this._hlsList) {
548 | this._hlsList = [];
549 | this._sequence = -1;
550 | }
551 | if (this._bufferList) {
552 | this._bufferList = [];
553 | }
554 | }
555 | }
556 |
557 | module.exports = Mp4Frag;
558 |
--------------------------------------------------------------------------------
/demo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/marcus-j-davies/nvr-js/8f8922eb6c7303b72d431aebdc23e1e15ae5a606/demo.png
--------------------------------------------------------------------------------
/nvrjs.config.example.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | /* System Settings */
3 | system: {
4 | /* Username */
5 | username: "admin",
6 | /* bcrypt password (default: admin) */
7 | password: '$2a$10$CnOx/6vFY2ehRDf68yqd..aLlv0UM.zeBLKnRjuU8YykCsC2Ap3iG',
8 | /* bcrypt API Key (default: x7Te9m38JHQq6ddv) */
9 | apiKey: '$2a$10$N53ci.EIQ7JCu6u1HlOjoO//W0Bmp3GrRruyK1Jysr01CQ1rDrVQK',
10 | /* Any random string */
11 | cookieKey: 'f3gi6FLhIPVV31d1TBQUPEAngrI3wAoP',
12 | interfacePort: 7878,
13 | /* location used for 24/7 recording and database generation */
14 | /* This should be the root of a mount point i.e a dedicated HDD for 24/7 recordings */
15 | storageVolume: '/Volumes/CCTV',
16 | /* Continuous recording settings */
17 | ffmpegLocation: 'ffmpeg',
18 | continuousSegTimeMinutes: 15,
19 | continuousDays: 14,
20 | continuousPurgeIntervalHours: 24,
21 | /* event throttle per sensorId */
22 | eventSensorIdCoolOffSeconds: 60
23 | },
24 | /* Cameras */
25 | cameras: {
26 | '66e39d21-72c4-405c-a838-05a8e8fe0742': {
27 | name: 'Garage',
28 | /* Input Source Config */
29 | /* The keys and values represent the ffmpeg options */
30 | inputConfig: {
31 | use_wallclock_as_timestamps: '1',
32 | fflags: '+igndts',
33 | analyzeduration: '1000000',
34 | probesize: '1000000',
35 | rtsp_transport: 'tcp',
36 | stimeout: '30000000'
37 | },
38 | /* Input Address */
39 | input: 'rtsp://user:password@ip:port/live0',
40 | /* Recording 24/7 */
41 | /* Disabling continuous recording, will disable the ability to create events */
42 | continuous: true,
43 | /* Live streaming config */
44 | /* These settings should be good enough for a low delay live stream, providing your camera produces h264 frames */
45 | /* streaming is achieved with websockets and MP4 fragments */
46 | liveConfig: {
47 | codecString: 'video/mp4; codecs="avc1.64001f"',
48 | streamConfig: {
49 | an: '',
50 | vcodec: 'copy',
51 | f: 'mp4',
52 | movflags: '+frag_keyframe+empty_moov+default_base_moof',
53 | reset_timestamps: '1'
54 | }
55 | }
56 | }
57 | }
58 | };
59 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "nvr-js",
3 | "version": "2.0.0",
4 | "description": "A simple, lightweight, but very functional NVR aimed at 24/7 recording using nodejs",
5 | "main": "NVRJS.js",
6 | "keywords": [
7 | "nvr",
8 | "cctv",
9 | "record",
10 | "24/7",
11 | "continuous",
12 | "footage",
13 | "streaming",
14 | "nodejs",
15 | "node"
16 | ],
17 | "author": {
18 | "name": "Marcus Davies",
19 | "email": "marcus.davies83@icloud.com"
20 | },
21 | "license": "MIT",
22 | "dependencies": {
23 | "child_process": "^1.0.2",
24 | "cookie-parser": "^1.4.6",
25 | "express": "^4.17.2",
26 | "handlebars": "^4.7.7",
27 | "socket.io": "^4.4.0",
28 | "sqlite3": "^5.0.2",
29 | "dayjs": "^1.10.7",
30 | "bcrypt": "^5.0.1",
31 | "node-os-utils": "^1.3.5",
32 | "queue-fifo":"^0.2.6",
33 | "express-rate-limit":"^5.5.1"
34 | },
35 | "devDependencies": {
36 | "eslint": "^8.5.0",
37 | "prettier": "^2.5.1"
38 | },
39 | "bugs": {
40 | "url": "https://github.com/marcus-j-davies/nvr-js/issues"
41 | },
42 | "repository": {
43 | "type": "git",
44 | "url": "git+https://github.com/marcus-j-davies/nvr-js.git"
45 | },
46 | "homepage": "https://github.com/marcus-j-davies/nvr-js#readme"
47 | }
48 |
--------------------------------------------------------------------------------
/readme.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/marcus-j-davies/nvr-js/8f8922eb6c7303b72d431aebdc23e1e15ae5a606/readme.png
--------------------------------------------------------------------------------
/web/dash.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | NVR JS : Dashboard
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 | 
37 | |
38 |
39 |
40 | |
41 |
42 |
43 | |
44 |
45 | 
46 | |
47 |
48 |
49 | |
50 |
51 |
52 | |
53 |
54 | 
55 | |
56 |
57 |
58 | |
59 |
60 |
61 |
62 |
33 |
Login
34 |
35 |
49 |