tor-browser

screen_capturer_sck.mm (32588B)

---

/*
*  Copyright (c) 2024 The WebRTC project authors. All Rights Reserved.
*
*  Use of this source code is governed by a BSD-style license
*  that can be found in the LICENSE file in the root of the source
*  tree. An additional intellectual property rights grant can be found
*  in the file PATENTS.  All contributing project authors may
*  be found in the AUTHORS file in the root of the source tree.
*/

#include "modules/desktop_capture/mac/screen_capturer_sck.h"

#import <ScreenCaptureKit/ScreenCaptureKit.h>

#include <atomic>

#include "absl/strings/str_format.h"
#include "api/sequence_checker.h"
#include "modules/desktop_capture/mac/desktop_frame_iosurface.h"
#include "modules/desktop_capture/shared_desktop_frame.h"
#include "rtc_base/logging.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/thread_annotations.h"
#include "rtc_base/time_utils.h"
#include "sck_picker_handle.h"
#include "sdk/objc/helpers/scoped_cftyperef.h"

using webrtc::DesktopFrameIOSurface;

namespace webrtc {
class ScreenCapturerSck;
}  // namespace webrtc

// The ScreenCaptureKit API was available in macOS 12.3, but full-screen capture
// was reported to be broken before macOS 13 - see http://crbug.com/40234870.
// Also, the `SCContentFilter` fields `contentRect` and `pointPixelScale` were
// introduced in macOS 14.
API_AVAILABLE(macos(14.0))
@interface SckHelper : NSObject <SCStreamDelegate,
                                SCStreamOutput,
                                SCContentSharingPickerObserver>

- (instancetype)initWithCapturer:(webrtc::ScreenCapturerSck*)capturer;

- (void)onShareableContentCreated:(SCShareableContent*)content
                           error:(NSError*)error;

// Called just before the capturer is destroyed. This avoids a dangling pointer,
// and prevents any new calls into a deleted capturer. If any method-call on the
// capturer is currently running on a different thread, this blocks until it
// completes.
- (void)releaseCapturer;

@end

