feat: add better support for sdp with multiple media definitions

Author: philhartung

src/app.js

@@ -11,6 +11,7 @@ export const audioInterfaces = ref([]);
 export const networkInterfaces = ref([]);
 export const selectedStream = ref(null);
 export const selectedChannel = ref([]);
+export const streamIndex = ref([]);
 export const visibleStreams = ref(0);
 export const playing = ref("");
 export const persistentData = ref({
@@ -158,7 +159,6 @@ export const getTextareaRowNumber = () => {
 export const viewStream = (stream) => {
 	page.value = "stream";
 	selectedStream.value = stream;
-	console.log(stream.name);
 };
 
 export const isDevMode = () => {
@@ -212,6 +212,7 @@ export const getChannelSelectValues = (stream) => {
 
 	if (!selectedChannel.value[stream.id]) {
 		selectedChannel.value[stream.id] = values[0].value;
+		streamIndex.value[stream.id] = 0;
 	}
 
 	return values;
@@ -225,26 +226,53 @@ export const playStream = (stream) => {
 		playing.value = stream.id;
 
 		let channelMapping = selectedChannel.value[stream.id].split(",");
+		let streamMapping = streamIndex.value[stream.id];
 		let channel0 = parseInt(channelMapping[0]);
 		let channel1 = parseInt(channelMapping[1]);
 
-		sendMessage({
-			type: "play",
-			data: {
+		if (stream.media[streamMapping] && stream.media[streamMapping].rtp[0]) {
+			let samplerate = stream.media[streamMapping].rtp[0].rate;
+			let channels = stream.media[streamMapping].rtp[0].encoding;
+			let ptime = stream.media[streamMapping].ptime;
+			let codec = stream.media[streamMapping].rtp[0].codec;
+			let port = stream.media[streamMapping].port;
+			let mcast = stream.mcast;
+			let filter = false;
+			let filterAddr = "";
+
+			if (streamMapping > 0) {
+				mcast = stream.media[streamMapping].connection.ip.split("/")[0];
+			}
+
+			if (stream.media[streamMapping].sourceFilter) {
+				filter = true;
+				filterAddr = stream.media[streamMapping].sourceFilter.srcList;
+			}
+
+			let data = {
 				id: stream.id,
-				mcast: stream.mcast,
-				port: stream.media[0].port,
-				addr: stream.origin.address,
-				codec: stream.codec,
-				ptime: stream.media[0].ptime,
-				samplerate: stream.samplerate,
-				channels: stream.channels,
+				mcast: mcast,
+				port: port,
+				codec: codec,
+				ptime: ptime,
+				samplerate: samplerate,
+				channels: channels,
 				ch1Map: channel0,
 				ch2Map: channel1,
 				jitterBufferEnabled: persistentData.value.settings.bufferEnabled,
 				jitterBufferSize: persistentData.value.settings.bufferSize,
-			},
-		});
+				filter: filter,
+				filterAddr: filterAddr,
+			};
+
+			console.log(data);
+			sendMessage({
+				type: "play",
+				data: data,
+			});
+		} else {
+			console.error("Error playing stream");
+		}
 	}
 };
 

src/components/pages/StreamsPage.vue

@@ -55,7 +55,25 @@
 			<template v-for="stream in sortedStreams" :key="stream.id">
 				<tr>
 					<td>{{ stream.name }}</td>
-					<td>{{ stream.mcast }}:{{ stream.media[0].port }}</td>
+					<td>
+						<span
+							v-if="stream.media.length > 1 && stream.isSupported"
+							class="copy"
+						>
+							<select
+								class="form-select form-select-sm"
+								v-model="streamIndex[stream.id]"
+								:disabled="stream.id === playing"
+							>
+								<template v-for="(media, index) in stream.media" :key="index">
+									<option :value="index">
+										{{ media.connection.ip.split("/")[0] }}:{{ media.port }}
+									</option>
+								</template>
+							</select>
+						</span>
+						<span v-else class="copy">{{ stream.mcast }}:{{ stream.media[0].port }}</span>
+					</td>
 					<td>
 						<span class="badge bg-primary me-1" v-if="stream.dante">Dante</span>
 						<span class="badge bg-primary me-1" v-if="stream.manual"
@@ -68,7 +86,9 @@
 					<td>
 						{{ stream.media[0].description ? stream.media[0].description : "" }}
 					</td>
-					<td>{{ stream.origin.address }}</td>
+					<td>
+						{{ stream.origin.address }}
+					</td>
 					<td>
 						<span v-if="stream.isSupported" class="copy">
 							{{ stream.codec }} / {{ stream.samplerate }}Hz /
@@ -142,6 +162,7 @@ import {
 	visibleStreams,
 	playing,
 	persistentData,
+	streamIndex,
 } from "../../app.js";
 import { ref, computed } from "vue";
 
@@ -213,6 +234,7 @@ export default {
 			visibleStreams,
 			playing,
 			persistentData,
+			streamIndex,
 		};
 	},
 	methods: {

src/lib/audio.js

@@ -33,13 +33,26 @@ const start = function (args) {
 	const samplesPerPacket = Math.round((args.samplerate / 1000) * args.ptime);
 	const bytesPerSample = args.codec == "L24" ? 3 : 2;
 	const pcmDataSize = samplesPerPacket * bytesPerSample * args.channels;
-	const packetSize = pcmDataSize + 12;
 	const pcmL16out = Buffer.alloc(samplesPerPacket * 4 * bufferSize);
 
 	let seqInternal = -1;
 
 	client.on("message", function (buffer, remote) {
-		if (buffer.length != packetSize || remote.address != args.addr) {
+		const firstByte = buffer.readUInt8(0);
+		const csrcCount = firstByte & 0x0f;
+		let headerLength = 12 + csrcCount * 4;
+		const extensionFlag = (firstByte >> 4) & 0x01;
+
+		if (extensionFlag) {
+			let extIndex = 12 + csrcCount * 4;
+			const extensionLength = buffer.readUInt16BE(extIndex + 2);
+			headerLength += 4 + extensionLength * 4;
+		}
+
+		if (
+			buffer.length != (pcmDataSize + headerLength) ||
+			(args.filter && remote.address != args.filterAddr)
+		) {
 			return;
 		}
 
@@ -49,21 +62,21 @@ const start = function (args) {
 		for (let sample = 0; sample < samplesPerPacket; sample++) {
 			pcmL16out.writeUInt16LE(
 				buffer.readUInt16BE(
-					(sample * args.channels + args.ch1Map) * bytesPerSample + 12
+					(sample * args.channels + args.ch1Map) * bytesPerSample + headerLength
 				),
 				sample * 4 + bufferIndex
 			);
 			pcmL16out.writeUInt16LE(
 				buffer.readUInt16BE(
-					(sample * args.channels + args.ch2Map) * bytesPerSample + 12
+					(sample * args.channels + args.ch2Map) * bytesPerSample + headerLength
 				),
 				sample * 4 + bufferIndex + 2
 			);
 		}
 
 		if (seqInternal != -1) {
 			let bufferIndex = seqInternal * samplesPerPacket * 4;
-			let outBuf = pcmL16out.slice(
+			let outBuf = pcmL16out.subarray(
 				bufferIndex,
 				bufferIndex + samplesPerPacket * 4
 			);

src/lib/sdp.js

@@ -30,17 +30,6 @@ const preParse = function (sdp) {
 		sdp.description = sdp.media[0].description;
 	}
 
-	//put all filter relevant stuff into one string (name, description, multicast, unicast host)
-	sdp.filterBy = (
-		sdp.name +
-		" " +
-		sdp.origin.address +
-		" " +
-		sdp.description +
-		" " +
-		sdp.mcast
-	).toLowerCase();
-
 	if (sdp.isSupported) {
 		sdp.codec = sdp.media[0].rtp[0].codec;
 		sdp.samplerate = sdp.media[0].rtp[0].rate;
@@ -60,37 +49,39 @@ const isSupportedStream = function (sdp) {
 		return sdp;
 	}
 
-	if (sdp.media[0].type != "audio" || sdp.media[0].protocol != "RTP/AVP") {
-		sdp.isSupported = false;
-		sdp.unsupportedReason = "Unsupported media type";
-		return sdp;
-	}
+	for (let i = 0; i < sdp.media.length; i++) {
+		if (sdp.media[i].type != "audio" || sdp.media[i].protocol != "RTP/AVP") {
+			sdp.isSupported = false;
+			sdp.unsupportedReason = "Unsupported media type";
+			return sdp;
+		}
 
-	if (sdp.media[0].rtp.length != 1) {
-		sdp.isSupported = false;
-		sdp.unsupportedReason = "Unsupported rtpmap";
-		return sdp;
-	}
+		if (sdp.media[i].rtp.length != 1) {
+			sdp.isSupported = false;
+			sdp.unsupportedReason = "Unsupported rtpmap";
+			return sdp;
+		}
 
-	if (supportedSampleRates.indexOf(sdp.media[0].rtp[0].rate) === -1) {
-		sdp.isSupported = false;
-		sdp.unsupportedReason = "Unsupported samplerate";
-		return sdp;
-	}
+		if (supportedSampleRates.indexOf(sdp.media[i].rtp[0].rate) === -1) {
+			sdp.isSupported = false;
+			sdp.unsupportedReason = "Unsupported samplerate";
+			return sdp;
+		}
 
-	if (
-		sdp.media[0].rtp[0].codec != "L24" &&
-		sdp.media[0].rtp[0].codec != "L16"
-	) {
-		sdp.isSupported = false;
-		sdp.unsupportedReason = "Unsupported codec";
-		return sdp;
-	}
+		if (
+			sdp.media[i].rtp[0].codec != "L24" &&
+			sdp.media[i].rtp[0].codec != "L16"
+		) {
+			sdp.isSupported = false;
+			sdp.unsupportedReason = "Unsupported codec";
+			return sdp;
+		}
 
-	if (sdp.media[0].rtp[0].encoding < 1 || sdp.media[0].rtp[0].encoding > 64) {
-		sdp.isSupported = false;
-		sdp.unsupportedReason = "Unsupported channel number";
-		return sdp;
+		if (sdp.media[i].rtp[0].encoding < 1 || sdp.media[i].rtp[0].encoding > 64) {
+			sdp.isSupported = false;
+			sdp.unsupportedReason = "Unsupported channel number";
+			return sdp;
+		}
 	}
 
 	sdp.isSupported = true;
@@ -158,7 +149,7 @@ const announceStream = function (rawSDP, addr, header) {
 	let sdpMsg = Buffer.concat([sapHeader, sapContentType, sdpBody]);
 
 	socket.send(sdpMsg, 9875, "239.255.255.255", function (err) {
-		console.error("Error sending SDP Message", err);
+		if (err) console.error("Error sending SDP Message", err);
 	});
 };