LiveKit Community

It should work via layer 4 SNI. Here's an example of how we use it with caddy

```  layer4:
    servers:
      main:
        listen: [":443"]
        routes:
          - match:
            - tls:
                sni:
                  - "<http://livekit-turn.myhost.com|livekit-turn.myhost.com>"
            handle:
              - handler: tls
              - handler: proxy
                upstreams:
                  - dial: ["localhost:5349"]
          - match:
              - tls:
                  sni:
                    - "<http://livekit.myhost.com|livekit.myhost.com>"
            handle:
              - handler: tls
                connection_policies:
                  - alpn: ["http/1.1"]
              - handler: proxy
                upstreams:
                  - dial: ["localhost:7880"]```
You can add to that `routes` list with your app's domain.

I've tried this with both builds of Caddy (yours and built with the repo's instruction). And in both cases I got strange result: index.html is loaded, but loading of *.css and *.js hangs indefinitely long. If I configure same backend with same certs, but as http app - it loads well ! What could it be, and is there a way to deploy with default http app ?

no, unfortunately you can't easily mix layer4 and http handlers on the same port.

can you try adding the following to your handle section?
```connection_policies:
                  - alpn: ["http/1.1"]```


Thanks, this seems to be helpful, though now traffic stops with Cross-Origin warning, maybe that the issue. Still, what's the minimum to start developing my back-end ? Can I switch TURN off, expose http 7880 and UDP 50-60000, and just specify ws instead of wss ? Will this get me going ?

I'm not sure why you are seeing CORS issues, but don't think that's related to this set up. That's between your web app and backend: <https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS>

you can check out flutter example. it switches camera.

I run into a problem or more of a bug with media transfer. When my Android user creates and joins the room first and then Iphone user joins as remote, android user’s cannot hear or see anything from iphone user.  This only happened a couple of times  but i wonder why?

hey <@U034V68D5SQ>, could you say a bit more about what you’re building and your needs are?

<@U01KZ0SCDKL> Hello, It is like a similar to the Clubhouse app. Users can join the audio chat room, there can be multiple rooms that managed by its creator.

Aha, thanks <@U034V68D5SQ>, I understand better now. There's a few ways to do this, but one such way is:

When a user creates a room, that creates a LiveKit room and attaches information (if applicable) like the topic/subject and description to the room’s metadata. In your interface, on the rooms list screen/page, your API endpoint could use one of the LiveKit server SDKs to query for a list of all the active rooms and display those in your UI.

Is there a particular reason you want the rooms list to be duplicated/mirrored in Firebase?

Thank you very much :grinning:. I have an app that using firebase with flutter webrtc p2p.  firebase has all the data of users and rooms.  I want to move it to the liveKit solution and looking for best and least data duplication implementation

You're welcome <@U034V68D5SQ>! Best (for now, at scale you may need additional functionality, like paging/cursor and sorting/filtering functionality from our server-side room APIs) and least duplicated-data implementation will be what I suggested above.

Another method which could reuse your existing logic would be to use the server SDK to “pre-create” the room. Without looking at your app, I'm assuming on the client, a user creates a room, which hits your Firebase endpoint to actually create a room entry in firestore, then upon success, a user is placed in the “room”.

If this is correct, instead of writing to Firebase, you could create the room via LiveKit server SDK, send back a signed token for that room to the client and have them connect to the room using said token.

To list all the active rooms for other users, you could use the server API, like I mentioned in my previous message.

You could, of course write to Firestore and also create the room server side, or completely maintain your own room and participant manifests and just return LiveKit join tokens granting access to those rooms. I would just be slightly concerned with state mismatch errors or inconsistencies between LiveKit and Firestore.

Hope this helps!

<@U035CJ1GK0F> where are you getting stuck? What would you like to see updated? Which functionality would you like to more sample code for?

<@U01KZ0SCDKL> RoomListner is deprecated. It recommend to use Room.events thats why i ask about to update docs. Can you tell me how to use that?

