LiveKit Community

for that it's probably best to create a custom recording template — basically you create a webapp that acts as a client and subscribes to the tracks you want: <https://docs.livekit.io/server/egress/custom-template/>

is the idea to create a ScreenShare track via
`CreateLocalScreenTracks` and
`await currentRoom.localParticipant.setScreenShareEnabled(true);`

and treat this as any other Track via `RoomEvent.TrackSubscribed` API

Hi,
you can have a look at the example of the js sdk repo <https://github.com/livekit/client-sdk-js/blob/main/example/sample.ts>

you don’t have to construct the screentracks yourself, calling `setScreenShareEnabled(true)` is enough by itself

thanks Lukas for the quick response, taking a look at the example

love that how it just picks WebAPI for screensharing and takes care of everything

Hey <@U02EU2ZPTQU>

I am trying to handle the screenpublishing for the player who initiated the publishing (in Unity)

```room.LocalTrackPublished += (publication, participant) =&gt;
            {
                if(publication.Source == TrackSource.ScreenShare){
                    ScreenSharingSurface.UpdateTrack(publication.Track);
                }
            };

            room.LocalTrackUnPublished += ( publication, participant) =&gt;
            {
                if(publication.Source == TrackSource.ScreenShare){
                    publication.Track.Detach();
                }
            };```

The `LocalTrackUnPublished` callback is throwing the following compile error

```Assets/Scripts/GameManager.cs(75,18): error CS1061: 'Room' does not contain a definition for 'LocalTrackUnPublished' and no accessible extension method 'LocalTrackUnPublished' accepting a first argument of type 'Room' could be found (are you missing a using directive or an assembly reference?)```

I want to hide the screen once the participant stop sharing their screen

<@U04AGSL3X39> Did you correctly import the LiveKit namespace ?

Or maybe it seems like there are multiple definitions of `Room`

because if i remove that line, as in the pastebin, codecompiles

let me run the rest of the code and double check that `room.LocalTrackPublished` is working as intended

<https://livekit.github.io/client-sdk-unity-web/api/LiveKit.Room.LocalTrackUnpublishedDelegate.html>

is it just a typo `LocalTrackUnpublished` instead of `LocalTrackUnPublished` ?

fwiw, the docs page on LiveKit docs is one of the best docs i have seen

i was able to figure out a lot out by clicking around

Hi,
this is something we have on our list!
The way it will most likely work is similar to how you can add custom webaudio nodes for remote audio tracks right now (if the experimental webaudio feature is enabled). We just haven’t gotten around adding a similar path for the publishing side (local audio tracks) yet

Definitely looking forward to it! :slightly_smiling_face:

Does anybody has a hint for a workaround at the moment? Maybe on system level for macOS and windows?

time="2022-11-23T16:45:45Z" level=info msg="Change state: From = &lt;Unknown&gt;, To = NotConnected(Server)" state="NotConnected(Server)" stream_id=0
time="2022-11-23T16:45:45Z" level=info msg=Connect state="NotConnected(Server)" stream_id=0
time="2022-11-23T16:45:45Z" level=info msg="Set win ack size: Size = 2147483647" state="NotConnected(Server)" stream_id=0
time="2022-11-23T16:45:45Z" level=info msg="Set peer bandwidth: Size = 786432, Limit = 0" state="NotConnected(Server)" stream_id=0
time="2022-11-23T16:45:45Z" level=info msg="Stream Begin: ID = 0" state="NotConnected(Server)" stream_id=0
time="2022-11-23T16:45:45Z" level=info msg="Connect: ResponseBody = &amp;message.NetConnectionConnectResult{Properties:message.NetConnectionConnectResultProperties{FMSVer:\"GO-RTMP/0,0,0,0\", Capabilities:31, Mode:1}, Information:message.NetConnectionConnectResultInformation{Level:\"status\", Code:\"NetConnection.Connect.Success\", Description:\"Connection succeeded.\", Data:amf0.ECMAArray{\"type\":\"go-rtmp\", \"version\":\"master\"}}}" state="NotConnected(Server)" stream_id=0
time="2022-11-23T16:45:45Z" level=info msg=Connected state="NotConnected(Server)" stream_id=0
time="2022-11-23T16:45:45Z" level=info msg="Change state: From = NotConnected(Server), To = Connected(Server)" state="Connected(Server)" stream_id=0
time="2022-11-23T16:45:45Z" level=info msg="Handle WinAckSize: Msg = &amp;message.WinAckSize{Size:786432}" state="Connected(Server)" stream_id=0
time="2022-11-23T16:45:45Z" level=info msg="Stream creating...: &amp;message.NetConnectionCreateStream{}" state="Connected(Server)" stream_id=0
time="2022-11-23T16:45:45Z" level=info msg="Change state: From = &lt;Unknown&gt;, To = Inactive(Server)" state="Inactive(Server)" stream_id=1
time="2022-11-23T16:45:45Z" level=info msg="Stream created...: NewStreamID = 1" state="Connected(Server)" stream_id=0
time="2022-11-23T16:45:45Z" level=info msg="Player is comming: &amp;message.NetStreamPlay{CommandObject:interface {}(nil), StreamName:\"\", Start:-2000}" state="Inactive(Server)" stream_id=1
time="2022-11-23T16:45:45Z" level=info msg="Player accepted" state="Inactive(Server)" stream_id=1
time="2022-11-23T16:45:45Z" level=info msg="Change state: From = Inactive(Server), To = Play(Server)" state="Play(Server)" stream_id=1
time="2022-11-23T16:45:49Z" level=info msg="Server closed"
{"level":"info","ts":1669221949.5405855,"logger":"ingress","caller":"rtmp/server.go:286","msg":"closing ingress RTMP session","nodeID":"NE_aSPrT7djpb7R"}
[4:51 PM] All ingresses created never change state from inactive:
[4:51 PM] +-----------------+--------------+--------------+---------------+-------------------+-------+
|  INGRESSID  |  NAME  | STREAMKEY |   URL   |   STATUS   | ERROR |
+-----------------+--------------+--------------+---------------+-------------------+-------+
| IN_4YMFeD27tWLc | ingress-name | Lh8aoyS4bABm | /Lh8aoyS4bABm | ENDPOINT_INACTIVE |   |
| IN_TwJ6jDpUzUSP | ingress-name | nb7kynmhXsGn | /nb7kynmhXsGn | ENDPOINT_INACTIVE |   |
| IN_yCQHNQv87Bzn | ingress-name | qAMUQuajHQhK | /qAMUQuajHQhK | ENDPOINT_INACTIVE |   |
| IN_nuondH2eKtuY | ingress-name | Ahe7L8duLbsn | /Ahe7L8duLbsn | ENDPOINT_INACTIVE |   |
| IN_J88jn5FPFXsD | ingress-name | Wwr2UwHcnKvh | /Wwr2UwHcnKvh | ENDPOINT_INACTIVE |   |
| IN_nWiYbRKzPVJE | ingress-name | jgPc3bN8McQV | /jgPc3bN8McQV | ENDPOINT_INACTIVE |   |
+-----------------+--------------+--------------+---------------+-------------------+-------+

