mediasoup 3.27.0 → 3.28.0

package/node/lib/rtpStreamFbsUtils.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRtpStream = parseRtpStream;
+function parseRtpStream(data) {
+    const params = parseRtpStreamParameters(data.params());
+    let rtxStream;
+    if (data.rtxStream()) {
+        rtxStream = parseRtxStream(data.rtxStream());
+    }
+    return {
+        params,
+        score: data.score(),
+        rtxStream,
+    };
+}
+function parseRtpStreamParameters(data) {
+    return {
+        encodingIdx: data.encodingIdx(),
+        ssrc: data.ssrc(),
+        payloadType: data.payloadType(),
+        mimeType: data.mimeType(),
+        clockRate: data.clockRate(),
+        rid: data.rid().length > 0 ? data.rid() : undefined,
+        cname: data.cname(),
+        rtxSsrc: data.rtxSsrc() !== null ? data.rtxSsrc() : undefined,
+        rtxPayloadType: data.rtxPayloadType() !== null ? data.rtxPayloadType() : undefined,
+        useNack: data.useNack(),
+        usePli: data.usePli(),
+        useFir: data.useFir(),
+        useInBandFec: data.useInBandFec(),
+        useDtx: data.useDtx(),
+        spatialLayers: data.spatialLayers(),
+        temporalLayers: data.temporalLayers(),
+    };
+}
+function parseRtxStream(data) {
+    const params = parseRtxStreamParameters(data.params());
+    return {
+        params,
+    };
+}
+function parseRtxStreamParameters(data) {
+    return {
+        ssrc: data.ssrc(),
+        payloadType: data.payloadType(),
+        mimeType: data.mimeType(),
+        clockRate: data.clockRate(),
+        rrid: data.rrid().length > 0 ? data.rrid() : undefined,
+        cname: data.cname(),
+    };
+}

