add is_screencast to VideoSource

examples/local_video/src/publisher.rs

@@ -185,7 +185,7 @@ async fn run(args: Args, ctrl_c_received: Arc<AtomicBool>) -> Result<()> {
     let pace_fps = args.fps as f64;
 
     // Create LiveKit video source and track
-    let rtc_source = NativeVideoSource::new(VideoResolution { width, height });
+    let rtc_source = NativeVideoSource::new(VideoResolution { width, height }, false);
     let track =
         LocalVideoTrack::create_video_track("camera", RtcVideoSource::Native(rtc_source.clone()));
 

examples/screensharing/src/lib.rs

@@ -101,7 +101,7 @@ mod test {
         let resolution = wait_for_resolution(&resolution_signal);
         log::info!("Detected capture resolution: {}x{}", resolution.width, resolution.height);
 
-        let buffer_source = NativeVideoSource::new(resolution.clone());
+        let buffer_source = NativeVideoSource::new(resolution.clone(), true);
         {
             let mut slot = video_source_slot.lock().unwrap();
             *slot = Some(buffer_source.clone());

examples/wgpu_room/src/logo_track.rs

@@ -47,10 +47,10 @@ pub struct LogoTrack {
 impl LogoTrack {
     pub fn new(room: Arc<Room>) -> Self {
         Self {
-            rtc_source: NativeVideoSource::new(VideoResolution {
-                width: FB_WIDTH as u32,
-                height: FB_HEIGHT as u32,
-            }),
+            rtc_source: NativeVideoSource::new(
+                VideoResolution { width: FB_WIDTH as u32, height: FB_HEIGHT as u32 },
+                false,
+            ),
             room,
             handle: None,
         }

libwebrtc/src/native/video_source.rs

@@ -50,11 +50,12 @@ struct VideoSourceInner {
 }
 
 impl NativeVideoSource {
-    pub fn new(resolution: VideoResolution) -> NativeVideoSource {
+    pub fn new(resolution: VideoResolution, is_screencast: bool) -> NativeVideoSource {
         let source = Self {
-            sys_handle: vt_sys::ffi::new_video_track_source(&vt_sys::ffi::VideoResolution::from(
-                resolution.clone(),
-            )),
+            sys_handle: vt_sys::ffi::new_video_track_source(
+                &vt_sys::ffi::VideoResolution::from(resolution.clone()),
+                is_screencast,
+            ),
             inner: Arc::new(Mutex::new(VideoSourceInner { captured_frames: 0 })),
         };
 

libwebrtc/src/video_source.rs

@@ -65,13 +65,13 @@ pub mod native {
 
     impl Default for NativeVideoSource {
         fn default() -> Self {
-            Self::new(VideoResolution::default())
+            Self::new(VideoResolution::default(), false)
         }
     }
 
     impl NativeVideoSource {
-        pub fn new(resolution: VideoResolution) -> Self {
-            Self { handle: vs_imp::NativeVideoSource::new(resolution) }
+        pub fn new(resolution: VideoResolution, is_screencast: bool) -> Self {
+            Self { handle: vs_imp::NativeVideoSource::new(resolution, is_screencast) }
         }
 
         pub fn capture_frame<T: AsRef<dyn VideoBuffer>>(&self, frame: &VideoFrame<T>) {

livekit-ffi-node-bindings/src/proto/video_frame_pb.ts

@@ -422,12 +422,17 @@ export class NewVideoSourceRequest extends Message<NewVideoSourceRequest> {
 
   /**
    * Used to determine which encodings to use + simulcast layers
-   * Most of the time it corresponds to the source resolution 
+   * Most of the time it corresponds to the source resolution
    *
    * @generated from field: required livekit.proto.VideoSourceResolution resolution = 2;
    */
   resolution?: VideoSourceResolution;
 
+  /**
+   * @generated from field: optional bool is_screencast = 3;
+   */
+  isScreencast?: boolean;
+
   constructor(data?: PartialMessage<NewVideoSourceRequest>) {
     super();
     proto2.util.initPartial(data, this);
@@ -438,6 +443,7 @@ export class NewVideoSourceRequest extends Message<NewVideoSourceRequest> {
   static readonly fields: FieldList = proto2.util.newFieldList(() => [
     { no: 1, name: "type", kind: "enum", T: proto2.getEnumType(VideoSourceType), req: true },
     { no: 2, name: "resolution", kind: "message", T: VideoSourceResolution, req: true },
+    { no: 3, name: "is_screencast", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NewVideoSourceRequest {

livekit-ffi/protocol/video_frame.proto

@@ -44,11 +44,12 @@ message VideoStreamFromParticipantResponse { required OwnedVideoStream stream =
 
 // Create a new VideoSource
 // VideoSource is used to send video frame to a track
-message NewVideoSourceRequest { 
-  required VideoSourceType type = 1; 
+message NewVideoSourceRequest {
+  required VideoSourceType type = 1;
   // Used to determine which encodings to use + simulcast layers
-  // Most of the time it corresponds to the source resolution 
+  // Most of the time it corresponds to the source resolution
   required VideoSourceResolution resolution = 2;
+  optional bool is_screencast = 3;
 }
 message NewVideoSourceResponse { required OwnedVideoSource source = 1; }
 

livekit-ffi/src/server/video_source.rs

@@ -36,7 +36,9 @@ impl FfiVideoSource {
             proto::VideoSourceType::VideoSourceNative => {
                 use livekit::webrtc::video_source::native::NativeVideoSource;
 
-                let video_source = NativeVideoSource::new(new_source.resolution.into());
+                let is_screencast = new_source.is_screencast.unwrap_or(false);
+                let video_source =
+                    NativeVideoSource::new(new_source.resolution.into(), is_screencast);
                 RtcVideoSource::Native(video_source)
             }
             _ => return Err(FfiError::InvalidRequest("unsupported video source type".into())),

webrtc-sys/include/livekit/video_track.h

@@ -87,10 +87,10 @@ std::shared_ptr<NativeVideoSink> new_native_video_sink(
 class VideoTrackSource {
   class InternalSource : public webrtc::AdaptedVideoTrackSource {
    public:
-    InternalSource(const VideoResolution&
-                       resolution);  // (0, 0) means no resolution/optional, the
-                                     // source will guess the resolution at the
-                                     // first captured frame
+    InternalSource(const VideoResolution& resolution,
+                   bool is_screencast);  // (0, 0) means no resolution/optional, the
+                                         // source will guess the resolution at the
+                                         // first captured frame
     ~InternalSource() override;
 
     bool is_screencast() const override;
@@ -104,10 +104,11 @@ class VideoTrackSource {
     mutable webrtc::Mutex mutex_;
     webrtc::TimestampAligner timestamp_aligner_;
     VideoResolution resolution_;
+    bool is_screencast_;
   };
 
  public:
-  VideoTrackSource(const VideoResolution& resolution);
+  VideoTrackSource(const VideoResolution& resolution, bool is_screencast);
 
   VideoResolution video_resolution() const;
 
@@ -121,7 +122,7 @@ class VideoTrackSource {
 };
 
 std::shared_ptr<VideoTrackSource> new_video_track_source(
-    const VideoResolution& resolution);
+    const VideoResolution& resolution, bool is_screencast);
 
 static std::shared_ptr<MediaStreamTrack> video_to_media(
     std::shared_ptr<VideoTrack> track) {

webrtc-sys/src/video_track.cpp

@@ -105,13 +105,13 @@ std::shared_ptr<NativeVideoSink> new_native_video_sink(
 }
 
 VideoTrackSource::InternalSource::InternalSource(
-    const VideoResolution& resolution)
-    : webrtc::AdaptedVideoTrackSource(4), resolution_(resolution) {}
+    const VideoResolution& resolution, bool is_screencast)
+    : webrtc::AdaptedVideoTrackSource(4), resolution_(resolution), is_screencast_(is_screencast) {}
 
 VideoTrackSource::InternalSource::~InternalSource() {}
 
 bool VideoTrackSource::InternalSource::is_screencast() const {
-  return false;
+  return is_screencast_;
 }
 
 std::optional<bool> VideoTrackSource::InternalSource::needs_denoising() const {
@@ -175,8 +175,8 @@ bool VideoTrackSource::InternalSource::on_captured_frame(
   return true;
 }
 
-VideoTrackSource::VideoTrackSource(const VideoResolution& resolution) {
-  source_ = webrtc::make_ref_counted<InternalSource>(resolution);
+VideoTrackSource::VideoTrackSource(const VideoResolution& resolution, bool is_screencast) {
+  source_ = webrtc::make_ref_counted<InternalSource>(resolution, is_screencast);
 }
 
 VideoResolution VideoTrackSource::video_resolution() const {
@@ -195,8 +195,8 @@ webrtc::scoped_refptr<VideoTrackSource::InternalSource> VideoTrackSource::get()
 }
 
 std::shared_ptr<VideoTrackSource> new_video_track_source(
-    const VideoResolution& resolution) {
-  return std::make_shared<VideoTrackSource>(resolution);
+    const VideoResolution& resolution, bool is_screencast) {
+  return std::make_shared<VideoTrackSource>(resolution, is_screencast);
 }
 
 }  // namespace livekit_ffi

webrtc-sys/src/video_track.rs

@@ -67,7 +67,10 @@ pub mod ffi {
 
         fn video_resolution(self: &VideoTrackSource) -> VideoResolution;
         fn on_captured_frame(self: &VideoTrackSource, frame: &UniquePtr<VideoFrame>) -> bool;
-        fn new_video_track_source(resolution: &VideoResolution) -> SharedPtr<VideoTrackSource>;
+        fn new_video_track_source(
+            resolution: &VideoResolution,
+            is_screencast: bool,
+        ) -> SharedPtr<VideoTrackSource>;
         fn video_to_media(track: SharedPtr<VideoTrack>) -> SharedPtr<MediaStreamTrack>;
         unsafe fn media_to_video(track: SharedPtr<MediaStreamTrack>) -> SharedPtr<VideoTrack>;
         fn _shared_video_track() -> SharedPtr<VideoTrack>;