Can you paste in the ingress request that you're sending?

ingress-audio

ingress-name

ingress-video

What rtmp url / stream key are you using?

Also, the logs above mention that the peer is attempting to play, not publish. What is the RTMP client? How is it being used?

We have tested several diferent ingresses with diferent names and respective stream keys. Currently we are using ffmpeg to stream h264/aac HD rtmp  into the ingress. Is there any specifics that the pyblisher should be compliant?

But again, what URL are you using? This may or may not be the only issue, but you need to make sure that the URL includes an application name

The fact ffmpeg attempts to play the url instead of publishing points to a setup issue with ffmpeg

Can't tell more without the URL / command line

You may already be aware of this, but this basic instructions should work: <https://ottverse.com/rtmp-streaming-using-ffmpeg-tutorial/>

In this example "show" is the application name. While some rtmp libraries seem to work without one, having an application name is part of the RTMP spec and ffmpeg requires one

so we are sending to <http://rtmp.xxxxxxxxxxxxx.com:1935/X5DBoBPXSPhj|rtmp.xxxxxxxxxxxxx.com:1935/X5DBoBPXSPhj>

Right, you need an application name in your URL

You should set the `rtmp_base_url`to <http://rtmp.xxxxxxxxxxxxx.com:1935/app_name|rtmp.xxxxxxxxxxxxx.com:1935/app_name> in the livekit conf if you want the URL reported above to be valid

There is also no real standard about how to represent rtmp URLs. In the first release, we've been using <rtmp://server/app_name/stream_key> as ffmpeg expects. We have an unreleased change where the URL is <rtmp://server/app_name> and <rtmp://server/app_name/stream_key|stream_key> is an extra field, as OBS and most other services use

OK, Using OBS it works well, is there a way to do it with ffmpeg? so we could do:
<http://rtmp.xxxxxxxxxxxxx.com:1935/app_name/&lt;streamID|rtmp.xxxxxxxxxxxxx.com:1935/app_name/&lt;streamID>&gt;

It should be working with ffmpeg as well provided proper pipeline setup and providing an app_name. Have you tried a very basic pipeline as described in the website above?

We found the issue… it was a problem between the keyboard and the chair :slightly_smiling_face:

the ingress is re-encoding the stream, is there a way to control the quality of this encoding?

or to just make a copy of the input to the output. Using gtreamer is adding additional delay and one more encoding step, so less quality

The encoding parameters are port of the create/update ingress request

can you please share the syntax for that config?

The protocol definition is always the best reference: <https://github.com/livekit/protocol/blob/main/livekit_ingress.proto>

Actual syntax will depend on the language you are using.

Regarding disabling transcoding, that's something that we may allow in the future, but there are so many way to get these wrong in a way that would affect functionality and performance that we'd like to be sure there is a real use case first, and that the service is stable enough first

This would also prevent PLIs, so join time and recovery from packet loss would be impacted

does it mean that on the json file used to create the Ingress we can define the diferent output streams?

Are you using the cli to create the ingress?

so yes, you would add it to the request json

I don't have one handy right now. I'll try to put something together when I have some time. But the proto -&gt; json translation is fairly mechanical and documented

For reference <https://developers.google.com/protocol-buffers/docs/proto3#json>