package/node/lib/supportedRtpCapabilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"supportedRtpCapabilities.d.ts","sourceRoot":"","sources":["../src/supportedRtpCapabilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAElE,QAAA,MAAM,wBAAwB,EAAE,qBA4U/B,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}
+{"version":3,"file":"supportedRtpCapabilities.d.ts","sourceRoot":"","sources":["../src/supportedRtpCapabilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAElE,QAAA,MAAM,wBAAwB,EAAE,qBAqU/B,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/node/lib/supportedRtpCapabilities.js

@@ -282,52 +282,45 @@ const supportedRtpCapabilities = {
             preferredEncrypt: false,
             direction: 'sendrecv',
         },
-        {
-            kind: 'video',
-            uri: 'urn:ietf:params:rtp-hdrext:toffset',
-            preferredId: 9,
-            preferredEncrypt: false,
-            direction: 'sendrecv',
-        },
         {
             kind: 'audio',
             uri: 'http://www.webrtc.org/experiments/rtp-hdrext/abs-capture-time',
-            preferredId: 10,
+            preferredId: 9,
             preferredEncrypt: false,
             direction: 'sendrecv',
         },
         {
             kind: 'video',
             uri: 'http://www.webrtc.org/experiments/rtp-hdrext/abs-capture-time',
-            preferredId: 10,
+            preferredId: 9,
             preferredEncrypt: false,
             direction: 'sendrecv',
         },
         {
             kind: 'audio',
             uri: 'http://www.webrtc.org/experiments/rtp-hdrext/playout-delay',
-            preferredId: 11,
+            preferredId: 10,
             preferredEncrypt: false,
             direction: 'sendrecv',
         },
         {
             kind: 'video',
             uri: 'http://www.webrtc.org/experiments/rtp-hdrext/playout-delay',
-            preferredId: 11,
+            preferredId: 10,
             preferredEncrypt: false,
             direction: 'sendrecv',
         },
         {
             kind: 'audio',
             uri: 'urn:mediasoup:params:rtp-hdrext:packet-id',
-            preferredId: 12,
+            preferredId: 11,
             preferredEncrypt: false,
             direction: 'sendrecv',
         },
         {
             kind: 'video',
             uri: 'urn:mediasoup:params:rtp-hdrext:packet-id',
-            preferredId: 12,
+            preferredId: 11,
             preferredEncrypt: false,
             direction: 'sendrecv',
         },

package/node/lib/test/test-Consumer.js

@@ -233,12 +233,6 @@ const ctx = {
                 preferredId: 8,
                 preferredEncrypt: false,
             },
-            {
-                kind: 'video',
-                uri: 'urn:ietf:params:rtp-hdrext:toffset',
-                preferredId: 9,
-                preferredEncrypt: false,
-            },
         ],
     }),
     vpxMediaCodecs: utils.deepFreeze([
@@ -745,7 +739,7 @@ test('consumer.dump() succeeds', async () => {
         { type: 'goog-remb' },
     ]);
     expect(Array.isArray(dump2.rtpParameters.headerExtensions)).toBe(true);
-    expect(dump2.rtpParameters.headerExtensions.length).toBe(4);
+    expect(dump2.rtpParameters.headerExtensions.length).toBe(3);
     expect(dump2.rtpParameters.headerExtensions).toEqual([
         {
             uri: 'urn:ietf:params:rtp-hdrext:sdes:mid',
@@ -765,12 +759,6 @@ test('consumer.dump() succeeds', async () => {
             parameters: {},
             encrypt: false,
         },
-        {
-            uri: 'urn:ietf:params:rtp-hdrext:toffset',
-            id: 9,
-            parameters: {},
-            encrypt: false,
-        },
     ]);
     expect(Array.isArray(dump2.rtpParameters.encodings)).toBe(true);
     expect(dump2.rtpParameters.encodings.length).toBe(1);

package/node/lib/test/test-DataConsumer.js

@@ -114,6 +114,15 @@ test('transport.consumeData() with unknown dataProducerId fails', async () => {
         dataProducerId: '12345678',
     })).rejects.toThrow(errors_1.NotFoundError);
 }, 2000);
+test('transport.consumeData() with maxRetransmits replaces DataProducer maxPacketLifeTime', async () => {
+    const dataConsumer = await ctx.webRtcTransport2.consumeData({
+        dataProducerId: ctx.sctpDataProducer.id,
+        maxRetransmits: 2,
+    });
+    expect(dataConsumer.sctpStreamParameters.ordered).toBe(false);
+    expect(dataConsumer.sctpStreamParameters.maxPacketLifeTime).toBeUndefined();
+    expect(dataConsumer.sctpStreamParameters.maxRetransmits).toBe(2);
+}, 2000);
 test('dataConsumer.dump() succeeds', async () => {
     const dataConsumer = await ctx.webRtcTransport2.consumeData({
         dataProducerId: ctx.sctpDataProducer.id,

package/node/lib/test/test-DataProducer.js

@@ -154,6 +154,44 @@ test('transport.produceData() with ordered and maxPacketLifeTime rejects with Ty
         },
     })).rejects.toThrow(TypeError);
 }, 2000);
