fix

.gitignore

@@ -1,2 +1 @@
 /node_modules
-/dist

app.js

@@ -5,12 +5,7 @@ const app = express();
 const Server = require('socket.io');
 const path = require('node:path');
 const fs = require('node:fs');
-let https;
+const https = require('https');
-try {
-  https = require('node:https');
-} catch (err) {
-  console.log('https support is disabled!');
-}
 const mediasoup = require('mediasoup');
 
 let worker
@@ -42,8 +37,8 @@ app.use('/sfu', express.static(path.join(__dirname, 'public')))
 
 // SSL cert for HTTPS access
 const options = {
-  key: fs.readFileSync(process.env.SERVER_KEY, 'utf-8'),
+  key: fs.readFileSync('./server/ssl/key.pem', 'utf-8'),
-  cert: fs.readFileSync(process.env.SERVER_CERT, 'utf-8'),
+  cert: fs.readFileSync('./server/ssl/cert.pem', 'utf-8'),
 }
 
 const httpsServer = https.createServer(options, app);
@@ -63,12 +58,13 @@ httpsServer.listen(process.env.PORT, () => {
 });
 
 const peers = io.of('/');
-
+console.log('process.env.RTC_MIN_PORT', process.env.RTC_MIN_PORT);
+console.log('process.env.RTC_MAX_PORT', process.env.RTC_MAX_PORT, process.env.RTC_MAX_PORT.length);
 const createWorker = async () => {
   try {
     worker = await mediasoup.createWorker({
-      rtcMinPort: parseInt(process.env.RTC_MIN_PORT),
+      rtcMinPort: process.env.RTC_MIN_PORT,
-      rtcMaxPort: parseInt(process.env.RTC_MAX_PORT),
+      rtcMaxPort: process.env.RTC_MAX_PORT,
     })
     console.log(`[createWorker] worker pid ${worker.pid}`);
   
@@ -92,79 +88,26 @@ worker = createWorker();
 // https://github.com/versatica/mediasoup/blob/v3/src/supportedRtpCapabilities.ts
 const mediaCodecs = [
   {
-    kind      : 'audio',
+    kind: 'audio',
-    mimeType  : 'audio/opus',
+    mimeType: 'audio/opus',
-    clockRate : 48000,
+    clockRate: 48000,
-    channels  : 2
+    channels: 2,
   },
   {
-    kind       : 'video',
+    kind: 'video',
-    mimeType   : 'video/VP8',
+    mimeType: 'video/VP8',
-    clockRate  : 90000,
+    clockRate: 90000,
-    parameters :
+    parameters: {
-    {
+      'x-google-start-bitrate': 1000,
-      'x-google-start-bitrate' : 1000
     },
-    channels  : 2
   },
-  {
-    kind       : 'video',
-    mimeType   : 'video/VP9',
-    clockRate  : 90000,
-    parameters :
-    {
-      'profile-id'             : 2,
-      'x-google-start-bitrate' : 1000
-    }
-  },
-  {
-    kind       : 'video',
-    mimeType   : 'video/h264',
-    clockRate  : 90000,
-    parameters :
-    {
-      'packetization-mode'      : 1,
-      'profile-level-id'        : '4d0032',
-      'level-asymmetry-allowed' : 1,
-      'x-google-start-bitrate'  : 1000
-    }
-  },
-  {
-    kind       : 'video',
-    mimeType   : 'video/h264',
-    clockRate  : 90000,
-    parameters :
-    {
-      'packetization-mode'      : 1,
-      'profile-level-id'        : '42e01f',
-      'level-asymmetry-allowed' : 1,
-      'x-google-start-bitrate'  : 1000
-    }
-  }
-//   {
-//     kind: 'audio',
-//     mimeType: 'audio/opus',
-//     clockRate: 48000,
-//     channels: 2,
-//   },
-//   {
-//     kind: 'video',
-//     mimeType: 'video/VP8',
-//     clockRate: 90000,
-//     parameters: {
-//       'x-google-start-bitrate': 1000,
-//     },
-//   },
 ];
 
 const closeCall = (callId) => {
   try {
     if (callId && videoCalls[callId]) {
-      videoCalls[callId].producerVideo?.close();
+      videoCalls[callId].producer?.close();
-      videoCalls[callId].producerAudio?.close();
+      videoCalls[callId].consumer?.close();
-      videoCalls[callId].consumerVideo?.close();
-      videoCalls[callId].consumerAudio?.close();
-
       videoCalls[callId]?.consumerTransport?.close();
       videoCalls[callId]?.producerTransport?.close();
       videoCalls[callId]?.router?.close();
@@ -177,6 +120,16 @@ const closeCall = (callId) => {
   }
 }
 
+const getRtpCapabilities = (callId, callback) => {
+  try {
+    console.log('[getRtpCapabilities] callId', callId);
+    const rtpCapabilities = videoCalls[callId].router.rtpCapabilities;
+    callback({ rtpCapabilities });
+  } catch (error) {
+    console.log(`ERROR | getRtpCapabilities | callId ${callId} | ${error.message}`);
+  }
+}
+
 /*
   - Handlers for WS events
   - These are created only when we have a connection with a peer
@@ -203,9 +156,7 @@ peers.on('connection', async socket => {
     - If the room already exists, it will not create it, but will only return rtpCapabilities
   */
   socket.on('createRoom', async ({ callId }, callback) => {
-    let callbackResponse = null;
     try {
-      // We can continue with the room creation process only if we have a callId
       if (callId) {
         console.log(`[createRoom] socket.id ${socket.id} callId ${callId}`);
         if (!videoCalls[callId]) {
@@ -214,19 +165,12 @@ peers.on('connection', async socket => {
           console.log(`[createRoom] Router ID: ${videoCalls[callId].router.id}`);
         }
         socketDetails[socket.id] = callId;
-
+        getRtpCapabilities(callId, callback);
-        // rtpCapabilities is set for callback
-        console.log('[getRtpCapabilities] callId', callId);
-        callbackResponse = { 
-          rtpCapabilities :videoCalls[callId].router.rtpCapabilities
-        };
       } else {
         console.log(`[createRoom] missing callId ${callId}`);
       }
     } catch (error) {
       console.log(`ERROR | createRoom | callId ${callId} | ${error.message}`);
-    } finally {
-      callback(callbackResponse);
     }
   });
 
@@ -247,19 +191,16 @@ peers.on('connection', async socket => {
           videoCalls[callId].producerTransport = await createWebRtcTransportLayer(callId, callback);
         } else {
           console.log(`producerTransport has already been defined | callId ${callId}`);
-          callback(null);
         }
       } else if (!sender) {
         if (!videoCalls[callId].consumerTransport) {
           videoCalls[callId].consumerTransport = await createWebRtcTransportLayer(callId, callback);
         } else {
           console.log(`consumerTransport has already been defined | callId ${callId}`);
-          callback(null);
         }
       }
     } catch (error) {
       console.log(`ERROR | createWebRtcTransport | callId ${socketDetails[socket.id]} | sender ${sender} | ${error.message}`);
-      callback(error);
     }
   });
 
@@ -289,48 +230,23 @@ peers.on('connection', async socket => {
       const callId = socketDetails[socket.id];
       if (typeof rtpParameters === 'string') rtpParameters = JSON.parse(rtpParameters);
 
-       console.log(`[transport-produce] kind: ${kind} | socket.id: ${socket.id} | callId: ${callId}`);
+      console.log('[transport-produce] | socket.id', socket.id, '| callId', callId);
-       console.log('kind', kind);
+      videoCalls[callId].producer = await videoCalls[callId].producerTransport.produce({
-       console.log('rtpParameters', rtpParameters);
-
-      if (kind === 'video') {
-        videoCalls[callId].producerVideo = await videoCalls[callId].producerTransport.produce({
         kind,
         rtpParameters,
       });
+      console.log(`[transport-produce] Producer ID: ${videoCalls[callId].producer.id} | kind: ${videoCalls[callId].producer.kind}`);
   
-
+      videoCalls[callId].producer.on('transportclose', () => {
-        console.log(`[transport-produce] Producer ID: ${videoCalls[callId].producerVideo.id} | kind: ${videoCalls[callId].producerVideo.kind}`);
-    
-        videoCalls[callId].producerVideo.on('transportclose', () => {
         const callId = socketDetails[socket.id];
         console.log('transport for this producer closed', callId)
         closeCall(callId);
       });
 
       // Send back to the client the Producer's id
-        callback && callback({
+      // callback({
-          id: videoCalls[callId].producerVideo.id
+      //   id: videoCalls[callId].producer.id
-        });
+      // });
-      } else if (kind === 'audio') {
-        videoCalls[callId].producerAudio = await videoCalls[callId].producerTransport.produce({
-          kind,
-          rtpParameters,
-        });
-
-        console.log(`[transport-produce] Producer ID: ${videoCalls[callId].producerAudio.id} | kind: ${videoCalls[callId].producerAudio.kind}`);
-    
-        videoCalls[callId].producerAudio.on('transportclose', () => {
-          const callId = socketDetails[socket.id];
-          console.log('transport for this producer closed', callId)
-          closeCall(callId);
-        });
-
-        // Send back to the client the Producer's id
-        callback && callback({
-          id: videoCalls[callId].producerAudio.id
-        });
-      }
     } catch (error) {
       console.log(`ERROR | transport-produce | callId ${socketDetails[socket.id]} | ${error.message}`);
     }
@@ -359,37 +275,48 @@ peers.on('connection', async socket => {
   */
   socket.on('consume', async ({ rtpCapabilities }, callback) => {
     try {
-      console.log(`[consume] rtpCapabilities: ${JSON.stringify(rtpCapabilities)}`);
-
       const callId = socketDetails[socket.id];
       console.log('[consume] callId', callId);
 
-      const canConsumeVideo = !!videoCalls[callId].producerVideo && !!videoCalls[callId].router.canConsume({
+      // Check if the router can consume the specified producer
-        producerId: videoCalls[callId].producerVideo.id,
+      if (videoCalls[callId].router.canConsume({
+        producerId: videoCalls[callId].producer.id,
         rtpCapabilities
-      })
+      })) {
+        console.log('[consume] Can consume', callId);
+        // Transport can now consume and return a consumer
+        videoCalls[callId].consumer = await videoCalls[callId].consumerTransport.consume({
+          producerId: videoCalls[callId].producer.id,
+          rtpCapabilities,
+          paused: true,
+        });
 
-      const canConsumeAudio = !!videoCalls[callId].producerAudio && !!videoCalls[callId].router.canConsume({
+        // https://mediasoup.org/documentation/v3/mediasoup/api/#consumer-on-transportclose
-        producerId: videoCalls[callId].producerAudio.id,
+        videoCalls[callId].consumer.on('transportclose', () => {
-        rtpCapabilities
+          const callId = socketDetails[socket.id];
-      })
+          console.log('transport close from consumer', callId);
+          closeCall(callId);
+        });
 
-      console.log('[consume] canConsumeVideo', canConsumeVideo);
+        // https://mediasoup.org/documentation/v3/mediasoup/api/#consumer-on-producerclose
-      console.log('[consume] canConsumeAudio', canConsumeAudio);
+        videoCalls[callId].consumer.on('producerclose', () => {
+          const callId = socketDetails[socket.id];
+          console.log('producer of consumer closed', callId);
+          closeCall(callId);
+        });
 
-      if (canConsumeVideo && !canConsumeAudio) {
+        // From the consumer extract the following params to send back to the Client
-        console.log('1');
+        const params = {
-        const videoParams = await consumeVideo(callId, rtpCapabilities)
+          id: videoCalls[callId].consumer.id,
-        console.log('videoParams', videoParams);
+          producerId: videoCalls[callId].producer.id,
-        callback({ videoParams, audioParams: null });
+          kind: videoCalls[callId].consumer.kind,
-      } else if (canConsumeVideo && canConsumeAudio) {
+          rtpParameters: videoCalls[callId].consumer.rtpParameters,
-        console.log('2');
+        };
-        const videoParams = await consumeVideo(callId, rtpCapabilities)
+
-        const audioParams = await consumeAudio(callId, rtpCapabilities)
+        // Send the parameters to the client
-        callback({ videoParams, audioParams });
+        callback({ params });
       } else {
-        console.log(`[consume] Can't consume | callId ${callId}`);
+        console.log(`[canConsume] Can't consume | callId ${callId}`);
-        callback(null);
       }
     } catch (error) {
       console.log(`ERROR | consume | callId ${socketDetails[socket.id]} | ${error.message}`)
@@ -405,71 +332,13 @@ peers.on('connection', async socket => {
     try {
       const callId = socketDetails[socket.id];
       console.log(`[consumer-resume] callId ${callId}`)
-      await videoCalls[callId].consumerVideo.resume();
+      await videoCalls[callId].consumer.resume();
-      await videoCalls[callId].consumerAudio.resume();
     } catch (error) {
       console.log(`ERROR | consumer-resume | callId ${socketDetails[socket.id]} | ${error.message}`);
     }
   });
 });
 
-const consumeVideo = async (callId, rtpCapabilities) => {
-  videoCalls[callId].consumerVideo = await videoCalls[callId].consumerTransport.consume({
-    producerId: videoCalls[callId].producerVideo.id,
-    rtpCapabilities,
-    paused: true,
-  });
-
-  // https://mediasoup.org/documentation/v3/mediasoup/api/#consumer-on-transportclose
-  videoCalls[callId].consumerVideo.on('transportclose', () => {
-    const callId = socketDetails[socket.id];
-    console.log('transport close from consumer', callId);
-    closeCall(callId);
-  });
-
-  // https://mediasoup.org/documentation/v3/mediasoup/api/#consumer-on-producerclose
-  videoCalls[callId].consumerVideo.on('producerclose', () => {
-    const callId = socketDetails[socket.id];
-    console.log('producer of consumer closed', callId);
-    closeCall(callId);
-  });
-
-  return {
-    id: videoCalls[callId].consumerVideo.id,
-    producerId: videoCalls[callId].producerVideo.id,
-    kind: 'video',
-    rtpParameters: videoCalls[callId].consumerVideo.rtpParameters,
-  }
-}
-
-const consumeAudio = async (callId, rtpCapabilities) => {
-  videoCalls[callId].consumerAudio = await videoCalls[callId].consumerTransport.consume({
-    producerId: videoCalls[callId].producerAudio.id,
-    rtpCapabilities,
-    paused: true,
-  });
-
-  // https://mediasoup.org/documentation/v3/mediasoup/api/#consumer-on-transportclose
-  videoCalls[callId].consumerAudio.on('transportclose', () => {
-    const callId = socketDetails[socket.id];
-    console.log('transport close from consumer', callId);
-    closeCall(callId);
-  });
-
-  // https://mediasoup.org/documentation/v3/mediasoup/api/#consumer-on-producerclose
-  videoCalls[callId].consumerAudio.on('producerclose', () => {
-    const callId = socketDetails[socket.id];
-    console.log('producer of consumer closed', callId);
-    closeCall(callId);
-  });
-  return {
-    id: videoCalls[callId].consumerAudio.id,
-    producerId: videoCalls[callId].producerAudio.id,
-    kind: 'audio',
-    rtpParameters: videoCalls[callId].consumerAudio.rtpParameters,
-  }
-}
-
 /*
   - Called from at event 'createWebRtcTransport' and assigned to the consumer or producer transport
   - It will return parameters, these are required for the client to create the RecvTransport 
@@ -517,7 +386,6 @@ const createWebRtcTransportLayer = async (callId, callback) => {
       dtlsParameters: transport.dtlsParameters,
     };
 
-    console.log('[createWebRtcTransportLayer] callback params', params);
     // Send back to the client the params
     callback({ params });
 

build.sh

@@ -1,48 +0,0 @@
-#/!bin/bash
-## PREBUILD PROCESS
-# check dist dir to be present and empty
-if [ ! -d "dist" ]; then
-  ## MAKE DIR
-  mkdir "dist"
-  echo "Directory dist created."
-else
-  ## CLEANUP
-  rm -fr dist/*
-fi
-# Install dependencies
-#npm install
-
-## PROJECT NEEDS
-echo "Building app... from $(git rev-parse --abbrev-ref HEAD)"
-#npm run-script build
-cp -r {.env,app.js,package.json,server,public} dist/
-
-#Add version control for pm2
-cd dist
-#Add version control for pm2
-version=$(git describe)
-file_pkg="package.json"
-key="  \"version\": \""
-
-count=$(echo ${version%%-*} | grep -o "\." | wc -l)
-if (( $count > 1 )); then
-        version=${version%%-*}
-else
-        version="${version%%-*}.0"
-fi
-if [ -f "$file_pkg" ] && [ ! -z "$version" ]; then
-  version="  \"version\": \"$version\","
-  sed -i "s|^.*$key.*|${version//\//\\/}|g" $file_pkg
-  text=$(cat $file_pkg | grep -c "$version")
-  if [ $text -eq 0 ]; then
-          echo "Version couldn't be set"
-  else
-          echo "Version $version successfully applied to App"
-  fi
-fi
-
-## POST BUILD
-
-cd -
-
-

public/config.js

@@ -1,4 +1,5 @@
 module.exports = {
   hubAddress: 'https://hub.dev.linx.safemobile.com/',
-  mediasoupAddress: 'https://video.safemobile.org',
+  mediasoupAddress: 'https://video.safemobile.org/mediasoup',
+  // mediasoupAddress: 'http://localhost:3000/mediasoup',
 }

public/index.html

@@ -43,7 +43,7 @@
                     <tr>
                         <td>
                             <div id="sharedBtns">
-                                <video id="localVideo" autoplay class="video" muted></video>
+                                <video id="localVideo" autoplay class="video" ></video>
                             </div>
                         </td>
                         <td>

public/index.js

@@ -12,45 +12,10 @@ let callId = parseInt(urlParams.get('callId')) || null;
 const IS_PRODUCER = urlParams.get('producer') === 'true' ? true : false
 console.log('[URL] ASSET_ID', ASSET_ID, '| ACCOUNT_ID', ACCOUNT_ID, '| callId', callId, ' | IS_PRODUCER', IS_PRODUCER)
 
-console.log('🟩 config', config)
+let socket 
+hub = io(config.hubAddress)
 
-let socket, hub
+const connectToMediasoup = () => {
-let doIHaveAudio = false
-let device
-let rtpCapabilities
-let producerTransport
-let consumerTransport
-let producerVideo
-let producerAudio
-let consumer
-let originAssetId
-
-// https://mediasoup.org/documentation/v3/mediasoup-client/api/#ProducerOptions
-// https://mediasoup.org/documentation/v3/mediasoup-client/api/#transport-produce
-let videoParams = {
-  encodings: [
-    { scaleResolutionDownBy: 4, maxBitrate: 500000 },
-    { scaleResolutionDownBy: 2, maxBitrate: 1000000 },
-    { scaleResolutionDownBy: 1, maxBitrate: 5000000 },
-    { scalabilityMode: 'S3T3_KEY' }
-  ],
-  codecOptions: {
-    videoGoogleStartBitrate: 1000
-  }
-}
-
-let audioParams = {
-  codecOptions :
-  {
-    opusStereo : true,
-    opusDtx    : true
-  }
-}
-
-setTimeout(() => {
-  hub = io(config.hubAddress)
-  
-  const connectToMediasoup = () => {
 
   socket = io(config.mediasoupAddress, {
     reconnection: true,
@@ -67,11 +32,11 @@ setTimeout(() => {
     }
     if (IS_PRODUCER && urlParams.get('testing') === 'true') { getLocalStream() }
   })
-  }
+}
 
-  if (IS_PRODUCER === true) {
+if (IS_PRODUCER === true) {
   hub.on('connect', async () => {
-      console.log(`[HUB]! ${config.hubAddress} | connected: ${hub.connected}`)
+    console.log(`[HUB] ${config.hubAddress} | connected: ${hub.connected}`)
     connectToMediasoup()
 
     hub.emit(
@@ -115,65 +80,77 @@ setTimeout(() => {
   hub.on('disconnect', () => {
     console.log('disconnect')
   })
-  } else {
+} else {
   connectToMediasoup()
-  }
+}
 
-}, 1600);
+let device
+let rtpCapabilities
+let producerTransport
+let consumerTransport
+let producer
+let consumer
+let originAssetId
+// let originAssetName = 'Adi'
+// let originAssetTypeName = 'linx'
+
+// https://mediasoup.org/documentation/v3/mediasoup-client/api/#ProducerOptions
+// https://mediasoup.org/documentation/v3/mediasoup-client/api/#transport-produce
+let params = {
+  // mediasoup params
+  encodings: [
+    {
+      rid: 'r0',
+      maxBitrate: 100000,
+      scalabilityMode: 'S1T3',
+    },
+    {
+      rid: 'r1',
+      maxBitrate: 300000,
+      scalabilityMode: 'S1T3',
+    },
+    {
+      rid: 'r2',
+      maxBitrate: 900000,
+      scalabilityMode: 'S1T3',
+    },
+  ],
+  // https://mediasoup.org/documentation/v3/mediasoup-client/api/#ProducerCodecOptions
+  codecOptions: {
+    videoGoogleStartBitrate: 1000
+  }
+}
 
 const streamSuccess = (stream) => {
-  console.log('[streamSuccess] device', device);
+  console.log('[streamSuccess]');
   localVideo.srcObject = stream
-  console.log('stream', stream);
+  const track = stream.getVideoTracks()[0]
-  const videoTrack = stream.getVideoTracks()[0]
+  params = {
-  const audioTrack = stream.getAudioTracks()[0]
+    track,
-
+    ...params
-  videoParams = {
-    track: videoTrack,
-    // codec : device.rtpCapabilities.codecs.find((codec) => codec.mimeType.toLowerCase() === 'video/vp9'),
-    // codec : 'video/vp9',
-    ...videoParams
   }
-
-  audioParams = {
-    track: audioTrack,
-    ...audioParams
-  }
-
-  console.log('[streamSuccess] videoParams', videoParams, ' | audioParams', audioParams);
   goConnect()
-  // console.log('[streamSuccess]');
-  // localVideo.srcObject = stream
-  // const track = stream.getVideoTracks()[0]
-  // videoParams = {
-  //   track,
-  //   ...videoParams
-  // }
-  // goConnect()
 }
 
 const getLocalStream = () => {
   console.log('[getLocalStream]');
   navigator.mediaDevices.getUserMedia({
-    audio: true,
+    audio: false,
     video: {
-      qvga : { width: { ideal: 320 }, height: { ideal: 240 } },
+      width: {
-      vga  : { width: { ideal: 640 }, height: { ideal: 480 } },
+        min: 640,
-      hd   : { width: { ideal: 1280 }, height: { ideal: 720 } }
+        max: 1920,
+      },
+      height: {
+        min: 400,
+        max: 1080,
+      }
     }
   })
   .then(streamSuccess)
   .catch(error => {
     console.log(error.message)
   })
-
-  navigator.permissions.query(
-    { name: 'microphone' }
-  ).then((permissionStatus) =>{
-    console.log('🟨 [PERMISSION] permissionStatus', permissionStatus); // granted, denied, prompt
-    // It will block the code from execution and display "Permission denied" if we don't have microphone permissions
-  })
-
 }
 
 const goConnect = () => {
@@ -190,7 +167,7 @@ const goCreateTransport = () => {
 // server side to send/recive media
 const createDevice = async () => {
   try {
-    console.log('[createDevice] 1 device', device);
+    console.log('[createDevice]');
     device = new mediasoupClient.Device()
 
     // https://mediasoup.org/documentation/v3/mediasoup-client/api/#device-load
@@ -201,7 +178,6 @@ const createDevice = async () => {
     })
 
     console.log('Device RTP Capabilities', device.rtpCapabilities)
-    console.log('[createDevice] 2 device', device);
 
     // once the device loads, create transport
     goCreateTransport()
@@ -231,20 +207,18 @@ const getRtpCapabilities = () => {
 }
 
 const createSendTransport = () => {
-  console.log('[createSendTransport');
   // see server's socket.on('createWebRtcTransport', sender?, ...)
   // this is a call from Producer, so sender = true
-  socket.emit('createWebRtcTransport', { sender: true, callId }, (value) => {
+  socket.emit('createWebRtcTransport', { sender: true, callId }, ({ params }) => {
-
-    console.log(`[createWebRtcTransport] value: ${JSON.stringify(value)}`);
-
-    const params = value.params;
     // The server sends back params needed 
     // to create Send Transport on the client side
     if (params.error) {
       console.log(params.error)
       return
     }
+
+    console.log(params)
+
     // creates a new WebRTC Transport to send media
     // based on the server's producer transport params
     // https://mediasoup.org/documentation/v3/mediasoup-client/api/#TransportOptions
@@ -270,10 +244,10 @@ const createSendTransport = () => {
     })
 
     producerTransport.on('produce', async (parameters, callback, errback) => {
-      console.log('[produce] parameters', parameters)
+      console.log(parameters)
 
       try {
-        // Tell the server to create a Producer
+        // tell the server to create a Producer
         // with the following parameters and produce
         // and expect back a server side producer id
         // see server's socket.on('transport-produce', ...)
@@ -296,44 +270,22 @@ const createSendTransport = () => {
 }
 
 const connectSendTransport = async () => {
-
+  // we now call produce() to instruct the producer transport
-  console.log('[connectSendTransport] producerTransport');
-
-  // We now call produce() to instruct the producer transport
   // to send media to the Router
   // https://mediasoup.org/documentation/v3/mediasoup-client/api/#transport-produce
   // this action will trigger the 'connect' and 'produce' events above
+  producer = await producerTransport.produce(params)
 
-  // Produce video
+  producer.on('trackended', () => {
-  producerVideo = await producerTransport.produce(videoParams)
-  console.log('videoParams', videoParams);
-  console.log('producerVideo', producerVideo);
-
-  producerVideo.on('trackended', () => {
     console.log('track ended')
     // close video track
   })
 
-  producerVideo.on('transportclose', () => {
+  producer.on('transportclose', () => {
     console.log('transport ended')
     // close video track
   })
 
-  // Produce audio
-  producerAudio = await producerTransport.produce(audioParams)
-  console.log('audioParams', audioParams);
-  console.log('producerAudio', producerAudio);
-
-  producerAudio.on('trackended', () => {
-    console.log('track ended')
-    // close audio track
-  })
-
-  producerAudio.on('transportclose', () => {
-    console.log('transport ended')
-    // close audio track
-  })
-
   const answer = {
     origin_asset_id: ASSET_ID,
     dest_asset_id: originAssetId || parseInt(urlParams.get('dest_asset_id')),
@@ -342,7 +294,7 @@ const connectSendTransport = async () => {
     origin_asset_type_name: ASSET_TYPE,
     origin_asset_name: ASSET_NAME,
     video_call_id: callId,
-    answer: 'accepted', // answer: accepted/rejected
+    answer: 'accepted', // answer: 'rejected'
   };
   console.log('SEND answer', answer);
 
@@ -358,7 +310,7 @@ const connectSendTransport = async () => {
 
 const createRecvTransport = async () => {
   console.log('createRecvTransport');
-  // See server's socket.on('consume', sender?, ...)
+  // see server's socket.on('consume', sender?, ...)
   // this is a call from Consumer, so sender = false
   await socket.emit('createWebRtcTransport', { sender: false, callId }, ({ params }) => {
     // The server sends back params needed 
@@ -368,15 +320,15 @@ const createRecvTransport = async () => {
       return
     }
 
-    console.log('[createRecvTransport] params', params)
+    console.log(params)
 
-    // Creates a new WebRTC Transport to receive media
+    // creates a new WebRTC Transport to receive media
     // based on server's consumer transport params
     // https://mediasoup.org/documentation/v3/mediasoup-client/api/#device-createRecvTransport
     consumerTransport = device.createRecvTransport(params)
 
     // https://mediasoup.org/documentation/v3/communication-between-client-and-server/#producing-media
-    // This event is raised when a first call to transport.produce() is made
+    // this event is raised when a first call to transport.produce() is made
     // see connectRecvTransport() below
     consumerTransport.on('connect', async ({ dtlsParameters }, callback, errback) => {
       try {
@@ -401,8 +353,7 @@ const resetCallSettings = () => {
   localVideo.srcObject = null
   remoteVideo.srcObject = null
   consumer = null
-  producerVideo = null
+  producer = null
-  producerAudio = null
   producerTransport = null
   consumerTransport = null
   device = undefined
@@ -410,7 +361,7 @@ const resetCallSettings = () => {
 
 const connectRecvTransport = async () => {
   console.log('connectRecvTransport');
-  // For consumer, we need to tell the server first
+  // for consumer, we need to tell the server first
   // to create a consumer based on the rtpCapabilities and consume
   // if the router can consume, it will send back a set of params as below
   await socket.emit('consume', {
@@ -422,7 +373,7 @@ const connectRecvTransport = async () => {
       return
     }
 
-    // Then consume with the local consumer transport
+    // then consume with the local consumer transport
     // which creates a consumer
     consumer = await consumerTransport.consume({
       id: params.id,
@@ -465,7 +416,6 @@ const closeCall = () => {
   resetCallSettings()
 }
 
-
 btnLocalVideo.addEventListener('click', getLocalStream)
 btnRecvSendTransport.addEventListener('click', goConnect)
 btnCloseCall.addEventListener('click', closeCall)