@byteplus/react-native-live-pull 1.1.3-rc.3 → 1.2.0-rc.0

package/ios/pictureInpicture/VeLivePictureInPictureController.m

@@ -1,3393 +0,0 @@
-
-//
-// VeLivePictureInPictureController.m
-// VELLiveDemo
-//
-// Created by Bytedance on 2023-06-09
-//
-
-#import "VeLivePictureInPictureController.h"
-#import <VideoToolbox/VideoToolbox.h>
-#import <objc/runtime.h>
-#define LOG_TAG @"VeLivePictureInPictureController"
-
-FOUNDATION_EXTERN_INLINE void vel_sync_in_main_queue(dispatch_block_t block) {
-  if (NSThread.isMainThread) {
-    block();
-  } else {
-    dispatch_sync(dispatch_get_main_queue(), block);
-  }
-}
-
-@interface VELPipPixelBufferTool : NSObject
-@property(nonatomic, assign) CVPixelBufferPoolRef pixelBufferPool;
-@property(nonatomic, strong) NSRecursiveLock *lock;
-@property(nonatomic, strong)
-    NSMutableDictionary<NSString *, NSValue *> *pixelBufferPoolDict;
-- (CVPixelBufferRef)createDarkFrameWithFrameSize:(CGSize)frameSize;
-- (CVPixelBufferRef)createPixelBuffer:(OSType)type
-                               heigth:(int)height
-                                width:(int)width;
-- (CMSampleBufferRef)sampleBufferFromPixelBuffer:(CVPixelBufferRef)pixelBuffer
-                                             fps:(CMTime)fps
-                                             pts:(CMTime)pts;
-@end
-
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-// MARK: - interface  VELPipAVPlayer
-@interface VELPipAVPlayer : AVPlayer
-- (void)velPause;
-@end
-
-// MARK: - interface  UIView (VELPipAutoSupport)
-@interface UIView (VELPipAutoSupport)
-@property(nonatomic, assign) BOOL vel_autoHideSamplePlayerView;
-@property(nonatomic, assign) BOOL vel_autoHideControlsView;
-@property(nonatomic, weak) UIViewController *vel_viewController;
-@end
-
-// MARK: - interface VELPipAVPlayerView
-@interface VELPipAVPlayerView : UIView
-@property(nonatomic, weak, readonly) AVPlayerLayer *playerLayer;
-@end
-
-// MARK: interface VELPipLoopPlayer
-@interface VELPipLoopPlayer : NSObject
-@property(nonatomic, strong, class, readonly, nullable) VELPipAVPlayer *player;
-@property(nonatomic, assign, class) CGSize videoSize;
-@property(nonatomic, assign, class, readonly) AVPlayerStatus status;
-@property(nonatomic, copy, class) void (^statusBlock)
-    (AVPlayerStatus status, NSError *_Nullable error);
-+ (void)initLoopPlayer;
-+ (void)playWithNotifyStatus:(BOOL)notify;
-+ (void)pause;
-+ (void)stop;
-@end
-#endif // end of VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-
-// MARK: - UIViewController (VELPipTopViewController)
-@interface UIViewController (VELPipTopViewController)
-+ (UIViewController *)vel_pipTopViewController;
-@end
-
-// MARK: - interface VELPipSampleBufferView
-@interface VELPipSampleBufferView : UIView
-@property(nonatomic, strong, readonly) AVSampleBufferDisplayLayer *sampleLayer;
-@property(nonatomic, copy) AVLayerVideoGravity videoGravity;
-- (void)rebuildSamplelayer;
-@end
-static BOOL vel_pip_is_started = NO;
-// MARK: interface VeLivePictureInPictureController
-@interface VeLivePictureInPictureController ()
-@property(nonatomic, strong) UIViewController *storeContentController;
-@property(nonatomic, strong) UIView *contentOriginSuperView;
-@property(nonatomic, assign) CGRect contentOriginFrame;
-@property(atomic, assign, readwrite) VeLivePictureInPictureState state;
-@property(nonatomic, strong, readwrite)
-    AVPictureInPictureController *pipController;
-@property(nonatomic, copy) VELPipPrepareCompletionBlock prepareCompletionBlock;
-@property(atomic, assign, readwrite) VeLivePictureInPictureType type;
-@property(nonatomic, strong, readwrite) UIView *pipHolderView;
-@property(nonatomic, strong) UIViewController *pipWrapperViewController;
-@property(nonatomic, strong) UIView *pipWrapperView;
-@property(nonatomic, assign) VeLivePictureInPictureType originPipType;
-@property(nonatomic, assign) BOOL needStartWhenPrepared;
-@property(nonatomic, assign) BOOL isRestoreUserInterface;
-@property(nonatomic, assign) BOOL isCalledRestoreUserInterface;
-@property(nonatomic, strong) UIImageView *pipHolderImageView;
-@end
-static VeLivePictureInPictureController *vel_instance_pip = nil;
-
-// MARK: interface VeLivePictureInPictureController (VELPipNotify)
-@interface VeLivePictureInPictureController (VELPipNotify)
-- (void)notifyDeleteIsReady;
-- (void)notifyDeleteWillStart;
-- (void)notifyDeleteDidStart;
-- (void)notifyDeleteWillStop;
-- (void)notifyDeleteDidStop;
-- (void)notifyDeleteRestoreUserInterfaceWithCompletion:
-    (void (^)(BOOL restored))completionHandler;
-- (void)notifyDeleteWithError:(NSError *)error;
-@end
-
-// MARK: interface VeLivePictureInPictureController (VELPipContentSource)
-@class VELSampleBufferPlaybackDelegate;
-@class VELPipContentSourceProvider;
-@interface VeLivePictureInPictureController (VELPipContentSource)
-@property(nonatomic, strong)
-    VELSampleBufferPlaybackDelegate *playbackDelegate API_AVAILABLE(
-        ios(15.0), tvos(15.0), macos(12.0)) API_UNAVAILABLE(watchos);
-@property(nonatomic, strong) VELPipContentSourceProvider *sourceProvider;
-- (void)initContentSourcePictureInPicture;
-- (void)releaseContentSourcePictureInPicture;
-- (void)vel_setContentSourceVideoSize:(CGSize)videoSize;
-- (void)setSampleLayerVideoGravity:(AVLayerVideoGravity)videoGravity;
-- (void)vel_enqueuePixelBuffer:(CVPixelBufferRef)pixelBuffer
-                     videoRect:(CGRect)videoRect;
-- (void)vel_enqueueSampleBuffer:(CMSampleBufferRef)sampleBuffer
-                      videoRect:(CGRect)videoRect;
-@end
-
-// MARK: interface VeLivePictureInPictureController
-// (VELPipContentViewPlayerLayer)
-@interface VeLivePictureInPictureController (VELPipContentViewPlayerLayer)
-@property(nonatomic, weak) AVPlayerLayer *contentViewPlayerLayer;
-@property(nonatomic, weak) UIView *contentViewPlayerLayerView;
-- (void)setContentViewPlayerLayerVideoGravity:(AVLayerVideoGravity)videoGravity;
-- (void)initContentViewPlayerLayerPictureInPicture;
-- (void)releaseContentViewPlayerLayerPictureInPicture;
-@end
-
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-// MARK: interface VeLivePictureInPictureController
-// (VELPipContentSourceAVPlayer)
-@interface VeLivePictureInPictureController (VELPipContentSourceAVPlayer)
-@property(nonatomic, strong) VELPipAVPlayerView *contentSourcePlayerView;
-- (void)setContentSourceAVPlayerLayerVideoGravity:
-    (AVLayerVideoGravity)videoGravity;
-- (void)initContentSourceAVPlayerPictureInPicture;
-- (void)releaseContentSourceAVPlayerPictureInPicture;
-@end
-
-// MARK: interface VeLivePictureInPictureController (VELPipAVPlayer)
-@interface VeLivePictureInPictureController (VELPipAVPlayer)
-@property(nonatomic, strong) VELPipAVPlayerView *playerView;
-- (void)setAVPlayerLayerVideoGravity:(AVLayerVideoGravity)videoGravity;
-- (void)initAVPlayerPictureInPicture;
-- (void)releaseAVPlayerPictureInPicture;
-@end
-
-// MARK: interface VeLivePictureInPictureController
-// (VELPipAVPlayerViewController)
-@protocol VELAVPictureInPictureProtocol;
-@interface VeLivePictureInPictureController (VELPipAVPlayerViewController)
-@property(nonatomic, strong)
-    AVPlayerViewController<VELAVPictureInPictureProtocol> *playerViewController;
-- (void)initAVPlayerViewControllerPictureInPicture;
-- (void)releaseAVPlayerViewControllerPictureInPicture;
-- (void)velPlayerVCStartPictureInPicture;
-- (void)velPlayerVCStopPictureInPicture;
-- (BOOL)velPlayerVCCanStartPictureInPicture;
-- (void)setAVPlayerVCVideoGravity:(AVLayerVideoGravity)videoGravity;
-- (void)velPlayerVCSetCanStartPictureInPictureAutomaticallyFromInline:
-    (BOOL)canStart;
-@end
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-
-// MARK: interface VeLivePictureInPictureController
-// (VeLivePictureInPictureDelegate)
-@interface VeLivePictureInPictureController (VeLivePictureInPictureDelegate) <
-    AVPictureInPictureControllerDelegate, AVPlayerViewControllerDelegate>
-@end
-
-// MARK: implementation VeLivePictureInPictureController
-@implementation VeLivePictureInPictureController
-- (instancetype)init {
-  return [self initWithType:(VeLivePictureInPictureTypeAuto)];
-}
-
-- (instancetype)initWithType:(VeLivePictureInPictureType)type {
-  if (self = [super init]) {
-    [self _InitWithType:type contentView:nil];
-  }
-  return self;
-}
-
-- (instancetype)initWithContentView:(UIView *)contentView {
-  if (self = [super init]) {
-    [self _InitWithType:VeLivePictureInPictureTypeAuto contentView:contentView];
-    self.contentView = contentView;
-  }
-  return self;
-}
-
-- (instancetype)initWithType:(VeLivePictureInPictureType)type
-                 contentView:(nullable UIView *)contentView {
-  if (self = [super init]) {
-    [self _InitWithType:(type) contentView:contentView];
-  }
-  return self;
-}
-
-- (void)_InitWithType:(VeLivePictureInPictureType)type
-          contentView:(UIView *)contentView {
-  self.fps = 15;
-  self.videoSourceCount = 1;
-  self.type = type;
-  self.contentView = contentView;
-  self.originPipType = type;
-  self.videoGravity = AVLayerVideoGravityResize;
-  self.autoHideContentController = NO;
-  if (@available(iOS 14.2, *)) {
-    self.canStartPictureInPictureAutomaticallyFromInline = YES;
-  }
-}
-
-- (void)dealloc {
-  VeLivePipLog(LOG_TAG, @"pip dealloc %@", @(self.type));
-}
-
-- (void)setPlaybackAudioSessionWithError:(NSError **)error {
-  /// NOTICE: 不能设置 options 为非 0 的参数，否则不能后台渲染
-  if ([AVAudioSession sharedInstance].category ==
-          AVAudioSessionCategoryPlayback &&
-      [AVAudioSession sharedInstance].category ==
-          AVAudioSessionCategoryPlayAndRecord) {
-    return;
-  }
-  if (@available(iOS 10.0, *)) {
-    [[AVAudioSession sharedInstance] setCategory:AVAudioSessionCategoryPlayback
-                                            mode:AVAudioSessionModeMoviePlayback
-                                         options:(0)error:nil];
-  } else if (@available(iOS 11.0, *)) {
-    [[AVAudioSession sharedInstance]
-               setCategory:AVAudioSessionCategoryPlayback
-                      mode:AVAudioSessionModeMoviePlayback
-        routeSharingPolicy:(AVAudioSessionRouteSharingPolicyDefault)options
-                          :(0)error:nil];
-  } else {
-    [[AVAudioSession sharedInstance] setCategory:AVAudioSessionCategoryPlayback
-                                     withOptions:(0)error:nil];
-  }
-  [[AVAudioSession sharedInstance] setActive:YES error:error];
-}
-
-//  {zh} 准备  {en} prepare
-- (void)prepareWithCompletion:(VELPipPrepareCompletionBlock)completion {
-  if (self.state != VeLivePictureInPictureStateIde &&
-      self.state != VeLivePictureInPictureStateError) {
-    if (completion) {
-      completion(self, nil);
-    }
-    VeLivePipLog(LOG_TAG, @"pip already prepared");
-    return;
-  }
-  //    NSAssert(self.delegate != nil, @"delegate cannot be nil");
-  self.state = VeLivePictureInPictureStatePreparing;
-  self.isRestoreUserInterface = NO;
-  self.isCalledRestoreUserInterface = NO;
-  self.prepareCompletionBlock = completion;
-  {
-    //  {zh} 这部分代码，可根据自身业务需求进行配置  {en} This part of the code
-    //  can be configured according to its own business needs {zh}
-    //  例如是否需要和别的 App 同时播放音频  {en} For example, do you need to
-    //  play audio with other apps at the same time?
-    NSError *error = nil;
-    [self setPlaybackAudioSessionWithError:&error];
-    if (error) {
-      VeLivePipLog(LOG_TAG, @"set audio session playback error %@", error);
-      [self notifyDeleteWithError:error];
-      return;
-    }
-  }
-  [self setupPictureInPictureController];
-}
-
-//  {zh} 开启画中画  {en} Open picture-in-picture
-- (void)startPictureInPicture {
-  self.needStartWhenPrepared = YES;
-  [self _startPictureInPicture];
-}
-
-- (void)_startPictureInPicture {
-  if (self.state == VeLivePictureInPictureStateRunning) {
-    return;
-  }
-  if (self.state == VeLivePictureInPictureStateError) {
-    self.state = VeLivePictureInPictureStateIde;
-    [self destroyPictureInPicture];
-    [self prepareWithCompletion:nil];
-  } else {
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-    if (self.type != VeLivePictureInPictureTypeContentViewPlayerLayer) {
-      [VELPipLoopPlayer playWithNotifyStatus:NO];
-    }
-    if (self.type == VeLivePictureInPictureTypeAVPlayerViewController) {
-      [self velPlayerVCStartPictureInPicture];
-    } else {
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-      [self pipControllerStartPictureInPicture];
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-    }
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  }
-}
-
-- (void)pipControllerStartPictureInPicture {
-  if (!self.canStartPictureInPicture) {
-    VeLivePipLog(LOG_TAG,
-                 @"can not start pip state:%@ pipIsPossible:%@, check app has "
-                 @"audio playing?",
-                 @(self.state),
-                 @(self.pipController.isPictureInPicturePossible));
-    [self
-        notifyDeleteWithError:
-            VeLivePipError(VeLivePictureInPictureErrorCodeNotPossible,
-                           @"can not start pip, check app has audio playing?")];
-    return;
-  }
-  VeLivePipLog(LOG_TAG, @"call pip controller to start pip");
-  [self.pipController startPictureInPicture];
-  self.state = VeLivePictureInPictureStateRunning;
-}
-
-//  {zh} 停止画中画  {en} Stop picture-in-picture
-- (void)stopPictureInPicture {
-  self.needStartWhenPrepared = NO;
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  if (self.type == VeLivePictureInPictureTypeAVPlayerViewController) {
-    [self velPlayerVCStopPictureInPicture];
-  } else {
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-    [self _stopPictureInPicture];
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  }
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-}
-
-- (void)destroyPictureInPicture {
-  VeLivePipLog(LOG_TAG, @"destroy pip with type:%@", @(self.type));
-  switch (self.type) {
-  case VeLivePictureInPictureTypeContentSource:
-    [self releaseContentSourcePictureInPicture];
-    break;
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  case VeLivePictureInPictureTypeContentSourceAVPlayer:
-    [self releaseContentSourceAVPlayerPictureInPicture];
-    break;
-  case VeLivePictureInPictureTypeAVPlayer:
-    [self releaseAVPlayerPictureInPicture];
-    break;
-  case VeLivePictureInPictureTypeAVPlayerViewController:
-    [self releaseAVPlayerViewControllerPictureInPicture];
-    break;
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  case VeLivePictureInPictureTypeContentViewPlayerLayer:
-    [self releaseContentViewPlayerLayerPictureInPicture];
-    break;
-  default:
-    break;
-  }
-
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  VeLivePipLog(LOG_TAG, @"destroy pip and player");
-  [VELPipLoopPlayer stop];
-#endif
-}
-
-- (void)_stopPictureInPicture {
-  if (self.state != VeLivePictureInPictureStateRunning) {
-    VeLivePipLog(LOG_TAG, @"pip not running");
-    return;
-  }
-  if (self.pipController.isPictureInPictureActive) {
-    [self.pipController stopPictureInPicture];
-    self.state = VeLivePictureInPictureStateStopping;
-    VeLivePipLog(LOG_TAG, @"call pip controller to stop pip");
-  } else {
-    self.state = VeLivePictureInPictureStateIde;
-    VeLivePipLog(LOG_TAG, @"pip not active set state for ide");
-  }
-  if (@available(iOS 14.2, *)) {
-    [self setupAutomaticallyFromInLine];
-  }
-}
-
-+ (void)destroyPictureInPicture {
-  [vel_instance_pip destroyPictureInPicture];
-}
-
-+ (BOOL)isPictureInPictureSupported {
-  return [AVPictureInPictureController isPictureInPictureSupported];
-}
-
-+ (BOOL)isPictureInPictureStarted {
-  return vel_pip_is_started && vel_instance_pip != nil;
-}
-
-// MARK: - Private
-- (void)autoSelectType {
-  if (self.type != VeLivePictureInPictureTypeAuto) {
-    return;
-  }
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  [self checkContentViewHasPlayerLayer];
-  if (@available(iOS 15.0, *)) {
-    self.type = VeLivePictureInPictureTypeContentSource;
-  } else {
-    self.type = VeLivePictureInPictureTypeAVPlayer;
-  }
-#else
-  if (@available(iOS 15.0, *)) {
-    self.type = VeLivePictureInPictureTypeContentSource;
-  } else {
-    [self notifyDeleteWithError:VeLivePipError(
-                                    VeLivePictureInPictureErrorCodeNotPossible,
-                                    @"pip is not possible")];
-  }
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-}
-
-- (void)setupPictureInPictureController {
-  self.state = VeLivePictureInPictureStateIde;
-  if (self.contentView == nil) {
-    VeLivePipLog(LOG_TAG, @"content view is null");
-    [self notifyDeleteWithError:VeLivePipError(
-                                    VeLivePictureInPictureErrorCodeNotPossible,
-                                    @"no content view")];
-    return;
-  }
-  [self setupPictureInPictureWithType];
-}
-
-- (void)setupPictureInPictureWithType {
-  [self autoSelectType];
-  switch (self.type) {
-  case VeLivePictureInPictureTypeContentSource:
-    [self initContentSourcePictureInPicture];
-    break;
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  case VeLivePictureInPictureTypeContentSourceAVPlayer:
-    [self initContentSourceAVPlayerPictureInPicture];
-    break;
-  case VeLivePictureInPictureTypeAVPlayer:
-    [self initAVPlayerPictureInPicture];
-    break;
-  case VeLivePictureInPictureTypeAVPlayerViewController:
-    [self initAVPlayerViewControllerPictureInPicture];
-    break;
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  case VeLivePictureInPictureTypeContentViewPlayerLayer:
-    [self initContentViewPlayerLayerPictureInPicture];
-    break;
-  default:
-    [self notifyDeleteWithError:VeLivePipError(
-                                    VeLivePictureInPictureErrorCodeNotPossible,
-                                    @"type unknown")];
-    break;
-  }
-  [self setupVideoGravity];
-}
-
-- (void)setupPipHolderView {
-  if (self.type == VeLivePictureInPictureTypeContentViewPlayerLayer) {
-    return;
-  }
-  if (self.contentView == nil) {
-    VeLivePipLog(LOG_TAG, @"content view is null");
-    [self notifyDeleteWithError:VeLivePipError(
-                                    VeLivePictureInPictureErrorCodeNotPossible,
-                                    @"no content view")];
-    return;
-  }
-  if (self.pipHolderView == nil || self.contentOriginSuperView == nil) {
-    return;
-  }
-  [self setupVideoSizeHolders];
-  self.pipHolderView.alpha = 1;
-  self.pipHolderView.frame = self.videoFrame;
-  if (self.pipHolderView.superview != self.contentOriginSuperView) {
-    [self.contentOriginSuperView insertSubview:self.pipHolderView
-                                  belowSubview:self.contentView];
-  }
-}
-
-- (void)setupVideoSizeHolders {
-  if (self.type == VeLivePictureInPictureTypeContentViewPlayerLayer) {
-    return;
-  }
-  if (CGRectEqualToRect(_videoFrame, CGRectZero)) {
-    return;
-  }
-  [self vel_setContentSourceVideoSize:self.videoSize];
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  [VELPipLoopPlayer setVideoSize:self.videoSize];
-#endif
-}
-
-- (void)storeContentViewOriginIfNeed {
-  if (self.contentView.superview == self.contentOriginSuperView) {
-    self.contentOriginFrame = self.contentView.frame;
-    [self setupPipHolderView];
-  }
-
-  if (CGRectEqualToRect(CGRectZero, self.videoFrame)) {
-    self.videoFrame = self.contentOriginFrame;
-  }
-}
-
-- (void)setupVideoGravity {
-  if (self.state == VeLivePictureInPictureStateIde) {
-    return;
-  }
-  switch (self.type) {
-  case VeLivePictureInPictureTypeContentSource:
-    [self setSampleLayerVideoGravity:self.videoGravity];
-    break;
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  case VeLivePictureInPictureTypeContentSourceAVPlayer:
-    [self setContentSourceAVPlayerLayerVideoGravity:self.videoGravity];
-    break;
-  case VeLivePictureInPictureTypeAVPlayer:
-    [self setAVPlayerVCVideoGravity:self.videoGravity];
-    break;
-  case VeLivePictureInPictureTypeAVPlayerViewController:
-    [self setAVPlayerVCVideoGravity:self.videoGravity];
-    break;
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  case VeLivePictureInPictureTypeContentViewPlayerLayer:
-    [self setContentViewPlayerLayerVideoGravity:self.videoGravity];
-    break;
-  default:
-    [self notifyDeleteWithError:VeLivePipError(
-                                    VeLivePictureInPictureErrorCodeNotPossible,
-                                    @"type unknown")];
-    break;
-  }
-}
-
-- (void)setupAutomaticallyFromInLine API_AVAILABLE(ios(14.2)) {
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  if (self.type == VeLivePictureInPictureTypeAVPlayerViewController) {
-    [self velPlayerVCSetCanStartPictureInPictureAutomaticallyFromInline:
-              self.canStartPictureInPictureAutomaticallyFromInline];
-  } else {
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-    self.pipController.canStartPictureInPictureAutomaticallyFromInline =
-        self.canStartPictureInPictureAutomaticallyFromInline;
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  }
-#endif
-}
-
-- (void)checkContentViewHasPlayerLayer {
-  UIView *layerView = nil;
-  self.contentViewPlayerLayer = [self findPlayerLayerInView:self.contentView
-                                                  layerView:&layerView];
-  self.contentViewPlayerLayerView = layerView;
-  if (self.contentViewPlayerLayer != nil) {
-    BOOL needStart = NO;
-    if (self.state == VeLivePictureInPictureStateRunning ||
-        self.state == VeLivePictureInPictureStatePreparing) {
-      [self stopPictureInPicture];
-      [self destroyPictureInPicture];
-      needStart = YES;
-    }
-    self.type = VeLivePictureInPictureTypeContentViewPlayerLayer;
-    if (needStart) {
-      [self startPictureInPicture];
-    }
-  }
-}
-- (AVPlayerLayer *)findPlayerLayerInView:(UIView *)view
-                               layerView:
-                                   (UIView *_Nullable *_Nullable)layerView {
-  AVPlayerLayer *layer = (AVPlayerLayer *)view.layer;
-  if ([layer isKindOfClass:AVPlayerLayer.class]) {
-    if (layerView != NULL) {
-      *layerView = view;
-    }
-    return (AVPlayerLayer *)layer;
-  }
-
-  for (CALayer *l in layer.sublayers) {
-    AVPlayerLayer *playerLayer = [self findPlayerLayerInLayer:l];
-    if (playerLayer != nil) {
-      if (layerView != NULL) {
-        *layerView = view;
-      }
-      return playerLayer;
-    }
-  }
-
-  for (UIView *v in view.subviews) {
-    AVPlayerLayer *layer = [self findPlayerLayerInView:v layerView:layerView];
-    if (layer != nil) {
-      return layer;
-    }
-  }
-  return nil;
-}
-
-- (AVPlayerLayer *)findPlayerLayerInLayer:(CALayer *)layer {
-  if ([layer isKindOfClass:AVPlayerLayer.class]) {
-    return (AVPlayerLayer *)layer;
-  }
-  for (CALayer *l in layer.sublayers) {
-    AVPlayerLayer *layer = [self findPlayerLayerInLayer:l];
-    if (layer != nil) {
-      return layer;
-    }
-  }
-  return nil;
-}
-
-// MARK: - Setter
-- (void)setContentView:(UIView *)contentView {
-  if (_contentView != contentView ||
-      contentView.superview != _contentView.superview) {
-    _contentView = contentView;
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-    [self checkContentViewHasPlayerLayer];
-#endif
-    self.contentOriginSuperView = self.contentView.superview;
-    self.contentOriginFrame = self.contentView.frame;
-    if (CGRectEqualToRect(CGRectZero, self.contentOriginFrame)) {
-      self.contentOriginFrame =
-          CGRectMake(CGRectGetMidX(UIScreen.mainScreen.bounds) - 120,
-                     CGRectGetMinY(UIScreen.mainScreen.bounds) - 90, 240, 180);
-    }
-    [self setVideoFrame:self.contentOriginFrame];
-    [self setupPipHolderView];
-  }
-}
-
-- (void)setVideoFrame:(CGRect)videoFrame {
-  if (!CGRectEqualToRect(_videoFrame, videoFrame)) {
-    VeLivePipLog(LOG_TAG, @"set videoFrame %@", NSStringFromCGRect(videoFrame));
-    _videoFrame = videoFrame;
-    if (CGSizeEqualToSize(_videoSize, CGSizeZero)) {
-      _videoSize = videoFrame.size;
-    }
-    [self setupPipHolderView];
-  }
-}
-
-- (void)setVideoSize:(CGSize)videoSize {
-  if (!CGSizeEqualToSize(_videoSize, videoSize)) {
-    VeLivePipLog(LOG_TAG, @"set video size %@", NSStringFromCGSize(videoSize));
-    _videoSize = videoSize;
-    [self setupVideoSizeHolders];
-  }
-}
-
-- (void)setVideoGravity:(AVLayerVideoGravity)videoGravity {
-  if (![_videoGravity isEqualToString:videoGravity]) {
-    _videoGravity = videoGravity.copy;
-    [self setupVideoGravity];
-  }
-}
-
-- (void)setCanStartPictureInPictureAutomaticallyFromInline:
-    (BOOL)canStartPictureInPictureAutomaticallyFromInline
-    API_AVAILABLE(ios(14.2)) {
-  if (_canStartPictureInPictureAutomaticallyFromInline !=
-      canStartPictureInPictureAutomaticallyFromInline) {
-    _canStartPictureInPictureAutomaticallyFromInline =
-        canStartPictureInPictureAutomaticallyFromInline;
-    [self setupAutomaticallyFromInLine];
-  }
-}
-
-- (void)setPipHolderView:(UIView *)pipHolderView {
-  if (_pipHolderView != pipHolderView) {
-    _pipHolderView = pipHolderView;
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-    _pipHolderView.vel_autoHideControlsView = YES;
-#endif
-    [self setupPipHolderView];
-  }
-}
-
-// MARK: - Setter
-- (void)setPipController:(AVPictureInPictureController *)pipController {
-  if (_pipController != pipController) {
-    _pipController = pipController;
-    if (@available(iOS 14.0, *)) {
-      pipController.requiresLinearPlayback = YES;
-      [pipController setValue:[NSNumber numberWithInt:1]
-                       forKey:@"controlsStyle"];
-    }
-    if (@available(iOS 14.2, *)) {
-      pipController.canStartPictureInPictureAutomaticallyFromInline =
-          self.canStartPictureInPictureAutomaticallyFromInline;
-    }
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-    @try {
-      [pipController setValue:[NSNumber numberWithInt:1]
-                       forKey:@"controlsStyle"];
-    } @catch (NSException *exception) {
-    }
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  }
-}
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-// MARK: - Getter
-- (UIViewController *)pipWrapperController {
-  @try {
-    NSString *selStr =
-        [NSString stringWithFormat:@"%@%@%@", @"pictu", @"reInPictureV",
-                                   @"iewController"];
-    if ([self.pipController respondsToSelector:NSSelectorFromString(selStr)]) {
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
-      return [self.pipController performSelector:NSSelectorFromString(selStr)];
-#pragma clang diagnostic pop
-    }
-  } @catch (NSException *exception) {
-  }
-
-  return nil;
-}
-
-- (UIView *)pipWrapperView {
-  if (!_pipWrapperView) {
-    UIView *view = self.pipWrapperController.view;
-    view.backgroundColor = UIColor.clearColor;
-    view.vel_autoHideSamplePlayerView = YES;
-    _pipWrapperView = view;
-  }
-  return _pipWrapperView;
-}
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-- (BOOL)canStartPictureInPicture {
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  if (self.type == VeLivePictureInPictureTypeAVPlayerViewController) {
-    return [self velPlayerVCCanStartPictureInPicture];
-  }
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  return [self _canStartPictureInPicture];
-}
-
-- (BOOL)isPictureInPictureStarted {
-  return VeLivePictureInPictureController.isPictureInPictureStarted;
-}
-
-- (BOOL)isPictureInPictureSupported {
-  return VeLivePictureInPictureController.isPictureInPictureSupported;
-}
-
-- (BOOL)_canStartPictureInPicture {
-  return self.state == VeLivePictureInPictureStateReady &&
-         self.pipController.isPictureInPicturePossible;
-}
-
-- (void)enqueuePixelBuffer:(nonnull CVPixelBufferRef)pixelBuffer {
-  [self enqueuePixelBuffer:pixelBuffer
-                 videoRect:VELPixtureInPictureFullVideoRect];
-}
-
-- (void)enqueuePixelBuffer:(nonnull CVPixelBufferRef)pixelBuffer
-                 videoRect:(CGRect)videoRect {
-  [self vel_enqueuePixelBuffer:pixelBuffer videoRect:videoRect];
-}
-
-- (void)enqueueSampleBuffer:(CMSampleBufferRef)sampleBuffer {
-  [self enqueueSampleBuffer:sampleBuffer
-                  videoRect:VELPixtureInPictureFullVideoRect];
-}
-
-- (void)enqueueSampleBuffer:(nonnull CMSampleBufferRef)sampleBuffer
-                  videoRect:(CGRect)videoRect {
-  [self vel_enqueueSampleBuffer:sampleBuffer videoRect:videoRect];
-}
-
-@end
-
-// MARK: - implementation VeLivePictureInPictureController (VELPipNotify)
-@implementation VeLivePictureInPictureController (VELPipNotify)
-
-- (void)notifyDeleteIsReady {
-  VeLivePipLog(LOG_TAG, @"pip is ready");
-  vel_sync_in_main_queue(^{
-    self.state = VeLivePictureInPictureStateReady;
-    self.isRestoreUserInterface = NO;
-    if (self.prepareCompletionBlock) {
-      self.prepareCompletionBlock(self, nil);
-    }
-    if (self.delegate && [self.delegate respondsToSelector:@selector
-                                        (pictureInPictureIsReady:)]) {
-      [self.delegate pictureInPictureIsReady:self];
-    }
-    if (self.needStartWhenPrepared &&
-        self.state == VeLivePictureInPictureStateReady) {
-      VeLivePipLog(LOG_TAG, @"pip is ready, auto start...");
-      [self _startPictureInPicture];
-    }
-  });
-}
-
-- (void)setupPipPlayerContentView {
-  self.state = VeLivePictureInPictureStateRunning;
-  vel_pip_is_started = YES;
-  vel_instance_pip = self;
-  [self storeContentViewOriginIfNeed];
-  [self hideContentControllerIfNeed];
-  [self setupContentViewFullInPipWrapperViewIfNeed];
-  [self adjustContentViewHidden:YES];
-}
-
-- (void)notifyDeleteWillStart {
-  VeLivePipLog(LOG_TAG, @"pip will start");
-  vel_sync_in_main_queue(^{
-    [self setupPipPlayerContentView];
-    if (self.delegate && [self.delegate respondsToSelector:@selector
-                                        (pictureInPictureWillStart:)]) {
-      [self.delegate pictureInPictureWillStart:self];
-    }
-  });
-}
-
-- (void)notifyDeleteDidStart {
-  VeLivePipLog(LOG_TAG, @"pip did start");
-  vel_sync_in_main_queue(^{
-    [self setupPipPlayerContentView];
-    self.pipHolderView.alpha = 1;
-    if (self.delegate && [self.delegate respondsToSelector:@selector
-                                        (pictureInPictureDidStart:)]) {
-      [self.delegate pictureInPictureDidStart:self];
-    }
-  });
-}
-
-- (void)notifyDeleteWillStop {
-  VeLivePipLog(LOG_TAG, @"pip will stop");
-  vel_sync_in_main_queue(^{
-    self.pipHolderView.alpha = 0.01;
-    self.needStartWhenPrepared = NO;
-    [self generatedPlacdholderImageViewFor:self.contentView];
-    if (!self.isRestoreUserInterface || self.autoHideContentController) {
-      [self
-          notifyDeleteRestoreUserInterfaceWithCompletion:nil
-                                              isUserStop:
-                                                  !self.isRestoreUserInterface];
-    } else if (!self.isCalledRestoreUserInterface) {
-      VeLivePipLog(
-          LOG_TAG,
-          @"pip will stop, but not call restore user interface, call once");
-      [self
-          notifyDeleteRestoreUserInterfaceWithCompletion:nil
-                                              isUserStop:
-                                                  !self.isRestoreUserInterface];
-    }
-    if (self.delegate && [self.delegate respondsToSelector:@selector
-                                        (pictureInPictureWillStop:
-                                                       isUserStop:)]) {
-      [self.delegate pictureInPictureWillStop:self
-                                   isUserStop:!self.isRestoreUserInterface];
-    }
-    [self hidePipHolderSnapshotView];
-  });
-}
-
-- (void)notifyDeleteDidStop {
-  VeLivePipLog(LOG_TAG, @"pip did stop");
-  vel_sync_in_main_queue(^{
-    if (self.isRestoreUserInterface && !self.autoHideContentController) {
-      [self
-          notifyDeleteRestoreUserInterfaceWithCompletion:nil
-                                              isUserStop:
-                                                  !self.isRestoreUserInterface];
-    } else if (!self.isCalledRestoreUserInterface) {
-      VeLivePipLog(
-          LOG_TAG,
-          @"pip did stop, but not call restore user interface, call once");
-      [self
-          notifyDeleteRestoreUserInterfaceWithCompletion:nil
-                                              isUserStop:
-                                                  !self.isRestoreUserInterface];
-    }
-
-    if (self.delegate && [self.delegate respondsToSelector:@selector
-                                        (pictureInPictureDidStop:
-                                                      isUserStop:)]) {
-      [self.delegate pictureInPictureDidStop:self
-                                  isUserStop:!self.isRestoreUserInterface];
-    }
-    self.needStartWhenPrepared = NO;
-    self.isRestoreUserInterface = NO;
-    self.isCalledRestoreUserInterface = NO;
-    self.state = VeLivePictureInPictureStateReady;
-    [self hidePipHolderSnapshotView];
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-    // play loop video
-    if (self.type != VeLivePictureInPictureTypeContentViewPlayerLayer) {
-      [VELPipLoopPlayer playWithNotifyStatus:NO];
-    }
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  });
-}
-
-- (void)notifyDeleteRestoreUserInterfaceWithCompletion:
-    (void (^)(BOOL restored))completionHandler {
-  VeLivePipLog(LOG_TAG, @"pip restore user interface");
-  self.isRestoreUserInterface = YES;
-  self.isCalledRestoreUserInterface = YES;
-  if (completionHandler) {
-    completionHandler(YES);
-  }
-}
-
-- (void)notifyDeleteRestoreUserInterfaceWithCompletion:
-            (void (^)(BOOL restored))completionHandler
-                                            isUserStop:(BOOL)isUserStop {
-  VeLivePipLog(LOG_TAG, @"pip restore user interface isUserStop:%@",
-               @(isUserStop));
-  vel_sync_in_main_queue(^{
-    vel_instance_pip = nil;
-    vel_pip_is_started = NO;
-    self.needStartWhenPrepared = NO;
-
-    [self generatedPlacdholderImageViewFor:self.contentView];
-
-    [self showContentControllerIfNeedIsUserStop:isUserStop];
-
-    void (^CompletionBlock)(BOOL restored) = ^(BOOL restored) {
-      if (completionHandler) {
-        completionHandler(restored);
-      }
-      self.pipHolderView.alpha = 0.01;
-      /// hide place holder
-      [self hidePipHolderSnapshotView];
-    };
-
-    if (self.delegate &&
-        [self.delegate
-            respondsToSelector:@selector
-            (pictureInPicture:
-                restoreUserInterfaceWithCompletionHandler:isUserStop:)]) {
-      [self.delegate pictureInPicture:self
-          restoreUserInterfaceWithCompletionHandler:CompletionBlock
-                                         isUserStop:isUserStop];
-    } else {
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-      [self _InnerRestoreUserInterfaceWithCompletion:CompletionBlock
-                                          isUserStop:isUserStop];
-#endif
-    }
-  });
-}
-
-- (void)notifyDeleteWithError:(NSError *)error {
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  if (self.downgradeWhenStartFailed &&
-      self.type > VeLivePictureInPictureTypeAVPlayer &&
-      self.type <= VeLivePictureInPictureTypeAuto) {
-    VeLivePipLog(LOG_TAG, @"pip retry with error %@", error);
-    [self destroyPictureInPicture];
-    self.type = self.type - 1;
-    self.state = VeLivePictureInPictureStateIde;
-    [self prepareWithCompletion:self.prepareCompletionBlock];
-  } else {
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-    VeLivePipLog(LOG_TAG, @"pip with error %@", error);
-    [self notifyDeleteRestoreUserInterfaceWithCompletion:nil isUserStop:NO];
-    self.type = self.originPipType;
-    [self autoSelectType];
-    self.state = VeLivePictureInPictureStateError;
-    self.needStartWhenPrepared = NO;
-    vel_sync_in_main_queue(^{
-      vel_pip_is_started = NO;
-      vel_instance_pip = nil;
-      if (self.delegate &&
-          [self.delegate respondsToSelector:@selector(pictureInPicture:
-                                                failedToStartWithError:)]) {
-        [self.delegate pictureInPicture:self failedToStartWithError:error];
-      }
-      if (self.prepareCompletionBlock) {
-        self.prepareCompletionBlock(self, error);
-      }
-      [self hidePipHolderSnapshotView];
-    });
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  }
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-}
-
-// MARK: - content view layout
-- (void)setupContentViewFullInPipWrapperViewIfNeed {
-  if (self.type == VeLivePictureInPictureTypeContentViewPlayerLayer) {
-    return;
-  }
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-  self.pipHolderView.alpha = 1;
-  if (self.contentView.superview != self.pipWrapperView) {
-    [self.contentView removeFromSuperview];
-    if (!CGRectEqualToRect(self.pipWrapperView.bounds, CGRectZero)) {
-      self.contentView.frame = self.pipWrapperView.bounds;
-    }
-    [self.pipWrapperView addSubview:self.contentView];
-    [self addFullContraints:self.pipWrapperView contentView:self.contentView];
-  }
-#endif
-}
-
-- (void)adjustContentViewHidden:(BOOL)hidden {
-  if (@available(iOS 15.0, *)) {
-    if (self.type == VeLivePictureInPictureTypeContentSource) {
-      self.contentView.hidden = hidden;
-    }
-  }
-}
-
-- (void)hideContentControllerIfNeed {
-  if (!self.contentController || !self.autoHideContentController) {
-    self.storeContentController = nil;
-    return;
-  }
-  if (self.storeContentController != nil) {
-    return;
-  }
-  /// add holder
-  [self generatedPlacdholderImageViewFor:self.contentView];
-  //  {zh} 如果想要做特效转场，自行实现  {en} If you want to do special effects
-  //  transitions, do it yourself
-  self.storeContentController = self.contentController;
-  if (self.contentController.presentingViewController) {
-    [self.contentController.presentingViewController
-        dismissViewControllerAnimated:NO
-                           completion:nil];
-  } else if (self.contentController.navigationController &&
-             self.contentController !=
-                 self.contentController.navigationController.viewControllers
-                     .firstObject) {
-    [self.contentController.navigationController popViewControllerAnimated:NO];
-  } else {
-    self.autoHideContentController = NO;
-    self.storeContentController = nil;
-    VeLivePipLog(LOG_TAG, @"can not dismiss contentController");
-  }
-}
-
-- (void)showContentControllerIfNeedIsUserStop:(BOOL)isUserStop {
-  if (!self.contentController || !self.autoHideContentController) {
-    self.storeContentController = nil;
-    return;
-  }
-
-  if (isUserStop) {
-    self.storeContentController = nil;
-    return;
-  }
-
-  if (self.storeContentController == nil) {
-    return;
-  }
-  [self generatedPlacdholderImageViewFor:self.contentView];
-  VeLivePipLog(LOG_TAG, @"show content controller");
-  //  {zh} 如果想要做特效转场，自行实现  {en} If you want to do special effects
-  //  transitions, do it yourself
-  UIViewController *topVC = [UIViewController vel_pipTopViewController];
-  if ([topVC isKindOfClass:UINavigationController.class]) {
-    [(UINavigationController *)topVC pushViewController:self.contentController
-                                               animated:NO];
-  } else if (topVC.navigationController != nil) {
-    [topVC.navigationController pushViewController:self.contentController
-                                          animated:NO];
-  } else {
-    [topVC presentViewController:self.contentController
-                        animated:NO
-                      completion:nil];
-  }
-  self.storeContentController = nil;
-}
-
-- (void)generatedPlacdholderImageViewFor:(UIView *)view {
-  if (self.type == VeLivePictureInPictureTypeContentViewPlayerLayer) {
-    return;
-  }
-  if (self.pipHolderImageView != nil) {
-    [self.pipHolderImageView removeFromSuperview];
-  }
-  UIView *superView = view.superview;
-  if (superView == nil) {
-    return;
-  }
-  UIImage *holderImage = [self generateImageForView:view];
-  self.pipHolderImageView = [[UIImageView alloc] initWithFrame:view.frame];
-  self.pipHolderImageView.contentMode = UIViewContentModeScaleAspectFit;
-  self.pipHolderImageView.image = holderImage;
-  [superView insertSubview:self.pipHolderImageView aboveSubview:view];
-  self.pipHolderImageView.translatesAutoresizingMaskIntoConstraints = NO;
-  [superView addConstraints:@[
-    [self.pipHolderImageView.topAnchor constraintEqualToAnchor:view.topAnchor],
-    [self.pipHolderImageView.leftAnchor
-        constraintEqualToAnchor:view.leftAnchor],
-    [self.pipHolderImageView.rightAnchor
-        constraintEqualToAnchor:view.rightAnchor],
-    [self.pipHolderImageView.bottomAnchor
-        constraintEqualToAnchor:view.bottomAnchor],
-  ]];
-}
-
-- (void)hidePipHolderSnapshotView {
-  if (self.pipHolderImageView != nil) {
-    [UIView animateWithDuration:0.3
-        animations:^{
-          self.pipHolderImageView.alpha = 0;
-        }
-        completion:^(BOOL finished) {
-          [self.pipHolderImageView removeFromSuperview];
-          self.pipHolderImageView = nil;
-        }];
-  }
-  [self adjustContentViewHidden:NO];
-}
-
-- (UIImage *)generateImageForView:(UIView *)view {
-  UIGraphicsBeginImageContextWithOptions(view.bounds.size, YES,
-                                         UIScreen.mainScreen.scale);
-  [view drawViewHierarchyInRect:view.bounds afterScreenUpdates:NO];
-  UIImage *img = UIGraphicsGetImageFromCurrentImageContext();
-  UIGraphicsEndImageContext();
-  return img;
-}
-
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-- (void)_InnerRestoreUserInterfaceWithCompletion:
-            (void (^)(BOOL restored))completionHandler
-                                      isUserStop:(BOOL)isUserStop {
-  if (self.type == VeLivePictureInPictureTypeContentViewPlayerLayer) {
-    return;
-  }
-  if (self.contentView.superview != self.contentOriginSuperView) {
-    [self.contentView removeFromSuperview];
-    if (self.pipHolderView.superview == self.contentOriginSuperView) {
-      [self.contentOriginSuperView insertSubview:self.contentView
-                                    aboveSubview:self.pipHolderView];
-    } else {
-      [self.contentOriginSuperView insertSubview:self.contentView atIndex:0];
-    }
-    void (^LayoutBlock)(void) = nil;
-    if ([self isFullScreenLayout]) {
-      LayoutBlock = ^(void) {
-        self.pipHolderImageView.alpha = 0;
-        self.pipHolderView.alpha = 0.01;
-        [self addFullContraints:self.contentOriginSuperView
-                    contentView:self.contentView];
-        [self.contentView setNeedsLayout];
-        [self.contentView layoutIfNeeded];
-        VeLivePipLog(LOG_TAG,
-                     @"set contentview frame with full screen constraint");
-      };
-    } else {
-      LayoutBlock = ^(void) {
-        self.pipHolderImageView.alpha = 0;
-        self.pipHolderView.alpha = 0.01;
-        self.contentView.translatesAutoresizingMaskIntoConstraints = YES;
-        self.contentView.frame = self.contentOriginFrame;
-        VeLivePipLog(LOG_TAG, @"set contentview frame %@",
-                     NSStringFromCGRect(self.contentOriginFrame));
-      };
-    }
-    [UIView animateWithDuration:0.3
-                     animations:LayoutBlock
-                     completion:^(BOOL finished) {
-                       if (completionHandler) {
-                         completionHandler(YES);
-                       }
-                     }];
-  }
-}
-
-- (void)addLayerAlphaAnimationFor:(UIView *)view to:(CGFloat)to {
-  [self addLayerAlphaAnimationFor:view to:to duration:0.3];
-}
-
-- (void)addLayerAlphaAnimationFor:(UIView *)view
-                               to:(CGFloat)to
-                         duration:(CGFloat)duration {
-  [view.layer removeAllAnimations];
-  if (duration <= 0) {
-    view.alpha = to;
-  } else {
-    CABasicAnimation *flash =
-        [CABasicAnimation animationWithKeyPath:@"opacity"];
-    flash.toValue = [NSNumber numberWithFloat:to];
-    flash.duration = duration;
-    [view.layer addAnimation:flash forKey:@"flashAnimation"];
-  }
-}
-
-//  {zh} 宽高误差在 16 像素的间距内，都默认是全屏展示  {en} The width and height
-//  error is within the spacing of 16 pixels, and the default is full-screen
-//  display.
-- (BOOL)isFullScreenLayout {
-  return ABS(self.contentOriginFrame.size.width -
-             self.contentOriginSuperView.bounds.size.width) < 16 &&
-         ABS(self.contentOriginFrame.size.height -
-             self.contentOriginSuperView.bounds.size.height) < 16;
-}
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-
-- (void)addFullContraints:(UIView *)superView
-              contentView:(UIView *)contentView {
-  if (superView == nil || contentView == nil ||
-      ![superView.subviews containsObject:contentView]) {
-    return;
-  }
-  contentView.translatesAutoresizingMaskIntoConstraints = NO;
-  [superView addConstraints:@[
-    [superView.topAnchor constraintEqualToAnchor:contentView.topAnchor],
-    [superView.leftAnchor constraintEqualToAnchor:contentView.leftAnchor],
-    [superView.rightAnchor constraintEqualToAnchor:contentView.rightAnchor],
-    [superView.bottomAnchor constraintEqualToAnchor:contentView.bottomAnchor],
-  ]];
-}
-@end
-
-// MARK: - implementation VeLivePictureInPictureController
-// (VeLivePictureInPictureDelegate)
-@implementation
-VeLivePictureInPictureController (VeLivePictureInPictureDelegate)
-// AVPictureInPictureControllerDelegate
-- (void)pictureInPictureControllerWillStartPictureInPicture:
-    (AVPictureInPictureController *)pictureInPictureController {
-  [self notifyDeleteWillStart];
-}
-
-- (void)pictureInPictureControllerDidStartPictureInPicture:
-    (AVPictureInPictureController *)pictureInPictureController {
-  [self notifyDeleteDidStart];
-}
-
-- (void)pictureInPictureController:
-            (AVPictureInPictureController *)pictureInPictureController
-    failedToStartPictureInPictureWithError:(NSError *)error {
-  [self notifyDeleteWithError:error];
-}
-
-- (void)pictureInPictureControllerWillStopPictureInPicture:
-    (AVPictureInPictureController *)pictureInPictureController {
-  [self notifyDeleteWillStop];
-}
-
-- (void)pictureInPictureControllerDidStopPictureInPicture:
-    (AVPictureInPictureController *)pictureInPictureController {
-  [self notifyDeleteDidStop];
-}
-
-- (void)pictureInPictureController:
-            (AVPictureInPictureController *)pictureInPictureController
-    restoreUserInterfaceForPictureInPictureStopWithCompletionHandler:
-        (void (^)(BOOL restored))completionHandler {
-  [self notifyDeleteRestoreUserInterfaceWithCompletion:completionHandler];
-}
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-// AVPlayerViewControllerDelegate
-- (void)playerViewControllerWillStartPictureInPicture:
-    (AVPlayerViewController *)playerViewController {
-  [self notifyDeleteWillStart];
-}
-
-- (void)playerViewControllerDidStartPictureInPicture:
-    (AVPlayerViewController *)playerViewController {
-  [self notifyDeleteDidStart];
-}
-
-- (void)playerViewController:(AVPlayerViewController *)playerViewController
-    failedToStartPictureInPictureWithError:(NSError *)error {
-  [self notifyDeleteWithError:error];
-}
-
-- (void)playerViewControllerWillStopPictureInPicture:
-    (AVPlayerViewController *)playerViewController {
-  [self notifyDeleteWillStop];
-}
-
-- (void)playerViewControllerDidStopPictureInPicture:
-    (AVPlayerViewController *)playerViewController {
-  [self notifyDeleteDidStop];
-}
-
-- (void)playerViewController:(AVPlayerViewController *)playerViewController
-    restoreUserInterfaceForPictureInPictureStopWithCompletionHandler:
-        (void (^)(BOOL restored))completionHandler {
-  [self notifyDeleteRestoreUserInterfaceWithCompletion:completionHandler];
-}
-#endif
-@end
-
-// MARK: - interface VELPipContentSourceProvider
-@interface VELPipCachedQueueBuffer : NSObject
-@property(nonatomic, assign) CVPixelBufferRef pixelBuffer;
-@property(nonatomic, assign) CGRect videoRect;
-@property(nonatomic, copy) NSString *key;
-@property(nonatomic, assign) NSTimeInterval lastUpdateTime;
-@end
-@implementation VELPipCachedQueueBuffer
-- (instancetype)initWithBuffer:(CVPixelBufferRef)pixelBuffer
-                     videoRect:(CGRect)videoRect {
-  if (self = [super init]) {
-    self.key = [VELPipCachedQueueBuffer getKeyWithVideoRect:videoRect];
-    self.pixelBuffer = CVPixelBufferRetain(pixelBuffer);
-    self.videoRect = videoRect;
-    self.lastUpdateTime = (NSTimeInterval)CACurrentMediaTime();
-  }
-  return self;
-}
-
-- (CGRect)convertRectFrom:(CGRect)rect {
-  CGFloat x = self.videoRect.origin.x * rect.size.width;
-  CGFloat y = self.videoRect.origin.y * rect.size.height;
-  CGFloat w = self.videoRect.size.width * rect.size.width;
-  CGFloat h = self.videoRect.size.height * rect.size.height;
-  return CGRectMake(x, y, w, h);
-}
-
-- (void)dealloc {
-  [self releaseBuffer];
-}
-
-- (void)releaseBuffer {
-  if (_pixelBuffer != NULL) {
-    CVPixelBufferRelease(_pixelBuffer);
-    _pixelBuffer = NULL;
-  }
-}
-
-+ (NSString *)getKeyWithVideoRect:(CGRect)videoRect {
-  return [NSString stringWithFormat:@"%d_%d_%d_%d",
-                                    (int)(videoRect.origin.x * 1000000),
-                                    (int)(videoRect.origin.y * 1000000),
-                                    (int)(videoRect.size.width * 1000000),
-                                    (int)(videoRect.size.height * 1000000)];
-}
-@end
-@interface VELPipContentSourceProvider : NSObject
-@property(nonatomic, strong) NSRecursiveLock *bufferLock;
-@property(nonatomic, assign) CGSize videoSize;
-@property(nonatomic, assign) int videoRectKeyScale;
-@property(nonatomic, strong) dispatch_queue_t bufferQueue;
-/// key is rect, value is pixelbuffer ref
-@property(nonatomic, strong)
-    NSMutableDictionary<NSString *, VELPipCachedQueueBuffer *>
-        *cachedQueueBuffers;
-@property(nonatomic, strong) VELPipPixelBufferTool *bufferTool;
-@property(nonatomic, strong) VELPipSampleBufferView *sampleBufferView;
-@property(nonatomic, strong) AVSampleBufferDisplayLayer *sampleDisplayLayer;
-@property(nonatomic, assign) CVPixelBufferRef darkPixelBuffer;
-@property(nonatomic, strong) dispatch_source_t darkFrameTimer;
-@property(nonatomic, strong) dispatch_queue_t darkFrameQueue;
-@property(nonatomic, copy) AVLayerVideoGravity videoGravity;
-@property(nonatomic, copy) void (^sampleDisplayLayerChanged)
-    (VELPipContentSourceProvider *provider);
-@property(atomic, assign) NSTimeInterval fpsInterval;
-@property(nonatomic, assign) int videoSourceCount;
-- (void)enqueuePixelBuffer:(CVPixelBufferRef)pixelBuffer
-                 videoRect:(CGRect)videoRect;
-- (void)enqueueSampleBuffer:(CMSampleBufferRef)sampleBuffer
-                  videoRect:(CGRect)videoRect;
-- (void)destroy;
-@end
-
-// MARK: - interface VELSampleBufferPlaybackDelegate
-API_AVAILABLE(ios(15.0), tvos(15.0), macos(12.0))
-API_UNAVAILABLE(watchos)
-@interface VELSampleBufferPlaybackDelegate
-    : NSObject <AVPictureInPictureSampleBufferPlaybackDelegate>
-@end
-
-// MARK: - implementation VELSampleBufferPlaybackDelegate
-@implementation VELSampleBufferPlaybackDelegate
-- (BOOL)pictureInPictureControllerIsPlaybackPaused:
-    (nonnull AVPictureInPictureController *)pictureInPictureController {
-  return NO;
-}
-
-- (CMTimeRange)pictureInPictureControllerTimeRangeForPlayback:
-    (AVPictureInPictureController *)pictureInPictureController {
-  return CMTimeRangeMake(kCMTimeZero, kCMTimePositiveInfinity);
-}
-
-- (void)pictureInPictureController:
-            (AVPictureInPictureController *)pictureInPictureController
-         didTransitionToRenderSize:(CMVideoDimensions)newRenderSize {
-  VeLivePipLog(LOG_TAG,
-               @"content source pip render size changed width:%@ height:%@",
-               @(newRenderSize.width), @(newRenderSize.height));
-}
-
-- (void)pictureInPictureController:
-            (AVPictureInPictureController *)pictureInPictureController
-                        setPlaying:(BOOL)playing {
-}
-
-- (void)pictureInPictureController:
-            (AVPictureInPictureController *)pictureInPictureController
-                    skipByInterval:(CMTime)skipInterval
-                 completionHandler:(void (^)(void))completionHandler {
-  completionHandler();
-}
-@end
-
-// MARK: - implementation VeLivePictureInPictureController (VELPipContentSource)
-@implementation VeLivePictureInPictureController (VELPipContentSource)
-static char kAssociatedObjectKey_pipContentSourceProvider;
-- (void)setSourceProvider:(VELPipContentSourceProvider *)sourceProvider {
-  @synchronized(self) {
-    objc_setAssociatedObject(self,
-                             &kAssociatedObjectKey_pipContentSourceProvider,
-                             sourceProvider, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
-  }
-}
-
-- (VELPipContentSourceProvider *)sourceProvider {
-  @synchronized(self) {
-    return (VELPipContentSourceProvider *)objc_getAssociatedObject(
-        self, &kAssociatedObjectKey_pipContentSourceProvider);
-  }
-}
-
-static char kAssociatedObjectKey_pipPlaybackDelegate;
-- (void)setPlaybackDelegate:(VELSampleBufferPlaybackDelegate *)playbackDelegate
-    API_AVAILABLE(ios(15.0), tvos(15.0), macos(12.0))API_UNAVAILABLE(watchos) {
-  objc_setAssociatedObject(self, &kAssociatedObjectKey_pipPlaybackDelegate,
-                           playbackDelegate, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
-}
-
-- (VELSampleBufferPlaybackDelegate *)playbackDelegate API_AVAILABLE(ios(15.0),
-                                                                    tvos(15.0),
-                                                                    macos(12.0))
-    API_UNAVAILABLE(watchos) {
-  return (VELSampleBufferPlaybackDelegate *)objc_getAssociatedObject(
-      self, &kAssociatedObjectKey_pipPlaybackDelegate);
-}
-
-- (void)initContentSourcePictureInPicture {
-  if (@available(iOS 15.0, *)) {
-    VeLivePipLog(LOG_TAG, @"init content source pip");
-    if (self.sourceProvider == nil) {
-      self.sourceProvider = [[VELPipContentSourceProvider alloc] init];
-      self.sourceProvider.fpsInterval = 1.0 / self.fps;
-      self.sourceProvider.videoSourceCount = MAX(self.videoSourceCount, 1);
-      self.sourceProvider.videoSize = self.videoSize;
-      __weak __typeof__(self) weakSelf = self;
-      [self.sourceProvider setSampleDisplayLayerChanged:^(
-                               VELPipContentSourceProvider *provider) {
-        __strong __typeof__(weakSelf) self = weakSelf;
-        VeLivePipLog(LOG_TAG, @"reset sample layer from provider ");
-        [self setupContentSource];
-      }];
-      [self setupContentSource];
-      self.pipHolderView = self.sourceProvider.sampleBufferView;
-    }
-    dispatch_after(
-        dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.3 * NSEC_PER_SEC)),
-        dispatch_get_main_queue(), ^{
-          [self notifyDeleteIsReady];
-        });
-  } else {
-    [self notifyDeleteWithError:
-              VeLivePipError(VeLivePictureInPictureErrorCodeNotPossible,
-                             @"content source not support below iOS 15.0")];
-  }
-}
-
-- (void)releaseContentSourcePictureInPicture {
-  if (self.pipController != nil) {
-    [self.sourceProvider.sampleBufferView removeFromSuperview];
-    [self.sourceProvider destroy];
-    self.sourceProvider = nil;
-    [self stopPictureInPicture];
-    self.pipController = nil;
-  }
-}
-
-- (void)setupContentSource API_AVAILABLE(ios(15.0)) {
-  // playback delegate strong ref
-  self.playbackDelegate = [[VELSampleBufferPlaybackDelegate alloc] init];
-  AVPictureInPictureControllerContentSource *contentSource =
-      [[AVPictureInPictureControllerContentSource alloc]
-          initWithSampleBufferDisplayLayer:self.sourceProvider
-                                               .sampleDisplayLayer
-                          playbackDelegate:self.playbackDelegate];
-  if (self.pipController == nil) {
-    self.pipController = [[AVPictureInPictureController alloc]
-        initWithContentSource:contentSource];
-    self.pipController.delegate = self;
-  } else {
-    [self.pipController setContentSource:contentSource];
-  }
-}
-
-- (void)vel_setContentSourceVideoSize:(CGSize)videoSize {
-  [self.sourceProvider setVideoSize:videoSize];
-}
-
-- (void)setSampleLayerVideoGravity:(AVLayerVideoGravity)videoGravity {
-  self.sourceProvider.sampleBufferView.videoGravity = videoGravity;
-}
-
-- (void)vel_enqueuePixelBuffer:(CVPixelBufferRef)pixelBuffer
-                     videoRect:(CGRect)videoRect {
-  if (self.state != VeLivePictureInPictureStateRunning) {
-    return;
-  }
-  [self.sourceProvider enqueuePixelBuffer:pixelBuffer videoRect:videoRect];
-}
-
-- (void)vel_enqueueSampleBuffer:(CMSampleBufferRef)sampleBuffer
-                      videoRect:(CGRect)videoRect {
-  if (self.state != VeLivePictureInPictureStateRunning) {
-    return;
-  }
-  [self.sourceProvider enqueueSampleBuffer:sampleBuffer videoRect:videoRect];
-}
-
-@end
-
-// MARK: - implementation VeLivePictureInPictureController
-// (VELPipContentViewPlayerLayer)
-@implementation VeLivePictureInPictureController (VELPipContentViewPlayerLayer)
-static char kAssociatedObjectKey_pipContentViewPlayerLayer;
-- (void)setContentViewPlayerLayer:(AVPlayerLayer *)contentViewPlayerLayer {
-  objc_setAssociatedObject(self,
-                           &kAssociatedObjectKey_pipContentViewPlayerLayer,
-                           contentViewPlayerLayer, OBJC_ASSOCIATION_ASSIGN);
-}
-- (AVPlayerLayer *)contentViewPlayerLayer {
-  return (AVPlayerLayer *)objc_getAssociatedObject(
-      self, &kAssociatedObjectKey_pipContentViewPlayerLayer);
-}
-static char kAssociatedObjectKey_pipContentViewPlayerLayerView;
-- (void)setContentViewPlayerLayerView:(UIView *)contentViewPlayerLayerView {
-  objc_setAssociatedObject(self,
-                           &kAssociatedObjectKey_pipContentViewPlayerLayerView,
-                           contentViewPlayerLayerView, OBJC_ASSOCIATION_ASSIGN);
-}
-- (UIView *)contentViewPlayerLayerView {
-  return (UIView *)objc_getAssociatedObject(
-      self, &kAssociatedObjectKey_pipContentViewPlayerLayerView);
-}
-
-- (void)initContentViewPlayerLayerPictureInPicture {
-  VeLivePipLog(LOG_TAG, @"init avplayer pip");
-  if (self.contentViewPlayerLayer == nil) {
-    [self notifyDeleteWithError:VeLivePipError(
-                                    -1,
-                                    @"content view has no AVPlayerLayer view")];
-    return;
-  }
-  if (self.pipController == nil) {
-    self.pipController = [[AVPictureInPictureController alloc]
-        initWithPlayerLayer:self.contentViewPlayerLayer];
-    self.pipController.delegate = self;
-  }
-  dispatch_after(
-      dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.3 * NSEC_PER_SEC)),
-      dispatch_get_main_queue(), ^{
-        [self notifyDeleteIsReady];
-      });
-}
-
-- (void)releaseContentViewPlayerLayerPictureInPicture {
-  if (self.pipController != nil) {
-    [self stopPictureInPicture];
-    self.contentViewPlayerLayer = nil;
-    self.contentViewPlayerLayerView = nil;
-    self.pipController = nil;
-  }
-}
-
-- (void)setContentViewPlayerLayerVideoGravity:
-    (AVLayerVideoGravity)videoGravity {
-  //    self.contentViewPlayerLayer.videoGravity = videoGravity;
-}
-@end
-
-#if VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-// MARK: - implementation VeLivePictureInPictureController
-// (VELPipContentSourceAVPlayer)
-@implementation VeLivePictureInPictureController (VELPipContentSourceAVPlayer)
-static char kAssociatedObjectKey_pipContentSourcePlayerView;
-- (void)setContentSourcePlayerView:
-    (VELPipAVPlayerView *)contentSourcePlayerView {
-  objc_setAssociatedObject(
-      self, &kAssociatedObjectKey_pipContentSourcePlayerView,
-      contentSourcePlayerView, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
-}
-
-- (VELPipAVPlayerView *)contentSourcePlayerView {
-  return (VELPipAVPlayerView *)objc_getAssociatedObject(
-      self, &kAssociatedObjectKey_pipContentSourcePlayerView);
-}
-
-- (void)initContentSourceAVPlayerPictureInPicture {
-  VeLivePipLog(LOG_TAG, @"init content source avplayer pip");
-  if (@available(iOS 15.0, *)) {
-    if (self.contentSourcePlayerView == nil) {
-      [VELPipLoopPlayer initLoopPlayer];
-      self.contentSourcePlayerView = [[VELPipAVPlayerView alloc] init];
-      self.contentSourcePlayerView.playerLayer.player = VELPipLoopPlayer.player;
-      self.contentSourcePlayerView.playerLayer.videoGravity =
-          AVLayerVideoGravityResize;
-      self.pipHolderView = self.contentSourcePlayerView;
-      AVPictureInPictureControllerContentSource *contentSource =
-          [[AVPictureInPictureControllerContentSource alloc]
-              initWithPlayerLayer:self.contentSourcePlayerView.playerLayer];
-      self.pipController = [[AVPictureInPictureController alloc]
-          initWithContentSource:contentSource];
-      self.pipController.delegate = self;
-    }
-    __weak __typeof__(self) weakSelf = self;
-    [VELPipLoopPlayer
-        setStatusBlock:^(AVPlayerStatus status, NSError *_Nullable error) {
-          __strong __typeof__(weakSelf) self = weakSelf;
-          VeLivePipLog(LOG_TAG, @"loop player status changed block %@-%@",
-                       @(status), error);
-          if (status == AVPlayerStatusFailed) {
-            [self notifyDeleteWithError:error];
-          } else if (status == AVPlayerStatusReadyToPlay) {
-            [self contentSourceAvplayerIsReady];
-          }
-        }];
-    [VELPipLoopPlayer setVideoSize:self.videoSize];
-    [VELPipLoopPlayer playWithNotifyStatus:YES];
-  } else {
-    [self notifyDeleteWithError:
-              VeLivePipError(
-                  VeLivePictureInPictureErrorCodeNotPossible,
-                  @"content source avplayer not support below iOS 15.0")];
-  }
-}
-
-- (void)releaseContentSourceAVPlayerPictureInPicture {
-  if (self.pipController != nil) {
-    [self.contentSourcePlayerView removeFromSuperview];
-    self.contentSourcePlayerView = nil;
-    [self stopPictureInPicture];
-    self.pipController = nil;
-  }
-}
-
-- (void)contentSourceAvplayerIsReady {
-  [self notifyDeleteIsReady];
-}
-
-- (void)setContentSourceAVPlayerLayerVideoGravity:
-    (AVLayerVideoGravity)videoGravity {
-  self.contentSourcePlayerView.playerLayer.videoGravity = videoGravity;
-}
-@end
-
-// MARK: - implementation VeLivePictureInPictureController (VELPipAVPlayer)
-@implementation VeLivePictureInPictureController (VELPipAVPlayer)
-static char kAssociatedObjectKey_pipAVplayerView;
-- (void)setPlayerView:(VELPipAVPlayerView *)playerView {
-  objc_setAssociatedObject(self, &kAssociatedObjectKey_pipAVplayerView,
-                           playerView, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
-}
-
-- (VELPipAVPlayerView *)playerView {
-  return (VELPipAVPlayerView *)objc_getAssociatedObject(
-      self, &kAssociatedObjectKey_pipAVplayerView);
-}
-
-- (void)initAVPlayerPictureInPicture {
-  VeLivePipLog(LOG_TAG, @"init avplayer pip");
-  if (self.playerView == nil) {
-    [VELPipLoopPlayer initLoopPlayer];
-    self.playerView = [[VELPipAVPlayerView alloc] init];
-    self.playerView.playerLayer.player = VELPipLoopPlayer.player;
-    self.playerView.playerLayer.videoGravity = AVLayerVideoGravityResize;
-    self.pipHolderView = self.playerView;
-
-    self.pipController = [[AVPictureInPictureController alloc]
-        initWithPlayerLayer:self.playerView.playerLayer];
-    self.pipController.delegate = self;
-  }
-  __weak __typeof__(self) weakSelf = self;
-  [VELPipLoopPlayer
-      setStatusBlock:^(AVPlayerStatus status, NSError *_Nullable error) {
-        __strong __typeof__(weakSelf) self = weakSelf;
-        VeLivePipLog(LOG_TAG, @"loop player status changed block %@-%@",
-                     @(status), error);
-        if (status == AVPlayerStatusFailed) {
-          [self notifyDeleteWithError:error];
-        } else if (status == AVPlayerStatusReadyToPlay) {
-          [self avplayerIsReady];
-        }
-      }];
-  [VELPipLoopPlayer setVideoSize:self.videoSize];
-  [VELPipLoopPlayer playWithNotifyStatus:YES];
-}
-
-- (void)releaseAVPlayerPictureInPicture {
-  if (self.pipController != nil) {
-    [self.playerView removeFromSuperview];
-    self.playerView = nil;
-
-    [self stopPictureInPicture];
-    self.pipController = nil;
-  }
-}
-
-- (void)avplayerIsReady {
-  [self notifyDeleteIsReady];
-}
-
-- (void)setAVPlayerLayerVideoGravity:(AVLayerVideoGravity)videoGravity {
-  self.playerView.playerLayer.videoGravity = videoGravity;
-}
-@end
-
-@protocol VELAVPictureInPictureProtocol <NSObject>
-- (void)startPictureInPicture;
-- (void)stopPictureInPicture;
-@property(nonatomic, readonly, getter=isPictureInPicturePossible)
-    BOOL pictureInPicturePossible;
-@property(nonatomic, readonly, getter=isPictureInPictureActive)
-    BOOL pictureInPictureActive;
-@property(nonatomic, readonly, getter=isPictureInPictureSuspended)
-    BOOL pictureInPictureSuspended;
-@property(nonatomic, readonly)
-    BOOL canStopPictureInPicture API_AVAILABLE(tvos(14.0))
-        API_UNAVAILABLE(ios, macos, watchos);
-@end
-
-// MARK: - implementation VeLivePictureInPictureController
-// (VELPipAVPlayerViewController)
-@implementation VeLivePictureInPictureController (VELPipAVPlayerViewController)
-static char kAssociatedObjectKey_pipAVPlayerViewController;
-- (void)setPlayerViewController:(AVPlayerViewController *)playerViewController {
-  objc_setAssociatedObject(
-      self, &kAssociatedObjectKey_pipAVPlayerViewController,
-      playerViewController, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
-}
-
-- (AVPlayerViewController *)playerViewController {
-  return (AVPlayerViewController *)objc_getAssociatedObject(
-      self, &kAssociatedObjectKey_pipAVPlayerViewController);
-}
-
-- (void)initAVPlayerViewControllerPictureInPicture {
-  VeLivePipLog(LOG_TAG, @"init AVPlayerViewController pip");
-  if (self.playerViewController == nil) {
-    [VELPipLoopPlayer initLoopPlayer];
-    self.playerViewController =
-        (AVPlayerViewController<VELAVPictureInPictureProtocol> *)
-            [[AVPlayerViewController alloc] init];
-    self.playerViewController.delegate = self;
-    self.playerViewController.player = VELPipLoopPlayer.player;
-    self.playerViewController.allowsPictureInPicturePlayback = YES;
-    self.playerViewController.videoGravity = AVLayerVideoGravityResize;
-    //    self.playerViewController.showsPlaybackControls = NO; // don't set to
-    //    NO
-
-    if (@available(iOS 14.0, *)) {
-      self.playerViewController.requiresLinearPlayback = YES;
-    }
-    if (@available(iOS 14.2, *)) {
-      self.playerViewController
-          .canStartPictureInPictureAutomaticallyFromInline =
-          self.canStartPictureInPictureAutomaticallyFromInline;
-    }
-    self.pipHolderView = self.playerViewController.view;
-  }
-  __weak __typeof__(self) weakSelf = self;
-  [VELPipLoopPlayer
-      setStatusBlock:^(AVPlayerStatus status, NSError *_Nullable error) {
-        __strong __typeof__(weakSelf) self = weakSelf;
-        VeLivePipLog(LOG_TAG, @"loop player status changed block %@-%@",
-                     @(status), error);
-        if (status == AVPlayerStatusFailed) {
-          [self notifyDeleteWithError:error];
-        } else if (status == AVPlayerStatusReadyToPlay) {
-          [self avPlayerViewControllerIsReady];
-        }
-      }];
-  [VELPipLoopPlayer setVideoSize:self.videoSize];
-  [VELPipLoopPlayer playWithNotifyStatus:YES];
-}
-
-- (void)velPlayerVCSetCanStartPictureInPictureAutomaticallyFromInline:
-    (BOOL)canStart {
-  if (@available(iOS 14.2, *)) {
-    self.playerViewController.canStartPictureInPictureAutomaticallyFromInline =
-        canStart;
-  }
-}
-
-- (void)releaseAVPlayerViewControllerPictureInPicture {
-  if (self.playerViewController != nil) {
-    [self.playerViewController.view removeFromSuperview];
-    [self velPlayerVCStopPictureInPicture];
-    self.playerViewController = nil;
-  }
-}
-
-//  {zh} 开启画中画  {en} Open picture-in-picture
-- (void)velPlayerVCStartPictureInPicture {
-  if (!self.velPlayerVCCanStartPictureInPicture) {
-    VeLivePipLog(LOG_TAG,
-                 @"AVPlayerViewController can not start pip state:%@, check "
-                 @"app has audio playing?",
-                 @(self.state));
-    [self
-        notifyDeleteWithError:
-            VeLivePipError(VeLivePictureInPictureErrorCodeNotPossible,
-                           @"can not start pip, check app has audio playing?")];
-    return;
-  }
-  if ([self.playerViewController
-          respondsToSelector:@selector(startPictureInPicture)]) {
-    VeLivePipLog(LOG_TAG, @"AVPlayerViewController start pip");
-    [self.playerViewController startPictureInPicture];
-  } else {
-    [self.pipController startPictureInPicture];
-  }
-  self.state = VeLivePictureInPictureStateRunning;
-}
-
-//  {zh} 停止画中画  {en} Stop picture-in-picture
-- (void)velPlayerVCStopPictureInPicture {
-  if (self.state != VeLivePictureInPictureStateRunning) {
-    VeLivePipLog(LOG_TAG, @"AVPlayerViewController not running");
-    return;
-  }
-  if ([self.playerViewController
-          respondsToSelector:@selector(stopPictureInPicture)]) {
-    VeLivePipLog(LOG_TAG, @"AVPlayerViewController stop pip");
-    [self.playerViewController stopPictureInPicture];
-  } else {
-    [self.pipController stopPictureInPicture];
-  }
-  self.state = VeLivePictureInPictureStateStopping;
-}
-
-- (BOOL)velPlayerVCCanStartPictureInPicture {
-  if ([self.playerViewController
-          respondsToSelector:@selector(isPictureInPicturePossible)]) {
-    return self.state == VeLivePictureInPictureStateReady &&
-           self.playerViewController.isPictureInPicturePossible;
-  }
-  return [self _canStartPictureInPicture];
-}
-
-- (void)avPlayerViewControllerIsReady {
-  [self getAVPlayerViewControllerPipController];
-  if (self.pipController == nil) {
-    return;
-  }
-  [self notifyDeleteIsReady];
-}
-
-- (void)getAVPlayerViewControllerPipController {
-  @try {
-    NSString *pipName = [NSString
-        stringWithFormat:@"_%@%@%@", @"pictur", @"eInPict", @"ureController"];
-    id pipController = [self.playerViewController valueForKey:pipName];
-    if (pipController != nil &&
-        [pipController isKindOfClass:[AVPictureInPictureController class]]) {
-      self.pipController = pipController;
-    } else {
-      [self notifyDeleteWithError:
-                VeLivePipError(VeLivePictureInPictureErrorCodeNotPossible,
-                               @"can not find PictureInPictureController")];
-    }
-  } @catch (NSException *exception) {
-    [self
-        notifyDeleteWithError:VeLivePipError(
-                                  VeLivePictureInPictureErrorCodeNotPossible,
-                                  @"can not find PictureInPictureController")];
-  }
-}
-
-- (void)setAVPlayerVCVideoGravity:(AVLayerVideoGravity)videoGravity {
-  self.playerViewController.videoGravity = videoGravity;
-}
-@end
-
-// MARK: - interface VELPipLoopPlayer
-@interface VELPipLoopPlayer ()
-@property(nonatomic, strong) VELPipAVPlayer *player;
-@property(nonatomic, strong) AVPlayerItem *playerItem;
-@property(nonatomic, assign) CGSize videoSize;
-@property(nonatomic, assign) AVPlayerStatus status;
-@property(nonatomic, copy) void (^statusBlock)
-    (AVPlayerStatus status, NSError *_Nullable error);
-/// 写入本地占位视频
-@property(nonatomic, copy, readonly) NSString *videoPath;
-@property(strong, nonatomic) AVAssetWriter *writer;
-@property(nonatomic, strong) NSRecursiveLock *videoWritterLock;
-@property(strong, nonatomic) AVAssetWriterInput *videoInput;
-@property(strong, nonatomic)
-    AVAssetWriterInputPixelBufferAdaptor *writerInputPixelBufferAdaptor;
-@property(nonatomic, strong) VELPipPixelBufferTool *bufferTool;
-@end
-
-// MARK: - implementation VELPipLoopPlayer
-@implementation VELPipLoopPlayer
-static VELPipLoopPlayer *vel_pip_loop_player_instance = nil;
-+ (instancetype)sharePlayer {
-  static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^{
-    vel_pip_loop_player_instance = [[VELPipLoopPlayer alloc] init];
-  });
-  return vel_pip_loop_player_instance;
-}
-
-- (instancetype)init {
-  if (self = [super init]) {
-    _videoWritterLock = [[NSRecursiveLock alloc] init];
-    _videoSize = CGSizeMake(360, 640);
-    _bufferTool = [[VELPipPixelBufferTool alloc] init];
-  }
-  return self;
-}
-
-+ (void)initLoopPlayer {
-  if ([self isInited]) {
-    return;
-  }
-  [[VELPipLoopPlayer sharePlayer] setup];
-  VeLivePipLog(LOG_TAG, @"loop player init");
-  [[VELPipLoopPlayer sharePlayer] playWithNotifyStatus:YES];
-}
-
-+ (BOOL)isInited {
-  return vel_pip_loop_player_instance != nil &&
-         vel_pip_loop_player_instance.player != nil;
-}
-
-+ (VELPipAVPlayer *)player {
-  if (![self isInited]) {
-    return nil;
-  }
-  return [[VELPipLoopPlayer sharePlayer] player];
-}
-
-+ (AVPlayerStatus)status {
-  if (![self isInited]) {
-    return AVPlayerStatusUnknown;
-  }
-  return [[VELPipLoopPlayer sharePlayer] status];
-}
-
-+ (void)playWithNotifyStatus:(BOOL)notify {
-  if (![self isInited]) {
-    return;
-  }
-  VeLivePipLog(LOG_TAG, @"loop player play");
-  [[VELPipLoopPlayer sharePlayer] playWithNotifyStatus:notify];
-}
-
-+ (void)pause {
-  if (![self isInited]) {
-    return;
-  }
-  VeLivePipLog(LOG_TAG, @"loop player pause");
-  [[VELPipLoopPlayer sharePlayer] pause];
-}
-
-+ (void)stop {
-  if (![self isInited]) {
-    return;
-  }
-  VeLivePipLog(LOG_TAG, @"loop player stop");
-  [[VELPipLoopPlayer sharePlayer] stop];
-}
-
-+ (void)setVideoSize:(CGSize)videoSize {
-  if (![self isInited]) {
-    return;
-  }
-  [[VELPipLoopPlayer sharePlayer] setVideoSize:videoSize];
-}
-
-+ (CGSize)videoSize {
-  if (![self isInited]) {
-    return CGSizeZero;
-  }
-  return [[VELPipLoopPlayer sharePlayer] videoSize];
-}
-
-+ (void)setStatusBlock:(void (^)(AVPlayerStatus,
-                                 NSError *_Nullable))statusBlock {
-  if (![self isInited]) {
-    return;
-  }
-  VeLivePipLog(LOG_TAG, @"loop player set status block");
-  [[VELPipLoopPlayer sharePlayer] setStatusBlock:statusBlock];
-}
-
-+ (void (^)(AVPlayerStatus, NSError *_Nullable))statusBlock {
-  if (![self isInited]) {
-    return nil;
-  }
-  return [[VELPipLoopPlayer sharePlayer] statusBlock];
-}
-
-// MARK: VELLoopPlayer Private
-- (void)setVideoSize:(CGSize)videoSize {
-  if (!CGSizeEqualToSize(_videoSize, videoSize)) {
-    VeLivePipLog(LOG_TAG, @"loop player set videoSize from %@ to %@",
-                 NSStringFromCGSize(_videoSize), NSStringFromCGSize(videoSize));
-    _videoSize = videoSize;
-    [self resetPlayerItem];
-  }
-}
-
-- (void)playWithNotifyStatus:(BOOL)notify {
-  CGFloat delayTime = 0.5;
-  NSError *error = nil;
-  if (self.status != AVPlayerStatusReadyToPlay) {
-    VeLivePipLog(LOG_TAG, @"loop player not ready");
-    error = VeLivePipError(-1, @"loop player not ready");
-  } else if (self.player.rate <= 0) {
-    VeLivePipLog(LOG_TAG, @"loop player is ready, play now");
-    [self.player play];
-  } else {
-    delayTime = 0.3;
-  }
-  if (notify) {
-    dispatch_after(
-        dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayTime * NSEC_PER_SEC)),
-        dispatch_get_main_queue(), ^{
-          VeLivePipLog(LOG_TAG, @"loop player call status changed %@",
-                       @(self.status));
-          if (self.statusBlock) {
-            self.statusBlock(self.status, error);
-          }
-        });
-  }
-}
-
-- (void)pause {
-  VeLivePipLog(LOG_TAG, @"loop player pause");
-  [self.player velPause];
-}
-
-- (void)stop {
-  if (self.player == nil) {
-    return;
-  }
-  VeLivePipLog(LOG_TAG, @"loop player stop");
-  [self pause];
-  [self removeSystemNotifactionObserver];
-  self.status = AVPlayerStatusUnknown;
-  self.playerItem = nil;
-  [self.player replaceCurrentItemWithPlayerItem:nil];
-  self.player = nil;
-}
-
-- (void)setup {
-  if (self.player != nil) {
-    return;
-  }
-  VeLivePipLog(LOG_TAG, @"loop player setup");
-  self.player = [[VELPipAVPlayer alloc] init];
-  // same to rate
-  [self.player
-      addPeriodicTimeObserverForInterval:CMTimeMake(1, 1000000000)
-                                   queue:dispatch_get_main_queue()
-                              usingBlock:^(CMTime time){
-                                  //        VeLivePipLog(LOG_TAG, @"loop player
-                                  //        time %@", @(time.value));
-                              }];
-  [self resetPlayerItem];
-  [self addSystemNotifactionObserver];
-}
-
-- (void)resetPlayerItem {
-  VeLivePipLog(LOG_TAG, @"loop player reset player item");
-  self.status = AVPlayerStatusUnknown;
-  self.playerItem = nil;
-  [self preparePlayerItem];
-}
-
-- (void)preparePlayerItem {
-  if (self.playerItem == nil) {
-    VeLivePipLog(LOG_TAG, @"loop player prepare player item");
-    [self getOrCreateDarkVideo:^(NSString *_Nullable videoPath,
-                                 NSError *_Nullable error) {
-      if (error != nil) {
-        VeLivePipLog(LOG_TAG, @"loop player prepare player item error:%@",
-                     error);
-        if (self.statusBlock) {
-          self.statusBlock(self.status, error);
-        }
-      } else {
-        VeLivePipLog(LOG_TAG,
-                     @"loop player prepare player item complete with path:%@",
-                     videoPath);
-        AVAsset *asset =
-            [AVAsset assetWithURL:[NSURL fileURLWithPath:videoPath]];
-        self.playerItem = [[AVPlayerItem alloc] initWithAsset:asset];
-      }
-    }];
-  }
-}
-
-- (void)setPlayerItem:(AVPlayerItem *)playerItem {
-  self.status = AVPlayerStatusUnknown;
-  [self removePlayerItemObserver:_playerItem];
-  _playerItem = playerItem;
-  [self addPlayerItemObserver:_playerItem];
-  [self.player replaceCurrentItemWithPlayerItem:playerItem];
-  [self.player play];
-}
-
-- (void)playerItemIsReadyToPlay {
-  VeLivePipLog(LOG_TAG, @"loop player player item is ready");
-  self.status = AVPlayerStatusReadyToPlay;
-  if (self.statusBlock) {
-    self.statusBlock(self.status, nil);
-  }
-}
-
-- (void)playerItemFailedToPlay {
-  VeLivePipLog(LOG_TAG, @"loop player player item is failed");
-  self.status = AVPlayerStatusFailed;
-  if (self.statusBlock) {
-    self.statusBlock(
-        self.status,
-        VeLivePipError(VeLivePictureInPictureErrorCodePlayTemplateFileFailed,
-                       @"play template file failed"));
-  }
-}
-
-- (void)observeValueForKeyPath:(NSString *)keyPath
-                      ofObject:(id)object
-                        change:(NSDictionary<NSKeyValueChangeKey, id> *)change
-                       context:(void *)context {
-  if (object == self.playerItem) {
-    AVPlayerStatus status = [change[NSKeyValueChangeNewKey] integerValue];
-    VeLivePipLog(LOG_TAG, @"loop player item status changed %d", (int)status);
-    if (status == AVPlayerItemStatusFailed) {
-      [self playerItemFailedToPlay];
-    } else if (status == AVPlayerItemStatusReadyToPlay) {
-      dispatch_after(
-          dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)),
-          dispatch_get_main_queue(), ^{
-            [self playerItemIsReadyToPlay];
-          });
-    }
-  }
-}
-
-- (void)removePlayerItemObserver:(AVPlayerItem *)playerItem {
-  if (playerItem == nil) {
-    return;
-  }
-  VeLivePipLog(LOG_TAG, @"loop player remove player item observer");
-  [playerItem removeObserver:self
-                  forKeyPath:NSStringFromSelector(@selector(status))];
-  [[NSNotificationCenter defaultCenter]
-      removeObserver:self
-                name:AVPlayerItemDidPlayToEndTimeNotification
-              object:playerItem];
-}
-
-- (void)addPlayerItemObserver:(AVPlayerItem *)playerItem {
-  if (playerItem == nil) {
-    return;
-  }
-  VeLivePipLog(LOG_TAG, @"loop player add player item observer");
-  [playerItem addObserver:self
-               forKeyPath:NSStringFromSelector(@selector(status))
-                  options:(NSKeyValueObservingOptionNew |
-                           NSKeyValueObservingOptionInitial)
-                  context:nil];
-  [[NSNotificationCenter defaultCenter]
-      addObserver:self
-         selector:@selector(loopPlayerDidEndPlayNotifaction:)
-             name:AVPlayerItemDidPlayToEndTimeNotification
-           object:self.playerItem];
-}
-
-- (void)addSystemNotifactionObserver {
-  VeLivePipLog(LOG_TAG, @"loop player add system notifaction");
-  [[NSNotificationCenter defaultCenter]
-      addObserver:self
-         selector:@selector(applicationDidBecomeActiveNotifaction)
-             name:UIApplicationDidBecomeActiveNotification
-           object:nil];
-
-  [[NSNotificationCenter defaultCenter]
-      addObserver:self
-         selector:@selector(audioInterruptNotifaction:)
-             name:AVAudioSessionInterruptionNotification
-           object:nil];
-}
-
-- (void)removeSystemNotifactionObserver {
-  VeLivePipLog(LOG_TAG, @"loop player remove system notifaction");
-  [[NSNotificationCenter defaultCenter]
-      removeObserver:self
-                name:UIApplicationDidBecomeActiveNotification
-              object:nil];
-  [[NSNotificationCenter defaultCenter]
-      removeObserver:self
-                name:AVAudioSessionInterruptionNotification
-              object:nil];
-}
-
-- (void)loopPlayerDidEndPlayNotifaction:(NSNotification *)notification {
-  if (notification.object == self.playerItem) {
-    VeLivePipLog(LOG_TAG, @"loop player play to end, will seek to zero");
-    if (@available(iOS 11.0, *)) {
-      [self.playerItem seekToTime:kCMTimeZero
-                completionHandler:^(BOOL finished){
-                }];
-    } else {
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-      [self.playerItem seekToTime:kCMTimeZero];
-#pragma clang diagnostic pop
-    }
-  }
-}
-
-- (void)applicationDidBecomeActiveNotifaction {
-  VeLivePipLog(LOG_TAG, @"loop player play when active");
-  if (self.status == AVPlayerStatusReadyToPlay) {
-    [self.player play];
-  }
-}
-
-- (void)audioInterruptNotifaction:(NSNotification *)notifaction {
-  if (@available(iOS 10.3, *)) {
-    NSNumber *suspended = [[notifaction userInfo]
-        objectForKey:AVAudioSessionInterruptionWasSuspendedKey];
-    if ([suspended boolValue]) {
-      return;
-    }
-  }
-  AVAudioSessionInterruptionType interruptionType =
-      (AVAudioSessionInterruptionType)[[[notifaction userInfo]
-          objectForKey:AVAudioSessionInterruptionTypeKey] unsignedIntegerValue];
-  if (AVAudioSessionInterruptionTypeEnded == interruptionType) {
-    VeLivePipLog(LOG_TAG, @"loop player play when audio interrupt end");
-    [self.player play];
-  }
-}
-
-- (void)getLocalDarkVideo:(void (^)(NSString *_Nullable videoPath,
-                                    NSError *_Nullable error))completion {
-  /// 不能创建，使用模板视频
-  VeLivePipLog(LOG_TAG, @"loop player prepare player item use local bundle");
-  BOOL landspace = self.videoSize.width > self.videoSize.height;
-  NSString *fileName =
-      landspace ? @"pipmode_template_landspace" : @"pipmode_template";
-  fileName =
-      [@"VELLiveDemo_Pull.bundle" stringByAppendingPathComponent:fileName];
-  NSString *videoPath =
-      [[NSBundle bundleForClass:self.class] pathForResource:fileName
-                                                     ofType:@"mp4"];
-  if (completion) {
-    completion(videoPath,
-               videoPath == nil ? VeLivePipError(-1, @"video not found") : nil);
-  }
-}
-
-// MARK: - Dark Video Create
-- (void)getOrCreateDarkVideo:(void (^)(NSString *_Nullable videoPath,
-                                       NSError *_Nullable error))completion {
-  /// 清理上次未写完的的 buffer
-  [self cancelAssetWritterWithCleanFile:YES];
-
-  if (CGSizeEqualToSize(self.videoSize, CGSizeZero)) {
-    [self getLocalDarkVideo:completion];
-    return;
-  }
-  if (![self.videoWritterLock tryLock]) {
-    return;
-  }
-  NSString *videoPath = [self videoPath];
-  if ([NSFileManager.defaultManager fileExistsAtPath:videoPath]) {
-    if ([NSFileManager.defaultManager attributesOfItemAtPath:videoPath
-                                                       error:nil]
-            .fileSize > 500) {
-      if (completion) {
-        completion(videoPath, nil);
-      }
-      [self.videoWritterLock unlock];
-      return;
-    }
-    [NSFileManager.defaultManager removeItemAtPath:videoPath error:nil];
-  }
-
-  if ([self setupAssetWriter:videoPath] && [self setupVideoInput]) {
-    VeLivePipLog(LOG_TAG,
-                 @"loop player prepare player item use asset writer %@",
-                 videoPath);
-    @try {
-      __weak __typeof__(self) weakSelf = self;
-      int videoSeconds = 3;
-      int32_t videoFps = 1;
-      CMTime startSampleTime = kCMTimeZero;
-      __block CMTime endSampleTime = startSampleTime;
-      __block int videoBufferIndex = 0;
-      int32_t videoBufferCount = videoSeconds * videoFps;
-      CGSize videoSize = self.videoSize;
-      [self.writer startWriting];
-      [self.writer startSessionAtSourceTime:startSampleTime];
-      [self.videoInput
-          requestMediaDataWhenReadyOnQueue:dispatch_queue_create(
-                                               "com.pip.video.queue", NULL)
-                                usingBlock:^{
-                                  __strong __typeof__(weakSelf) self = weakSelf;
-
-                                  if ([self.videoWritterLock tryLock]) {
-                                    @try {
-                                      while ([self.videoInput
-                                                  isReadyForMoreMediaData]) {
-                                        videoBufferIndex = videoBufferIndex + 1;
-                                        endSampleTime = CMTimeAdd(
-                                            startSampleTime,
-                                            CMTimeMake(videoBufferIndex,
-                                                       videoFps));
-                                        if (videoBufferIndex <=
-                                            videoBufferCount) {
-                                          CVPixelBufferRef darkBuffer =
-                                              [self.bufferTool
-                                                  createDarkFrameWithFrameSize:
-                                                      videoSize];
-                                          [self.writerInputPixelBufferAdaptor
-                                                 appendPixelBuffer:darkBuffer
-                                              withPresentationTime:
-                                                  endSampleTime];
-                                          CVPixelBufferRelease(darkBuffer);
-                                          VeLivePipLog(
-                                              LOG_TAG,
-                                              @"write buffer at index %d-%f",
-                                              videoBufferIndex,
-                                              CMTimeGetSeconds(endSampleTime));
-                                        } else {
-                                          VeLivePipLog(
-                                              LOG_TAG,
-                                              @"write buffer complete index %d "
-                                              @"- %f",
-                                              videoBufferIndex,
-                                              CMTimeGetSeconds(endSampleTime));
-                                          [self.videoInput markAsFinished];
-                                          [self.writer endSessionAtSourceTime:
-                                                           endSampleTime];
-                                          [self.writer
-                                              finishWritingWithCompletionHandler:^{
-                                                __strong __typeof__(weakSelf)
-                                                    self = weakSelf;
-                                                if ([self.videoWritterLock
-                                                            tryLock]) {
-                                                  if (self.writer.status ==
-                                                      AVAssetWriterStatusCompleted) {
-                                                    VeLivePipLog(
-                                                        LOG_TAG,
-                                                        @"avasset writter end "
-                                                        @"completed");
-                                                    vel_sync_in_main_queue(^{
-                                                      CGFloat fileSize =
-                                                          [NSFileManager
-                                                                  .defaultManager
-                                                              attributesOfItemAtPath:
-                                                                  videoPath
-                                                                               error:
-                                                                                   nil]
-                                                              .fileSize;
-                                                      if (fileSize > 20) {
-                                                        if (completion) {
-                                                          completion(videoPath,
-                                                                     nil);
-                                                        }
-                                                        [self cleanupWritter];
-                                                      } else {
-                                                        [self cleanupWritter];
-                                                        [self getLocalDarkVideo:
-                                                                  completion];
-                                                      }
-                                                    });
-                                                  } else {
-                                                    VeLivePipLog(
-                                                        LOG_TAG,
-                                                        @"avasset writter end "
-                                                        @"error %@-%@",
-                                                        @(self.writer.status),
-                                                        self.writer.error);
-                                                    [NSFileManager
-                                                            .defaultManager
-                                                        removeItemAtPath:
-                                                            videoPath
-                                                                   error:nil];
-                                                    vel_sync_in_main_queue(^{
-                                                      [self cleanupWritter];
-                                                      [self getLocalDarkVideo:
-                                                                completion];
-                                                    });
-                                                  }
-                                                  [self.videoWritterLock
-                                                          unlock];
-                                                }
-                                              }];
-                                        }
-                                      }
-                                    } @catch (NSException *exception) {
-                                      vel_sync_in_main_queue(^{
-                                        [self cleanupWritter];
-                                        [self getLocalDarkVideo:completion];
-                                      });
-                                    }
-                                    [self.videoWritterLock unlock];
-                                  }
-                                }];
-    } @catch (NSException *exception) {
-      [self cancelAssetWritterWithCleanFile:YES];
-      [self getLocalDarkVideo:completion];
-    }
-  } else {
-    [self cleanupWritter];
-    [self getLocalDarkVideo:completion];
-  }
-  [self.videoWritterLock unlock];
-}
-
-- (void)cancelAssetWritterWithCleanFile:(BOOL)cleanFile {
-  if ([self.videoWritterLock tryLock]) {
-    @try {
-      if (self.videoInput != nil) {
-        [self.videoInput markAsFinished];
-      }
-      if (self.writer != nil) {
-        [self.writer
-            endSessionAtSourceTime:CMTimeMakeWithSeconds(CACurrentMediaTime(),
-                                                         1000000000)];
-        [self.writer cancelWriting];
-        VeLivePipLog(LOG_TAG, @"cancel avasset writter %@",
-                     self.writer.outputURL);
-        if (cleanFile) {
-          NSURL *outputUrl = self.writer.outputURL;
-          if (outputUrl != nil &&
-              [NSFileManager.defaultManager
-                  fileExistsAtPath:outputUrl.absoluteString]) {
-            [NSFileManager.defaultManager removeItemAtURL:outputUrl error:nil];
-          }
-        }
-      }
-      [self cleanupWritter];
-    } @catch (NSException *exception) {
-      VeLivePipLog(LOG_TAG, @"cancel avasset writter exception %@", exception);
-    }
-    [self.videoWritterLock unlock];
-  }
-}
-
-- (void)cleanupWritter {
-  if ([self.videoWritterLock tryLock]) {
-    self.videoInput = nil;
-    self.writerInputPixelBufferAdaptor = nil;
-    self.writer = nil;
-    [self.videoWritterLock unlock];
-  }
-}
-
-- (BOOL)setupAssetWriter:(NSString *)videoPath {
-  if ([self.videoWritterLock tryLock]) {
-    NSError *error = nil;
-    self.writer =
-        [[AVAssetWriter alloc] initWithURL:[NSURL fileURLWithPath:videoPath]
-                                  fileType:AVFileTypeQuickTimeMovie
-                                     error:&error];
-    if (error != nil) {
-      [self.videoWritterLock unlock];
-      return NO;
-    }
-    [self.videoWritterLock unlock];
-    return YES;
-  }
-  return NO;
-}
-
-- (BOOL)setupVideoInput {
-  if ([self.videoWritterLock tryLock]) {
-    NSDictionary *videoCompression = @{
-      AVVideoAverageBitRateKey : @(5 * 1000 * 1000),
-      AVVideoProfileLevelKey : AVVideoProfileLevelH264HighAutoLevel,
-      AVVideoAllowFrameReorderingKey : [NSNumber numberWithBool:YES],
-      AVVideoMaxKeyFrameIntervalDurationKey : [NSNumber numberWithFloat:4.0],
-      AVVideoH264EntropyModeKey : AVVideoH264EntropyModeCABAC
-    };
-
-    NSMutableDictionary *videoSettings =
-        [NSMutableDictionary dictionaryWithDictionary:@{
-          AVVideoWidthKey : [NSNumber numberWithInt:self.videoSize.width],
-          AVVideoHeightKey : [NSNumber numberWithInt:self.videoSize.height],
-          AVVideoCompressionPropertiesKey : videoCompression
-        }];
-    if (@available(iOS 11.0, *)) {
-      videoSettings[AVVideoCodecKey] = AVVideoCodecTypeH264;
-    } else {
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-      videoSettings[AVVideoCodecKey] = AVVideoCodecH264;
-#pragma clang diagnostic pop
-    }
-    self.videoInput =
-        [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeVideo
-                                           outputSettings:videoSettings];
-    self.videoInput.expectsMediaDataInRealTime = YES;
-    NSDictionary *bufferAttributes = @{
-      (id)kCVPixelBufferPixelFormatTypeKey : @(kCVPixelFormatType_32BGRA),
-      (id)kCVPixelBufferCGBitmapContextCompatibilityKey : @YES,
-      (id)kCVPixelBufferWidthKey : @(self.videoSize.width),
-      (id)kCVPixelBufferHeightKey : @(self.videoSize.height),
-      (id)kCVPixelBufferBytesPerRowAlignmentKey : @(self.videoSize.width * 4)
-    };
-    self.writerInputPixelBufferAdaptor = [AVAssetWriterInputPixelBufferAdaptor
-        assetWriterInputPixelBufferAdaptorWithAssetWriterInput:self.videoInput
-                                   sourcePixelBufferAttributes:
-                                       bufferAttributes];
-
-    if ([self.writer canAddInput:self.videoInput]) {
-      [self.writer addInput:self.videoInput];
-      [self.videoWritterLock unlock];
-      return YES;
-    } else {
-      [self.videoWritterLock unlock];
-      return NO;
-    }
-  }
-  return NO;
-}
-
-- (NSString *)videoPath {
-  NSString *rootPath = NSSearchPathForDirectoriesInDomains(
-                           NSDocumentDirectory, NSUserDomainMask, YES)
-                           .lastObject;
-  rootPath = [rootPath stringByAppendingPathComponent:@"vel_pip/dark_video"];
-  BOOL isDir = NO;
-  if (![NSFileManager.defaultManager fileExistsAtPath:rootPath
-                                          isDirectory:&isDir] ||
-      !isDir) {
-    [NSFileManager.defaultManager createDirectoryAtPath:rootPath
-                            withIntermediateDirectories:YES
-                                             attributes:nil
-                                                  error:nil];
-  }
-  rootPath =
-      [rootPath stringByAppendingPathComponent:
-                    [NSString stringWithFormat:@"dark_video_%d_%d.mp4",
-                                               (int)self.videoSize.width,
-                                               (int)self.videoSize.height]];
-  return rootPath;
-}
-@end
-
-// MARK: - implementation VELPipAVPlayer
-@implementation VELPipAVPlayer
-- (instancetype)init {
-  if (self = [super init]) {
-    self.allowsExternalPlayback = NO;
-    self.usesExternalPlaybackWhileExternalScreenIsActive = NO;
-  }
-  return self;
-}
-
-- (void)setRate:(float)rate {
-  [self setMuted:YES];
-  VeLivePipLog(LOG_TAG, @"loop player set rate %f", rate);
-  if (rate != 0) {
-    [super setRate:0.000000001];
-  } else {
-    [super setRate:0];
-  }
-}
-
-- (void)velPause {
-  [super setRate:0];
-}
-@end
-
-// MARK: - implementation VELPipAVPlayerView
-@implementation VELPipAVPlayerView
-- (instancetype)initWithFrame:(CGRect)frame {
-  if (self = [super initWithFrame:frame]) {
-    self.backgroundColor = UIColor.blackColor;
-  }
-  return self;
-}
-+ (Class)layerClass {
-  return AVPlayerLayer.class;
-}
-
-- (AVPlayerLayer *)playerLayer {
-  return (AVPlayerLayer *)self.layer;
-}
-@end
-
-// MARK: - implementation UIView (VELPipAutoSupport)
-@implementation UIView (VELPipAutoSupport)
-+ (void)load {
-  static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^{
-    Class class = [self class];
-    SEL originSelector = @selector(addSubview:);
-    SEL newSelector = @selector(vel_autoHideSampleLayerSubview:);
-    Method oriMethod = class_getInstanceMethod(class, originSelector);
-    Method newMethod = class_getInstanceMethod(class, newSelector);
-    if (newMethod) {
-      BOOL isAddedMethod = class_addMethod(class, originSelector,
-                                           method_getImplementation(newMethod),
-                                           method_getTypeEncoding(newMethod));
-      if (isAddedMethod) {
-        IMP oriMethodIMP = method_getImplementation(oriMethod)
-                               ?: imp_implementationWithBlock(^(id selfObject){
-                                  });
-        const char *oriMethodTypeEncoding =
-            method_getTypeEncoding(oriMethod) ?: "v@:";
-        class_replaceMethod(class, newSelector, oriMethodIMP,
-                            oriMethodTypeEncoding);
-      } else {
-        method_exchangeImplementations(oriMethod, newMethod);
-      }
-    }
-  });
-}
-
-static char kAssociatedObjectKey_vel_autoHideSamplePlayerView;
-- (void)setVel_autoHideSamplePlayerView:(BOOL)vel_autoHideSamplePlayerView {
-  objc_setAssociatedObject(
-      self, &kAssociatedObjectKey_vel_autoHideSamplePlayerView,
-      @(vel_autoHideSamplePlayerView), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
-  if (vel_autoHideSamplePlayerView) {
-    [self hideSamplePlayerView];
-  }
-}
-
-- (BOOL)vel_autoHideSamplePlayerView {
-  return [((NSNumber *)objc_getAssociatedObject(
-      self, &kAssociatedObjectKey_vel_autoHideSamplePlayerView)) boolValue];
-}
-
-static char kAssociatedObjectKey_velAutoHideControlsView;
-- (void)setVel_autoHideControlsView:(BOOL)vel_autoHideControlsView {
-  objc_setAssociatedObject(self, &kAssociatedObjectKey_velAutoHideControlsView,
-                           @(vel_autoHideControlsView),
-                           OBJC_ASSOCIATION_RETAIN_NONATOMIC);
-  if (vel_autoHideControlsView) {
-    [self hideControlViewInSubviews];
-  }
-}
-
-- (BOOL)vel_autoHideControlsView {
-  return [((NSNumber *)objc_getAssociatedObject(
-      self, &kAssociatedObjectKey_velAutoHideControlsView)) boolValue];
-}
-
-- (void)vel_autoHideSampleLayerSubview:(UIView *)view {
-  [self vel_autoHideSampleLayerSubview:view];
-  if (self.vel_autoHideSamplePlayerView) {
-    [self hideSamplePlayerView];
-  }
-  if (self.vel_autoHideControlsView) {
-    [self hideControlViewInSubviews];
-  }
-}
-
-- (void)hideSamplePlayerView {
-  NSString *layerName = [NSString
-      stringWithFormat:@"%@%@%@", @"_AVS", @"implePlay", @"erLayerView"];
-  NSString *otherLayerName =
-      [NSString stringWithFormat:@"%@%@%@%@%@%@%@%@", @"A", @"VPict",
-                                 @"ureInPic", @"tureSam", @"pleBufferDisp",
-                                 @"layLaye", @"rHos", @"tView"];
-  if ([@[ layerName, otherLayerName ]
-          containsObject:NSStringFromClass(self.class)]) {
-    self.hidden = YES;
-    return;
-  }
-  for (UIView *v in self.subviews) {
-    v.vel_autoHideSamplePlayerView = YES;
-  }
-}
-
-- (void)hideControlViewInSubviews {
-  NSString *controlName = [NSString
-      stringWithFormat:@"%@%@%@%@", @"AVPla", @"ybackCo", @"ntrol", @"sView"];
-  if ([NSStringFromClass(self.class) isEqualToString:controlName]) {
-    self.hidden = YES;
-    return;
-  }
-  for (UIView *v in self.subviews) {
-    v.vel_autoHideControlsView = YES;
-  }
-}
-
-static char kAssociatedObjectKey_vel_viewController;
-- (void)setVel_viewController:(UIViewController *)vel_viewController {
-  objc_setAssociatedObject(self, &kAssociatedObjectKey_vel_viewController,
-                           vel_viewController, OBJC_ASSOCIATION_ASSIGN);
-}
-
-- (UIViewController *)vel_viewController {
-  UIViewController *vc = (UIViewController *)objc_getAssociatedObject(
-      self, &kAssociatedObjectKey_vel_viewController);
-  if (vc == nil) {
-    UIResponder *responder = self;
-    while (responder && ![responder isKindOfClass:[UIViewController class]]) {
-      responder = [responder nextResponder];
-    }
-    vc = (UIViewController *)responder;
-    [self setVel_viewController:vc];
-  }
-  return vc;
-}
-@end
-#endif // VEL_PICTURE_IN_PICTURE_ENABLE_PIP_BELOW_IOS_15
-
-// MARK: - interface VELPipSampleBufferView
-@interface VELPipSampleBufferView ()
-@property(nonatomic, strong, readwrite) AVSampleBufferDisplayLayer *sampleLayer;
-@end
-
-// MARK: - implementation VELPipSampleBufferView
-@implementation VELPipSampleBufferView
-- (instancetype)initWithFrame:(CGRect)frame {
-  if (self = [super initWithFrame:frame]) {
-    self.backgroundColor = UIColor.blackColor;
-    [self rebuildSamplelayer];
-  }
-  return self;
-}
-
-- (void)setVideoGravity:(AVLayerVideoGravity)videoGravity {
-  _videoGravity = videoGravity.copy;
-  @synchronized(self) {
-    self.sampleLayer.videoGravity = videoGravity;
-  }
-}
-
-- (void)rebuildSamplelayer {
-  @synchronized(self) {
-    if (self.sampleLayer) {
-      [self.sampleLayer flush];
-      [self.sampleLayer stopRequestingMediaData];
-      [self.sampleLayer removeFromSuperlayer];
-    }
-
-    self.sampleLayer = [[AVSampleBufferDisplayLayer alloc] init];
-    self.sampleLayer.videoGravity = self.videoGravity;
-    self.sampleLayer.opaque = YES;
-    CMTimebaseRef timebase;
-    CMTimebaseCreateWithSourceClock(nil, CMClockGetHostTimeClock(), &timebase);
-    CMTimebaseSetTime(timebase, kCMTimeZero);
-    CMTimebaseSetRate(timebase, 1);
-    self.sampleLayer.controlTimebase = timebase;
-    if (timebase) {
-      CFRelease(timebase);
-    }
-    self.sampleLayer.frame = self.bounds;
-    [self.layer addSublayer:self.sampleLayer];
-  }
-}
-
-- (void)layoutSubviews {
-  [super layoutSubviews];
-  @synchronized(self) {
-    self.sampleLayer.frame = self.bounds;
-    self.sampleLayer.position =
-        CGPointMake(CGRectGetMidX(self.bounds), CGRectGetMidY(self.bounds));
-  }
-}
-
-@end
-
-// MARK: - implementation VELPipContentSourceProvider
-@implementation VELPipContentSourceProvider
-- (instancetype)init {
-  if (self = [super init]) {
-    [self initContentSource];
-  }
-  return self;
-}
-
-- (void)dealloc {
-  [self destroy];
-}
-
-- (void)destroy {
-  VeLivePipLog(LOG_TAG, @"content source provider destroy");
-  [self stopDarkFrameTimer];
-  [self releaseDarkFrame];
-  [self releaseAllQueueCachedBuffers];
-  vel_sync_in_main_queue(^{
-    [self.sampleBufferView removeFromSuperview];
-  });
-}
-static char kVELPipBufferQueueSpecificKey;
-- (void)initContentSource {
-  VeLivePipLog(LOG_TAG, @"content source provider init");
-  self.videoSize = CGSizeMake(360, 480);
-  self.videoRectKeyScale = 1000000;
-  self.bufferLock = [[NSRecursiveLock alloc] init];
-  self.cachedQueueBuffers = [[NSMutableDictionary alloc] init];
-  self.bufferTool = [[VELPipPixelBufferTool alloc] init];
-  self.sampleBufferView =
-      [[VELPipSampleBufferView alloc] initWithFrame:CGRectMake(0, 0, 360, 480)];
-  self.sampleDisplayLayer = self.sampleBufferView.sampleLayer;
-  self.bufferQueue =
-      dispatch_queue_create("com.velpip.buffer.queue", DISPATCH_QUEUE_SERIAL);
-  dispatch_queue_set_specific(self.bufferQueue, &kVELPipBufferQueueSpecificKey,
-                              &kVELPipBufferQueueSpecificKey, NULL);
-  [self startDarkFrameTimer];
-}
-
-- (void)safeAsyncInBufferQueue:(void (^)(void))block {
-  if (dispatch_get_specific(&kVELPipBufferQueueSpecificKey)) {
-    block();
-  } else {
-    dispatch_async(self.bufferQueue, block);
-  }
-}
-
-- (void)safeSyncInBufferQueue:(void (^)(void))block {
-  if (dispatch_get_specific(&kVELPipBufferQueueSpecificKey)) {
-    block();
-  } else {
-    dispatch_sync(self.bufferQueue, block);
-  }
-}
-
-- (void)enqueuePixelBuffer:(CVPixelBufferRef)pixelBuffer
-                 videoRect:(CGRect)videoRect {
-  if (pixelBuffer == NULL) {
-    return;
-  }
-  //  {zh} 外部送视频帧，停止内部黑帧  {en} Send video frames externally, stop
-  //  internal black frames
-  [self stopDarkFrameTimer];
-  [self _enqueuePixelBuffer:pixelBuffer videoRect:videoRect];
-}
-
-- (void)enqueueSampleBuffer:(CMSampleBufferRef)sampleBuffer
-                  videoRect:(CGRect)videoRect {
-  if (sampleBuffer == NULL) {
-    return;
-  }
-  //  {zh} 外部送视频帧，停止内部黑帧  {en} Send video frames externally, stop
-  //  internal black frames
-  [self stopDarkFrameTimer];
-  [self _enqueuePixelBuffer:CMSampleBufferGetImageBuffer(sampleBuffer)
-                  videoRect:videoRect];
-}
-
-- (void)setupDarkFrame:(BOOL)force {
-  if (force) {
-    VeLivePipLog(LOG_TAG, @"content source provider force rebuild dark frame");
-    [self releaseDarkFrame];
-  }
-  [self.bufferLock lock];
-  if (_darkPixelBuffer != NULL) {
-    return;
-  }
-  VeLivePipLog(LOG_TAG, @"content source provider build dark frame");
-  _darkPixelBuffer =
-      [self.bufferTool createDarkFrameWithFrameSize:self.videoSize];
-  [self.bufferLock unlock];
-}
-
-- (void)releaseDarkFrame {
-  [self.bufferLock lock];
-  if (_darkPixelBuffer != NULL) {
-    VeLivePipLog(LOG_TAG, @"content source provider release dark frame");
-    CVPixelBufferRelease(_darkPixelBuffer);
-    _darkPixelBuffer = NULL;
-  }
-  [self.bufferLock unlock];
-}
-
-- (void)startDarkFrameTimer {
-  [self.bufferLock lock];
-  if (_darkFrameTimer != NULL) {
-    [self stopDarkFrameTimer];
-  }
-
-  if (_darkFrameQueue == NULL) {
-    _darkFrameQueue =
-        dispatch_queue_create("com.pip.dark.queue", DISPATCH_QUEUE_SERIAL);
-  }
-
-  [self setupDarkFrame:NO];
-  VeLivePipLog(LOG_TAG,
-               @"content source provider start dark frame timer with 15fps");
-  _darkFrameTimer =
-      dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, _darkFrameQueue);
-  dispatch_time_t start =
-      dispatch_walltime(NULL, (int64_t)(0.0 * NSEC_PER_SEC));
-  uint64_t interval = (uint64_t)(1 / 15.0 * NSEC_PER_SEC);
-  dispatch_source_set_timer(_darkFrameTimer, start, interval, 0);
-  __weak __typeof__(self) weakSelf = self;
-  dispatch_source_set_event_handler(_darkFrameTimer, ^{
-    __strong __typeof__(weakSelf) self = weakSelf;
-    if (self == nil) {
-      return;
-    }
-    [self.bufferLock lock];
-    if (self.darkPixelBuffer != NULL) {
-      [self _enqueuePixelBuffer:self.darkPixelBuffer
-                      videoRect:VELPixtureInPictureFullVideoRect];
-    }
-    [self.bufferLock unlock];
-  });
-  dispatch_resume(_darkFrameTimer);
-  [self.bufferLock unlock];
-}
-
-- (void)stopDarkFrameTimer {
-  if (_darkFrameTimer != NULL) {
-    VeLivePipLog(LOG_TAG, @"content source provider stop dark frame timer");
-    dispatch_source_cancel(_darkFrameTimer);
-    _darkFrameTimer = NULL;
-  }
-}
-
-- (void)releaseAllQueueCachedBuffers {
-  [self safeSyncInBufferQueue:^{
-    [self.bufferLock lock];
-    for (VELPipCachedQueueBuffer *cachedBuffer in self.cachedQueueBuffers
-             .allValues) {
-      [cachedBuffer releaseBuffer];
-    }
-    [self.cachedQueueBuffers removeAllObjects];
-    [self.bufferLock unlock];
-  }];
-}
-
-- (void)cacheQueueBuffer:(CVPixelBufferRef)pixelBuffer
-               videoRect:(CGRect)videoRect {
-  [self.bufferLock lock];
-  NSString *key = [VELPipCachedQueueBuffer getKeyWithVideoRect:videoRect];
-  VELPipCachedQueueBuffer *buffer = [self.cachedQueueBuffers objectForKey:key];
-  /// release old
-  if (buffer != nil) {
-    if (CACurrentMediaTime() - buffer.lastUpdateTime > self.fpsInterval) {
-      [buffer releaseBuffer];
-      [self.cachedQueueBuffers removeObjectForKey:key];
-      buffer = [[VELPipCachedQueueBuffer alloc] initWithBuffer:pixelBuffer
-                                                     videoRect:videoRect];
-    }
-  } else {
-    buffer = [[VELPipCachedQueueBuffer alloc] initWithBuffer:pixelBuffer
-                                                   videoRect:videoRect];
-  }
-  [self.cachedQueueBuffers setObject:buffer forKey:key];
-  [self.bufferLock unlock];
-}
-
-- (BOOL)needUpdateQueuePixelBuffer {
-  __block BOOL needUpdatePixelBuffer = NO;
-  [self.bufferLock lock];
-  if (self.cachedQueueBuffers.count == self.videoSourceCount) {
-    NSTimeInterval currTime = CACurrentMediaTime();
-    [self.cachedQueueBuffers
-        enumerateKeysAndObjectsUsingBlock:^(
-            NSString *_Nonnull key, VELPipCachedQueueBuffer *_Nonnull obj,
-            BOOL *_Nonnull stop) {
-          if (currTime - obj.lastUpdateTime > self.fpsInterval) {
-            needUpdatePixelBuffer = YES;
-            *stop = YES;
-          }
-        }];
-  }
-  [self.bufferLock unlock];
-  return needUpdatePixelBuffer;
-}
-
-- (CVPixelBufferRef)createPixelBufferFromAllCachedQueueBuffer {
-  CVPixelBufferRef mixPixelBuffer = NULL;
-  [self.bufferLock lock];
-  CGSize videoSize = self.videoSize;
-  int videoWidth = videoSize.width;
-  int videoHeight = videoSize.height;
-  int minFrameSize = 2048;
-  if (videoWidth > videoHeight && videoWidth < minFrameSize) {
-    CGFloat scale = minFrameSize / videoWidth;
-    videoWidth = minFrameSize;
-    videoHeight = videoHeight * scale;
-  } else if (videoHeight > videoWidth && videoHeight < minFrameSize) {
-    CGFloat scale = minFrameSize / videoHeight;
-    videoHeight = minFrameSize;
-    videoWidth = videoWidth * scale;
-  }
-  mixPixelBuffer = [self.bufferTool createPixelBuffer:kCVPixelFormatType_32BGRA
-                                               heigth:videoHeight
-                                                width:videoWidth];
-  if (mixPixelBuffer) {
-    CVPixelBufferLockBaseAddress(mixPixelBuffer, 0);
-    void *pxdata = CVPixelBufferGetBaseAddress(mixPixelBuffer);
-    if (pxdata == NULL) {
-      CVPixelBufferRelease(mixPixelBuffer);
-      [self.bufferLock unlock];
-      return NULL;
-    }
-    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
-    uint32_t bitmapInfo = kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host;
-    // uint32_t bitmapInfo = kCGBitmapByteOrder32Little |
-    // kCGImageAlphaPremultipliedFirst;
-    size_t bytesPerRow = CVPixelBufferGetBytesPerRow(mixPixelBuffer);
-    CGContextRef context =
-        CGBitmapContextCreate(pxdata, videoWidth, videoHeight, 8, bytesPerRow,
-                              colorSpace, bitmapInfo);
-    if (context == NULL) {
-      CVPixelBufferRelease(mixPixelBuffer);
-      CGColorSpaceRelease(colorSpace);
-      [self.bufferLock unlock];
-      return NULL;
-    }
-
-    for (VELPipCachedQueueBuffer *cachedBuffer in self.cachedQueueBuffers
-             .allValues) {
-      CGImageRef imageRef = nil;
-      VTCreateCGImageFromCVPixelBuffer(cachedBuffer.pixelBuffer, nil,
-                                       &imageRef);
-      if (imageRef != nil) {
-        CGContextDrawImage(
-            context,
-            [cachedBuffer
-                convertRectFrom:CGRectMake(0, 0, videoWidth, videoHeight)],
-            imageRef);
-        CGImageRelease(imageRef);
-      }
-    }
-    CVPixelBufferUnlockBaseAddress(mixPixelBuffer, 0);
-    CGColorSpaceRelease(colorSpace);
-    CGContextRelease(context);
-  }
-  [self.bufferLock unlock];
-  return mixPixelBuffer;
-}
-
-- (void)_enqueuePixelBuffer:(CVPixelBufferRef)pixelBuffer
-                  videoRect:(CGRect)videoRect {
-  if (pixelBuffer == NULL) {
-    return;
-  }
-  __block CVPixelBufferRef asyncBuffer = CVPixelBufferRetain(pixelBuffer);
-  [self safeAsyncInBufferQueue:^{
-    if (CGRectEqualToRect(videoRect, VELPixtureInPictureFullVideoRect)) {
-      [self releaseAllQueueCachedBuffers];
-      [self _enqueueVideoRectPixelBuffer:asyncBuffer];
-      CVPixelBufferRelease(asyncBuffer);
-    } else {
-      [self cacheQueueBuffer:asyncBuffer videoRect:videoRect];
-      CVPixelBufferRelease(asyncBuffer);
-      if ([self needUpdateQueuePixelBuffer]) {
-        CVPixelBufferRef pixelBuffer =
-            [self createPixelBufferFromAllCachedQueueBuffer];
-        [self _enqueueVideoRectPixelBuffer:pixelBuffer];
-        CVPixelBufferRelease(pixelBuffer);
-      } else {
-        //                VeLivePipLog(LOG_TAG, @"drop mix video frame with fps
-        //                no need update");
-      }
-    }
-  }];
-}
-
-- (void)_enqueueVideoRectPixelBuffer:(CVPixelBufferRef)pixelBuffer {
-  CMSampleBufferRef sampleBuffer =
-      [self.bufferTool sampleBufferFromPixelBuffer:pixelBuffer
-                                               fps:kCMTimeInvalid
-                                               pts:kCMTimeInvalid];
-  [self _enqueueDisplaySampleBuffer:sampleBuffer];
-  if (sampleBuffer != NULL) {
-    CFRelease(sampleBuffer);
-  }
-}
-
-- (void)_enqueueDisplaySampleBuffer:(CMSampleBufferRef)sampleBuffer {
-  if (sampleBuffer) {
-    [self.bufferLock lock];
-    [_sampleDisplayLayer enqueueSampleBuffer:sampleBuffer];
-    if (_sampleDisplayLayer.status ==
-        AVQueuedSampleBufferRenderingStatusFailed) {
-      [_sampleDisplayLayer flush];
-      //  {zh} 后台唤醒，重启渲染  {en} Wake up in the background, restart
-      //  rendering
-      if (-11847 == _sampleDisplayLayer.error.code) {
-        VeLivePipLog(LOG_TAG, @"content source provider rebuild sampleLayer");
-        vel_sync_in_main_queue(^{
-          [self.sampleBufferView rebuildSamplelayer];
-          self.sampleDisplayLayer = self.sampleBufferView.sampleLayer;
-          if (self.sampleDisplayLayerChanged) {
-            self.sampleDisplayLayerChanged(self);
-          }
-        });
-      }
-    }
-    [self.bufferLock unlock];
-  }
-}
-
-// MARK: - Setter
-- (void)setVideoGravity:(AVLayerVideoGravity)videoGravity {
-  _videoGravity = videoGravity.copy;
-  self.sampleDisplayLayer.videoGravity = videoGravity;
-}
-
-- (void)setVideoSize:(CGSize)videoSize {
-  if (!CGSizeEqualToSize(_videoSize, videoSize)) {
-    VeLivePipLog(LOG_TAG,
-                 @"content source provider video size changed from %@ to %@",
-                 NSStringFromCGSize(_videoSize), NSStringFromCGSize(videoSize));
-    _videoSize = videoSize;
-    [self setupDarkFrame:YES];
-  }
-}
-
-@end
-
-@implementation UIViewController (VELPipTopViewController)
-+ (UIViewController *)vel_pipTopViewController {
-  UIViewController *resultVC;
-  resultVC =
-      [self _velPipTopViewController:[[UIApplication sharedApplication]
-                                             .keyWindow rootViewController]];
-  while (resultVC.presentedViewController) {
-    resultVC = [self _velPipTopViewController:resultVC.presentedViewController];
-  }
-  if ([resultVC isKindOfClass:[UIAlertController class]]) {
-    resultVC =
-        [self _velPipTopViewController:[[UIApplication sharedApplication]
-                                               .keyWindow rootViewController]];
-  }
-  return resultVC;
-}
-
-+ (UIViewController *)_velPipTopViewController:(UIViewController *)vc {
-  if ([vc isKindOfClass:[UINavigationController class]]) {
-    return [self _velPipTopViewController:[(UINavigationController *)
-                                                  vc topViewController]];
-  } else if ([vc isKindOfClass:[UITabBarController class]]) {
-    return [self _velPipTopViewController:[(UITabBarController *)
-                                                  vc selectedViewController]];
-  } else {
-    return vc;
-  }
-  return nil;
-}
-@end
-
-@implementation VELPipPixelBufferTool
-- (instancetype)init {
-  if (self = [super init]) {
-    self.pixelBufferPoolDict =
-        [[NSMutableDictionary alloc] initWithCapacity:10];
-    self.lock = [[NSRecursiveLock alloc] init];
-  }
-  return self;
-}
-
-- (void)dealloc {
-  [self releaseMemory];
-}
-
-- (void)releaseMemory {
-  if ([self.lock tryLock]) {
-    NSDictionary<NSString *, NSValue *> *bufferPool =
-        self.pixelBufferPoolDict.copy;
-    [self.pixelBufferPoolDict removeAllObjects];
-    [bufferPool enumerateKeysAndObjectsUsingBlock:^(NSString *_Nonnull key,
-                                                    NSValue *_Nonnull obj,
-                                                    BOOL *_Nonnull stop) {
-      CVPixelBufferPoolRef pixelBufferPool =
-          (CVPixelBufferPoolRef)[obj pointerValue];
-      CVPixelBufferPoolRelease(pixelBufferPool);
-    }];
-    [self.lock unlock];
-  }
-}
-// MARK: - Dark PixelBuffer
-- (CVPixelBufferRef)createDarkFrameWithFrameSize:(CGSize)frameSize {
-
-  CVPixelBufferRef pxbuffer = [self createPixelBuffer:kCVPixelFormatType_32BGRA
-                                               heigth:frameSize.height
-                                                width:frameSize.width];
-  if (pxbuffer == NULL) {
-    return NULL;
-  }
-
-  CVPixelBufferLockBaseAddress(pxbuffer, 0);
-  void *pxdata = CVPixelBufferGetBaseAddress(pxbuffer);
-  CGColorSpaceRef rgbColorSpace = CGColorSpaceCreateDeviceRGB();
-  CGContextRef context = CGBitmapContextCreate(
-      pxdata, frameSize.width, frameSize.height, 8,
-      CVPixelBufferGetBytesPerRow(pxbuffer), rgbColorSpace,
-      (CGBitmapInfo)kCGBitmapByteOrder32Little |
-          kCGImageAlphaPremultipliedFirst);
-  CGContextSetRGBFillColor(context, 0, 0, 0, 1);
-  CGContextFillRect(context,
-                    CGRectMake(0, 0, frameSize.width, frameSize.height));
-  CGColorSpaceRelease(rgbColorSpace);
-  CGContextRelease(context);
-  CVPixelBufferUnlockBaseAddress(pxbuffer, 0);
-  return pxbuffer;
-}
-
-- (CMSampleBufferRef)sampleBufferFromPixelBuffer:(CVPixelBufferRef)pixelBuffer
-                                             fps:(CMTime)fps
-                                             pts:(CMTime)pts {
-  if (!pixelBuffer) {
-    return NULL;
-  }
-  CVPixelBufferLockBaseAddress(pixelBuffer, 0);
-  CMSampleTimingInfo timing = {fps, pts, pts};
-  CMVideoFormatDescriptionRef videoInfo = NULL;
-  OSStatus result = CMVideoFormatDescriptionCreateForImageBuffer(
-      NULL, pixelBuffer, &videoInfo);
-  if (result != noErr) {
-    CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
-    return NULL;
-  }
-
-  CMSampleBufferRef sampleBuffer = NULL;
-  result = CMSampleBufferCreateForImageBuffer(kCFAllocatorDefault, pixelBuffer,
-                                              true, NULL, NULL, videoInfo,
-                                              &timing, &sampleBuffer);
-  if (result != noErr || sampleBuffer == nil) {
-    if (videoInfo) {
-      CFRelease(videoInfo);
-      videoInfo = nil;
-    }
-    CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
-    return nil;
-  }
-  if (videoInfo) {
-    CFRelease(videoInfo);
-    videoInfo = nil;
-  }
-  // display immediately
-  CFArrayRef attachments =
-      CMSampleBufferGetSampleAttachmentsArray(sampleBuffer, YES);
-  CFMutableDictionaryRef dict =
-      (CFMutableDictionaryRef)CFArrayGetValueAtIndex(attachments, 0);
-  CFDictionarySetValue(dict, kCMSampleAttachmentKey_DisplayImmediately,
-                       kCFBooleanTrue);
-  CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
-  return sampleBuffer;
-}
-
-- (CVPixelBufferRef)createPixelBuffer:(OSType)type
-                               heigth:(int)height
-                                width:(int)width {
-  CVPixelBufferRef buffer = [self createPixelBufferFromPool:type
-                                                     heigth:height
-                                                      width:width];
-  if (buffer == NULL) {
-    buffer = [self createPixelBufferNormalWithType:type
-                                            heigth:height
-                                             width:width];
-  }
-  return buffer;
-}
-
-- (CVPixelBufferRef)createPixelBufferFromPool:(OSType)type
-                                       heigth:(int)height
-                                        width:(int)width {
-
-  NSString *poolKey = [NSString
-      stringWithFormat:@"%u_%d_%d", (unsigned int)type, height, width];
-  CVPixelBufferPoolRef pixelBufferPool = NULL;
-  CVPixelBufferRef buffer = NULL;
-
-  if ([self.lock tryLock]) {
-    NSValue *bufferPoolAddress =
-        [self.pixelBufferPoolDict objectForKey:poolKey];
-    if (!bufferPoolAddress) {
-      pixelBufferPool = [self createPixelBufferPool:type
-                                             heigth:height
-                                              width:width];
-      if (pixelBufferPool != NULL) {
-        bufferPoolAddress = [NSValue valueWithPointer:pixelBufferPool];
-        [self.pixelBufferPoolDict setValue:bufferPoolAddress forKey:poolKey];
-      }
-    } else {
-      pixelBufferPool = (CVPixelBufferPoolRef)[bufferPoolAddress pointerValue];
-    }
-    [self.lock unlock];
-  }
-
-  if (pixelBufferPool != NULL) {
-    CVPixelBufferPoolCreatePixelBuffer(kCFAllocatorDefault, pixelBufferPool,
-                                       &buffer);
-    [self cleanPixelBuffer:buffer];
-  }
-  return buffer;
-}
-
-- (CVPixelBufferRef)createPixelBufferNormalWithType:(OSType)type
-                                             heigth:(int)height
-                                              width:(int)width {
-  NSDictionary *attributes = [self getPixelBufferAttributes:type
-                                                     heigth:height
-                                                      width:width];
-  CVPixelBufferRef pixelBuffer = NULL;
-  CVReturn status =
-      CVPixelBufferCreate(kCFAllocatorDefault, width, height, type,
-                          (__bridge CFDictionaryRef)attributes, &pixelBuffer);
-  if (status != kCVReturnSuccess) {
-    return NULL;
-  }
-  [self cleanPixelBuffer:pixelBuffer];
-  return pixelBuffer;
-}
-
-- (void)cleanPixelBuffer:(CVPixelBufferRef)pixelBuffer {
-  if (pixelBuffer != NULL) {
-    CVPixelBufferLockBaseAddress(pixelBuffer, 0);
-    void *pxdata = CVPixelBufferGetBaseAddress(pixelBuffer);
-    size_t dataSize = CVPixelBufferGetDataSize(pixelBuffer);
-    memset(pxdata, 0, dataSize);
-    CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
-  }
-}
-
-- (CVPixelBufferPoolRef)createPixelBufferPool:(OSType)type
-                                       heigth:(int)height
-                                        width:(int)width {
-  CVPixelBufferPoolRef pool = NULL;
-
-  NSDictionary *attributes = [self getPixelBufferAttributes:type
-                                                     heigth:height
-                                                      width:width];
-
-  CVReturn ret = CVPixelBufferPoolCreate(
-      kCFAllocatorDefault, NULL, (__bridge CFDictionaryRef)attributes, &pool);
-
-  if (ret != kCVReturnSuccess) {
-    return NULL;
-  }
-
-  CVPixelBufferRef buffer = NULL;
-  ret = CVPixelBufferPoolCreatePixelBuffer(NULL, pool, &buffer);
-  if (ret != kCVReturnSuccess) {
-    return NULL;
-  }
-  if (buffer != NULL) {
-    CVPixelBufferRelease(buffer);
-  }
-  return pool;
-}
-
-- (NSDictionary *)getPixelBufferAttributes:(OSType)type
-                                    heigth:(int)height
-                                     width:(int)width {
-  NSMutableDictionary *attributes = [NSMutableDictionary dictionary];
-  [attributes
-      setObject:[NSNumber numberWithBool:YES]
-         forKey:(__bridge NSString *)kCVPixelBufferOpenGLCompatibilityKey];
-  [attributes
-      setObject:[NSNumber numberWithBool:YES]
-         forKey:(__bridge NSString *)kCVPixelBufferCGImageCompatibilityKey];
-  [attributes setObject:[NSNumber numberWithBool:YES]
-                 forKey:(__bridge NSString *)
-                            kCVPixelBufferCGBitmapContextCompatibilityKey];
-  [attributes
-      setObject:[NSNumber numberWithInt:64]
-         forKey:(__bridge NSString *)kCVPixelBufferBytesPerRowAlignmentKey];
-  [attributes setObject:[NSNumber numberWithInt:type]
-                 forKey:(__bridge NSString *)kCVPixelBufferPixelFormatTypeKey];
-  [attributes setObject:[NSNumber numberWithInt:width]
-                 forKey:(__bridge NSString *)kCVPixelBufferWidthKey];
-  [attributes setObject:[NSNumber numberWithInt:height]
-                 forKey:(__bridge NSString *)kCVPixelBufferHeightKey];
-  [attributes
-      setObject:[NSDictionary dictionary]
-         forKey:(__bridge NSString *)kCVPixelBufferIOSurfacePropertiesKey];
-  return attributes;
-}
-@end
-
-NSString *VeLivePictureInPictureErrorDomain =
-    @"VeLivePictureInPictureErrorDomain";
-CGRect VELPixtureInPictureFullVideoRect = {0, 0, 1, 1};