LiveKit Community

PS. Kudos to the team for the great work, LiveKit seems really nice even at this pretty early stages! :+1:

Are you setting `audioBitrate` in your track publishing options? <https://docs.livekit.io/client/publish/#advanced-track-management>

We don’t resample audio; the layers for low/medium/high quality are only used for video. Also are you setting `AudioCaptureOptions` in `setMicrophoneEnabled`? <https://docs.livekit.io/client-sdk-js/classes/LocalParticipant.html#setMicrophoneEnabled>

For the DJ, you can get the optimal audio quality with:
• AudioCaptureOptions
    ◦ channelCount: 2
    ◦ echoCancellation: false
    ◦ noiseSuppression: false
    ◦ autoGainControl: false
• TrackPublishOptions
    ◦ audioBitrate: 320_000
    ◦ dtx: false
these should minimize any type of processing WebRTC performs (which are typically tuned for voice conversations).

For audience, defaults should work well for them

Thanks for the help! :+1:  I'm using those exact settings for the DJ, but the audio quality seems to fluctuate quite a bit during my short ~15min tests.

I'm not yet familiar with the codec but it seems to make all kinds of artifacts, audible speedups etc. to the sound very easily, which kills the listening experience compared to RTMP streams. But as the tools are so powerful, I'm pretty hopeful that learning enough of the underlying codecs and tech will help :slightly_smiling_face:

(Btw. It would be super nice to have to have for example a flag for the cli load-test command to feed it your own audio source -- would help quite a bit in testing music applications (which are very different to voice/speech in general)!)

Another thing I found out was that the audio output seems to be VBR which is suboptimal for streaming music. Is there any way to instruct the SFU to output CBR (at least for audio)?

if audio seems to fluctuate (speedup/etc), then it might be a sign that it's publishing at a bitrate that's too high for the publisher and/or subscribers. WebRTC is much more sensitive to network fluctuations compared to RTMP, due to low latency requirements.

In terms of load testing, you could publish a pre-encoded file with <https://github.com/livekit/livekit-cli#publish-media-files|this command>. and then spin up subscribers with `livekit-cli load-test`

yeah, we can look at supporting CBR mode too. that's currently not enabled as it requires some SDP wrangling with WebRTC. FWIW, it would be the publisher encoding in CBR. the SFU only forwards data, and does not re-encode.

what do you want to do with Amazon Interactive Video Service?

from what i understand the livekit needs a stream service to stream live videos.  or do not need?

LiveKit has both SDKs for clients to publish/subscribe video, as well as a server that provides streaming service. You can use <http://livekit.io/cloud> if you don’t want to host the server yourself.

so is the self hosted server already the streaming service?

Hi !
Has anyone got this error while trying to build egress ?
```Step 5/10 : COPY compile /
 ---&gt; 928836eb219f
Step 6/10 : RUN /compile
 ---&gt; Running in f04ffa3b87c6
/compile: line 4: NINJA_OPTS: unbound variable
The command '/bin/sh -c /compile' returned a non-zero code: 1
Error: exit status 1```

The build command was:
`mage buildGStreamer`

1.jpg

Screenshot_1670575820.png

image.png

Hey Furkan, do you know which device the user is publishing with? this seems like an issue that's related to the hardware (either camera or encoder)

Device having another green stripe issue that I didn't mention above : HUAWEI Y9 Prime 2019 <@U01KZ61GV5Z>

<@U041KCGQCGZ> can you get full device logs from this user?

I am using Firebase Crashlytics. There are few bug logs related to livekit or webrtc. But only one of these users has a log record. I have added below: `Fatal Exception: io.flutter.plugins.firebase.crashlytics.FlutterError: PlatformException(error, MediaStreamTrack has been disposed., null, java.lang.IllegalStateException: MediaStreamTrack has been disposed.`
	`at org.webrtc.MediaStreamTrack.checkMediaStreamTrackExists(Unknown Source:13)`
	`at org.webrtc.MediaStreamTrack.enabled(Unknown Source:0)`
	`at com.cloudwebrtc.webrtc.MethodCallHandlerImpl.mediaStreamTrackSetEnabled(Unknown Source:14)`
	`at com.cloudwebrtc.webrtc.MethodCallHandlerImpl.onMethodCall(Unknown Source:905)`
	`at io.flutter.plugin.common.MethodChannel$IncomingMethodCallHandler.onMessage(Unknown Source:17)`
	`at io.flutter.embedding.engine.dart.DartMessenger.invokeHandler(Unknown Source:18)`
	`at io.flutter.embedding.engine.dart.DartMessenger.lambda$dispatchMessageToQueue$0(Unknown Source:20)`
	`at io.flutter.embedding.engine.dart.DartMessenger.a(Unknown Source:0)`
	`at io.flutter.embedding.engine.dart.a.run(Unknown Source:12)`
	`at android.os.Handler.handleCallback(Handler.java:900)`
	`at android.os.Handler.dispatchMessage(Handler.java:103)`
	`at android.os.Looper.loop(Looper.java:219)`
	`at android.app.ActivityThread.main(ActivityThread.java:8668)`
	`at java.lang.reflect.Method.invoke(Native Method)`
	`at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:513)`
	`at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:1109)`
