react-native-webgpu 0.11.0 → 0.11.1

package/android/src/main/java/com/webgpu/WebGPUVideoPlayer.java

@@ -0,0 +1,420 @@
+package com.webgpu;
+
+import android.content.Context;
+import android.graphics.ImageFormat;
+import android.hardware.HardwareBuffer;
+import android.media.AudioAttributes;
+import android.media.Image;
+import android.media.ImageReader;
+import android.media.MediaExtractor;
+import android.media.MediaFormat;
+import android.media.MediaMetadataRetriever;
+import android.media.MediaPlayer;
+import android.net.Uri;
+import android.os.Build;
+import android.util.Log;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Decodes a video with {@link MediaPlayer} into an {@link ImageReader} whose
+ * buffers the GPU can sample ({@link ImageFormat#PRIVATE} with
+ * {@link HardwareBuffer#USAGE_GPU_SAMPLED_IMAGE}). Each frame is handed to C++
+ * (AndroidVideoPlayer) as an {@link Image} that stays acquired until the
+ * NativeVideoFrame is released, which hands the buffer back to the decoder.
+ *
+ * The frames keep the decoder's native YUV layout, so they are sampled through
+ * GPUDevice.importExternalTexture. MediaPlayer owns the audio, the clock and
+ * the A/V synchronization.
+ *
+ * MediaPlayer is driven from the caller's thread (its methods are thread
+ * safe); its callbacks arrive on the main looper, so the shared state is
+ * guarded by {@code lock}.
+ */
+@DoNotStrip
+public class WebGPUVideoPlayer {
+  private static final String TAG = "WebGPUVideoPlayer";
+
+  // Frames the consumer can hold at once: the one being drawn, the next one,
+  // and a spare. Holding more makes copyLatestFrame() return null until a
+  // frame is released.
+  private static final int MAX_IMAGES = 3;
+
+  private final Object lock = new Object();
+  private final Set<Image> acquired = new HashSet<>();
+  private MediaPlayer player;
+  private ImageReader reader;
+  private boolean prepared = false;
+  private boolean playing = false;
+  private boolean loop = true;
+  private float volume = 1f;
+  private double pendingSeekSeconds = -1;
+  private boolean released = false;
+
+  private volatile int width = 0;
+  private volatile int height = 0;
+  private volatile int rotation = 0;
+  private volatile double frameRate = 0;
+  private volatile double durationSeconds = 0;
+
+  WebGPUVideoPlayer(Context context, String source) {
+    Uri uri = parseSource(source);
+    readMetadata(context, uri);
+
+    MediaPlayer mp = new MediaPlayer();
+    mp.setAudioAttributes(
+        new AudioAttributes.Builder()
+            .setUsage(AudioAttributes.USAGE_MEDIA)
+            .setContentType(AudioAttributes.CONTENT_TYPE_MOVIE)
+            .build());
+    mp.setOnVideoSizeChangedListener((p, w, h) -> onVideoSizeChanged(w, h));
+    mp.setOnPreparedListener(this::onPrepared);
+    mp.setOnCompletionListener(
+        p -> {
+          // Not called while looping: MediaPlayer restarts on its own.
+          synchronized (lock) {
+            if (!loop) {
+              playing = false;
+            }
+          }
+        });
+    mp.setOnErrorListener(
+        (p, what, extra) -> {
+          Log.e(TAG, "MediaPlayer error " + what + " (" + extra + ") for " + source);
+          synchronized (lock) {
+            playing = false;
+          }
+          return true;
+        });
+    try {
+      mp.setDataSource(context, uri);
+    } catch (IOException | IllegalArgumentException | SecurityException e) {
+      mp.release();
+      throw new RuntimeException("createVideoPlayer: cannot open " + source, e);
+    }
+    mp.setLooping(loop);
+    mp.prepareAsync();
+    synchronized (lock) {
+      player = mp;
+    }
+  }
+
+  // A URL (http, https, file, content) or a plain file path.
+  private static Uri parseSource(String source) {
+    Uri uri = Uri.parse(source);
+    if (uri.getScheme() == null) {
+      return Uri.fromFile(new File(source));
+    }
+    return uri;
+  }
+
+  // The frame geometry comes from the container (MediaMetadataRetriever for
+  // the size, rotation and duration, MediaExtractor for the frame rate). The
+  // metadata of a remote video is fetched off the calling thread; the getters
+  // report 0 until it is known.
+  private void readMetadata(Context context, Uri uri) {
+    Thread thread =
+        new Thread(
+            () -> {
+              MediaMetadataRetriever retriever = new MediaMetadataRetriever();
+              try {
+                String scheme = uri.getScheme();
+                if ("http".equals(scheme) || "https".equals(scheme)) {
+                  retriever.setDataSource(uri.toString(), new java.util.HashMap<>());
+                } else {
+                  retriever.setDataSource(context, uri);
+                }
+                int w = parseInt(retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH));
+                int h = parseInt(retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT));
+                if (w > 0 && h > 0 && width == 0) {
+                  width = w;
+                  height = h;
+                }
+                rotation = parseInt(retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION));
+                long durationMs = parseInt(retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION));
+                if (durationMs > 0 && durationSeconds == 0) {
+                  durationSeconds = durationMs / 1000.0;
+                }
+              } catch (RuntimeException e) {
+                Log.w(TAG, "Could not read the metadata of " + uri + ": " + e.getMessage());
+              } finally {
+                try {
+                  retriever.release();
+                } catch (IOException ignored) {
+                  // Nothing to recover.
+                }
+              }
+
+              MediaExtractor extractor = new MediaExtractor();
+              try {
+                extractor.setDataSource(context, uri, null);
+                for (int i = 0; i < extractor.getTrackCount(); i++) {
+                  MediaFormat format = extractor.getTrackFormat(i);
+                  String mime = format.getString(MediaFormat.KEY_MIME);
+                  if (mime != null && mime.startsWith("video/")) {
+                    if (format.containsKey(MediaFormat.KEY_FRAME_RATE)) {
+                      frameRate = format.getInteger(MediaFormat.KEY_FRAME_RATE);
+                    }
+                    break;
+                  }
+                }
+              } catch (IOException | RuntimeException e) {
+                Log.w(TAG, "Could not read the frame rate of " + uri + ": " + e.getMessage());
+              } finally {
+                extractor.release();
+              }
+            },
+            "WebGPUVideoPlayer metadata");
+    thread.setDaemon(true);
+    thread.start();
+  }
+
+  private static int parseInt(String value) {
+    if (value == null) {
+      return 0;
+    }
+    try {
+      return Integer.parseInt(value);
+    } catch (NumberFormatException e) {
+      return 0;
+    }
+  }
+
+  // The decoder reports the frame size (possibly more than once for adaptive
+  // streams); the ImageReader that receives the frames is sized accordingly.
+  private void onVideoSizeChanged(int w, int h) {
+    if (w <= 0 || h <= 0) {
+      return;
+    }
+    ImageReader previous;
+    synchronized (lock) {
+      if (released || player == null) {
+        return;
+      }
+      if (reader != null && reader.getWidth() == w && reader.getHeight() == h) {
+        return;
+      }
+      if (width == 0) {
+        width = w;
+        height = h;
+      }
+      previous = reader;
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+        reader = ImageReader.newInstance(w, h, ImageFormat.PRIVATE, MAX_IMAGES, HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE);
+      } else {
+        reader = ImageReader.newInstance(w, h, ImageFormat.PRIVATE, MAX_IMAGES);
+      }
+      player.setSurface(reader.getSurface());
+    }
+    if (previous != null) {
+      // Frames still held by the consumer were acquired from the old reader;
+      // closing it closes them, and the native side keeps the buffers alive.
+      synchronized (lock) {
+        acquired.clear();
+      }
+      previous.close();
+    }
+  }
+
+  private void onPrepared(MediaPlayer mp) {
+    synchronized (lock) {
+      if (released) {
+        return;
+      }
+      prepared = true;
+      int durationMs = mp.getDuration();
+      if (durationMs > 0) {
+        durationSeconds = durationMs / 1000.0;
+      }
+      mp.setVolume(volume, volume);
+      mp.setLooping(loop);
+      if (pendingSeekSeconds >= 0) {
+        mp.seekTo((long) (pendingSeekSeconds * 1000), MediaPlayer.SEEK_CLOSEST);
+        pendingSeekSeconds = -1;
+      }
+      if (playing) {
+        mp.start();
+      }
+    }
+  }
+
+  /**
+   * The most recently decoded frame, or null when no new frame was decoded
+   * since the last call (or when the consumer holds {@link #MAX_IMAGES}
+   * frames). Close it with {@link #closeImage} once the frame is released.
+   */
+  @DoNotStrip
+  public Image copyLatestFrame() {
+    ImageReader current;
+    synchronized (lock) {
+      if (released || reader == null) {
+        return null;
+      }
+      current = reader;
+    }
+    Image image;
+    try {
+      image = current.acquireLatestImage();
+    } catch (IllegalStateException e) {
+      Log.w(TAG, "copyLatestFrame: every frame is held, release one to get a new frame");
+      return null;
+    }
+    if (image == null) {
+      return null;
+    }
+    synchronized (lock) {
+      acquired.add(image);
+    }
+    return image;
+  }
+
+  /** Hands the buffer of a frame returned by {@link #copyLatestFrame} back to the decoder. */
+  @DoNotStrip
+  public void closeImage(Image image) {
+    synchronized (lock) {
+      if (!acquired.remove(image)) {
+        return;
+      }
+    }
+    image.close();
+  }
+
+  @DoNotStrip
+  public void play() {
+    synchronized (lock) {
+      playing = true;
+      if (player != null && prepared) {
+        player.start();
+      }
+    }
+  }
+
+  @DoNotStrip
+  public void pause() {
+    synchronized (lock) {
+      playing = false;
+      if (player != null && prepared && player.isPlaying()) {
+        player.pause();
+      }
+    }
+  }
+
+  @DoNotStrip
+  public boolean getPaused() {
+    synchronized (lock) {
+      return !playing;
+    }
+  }
+
+  @DoNotStrip
+  public double getCurrentTime() {
+    synchronized (lock) {
+      if (player != null && prepared) {
+        return player.getCurrentPosition() / 1000.0;
+      }
+      return pendingSeekSeconds >= 0 ? pendingSeekSeconds : 0;
+    }
+  }
+
+  // An exact seek, also while paused: the decoder then renders the frame at
+  // the new position, which the next copyLatestFrame() returns.
+  @DoNotStrip
+  public void seek(double seconds) {
+    synchronized (lock) {
+      if (player != null && prepared) {
+        player.seekTo((long) (Math.max(0, seconds) * 1000), MediaPlayer.SEEK_CLOSEST);
+      } else {
+        pendingSeekSeconds = Math.max(0, seconds);
+      }
+    }
+  }
+
+  @DoNotStrip
+  public double getDuration() {
+    return durationSeconds;
+  }
+
+  @DoNotStrip
+  public double getVolume() {
+    synchronized (lock) {
+      return volume;
+    }
+  }
+
+  @DoNotStrip
+  public void setVolume(double value) {
+    synchronized (lock) {
+      volume = (float) Math.max(0, Math.min(1, value));
+      if (player != null) {
+        player.setVolume(volume, volume);
+      }
+    }
+  }
+
+  @DoNotStrip
+  public boolean getLoop() {
+    synchronized (lock) {
+      return loop;
+    }
+  }
+
+  @DoNotStrip
+  public void setLoop(boolean value) {
+    synchronized (lock) {
+      loop = value;
+      if (player != null) {
+        player.setLooping(value);
+      }
+    }
+  }
+
+  @DoNotStrip
+  public int getVideoWidth() {
+    return width;
+  }
+
+  @DoNotStrip
+  public int getVideoHeight() {
+    return height;
+  }
+
+  @DoNotStrip
+  public int getRotation() {
+    return rotation;
+  }
+
+  @DoNotStrip
+  public double getFrameRate() {
+    return frameRate;
+  }
+
+  /** Stops playback and releases the decoder. Frames already copied stay valid until closed. */
+  @DoNotStrip
+  public void release() {
+    MediaPlayer mp;
+    ImageReader current;
+    synchronized (lock) {
+      if (released) {
+        return;
+      }
+      released = true;
+      playing = false;
+      mp = player;
+      player = null;
+      current = reader;
+      reader = null;
+      acquired.clear();
+    }
+    if (mp != null) {
+      mp.release();
+    }
+    if (current != null) {
+      current.close();
+    }
+  }
+}