and the protobuf is here <https://github.com/livekit/protocol/blob/main/livekit_ingress.proto#L20>

Thanks for the help. We managed to make it work with live feeds.

Can you include the request that you've made?

It appears that the Egress container isn't able to connect to our default template, hosted at `<https://egress-composite.livekit.io>`. Which environment are you running this in? Is it able to connect out to the public internet?

<@U01KZ61GV5Z> I was able to find out the problem with my system from the question you asked.
Thank you so much!!

We haven't seen any reports of this. Which browser/OS/microphone are you using?

AGC is a feature of microphones, so it could be hardware dependent.

Ok. I checked with the measures MacOS will give me in the preference pane and you are correct. It is the same.
Thanks! We will switch from Jitsi to Livekit cloud. Looking good!

Awesome! glad this is working for you! Let us know if we can help with anything else.

Hey Dennis, take a look at <https://github.com/livekit/meet/blob/main/components/PreJoin.tsx|PreJoin> example. Basically, before the user connects to the session, you'd need to remember their preferred deviceIds in your component. Then pass it to the Room component once a user connects.

Thanks <@U01KZ61GV5Z> for answering.

Maybe I’m blind, but in that example is no audio output device used or changeable, right?

Hey Dennis, you are not.. Handling audio output should be similar though (persisting the state and setting it once the user joined the room).

Am I misunderstanding what you are looking to do?

How can I get and change the output device (for local tracks) while NOT being in a room?

within a browser you (currently) do not have the ability to set a general audio output device from js. The output device will always be tied to existing audio elements/streams.
What <@U01KZ61GV5Z> is suggesting to let users choose a desired output device ahead of time, and once you have your room set up, set that user preference on the room.

So I can’t test the chosen output device before joining a room?

you can in theory, you just have to actually create an audio track, attach it to an audio element and set the desired device there, although you are right, our APIs currently do not support that usecase very well, it would be more low level.

Thanks  :pray: <@U02EU2ZPTQU> 
I think that was/is my question.

Do you know how to do it even it is outside of scope currently of your library?

Are there plans so support that because I think that is not a edge case scenario “testing my chosen output device before joining a room”?
If you don’t have plans to integrate it or I’m not able to create a pull request to do that (also an option) maybe documenting that low level way is also worth it somewhere.

In order to prevent loopbacks, I think most of the applications around don’t actually use the mic input to test output devices, but some pre-recorded sound to play back via the selected output.
A rather complete example that’s more low level would be this one: <https://webrtc.github.io/samples/src/content/devices/multi/>

Thank you very much :slightly_smiling_face:
I will implement this and test it. Really cool!Thanks :pray:

I still think it would be useful for your users to either implement something like this in the/an example and/or document it somewhere.
Such a feature always comes more or stands out you so that one has a better UX.

It's the former. The audioLevel is coming from the server, which is updated every 500ms. It's useful for somethings, but probably not fast enough to power an animated audio-level widget.

It's probably better to analyze the stream locally in that case.

You mean analyzing the local and remote streams locally? Sounds interesting :+1:
How is that possible, do you have some code good example, links or other hints?

Here are my code snippets for a very nice vu meter. You can attach it to any stream.

```			// setup an audio analyzer
			this.audioContext = new window.AudioContext;
			this.analyser = this.audioContext.createAnalyser();
			this.analyser.fftSize = 32; // minimum
			this.analyser.maxDecibels = 60;
			this.analyser.maxDecibels = 20;```

```onLocalTrackPublished(pub: LocalTrackPublication, participant: LocalParticipant) {
		
	
		if (pub.kind === 'audio') {
			// connect the stream to an analyzer
			let stream = pub.track?.mediaStream;
			if (stream &amp;&amp; this.audioContext) {

				let source = this.audioContext?.createMediaStreamSource(stream);
				source?.connect(analyser);
			}
		}```


Then setup a timer.
```this.timer = window.setInterval(() =&gt; {
				if (this.analyser &amp;&amp; this.analyser.numberOfInputs &gt; 0) {
					let frequencyData = new Uint8Array(1);
					this.analyser.getByteFrequencyData(frequencyData);
					let volume=frequencyData[0] / 1.5;
					
					this.onLocalAudioLevel(volume); // do some graphics stuff with this value
				}```

Thanks you <@U04BX1191BR> :slightly_smiling_face: :pray: 

PS: I'm using createLocalAudioTrack/createLocalVideoTrack (not sure if related or not)

hey boris,
it should be enough to simply call `room.disconnect()` without all the other cleanup methods you’re calling before.
the disconnect method does all the things you are doing there internally in the right order.
Does that help?