check out this example here: <https://github.com/livekit/client-sdk-android/blob/main/sample-app/src/main/java/io/livekit/android/sample/CallActivity.kt>

livekit_s21_connect.log

livekit_s20_connect.log

<@U02UKGBNK27>, this sounds really strange. it sounds like a codec compatibility issue. can you try forcing the server down to vp8 to see if publishing works? to do so, add the <https://github.com/livekit/livekit-server/blob/master/config-sample.yaml#L110|following lines> to your config.

Hey <@U01KZ61GV5Z>

We managed to get things working with the following config:

```room:
  enabled_codecs:
    - mime: video/vp8
    - mime: audio/opus```
We tried VP9 as well, but we're currently seeing a lot PLI messages from LiveKit, and can't seem to successfully render video with it. We're hoping to be able to use VP9, so any advice there would be greatly appreciated.

Thanks for everything! :)

thanks for confirming <@U02UKGBNK27>, I'll file a bug for this anyways so we can keep track of this. There must be something about the specific H.264 profile S21 is using that we are not liking. Using VP8 is a workaround, but it'd be great if we can properly handle H.264 from the device

VP9 isn't supported right now, that's also something that's on our roadmap

you should be able to just use it with a bit of work on your end. can you try following <https://developer.apple.com/documentation/swift/imported_c_and_objective-c_apis/importing_swift_into_objective-c|this guide>?

Classes in the Swift library are still not exposed to object-C bridging after encapsulation.

For example :
VideoView, Track, Room class how to  expose it so that it can be exposed to object-C bridge.

Hmmm the needed proguards should automatically be pulled in, I'll recheck if anything else is needed

Do you have any logs of what happens when you try to connect?

Thanks, <@U01NZKTNE1H>. I don't have any logs right now, but I'll try and do some logging.

Sorry, I think the problem is in my code prior to calling LiveKit.

ah, running into issues on my minify enabled build anyways, will look into this

looks like proguard rules weren't being correctly applied to the release for consumption, latest build should have this fixed now

Cool, thanks, <@U01NZKTNE1H> How do I point my gradle to use the latest build with the fix?

Use 0.9.1-SNAPSHOT (refer to the readme for maven repo setup)

If you’re running it via Docker, use detached mode

<@U02SGSET1RT> is there any alternative to docker livekit server? Because I never used docker before so no experience in that.

I use the init-script on DigitalOcean which creates a systemd service. I'm currently on an uptime of weeks on my livekit server.
<https://docs.livekit.io/deploy/vm#deploy-to-a-vm>

I'm using free tier of aws for testing purpose only and my storage is now full, how? I don't even record anything in livekit room.

I'm not super familiar with AWS and how their storage works. Maybe <@U01KZ0SCDKL>, <@U01KZ61GV5Z> or <@U02MAJLGN65> could assist you with that.

You can use docker-compose for this purpose. For a quick example you can have a look here:

<https://github.com/mynaparrot/plugNmeet-install/blob/151c790526ef0df29ecbba9003b9147cb5d3e128/install-files/docker-compose.yaml#L16>

For your case may need only `redis` &amp; `livekit`. Later run `docker-compose up` or as a background ``docker-compose up -d``

<@U02LCP104CQ> i just want to know how livekit data storage works. And which data it save on the server.

would this work with livekit? <https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API/Manipulating_video_using_canvas>

if you can create a media stream, you can just publish the Video track associated with it

localParticipant.publishTrack will accept any `MediaStreamTrack`

That worked fine on the local participant side by doing
```const canvasStream = videoCanvasRef.current.captureStream(25);
p.publishTrack(canvasStream.getVideoTracks()[0]);```
on the other participants end the video is super slow, like 1fps, am i missing anything?

The size of canvas matter here. You'll require to adjust canvas size or send a low resolution. We've also implemented similar for virtual background. For quick reference:

<https://github.com/mynaparrot/plugNmeet-client/blob/1b1c5b2c076cd7b42d789614601c08c05e481401/src/components/footer/icons/webcam.tsx#L172>