`). Error thrown null.`
       `at StandardMethodCodec.decodeEnvelope(message_codecs.dart:653)`
       `at MethodChannel._invokeMethod(platform_channel.dart:296)`

There are livekit and webrtc logs independent of these people, I can send them if you want. <@U01NZKTNE1H>

yes.  I am using this : <https://github.com/livekit/client-sdk-flutter>

`Fatal Exception: io.flutter.plugins.firebase.crashlytics.FlutterError: LiveKit Exception ConnectException Timed out waiting for EnginePeerStateUpdatedEvent. Error thrown null. at Engine.connect.&lt;fn&gt;(engine.dart:148)`

`Fatal Exception: io.flutter.plugins.firebase.crashlytics.FlutterError: Unable to RTCPeerConnection::setRemoteDescription: peerConnectionSetRemoteDescription(): WEBRTC_SET_REMOTE_DESCRIPTION_ERROR: Failed to set remote answer sdp: Called in wrong state: stable. Error thrown null.`
       `at RTCPeerConnectionNative.setRemoteDescription(rtc_peerconnection_impl.dart:319)`
       `at Transport.setRemoteDescription(transport.dart:84)`
       `at Engine._setUpSignalListeners.&lt;fn&gt;(engine.dart:746)`
       `at EventsListenable.on.&lt;fn&gt;(event.dart:157)`
       `at EventsListenable.listen.&lt;fn&gt;.&lt;fn&gt;(event.dart:128)`
       `at BasicLock.synchronized(basic_lock.dart:33)`
       `at EventsListenable.listen.&lt;fn&gt;(event.dart:127)`

`Fatal Exception: io.flutter.plugins.firebase.crashlytics.FlutterError: Unable to getUserMedia: getUserMedia(): DOMException, NotAllowedError. Error thrown null.`
       `at MediaDeviceNative.getUserMedia(mediadevices_impl.dart:48)`
       `at LocalTrack.createStream(local.dart:135)`
       `at LocalVideoTrack.createCameraTrack(video.dart:39)`
       `at LocalParticipant.setSourceEnabled(local.dart:339)`

`Fatal Exception: io.flutter.plugins.firebase.crashlytics.FlutterError: Call initialize before setting the stream. Error thrown null.`
       `at RTCVideoRenderer.srcObject=(rtc_video_renderer_impl.dart:50)`
       `at _VideoTrackRendererState._attach(video_track_renderer.dart:64)`
       `at _VideoTrackRendererState.didUpdateWidget.&lt;fn&gt;(video_track_renderer.dart:87)`
       `at _VideoTrackRendererState.didUpdateWidget(video_track_renderer.dart:88)`
       `at StatefulElement.update(framework.dart:5065)`
       `at Element.updateChild(framework.dart:3570)`

`Fatal Exception: io.flutter.plugins.firebase.crashlytics.FlutterError: LiveKit Exception: [NegotiationError] Unable to RTCPeerConnection::setLocalDescription: peerConnectionSetLocalDescription(): WEBRTC_SET_LOCAL_DESCRIPTION_ERROR: Failed to set local offer sdp: The order of m-lines in subsequent offer doesn't match order from previous offer/answer.. Error thrown null.`
       `at Transport.createAndSendOffer(transport.dart:140)`

`Fatal Exception: io.flutter.plugins.firebase.crashlytics.FlutterError: Unable to RTCRtpSender::setTrack: rtpSenderSetTrack(): peerConnection is null. Error thrown null.`
       `at RTCRtpSenderNative.setTrack(rtc_rtp_sender_impl.dart:112)`
       `at LocalParticipant.setSourceEnabled(local.dart:330)`

`Fatal Exception: io.flutter.plugins.firebase.crashlytics.FlutterError: Unable to RTCPeerConnection::getLocalDescription: getLocalDescription(): peerConnection is null. Error thrown null.`
       `at RTCPeerConnectionNative.getLocalDescription(rtc_peerconnection_impl.dart:338)`
       `at Engine.sendSyncState(engine.dart:668)`

These are all the errors I've seen in Firebase. The first post I posted is the most common error log.

hmm, do you have logs from a device that is showing the green stripes? the errors should probably get a separate thread for investigation. cc <@U02GAC58A79> fatal exceptions

<@U041KCGQCGZ> Is the log you provided a continuous log? I mean these logs are produced in the same exception?

These errors are Firebase log records that occur in dozens of users every day. I don't know how they are triggered. <@U02GAC58A79>

These are the error logs for all my users, not the ones with the green stripe problem.

okay, thanks, I’ll look into these issues

<@U02GAC58A79> According to my research, this happens to streamers with bad internet. It probably occurs in other screens for the same reason. Maybe this information will help you.