+test('transport.produceData() with maxRetransmits 0 or maxPacketLifeTime 0 creates an unordered DataProducer', async () => {
+    const dataProducer1 = await ctx.webRtcTransport1.produceData({
+        sctpStreamParameters: {
+            streamId: 888,
+            maxRetransmits: 0,
+        },
+    });
+    expect(dataProducer1.sctpStreamParameters?.ordered).toBe(false);
+    expect(dataProducer1.sctpStreamParameters?.maxPacketLifeTime).toBeUndefined();
+    expect(dataProducer1.sctpStreamParameters?.maxRetransmits).toBe(0);
+    const dataProducer2 = await ctx.webRtcTransport1.produceData({
+        sctpStreamParameters: {
+            streamId: 999,
+            maxPacketLifeTime: 0,
+        },
+    });
+    expect(dataProducer2.sctpStreamParameters?.ordered).toBe(false);
+    expect(dataProducer2.sctpStreamParameters?.maxPacketLifeTime).toBe(0);
+    expect(dataProducer2.sctpStreamParameters?.maxRetransmits).toBeUndefined();
+}, 2000);
+test('transport.produceData() with ordered and maxRetransmits 0 rejects with TypeError', async () => {
+    await expect(ctx.webRtcTransport1.produceData({
+        sctpStreamParameters: {
+            streamId: 999,
+            ordered: true,
+            maxRetransmits: 0,
+        },
+    })).rejects.toThrow(TypeError);
+}, 2000);
+test('transport.produceData() with maxPacketLifeTime 0 and maxRetransmits rejects with TypeError', async () => {
+    await expect(ctx.webRtcTransport1.produceData({
+        sctpStreamParameters: {
+            streamId: 999,
+            maxPacketLifeTime: 0,
+            maxRetransmits: 5,
+        },
+    })).rejects.toThrow(TypeError);
+}, 2000);
 test('dataProducer.dump() succeeds', async () => {
     const dataProducer1 = await ctx.webRtcTransport1.produceData(ctx.dataProducerOptions1);
     const dump1 = await dataProducer1.dump();

package/node/lib/test/test-PipeTransport.js

@@ -262,13 +262,13 @@ test('router.pipeToRouter() succeeds with audio', async () => {
         },
         {
             uri: 'http://www.webrtc.org/experiments/rtp-hdrext/playout-delay',
-            id: 11,
+            id: 10,
             encrypt: false,
             parameters: {},
         },
         {
             uri: 'urn:mediasoup:params:rtp-hdrext:packet-id',
-            id: 12,
+            id: 11,
             encrypt: false,
             parameters: {},
         },
@@ -315,13 +315,13 @@ test('router.pipeToRouter() succeeds with audio', async () => {
         },
         {
             uri: 'http://www.webrtc.org/experiments/rtp-hdrext/playout-delay',
-            id: 11,
+            id: 10,
             encrypt: false,
             parameters: {},
         },
         {
             uri: 'urn:mediasoup:params:rtp-hdrext:packet-id',
-            id: 12,
+            id: 11,
             encrypt: false,
             parameters: {},
         },
@@ -370,21 +370,15 @@ test('router.pipeToRouter() succeeds with video', async () => {
             encrypt: false,
             parameters: {},
         },
-        {
-            uri: 'urn:ietf:params:rtp-hdrext:toffset',
-            id: 9,
-            encrypt: false,
-            parameters: {},
-        },
         {
             uri: 'http://www.webrtc.org/experiments/rtp-hdrext/playout-delay',
-            id: 11,
+            id: 10,
             encrypt: false,
             parameters: {},
         },
         {
             uri: 'urn:mediasoup:params:rtp-hdrext:packet-id',
-            id: 12,
+            id: 11,
             encrypt: false,
             parameters: {},
         },
@@ -428,21 +422,15 @@ test('router.pipeToRouter() succeeds with video', async () => {
             encrypt: false,
             parameters: {},
         },
-        {
-            uri: 'urn:ietf:params:rtp-hdrext:toffset',
-            id: 9,
-            encrypt: false,
-            parameters: {},
-        },
         {
             uri: 'http://www.webrtc.org/experiments/rtp-hdrext/playout-delay',
-            id: 11,
+            id: 10,
             encrypt: false,
             parameters: {},
         },
         {
             uri: 'urn:mediasoup:params:rtp-hdrext:packet-id',
-            id: 12,
+            id: 11,
             encrypt: false,
             parameters: {},
         },
@@ -479,7 +467,7 @@ test('router.pipeToRouter() gives abs-capture-time to the pipe Consumer if the P
     }));
     expect(pipeConsumer.rtpParameters.headerExtensions).toContainEqual({
         uri: 'http://www.webrtc.org/experiments/rtp-hdrext/abs-capture-time',
-        id: 10,
+        id: 9,
         encrypt: false,
         parameters: {},
     });
@@ -502,6 +490,22 @@ test('router.pipeToRouter() with unknown router, producerId or dataProducerId fa
         dataProducerId: '12345678',
     })).rejects.toThrow(errors_1.NotFoundError);
 }, 2000);