Hi Lukas, thans for your help, but the result is the same.
Here are livekit logs :
```
livekit-client.esm.mjs?23b0:24394 room event connectionStateChanged {event: 'connectionStateChanged', args: Array(1)}
livekit-client.esm.mjs?23b0:20722 connecting to <ws://localhost:7880/rtc?access_token=...auto_subscribe=1&amp;sdk=js&amp;version=1.5.0&amp;protocol=8&amp;adaptive_stream=1&amp;network=wifi>
livekit-client.esm.mjs?23b0:20794 ping config {timeout: 20, interval: 10}
livekit-client.esm.mjs?23b0:21132 clearing ping interval
livekit-client.esm.mjs?23b0:21125 start ping interval
livekit-client.esm.mjs?23b0:23372 connected to Livekit Server edition: 0, version: 1.3.1, protocol: 8, region: , nodeId: ND_SvB0B7aW, debugInfo: 
livekit-client.esm.mjs?23b0:24394 room event signalConnected {event: 'signalConnected', args: Array(0)}
livekit-client.esm.mjs?23b0:22677 received server offer {RTCSdpType: 'offer', signalingState: 'stable'}
livekit-client.esm.mjs?23b0:22121 setting munged local description
livekit-client.esm.mjs?23b0:20855 sending answer
livekit-client.esm.mjs?23b0:22601 primary PC state changed connecting
livekit-client.esm.mjs?23b0:22601 primary PC state changed connected
livekit-client.esm.mjs?23b0:19653 updating track subscription permissions {allParticipantsAllowed: true, participantTrackPermissions: Array(0)}
livekit-client.esm.mjs?23b0:24394 room event connectionStateChanged {event: 'connectionStateChanged', args: Array(1)}
livekit-client.esm.mjs?23b0:24394 room event connected {event: 'connected', args: Array(0)}
livekit-client.esm.mjs?23b0:22282 on data channel 1, _reliable
livekit-client.esm.mjs?23b0:22282 on data channel 3, _lossy
livekit-client.esm.mjs?23b0:22039 starting to negotiate
livekit-client.esm.mjs?23b0:22121 setting munged local description
livekit-client.esm.mjs?23b0:20846 sending offer RTCSessionDescription {type: 'offer', sdp: 'v=0\r\no=- 5562703927248534467 2 IN IP4 127.0.0.1\r\ns…le\r\na=sctp-port:5000\r\na=max-message-size:262144\r\n'}
livekit-client.esm.mjs?23b0:22646 received server answer {RTCSdpType: 'answer', signalingState: 'have-local-offer'}
livekit-client.esm.mjs?23b0:22628 secondary PC state changed connecting
livekit-client.esm.mjs?23b0:22628 secondary PC state changed connected
livekit-client.esm.mjs?23b0:22688 received trackPublishedResponse {cid: 'd6ddd03e-e2ef-4896-b50f-7afd565dcc4b', track: {…}}
livekit-client.esm.mjs?23b0:20315 publishing audio with encodings {encodings: Array(1), trackInfo: {…}}
livekit-client.esm.mjs?23b0:24394 room event localTrackPublished {event: 'localTrackPublished', args: Array(2)}
livekit-client.esm.mjs?23b0:22039 starting to negotiate
livekit-client.esm.mjs?23b0:22121 setting munged local description
livekit-client.esm.mjs?23b0:20846 sending offer RTCSessionDescription {type: 'offer', sdp: 'v=0\r\no=- 5562703927248534467 3 IN IP4 127.0.0.1\r\ns…6ddd03e-e2ef-4896-b50f-7afd565dcc4b\r\na=rtcp-mux\r\n'}
livekit-client.esm.mjs?23b0:22646 received server answer {RTCSdpType: 'answer', signalingState: 'have-local-offer'}
livekit-client.esm.mjs?23b0:17126 silence detected on local audio track
livekit-client.esm.mjs?23b0:18829 using video encoding {maxBitrate: 1700000, maxFramerate: 30}
livekit-client.esm.mjs?23b0:22688 received trackPublishedResponse {cid: 'c544df10-f912-452f-ba7a-7a80d7ded7a5', track: {…}}
livekit-client.esm.mjs?23b0:20315 publishing video with encodings {encodings: Array(3), trackInfo: {…}}
livekit-client.esm.mjs?23b0:22767 get capabilities {codecs: Array(8), headerExtensions: Array(11)}
livekit-client.esm.mjs?23b0:24394 room event localTrackPublished {event: 'localTrackPublished', args: Array(2)}
livekit-client.esm.mjs?23b0:22039 starting to negotiate
livekit-client.esm.mjs?23b0:22121 setting munged local description
livekit-client.esm.mjs?23b0:20846 sending offer RTCSessionDescription {type: 'offer', sdp: 'v=0\r\no=- 5562703927248534467 4 IN IP4 127.0.0.1\r\ns…id:h send\r\na=rid:f send\r\na=simulcast:send q;h;f\r\n'}
livekit-client.esm.mjs?23b0:22646 received server answer {RTCSdpType: 'answer', signalingState: 'have-local-offer'}
livekit-client.esm.mjs?23b0:24394 room event recordingStatusChanged {event: 'recordingStatusChanged', args: Array(1)}
livekit-client.esm.mjs?23b0:24394 room event connectionQualityChanged {event: 'connectionQualityChanged', args: Array(2)}
livekit-client.esm.mjs?23b0:23474 disconnect from room {identity: '{"browserId":"browser-ii40a72c-74d0-4dec-bafd-0979…e.localhost","requestId":"9thYFmG6ZMiireZ82cy2X"}'}
livekit-client.esm.mjs?23b0:21132 clearing ping interval
livekit-client.esm.mjs?23b0:20414 unpublishing track {track: LocalAudioTrack, method: 'unpublishTrack'}
livekit-client.esm.mjs?23b0:24394 room event localTrackUnpublished {event: 'localTrackUnpublished', args: Array(2)}
livekit-client.esm.mjs?23b0:20414 unpublishing track {track: LocalVideoTrack, method: 'unpublishTrack'}
livekit-client.esm.mjs?23b0:24394 room event localTrackUnpublished {event: 'localTrackUnpublished', args: Array(2)}
livekit-client.esm.mjs?23b0:24394 room event connectionStateChanged {event: 'connectionStateChanged', args: Array(1)}
livekit-client.esm.mjs?23b0:24394 room event disconnected {event: 'disconnected', args: Array(1)}

----- background/foreground

livekit-client.esm.mjs?23b0:16830 visibility changed, is in Background: false
livekit-client.esm.mjs?23b0:16833 track needs to be reaquired, restarting microphone
livekit-client.esm.mjs?23b0:16766 restarting track with constraints {echoCancellation: true, noiseSuppression: true, deviceId: 'default', autoGainControl: true}
livekit-client.esm.mjs?23b0:16830 visibility changed, is in Background: false
livekit-client.esm.mjs?23b0:16833 track needs to be reaquired, restarting camera
livekit-client.esm.mjs?23b0:16766 restarting track with constraints {width: 1280, height: 720, encoding: {…}, deviceId: '7a3f713abf7376b61e1d61909b7784f0e712a58ef701920a7fec65fcf932886f'}
livekit-client.esm.mjs?23b0:16794 re-acquired MediaStreamTrack
livekit-client.esm.mjs?23b0:17126 silence detected on local audio track```