namespace webrtc {

class API_AVAILABLE(macos(14.0)) ScreenCapturerSck final
   : public DesktopCapturer {
public:
 explicit ScreenCapturerSck(const DesktopCaptureOptions& options);
 ScreenCapturerSck(const DesktopCaptureOptions& options,
                   SCContentSharingPickerMode modes);
 ScreenCapturerSck(const ScreenCapturerSck&) = delete;
 ScreenCapturerSck& operator=(const ScreenCapturerSck&) = delete;

 ~ScreenCapturerSck() override;

 // DesktopCapturer interface. All these methods run on the caller's thread.
 void Start(DesktopCapturer::Callback* callback) override;
 void SetMaxFrameRate(uint32_t max_frame_rate) override;
 void CaptureFrame() override;
 bool GetSourceList(SourceList* sources) override;
 bool SelectSource(SourceId id) override;
 // Creates the SckPickerHandle if needed and not already done.
 void EnsurePickerHandle();
 // Prep for implementing DelegatedSourceListController interface, for now used
 // by Start(). Triggers SCContentSharingPicker. Runs on the caller's thread.
 void EnsureVisible();
 // Helper functions to forward SCContentSharingPickerObserver notifications to
 // source_list_observer_.
 void NotifySourceSelection(SCContentFilter* filter, SCStream* stream);
 void NotifySourceCancelled(SCStream* stream);
 void NotifySourceError();

 // Called after a SCStreamDelegate stop notification.
 void NotifyCaptureStopped(SCStream* stream);

 // Called by SckHelper when shareable content is returned by ScreenCaptureKit.
 // `content` will be nil if an error occurred. May run on an arbitrary thread.
 void OnShareableContentCreated(SCShareableContent* content, NSError* error);

 // Start capture with the given filter. Creates or updates stream_ as needed.
 void StartWithFilter(SCContentFilter* filter)
     RTC_EXCLUSIVE_LOCKS_REQUIRED(lock_);

 // Called by SckHelper to notify of a newly captured frame. May run on an
 // arbitrary thread.
 void OnNewIOSurface(IOSurfaceRef io_surface, NSDictionary* attachment);

private:
 // Called when starting the capturer or the configuration has changed (either
 // from a SelectSource() call, or the screen-resolution has changed). This
 // tells SCK to fetch new shareable content, and the completion-handler will
 // either start a new stream, or reconfigure the existing stream. Runs on the
 // caller's thread.
 void StartOrReconfigureCapturer();

 // Calls to the public API must happen on a single thread.
 webrtc::SequenceChecker api_checker_;

 // Helper object to receive Objective-C callbacks from ScreenCaptureKit and
 // call into this C++ object. The helper may outlive this C++ instance, if a
 // completion-handler is passed to ScreenCaptureKit APIs and the C++ object is
 // deleted before the handler executes.
 SckHelper* __strong helper_;

 // Callback for returning captured frames, or errors, to the caller.
 Callback* callback_ RTC_GUARDED_BY(api_checker_) = nullptr;

 // Helper class that tracks the number of capturers needing
 // SCContentSharingPicker to stay active.
 std::unique_ptr<SckPickerHandleInterface> picker_handle_
     RTC_GUARDED_BY(api_checker_);

 // Flag to track if we have added ourselves as observer to picker_handle_.
 bool picker_handle_registered_ RTC_GUARDED_BY(api_checker_) = false;

 // Options passed to the constructor. May be accessed on any thread, but the
 // options are unchanged during the capturer's lifetime.
 const DesktopCaptureOptions capture_options_;

 // Modes to use iff using the system picker.
 // See docs on SCContentSharingPickerMode.
 const SCContentSharingPickerMode picker_modes_;

 // Signals that a permanent error occurred. This may be set on any thread, and
 // is read by CaptureFrame() which runs on the caller's thread.
 std::atomic<bool> permanent_error_ = false;

 // Guards some variables that may be accessed on different threads.
 Mutex lock_;

 // Provides captured desktop frames.
 SCStream* __strong stream_ RTC_GUARDED_BY(lock_);

 // Current filter on stream_.
 SCContentFilter* __strong filter_ RTC_GUARDED_BY(lock_);

 // Currently selected display, or 0 if the full desktop is selected. This
 // capturer does not support full-desktop capture, and will fall back to the
 // first display.
 CGDirectDisplayID current_display_ RTC_GUARDED_BY(lock_) = 0;

 // Configured maximum frame rate in frames per second.
 uint32_t max_frame_rate_ RTC_GUARDED_BY(lock_) = 0;

 // Used by CaptureFrame() to detect if the screen configuration has changed.
 MacDesktopConfiguration desktop_config_ RTC_GUARDED_BY(api_checker_);

 Mutex latest_frame_lock_ RTC_ACQUIRED_AFTER(lock_);
 std::unique_ptr<SharedDesktopFrame> latest_frame_
     RTC_GUARDED_BY(latest_frame_lock_);

 int32_t latest_frame_dpi_ RTC_GUARDED_BY(latest_frame_lock_) = kStandardDPI;

 // Tracks whether the latest frame contains new data since it was returned to
 // the caller. This is used to set the DesktopFrame's `updated_region`
 // property. The flag is cleared after the frame is sent to OnCaptureResult(),
 // and is set when SCK reports a new frame with non-empty "dirty" rectangles.
 // TODO: crbug.com/327458809 - Replace this flag with ScreenCapturerHelper to
 // more accurately track the dirty rectangles from the
 // SCStreamFrameInfoDirtyRects attachment.
 bool frame_is_dirty_ RTC_GUARDED_BY(latest_frame_lock_) = true;

 // Tracks whether a reconfigure is needed.
 bool frame_needs_reconfigure_ RTC_GUARDED_BY(latest_frame_lock_) = false;
 // If a reconfigure is needed, this will be set to the size in pixels required
 // to fit the entire source without downscaling.
 std::optional<CGSize> frame_reconfigure_img_size_
     RTC_GUARDED_BY(latest_frame_lock_);
};

/* Helper class for stringifying SCContentSharingPickerMode. Needed as
* SCContentSharingPickerMode is a typedef to NSUInteger which we cannot add a
* AbslStringify function for. */
struct StringifiableSCContentSharingPickerMode {
 const SCContentSharingPickerMode modes_;