package/apple/AppleVideoPlayer.mm

@@ -3,6 +3,9 @@
 #import <AVFoundation/AVFoundation.h>
 #import <CoreVideo/CoreVideo.h>
 
+#include <algorithm>
+#include <atomic>
+#include <memory>
 #include <stdexcept>
 
 namespace rnwgpu {
@@ -16,27 +19,27 @@ namespace {
 // range) means luma is 16..235, chroma is 16..240 (8-bit).
 // Reference: https://en.wikipedia.org/wiki/YCbCr (BT.601 / BT.709).
 static constexpr float kBT709LimitedToRgb[12] = {
-    1.164383f, 0.000000f, 1.792741f, -0.972945f, //
-    1.164383f, -0.213249f, -0.532909f, 0.301517f, //
-    1.164383f, 2.112402f, 0.000000f, -1.133402f, //
+    1.164383f, 0.000000f,  1.792741f,  -0.972945f, //
+    1.164383f, -0.213249f, -0.532909f, 0.301517f,  //
+    1.164383f, 2.112402f,  0.000000f,  -1.133402f, //
 };
 static constexpr float kBT601LimitedToRgb[12] = {
-    1.164383f, 0.000000f, 1.596027f, -0.874202f, //
-    1.164383f, -0.391762f, -0.812968f, 0.531668f, //
-    1.164383f, 2.017232f, 0.000000f, -1.085631f, //
+    1.164383f, 0.000000f,  1.596027f,  -0.874202f, //
+    1.164383f, -0.391762f, -0.812968f, 0.531668f,  //
+    1.164383f, 2.017232f,  0.000000f,  -1.085631f, //
 };
 static constexpr float kBT2020LimitedToRgb[12] = {
-    1.164383f, 0.000000f, 1.678674f, -0.915688f, //
-    1.164383f, -0.187326f, -0.650424f, 0.347459f, //
-    1.164383f, 2.141772f, 0.000000f, -1.148145f, //
+    1.164383f, 0.000000f,  1.678674f,  -0.915688f, //
+    1.164383f, -0.187326f, -0.650424f, 0.347459f,  //
+    1.164383f, 2.141772f,  0.000000f,  -1.148145f, //
 };
 
 // Pick the right YUV→RGB matrix from the pixel buffer's color attachments.
 // Falls back to BT.709 limited range (the right call for ≥720p H.264, which
 // is what AVPlayer hands us for Big Buck Bunny and most streamed media).
 static void fillYuvMatrix(CVPixelBufferRef pixelBuffer, float out[12]) {
-  CFTypeRef matrixKey = CVBufferGetAttachment(
-      pixelBuffer, kCVImageBufferYCbCrMatrixKey, nullptr);
+  CFTypeRef matrixKey =
+      CVBufferGetAttachment(pixelBuffer, kCVImageBufferYCbCrMatrixKey, nullptr);
   const float *src = kBT709LimitedToRgb;
   if (matrixKey) {
     auto matrix = (CFStringRef)matrixKey;
@@ -53,28 +56,108 @@ static void fillYuvMatrix(CVPixelBufferRef pixelBuffer, float out[12]) {
 }
 
 // Map a CVPixelBuffer's pixel format to our VideoPixelFormat enum.
-static VideoPixelFormat pixelFormatFromCVPixelBuffer(
-    CVPixelBufferRef pixelBuffer) {
+static VideoPixelFormat
+pixelFormatFromCVPixelBuffer(CVPixelBufferRef pixelBuffer) {
   OSType type = CVPixelBufferGetPixelFormatType(pixelBuffer);
   switch (type) {
-    case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
-    case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
-      return VideoPixelFormat::NV12;
-    default:
-      return VideoPixelFormat::BGRA8;
+  case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
+  case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange:
+    return VideoPixelFormat::NV12;
+  default:
+    return VideoPixelFormat::BGRA8;
   }
 }
 
+// The clockwise rotation, in degrees, that a track's preferredTransform
+// applies to its frames: a video recorded in portrait stores landscape frames
+// with a 90 or 270 degree transform.
+static int rotationFromTransform(CGAffineTransform t) {
+  if (t.a == 0 && t.b == 1 && t.c == -1 && t.d == 0) {
+    return 90;
+  }
+  if (t.a == 0 && t.b == -1 && t.c == 1 && t.d == 0) {
+    return 270;
+  }
+  if (t.a == -1 && t.b == 0 && t.c == 0 && t.d == -1) {
+    return 180;
+  }
+  return 0;
+}
+
+// The state the AVFoundation callbacks update. It is shared with the blocks
+// observing the asset and the item, so a callback that fires after the player
+// was destroyed only touches memory that outlives it.
+struct AppleVideoPlayerState {
+  std::atomic<bool> playing{false};
+  std::atomic<bool> loop{true};
+  std::atomic<double> duration{0};
+  std::atomic<double> frameRate{0};
+  std::atomic<uint32_t> width{0};
+  std::atomic<uint32_t> height{0};
+  std::atomic<int> rotation{0};
+};
+
 class AppleVideoPlayer : public IVideoPlayer {
 public:
-  AppleVideoPlayer(AVPlayer *player, AVPlayerItemVideoOutput *output,
-                   id loopObserver)
-      : _player(player), _output(output), _loopObserver(loopObserver) {}
+  AppleVideoPlayer(AVPlayer *player, AVPlayerItem *item,
+                   AVPlayerItemVideoOutput *output)
+      : _player(player), _output(output),
+        _state(std::make_shared<AppleVideoPlayerState>()) {
+    auto state = _state;
+
+    // The metadata loads asynchronously, so that a remote asset never blocks
+    // the calling thread; the getters report 0 until it has.
+    AVAsset *asset = item.asset;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    [asset
+        loadValuesAsynchronouslyForKeys:@[ @"duration", @"tracks" ]
+                      completionHandler:^{
+                        if ([asset statusOfValueForKey:@"duration" error:nil] ==
+                            AVKeyValueStatusLoaded) {
+                          CMTime duration = asset.duration;
+                          if (CMTIME_IS_NUMERIC(duration)) {
+                            state->duration = CMTimeGetSeconds(duration);
+                          }
+                        }
+                        if ([asset statusOfValueForKey:@"tracks" error:nil] ==
+                            AVKeyValueStatusLoaded) {
+                          AVAssetTrack *track =
+                              [[asset tracksWithMediaType:AVMediaTypeVideo]
+                                  firstObject];
+                          if (track) {
+                            CGSize size = track.naturalSize;
+                            state->width = static_cast<uint32_t>(size.width);
+                            state->height = static_cast<uint32_t>(size.height);
+                            state->rotation =
+                                rotationFromTransform(track.preferredTransform);
+                            state->frameRate = track.nominalFrameRate;
+                          }
+                        }
+                      }];
+#pragma clang diagnostic pop
+
+    // At the end of the stream, either loop or stop. The player keeps showing
+    // the last frame either way (actionAtItemEnd is None).
+    __weak AVPlayer *weakPlayer = player;
+    _endObserver = [[NSNotificationCenter defaultCenter]
+        addObserverForName:AVPlayerItemDidPlayToEndTimeNotification
+                    object:item
+                     queue:[NSOperationQueue mainQueue]
+                usingBlock:^(NSNotification * /*note*/) {
+                  if (state->loop) {
+                    [weakPlayer seekToTime:kCMTimeZero];
+                    [weakPlayer play];
+                  } else {
+                    state->playing = false;
+                  }
+                }];
+  }
 
   ~AppleVideoPlayer() override {
-    if (_loopObserver) {
-      [[NSNotificationCenter defaultCenter] removeObserver:_loopObserver];
-      _loopObserver = nil;
+    if (_endObserver) {
+      [[NSNotificationCenter defaultCenter] removeObserver:_endObserver];
+      _endObserver = nil;
     }
     [_player pause];
     _player = nil;
@@ -105,13 +188,51 @@ public:
     }
   }
 
-  void play() override { [_player play]; }
-  void pause() override { [_player pause]; }
+  void play() override {
+    _state->playing = true;
+    [_player play];
+  }
+
+  void pause() override {
+    _state->playing = false;
+    [_player pause];
+  }
+
+  bool paused() override { return !_state->playing; }
+
+  double currentTime() override {
+    CMTime time = [_player currentTime];
+    return CMTIME_IS_NUMERIC(time) ? CMTimeGetSeconds(time) : 0;
+  }
+
+  // An exact seek: the output then holds the frame at that position, also
+  // while paused, so the next copyLatestFrame() returns it.
+  void seek(double seconds) override {
+    [_player seekToTime:CMTimeMakeWithSeconds(seconds, NSEC_PER_SEC)
+        toleranceBefore:kCMTimeZero
+         toleranceAfter:kCMTimeZero];
+  }
+
+  double duration() override { return _state->duration; }
+
+  double volume() override { return _player.volume; }
+  void setVolume(double volume) override {
+    _player.volume = static_cast<float>(std::clamp(volume, 0.0, 1.0));
+  }
+
+  bool loop() override { return _state->loop; }
+  void setLoop(bool loop) override { _state->loop = loop; }
+
+  uint32_t videoWidth() override { return _state->width; }
+  uint32_t videoHeight() override { return _state->height; }
+  int rotation() override { return _state->rotation; }
+  double frameRate() override { return _state->frameRate; }
 
 private:
   AVPlayer *_player;
   AVPlayerItemVideoOutput *_output;
-  id _loopObserver;
+  std::shared_ptr<AppleVideoPlayerState> _state;
+  id _endObserver = nil;
 };
 
 } // namespace
@@ -142,8 +263,8 @@ VideoFrameHandle wrapCVPixelBuffer(CVPixelBufferRef pixelBuffer) {
   return handle;
 }
 
-std::unique_ptr<IVideoPlayer>
-createAppleVideoPlayer(const std::string &path, VideoPixelFormat format) {
+std::unique_ptr<IVideoPlayer> createAppleVideoPlayer(const std::string &path,
+                                                     VideoPixelFormat format) {
   NSString *nsPath = [NSString stringWithUTF8String:path.c_str()];
   NSURL *url;
   if ([nsPath hasPrefix:@"http://"] || [nsPath hasPrefix:@"https://"] ||
@@ -164,8 +285,8 @@ createAppleVideoPlayer(const std::string &path, VideoPixelFormat format) {
   // importExternalTexture. BGRA is the "decode + convert" path for the
   // single-plane SharedTextureMemory demo.
   OSType pixelFormat = format == VideoPixelFormat::NV12
-                          ? kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
-                          : kCVPixelFormatType_32BGRA;
+                           ? kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
+                           : kCVPixelFormatType_32BGRA;
   NSDictionary *outputSettings = @{
     (NSString *)kCVPixelBufferPixelFormatTypeKey : @(pixelFormat),
     (NSString *)kCVPixelBufferIOSurfacePropertiesKey : @{},
@@ -176,20 +297,11 @@ createAppleVideoPlayer(const std::string &path, VideoPixelFormat format) {
   [item addOutput:output];
 
   AVPlayer *player = [AVPlayer playerWithPlayerItem:item];
+  // Keep the last frame at the end of the stream; AppleVideoPlayer decides
+  // whether to loop.
   player.actionAtItemEnd = AVPlayerActionAtItemEndNone;
 
-  // Loop on end-of-stream by seeking back to zero.
-  __weak AVPlayer *weakPlayer = player;
-  id loopObserver = [[NSNotificationCenter defaultCenter]
-      addObserverForName:AVPlayerItemDidPlayToEndTimeNotification
-                  object:item
-                   queue:[NSOperationQueue mainQueue]
-              usingBlock:^(NSNotification * /*note*/) {
-                [weakPlayer seekToTime:kCMTimeZero];
-                [weakPlayer play];
-              }];
-
-  return std::make_unique<AppleVideoPlayer>(player, output, loopObserver);
+  return std::make_unique<AppleVideoPlayer>(player, item, output);
 }
 
 std::string writeAppleTestVideoFile() {
@@ -231,8 +343,7 @@ std::string writeAppleTestVideoFile() {
   writerInput.expectsMediaDataInRealTime = NO;
 
   NSDictionary *bufferAttrs = @{
-    (NSString *)kCVPixelBufferPixelFormatTypeKey :
-        @(kCVPixelFormatType_32BGRA),
+    (NSString *)kCVPixelBufferPixelFormatTypeKey : @(kCVPixelFormatType_32BGRA),
     (NSString *)kCVPixelBufferWidthKey : @(kWidth),
     (NSString *)kCVPixelBufferHeightKey : @(kHeight),
     (NSString *)kCVPixelBufferIOSurfacePropertiesKey : @{},
@@ -274,8 +385,7 @@ std::string writeAppleTestVideoFile() {
       for (int x = 0; x < kWidth; ++x) {
         uint8_t r = static_cast<uint8_t>((x + phase) & 0xFF);
         uint8_t g = static_cast<uint8_t>((y + phase * 2) & 0xFF);
-        uint8_t b =
-            static_cast<uint8_t>(((x + y + phase) & 0x40) ? 220 : 30);
+        uint8_t b = static_cast<uint8_t>(((x + y + phase) & 0x40) ? 220 : 30);
         row[x * 4 + 0] = b;
         row[x * 4 + 1] = g;
         row[x * 4 + 2] = r;