Hi <@U02EU2ZPTQU>, sorry to ping you but I'm still facing this issue... do you see anything wrong in these logs ? :confused:

hi boris,
nothing seems out of the ordinary with those logs. What I could imagine is that you’re creating local track instances that you never published?
That way `localParticipant` wouldn’t know about them and the event listeners might not be cleared.
It’d be great if you could create a minimal reproduction based on the sample in `client-sdk-js/example` repo to confirm.

:ok_hand: the two created tracks seems to be well published, but I will create the reproduction test and come back to you, thanks

Ok, I found the reason. It's because I was publishing the mediaStreamTrack (of the LocalVideoTrack) and not the LocalVideoTrack directly

ah, great to hear that you figured it out!

I’m glad you raised this issue, because it does indicate that cleanup of unpublished tracks isn’t exactly perfect right now. Will think about how to avoid this scenario alltogether!

LiveKit Log:
```2022-11-25T13:44:27.621Z	INFO	livekit	service/roommanager.go:257	starting RTC session	{"room": "test-room", "nodeID": "ND_zutQo5Hs", "participant": "ben-citrix", "sdk": "JS", "sdkVersion": "1.3.2", "protocol": 8}
2022-11-25T13:44:27.622Z	INFO	livekit	rtc/room.go:297	new participant joined	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "pID": "PA_YcFWicFGME5e", "participant": "ben-citrix", "protocol": 8, "options": {"AutoSubscribe":true}}
2022-11-25T13:44:27.622Z	DEBUG	livekit	rtc/participant.go:1124	updating participant state	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "state": "JOINED"}
2022-11-25T13:44:27.622Z	DEBUG	livekit	rtc/participant.go:683	SetMigrateState	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "state": "MIGRATE_STATE_COMPLETE"}
2022-11-25T13:44:27.622Z	DEBUG	livekit	rtc/room.go:246	participant state changed	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "state": "JOINED", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "oldState": "JOINING"}
2022-11-25T13:44:27.622Z	INFO	livekit	service/rtcservice.go:242	new client WS connected	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "remote": false, "connID": "CO_PJHJJpwWfhGd"}
2022-11-25T13:44:27.623Z	INFO	livekit	rtc/transport.go:438	ice gathering state change	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "transport": "SUBSCRIBER", "state": "gathering"}
2022-11-25T13:44:27.623Z	INFO	livekit	rtc/participant.go:1143	sending offer	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "transport": "SUBSCRIBER"}
2022-11-25T13:44:27.623Z	INFO	livekit	rtc/transport.go:438	ice gathering state change	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "transport": "SUBSCRIBER", "state": "complete"}
2022-11-25T13:44:27.686Z	INFO	livekit	rtc/participant.go:419	received answer	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "transport": "SUBSCRIBER"}
2022-11-25T13:44:27.686Z	INFO	livekit	rtc/transport.go:472	ice connection state change	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "transport": "SUBSCRIBER", "state": "checking"}
2022-11-25T13:44:42.690Z	DEBUG	livekit	service/rtcservice.go:283	exit ws read loop for closed connection	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "remote": false, "connID": "CO_PJHJJpwWfhGd"}
2022-11-25T13:44:42.690Z	INFO	livekit	service/rtcservice.go:220	finishing WS connection	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "remote": false, "connID": "CO_PJHJJpwWfhGd"}
2022-11-25T13:44:42.690Z	INFO	livekit	service/roommanager.go:443	RTC session finishing	{"participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "room": "test-room", "roomID": "RM_DqUGNhXsvmQg"}
2022-11-25T13:44:50.475Z	INFO	livekit	routing/localrouter.go:215	memstats	{"mallocs": 504023, "frees": 469974, "m-f": 34049, "hinuse": 21184512, "halloc": 15125888, "frag": 6058624}
2022-11-25T13:45:02.792Z	INFO	livekit	rtc/transport.go:472	ice connection state change	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "transport": "SUBSCRIBER", "state": "failed"}
2022-11-25T13:45:02.792Z	INFO	livekit	rtc/transport.go:485	peer connection state change	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "transport": "SUBSCRIBER", "state": "failed"}
2022-11-25T13:45:02.792Z	INFO	livekit	rtc/participant_signal.go:198	closing signal connection	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false}
2022-11-25T13:45:02.792Z	INFO	livekit	rtc/transport.go:1357	ice candidates	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "transport": "SUBSCRIBER", "lc": ["udp4 host X.X.X.X:56430", "tcp4 host X.X.X.X:7881", "udp4 host 172.17.0.1:56322", "tcp4 host 172.17.0.1:7881"], "rc": ["candidate:2503476600 1 udp 2122260223 10.97.236.34 64233 typ host generation 0 ufrag NX0x network-id 1", "candidate:1799031094 1 udp 2122194687 10.94.250.71 64234 typ host generation 0 ufrag NX0x network-id 2", "candidate:3686529416 1 tcp 1518280447 10.97.236.34 9 typ host tcptype active generation 0 ufrag NX0x network-id 1", "candidate:632878534 1 tcp 1518214911 10.94.250.71 9 typ host tcptype active generation 0 ufrag NX0x network-id 2"], "lc (filtered)": [], "rc (filtered)": []}
2022-11-25T13:45:17.792Z	INFO	livekit	rtc/participant.go:1271	closing disconnected participant	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false}
2022-11-25T13:45:17.793Z	INFO	livekit	rtc/participant.go:538	participant closing	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "sendLeave": true, "reason": "PEER_CONNECTION_DISCONNECTED"}
2022-11-25T13:45:17.793Z	INFO	livekit	rtc/participant_signal.go:180	could not send message to participant	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "message": "*livekit.SignalResponse_Leave", "error": "no response sink"}
2022-11-25T13:45:17.793Z	DEBUG	livekit	rtc/participant.go:1124	updating participant state	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "state": "DISCONNECTED"}
2022-11-25T13:45:17.793Z	DEBUG	livekit	rtc/transport.go:1203	leaving events processor	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "transport": "PUBLISHER"}
2022-11-25T13:45:17.793Z	DEBUG	livekit	rtc/room.go:246	participant state changed	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "state": "DISCONNECTED", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "oldState": "JOINED"}
2022-11-25T13:45:17.793Z	DEBUG	livekit	rtc/transport.go:1203	leaving events processor	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "transport": "SUBSCRIBER"}
2022-11-25T13:45:17.793Z	INFO	livekit	rtc/transport.go:485	peer connection state change	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "transport": "PUBLISHER", "state": "closed"}
2022-11-25T13:45:17.793Z	INFO	livekit	rtc/room.go:403	closing participant for removal	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "pID": "PA_YcFWicFGME5e", "participant": "ben-citrix"}
2022-11-25T13:45:17.793Z	INFO	livekit	rtc/participant.go:538	participant closing	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "sendLeave": true, "reason": "STATE_DISCONNECTED"}
2022-11-25T13:45:17.793Z	INFO	livekit	rtc/transport.go:438	ice gathering state change	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "transport": "SUBSCRIBER", "state": "closed"}
2022-11-25T13:45:17.793Z	INFO	livekit	rtc/transport.go:472	ice connection state change	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "transport": "SUBSCRIBER", "state": "closed"}
2022-11-25T13:45:17.793Z	INFO	livekit	rtc/transport.go:485	peer connection state change	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg", "participant": "ben-citrix", "pID": "PA_YcFWicFGME5e", "remote": false, "transport": "SUBSCRIBER", "state": "closed"}
2022-11-25T13:45:20.476Z	INFO	livekit	routing/localrouter.go:215	memstats	{"mallocs": 505033, "frees": 474630, "m-f": 30403, "hinuse": 21028864, "halloc": 14804736, "frag": 6224128}
^C2022-11-25T13:45:20.665Z	INFO	livekit	server/main.go:249	exit requested, shutting down	{"signal": "interrupt"}
2022-11-25T13:45:20.665Z	INFO	livekit	rtc/room.go:556	closing room	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg"}
2022-11-25T13:45:20.665Z	INFO	livekit	service/roommanager.go:110	deleting room state	{"room": "test-room"}
2022-11-25T13:45:20.665Z	INFO	livekit	service/roommanager.go:411	room closed	{"room": "test-room", "roomID": "RM_DqUGNhXsvmQg"}```