<https://github.com/mynaparrot/plugNmeet-client/blob/1b1c5b2c076cd7b42d789614601c08c05e481401/src/components/footer/icons/webcam.tsx#L200>

<https://github.com/mynaparrot/plugNmeet-client/blob/1b1c5b2c076cd7b42d789614601c08c05e481401/src/components/footer/icons/webcam.tsx#L236>

<@U02LCP104CQ> I'm noticing aliasing effect on the canvas with straight lines, have you faced the same?

I tried to use this method for live streaming.
But it’s not quite robust.
So we decided to use server streaming.
When you use virtual screen with browser and capture it with ffmpeg -&gt; rtmp

<@U02QL81L42H> Thanks a lot, can you elaborate more? did you mean to pass regular camera stream to the server and add the virtual background there? how did that integrate with livekit?

Screen Shot 2022-03-20 at 2.59.44 PM.png

looking into google meet, they use seperate video elements for each participant, no canvas similar to livekit implementation, the thing is this approach works great if you have control over the host UI (room) but if you want to do rtmp out to FB or YT you lose all customization, wondering if anyone got this working. this = ui customization + rtmp out

so imagine you have a viewer link to your room

and this link is opened on server on virtual screen as regular person

I thought you want stream to some destination

Yup, i want stream to YT and FB, not virtual background

I want to have a frame (not a virtual background) around my video, and maybe combine 2 video streams from 2 users together and stream the entire thing to facebook for example

Ohh, <@U02QL81L42H> are you saying to use livekit recorder <https://github.com/livekit/livekit-recorder> to record my entire room and do any customization as html overlays?

<@U02UMFKPC6Q> you can just build your own recorder template. i.e. see <https://github.com/livekit/livekit-recorder/tree/main/web|Building your own templates> section

<@U01KZ61GV5Z> thank you, that’s a much better approach, essentially we leave the user camera feed alone and stitch everything together using html elements then record the entire page using the recorder, that’s endless possibilities :pray:

What OS/Browser are you using? if the label did not change, it means the acquisition of the device has failed. Setting a deviceId signals we "desire" the device. When it couldn't acquire those constraints, it'll fallback to another device that it can acquire

On windows, this can happen if another process is already using the camera

MacOS / Chrome. I found the issue because of what you said about the constraints. Device didn’t support `VideoPresets.h720.resolution` which was set on the `videoCaptureDefaults` when creating a new room. Thanks a lot for helping :)

the SDK supports Go 1.16+. The error is regarding <https://pkg.go.dev/log#Default|this function>

this looks right to me, but I’m not super familiar with argo tunnel. are you able to connect directly to 7880 on your device, without argo?

that might be why! we are only listening on ipv4 interfaces

Thanks for the inputs. The issue was with the route on the argo tunnel. For anyone else who is trying to integrate argo tunnels or ending their TLS on Cloud flare, here are the steps

1. Add a route to the tunnel 
```cloudflared tunnel  route dns -f {tunnel-name} {route-name}```
2. Add a rule in the argo tunnel config
```- hostname: {routename}
    service: <http://localhost:2053>```
I am using 2053 as the main TCP port because Argo tunnel proxies that directly and does not do that for 7880

hey <@U02UKGBNK27>, thanks for the detailed description on the issues you’re seeing, it’s very helpful! This _sounds_ like a congestion control issue. To narrow it down, here’s the first thing to try:

Please set `allow_pause` to `false` in your LiveKit server config and let’s see if that resolves the issue. Here’s the spot:
<https://github.com/livekit/livekit-server/blob/cf63da2e64379fbc91f8e67bdd2981893c48744e/config-sample.yaml#L56>

Hey Matthew, a few questions

