@camstack/addon-decoder-ffmpeg 1.2.50 → 1.2.52
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.js +117 -6
- package/dist/index.mjs +117 -6
- package/package.json +1 -1
package/dist/index.js
CHANGED
|
@@ -15704,6 +15704,8 @@ var NcSystemEventKindSchema = _enum([
|
|
|
15704
15704
|
"device-offline",
|
|
15705
15705
|
"device-disabled",
|
|
15706
15706
|
"device-enabled",
|
|
15707
|
+
"device-battery-low",
|
|
15708
|
+
"device-battery-normal",
|
|
15707
15709
|
"stream-online",
|
|
15708
15710
|
"stream-offline",
|
|
15709
15711
|
"node-online",
|
|
@@ -18978,6 +18980,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
18978
18980
|
deviceId: number(),
|
|
18979
18981
|
events: array(KeyEventSchema).readonly()
|
|
18980
18982
|
});
|
|
18983
|
+
/** One non-empty bucket of the timeline histogram. */
|
|
18984
|
+
var EventDensityBucketSchema = object({
|
|
18985
|
+
bucketStart: number(),
|
|
18986
|
+
motion: number().int(),
|
|
18987
|
+
object: number().int(),
|
|
18988
|
+
audio: number().int()
|
|
18989
|
+
});
|
|
18990
|
+
/**
|
|
18991
|
+
* One camera's row in a `getEventDensityBatch` answer.
|
|
18992
|
+
*
|
|
18993
|
+
* TWO facts, and the timeline draws them differently:
|
|
18994
|
+
*
|
|
18995
|
+
* - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
|
|
18996
|
+
* claim: read, and nothing happened in the window.
|
|
18997
|
+
* - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
|
|
18998
|
+
* empty and that emptiness means NOTHING; the timeline must render unknown,
|
|
18999
|
+
* not quiet.
|
|
19000
|
+
*
|
|
19001
|
+
* Fanned out per camera the difference was free — one query rejected while the
|
|
19002
|
+
* others resolved — and collapsing to a batch is the exact moment it is lost
|
|
19003
|
+
* silently. Every requested id gets a row: a caller that asked for twelve and
|
|
19004
|
+
* got eleven cannot tell which one is missing, or that any is.
|
|
19005
|
+
*/
|
|
19006
|
+
var EventDensityForDeviceSchema = object({
|
|
19007
|
+
deviceId: number(),
|
|
19008
|
+
read: _enum(["read", "unreadable"]),
|
|
19009
|
+
buckets: array(EventDensityBucketSchema).readonly()
|
|
19010
|
+
});
|
|
18981
19011
|
object({
|
|
18982
19012
|
trackId: string(),
|
|
18983
19013
|
className: string(),
|
|
@@ -19288,12 +19318,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
19288
19318
|
since: number(),
|
|
19289
19319
|
until: number(),
|
|
19290
19320
|
bucketMs: number().int().positive()
|
|
19291
|
-
}), array(object({
|
|
19292
|
-
|
|
19293
|
-
|
|
19294
|
-
|
|
19295
|
-
|
|
19296
|
-
})).readonly()), method(object({
|
|
19321
|
+
}), array(EventDensityBucketSchema).readonly()), method(object({
|
|
19322
|
+
deviceIds: array(number()).min(1).max(200),
|
|
19323
|
+
since: number(),
|
|
19324
|
+
until: number(),
|
|
19325
|
+
bucketMs: number().int().positive()
|
|
19326
|
+
}), array(EventDensityForDeviceSchema).readonly()), method(object({
|
|
19297
19327
|
deviceId: number(),
|
|
19298
19328
|
cutoffMs: number()
|
|
19299
19329
|
}), object({
|
|
@@ -26603,6 +26633,39 @@ var RecordingDaysSchema = object({
|
|
|
26603
26633
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26604
26634
|
days: array(number())
|
|
26605
26635
|
});
|
|
26636
|
+
/**
|
|
26637
|
+
* One camera's row in a `getAvailabilityBatch` answer.
|
|
26638
|
+
*
|
|
26639
|
+
* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
|
|
26640
|
+
* batch collapses the transport, not the work — plus the one thing the singular
|
|
26641
|
+
* method never had to say:
|
|
26642
|
+
*
|
|
26643
|
+
* - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
|
|
26644
|
+
* no footage in the window", which is a real claim.
|
|
26645
|
+
* - `read: 'unreadable'` — the recorder could not answer for this camera (its
|
|
26646
|
+
* calendar rung threw, its location is unmounted). `ranges` is empty and
|
|
26647
|
+
* that emptiness means NOTHING.
|
|
26648
|
+
*
|
|
26649
|
+
* A timeline that renders the second as the first tells an operator there is no
|
|
26650
|
+
* footage when the truth is that nobody looked.
|
|
26651
|
+
*/
|
|
26652
|
+
var RecordingAvailabilityForDeviceSchema = object({
|
|
26653
|
+
deviceId: number(),
|
|
26654
|
+
read: _enum(["read", "unreadable"]),
|
|
26655
|
+
ranges: array(RecordingRangeSchema).readonly()
|
|
26656
|
+
});
|
|
26657
|
+
/**
|
|
26658
|
+
* One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
|
|
26659
|
+
* {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
|
|
26660
|
+
* "no footage in this month", `read: 'unreadable'` is "nobody could look", and
|
|
26661
|
+
* the date-picker's day dots must not spell them the same.
|
|
26662
|
+
*/
|
|
26663
|
+
var RecordingDaysForDeviceSchema = object({
|
|
26664
|
+
deviceId: number(),
|
|
26665
|
+
read: _enum(["read", "unreadable"]),
|
|
26666
|
+
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26667
|
+
days: array(number()).readonly()
|
|
26668
|
+
});
|
|
26606
26669
|
var RecordingManifestSchema = object({
|
|
26607
26670
|
deviceId: number(),
|
|
26608
26671
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -26837,6 +26900,13 @@ method(object({
|
|
|
26837
26900
|
}), RecordingAvailabilitySchema, {
|
|
26838
26901
|
kind: "query",
|
|
26839
26902
|
auth: "protected"
|
|
26903
|
+
}), method(object({
|
|
26904
|
+
deviceIds: array(number()).min(1).max(200),
|
|
26905
|
+
fromMs: number(),
|
|
26906
|
+
toMs: number()
|
|
26907
|
+
}), array(RecordingAvailabilityForDeviceSchema).readonly(), {
|
|
26908
|
+
kind: "query",
|
|
26909
|
+
auth: "protected"
|
|
26840
26910
|
}), method(object({
|
|
26841
26911
|
deviceId: number(),
|
|
26842
26912
|
fromMs: number(),
|
|
@@ -26845,6 +26915,14 @@ method(object({
|
|
|
26845
26915
|
}), RecordingDaysSchema, {
|
|
26846
26916
|
kind: "query",
|
|
26847
26917
|
auth: "protected"
|
|
26918
|
+
}), method(object({
|
|
26919
|
+
deviceIds: array(number()).min(1).max(200),
|
|
26920
|
+
fromMs: number(),
|
|
26921
|
+
toMs: number(),
|
|
26922
|
+
tzOffsetMinutes: number()
|
|
26923
|
+
}), array(RecordingDaysForDeviceSchema).readonly(), {
|
|
26924
|
+
kind: "query",
|
|
26925
|
+
auth: "protected"
|
|
26848
26926
|
}), method(object({
|
|
26849
26927
|
deviceId: number(),
|
|
26850
26928
|
fromMs: number(),
|
|
@@ -32042,6 +32120,12 @@ Object.freeze({
|
|
|
32042
32120
|
addonId: null,
|
|
32043
32121
|
access: "view"
|
|
32044
32122
|
},
|
|
32123
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
32124
|
+
capName: "pipeline-analytics",
|
|
32125
|
+
capScope: "device",
|
|
32126
|
+
addonId: null,
|
|
32127
|
+
access: "view"
|
|
32128
|
+
},
|
|
32045
32129
|
"pipelineAnalytics.getEventMedia": {
|
|
32046
32130
|
capName: "pipeline-analytics",
|
|
32047
32131
|
capScope: "device",
|
|
@@ -33164,12 +33248,24 @@ Object.freeze({
|
|
|
33164
33248
|
addonId: null,
|
|
33165
33249
|
access: "view"
|
|
33166
33250
|
},
|
|
33251
|
+
"recording.getAvailabilityBatch": {
|
|
33252
|
+
capName: "recording",
|
|
33253
|
+
capScope: "system",
|
|
33254
|
+
addonId: null,
|
|
33255
|
+
access: "view"
|
|
33256
|
+
},
|
|
33167
33257
|
"recording.getDaysWithRecordings": {
|
|
33168
33258
|
capName: "recording",
|
|
33169
33259
|
capScope: "system",
|
|
33170
33260
|
addonId: null,
|
|
33171
33261
|
access: "view"
|
|
33172
33262
|
},
|
|
33263
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
33264
|
+
capName: "recording",
|
|
33265
|
+
capScope: "system",
|
|
33266
|
+
addonId: null,
|
|
33267
|
+
access: "view"
|
|
33268
|
+
},
|
|
33173
33269
|
"recording.getDeviceConfig": {
|
|
33174
33270
|
capName: "recording",
|
|
33175
33271
|
capScope: "system",
|
|
@@ -35774,6 +35870,11 @@ Object.freeze({
|
|
|
35774
35870
|
form: "single",
|
|
35775
35871
|
optional: false
|
|
35776
35872
|
}],
|
|
35873
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
35874
|
+
name: "deviceIds",
|
|
35875
|
+
form: "array",
|
|
35876
|
+
optional: false
|
|
35877
|
+
}],
|
|
35777
35878
|
"pipelineAnalytics.getEventMedia": [{
|
|
35778
35879
|
name: "deviceId",
|
|
35779
35880
|
form: "single",
|
|
@@ -36189,11 +36290,21 @@ Object.freeze({
|
|
|
36189
36290
|
form: "single",
|
|
36190
36291
|
optional: false
|
|
36191
36292
|
}],
|
|
36293
|
+
"recording.getAvailabilityBatch": [{
|
|
36294
|
+
name: "deviceIds",
|
|
36295
|
+
form: "array",
|
|
36296
|
+
optional: false
|
|
36297
|
+
}],
|
|
36192
36298
|
"recording.getDaysWithRecordings": [{
|
|
36193
36299
|
name: "deviceId",
|
|
36194
36300
|
form: "single",
|
|
36195
36301
|
optional: false
|
|
36196
36302
|
}],
|
|
36303
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
36304
|
+
name: "deviceIds",
|
|
36305
|
+
form: "array",
|
|
36306
|
+
optional: false
|
|
36307
|
+
}],
|
|
36197
36308
|
"recording.getDeviceConfig": [{
|
|
36198
36309
|
name: "deviceId",
|
|
36199
36310
|
form: "single",
|
package/dist/index.mjs
CHANGED
|
@@ -15700,6 +15700,8 @@ var NcSystemEventKindSchema = _enum([
|
|
|
15700
15700
|
"device-offline",
|
|
15701
15701
|
"device-disabled",
|
|
15702
15702
|
"device-enabled",
|
|
15703
|
+
"device-battery-low",
|
|
15704
|
+
"device-battery-normal",
|
|
15703
15705
|
"stream-online",
|
|
15704
15706
|
"stream-offline",
|
|
15705
15707
|
"node-online",
|
|
@@ -18974,6 +18976,34 @@ var KeyEventsForDeviceSchema = object({
|
|
|
18974
18976
|
deviceId: number(),
|
|
18975
18977
|
events: array(KeyEventSchema).readonly()
|
|
18976
18978
|
});
|
|
18979
|
+
/** One non-empty bucket of the timeline histogram. */
|
|
18980
|
+
var EventDensityBucketSchema = object({
|
|
18981
|
+
bucketStart: number(),
|
|
18982
|
+
motion: number().int(),
|
|
18983
|
+
object: number().int(),
|
|
18984
|
+
audio: number().int()
|
|
18985
|
+
});
|
|
18986
|
+
/**
|
|
18987
|
+
* One camera's row in a `getEventDensityBatch` answer.
|
|
18988
|
+
*
|
|
18989
|
+
* TWO facts, and the timeline draws them differently:
|
|
18990
|
+
*
|
|
18991
|
+
* - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
|
|
18992
|
+
* claim: read, and nothing happened in the window.
|
|
18993
|
+
* - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
|
|
18994
|
+
* empty and that emptiness means NOTHING; the timeline must render unknown,
|
|
18995
|
+
* not quiet.
|
|
18996
|
+
*
|
|
18997
|
+
* Fanned out per camera the difference was free — one query rejected while the
|
|
18998
|
+
* others resolved — and collapsing to a batch is the exact moment it is lost
|
|
18999
|
+
* silently. Every requested id gets a row: a caller that asked for twelve and
|
|
19000
|
+
* got eleven cannot tell which one is missing, or that any is.
|
|
19001
|
+
*/
|
|
19002
|
+
var EventDensityForDeviceSchema = object({
|
|
19003
|
+
deviceId: number(),
|
|
19004
|
+
read: _enum(["read", "unreadable"]),
|
|
19005
|
+
buckets: array(EventDensityBucketSchema).readonly()
|
|
19006
|
+
});
|
|
18977
19007
|
object({
|
|
18978
19008
|
trackId: string(),
|
|
18979
19009
|
className: string(),
|
|
@@ -19284,12 +19314,12 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
|
|
|
19284
19314
|
since: number(),
|
|
19285
19315
|
until: number(),
|
|
19286
19316
|
bucketMs: number().int().positive()
|
|
19287
|
-
}), array(object({
|
|
19288
|
-
|
|
19289
|
-
|
|
19290
|
-
|
|
19291
|
-
|
|
19292
|
-
})).readonly()), method(object({
|
|
19317
|
+
}), array(EventDensityBucketSchema).readonly()), method(object({
|
|
19318
|
+
deviceIds: array(number()).min(1).max(200),
|
|
19319
|
+
since: number(),
|
|
19320
|
+
until: number(),
|
|
19321
|
+
bucketMs: number().int().positive()
|
|
19322
|
+
}), array(EventDensityForDeviceSchema).readonly()), method(object({
|
|
19293
19323
|
deviceId: number(),
|
|
19294
19324
|
cutoffMs: number()
|
|
19295
19325
|
}), object({
|
|
@@ -26599,6 +26629,39 @@ var RecordingDaysSchema = object({
|
|
|
26599
26629
|
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26600
26630
|
days: array(number())
|
|
26601
26631
|
});
|
|
26632
|
+
/**
|
|
26633
|
+
* One camera's row in a `getAvailabilityBatch` answer.
|
|
26634
|
+
*
|
|
26635
|
+
* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
|
|
26636
|
+
* batch collapses the transport, not the work — plus the one thing the singular
|
|
26637
|
+
* method never had to say:
|
|
26638
|
+
*
|
|
26639
|
+
* - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
|
|
26640
|
+
* no footage in the window", which is a real claim.
|
|
26641
|
+
* - `read: 'unreadable'` — the recorder could not answer for this camera (its
|
|
26642
|
+
* calendar rung threw, its location is unmounted). `ranges` is empty and
|
|
26643
|
+
* that emptiness means NOTHING.
|
|
26644
|
+
*
|
|
26645
|
+
* A timeline that renders the second as the first tells an operator there is no
|
|
26646
|
+
* footage when the truth is that nobody looked.
|
|
26647
|
+
*/
|
|
26648
|
+
var RecordingAvailabilityForDeviceSchema = object({
|
|
26649
|
+
deviceId: number(),
|
|
26650
|
+
read: _enum(["read", "unreadable"]),
|
|
26651
|
+
ranges: array(RecordingRangeSchema).readonly()
|
|
26652
|
+
});
|
|
26653
|
+
/**
|
|
26654
|
+
* One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
|
|
26655
|
+
* {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
|
|
26656
|
+
* "no footage in this month", `read: 'unreadable'` is "nobody could look", and
|
|
26657
|
+
* the date-picker's day dots must not spell them the same.
|
|
26658
|
+
*/
|
|
26659
|
+
var RecordingDaysForDeviceSchema = object({
|
|
26660
|
+
deviceId: number(),
|
|
26661
|
+
read: _enum(["read", "unreadable"]),
|
|
26662
|
+
/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
|
|
26663
|
+
days: array(number()).readonly()
|
|
26664
|
+
});
|
|
26602
26665
|
var RecordingManifestSchema = object({
|
|
26603
26666
|
deviceId: number(),
|
|
26604
26667
|
/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
|
|
@@ -26833,6 +26896,13 @@ method(object({
|
|
|
26833
26896
|
}), RecordingAvailabilitySchema, {
|
|
26834
26897
|
kind: "query",
|
|
26835
26898
|
auth: "protected"
|
|
26899
|
+
}), method(object({
|
|
26900
|
+
deviceIds: array(number()).min(1).max(200),
|
|
26901
|
+
fromMs: number(),
|
|
26902
|
+
toMs: number()
|
|
26903
|
+
}), array(RecordingAvailabilityForDeviceSchema).readonly(), {
|
|
26904
|
+
kind: "query",
|
|
26905
|
+
auth: "protected"
|
|
26836
26906
|
}), method(object({
|
|
26837
26907
|
deviceId: number(),
|
|
26838
26908
|
fromMs: number(),
|
|
@@ -26841,6 +26911,14 @@ method(object({
|
|
|
26841
26911
|
}), RecordingDaysSchema, {
|
|
26842
26912
|
kind: "query",
|
|
26843
26913
|
auth: "protected"
|
|
26914
|
+
}), method(object({
|
|
26915
|
+
deviceIds: array(number()).min(1).max(200),
|
|
26916
|
+
fromMs: number(),
|
|
26917
|
+
toMs: number(),
|
|
26918
|
+
tzOffsetMinutes: number()
|
|
26919
|
+
}), array(RecordingDaysForDeviceSchema).readonly(), {
|
|
26920
|
+
kind: "query",
|
|
26921
|
+
auth: "protected"
|
|
26844
26922
|
}), method(object({
|
|
26845
26923
|
deviceId: number(),
|
|
26846
26924
|
fromMs: number(),
|
|
@@ -32038,6 +32116,12 @@ Object.freeze({
|
|
|
32038
32116
|
addonId: null,
|
|
32039
32117
|
access: "view"
|
|
32040
32118
|
},
|
|
32119
|
+
"pipelineAnalytics.getEventDensityBatch": {
|
|
32120
|
+
capName: "pipeline-analytics",
|
|
32121
|
+
capScope: "device",
|
|
32122
|
+
addonId: null,
|
|
32123
|
+
access: "view"
|
|
32124
|
+
},
|
|
32041
32125
|
"pipelineAnalytics.getEventMedia": {
|
|
32042
32126
|
capName: "pipeline-analytics",
|
|
32043
32127
|
capScope: "device",
|
|
@@ -33160,12 +33244,24 @@ Object.freeze({
|
|
|
33160
33244
|
addonId: null,
|
|
33161
33245
|
access: "view"
|
|
33162
33246
|
},
|
|
33247
|
+
"recording.getAvailabilityBatch": {
|
|
33248
|
+
capName: "recording",
|
|
33249
|
+
capScope: "system",
|
|
33250
|
+
addonId: null,
|
|
33251
|
+
access: "view"
|
|
33252
|
+
},
|
|
33163
33253
|
"recording.getDaysWithRecordings": {
|
|
33164
33254
|
capName: "recording",
|
|
33165
33255
|
capScope: "system",
|
|
33166
33256
|
addonId: null,
|
|
33167
33257
|
access: "view"
|
|
33168
33258
|
},
|
|
33259
|
+
"recording.getDaysWithRecordingsBatch": {
|
|
33260
|
+
capName: "recording",
|
|
33261
|
+
capScope: "system",
|
|
33262
|
+
addonId: null,
|
|
33263
|
+
access: "view"
|
|
33264
|
+
},
|
|
33169
33265
|
"recording.getDeviceConfig": {
|
|
33170
33266
|
capName: "recording",
|
|
33171
33267
|
capScope: "system",
|
|
@@ -35770,6 +35866,11 @@ Object.freeze({
|
|
|
35770
35866
|
form: "single",
|
|
35771
35867
|
optional: false
|
|
35772
35868
|
}],
|
|
35869
|
+
"pipelineAnalytics.getEventDensityBatch": [{
|
|
35870
|
+
name: "deviceIds",
|
|
35871
|
+
form: "array",
|
|
35872
|
+
optional: false
|
|
35873
|
+
}],
|
|
35773
35874
|
"pipelineAnalytics.getEventMedia": [{
|
|
35774
35875
|
name: "deviceId",
|
|
35775
35876
|
form: "single",
|
|
@@ -36185,11 +36286,21 @@ Object.freeze({
|
|
|
36185
36286
|
form: "single",
|
|
36186
36287
|
optional: false
|
|
36187
36288
|
}],
|
|
36289
|
+
"recording.getAvailabilityBatch": [{
|
|
36290
|
+
name: "deviceIds",
|
|
36291
|
+
form: "array",
|
|
36292
|
+
optional: false
|
|
36293
|
+
}],
|
|
36188
36294
|
"recording.getDaysWithRecordings": [{
|
|
36189
36295
|
name: "deviceId",
|
|
36190
36296
|
form: "single",
|
|
36191
36297
|
optional: false
|
|
36192
36298
|
}],
|
|
36299
|
+
"recording.getDaysWithRecordingsBatch": [{
|
|
36300
|
+
name: "deviceIds",
|
|
36301
|
+
form: "array",
|
|
36302
|
+
optional: false
|
|
36303
|
+
}],
|
|
36193
36304
|
"recording.getDeviceConfig": [{
|
|
36194
36305
|
name: "deviceId",
|
|
36195
36306
|
form: "single",
|