 template <typename Sink>
 friend void AbslStringify(Sink& sink,
                           const StringifiableSCContentSharingPickerMode& m) {
   auto modes = m.modes_;
   if (@available(macos 14, *)) {
     bool empty = true;
     const std::tuple<SCContentSharingPickerMode, const char*> all_modes[] = {
         {SCContentSharingPickerModeSingleWindow, "SingleWindow"},
         {SCContentSharingPickerModeMultipleWindows, "MultiWindow"},
         {SCContentSharingPickerModeSingleApplication, "SingleApp"},
         {SCContentSharingPickerModeMultipleApplications, "MultiApp"},
         {SCContentSharingPickerModeSingleDisplay, "SingleDisplay"}};
     for (const auto& [mode, text] : all_modes) {
       if (modes & mode) {
         modes = modes & (~mode);
         absl::Format(&sink, "%s%s", empty ? "" : "|", text);
         empty = false;
       }
     }
     if (modes) {
       absl::Format(&sink, "%sRemaining=%v", empty ? "" : "|", modes);
     }
     return;
   }
   absl::Format(&sink, "%v", modes);
 }
};

ScreenCapturerSck::ScreenCapturerSck(const DesktopCaptureOptions& options,
                                    SCContentSharingPickerMode modes)
   : api_checker_(SequenceChecker::kDetached),
     capture_options_(options),
     picker_modes_(modes) {
 helper_ = [[SckHelper alloc] initWithCapturer:this];
}

ScreenCapturerSck::ScreenCapturerSck(const DesktopCaptureOptions& options)
   : ScreenCapturerSck(options, SCContentSharingPickerModeSingleDisplay) {}

ScreenCapturerSck::~ScreenCapturerSck() {
 RTC_DCHECK_RUN_ON(&api_checker_);
 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << this << " destroyed.";
 [stream_ stopCaptureWithCompletionHandler:nil];
 [helper_ releaseCapturer];
}

void ScreenCapturerSck::Start(DesktopCapturer::Callback* callback) {
 RTC_DCHECK_RUN_ON(&api_checker_);
 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << this << " " << __func__ << ".";
 callback_ = callback;
 desktop_config_ =
     capture_options_.configuration_monitor()->desktop_configuration();
 if (capture_options_.allow_sck_system_picker()) {
   EnsureVisible();
   return;
 }
 StartOrReconfigureCapturer();
}

void ScreenCapturerSck::SetMaxFrameRate(uint32_t max_frame_rate) {
 RTC_DCHECK_RUN_ON(&api_checker_);
 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << this << " SetMaxFrameRate("
                  << max_frame_rate << ").";
 bool stream_started = false;
 {
   MutexLock lock(&lock_);
   if (max_frame_rate_ == max_frame_rate) {
     return;
   }

   max_frame_rate_ = max_frame_rate;
   stream_started = stream_;
 }
 if (stream_started) {
   StartOrReconfigureCapturer();
 }
}

void ScreenCapturerSck::CaptureFrame() {
 RTC_DCHECK_RUN_ON(&api_checker_);
 int64_t capture_start_time_millis = webrtc::TimeMillis();

 if (permanent_error_) {
   RTC_LOG(LS_VERBOSE) << "ScreenCapturerSck " << this
                       << " CaptureFrame() -> ERROR_PERMANENT";
   callback_->OnCaptureResult(Result::ERROR_PERMANENT, nullptr);
   return;
 }

 MacDesktopConfiguration new_config =
     capture_options_.configuration_monitor()->desktop_configuration();
 if (!desktop_config_.Equals(new_config)) {
   desktop_config_ = new_config;
   StartOrReconfigureCapturer();
 }

 std::unique_ptr<DesktopFrame> frame;
 bool needs_reconfigure = false;
 {
   MutexLock lock(&latest_frame_lock_);
   if (latest_frame_) {
     frame = latest_frame_->Share();
     if (frame_is_dirty_) {
       frame->mutable_updated_region()->AddRect(
           DesktopRect::MakeSize(frame->size()));
       frame_is_dirty_ = false;
     }
   }
   needs_reconfigure = frame_needs_reconfigure_;
   frame_needs_reconfigure_ = false;
 }

 if (needs_reconfigure) {
   StartOrReconfigureCapturer();
 }

 if (frame) {
   RTC_LOG(LS_VERBOSE) << "ScreenCapturerSck " << this
                       << " CaptureFrame() -> SUCCESS";
   frame->set_capture_time_ms(webrtc::TimeSince(capture_start_time_millis));
   callback_->OnCaptureResult(Result::SUCCESS, std::move(frame));
 } else {
   RTC_LOG(LS_VERBOSE) << "ScreenCapturerSck " << this
                       << " CaptureFrame() -> ERROR_TEMPORARY";
   callback_->OnCaptureResult(Result::ERROR_TEMPORARY, nullptr);
 }
}

void ScreenCapturerSck::EnsurePickerHandle() {
 RTC_DCHECK_RUN_ON(&api_checker_);
 if (!picker_handle_ && capture_options_.allow_sck_system_picker()) {
   picker_handle_ = CreateSckPickerHandle();
   RTC_LOG(LS_INFO) << "ScreenCapturerSck " << this
                    << " Created picker handle. allow_sck_system_picker="
                    << capture_options_.allow_sck_system_picker()
                    << ", source="
                    << (picker_handle_ ? picker_handle_->Source() : -1)
                    << ", modes="
                    << StringifiableSCContentSharingPickerMode{
                           .modes_ = picker_modes_};
 }
}

void ScreenCapturerSck::EnsureVisible() {
 RTC_DCHECK_RUN_ON(&api_checker_);
 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << this << " " << __func__ << ".";
 EnsurePickerHandle();
 if (picker_handle_) {
   if (!picker_handle_registered_) {
     picker_handle_registered_ = true;
     [picker_handle_->GetPicker() addObserver:helper_];
   }
 } else {
   // We reached the maximum number of streams.
   RTC_LOG(LS_ERROR)
       << "ScreenCapturerSck " << this
       << " EnsureVisible() reached the maximum number of streams.";
   permanent_error_ = true;
   return;
 }
 SCContentSharingPicker* picker = picker_handle_->GetPicker();
 SCStream* stream;
 {
   MutexLock lock(&lock_);
   stream = stream_;
   stream_ = nil;
   filter_ = nil;
   MutexLock lock2(&latest_frame_lock_);
   frame_needs_reconfigure_ = false;
   frame_reconfigure_img_size_ = std::nullopt;
 }
 [stream removeStreamOutput:helper_ type:SCStreamOutputTypeScreen error:nil];
 [stream stopCaptureWithCompletionHandler:nil];
 SCContentSharingPickerConfiguration* config = picker.defaultConfiguration;
 config.allowedPickerModes = picker_modes_;
 picker.defaultConfiguration = config;
 SCShareableContentStyle style = SCShareableContentStyleNone;
 // Pick a sensible style to start out with, based on our current mode.
 if (@available(macOS 15, *)) {
   // Stick with None because if we use Display, the picker doesn't let us
   // pick a window when first opened. Behaves like Window in 14 except doesn't
   // change window focus.
 } else {
   // Default to Display because if using Window the picker automatically hides
   // our current window to show others. Saves a click compared to None when
   // picking a display.
   style = SCShareableContentStyleDisplay;
 }
 if (picker_modes_ == SCContentSharingPickerModeSingleDisplay) {
   style = SCShareableContentStyleDisplay;
 } else if (picker_modes_ == SCContentSharingPickerModeSingleWindow ||
            picker_modes_ == SCContentSharingPickerModeMultipleWindows) {
   style = SCShareableContentStyleWindow;
 } else if (picker_modes_ == SCContentSharingPickerModeSingleApplication ||
            picker_modes_ == SCContentSharingPickerModeMultipleApplications) {
   style = SCShareableContentStyleApplication;
 }
 // This dies silently if maximumStreamCount streams are already running. We
 // need our own stream count bookkeeping because of this, and to be able to
 // unset `active`.
 [picker presentPickerForStream:stream usingContentStyle:style];
}

void ScreenCapturerSck::NotifySourceSelection(SCContentFilter* filter,
                                             SCStream* stream) {
 MutexLock lock(&lock_);
 if (stream_ != stream) {
   // The picker selected a source for another capturer.
   RTC_LOG(LS_INFO) << "ScreenCapturerSck " << this << " " << __func__
                    << ". stream_ != stream.";
   return;
 }
 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << this << " " << __func__
                  << ". Starting.";
 StartWithFilter(filter);
}

void ScreenCapturerSck::NotifySourceCancelled(SCStream* stream) {
 MutexLock lock(&lock_);
 if (stream_ != stream) {
   // The picker was cancelled for another capturer.
   return;
 }
 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << this << " " << __func__ << ".";
 if (!stream_) {
   // The initial picker was cancelled. There is no stream to fall back to.
   permanent_error_ = true;
 }
}

void ScreenCapturerSck::NotifySourceError() {
 {
   MutexLock lock(&lock_);
   if (stream_) {
     // The picker failed to start. But fear not, it was not our picker,
     // we already have a stream!
     return;
   }
 }
 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << this << " " << __func__ << ".";
 permanent_error_ = true;
}

void ScreenCapturerSck::NotifyCaptureStopped(SCStream* stream) {
 MutexLock lock(&lock_);
 if (stream_ != stream) {
   return;
 }
 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << this << " " << __func__ << ".";
 permanent_error_ = true;
}

bool ScreenCapturerSck::GetSourceList(SourceList* sources) {
 RTC_DCHECK_RUN_ON(&api_checker_);
 sources->clear();
 EnsurePickerHandle();
 if (picker_handle_) {
   sources->push_back({picker_handle_->Source(), 0, std::string()});
 }
 return true;
}

bool ScreenCapturerSck::SelectSource(SourceId id) {
 if (capture_options_.allow_sck_system_picker()) {
   return true;
 }

 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << this << " SelectSource(id=" << id
                  << ").";
 bool stream_started = false;
 {
   MutexLock lock(&lock_);
   if (current_display_ == id) {
     return true;
   }
   current_display_ = id;

   if (stream_) {
     stream_started = true;
   }
 }

 // If the capturer was already started, reconfigure it. Otherwise, wait until
 // Start() gets called.
 if (stream_started) {
   StartOrReconfigureCapturer();
 }

 return true;
}

void ScreenCapturerSck::OnShareableContentCreated(SCShareableContent* content,
                                                 NSError* error) {
 if (!content) {
   RTC_LOG(LS_ERROR) << "ScreenCapturerSck " << this
                     << " getShareableContent failed with error code "
                     << (error ? error.code : 0) << ".";
   permanent_error_ = true;
   return;
 }

 if (!content.displays.count) {
   RTC_LOG(LS_ERROR) << "ScreenCapturerSck " << this
                     << " getShareableContent returned no displays.";
   permanent_error_ = true;
   return;
 }

 MutexLock lock(&lock_);
 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << this << " " << __func__
                  << ". current_display_=" << current_display_;
 SCDisplay* captured_display;
 for (SCDisplay* display in content.displays) {
   if (current_display_ == display.displayID) {
     captured_display = display;
     break;
   }
 }
 if (!captured_display) {
   if (current_display_ ==
       static_cast<CGDirectDisplayID>(kFullDesktopScreenId)) {
     RTC_LOG(LS_WARNING) << "ScreenCapturerSck " << this
                         << " Full screen "
                            "capture is not supported, falling back to first "
                            "display.";
   } else {
     RTC_LOG(LS_WARNING) << "ScreenCapturerSck " << this << " Display "
                         << current_display_
                         << " not found, falling back to "
                            "first display.";
   }
   captured_display = content.displays.firstObject;
 }

 SCContentFilter* filter =
     [[SCContentFilter alloc] initWithDisplay:captured_display
                             excludingWindows:@[]];
 StartWithFilter(filter);
}

void ScreenCapturerSck::StartWithFilter(SCContentFilter* __strong filter) {
 lock_.AssertHeld();
 SCStreamConfiguration* config = [[SCStreamConfiguration alloc] init];
 config.pixelFormat = kCVPixelFormatType_32BGRA;
 config.colorSpaceName = kCGColorSpaceSRGB;
 config.showsCursor = capture_options_.prefer_cursor_embedded();
 config.captureResolution = SCCaptureResolutionNominal;
 config.minimumFrameInterval = max_frame_rate_ > 0 ?
     CMTimeMake(1, static_cast<int32_t>(max_frame_rate_)) :
     kCMTimeZero;

 {
   MutexLock lock(&latest_frame_lock_);
   latest_frame_dpi_ = filter.pointPixelScale * kStandardDPI;
   if (filter_ != filter) {
     frame_reconfigure_img_size_ = std::nullopt;
   }
   auto sourceImgRect = frame_reconfigure_img_size_.value_or(
       CGSizeMake(filter.contentRect.size.width * filter.pointPixelScale,
                  filter.contentRect.size.height * filter.pointPixelScale));
   config.width = sourceImgRect.width;
   config.height = sourceImgRect.height;
 }

 filter_ = filter;

 if (stream_) {
   RTC_LOG(LS_INFO) << "ScreenCapturerSck " << this
                    << " Updating stream configuration to size="
                    << config.width << "x" << config.height
                    << " and max_frame_rate=" << max_frame_rate_ << ".";
   [stream_ updateContentFilter:filter completionHandler:nil];
   [stream_ updateConfiguration:config completionHandler:nil];
 } else {
   RTC_LOG(LS_INFO) << "ScreenCapturerSck " << this << " Creating new stream.";
   stream_ = [[SCStream alloc] initWithFilter:filter
                                configuration:config
                                     delegate:helper_];

   // TODO: crbug.com/327458809 - Choose an appropriate sampleHandlerQueue for
   // best performance.
   NSError* add_stream_output_error;
   bool add_stream_output_result =
       [stream_ addStreamOutput:helper_
                           type:SCStreamOutputTypeScreen
             sampleHandlerQueue:nil
                          error:&add_stream_output_error];
   if (!add_stream_output_result) {
     stream_ = nil;
     filter_ = nil;
     RTC_LOG(LS_ERROR) << "ScreenCapturerSck " << this
                       << " addStreamOutput failed.";
     permanent_error_ = true;
     return;
   }

   auto handler = ^(NSError* error) {
     if (error) {
       // It should be safe to access `this` here, because the C++ destructor
       // calls stopCaptureWithCompletionHandler on the stream, which cancels
       // this handler.
       permanent_error_ = true;
       RTC_LOG(LS_ERROR) << "ScreenCapturerSck " << this
                         << " Starting failed with error code " << error.code
                         << ".";
     } else {
       RTC_LOG(LS_INFO) << "ScreenCapturerSck " << this << " Capture started.";
     }
   };

   [stream_ startCaptureWithCompletionHandler:handler];
 }
}

void ScreenCapturerSck::OnNewIOSurface(IOSurfaceRef io_surface,
                                      NSDictionary* attachment) {
 bool has_frame_to_process = false;
 if (auto status_nr = (NSNumber*)attachment[SCStreamFrameInfoStatus]) {
   auto status = (SCFrameStatus)[status_nr integerValue];
   has_frame_to_process =
       status == SCFrameStatusComplete || status == SCFrameStatusStarted;
 }
 if (!has_frame_to_process) {
   return;
 }

 double scale_factor = 1;
 if (auto factor = (NSNumber*)attachment[SCStreamFrameInfoScaleFactor]) {
   scale_factor = [factor floatValue];
 }
 double content_scale = 1;
 if (auto scale = (NSNumber*)attachment[SCStreamFrameInfoContentScale]) {
   content_scale = [scale floatValue];
 }
 CGRect content_rect = {};
 if (const auto* rect_dict =
         (__bridge CFDictionaryRef)attachment[SCStreamFrameInfoContentRect]) {
   if (!CGRectMakeWithDictionaryRepresentation(rect_dict, &content_rect)) {
     content_rect = CGRect();
   }
 }
 CGRect bounding_rect = {};
 if (const auto* rect_dict =
         (__bridge CFDictionaryRef)attachment[SCStreamFrameInfoBoundingRect]) {
   if (!CGRectMakeWithDictionaryRepresentation(rect_dict, &bounding_rect)) {
     bounding_rect = CGRect();
   }
 }
 CGRect overlay_rect = {};
 if (@available(macOS 14.2, *)) {
   if (const auto* rect_dict = (__bridge CFDictionaryRef)
           attachment[SCStreamFrameInfoPresenterOverlayContentRect]) {
     if (!CGRectMakeWithDictionaryRepresentation(rect_dict, &overlay_rect)) {
       overlay_rect = CGRect();
     }
   }
 }
 const auto* dirty_rects = (NSArray*)attachment[SCStreamFrameInfoDirtyRects];

 auto img_bounding_rect = CGRectMake(scale_factor * bounding_rect.origin.x,
                                     scale_factor * bounding_rect.origin.y,
                                     scale_factor * bounding_rect.size.width,
                                     scale_factor * bounding_rect.size.height);

 webrtc::ScopedCFTypeRef<IOSurfaceRef> scoped_io_surface(
     io_surface, webrtc::RetainPolicy::RETAIN);
 std::unique_ptr<DesktopFrameIOSurface> desktop_frame_io_surface =
     DesktopFrameIOSurface::Wrap(scoped_io_surface, img_bounding_rect);
 if (!desktop_frame_io_surface) {
   RTC_LOG(LS_ERROR) << "Failed to lock IOSurface.";
   return;
 }

 const size_t width = IOSurfaceGetWidth(io_surface);
 const size_t height = IOSurfaceGetHeight(io_surface);

 RTC_LOG(LS_VERBOSE) << "ScreenCapturerSck " << this << " " << __func__
                     << ". New surface: width=" << width
                     << ", height=" << height << ", content_rect="
                     << NSStringFromRect(content_rect).UTF8String
                     << ", bounding_rect="
                     << NSStringFromRect(bounding_rect).UTF8String
                     << ", overlay_rect=("
                     << NSStringFromRect(overlay_rect).UTF8String
                     << ", scale_factor=" << scale_factor
                     << ", content_scale=" << content_scale
                     << ". Cropping to rect "
                     << NSStringFromRect(img_bounding_rect).UTF8String << ".";

 std::unique_ptr<SharedDesktopFrame> frame =
     SharedDesktopFrame::Wrap(std::move(desktop_frame_io_surface));

 bool dirty;
 {
   MutexLock lock(&latest_frame_lock_);
   // Mark the frame as dirty if it has a different size, and ignore any
   // DirtyRects attachment in this case. This is because SCK does not apply a
   // correct attachment to the frame in the case where the stream was
   // reconfigured.
   dirty = !latest_frame_ || !latest_frame_->size().equals(frame->size());
 }

 if (!dirty) {
   if (!dirty_rects) {
     // This is never expected to happen - SCK attaches a non-empty dirty-rects
     // list to every frame, even when nothing has changed.
     return;
   }
   for (NSUInteger i = 0; i < dirty_rects.count; i++) {
     const auto* rect_ptr = (__bridge CFDictionaryRef)dirty_rects[i];
     if (CFGetTypeID(rect_ptr) != CFDictionaryGetTypeID()) {
       // This is never expected to happen - the dirty-rects attachment should
       // always be an array of dictionaries.
       return;
     }
     CGRect rect{};
     CGRectMakeWithDictionaryRepresentation(rect_ptr, &rect);
     if (!CGRectIsEmpty(rect)) {
       dirty = true;
       break;
     }
   }
 }

 MutexLock lock(&latest_frame_lock_);
 if (content_scale > 0 && content_scale < 1) {
   frame_needs_reconfigure_ = true;
   double scale = 1 / content_scale;
   frame_reconfigure_img_size_ =
       CGSizeMake(std::ceil(scale * width), std::ceil(scale * height));
 }
 if (dirty) {
   frame->set_dpi(DesktopVector(latest_frame_dpi_, latest_frame_dpi_));
   frame->set_may_contain_cursor(capture_options_.prefer_cursor_embedded());

   frame_is_dirty_ = true;
   std::swap(latest_frame_, frame);
 }
}

void ScreenCapturerSck::StartOrReconfigureCapturer() {
 if (capture_options_.allow_sck_system_picker()) {
   MutexLock lock(&lock_);
   if (filter_) {
     StartWithFilter(filter_);
   }
   return;
 }

 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << this << " " << __func__ << ".";
 // The copy is needed to avoid capturing `this` in the Objective-C block.
 // Accessing `helper_` inside the block is equivalent to `this->helper_` and
 // would crash (UAF) if `this` is deleted before the block is executed.
 SckHelper* local_helper = helper_;
 auto handler = ^(SCShareableContent* content, NSError* error) {
   [local_helper onShareableContentCreated:content error:error];
 };

 [SCShareableContent getShareableContentWithCompletionHandler:handler];
}

bool ScreenCapturerSckAvailable() {
 static bool available = ([] {
   if (@available(macOS 14.0, *)) {
     return true;
   }
   return false;
 })();
 return available;
}

std::unique_ptr<DesktopCapturer> CreateScreenCapturerSck(
   const DesktopCaptureOptions& options) {
 if (@available(macOS 14.0, *)) {
   return std::make_unique<ScreenCapturerSck>(options);
 }
 return nullptr;
}

bool GenericCapturerSckWithPickerAvailable() {
 bool available = false;
 if (@available(macOS 14.0, *)) {
   available = true;
 }
 return available;
}

std::unique_ptr<DesktopCapturer> CreateGenericCapturerSck(
   const DesktopCaptureOptions& options) {
 if (@available(macOS 14.0, *)) {
   if (options.allow_sck_system_picker()) {
     return std::make_unique<ScreenCapturerSck>(
         options,
         SCContentSharingPickerModeSingleDisplay |
             SCContentSharingPickerModeMultipleWindows);
   }
 }
 return nullptr;
}

}  // namespace webrtc