+test('router.pipeToRouter() can be retried after failing to create the PipeTransport pair', async () => {
+    // Fails because the IP is not assigned to any local network interface.
+    await expect(ctx.router1.pipeToRouter({
+        router: ctx.router2,
+        producerId: ctx.videoProducer.id,
+        listenInfo: { protocol: 'udp', ip: '203.0.113.1' },
+    })).rejects.toThrow();
+    const { pipeConsumer, pipeProducer } = await ctx.router1.pipeToRouter({
+        router: ctx.router2,
+        producerId: ctx.videoProducer.id,
+        listenInfo: { protocol: 'udp', ip: '127.0.0.1' },
+    });
+    expect(pipeConsumer).toBeDefined();
+    expect(pipeProducer).toBeDefined();
+    expect(pipeProducer.id).toBe(ctx.videoProducer.id);
+}, 5000);
 test('router.createPipeTransport() with wrong arguments rejects with TypeError', async () => {
     // @ts-expect-error --- Testing purposes.
     await expect(ctx.router1.createPipeTransport({})).rejects.toThrow(TypeError);
@@ -576,21 +580,15 @@ test('router.createPipeTransport() with enableRtx succeeds', async () => {
             encrypt: false,
             parameters: {},
         },
-        {
-            uri: 'urn:ietf:params:rtp-hdrext:toffset',
-            id: 9,
-            encrypt: false,
-            parameters: {},
-        },
         {
             uri: 'http://www.webrtc.org/experiments/rtp-hdrext/playout-delay',
-            id: 11,
+            id: 10,
             encrypt: false,
             parameters: {},
         },
         {
             uri: 'urn:mediasoup:params:rtp-hdrext:packet-id',
-            id: 12,
+            id: 11,
             encrypt: false,
             parameters: {},
         },

package/node/lib/test/test-Producer.js

@@ -536,6 +536,8 @@ test('producer.dump() succeeds', async () => {
     expect(dump1.rtpParameters.encodings[0]).toEqual(expect.objectContaining({
         codecPayloadType: 0,
     }));
+    // No RTP has been received yet, so there are no RTP streams.
+    expect(dump1.rtpStreams).toEqual([]);
     expect(dump1.type).toBe('simple');
     const videoProducer = await ctx.webRtcTransport2.produce(ctx.videoProducerOptions);
     const dump2 = await videoProducer.dump();
@@ -592,8 +594,103 @@ test('producer.dump() succeeds', async () => {
         { codecPayloadType: 112, ssrc: 22222226, rtx: { ssrc: 22222227 } },
         { codecPayloadType: 112, ssrc: 22222228, rtx: { ssrc: 22222229 } },
     ]);
+    // These encodings have no rid, so it must be undefined in rtpMapping.
+    expect(dump2.rtpMapping).toMatchObject({
+        encodings: [
+            { rid: undefined, ssrc: 22222222 },
+            { rid: undefined, ssrc: 22222224 },
+            { rid: undefined, ssrc: 22222226 },
+            { rid: undefined, ssrc: 22222228 },
+        ],
+    });
+    expect(dump2.rtpStreams).toEqual([]);
     expect(dump2.type).toBe('simulcast');
 }, 2000);
+test('producer.dump() exposes rid in rtpMapping.encodings', async () => {
+    const videoProducer = await ctx.webRtcTransport1.produce({
+        kind: 'video',
+        rtpParameters: {
+            mid: 'VIDEO',
+            codecs: [
+                {
+                    mimeType: 'video/VP8',
+                    payloadType: 96,
+                    clockRate: 90000,
+                },
+            ],
+            headerExtensions: [
+                {
+                    uri: 'urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id',
+                    id: 11,
+                },
+            ],
+            encodings: [{ rid: 'r0' }, { rid: 'r1' }, { rid: 'r2' }],
+            rtcp: { cname: 'video-rid' },
+        },
+    });
+    const dump = await videoProducer.dump();
+    expect(dump.type).toBe('simulcast');
+    expect(dump.rtpMapping).toMatchObject({
+        encodings: [
+            { rid: 'r0', ssrc: undefined },
+            { rid: 'r1', ssrc: undefined },
+            { rid: 'r2', ssrc: undefined },
+        ],
+    });
+}, 2000);
+test('producer.dump() exposes rtpStreams once RTP is received', async () => {
+    // RTP packet without extensions or payload.
+    // payloadType: 1, seqNumber: 8, timestamp: 4, ssrc: 5.
+    // prettier-ignore
+    const rtpPacket = Buffer.from([
+        0x80, 0x01, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x04,
+        0x00, 0x00, 0x00, 0x05,
+    ]);
+    // A DirectTransport is needed since it's the only one that allows injecting
+    // RTP packets via producer.send().
+    const directTransport = await ctx.router.createDirectTransport();
+    const audioProducer = await directTransport.produce({
+        kind: 'audio',
+        rtpParameters: {
+            mid: 'AUDIO',
+            codecs: [
+                {
+                    mimeType: 'audio/opus',
+                    payloadType: 1,
+                    clockRate: 48000,
+                    channels: 2,
+                },
+            ],
+            encodings: [{ ssrc: 5 }],
+            rtcp: { cname: 'audio-rtp' },
+        },
+    });
+    // No RTP has been received yet, so there are no RTP streams.
+    await expect(audioProducer.dump()).resolves.toMatchObject({
+        rtpStreams: [],
+    });
+    // The worker emits a first 'score' event as soon as it creates the
+    // RtpStreamRecv, which happens upon reception of the first RTP packet.
+    const onScore = (0, enhancedEvents_1.enhancedOnce)(audioProducer, 'score');
+    audioProducer.send(rtpPacket);
+    await onScore;
+    const dump = await audioProducer.dump();
+    expect(dump.rtpStreams.length).toBe(1);
+    expect(typeof dump.rtpStreams[0].score).toBe('number');
+    expect(dump.rtpStreams[0].rtxStream).toBeUndefined();
+    expect(dump.rtpStreams[0].params).toMatchObject({
+        encodingIdx: 0,
+        ssrc: 5,
+        payloadType: 1,
+        mimeType: 'audio/opus',
+        clockRate: 48000,
+        cname: 'audio-rtp',
+        rid: undefined,
+        rtxSsrc: undefined,
+        rtxPayloadType: undefined,
+    });
+}, 2000);
 test('producer.getStats() succeeds', async () => {
     const audioProducer = await ctx.webRtcTransport1.produce(ctx.audioProducerOptions);
     const videoProducer = await ctx.webRtcTransport2.produce(ctx.videoProducerOptions);

package/node/lib/test/test-ortc.js

@@ -174,7 +174,7 @@ test('generateRouterRtpCapabilities() with too many codecs throws', () => {
             channels: 2,
         });
     }
-    expect(() => ortc.generateRouterRtpCapabilities(mediaCodecs)).toThrow('cannot allocate');
+    expect(() => ortc.generateRouterRtpCapabilities(mediaCodecs)).toThrow();
 });
 test('getProducerRtpParametersMapping(), getConsumableRtpParameters(), getConsumerRtpParameters() and getPipeConsumerRtpParameters() succeed', () => {
     const mediaCodecs = [
@@ -377,13 +377,6 @@ test('getProducerRtpParametersMapping(), getConsumableRtpParameters(), getConsum
                 preferredEncrypt: false,
                 direction: 'sendrecv',
             },
-            {
-                kind: 'video',
-                uri: 'urn:ietf:params:rtp-hdrext:toffset',
-                preferredId: 9,
-                preferredEncrypt: false,
-                direction: 'sendrecv',
-            },
         ],
     };
     const consumerRtpParameters = ortc.getConsumerRtpParameters({
@@ -436,12 +429,6 @@ test('getProducerRtpParametersMapping(), getConsumableRtpParameters(), getConsum
             encrypt: false,
             parameters: {},
         },
-        {
-            uri: 'urn:ietf:params:rtp-hdrext:toffset',
-            id: 9,
-            encrypt: false,
-            parameters: {},
-        },
     ]);
     expect(consumerRtpParameters.rtcp).toEqual({
         cname: rtpParameters.rtcp?.cname,
@@ -523,3 +510,36 @@ test('getProducerRtpParametersMapping() with incompatible params throws Unsuppor
     };
     expect(() => ortc.getProducerRtpParametersMapping(rtpParameters, routerRtpCapabilities)).toThrow(errors_1.UnsupportedError);
 });
+test('getProducerRtpParametersMapping() with RTX apt pointing to a non media codec throws', () => {
+    const mediaCodecs = [
+        {
+            kind: 'video',
+            mimeType: 'video/VP8',
+            clockRate: 90000,
+        },
+    ];
+    const routerRtpCapabilities = ortc.generateRouterRtpCapabilities(mediaCodecs);
+    // The apt parameter of the RTX codec is its own payload type, which is not a
+    // media codec.
+    const rtpParameters = {
+        codecs: [
+            {
+                mimeType: 'video/VP8',
+                payloadType: 111,
+                clockRate: 90000,
+            },
+            {
+                mimeType: 'video/rtx',
+                payloadType: 112,
+                clockRate: 90000,
+                parameters: { apt: 112 },
+            },
+        ],
+        headerExtensions: [],
+        encodings: [{ ssrc: 11111111 }],
+        rtcp: {
+            cname: 'qwerty1234',
+        },
+    };
+    expect(() => ortc.getProducerRtpParametersMapping(rtpParameters, routerRtpCapabilities)).toThrow(TypeError);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mediasoup",
-	"version": "3.27.0",
+	"version": "3.28.0",
 	"description": "Cutting Edge WebRTC Video Conferencing",
 	"contributors": [
 		"Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -121,22 +121,22 @@
 		"@types/debug": "^4.1.13",
 		"@types/ini": "^4.1.1",
 		"@types/jest": "^30.0.0",
-		"@types/node": "^26.5.1",
-		"eslint": "^10.10.0",
+		"@types/node": "^26.6.3",
+		"eslint": "^10.11.0",
 		"eslint-config-prettier": "^10.1.8",
 		"eslint-plugin-jest": "^29.16.6",
 		"eslint-plugin-prettier": "^5.5.6",
-		"globals": "^17.12.0",
+		"globals": "^17.13.0",
 		"ini": "^7.0.0",
-		"jest": "^30.5.1",
-		"knip": "^6.35.1",
-		"marked": "^18.0.13",
+		"jest": "^30.5.2",
+		"knip": "^6.39.0",
+		"marked": "^18.0.14",
 		"open-cli": "^9.0.0",
 		"pick-port": "^2.2.1",
-		"prettier": "^3.9.6",
-		"ts-jest": "^29.4.12",
+		"prettier": "^3.9.9",
+		"ts-jest": "^29.4.14",
 		"typescript": "^6.0.3",
-		"typescript-eslint": "^8.70.0",
+		"typescript-eslint": "^8.71.0",
 		"werift-sctp": "^0.0.11"
 	}
 }

package/worker/fbs/FBS/meson.build

@@ -0,0 +1,25 @@
+# The generator writes a single header per schema, with the same base name and
+# a .h extension since the empty --filename-suffix removes the default one.
+flatbuffers_headers = []
+
+foreach schema : flatbuffers_schemas
+  flatbuffers_headers += schema.replace('.fbs', '.h')
+endforeach
+
+flatc = find_program('flatc')
+
+flatbuffers_generator = custom_target('flatbuffers-generator',
+  output: flatbuffers_headers,
+  input: flatbuffers_schema_files,
+  command : [
+    flatc,
+    '--cpp',
+    '--cpp-field-case-style', 'lower',
+    '--reflect-names',
+    '--scoped-enums',
+    '--filename-suffix', '',
+    '-o', '@OUTDIR@',
+    '@INPUT@'
+  ],
+  build_by_default: true,
+)

package/worker/fbs/meson.build

@@ -29,26 +29,23 @@ flatbuffers_schemas = [
   'worker.fbs',
 ]
 
-# Directory from which worker code will include the header files.
-flatbuffers_cpp_out_dir = 'FBS'
+# The schemas are turned into file objects here because the target that
+# consumes them is declared in the FBS subdirectory, where plain relative names
+# would no longer resolve.
+flatbuffers_schema_files = files(flatbuffers_schemas)
 
-flatc = find_program('flatc')
-flatbuffers_generator = custom_target('flatbuffers-generator',
-  output: flatbuffers_cpp_out_dir,
-  input: flatbuffers_schemas,
-  command : [
-    flatc,
-    '--cpp',
-    '--cpp-field-case-style', 'lower',
-    '--reflect-names',
-    '--scoped-enums',
-    '--filename-suffix', '',
-    '-o', '@OUTPUT@',
-    '@INPUT@'
-  ],
-  build_by_default: true,
-)
+# FBS is the directory from which worker code includes the generated header
+# files. The generator target is declared from within that very subdirectory
+# because Meson does not allow path segments in the outputs of a custom target,
+# and the outputs must be the individual headers rather than the directory that
+# holds them. Declaring the directory as the output makes the target dirty
+# forever: running the generator rewrites the headers in place, which never
+# updates the modification time of the directory containing them, so the target
+# never becomes up to date and every build regenerates the headers and
+# recompiles every source file that includes them.
+subdir('FBS')
 
 flatbuffers_generator_dep = declare_dependency(
   include_directories: '.',
+  sources: flatbuffers_generator,
 )

package/worker/fbs/rtpParameters.fbs

@@ -70,7 +70,6 @@ enum RtpHeaderExtensionUri: uint8 {
     SsrcAudioLevel,
     DependencyDescriptor,
     VideoOrientation,
-    TimeOffset,
     AbsCaptureTime,
     PlayoutDelay,
     MediasoupPacketId,

package/worker/fuzzer/src/FuzzerUtils.cpp

@@ -92,10 +92,12 @@ void FuzzerUtils::Fuzz(const uint8_t* data, size_t len)
 
 	/* Time class. */
 
-	auto ntp = Utils::Time::TimeUs2Ntp(static_cast<int64_t>(len));
+	auto ntp = Utils::Time::TimeUsToNtp(static_cast<int64_t>(len));
 
-	Utils::Time::Ntp2TimeUs(ntp);
+	Utils::Time::NtpToTimeUs(ntp);
+	Utils::Time::CompactNtpIntervalToTimeUs(static_cast<uint32_t>(len));
+	Utils::Time::CompactNtpRttToTimeUs(static_cast<uint32_t>(len));
 	Utils::Time::TimeUsToAbsSendTime(static_cast<int64_t>(len));
 	Utils::Time::Q32x32ToTimeUs(static_cast<int64_t>(len));
-	Utils::Time::TimeUs2Q32x32(static_cast<int64_t>(len));
+	Utils::Time::TimeUsToQ32x32(static_cast<int64_t>(len));
 }