matterbridge-example-camera 0.0.7 → 0.0.8-dev-20260726-2ea4814

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/CHANGELOG.md CHANGED
@@ -28,6 +28,21 @@ If you like this project and find it useful, please consider giving it a star on
28
28
 
29
29
  <a href="https://www.buymeacoffee.com/luligugithub"><img src="https://matterbridge.io/assets/bmc-button.svg" alt="Buy me a coffee" width="120"></a>
30
30
 
31
+ ## [0.0.8] - Dev branch
32
+
33
+ ### Added
34
+
35
+ - [webrtc]: Add an `rtsp` video generator option that pulls from a real RTSP camera via `ffmpeg -rtsp_transport tcp -i <url>` instead of only the synthetic test pattern or a local webcam.
36
+ - [platform]: Rename the `webcam`/`webcamResolution`/`webcamBitrate` config properties to `videoSource`/`videoResolution`/`videoBitrate` (and the corresponding `MATTERBRIDGE_CAMERA_WEBCAM_*` env vars to `MATTERBRIDGE_CAMERA_VIDEO_SOURCE_DEVICE`/`MATTERBRIDGE_CAMERA_VIDEO_RESOLUTION`/`MATTERBRIDGE_CAMERA_VIDEO_BITRATE`), since `videoSource` now also holds the RTSP url for the `rtsp` generator.
37
+ - [platform]: Rename the `generator` config property to `videoGenerator`.
38
+ - [webrtc]: Add an `auto` value for `videoResolution` (now the default) that uses the controller's requested per-session resolution (the allocated video stream's `maxResolution`) instead of a fixed value; a fixed `videoResolution` still always wins over the controller's request. For `rtsp`, the resolved resolution (fixed or auto) is now applied to the injected track with an ffmpeg `scale` filter instead of being ignored.
39
+ - [docs]: Document the `rtsp` video generator, the renamed config properties, the `auto`/fixed `videoResolution` precedence, and the previously undocumented `videoBitrate` property in the README, with example configurations.
40
+ - [tests]: Add `rtsp` video source and `videoResolution` precedence (`auto` vs. fixed, webcam and rtsp) coverage in `vitest/webrtc/weriftSession.test.ts`; extend `vitest/module.test.ts` with the `videoGenerator` normalization test and a test for the `videoResolution` default of `auto`.
41
+
42
+ ### Fixed
43
+
44
+ - [webrtc]: The per-session requested webcam resolution (from a client's `CameraAvStreamManagement.VideoStreamAllocate`) was never actually applied: `buildFfmpegVideoInputArgs` read `MATTERBRIDGE_CAMERA_VIDEO_RESOLUTION` directly before falling back to `getConfiguredVideoResolution(requestedResolution)`, and since the plugin always sets that env var (default `640x480`), the fallback — and therefore the requested resolution — was never reached.
45
+
31
46
  ## [0.0.7] - 2026-07-25
32
47
 
33
48
  ### Added
package/README.md CHANGED
@@ -192,15 +192,19 @@ With both directions in place, either Intercom can call the other; a call initia
192
192
 
193
193
  The platform configuration controls WebRTC video injection with these properties:
194
194
 
195
- - `generator` is required and accepts `none`, `test`, or `webcam`. It defaults to `none`, which negotiates the video transceiver without attaching a track. `test` injects a synthetic moving test pattern, while `webcam` captures from the configured local webcam.
196
- - `webcam` is optional and has no default. It contains the OS-specific ffmpeg device identifier — e.g. `/dev/video0` on Linux (v4l2), an avfoundation index such as `0` on macOS, or a device name such as `Integrated Camera` on Windows (dshow). Selecting the `webcam` generator without this property falls back to the test pattern with a warning.
197
- - `webcamResolution` is required and accepts `640x480`, `1280x720`, or `1920x1080`. It defaults to `640x480`. The actual achievable frame rate depends on the webcam and can be much lower than 30 FPS at higher resolutions (check with `v4l2-ctl -d <device> --list-formats-ext` on Linux).
195
+ - `videoGenerator` is required and accepts `none`, `test`, `webcam`, or `rtsp`. It defaults to `none`, which negotiates the video transceiver without attaching a track. `test` injects a synthetic moving test pattern, `webcam` captures from the configured local webcam, and `rtsp` pulls from the RTSP url configured in `videoSource`.
198
196
 
199
- A real client's resolution/quality picker (e.g. in Home Assistant) takes precedence over `webcamResolution`: it allocates a video stream with `CameraAvStreamManagement.VideoStreamAllocate` before soliciting or providing a WebRTC offer, and `MatterbridgeWebRtcTransportProviderServer` looks up that stream's `maxResolution` to select the webcam capture resolution for the session. `webcamResolution` is used when no matching allocated stream is found, or when the requested resolution isn't one of the three supported above.
197
+ - `videoSource` is optional and has no default. For the `webcam` generator it contains the OS-specific ffmpeg device identifier — e.g. `/dev/video0` on Linux (v4l2), an avfoundation index such as `0` on macOS, or a device name such as `Integrated Camera` on Windows (dshow). For the `rtsp` generator it instead holds the RTSP url, e.g. `rtsp://user:password@host:554/path`. Selecting the `webcam` or `rtsp` generator without this property falls back to the test pattern with a warning.
198
+
199
+ - `videoResolution` is required and accepts `auto`, `640x480`, `1280x720`, or `1920x1080`. It defaults to `auto`, which uses the resolution requested by the controller for the session (see below), falling back to `640x480` when no request is available or it names an unsupported resolution. A fixed resolution always wins over what the controller requested. The actual achievable frame rate depends on the webcam and can be much lower than 30 FPS at higher resolutions (check with `v4l2-ctl -d <device> --list-formats-ext` on Linux).
200
+
201
+ - `videoBitrate` is required and accepts a number (the target encoder bitrate in kbps). It defaults to `1000`. It applies to the `webcam` and `rtsp` sources only; the `test` pattern is always encoded at a fixed 1000 kbps regardless of this setting.
202
+
203
+ With `videoResolution: "auto"`, a real client's resolution/quality picker (e.g. in Home Assistant) drives the capture/output resolution: it allocates a video stream with `CameraAvStreamManagement.VideoStreamAllocate` before soliciting or providing a WebRTC offer, and `MatterbridgeWebRtcTransportProviderServer` looks up that stream's `maxResolution` to select the resolution for the session. For `webcam` this is the capture resolution passed to ffmpeg; for `rtsp` the camera keeps streaming at its own native resolution and ffmpeg scales it to match.
200
204
 
201
205
  Requires `ffmpeg` to be installed. The resolver checks the system command and common installation directories on Linux, macOS, and Windows.
202
206
 
203
- Use ffmpeg itself to list the available capture devices and find the right value for `webcam`:
207
+ Use ffmpeg itself to list the available capture devices and find the right value for `videoSource`:
204
208
 
205
209
  - Linux (v4l2): `v4l2-ctl --list-devices` (from `v4l-utils`), or `ls /dev/video*`.
206
210
  - macOS (avfoundation): `ffmpeg -f avfoundation -list_devices true -i dummy` — video devices are listed with their index, e.g. `[0] FaceTime HD Camera`; use that index (e.g. `0`) as the device value.
@@ -210,19 +214,40 @@ Example configuration for a real Linux webcam at 720p:
210
214
 
211
215
  ```json
212
216
  {
213
- "generator": "webcam",
214
- "webcam": "/dev/video0",
215
- "webcamResolution": "1280x720"
217
+ "videoGenerator": "webcam",
218
+ "videoSource": "/dev/video0",
219
+ "videoResolution": "1280x720"
220
+ }
221
+ ```
222
+
223
+ Example, capturing from a real Windows webcam at 720p with a higher bitrate:
224
+
225
+ ```json
226
+ {
227
+ "videoGenerator": "webcam",
228
+ "videoSource": "Integrated Camera",
229
+ "videoResolution": "1280x720",
230
+ "videoBitrate": 2000
231
+ }
232
+ ```
233
+
234
+ Example, pulling from a real RTSP camera, scaled to a fixed 1280x720 and re-encoded at `videoBitrate` (the camera's own frame rate is kept):
235
+
236
+ ```json
237
+ {
238
+ "videoGenerator": "rtsp",
239
+ "videoSource": "rtsp://admin:password@192.168.1.100:554/ch1/main",
240
+ "videoResolution": "1280x720"
216
241
  }
217
242
  ```
218
243
 
219
- Example, capturing from a real Windows webcam at 720p:
244
+ Example, pulling from a real RTSP camera and scaling to whatever resolution the controller requests for the session:
220
245
 
221
246
  ```json
222
247
  {
223
- "generator": "webcam",
224
- "webcam": "Integrated Camera",
225
- "webcamResolution": "1280x720"
248
+ "videoGenerator": "rtsp",
249
+ "videoSource": "rtsp://admin:password@192.168.1.100:554/ch1/main",
250
+ "videoResolution": "auto"
226
251
  }
227
252
  ```
228
253
 
package/dist/module.js CHANGED
@@ -31,25 +31,25 @@ export class ExampleMatterbridgeCameraPlatform extends MatterbridgeDynamicPlatfo
31
31
  this.log.info(`Initializing platform ${this.config.name}...`);
32
32
  this.config.whiteList ??= [];
33
33
  this.config.blackList ??= [];
34
- this.config.generator ??= 'none';
35
- this.config.webcamResolution ??= '640x480';
36
- this.config.webcamBitrate ??= 1000;
34
+ this.config.videoGenerator ??= 'none';
35
+ this.config.videoResolution ??= 'auto';
36
+ this.config.videoBitrate ??= 1000;
37
37
  this.config.animationInterval ??= 60;
38
38
  this.config.debug ??= false;
39
39
  this.config.unregisterOnShutdown ??= false;
40
- process.env.MATTERBRIDGE_CAMERA_VIDEO_SOURCE = this.config.generator;
41
- if (this.config.webcam === undefined)
42
- delete process.env.MATTERBRIDGE_CAMERA_WEBCAM_DEVICE;
40
+ process.env.MATTERBRIDGE_CAMERA_VIDEO_SOURCE = this.config.videoGenerator;
41
+ if (this.config.videoSource === undefined)
42
+ delete process.env.MATTERBRIDGE_CAMERA_VIDEO_SOURCE_DEVICE;
43
43
  else
44
- process.env.MATTERBRIDGE_CAMERA_WEBCAM_DEVICE = this.config.webcam;
45
- process.env.MATTERBRIDGE_CAMERA_WEBCAM_RESOLUTION = this.config.webcamResolution;
46
- process.env.MATTERBRIDGE_CAMERA_WEBCAM_BITRATE = String(this.config.webcamBitrate);
44
+ process.env.MATTERBRIDGE_CAMERA_VIDEO_SOURCE_DEVICE = this.config.videoSource;
45
+ process.env.MATTERBRIDGE_CAMERA_VIDEO_RESOLUTION = this.config.videoResolution;
46
+ process.env.MATTERBRIDGE_CAMERA_VIDEO_BITRATE = String(this.config.videoBitrate);
47
47
  this.log.debug(`Platform ${this.config.name} config:\n${RESET}${inspect(this.config, { depth: 10, colors: true })}`);
48
48
  this.log.debug(`Platform ${this.config.name} environment variables:\n${RESET}${inspect({
49
49
  MATTERBRIDGE_CAMERA_VIDEO_SOURCE: process.env.MATTERBRIDGE_CAMERA_VIDEO_SOURCE,
50
- MATTERBRIDGE_CAMERA_WEBCAM_DEVICE: process.env.MATTERBRIDGE_CAMERA_WEBCAM_DEVICE,
51
- MATTERBRIDGE_CAMERA_WEBCAM_RESOLUTION: process.env.MATTERBRIDGE_CAMERA_WEBCAM_RESOLUTION,
52
- MATTERBRIDGE_CAMERA_WEBCAM_BITRATE: process.env.MATTERBRIDGE_CAMERA_WEBCAM_BITRATE,
50
+ MATTERBRIDGE_CAMERA_VIDEO_SOURCE_DEVICE: process.env.MATTERBRIDGE_CAMERA_VIDEO_SOURCE_DEVICE,
51
+ MATTERBRIDGE_CAMERA_VIDEO_RESOLUTION: process.env.MATTERBRIDGE_CAMERA_VIDEO_RESOLUTION,
52
+ MATTERBRIDGE_CAMERA_VIDEO_BITRATE: process.env.MATTERBRIDGE_CAMERA_VIDEO_BITRATE,
53
53
  }, { depth: 10, colors: true })}`);
54
54
  this.log.info(`Platform ${this.config.name} initialized successfully`);
55
55
  }
@@ -143,9 +143,6 @@ export class ExampleMatterbridgeCameraPlatform extends MatterbridgeDynamicPlatfo
143
143
  const exampleChime = this.getDeviceById('Chime-CHIME-001');
144
144
  await exampleChime?.setCluster(PowerSource, { batChargeLevel: PowerSource.BatChargeLevel.Ok, batPercentRemaining: 150, batQuantity: 2, batReplacementDescription: 'AA' }, exampleChime.log);
145
145
  await exampleChime?.setCluster(ChimeCluster, { enabled: true, selectedChime: 0 }, exampleChime.log);
146
- const exampleIntercom1 = this.getDeviceById('Intercom1-INTERCOM1-001');
147
- if (!exampleIntercom1)
148
- throw new Error(`Intercom device not found. Please ensure the device is registered before configuration.`);
149
146
  const serverChime = this.getDeviceById('ServerChime-SERVER-CHIME-001');
150
147
  await serverChime?.setCluster(PowerSource, { batChargeLevel: PowerSource.BatChargeLevel.Ok, batPercentRemaining: 150, batVoltage: 2900, batReplacementNeeded: false }, serverChime.log);
151
148
  await serverChime?.setCluster(ChimeCluster, { enabled: true, selectedChime: 0 }, serverChime.log);
@@ -169,38 +169,39 @@ export class WeriftWebRtcSession {
169
169
  this.log.debug('No preferred injectable audio codec (Opus) negotiated on any audio transceiver');
170
170
  return undefined;
171
171
  }
172
- static SUPPORTED_WEBCAM_RESOLUTIONS = ['640x480', '1280x720', '1920x1080'];
172
+ static SUPPORTED_VIDEO_RESOLUTIONS = ['640x480', '1280x720', '1920x1080'];
173
173
  static DEFAULT_BITRATE_KBPS = 1000;
174
- getConfiguredWebcamBitrate() {
175
- const configured = process.env.MATTERBRIDGE_CAMERA_WEBCAM_BITRATE;
174
+ getConfiguredVideoBitrate() {
175
+ const configured = process.env.MATTERBRIDGE_CAMERA_VIDEO_BITRATE;
176
176
  if (!configured)
177
177
  return WeriftWebRtcSession.DEFAULT_BITRATE_KBPS;
178
178
  const bitrateKbps = Number(configured);
179
179
  if (!Number.isFinite(bitrateKbps) || bitrateKbps <= 0) {
180
- this.log.warn(`Invalid MATTERBRIDGE_CAMERA_WEBCAM_BITRATE "${configured}"; falling back to ${WeriftWebRtcSession.DEFAULT_BITRATE_KBPS}kbps`);
180
+ this.log.warn(`Invalid MATTERBRIDGE_CAMERA_VIDEO_BITRATE "${configured}"; falling back to ${WeriftWebRtcSession.DEFAULT_BITRATE_KBPS}kbps`);
181
181
  return WeriftWebRtcSession.DEFAULT_BITRATE_KBPS;
182
182
  }
183
183
  return bitrateKbps;
184
184
  }
185
- getConfiguredWebcamResolution(requestedResolution) {
186
- const [defaultResolution] = WeriftWebRtcSession.SUPPORTED_WEBCAM_RESOLUTIONS;
185
+ getConfiguredVideoResolution(requestedResolution) {
186
+ const [defaultResolution] = WeriftWebRtcSession.SUPPORTED_VIDEO_RESOLUTIONS;
187
+ const configured = process.env.MATTERBRIDGE_CAMERA_VIDEO_RESOLUTION;
188
+ if (configured && configured !== 'auto') {
189
+ if (WeriftWebRtcSession.SUPPORTED_VIDEO_RESOLUTIONS.includes(configured)) {
190
+ this.log.debug(`Using configured MATTERBRIDGE_CAMERA_VIDEO_RESOLUTION ${configured}`);
191
+ return configured;
192
+ }
193
+ this.log.warn(`Unsupported MATTERBRIDGE_CAMERA_VIDEO_RESOLUTION "${configured}" (supported: ${WeriftWebRtcSession.SUPPORTED_VIDEO_RESOLUTIONS.join(', ')}, auto); falling back to ${defaultResolution}`);
194
+ return defaultResolution;
195
+ }
187
196
  if (requestedResolution) {
188
- if (WeriftWebRtcSession.SUPPORTED_WEBCAM_RESOLUTIONS.includes(requestedResolution)) {
189
- this.log.debug(`Using requested webcam capture resolution ${requestedResolution}`);
197
+ if (WeriftWebRtcSession.SUPPORTED_VIDEO_RESOLUTIONS.includes(requestedResolution)) {
198
+ this.log.debug(`Using requested video stream resolution ${requestedResolution} (MATTERBRIDGE_CAMERA_VIDEO_RESOLUTION=auto)`);
190
199
  return requestedResolution;
191
200
  }
192
- this.log.warn(`Requested video stream resolution "${requestedResolution}" is not supported for webcam capture (supported: ${WeriftWebRtcSession.SUPPORTED_WEBCAM_RESOLUTIONS.join(', ')}); falling back to MATTERBRIDGE_CAMERA_WEBCAM_RESOLUTION`);
193
- }
194
- const requested = process.env.MATTERBRIDGE_CAMERA_WEBCAM_RESOLUTION;
195
- if (!requested) {
196
- this.log.debug(`Using default webcam capture resolution ${defaultResolution}`);
201
+ this.log.warn(`Requested video stream resolution "${requestedResolution}" is not supported (supported: ${WeriftWebRtcSession.SUPPORTED_VIDEO_RESOLUTIONS.join(', ')}); falling back to ${defaultResolution}`);
197
202
  return defaultResolution;
198
203
  }
199
- if (WeriftWebRtcSession.SUPPORTED_WEBCAM_RESOLUTIONS.includes(requested)) {
200
- this.log.debug(`Using MATTERBRIDGE_CAMERA_WEBCAM_RESOLUTION ${requested}`);
201
- return requested;
202
- }
203
- this.log.warn(`Unsupported MATTERBRIDGE_CAMERA_WEBCAM_RESOLUTION "${requested}" (supported: ${WeriftWebRtcSession.SUPPORTED_WEBCAM_RESOLUTIONS.join(', ')}); falling back to ${defaultResolution}`);
204
+ this.log.debug(`No requested video stream resolution available; using default ${defaultResolution} (MATTERBRIDGE_CAMERA_VIDEO_RESOLUTION=auto)`);
204
205
  return defaultResolution;
205
206
  }
206
207
  getConfiguredVideoSource() {
@@ -209,9 +210,10 @@ export class WeriftWebRtcSession {
209
210
  case 'none':
210
211
  case 'test':
211
212
  case 'webcam':
213
+ case 'rtsp':
212
214
  return source;
213
215
  default:
214
- this.log.warn(`Unsupported MATTERBRIDGE_CAMERA_VIDEO_SOURCE "${source}" (supported: test, webcam, none); falling back to none`);
216
+ this.log.warn(`Unsupported MATTERBRIDGE_CAMERA_VIDEO_SOURCE "${source}" (supported: test, webcam, rtsp, none); falling back to none`);
215
217
  return 'none';
216
218
  }
217
219
  }
@@ -225,13 +227,18 @@ export class WeriftWebRtcSession {
225
227
  this.log.debug(`Test pattern params: resolution=640x480, description="${testPatternInput.description}", bitrateKbps=${testPatternInput.bitrateKbps}`);
226
228
  return testPatternInput;
227
229
  }
228
- const device = process.env.MATTERBRIDGE_CAMERA_WEBCAM_DEVICE;
230
+ const device = process.env.MATTERBRIDGE_CAMERA_VIDEO_SOURCE_DEVICE;
229
231
  if (!device) {
230
- this.log.warn('MATTERBRIDGE_CAMERA_VIDEO_SOURCE=webcam requires MATTERBRIDGE_CAMERA_WEBCAM_DEVICE to be set; falling back to the synthetic test video');
232
+ this.log.warn(`MATTERBRIDGE_CAMERA_VIDEO_SOURCE=${videoSource} requires MATTERBRIDGE_CAMERA_VIDEO_SOURCE_DEVICE to be set; falling back to the synthetic test video`);
231
233
  return testPatternInput;
232
234
  }
233
- const resolution = process.env.MATTERBRIDGE_CAMERA_WEBCAM_RESOLUTION ?? this.getConfiguredWebcamResolution(requestedResolution);
234
- const bitrateKbps = this.getConfiguredWebcamBitrate();
235
+ const resolution = this.getConfiguredVideoResolution(requestedResolution);
236
+ const bitrateKbps = this.getConfiguredVideoBitrate();
237
+ if (videoSource === 'rtsp') {
238
+ const description = `RTSP camera (${device}, ${resolution})`;
239
+ this.log.debug(`RTSP capture params: url=${device}, resolution=${resolution}, description="${description}", bitrateKbps=${bitrateKbps}`);
240
+ return { args: ['-rtsp_transport', 'tcp', '-i', device, '-vf', `scale=${resolution.replace('x', ':')}`], description, bitrateKbps };
241
+ }
235
242
  const description = `local webcam (${device}, ${resolution})`;
236
243
  this.log.debug(`Webcam capture params: device=${device}, resolution=${resolution}, description="${description}", bitrateKbps=${bitrateKbps}`);
237
244
  switch (process.platform) {
@@ -3,9 +3,9 @@
3
3
  "type": "DynamicPlatform",
4
4
  "whiteList": [],
5
5
  "blackList": [],
6
- "generator": "none",
7
- "webcamResolution": "640x480",
8
- "webcamBitrate": 1000,
6
+ "videoGenerator": "none",
7
+ "videoResolution": "auto",
8
+ "videoBitrate": 1000,
9
9
  "animationInterval": 60,
10
10
  "debug": false,
11
11
  "unregisterOnShutdown": false
@@ -2,7 +2,7 @@
2
2
  "title": "Matterbridge example camera plugin",
3
3
  "description": "matterbridge-example-camera v. 1.0.0 by https://github.com/Luligu",
4
4
  "type": "object",
5
- "required": ["generator", "webcamResolution"],
5
+ "required": ["videoGenerator", "videoResolution"],
6
6
  "properties": {
7
7
  "name": {
8
8
  "description": "Plugin Name",
@@ -42,28 +42,28 @@
42
42
  "type": "number",
43
43
  "default": 60
44
44
  },
45
- "generator": {
45
+ "videoGenerator": {
46
46
  "title": "Video Generator",
47
- "description": "Select the WebRTC video source: none disables track injection, test generates a synthetic moving test pattern, and webcam captures from the configured local webcam.",
47
+ "description": "Select the WebRTC video generator: none disables track injection, test generates a synthetic moving test pattern, webcam captures from the configured local webcam, and rtsp pulls from the RTSP url configured in Video Source.",
48
48
  "type": "string",
49
- "enum": ["none", "test", "webcam"],
49
+ "enum": ["none", "test", "webcam", "rtsp"],
50
50
  "default": "none"
51
51
  },
52
- "webcam": {
53
- "title": "Webcam Device",
54
- "description": "OS-specific ffmpeg webcam identifier, such as /dev/video0 on Linux, 0 on macOS, or Integrated Camera on Windows.",
52
+ "videoSource": {
53
+ "title": "Video Source",
54
+ "description": "OS-specific ffmpeg webcam identifier, such as /dev/video0 on Linux, 0 on macOS, or Integrated Camera on Windows. When Video Generator is rtsp, this holds the RTSP url instead, e.g. rtsp://user:password@host:554/path.",
55
55
  "type": "string"
56
56
  },
57
- "webcamResolution": {
58
- "title": "Webcam Resolution",
59
- "description": "Resolution used when capturing from the configured webcam.",
57
+ "videoResolution": {
58
+ "title": "Video Resolution",
59
+ "description": "Resolution used when capturing from the configured webcam or RTSP camera. auto uses the resolution requested by the controller (the allocated video stream's maxResolution) instead of a fixed value.",
60
60
  "type": "string",
61
- "enum": ["640x480", "1280x720", "1920x1080"],
62
- "default": "640x480"
61
+ "enum": ["auto", "640x480", "1280x720", "1920x1080"],
62
+ "default": "auto"
63
63
  },
64
- "webcamBitrate": {
65
- "title": "Webcam Bitrate",
66
- "description": "Target encoder bitrate (kbps) used when capturing from the configured webcam, regardless of resolution.",
64
+ "videoBitrate": {
65
+ "title": "Video Bitrate",
66
+ "description": "Target encoder bitrate (kbps) used when capturing from the configured webcam or RTSP camera, regardless of resolution.",
67
67
  "type": "number",
68
68
  "default": 1000
69
69
  },
@@ -1,12 +1,12 @@
1
1
  {
2
2
  "name": "matterbridge-example-camera",
3
- "version": "0.0.7",
3
+ "version": "0.0.8-dev-20260726-2ea4814",
4
4
  "lockfileVersion": 3,
5
5
  "requires": true,
6
6
  "packages": {
7
7
  "": {
8
8
  "name": "matterbridge-example-camera",
9
- "version": "0.0.7",
9
+ "version": "0.0.8-dev-20260726-2ea4814",
10
10
  "license": "Apache-2.0",
11
11
  "dependencies": {
12
12
  "node-ansi-logger": "3.3.0",
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "matterbridge-example-camera",
3
- "version": "0.0.7",
3
+ "version": "0.0.8-dev-20260726-2ea4814",
4
4
  "description": "Matterbridge camera example plugin",
5
5
  "author": "https://github.com/Luligu",
6
6
  "license": "Apache-2.0",