@implementation SckHelper {
 // This lock is to prevent the capturer being destroyed while an instance
 // method is still running on another thread.
 webrtc::Mutex _capturer_lock;
 webrtc::ScreenCapturerSck* _capturer;
}

- (instancetype)initWithCapturer:(webrtc::ScreenCapturerSck*)capturer {
 self = [super init];
 if (self) {
   _capturer = capturer;
 }
 return self;
}

- (void)onShareableContentCreated:(SCShareableContent*)content
                           error:(NSError*)error {
 webrtc::MutexLock lock(&_capturer_lock);
 if (_capturer) {
   _capturer->OnShareableContentCreated(content, error);
 }
}

- (void)stream:(SCStream*)stream didStopWithError:(NSError*)error {
 webrtc::MutexLock lock(&_capturer_lock);
 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << _capturer << " " << __func__
                  << ".";
 if (_capturer) {
   _capturer->NotifyCaptureStopped(stream);
 }
}

- (void)userDidStopStream:(SCStream*)stream NS_SWIFT_NAME(userDidStopStream(_:))
                             API_AVAILABLE(macos(14.4)) {
 webrtc::MutexLock lock(&_capturer_lock);
 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << _capturer << " " << __func__
                  << ".";
 if (_capturer) {
   _capturer->NotifyCaptureStopped(stream);
 }
}