have you had a look at the output of <https://livekit.io/connection-test> ?
also you can try to pass `iceTransportPolicy: 'relay'` as a connection option in the rtcConfig to force usage of your turn server

Thanks <@U02EU2ZPTQU> for responding.  In the code, though, I don’t see a way to set the `iceTransportPolicy` like you mentioned.  Here is the `RTCConfig`:
```type RTCConfig struct {
	UDPPort                 uint32           `yaml:"udp_port,omitempty"`
	TCPPort                 uint32           `yaml:"tcp_port,omitempty"`
	ICEPortRangeStart       uint32           `yaml:"port_range_start,omitempty"`
	ICEPortRangeEnd         uint32           `yaml:"port_range_end,omitempty"`
	NodeIP                  string           `yaml:"node_ip,omitempty"`
	NodeIPAutoGenerated     bool             `yaml:"-"`
	STUNServers             []string         `yaml:"stun_servers,omitempty"`
	TURNServers             []TURNServer     `yaml:"turn_servers,omitempty"`
	UseExternalIP           bool             `yaml:"use_external_ip"`
	UseICELite              bool             `yaml:"use_ice_lite,omitempty"`
	Interfaces              InterfacesConfig `yaml:"interfaces"`
	IPs                     IPsConfig        `yaml:"ips"`
	EnableLoopbackCandidate bool             `yaml:"enable_loopback_candidate"`

	// Number of packets to buffer for NACK
	PacketBufferSize int `yaml:"packet_buffer_size,omitempty"`

	// Throttle periods for pli/fir rtcp packets
	PLIThrottle PLIThrottleConfig `yaml:"pli_throttle,omitempty"`

	CongestionControl CongestionControlConfig `yaml:"congestion_control,omitempty"`

	// allow TCP and TURN/TLS fallback
	AllowTCPFallback *bool `yaml:"allow_tcp_fallback,omitempty"`

	// for testing, disable UDP
	ForceTCP bool `yaml:"force_tcp,omitempty"`
}```
I tried setting it in my yaml file, and it had no effect.