1. How many videos tiles is each client pulling down at the same time?
2. Are you publishing with simulcast? (it's default on, but could be disabled)
3. what resolution/bitrate are you publishing at?
The congestion controller by default would "pause" streams that couldn't fit within the detected downstream bandwidth of the client. I think that's what you are seeing.

Screen Shot 2022-03-22 at 12.50.10 AM.png

Rtmp urls should always be &lt;server url&gt;/&lt;stream key&gt; like in the twitch example, however the recorder doesn't currently support rtmps (which I believe Facebook requires). I'll look into supporting it

<@U01UB0LHTTQ> thanks so much, hope we support it soon since Facebook is very much needed for our solution :pray::pray:

I'm pretty sure there is no built in way to password protect a room, you could use the server SDK to create one yourself though before generating the token for the user.

as William said.. this is an application-level protection that you would implement. You should not issue a token to a user unless they meet your authentication requirements

hmm currently there isn't.. it would be good to expose that information via server APIs though.

I checked that, but I think the `GetParticipant().Tracks` represents the tracks that participant is publishing, not subscribed to

If it doesn't work on the server side, we can do it on the client side as well. Just that it'll be better to have it on the server side :slightly_smiling_face:

I just meant we should probably add that feature :)

Ah right, gotcha. Cool :slightly_smiling_face:

Hi <@U035UAPSUJ3>, we don’t support this today. You can, however, persist chat messages yourself in Firestore or using another service along with one of our server SDKs.

Hello guys, when user joined the call how can I show like this green indicator. is this possible from flutter ? <https://i.stack.imgur.com/9XogR.png>

What are you trying to accomplish? To create a token, you should follow these <https://docs.livekit.io/guides/access-tokens#creating-a-token|steps here>.

If joining to the room from Go SDK, see <https://docs.livekit.io/guides/room/connect#connecting-to-a-room|connecting>

Room object does come with an unique session id, it's `Room.SID` field

Yep, I'm creating token as in mentioned steps above, but what should I pass as 'room', livekit.Room.Name ?

That VideoGrant.Room field should really be RoomName then

Have a look here: <https://github.com/livekit/server-sdk-go#token-creation>
that will be room unique id/name

That's what I'm trying to implement, but that 'room' variable should be roomName then, since it is not of  livekit.Room type

It should be supported.. but we'll double check on that. Which version of the SDK are you using?

Hey Luis, confirmed that it's working for screenshare tracks too

Hey David, thanks so much for confirming this! In this case, something in my implementation must be wonky.. What‘s your go-to method for debugging state related to adaptive stream? Is there a way to use the sdk for more detailed stats? (I‘d say the exposed Prometheus metrics seem to be a little too coarse-grained for such cases. Being able to monitor each participants bandwidth usage on a pub/sub per track level would be very helpful for optimization purposes..)

for sure! you can use track level metrics for this. We do expose the <https://docs.livekit.io/client-sdk-js/classes/track.html#currentbitrate|current bitrate> for each track. On Local tracks, it'll report send bitrate

you can also check webrtc-internals for details on what it's doing

Thanks for the hints <@U01KZ61GV5Z>! I think I may have found the actual issue: As long as a track has not been rendered yet, `updateVisibility()` is never triggered and therefore the initial state (enabled) remains active until the track has been attached and then hidden. In our use case, screenshares (as well as video streams, by the way) need to be "prestaged", before they are shown to all participants – and thus having all tracks enabled until first rendering kinda defeats the purpose of adaptiveStream.
Do you have an idea how this could be solved? Manually disabling the track on subscription is not allowed when adaptiveStream is enabled, so that workaround doesn't work as well – and it's probably not desirable anyway, as it could lead to race conditions.
What would you think about initially disabling RemoteTrackPublications when adaptiveStream is enabled and then enabling the publication on first `attach()`?

ohhh interesting.. can you file an issue for this in the JS repo?

that makes a lot of sense.. we should be calling these earlier in its lifecycle

Yes, I'll file the issue tomorrow morning. Thanks for your confirmation!

Filed as <https://github.com/livekit/client-sdk-js/issues/175|#175>

You can find benchmark results and how to run tests here - <https://docs.livekit.io/deploy/benchmark>