- (void)contentSharingPicker:(SCContentSharingPicker*)picker
        didUpdateWithFilter:(SCContentFilter*)filter
                  forStream:(SCStream*)stream {
 webrtc::MutexLock lock(&_capturer_lock);
 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << _capturer << " " << __func__
                  << ".";
 if (_capturer) {
   _capturer->NotifySourceSelection(filter, stream);
 }
}

- (void)contentSharingPicker:(SCContentSharingPicker*)picker
         didCancelForStream:(SCStream*)stream {
 webrtc::MutexLock lock(&_capturer_lock);
 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << _capturer << " " << __func__
                  << ".";
 if (_capturer) {
   _capturer->NotifySourceCancelled(stream);
 }
}

- (void)contentSharingPickerStartDidFailWithError:(NSError*)error {
 webrtc::MutexLock lock(&_capturer_lock);
 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << _capturer << " " << __func__
                  << ". error.code=" << error.code;
 if (_capturer) {
   _capturer->NotifySourceError();
 }
}

- (void)stream:(SCStream*)stream
   didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
                  ofType:(SCStreamOutputType)type {
 CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
 if (!pixelBuffer) {
   return;
 }

 IOSurfaceRef ioSurface = CVPixelBufferGetIOSurface(pixelBuffer);
 if (!ioSurface) {
   return;
 }

 CFArrayRef attachmentsArray = CMSampleBufferGetSampleAttachmentsArray(
     sampleBuffer, /*createIfNecessary=*/false);
 if (!attachmentsArray || CFArrayGetCount(attachmentsArray) <= 0) {
   RTC_LOG(LS_ERROR) << "Discarding frame with no attachments.";
   return;
 }

 CFDictionaryRef attachment =
     static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(attachmentsArray, 0));

 webrtc::MutexLock lock(&_capturer_lock);
 if (_capturer) {
   _capturer->OnNewIOSurface(ioSurface, (__bridge NSDictionary*)attachment);
 }
}

- (void)releaseCapturer {
 webrtc::MutexLock lock(&_capturer_lock);
 RTC_LOG(LS_INFO) << "ScreenCapturerSck " << _capturer << " " << __func__
                  << ".";
 _capturer = nullptr;
}

@end