Sorry, I meant on the (js) client side! <https://docs.livekit.io/client-sdk-js/interfaces/RoomConnectOptions.html#rtcConfig|https://docs.livekit.io/client-sdk-js/interfaces/RoomConnectOptions.html#rtcConfig>

Hi <@U02EU2ZPTQU>, I am currently using the livekit-react example for my front end (I’m hosting it, so I can modify it locally).  I’m not a React programmer, so I may be wrong, but it appears to me that it is not using the LiveKit SDK, but rather using URL query parameters to setup the room.  Is there a way that I can easily add the RTC Connection Options in the react example or do I need to go back to square one and create a different front end?

I found the example webpage under the SDK examples directory, so I will use that to test.

<@U04C2CDU5KP> I don’t see the `relay` candidates in the log, so your external turn server might not takes effect (if it is accessible from the client network)

Ok, I’ve been doing a lot more testing and still cannot get LiveKit to work with this particular TURN server.  I was able to compare wireshark results between three cases:
1. LiveKit to external TURN server running inside a company network - doesn’t work
2. LiveKit to external TURN server under my control running on a VM in Google Cloud - works
3. Our company application to the external TURN server running inside the company network - works
When I look at the network traffic in #1, all I see are STUN Binding Requests going from the Livekit server to the TURN server, but no responses or any other traffic.
When I look at the network traffic in #2, I see STUN Binding Requests and Responses, and then I see DTLS traffic between the two servers
When I look at the network traffic in #3, I also see some initial STUN Binding Requests over UDP, but no Responses.  However, after that the communication seems to resort to TCP only and the WebRTC session is established through the TURN server.
My question:  if the TURN server inside the company network has incoming UDP blocked, is there any way for Livekit to establish a session with this server?

The TURN server use udp to communicate with sfu server (livekit), so you can’t use this TURN if it’s udp traffic is blocked. In common case, TURN is used to help client whos udp traffic to webrtc server is blocked while TURN server is open, so client can use the TURN to relay traffic to webrtc server, why are you using a TURN has same network condition with client to establish the session?

&gt; why are you using a TURN has same network condition with client to establish the session?
Because it is a bank that has very strict security policies.

If all UDP traffic to the TURN server is blocked, I think there is no way to force client connect to livekit-server by the TURN. But livekit-server can use `udpmux` to reuse a single port for all udp traffic, if you can open a policy to enable the single &lt;ip&gt;:&lt;port&gt; of livekit-serve, it will success

Ok, I switched gears a bit since trying to work with the corporate TURN server where I have no access to logs was becoming too difficult.  I created a new coturn server running in an Azure VM and my LiveKit server is running inside a Google Cloud VM.  I am having similar issues when trying to establish a WebRTC session using this external TURN server.
• So far, I can only get an external TURN server to work if it is on the same internal network as the LiveKit server (e.g. both VMs are inside Google Cloud)
• In the case that works, in my TURN server logs I see incoming packets for ALLOCATE, CREATE_PERMISSION, and CHANNEL_BIND
• For the Azure TURN case that doesn’t work, in my logs I see incoming packets for ALLOCATE and CREATE_PERMISSION (both marked success), but I never see the CHANNEL_BIND packet.
• In wireshark, I never see the Binding Success Response messages from the LiveKit server to the TURN server when using the Azure VM 
Any ideas on what would prevent the CHANNEL_BIND message?