Thanks, do you have any comparison paper/blogs of different WebRTCs like the below. Also, load test on basic config like 4CPUs and 4GB ram looks like 16 cores were used for load test on livekit site.
```1 - feature comparison
2 - deployment - containers, AWS etc
3 - Architecture  - load balancing, clustering support, simulcast
4 - development - nodejs, binary, react etc```

Maybe you should just store your type in Metadata field

Denis is right, you should be putting custom data in the metadata field. (perhaps storing a JSON structure).

You cannot easily add other fields to LiveKit objects because they are wire objects that all clients would need to understand

What’s the error? Share it here. If server takes forever to respond and times out, then it’s probably a firewall issue.

Hello,
Is it possible to add track, for current user? While user share screen
iOS

And how can i share screen in background mode

You can use the data channel for chat message transport, but you‘ll need to implement some kind of persistence layer yourself (if you need messages to be persistent). User information can be stored in and written from the participants metadata field.

Hi, <@U036B4BJH55> and <@U028SSAKLQ1> a bit late “to the party” … I understand what <@U028SSAKLQ1> is saying and i know is possible to do this thing because I did it with a different library for also webrtc implementation but with livekit I don’t know how actually to do this :)))
Can someone maybe share a code example how this is done ? Would help a lot me and also others who for sure will come searching for this :slightly_smiling_face:

Thank you guys! :)

hey Akshat, how are you unpublish the track? is this published with the Go SDK?

I am also seeing a Publish timeout when re publishing in some cases. Here is the code.
```room.Callback.OnParticipantConnected = func(p *lksdk.RemoteParticipant) {

		<http://log.Info|log.Info>("New participant ", camSerial, p.Identity())
		// check the number of participants

		participants, err := listClientParticipants(room)
		if err != nil {
			log.Error(err)
		}

		//log.Info("Total participants after connection: ", len(participants))
		if len(participants) == 1 {

			err := camConfig.CreateLocalTracks(camConfig.videoEnabled, camConfig.audioEnabled)

			if err != nil {
				log.Error("Unable to recreated Local tracks ", err)
			}			

			_, err = room.LocalParticipant.PublishTrack(camConfig.localVideoTrack, "video")

			if err != nil {
				log.WithField("cam", camSerial).Error(err, " PUBLISH FAILED")
			} else {
				<http://log.Info|log.Info>("Published successfully")
			}

			camConfig.connChannel &lt;- true
		}
	}```
This code only publishes half the time and times out rest of the times. `listClientParticipants` is a function that returns all non local participants

This is the timeout I am hitting. In `localparticipant.go`. It happens only half the time
```pubChan := p.engine.TrackPublishedChan()
	var pubRes *livekit.TrackPublishedResponse

	select {
	case pubRes = &lt;-pubChan:
		break
	case &lt;-time.After(5 * time.Second):
		return nil, ErrTrackPublishTimeout
	}```

When the publication timesout, I do see a `add track request`
```{"level":"debug","ts":1648569133.1106443,"logger":"livekit","caller":"rtc/signalhandler.go:19","msg":"add track request","room":"hd-serial","roomID":"RM_7jSane7Z5jLP","participant":"SPOT_SFU","pID":"PA_vi79Gj2eFt6H","track":"video"}```
but I never see a answer.
```{"level":"debug","ts":1648569174.9999797,"logger":"livekit","caller":"rtc/participant.go:369","msg":"answering pub offer","room":"hd-serial","roomID":"RM_7jSane7Z5jLP","participant":"SPOT_SFU","pID":"PA_vi79Gj2eFt6H","state":"ACTIVE"}

{"level":"debug","ts":1648569175.021655,"logger":"livekit","caller":"rtc/participant.go:394","msg":"sending answer to client","room":"hd-serial","roomID":"RM_7jSane7Z5jLP","participant":"SPOT_SFU","pID":"PA_vi79Gj2eFt6H"}```

Choosing `relay` in the IceTransports should force TURN