<@U041KCGQCGZ> which version of the SDK are you using? can you comment in <https://github.com/livekit/client-sdk-flutter/issues/232|this issue>?

Hey Osman, we don't currently negotiate pcm mulaw on the server side. If this is something you are looking for, feel free to open an issue <https://github.com/livekit/livekit/issues|here>.

alternatively, you could encode the audio track with Opus (perhaps with <https://github.com/pion/opus|this>), and it should work as is.

Thank you David for your detailed answer.

And I tried this way too
`publishTrack(audioTrack, { source: Track.Source.Microphone, stopMicTrackOnMute: true })`
But it's keeping recording is on when the user muted always

So I was trying to unpublish/publish to stop track when the user muted. But it's getting warning. I was trying to publish audio track by using same source `Microphone`

Hm <@U02EU2ZPTQU> probably knows the answer (though he might be out for the weekend)

Got it. Thanks. I will wait by next Monday

<@U04DED3V5PT> which platform are you testing on? On Chrome/Mac, `stopMicTrackOnMute` works well for me.

possibly. So if you unpublish &amp; republish, other than the warning, what else do you see?

No else. I am getting warning. `"You are trying to publish with same Source again"`

but it behaves like the way you would like?

ok, that's good. we'll check out how it behaves on windows

last I tried it did work properly. but maybe something has changed

Can you help to check why track is not stopped when it's muted?

the code is stopping it when that option is set

Yes. I checked the code. It's trying to stop. But it's not working on my side.
Let me try to debug again.

<@U01KZ61GV5Z> I tried to debug. It's not working

I checked `setMicrophoneEnabled` function. It's trying to unpublish/publish. So I think I can do this way on my local side without using this `setMicrophoneEnabled`
What do you think of this?

just to check, did you pass in stopMicTrackOnMute when initially enabling microphone? those options are used only during publishing (enabled=true), and ignored when it's being turned off

Please check `setTrackEnabled`. It's checking source is Screenshare. If it's not screenshare, it's trying to unmute simply

can you check your code when mic was enabled? what are you passing in for publish options?

again.. not when you are calling setEnabled(false... how are you enabling the track?

what is audioTrack? how was that acquired?

if you are using that instead of setMicrphoneEnabled(true), we cannot manage mic indicator for you

If  you are using K8s follow <https://docs.livekit.io/oss/deployment/kubernetes/#cert-manager> (cert manager) and <https://github.com/livekit/livekit-helm/blob/master/examples/server-do.yaml#L24> (which will issue a SSL via cert-manger)

Is this TLS the same as DTLS? I  thought it is for signaling TCP TLS.

WebRTC doesn't use CA signed certificates with DTLS. <https://webrtcforthecurious.com/docs/04-securing/|Here's> a good overview on how it works.

The way I see it there is a bug in `Room.connect()`
or much rather `Room.acquireAudioContext()`
There  `const ctx = getNewAudioContext();`
should be wrapped in a `try/catch` and the `audioEnabled` flag should be set to `false` and trigger the `RoomEvent.AudioPlaybackStatusChanged` event.

It is a bit strange though that still the video playback doesn’t start and the
```TrackEvent.AudioPlaybackFailed```
Isn’t triggered though when trying to play back the video

Okay, so I debugged it and the issue isn’t that an exception is thrown, the warning is printed without an exception but the returned context is in `suspended` status. --&gt; This means that `Room.acquireAudioContext()` should likely both have a `try/catch`  AND check for the `status` to be running.

I’ll debug the `play()` of the actual video now to see why we don’t get a promise rejection there.

Hey David, thanks for looking into this! That is indeed inconsistent behaviour.
1. From the first look I would say a good fix for the audio part would be to check the audioContext status in `acquireAudioContext` and emit the `AudioPlaybackStatusChanged` event if it failed to start (and was `true` before). 
2. Regarding the video playback, that’s even stranger. video elements with `muted` attribute set, should always be allowed to autoplay. Are you using the client-sdk `attach` call ? Are you seeing this behaviour across different browsers?


&gt; Are you using the client-sdk `attach` call ?
Yes
&gt; Are you seeing this behaviour across different browsers?
I’m not having it on my OSX Chrome but (not even the warning message) but I have it on a Windows PC Chrome  and on the OSX of 2 colleagues on Chrome
I’ll debug it on the Windows PC and report back

I’m attaching both to the same `video` element and I think I found the problem.
You only ever explicitly call the `play()` method when you are either attaching it to an `audio`  element or if you are using a `Firefox`  or `Safari`  browser (`Track.attach()` and `Track.attachToElement()`)
As far as I can see for a normal Chrome you’d simply set `autoplay`  to true but I can’t see you calling `muted=true` anywhere.
I have had the same issue in the past when we where managing this ourselves.

The way we solved this was like this:
1. Always set `autoplay=false`
2. set the `muted` flag to `true`  if we don’t have any audio track, otherwise keep it false
3. always call `play()`
4. if `play()`  fails, do `muted=true` and call `play()`  again
5. Display a button that displays a speaker symbol, on click change `muted=false` 

chrome does keep an `media interaction index` for each url, might be related: <https://developer.chrome.com/blog/autoplay/>

I think if the audio playback requires interaction we would get the autoplay for video for free.

yes but autoplay doesn’t start anything if you have `muted=false` and you’re not allowed to play audio

aha! yeah, we would generally recommend to use separate media elements for audio and video tracks! any particular reason why you want to attach both to the same element?

In that case it will neither start audio nor video

which is why you it’s better to put `autoplay=false` and call it yourself so you know it failed

&gt; aha! yeah, we would generally recommend to use separate media elements for audio and video tracks! any particular reason why you want to attach both to the same element?
Just because it’s easier to manage on our end that way, and I thought, why manage a separate audio element if I can do both in one… :shrug:

I do agree keeping them separate makes it easier to manage off-screen users etc so I might change it to be that way once we start doing so

Makes sense, we did encounter issues before of audio not starting in those cases if the video data didn’t come through though. E.g. a video track is being attached to the element first, but doesn’t have any data ready, so playing is blocked. Then an audio track is attached which would already have data to play, but the playback of the video element is still blocked due to the video track lacking data.

The error wasn’t consistent, but there was definitely something going on with the combination of different tracks in different readystates attached to the same element.

I’ll raise an issue on the GH repo about the missing audio playback event, which will be an improvement anyways and might also help with attaching both tracks to the same element.

thanks for your help debugging this :pray:

Okay, so I changed my implementation to use a separate `audio` element and attach the mic track to it instead of the `video` element.
Now here’s the interesting thing: I do get the expected `RoomEvent.AudioPlaybackStatusChanged` now and ``room.canPlayAudio=false`` BUT my video’s still don’t play

(they do play if I refresh while my camera is published so it’s not a general issue)

I don’t have a repro for this at hand, if you call `videoEl.play` in the `TrackSubscribed` callback, does that fix things?

If I do it via the Chrome DevTools (directly selecting the video element on the screen and then calling `$0.play()`  it solves the issue, yes.

I think it’s the problem I described above as soon as the video element doesn’t have the `muted=true` autoplay will not start if you haven’t had a user interaction on the page

This is why we changed it to the steps I posted above

Yes this fixes it. If I create my own `video`  element, set it to `muted=true` and then pass it into the `attach()` method it works

huh, our `attach` method  also sets the muted attribute on the element :thinking_face:

to be fair, I have always created the video element myself so that might be the case

&gt; huh, our `attach` method  also sets the muted attribute on the element
Looking at your `Track` class I can’t find where you are doing the `muted=true`  though all I see is this:

The only place I find is in `RemoteAudioTrack.attach`  but in this case we’re talking about the `RemoteVideoTrack.attach`

You are right, I remembered incorrectly. The place where we do set some of these attributes is the `attachToElement` function, but `muted` is currently not part of it.
It does get trickier to think about it if users would want to use the same element for both video and audio. In this case setting `muted` would be undesired.

if you follow the steps in this post it should work though:
<https://livekit-users.slack.com/archives/C01KVTJH6BX/p1670847434129869?thread_ts=1670841530.846569&amp;cid=C01KVTJH6BX>

you’d have to emit your event in step 4

thanks, does the combination of `muted=true` and `autoplay=true` not work for you? do you _have_ to call play manually?

sorry I mixed up step 2 I just updated it

&gt; thanks, does the combination of `muted=true` and `autoplay=true` not work for you?
Yes it does but if you want to be able to detect if playback worked or not you need to explicitly call `play()`

as long as you always separate audio and video into 2 elements simply muting the video element is fine

but if you want to be able to mix them then you first have to do `muted=false` try play and if it doesn’t work `mute=true` and play again

in case you have audio and video tracks combined on the same element, your step 4. would then only play the video, I assume?

I mean, you wouldn’t get audio playback that way, as the element is muted

&gt; in case you have audio and video tracks combined on the same element, your step 4. would then only play the video, I assume?
Yes and then it would emit the `RoomEvent.AudioPlaybackStatusChanged` event

then the integration is responsible for getting the needed user interaction and calling the `room.startAudio()` method

got it, to confirm, would <https://github.com/livekit/client-sdk-js/pull/534/files> address all your concerns?

how are you publishing the stream? with the go sdk?

<@U04FN22V5L0> LiveKit does not perform any encoding of streams. You should be able to publish H.264 encoded in any way. Please verify your pipelines to ensure keyframes are being published. (and that you are encoding into constrained baseline). see <https://developer.mozilla.org/en-US/docs/Web/Media/Formats/WebRTC_codecs#supported_video_codecs|MDN docs on this>

<@U02EU2ZPTQU>, to publish stream we are used livekit-cli Join room command, _livekit-cli join-room --room &lt;room name&gt; --api-key &lt;api key of server&gt; --api-secret &lt;secret key of the server&gt; --url &lt;url of the server&gt; --identity &lt;name of user&gt; --publish <h264://127.0.0.1:8888>_

Couldn't you control this through your app itself? I feel like this could be app business logic. This said, from my understanding its you canPublish or you cannot. Currently I don't think there's a way to control per media type.

You can read about the grants from this doc: <https://docs.livekit.io/concepts/authentication/#video-grant>

I already thought that this could be handled on the app-side with some tweaks on the server, but wanted to make sure that this is the only way.

Thanks for the reply!

As Pat said, this could be done at the app layer. But I think you bring up a great point.. we can provide more fine-grained enforcement with the permissions layer.

I'm thinking it might be good to break it down into `canPublish&lt;source&gt;` where &lt;source&gt; could be camera, microphone, screenshare, screenshare-audio.

that way these are enforced on the server side even if a participant uses a different client to overcome the limitations that you've set at the app layer

Wonderful idea <@U01KZ61GV5Z>. This could be a great additional feature. More granularity on per permission level could be handy. Id still keep the original one as a global one, but if you don't want the global one, allowing per source type.

yeah, that makes sense. by default they are the same value as `canPublish`, but you may override to anything

hey there :wave:

Here are some self-hosted benchmarks we’ve done using our <https://docs.livekit.io/oss/benchmark/#load-tester|load tester> for audio-only:
<https://docs.livekit.io/oss/benchmark/#audio-only>

Thank you for your kind reply. May I please ask:

1.Isn't a 16-core computer kinda expensive though? Does it require so many resources to operate on normal conditions?

2. Also, why does it require API keys if it's self hosted?

&gt; 1.Isn’t a 16-core computer kinda expensive though? Does it require so many resources to operate on normal conditions? (edited)
Are you aware what an SFU has to do? It creates a WebRTC connection to each peer and forwards the correct media stream to it. This is pretty CPU intensive and those numbers are actually incredible.
Compare them to any other SFU and you’ll see that

I might be missing something. Can it handle, let's say 10 users talking in a group chat and that, multiplied * 100 different group chats?

While I highly recommend you use our load tester for your specific use case, on the surface, this shouldn’t be a problem at all. You can also easily horizontally scale the number of rooms/sessions with LiveKit. What is trickier is scaling the number of participants in a single session (which the benchmarks I shared reflect for a single instance).

Thank you very much for your kind reply. I highly appreciate it and this service is one of the very few that I admire so much! Thank you for this contribution :pray:

May I please ask 3 last questions?

1. I've seen that server sdk requires api-key and secret-key. Why is that? I mean, if it's self hosted solution, then where do we find those keys?
2. How many one to one video/audio calls can LiveKit handle (no participants/subscribers, just 2 people talking or doing video call) and what's the minimum server requirements?

3. Is there a comparison between LiveKit and Jitsi meet? I can't find any benchmarks between those two.


Thank you very much for your valuable time once again :pray:

<@U01KZ0SCDKL> <@U0414095DAB> I'd appreciate your help guys :pray:

Thanks for the kind words <@U04F60A3U92>. :pray::skin-tone-4:  

On your questions:
1. In a self-hosted setup, access tokens can be generated via server SDK or CLI. They are used to authenticate participants with instance(s) of LiveKit’s media server (“SFU”). The server SDK is code running external to the SFU, so for security reasons, this is why you must do this handshake. I’ve been meaning to write up some more on this, but here’s some additional <https://docs.livekit.io/concepts/authentication/|info>.
2. I’m not sure on this and encourage you to load test your specific use case. However, LiveKit has no problem horizontally scaling as the number of rooms increases. You should be able to host as many of these 1:1 conversations as you want.
3. we have not yet done a detailed comparison of LK against Jitsi.

Thank you very much <@U01KZ0SCDKL> for your detailed reply, I highly appreciate it. Also I cannot thank you enough for your open-source contribution. LiveKit is by far the most interesting open source software I've found that is backed by the most inspiring team!

Thank you guys!:pray:

Thanks for sharing this with us, <@U04F60A3U92>. It means a lot to the team! Excited to see what you build with LiveKit and if you have any more questions or concepts need further clarification, please let us know.

<@U01KZ0SCDKL> I'm trying to build a social-media/chat like app, but more secure. However, I have some GDPR concerns as to whether it is possible to store and retain every audio/video call (in .mp4 format) on the server, for a specified amount of time (e.g. 1 year). I guess LiveKit provides this option. So far, I guess this can be included on terms of use &amp; privacy policy pages where the user accepts any given terms. Would that be enough/okay though for GDPR compliance?

The reason of being able to store every data, even audio/video ones has 2 main security benefits. Case 1, is when e.g. law enforcement is applied for whatever the case (e.g. between a dispute of 2 or more users), so they require data. Case 2 though, is more important. It is about preventing bad or certain things to happen, eliminates bots and makes a social system more safe. That ofcourse, requires an automated process where every stored text/audio/video information from each user is passed into a Natural Language Processing model (for text/audio) and into a Video Classification model (for video), to identify (bad/harmful) personality traits.

Being able to use self-hosted software, allows us to build more secure systems without transferring data to 3rd party services, thus respecting user's privacy while providing an almost bot-free environment that is used by non-weirdo people :)

Thanks for the detailed response on what you’re trying to build! LiveKit Cloud doesn’t actually store/retain audio or video data. If you use the egress service to record a call, it’s uploaded directly to your specified cloud bucket. Virtually every popular cloud provider is GDPR compliant, so you’re fine there. Regarding LiveKit, you *primarily* (there’s some additional nuance here, but not worth getting in the weeds) need us to be compliant as a data processor (which we’re in the process of doing) for transmission. You also need to ensure your app itself complies with GDPR (making sure you have your user’s permission to collect/transmit personal data, etc.).

Thank you for your detailed response. I guess LiveKit Cloud doesn't store any audio or video data, however a self hosted instance of LiveKit on our own server should be able to, right?

A self-hosted deployment of LiveKit + Egress does allow you to store recordings locally if that’s what you want to do, yes. With Cloud, you’re still hosting the files yourself, they’re just in a cloud bucket (e.g. S3) that you control.

Please let me clarify. By recordings you mean every video/audio call in general or only the ones when a user presses a button to record? I'm interested for the first case.

That’s completely up to you. You can record every call or you can only record certain ones (either user-initiated or by some other mechanism). GDPR doesn’t explicitly prevent you from doing the first case, but you do have to make sure you describe what your application is doing somewhere and obtain your users’ consent.

Yeah, most definitely! Users will be informed about everything. Processing data will ensure better user safety. Thank you for your response:pray:

4.png

It does look high and may be worth looking into, but hard tell for sure/reproduce without more details on the test parameters

Here are some more details:
Regarding Egress installation its running on Debian 11 and libgstreamer dependencies have been installed via apt-get (is this ok? should I be using specific versions?).
Regarding the test I have a small bash script but the main parts are:
• start a room with a pub and a sub: 
```livekit-cli load-test --api-key $LKKEY --api-secret $LKSECRET --url $LKURL --room $ROOM_NAME --publishers 1 --subscribers 1```
• get the participant and get the video track 
```livekit-cli list-participants --api-key $LKKEY --api-secret $LKSECRET --url $LKURL --room $ROOM_NAME
livekit-cli get-participant --identity $PARTICIPANT_ID --api-key $LKKEY --api-secret $LKSECRET --url $LKURL --room $ROOM_NAME```
• start recording the track
```livekit-cli start-track-egress --api-key $LKKEY --api-secret $LKSECRET --url $LKURL --request $REQFILE```
• REQFILE has the following format:
```{ 
  "room_name": "$ROOM_NAME",
  "track_id": "$TRACK",
  "file": {
    "filepath": "$ROOM_NAME.mp4",
    "s3": {
      "access_key": "KEY",
      "secret": "SECRET",
      "region": "us-east-1",
      "bucket": "BUCKET" 
    }
  } 
 } ```
• After this I sleep for a while, right now I’m doing 300s
• After that I stop the track egress
```livekit-cli stop-egress --api-key $LKKEY --api-secret $LKSECRET --url $LKURL -id $EGRESS_ID```

Thanks for the report. It looks like contrary to what the documentation states, H264 track egress are getting transcoded. We will fix the logic.

As a side note since you mention installing he dependencies on the host system: are you running egress directly on the host or in docker? Running directly on the host can be convenient for testing but would not be advised with production traffic.

Thx for your input <@U03H6MNQ9G9>, do you happen to have an issue link that I can track for the transcode problem?

I'm indeed running the binary directly on the host ... I'm kind of old school VoIP guy and I'm a little scared to run media through docker/kubernetes. I will take that into consideration for sure. But can you tell me what kind of issues can I run into when running directly on the host? Just so I can keep an eye out during my tests.

Security, mostly. the egress service writes media to a path provided in the StartEgress request

regarding a ticket, we do not have one on GH. Best would be to create one if you want a notification when it's fixed

And one more, I am getting `connection timeout` error sometimes

After get this exception, reconnection is not working automatically

Hi!
for the first issue, could you open an issue on the client-sdk github with steps how to reproduce it?
`LocalTrackPublished` is supposed to fire, as long as the connection is already established.
For the `connection timeout` can you post the exact error message you are getting?

When I reproduce connection timeout, I will create video

<@U02EU2ZPTQU> Please check this screenshot

I was facing this issue with slow network

Can you help how to reconnect at this time?

On a slow network it can happen!
One option would be to increase the `peerConnectionTimeOut` in the `RoomConnectOptions` , the default is 15 seconds.
If there’s something not working when trying to call `room.connect` again after the peer connection failed, it would be great if you could open an issue with detailed logs and description of what’s happening!

I think it need to reconnect automatically, if get exception

it’s a different reconnect logic, because the connection has never been fully established before.
The best way for now would be to `try…catch` the `connect` call yourself

When I try to switch or reload the browser, I am getting this error.
Do I need to republish at this time t oo?
<@U02EU2ZPTQU>

Yeah, publication wasn’t successful in that case and there’s currently no logic to automatically try to re-publish failed attempts

hi Ryan,
the way this works today is by calling `setVolume` on the either the <https://docs.livekit.io/client-sdk-js/classes/RemoteParticipant.html#setVolume|RemoteParticipant> or on the <https://docs.livekit.io/client-sdk-js/classes/RemoteAudioTrack.html#setVolume|RemoteAudioTrack>. There’s also an open issue on enabling your usecase with ScreenShareAudio more directly via the participant here: <https://github.com/livekit/client-sdk-js/issues/442>
For now you’d have to call that function directly on the RemoteAudioTrack until the participant level feature for screen share audio has landed!

just realised I misread the question: you’re talking about controlling the input volume. That’s currently not possible without some manual workarounds.

Okay I figured that was the case!  Are there any listeners I can add to check if a remote track is muted or not?  My goal is just to increase Microphone clarity while speaking over audio.

The way we would like this to work in the future is that you can pipe local tracks through web audio before they are sent out and use a `gainNode` to control the volume!

I was looking at the exact same gainNode stuff earlier

in order to listen to a remote track’s muted status there’s a `TrackMuted` event.

The manual workarounds for piping the a mediastream through webaudio would require you to work with more low level APIs of LiveKit, the basic gist would be:
• acquire your source track via `getUserMedia`
• create a source from it with `audioContext.createMediaStreamSource(myTrack)`
• create a destination with `audioContext.createMediaStreamDestination()`
• link them up with `mySource.connect(myGainNode); myGainNode.connect(myDestination)`
• manually publish that track with `localParticipant.publishTrack(myDestination.stream.getAudioTracks()[0])`
(this is totally untested, but the basic workflow should be correct)

while LiveKit is trying to reconnect the sdk doesn’t emit a `Disconnected` event. it will only do so once all reconnect attempts are exhausted.
In order to listen to a reconnection attempt you can listen to `RoomEvent.Reconnecting` and `RoomEvent.Reconnected` for knowing when the connection has re-established.
Another way (for getting all connection-status updates) is to listen to `RoomEvent.ConnectionStateChanged`.

Hey owais, the android implementation should exist in the demo app. Note that a foreground service is required for screen share. You can see our example of that here: <https://github.com/livekit/client-sdk-react-native/blob/main/example/src/callservice/CallService.android.ts|https://github.com/livekit/client-sdk-react-native/blob/main/example/src/callservice/CallService.android.ts>

there’s currently discussion around a related topic here: <https://github.com/livekit/client-sdk-js/issues/507>

from within the livekit-sdk the goal is to take care of publishing issues while the client is in a `Reconnecting` state.
If it’s about switching rooms (I guess that’s your use case, or what to you mean by switching?) then this would have to be handled by your application layer.

maybe in your usecase it’s even simpler to just try/catch publishing and retry if it fails?

Understand <@U02EU2ZPTQU> Thanks for your quick support. Let me try to handle on our application layer

we have a docs page for server setup! <https://docs.livekit.io/getting-started/server-setup/>

So the only thing required is this line of code:

livekit-server --dev --bind &lt;server_ip&gt;

?

I was referring to a more detailed process for production use

check this
<https://docs.livekit.io/oss/deployment/vm/>

no server-side cancellation (we don’t decode on the server), the echo cancellation and noise suppression options are the best we have at the moment

Thank you very much for the prompt reply. :+1:

just to make sure, are you talking about two participants being in the same _physical_ room and joining the same livekit-room?

No, both are in different rooms and not using headsets. The audio comes from the speakers which echoes back into the mics. It is not possible to have a conversation in this scenario. Using headsets is not an option as the system is used in stage performances. It would be great to have a solution to prevent room echoes because it would allow us to replace zoom. Any help is highly appreciated.

the room echoes you are talking about are the voices of the other participants or are there other audio sources involved (e.g. audio files playing at the same time?)
browsers generally do a pretty good job at filtering out the other participants’ voices, but it breaks down if e.g. both participants listen to the same audio stream that gets looped back into the microphone via the speakers

It is a stage situation. That means we have other audio sources beside the spoken words.

got it, thanks for clarifying.  unfortunately will have to refer back to noah’s original answer then…

As far as I understand echo cancellation and noise reduction happens on the client side. Is it build in to the client SDKs or is it something the hardware does and is only switched on?

the echo cancellation that the LiveKit js-sdk uses is the one that is built-in in the browser. You can enable/disable echo cancellation for a user by setting `echoCancellation: false` in the <https://docs.livekit.io/client-sdk-js/interfaces/AudioCaptureOptions.html#echoCancellation|AudioCaptureOptions> .

livekit-server logs.PNG

client error.PNG

Please follow the thread <https://livekit-users.slack.com/archives/C01KZ61HZRR/p1669972332348759?thread_ts=1669972332.348759&amp;cid=C01KZ61HZRR|https://livekit-users.slack.com/archives/C01KZ61HZRR/p1669972332348759?thread_ts=1669972332.348759&amp;cid=C01KZ61HZRR>, hope it will give you the required insights. The error is due to queue stack limitation in users set queue

Hi, Ashan, thanks for bringing the issue to me. You mentioned: "The error is due to queue stack limitation in users set queue", how should I set the queue stack limitation higher? Thanks again!

<@U01KZ61GV5Z> / livekit team is looking into to fix the issue ( to support more users in testing) . Till then you can  start parallel thread in same machine and you can increase each server count as required.

Fir a single thread, you can start with 600 subscribe s and move your way up to get the marginal testing. Please read shared thread commets for more insights

Thanks Ashan, I was able to use livelit-cli to pub and sub 200 tracks before. Looks something changed.

did you set file handle limit on the tester instance?

1671588839819.png

you would not want the `<tcp://ip>` in there. port should just be `80`

I am using Helm charts. I was using the helm upgrade command after the helm repo update to update the livekit version, but in the last update the helm upgrade command gives the following error: " Error: failed to download "livekit/livekit-server" "    <@U01KZ61GV5Z>

Hi <@U045T502K53>,
does this happen when the browser tab/window is being closed or also when the component unmounts without navigation/browser being closed?

Hi <@U02EU2ZPTQU>, it happens when for example moving from the the call page where I’ve implemented Livekit to another page by calling the `history.push('/')` function … my workaround is thinking this is a SPA issue, maybe, is also after this calling `window_.location.reload_();` function so I reload the page that I’m redirecting to so I make sure the call connection is closed but also the camera is turning off.

<@U045T502K53> you may have meant to tag Lukas not Luis ;)

The navigation within your SPA occurs entirely client-side right? so there’s no actual browser page (un)loading?

Does it work if you call
```room.disconnect()```
directly before doing the SPA navigation?

<@U028SSAKLQ1> Yes, only client. My example is wrong.. sorry.
The issue is when I’m not performing the redirect like the user pressing on a button in the page and the actual issue is when he presses the browsers back button, not one from the application where i can control the redirect to happen after disconnecting from the call.

So if I do this for example:
```await room?.disconnect();
history.push('/');```
I disconnected from the call before redirecting but if the user presses the browser back button and as a consequence the component is unmounting Likekit does not detect this and disconnect me from the call and if trying on onmount effect to manually disconnect the user is not working
```useEffect(() =&gt; {
        return () =&gt; {
            (async () =&gt; {
                await roomCall?.disconnect();           
        };
        // eslint-disable-next-line react-hooks/exhaustive-deps
    }, []);  ```

thanks for clarifying. We do a couple of things to try and disconnect automatically when a component unmounts or when a page gets unloaded. Disconnection might take a tiny bit longer on slower connections, but generally it should be more or less instant.

To your manual disconnect call, the example you posted seems wrong (there’s a couple of parenthesis missing), but maybe that’s just a copy-past error? have you tried a simpler version with
```useEffect(() =&gt; {
  return () =&gt; roomCall.disconnect();
});```
also, if your `roomCall` is potentially undefined, are you sure you are actually calling disconnect?

It’s strange that it doesn’t work out of the box for you though. Could you spin up a minimal reproduction repository? that would be helpful in debugging this.

I see, in fact your right <@U02EU2ZPTQU> with `roomCall` being `undefined`  so that’s why is not working … but the interesting part comes if I console.log(roomCall) the values of it comes like this:
```useEffect(() =&gt; {
        return () =&gt; {
            console.log({roomCall})        
        };
        // eslint-disable-next-line react-hooks/exhaustive-deps
    }, [roomCall]);
 
```
Initial render:
```{roomCall: undefined}
```
Second render since is a dependency of `useEffect`:
```{roomCall: Room}
```
On unmount:
```{roomCall: undefined}
```
Not sure why is `undefined` to be honest on unmount, maybe because `Livekit` detects that the component unmounts and calls the `disconnect` function?

But the issue is interesting because even though let’s assume LiveKit disconnected me from the call I still can see  I’m connected if I’m not `manually refreshing` the page and if i’m going back again in the call and repeat the process w/o refresh the call I can see me multiple times inside the call

I think this behaviour might be specific to your implementation but it’s hard to say without more code context.
If you can spin up a minimal reproduction example that showcases the issue, I’m happy to take a look!

Hi <@U045T502K53>, I guess you‘re still talking to Lukas? :smile: 

you are the first appearing in the mention list :)))

<@U02EU2ZPTQU> the “bug” with disconnecting and reconnecting to the room I reproduced it also with the example you guys are hosting over here:
```<https://example.livekit.io/#/>```

I connect then press back button … connect again … press again the back button … connect again and 2 times i connected and disconnected still appear to be connected.

w/o refreshing the page the user still remains connected to the call until he forces a refresh of the page when the disconnect really happens.

thanks for the update! I will post this insight also on the GH issue you opened and try to reproduce with the react example!

Ok, nice. Hope this context helps the debugging process