~Update:  I set `use_external_ip` to `true` and now the Azure TURN seems to be working.  Now I need to try to  run the test again with the bank TURN server to see if it will work now (they are enabling UDP this evening).~  Don’t know why it worked for a short period of time, but now it’s back to not working for the TURN server outside the LiveKit network.  I’m beginning to think what I’m trying to do just won’t work with LiveKit.

If your livekit-server is inside Cloud VM, set `use_external_ip` will provide help to the connection. You can use client outside the bank network to verify your TURN and livekit is working correctly.

What do you think about this <@U01UB0LHTTQ> ?

It does support local recordings, you need to mount a drive to docker (see the docker run command under <https://github.com/livekit/egress#running-locally>). Then you would use `/out/filename.mp4` as filenames for your requests

Noted wit Thanks <@U01UB0LHTTQ> . Good to know that you can attach a volume to local and download the file apart from file storage upload.

I'm more of interest in downloading file to user side browser, may be like user local machine as a feature if that can be supported.
But it seems even in zoom they support it with desktop client only.

<@U045CJPACG1> are you asking for a LiveKit dashboard interface for your users? If so, this is out of scope on our side. You can certainly put one together though!

<@U01KZ0SCDKL> No, it is more like a just download the file to your local machine ( of record capturing) . 

More as of (local file download) - <https://youtu.be/bAZsWx1LuUY|https://youtu.be/bAZsWx1LuUY> ( zoom given this with desktop client only, not native via browser it seems )

we don’t currently support client-side recording, but you could build a way into your app to download a recording after it’s finished by getting the file location from the `egress_ended` web hook

Thank you for the info <@U01UB0LHTTQ>. Will check on this

Spent over 1 hour because of a typo.

`https://{myapp}.livekit&lt;-----.cloud`

ah! oops. I do wish we owned live.cloud though.

Yes! we would like to. It would be nice to ensure devs could still customize themes without having to handle all of the logic.

What are the requirements to render a participants video?

Do you use the room listener to get access to other participants video streams?

Does it include the local participant video stream?

Apologies for bombarding you with questions…

I have a great demo application atm. Although the video track cannot be played with the VideoTrackRenderer. It’s saying the track is not a VideoTrack

```RemoteTrackPublication&lt;RemoteVideoTrack&gt;(sid: TR_VCcPuG2QwvJ3Mz, source: TrackSource.camera)```

```         return VideoTrackRenderer(
                    participant!.videoTracks.first as VideoTrack,
                  );```

Hey,
I recently subscribe to livekit premium and i want to use the egress helm chart in my kubernetes cluster. How can i know the host of my redis server ?
Thanks

<@U03SP6DMWUS> please thread your question please.

in particular, logs and configuration should go into a code block like:
```code and logs go here```

Auto Egress is a room-specific concept. So it'll be valid only for that room.

you will not be able to disable it on that room mid-session

It shouldn't be too bad. Currently we are not focused on it, but it shouldn't be too bad for someone who's familiar with SFUs to create a PR.

basically it'll need to know how to determine if a particular packet contains a keyframe or not. like <https://github.com/livekit/livekit/blob/792349cc56b4e8ad0e3132ad15bf01d6a62a8678/pkg/sfu/buffer/helpers.go#L215|this function> for H.264

You seem to be using MediaStreamTrack events, which we have no control over. I would recommend listening to the <https://docs.livekit.io/client-sdk-js/enums/ParticipantEvent.html|Participant> or <https://docs.livekit.io/client-sdk-js/enums/RoomEvent.html|Room> level event for `TrackMuted`  and `TrackUnmuted`

So your suggestion is to connect to a room but only for the purpose to receive TrackMuted events from the localParticipant?

Because in my current concept I’m not connected to a room at this point in time. It’s a local stage and not using a room to not produce network traffic and costs.

ah I see, before entering the room. In that case `localVideoTrack.on(TrackEvent.Muted, ...)` should work.

can you enable debug logging and see what gets printed out when you call `localVideoTrack.mute()` ?

after setting `setLogLevel(LogLevel.debug)`  I can see the following:
```setting video track muted livekit-client.esm.mjs?dbe3:16812 
setting video track unmuted livekit-client.esm.mjs?dbe3:16812 ```
nothing before that.


but my code does not seem to be executed
``` localVideoTrack.on(TrackEvent.Muted, () =&gt; {
       console.log("localVideoTrack muted")
  })```

Maybe it’s better that I check the github issues and create a bug if there is none, instead of asking here.

Yes, a GH issue would be great. thanks for filing one!

Whenever clients connect to it, it should log a debug entry indicating server information. Currently we are not exposing this information publicly.

you can also look at the startup logs on the server-side

ah, there's a specific zOrder property that we aren't exposing, I'll add that shortly

Should I upgrade react native version after you add?

the react-native npm library? no; our client-sdk-react-native? yes

okay, please let me know once you added. thank you

added. note: zOrder is limited to 0,1,2 on android

no new version is released yet, but should be accessible if you use `npm update`/`yarn upgrade livekit-react-native`

Screenshot 2022-11-28 at 20.12.49.png

Think I've overcome this. I hadn't allowed egress for ports 50000-60000

this isn't possible from NodeJS. currently only the Go SDK could receive media from the room

Okay. Go sdk is suitable for us. How can i do this?