FlutterVSyncWaiter Class Reference

#include <FlutterVSyncWaiter.h>

Inheritance diagram for FlutterVSyncWaiter:

Instance Methods
(instancetype)	- initWithDisplayLink:block:
(void)	- waitForVSync:
(void)	- processDisplayLink:targetTimestamp: [implementation]
(void)	- onDisplayLink:targetTimestamp: [implementation]
(void)	- dealloc [implementation]

Detailed Description

Definition at line 8 of file FlutterVSyncWaiter.h.

Method Documentation

dealloc

- (void) dealloc

implementation

Definition at line 42 of file FlutterVSyncWaiter.mm.

                {
  if (_pendingBaton.has_value()) {
    FML_LOG(WARNING) << "Deallocating FlutterVSyncWaiter with a pending vsync";
  }

initWithDisplayLink:block:

- (instancetype) initWithDisplayLink:		(FlutterDisplayLink*)	displayLink
block:		(void(^)(CFTimeInterval timestamp, CFTimeInterval targetTimestamp, uintptr_t baton))	block

Creates new waiter instance tied to provided NSView. This function must be called on the main thread.

Provided |block| will be invoked on same thread as -waitForVSync:.

Definition at line 42 of file FlutterVSyncWaiter.mm.

                                   :(FlutterDisplayLink*)displayLink
                              block:(void (^)(CFTimeInterval timestamp,
                                              CFTimeInterval targetTimestamp,
                                              uintptr_t baton))block {
  FML_DCHECK([NSThread isMainThread]);
  if (self = [super init]) {
    _block = block;
 
    _displayLink = displayLink;
    _displayLink.delegate = self;
    // Get at least one callback to initialize _lastTargetTimestamp.
    _displayLink.paused = NO;
    _warmUpFrame = YES;
  }

onDisplayLink:targetTimestamp:

- (void) onDisplayLink: (CFTimeInterval)  timestamp targetTimestamp: (CFTimeInterval)  targetTimestamp

implementation

Reimplemented from <FlutterDisplayLinkDelegate>.

Definition at line 42 of file FlutterVSyncWaiter.mm.

                     :(CFTimeInterval)timestamp targetTimestamp:(CFTimeInterval)targetTimestamp {
  @synchronized(self) {
    if (_runLoop == nil) {
      // Initial vsync - timestamp will be used to determine vsync phase.
      _lastTargetTimestamp = targetTimestamp;
      _displayLink.paused = YES;
    } else {
      [_runLoop performBlock:^{
        [self processDisplayLink:timestamp targetTimestamp:targetTimestamp];
      }];
    }

processDisplayLink:targetTimestamp:

- (void) processDisplayLink: (CFTimeInterval)  timestamp targetTimestamp: (CFTimeInterval)  targetTimestamp

implementation

Definition at line 42 of file FlutterVSyncWaiter.mm.

                          :(CFTimeInterval)timestamp
           targetTimestamp:(CFTimeInterval)targetTimestamp {
  FML_DCHECK([NSRunLoop currentRunLoop] == _runLoop);
 
  _lastTargetTimestamp = targetTimestamp;
 
  // CVDisplayLink callback is called one and a half frame before the target
  // timestamp. That can cause frame-pacing issues if the frame is rendered too early,
  // it may also trigger frame start before events are processed.
  CFTimeInterval minStart = targetTimestamp - _displayLink.nominalOutputRefreshPeriod;
  CFTimeInterval current = CACurrentMediaTime();
  CFTimeInterval remaining = std::max(minStart - current - kTimerLatencyCompensation, 0.0);
 
  TRACE_VSYNC("DisplayLinkCallback-Original", _pendingBaton.value_or(0));
 
  NSTimer* timer = [NSTimer
      timerWithTimeInterval:remaining
                    repeats:NO
                      block:^(NSTimer* _Nonnull timer) {
                        if (!_pendingBaton.has_value()) {
                          TRACE_VSYNC("DisplayLinkPaused", size_t(0));
                          _displayLink.paused = YES;
                          return;
                        }
                        TRACE_VSYNC("DisplayLinkCallback-Delayed", _pendingBaton.value_or(0));
                        _block(minStart, targetTimestamp, *_pendingBaton);
                        _pendingBaton = std::nullopt;
                      }];

waitForVSync:

- (void) waitForVSync:

(uintptr_t)

baton

Schedules |baton| to be signaled on next display refresh. The block provided in the initializer will be invoked on same thread as this method (there must be a run loop associated with current thread).

Definition at line 42 of file FlutterVSyncWaiter.mm.

                    :(uintptr_t)baton {
  // CVDisplayLink start -> callback latency is two frames, there is
  // no need to delay the warm-up frame.
  if (_warmUpFrame) {
    _warmUpFrame = NO;
    TRACE_VSYNC("WarmUpFrame", baton);
    [[NSRunLoop currentRunLoop] performBlock:^{
      CFTimeInterval now = CACurrentMediaTime();
      _block(now, now, baton);
    }];
    return;
  }
 
  // RunLoop is accessed both from main thread and from the display link thread.
  @synchronized(self) {
    if (_runLoop == nil) {
      _runLoop = [NSRunLoop currentRunLoop];
    }
  }
 
  FML_DCHECK(_runLoop == [NSRunLoop currentRunLoop]);
  if (_pendingBaton.has_value()) {
    FML_LOG(WARNING) << "Engine requested vsync while another was pending";
    _block(0, 0, *_pendingBaton);
    _pendingBaton = std::nullopt;
  }
 
  TRACE_VSYNC("VSyncRequest", _pendingBaton.value_or(0));
 
  CFTimeInterval tick_interval = _displayLink.nominalOutputRefreshPeriod;
  if (_displayLink.paused || tick_interval == 0) {
    // When starting display link the first notification will come in the middle
    // of next frame, which would incur a whole frame period of latency.
    // To avoid that, first vsync notification will be fired using a timer
    // scheduled to fire where the next frame is expected to start.
    // Also use a timer if display link does not belong to any display
    // (nominalOutputRefreshPeriod being 0)
 
    // Start of the vsync interval.
    CFTimeInterval start = CACurrentMediaTime();
 
    // Timer delay is calculated as the time to the next frame start.
    CFTimeInterval delay = 0;
 
    if (tick_interval != 0 && _lastTargetTimestamp != 0) {
      CFTimeInterval phase = fmod(_lastTargetTimestamp, tick_interval);
      CFTimeInterval now = start;
      start = now - (fmod(now, tick_interval)) + phase;
      if (start < now) {
        start += tick_interval;
      }
      delay = std::max(start - now - kTimerLatencyCompensation, 0.0);
    }
 
    NSTimer* timer = [NSTimer timerWithTimeInterval:delay
                                            repeats:NO
                                              block:^(NSTimer* timer) {
                                                CFTimeInterval targetTimestamp =
                                                    start + tick_interval;
                                                TRACE_VSYNC("SynthesizedInitialVSync", baton);
                                                _block(start, targetTimestamp, baton);
                                              }];
    [_runLoop addTimer:timer forMode:NSRunLoopCommonModes];
    _displayLink.paused = NO;
  } else {
    _pendingBaton = baton;

---

The documentation for this class was generated from the following files:

• shell/platform/darwin/macos/framework/Source/FlutterVSyncWaiter.h
• shell/platform/darwin/macos/framework/Source/FlutterVSyncWaiter.mm