@byteplus/react-native-live-push 1.1.3-rc.0 → 1.1.3-rc.2

package/ios/VeLiveMixerHelper.m

@@ -0,0 +1,562 @@
+//
+//  VeLiveMixerHelper.m
+//  react-native-live-push
+//
+//  Created by ByteDance on 2024/12/09.
+//
+
+#import "VeLiveMixerHelper.h"
+#include <objc/NSObjCRuntime.h>
+#import <UIKit/UIKit.h>
+#import <TTSDKLivePushRTS/TTSDKLivePushRTS.h>
+#import <mach/mach.h>
+#import <mach/task_info.h>
+
+static NSString *TAG = @"VeLiveMixerHelper";
+
+#pragma mark - Forward Declaration
+
+@class VeLiveMixerBitmapCallback;
+
+#pragma mark - VeLiveMixerHelper Implementation
+
+@interface VeLiveMixerHelper ()
+
+@property(nonatomic, strong) NSMutableDictionary<NSString *, NSDictionary *> *mixedViewLayout;
+@property(nonatomic, strong) NSMutableDictionary<NSString *, NSNumber *> *viewIdToStreamId;
+@property(nonatomic, strong) NSMutableDictionary<NSString *, NSNumber *> *pendingCallbacks;
+@property(nonatomic, strong) NSMutableDictionary<NSString *, VeLiveMixerBitmapCallback *> *callbacks;
+@property (nonatomic, strong) NSTimer *memoryMonitorTimer;
+
+@end
+
+#pragma mark - VeLiveMixerBitmapCallback Declaration
+
+@interface VeLiveMixerBitmapCallback : NSObject <VeLiveBitmapCaptureCallback>
+@property (nonatomic, assign) int streamId;
+- (instancetype)initWithStreamId:(int)streamId;
+@end
+
+@implementation VeLiveMixerHelper
+
+// 对齐Android的static cachedMixedViews
+static NSMutableDictionary<NSString *, VeLiveMixerUIView *> *_cachedMixedViews = nil;
+static VeLiveMixerHelper *currentInstance = nil; // 强引用，防止被ARC释放
+
++ (NSMutableDictionary<NSString *, VeLiveMixerUIView *> *)cachedMixedViews {
+    if (!_cachedMixedViews) {
+        _cachedMixedViews = [[NSMutableDictionary alloc] init];
+    }
+    return _cachedMixedViews;
+}
+
++ (void)setCachedMixedViews:(NSMutableDictionary<NSString *, VeLiveMixerUIView *> *)cachedMixedViews {
+    _cachedMixedViews = cachedMixedViews;
+}
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    [self commonInit];
+  }
+  return self;
+}
+
+- (instancetype)initWithPusher:(VeLivePusher *)pusher {
+  self = [super init];
+  if (self) {
+    _pusher = pusher;
+    [self commonInit];
+    [self startMemoryMonitoring];
+  }
+  return self;
+}
+
+- (void)commonInit {
+  _mixedViewLayout = [[NSMutableDictionary alloc] init];
+  _viewIdToStreamId = [[NSMutableDictionary alloc] init];
+  _pendingCallbacks = [[NSMutableDictionary alloc] init];
+  _callbacks = [[NSMutableDictionary alloc] init];
+  
+  currentInstance = self;
+}
+
+#pragma mark - Lazy Loading Properties
+
+- (NSMutableDictionary *)mixedViewLayout {
+  if (!_mixedViewLayout) {
+    _mixedViewLayout = [[NSMutableDictionary alloc] init];
+  }
+  return _mixedViewLayout;
+}
+
+- (NSMutableDictionary *)viewIdToStreamId {
+  if (!_viewIdToStreamId) {
+    _viewIdToStreamId = [[NSMutableDictionary alloc] init];
+  }
+  return _viewIdToStreamId;
+}
+
+- (NSMutableDictionary *)pendingCallbacks {
+  if (!_pendingCallbacks) {
+    _pendingCallbacks = [[NSMutableDictionary alloc] init];
+  }
+  return _pendingCallbacks;
+}
+
+- (NSMutableDictionary *)callbacks {
+  if (!_callbacks) {
+    _callbacks = [[NSMutableDictionary alloc] init];
+  }
+  return _callbacks;
+}
+
+#pragma mark - Public Methods
+
+- (void)setPusher:(VeLivePusher *)pusher {
+  _pusher = pusher;
+  
+  if (currentInstance != self) {
+    currentInstance = self;
+  }
+}
+
+- (int)addView:(NSString *)viewId config:(NSDictionary *)viewInfo {
+  @try {
+    if (!self.pusher) {
+      return -1;
+    }
+    
+    VeLiveMixerUIView *view = [VeLiveMixerHelper cachedMixedViews][viewId];
+    if (![view isKindOfClass:[VeLiveMixerUIView class]]) {
+      // View not ready, store pending callback
+    }
+    
+    NSNumber *existingStreamId = [self.viewIdToStreamId objectForKey:viewId];
+    if(existingStreamId != nil) {
+      return [existingStreamId intValue];
+    }
+    
+    int videoStreamId = [[self.pusher getMixerManager] addVideoStream];
+    
+    NSDictionary *layout = @{
+      @"x": viewInfo[@"x"] ?: @(0),
+      @"y": viewInfo[@"y"] ?: @(0),
+      @"width": viewInfo[@"width"] ?: @(0),
+      @"height": viewInfo[@"height"] ?: @(0),
+      @"zOrder": viewInfo[@"zOrder"] ?: @(1),
+      @"renderMode": viewInfo[@"renderMode"] ?: @(0),
+      @"streamId": @(videoStreamId)
+    };
+    
+    VeLiveStreamMixDescription *description = [[VeLiveStreamMixDescription alloc] init];
+    VeLiveMixVideoLayout *videoLayout = [[VeLiveMixVideoLayout alloc] init];
+    videoLayout.streamId = videoStreamId;
+    videoLayout.x = [viewInfo[@"x"] floatValue];
+    videoLayout.y = [viewInfo[@"y"] floatValue];
+    videoLayout.width = [viewInfo[@"width"] floatValue];
+    videoLayout.height = [viewInfo[@"height"] floatValue];
+    videoLayout.zOrder = [viewInfo[@"zOrder"] intValue];
+    videoLayout.renderMode = [viewInfo[@"renderMode"] intValue];
+    description.mixVideoStreams = @[videoLayout];
+    [self.pusher.getMixerManager updateStreamMixDescription:description];
+    
+    [self.mixedViewLayout setObject:layout forKey:viewId];
+    [self.viewIdToStreamId setObject:@(videoStreamId) forKey:viewId];
+    
+    if ([view isKindOfClass:[VeLiveMixerUIView class]]) {
+      [VeLiveMixerHelper setupCallbackForMixerView:view streamId:videoStreamId];
+    } else {
+      [self.pendingCallbacks setObject:@(videoStreamId) forKey:viewId];
+    }
+    
+    return videoStreamId;
+  } @catch (NSException *exception) {
+    return -1;
+  }
+}
+
+- (BOOL)updateView:(NSString *)viewId config:(NSDictionary *)viewInfo {
+  @try {
+    NSDictionary *layout = [self.mixedViewLayout objectForKey:viewId];
+    if (!layout) {
+      return NO;
+    }
+    
+    NSNumber *streamIdNumber = [self.viewIdToStreamId objectForKey:viewId];
+    int videoStreamId = [streamIdNumber intValue];
+    
+    NSMutableDictionary *updatedLayout = [layout mutableCopy];
+    [updatedLayout setObject:(viewInfo[@"x"] ?: layout[@"x"]) forKey:@"x"];
+    [updatedLayout setObject:(viewInfo[@"y"] ?: layout[@"y"]) forKey:@"y"];
+    [updatedLayout setObject:(viewInfo[@"width"] ?: layout[@"width"]) forKey:@"width"];
+    [updatedLayout setObject:(viewInfo[@"height"] ?: layout[@"height"]) forKey:@"height"];
+    [updatedLayout setObject:(viewInfo[@"zOrder"] ?: layout[@"zOrder"]) forKey:@"zOrder"];
+    [updatedLayout setObject:(viewInfo[@"renderMode"] ?: layout[@"renderMode"]) forKey:@"renderMode"];
+
+    VeLiveStreamMixDescription *description = [[VeLiveStreamMixDescription alloc] init];
+    VeLiveMixVideoLayout *videoLayout = [[VeLiveMixVideoLayout alloc] init];
+    videoLayout.streamId = videoStreamId;
+    videoLayout.x = [updatedLayout[@"x"] floatValue];
+    videoLayout.y = [updatedLayout[@"y"] floatValue];
+    videoLayout.width = [updatedLayout[@"width"] floatValue];
+    videoLayout.height = [updatedLayout[@"height"] floatValue];
+    videoLayout.zOrder = [updatedLayout[@"zOrder"] intValue];
+    videoLayout.renderMode = [updatedLayout[@"renderMode"] intValue];
+    description.mixVideoStreams = @[videoLayout];
+    [self.pusher.getMixerManager updateStreamMixDescription:description];
+    
+    [self.mixedViewLayout setObject:updatedLayout forKey:viewId];
+    
+    VeLiveMixerUIView *mixerView = [[VeLiveMixerHelper cachedMixedViews] objectForKey:viewId];
+    [mixerView performCaptureWithTrigger:@"update"];
+    
+    return YES;
+  } @catch (NSException *exception) {
+    return NO;
+  }
+}
+
+- (BOOL)removeView:(NSString *)viewId {
+  @try {
+    NSDictionary *layout = [self.mixedViewLayout objectForKey:viewId];
+    if (!layout) {
+      return NO;
+    }
+    
+    NSNumber *streamIdNumber = [self.viewIdToStreamId objectForKey:viewId];
+    if (streamIdNumber) {
+      int streamId = [streamIdNumber intValue];
+      [self.pusher.getMixerManager removeVideoStream:streamId];
+      
+      NSString *callbackKey = [NSString stringWithFormat:@"%d", streamId];
+      [self.callbacks removeObjectForKey:callbackKey];
+    }
+    
+    [self.viewIdToStreamId removeObjectForKey:viewId];
+    [self.pendingCallbacks removeObjectForKey:viewId];
+    
+    VeLiveMixerUIView *view = [[VeLiveMixerHelper cachedMixedViews] objectForKey:viewId];
+    if ([view isKindOfClass:[VeLiveMixerUIView class]]) {
+      view.bitmapCaptureCallback = nil;
+    }
+    
+    [self.mixedViewLayout removeObjectForKey:viewId];
+    
+    return YES;
+  } @catch (NSException *exception) {
+    return NO;
+  }
+}
+
+- (void)captureView:(NSString *)viewId {
+  VeLiveMixerUIView *view = [[VeLiveMixerHelper cachedMixedViews] objectForKey:viewId];
+  if ([view isKindOfClass:[VeLiveMixerUIView class]]) {
+    [view performCaptureWithTrigger:@"manual"];
+  }
+}
+
+#pragma mark - Static Methods
+
++ (void)setupCallbackForMixerView:(VeLiveMixerUIView *)mixerView streamId:(int)streamId {
+  if (mixerView == nil) {
+    return;
+  }
+  
+  VeLiveMixerHelper *instance = [VeLiveMixerHelper findActiveMixerManager];
+  if (!instance) {
+    return;
+  }
+  
+  VeLiveMixerBitmapCallback *callback = [[VeLiveMixerBitmapCallback alloc] initWithStreamId:streamId];
+  
+  NSString *callbackKey = [NSString stringWithFormat:@"%d", streamId];
+  [instance.callbacks setObject:callback forKey:callbackKey];
+  
+  mixerView.bitmapCaptureCallback = callback;
+  
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+    @try {
+      if (mixerView && mixerView.bitmapCaptureCallback) {
+        VeLiveMixerHelper *instance = [VeLiveMixerHelper findActiveMixerManager];
+        if (instance && instance.pusher) {
+          @try {
+            NSString *viewId = mixerView.viewId;
+            NSDictionary *layout = [instance.mixedViewLayout objectForKey:viewId];
+            if (layout) {
+              VeLiveStreamMixDescription *description = [[VeLiveStreamMixDescription alloc] init];
+              VeLiveMixVideoLayout *videoLayout = [[VeLiveMixVideoLayout alloc] init];
+              videoLayout.streamId = streamId;
+              videoLayout.x = [layout[@"x"] floatValue];
+              videoLayout.y = [layout[@"y"] floatValue];
+              videoLayout.width = [layout[@"width"] floatValue];
+              videoLayout.height = [layout[@"height"] floatValue];
+              videoLayout.zOrder = [layout[@"zOrder"] intValue];
+              videoLayout.renderMode = [layout[@"renderMode"] intValue];
+              description.mixVideoStreams = @[videoLayout];
+              [instance.pusher.getMixerManager updateStreamMixDescription:description];
+            }
+          } @catch (NSException *e) {
+            // Ignore
+          }
+        }
+        
+        [mixerView performCaptureWithTrigger:@"update"];
+      }
+    } @catch (NSException *exception) {
+      // Ignore
+    }
+  });
+}
+
++ (void)sendBitmapToMixerStatic:(int)streamId bitmap:(UIImage *)bitmap {
+  VeLiveMixerHelper *instance = [VeLiveMixerHelper findActiveMixerManager];
+  if (instance && instance.pusher) {
+    [instance sendBitmapToMixer:streamId bitmap:bitmap];
+  }
+}
+
++ (VeLiveMixerHelper *)findActiveMixerManager {
+  return currentInstance;
+}
+
++ (void)onViewReady:(NSString *)viewId mixerView:(VeLiveMixerUIView *)mixerView {
+  @try {
+    VeLiveMixerHelper *instance = [VeLiveMixerHelper findActiveMixerManager];
+    if (instance != nil) {
+      NSNumber *streamIdNumber = [instance.pendingCallbacks objectForKey:viewId];
+      if (streamIdNumber != nil) {
+        int streamId = [streamIdNumber intValue];
+        [instance.pendingCallbacks removeObjectForKey:viewId];
+        [VeLiveMixerHelper setupCallbackForMixerView:mixerView streamId:streamId];
+      }
+    }
+  } @catch (NSException *exception) {
+    // Ignore
+  }
+}
+
+- (void)cleanup {
+  [self stopMemoryMonitoring];
+  
+  for (NSString *viewId in self.mixedViewLayout.allKeys) {
+    VeLiveMixerUIView *view = [[VeLiveMixerHelper cachedMixedViews] objectForKey:viewId];
+    if ([view isKindOfClass:[VeLiveMixerUIView class]]) {
+      view.bitmapCaptureCallback = nil;
+    }
+  }
+  
+  [self.mixedViewLayout removeAllObjects];
+  [self.pendingCallbacks removeAllObjects];
+  [self.callbacks removeAllObjects];
+  
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
+    @autoreleasepool {
+      [[NSURLCache sharedURLCache] removeAllCachedResponses];
+      [[NSURLCache sharedURLCache] setMemoryCapacity:0];
+      [[NSURLCache sharedURLCache] setMemoryCapacity:10 * 1024 * 1024];
+      
+      [[NSNotificationCenter defaultCenter] postNotificationName:UIApplicationDidReceiveMemoryWarningNotification object:nil];
+      
+      dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+        // Final cleanup completed
+      });
+    }
+  });
+}
+
+- (void)dealloc {
+  [self cleanup];
+  
+  if (currentInstance == self) {
+    currentInstance = nil;
+  }
+}
+
+#pragma mark - Memory Monitoring
+
+- (void)startMemoryMonitoring {
+  self.memoryMonitorTimer = [NSTimer scheduledTimerWithTimeInterval:30.0
+                                                             target:self
+                                                           selector:@selector(checkMemoryUsage)
+                                                           userInfo:nil
+                                                            repeats:YES];
+}
+
+- (void)stopMemoryMonitoring {
+  if (self.memoryMonitorTimer) {
+    [self.memoryMonitorTimer invalidate];
+    self.memoryMonitorTimer = nil;
+  }
+}
+
+- (void)checkMemoryUsage {
+  @autoreleasepool {
+    struct task_basic_info info;
+    mach_msg_type_number_t size = TASK_BASIC_INFO_COUNT;
+    kern_return_t kerr = task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &size);
+    
+    if (kerr == KERN_SUCCESS) {
+      double memoryUsageMB = info.resident_size / 1024.0 / 1024.0;
+      
+      if (memoryUsageMB > 200.0) {
+        [self performMemoryCleanup];
+      }
+    }
+  }
+}
+
+- (void)performMemoryCleanup {
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
+    @autoreleasepool {
+      NSMutableDictionary *cachedViews = [VeLiveMixerHelper cachedMixedViews];
+      for (NSString *viewId in cachedViews.allKeys) {
+        VeLiveMixerUIView *view = [cachedViews objectForKey:viewId];
+        if ([view isKindOfClass:[VeLiveMixerUIView class]]) {
+          if ([view.captureMode isEqualToString:@"realtime"]) {
+            [view stopCapture];
+            
+            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+              if (view && [cachedViews objectForKey:viewId] == view) {
+                [view startCapture];
+              }
+            });
+          }
+        }
+      }
+      
+      [[NSURLCache sharedURLCache] removeAllCachedResponses];
+      [[NSURLCache sharedURLCache] setMemoryCapacity:5 * 1024 * 1024];
+      
+      [[NSNotificationCenter defaultCenter] postNotificationName:UIApplicationDidReceiveMemoryWarningNotification object:nil];
+    }
+  });
+}
+
+#pragma mark - Private Methods
+
+- (void)sendBitmapToMixer:(int)streamId bitmap:(UIImage *)bitmap {
+  @autoreleasepool {
+    if (!self.pusher || !bitmap) {
+      return;
+    }
+    
+    CVPixelBufferRef pixelBuffer = NULL;
+    
+    @try {
+      pixelBuffer = [self pixelBufferFromUIImage:bitmap];
+      if (!pixelBuffer) {
+        return;
+      }
+      
+      VeLiveVideoFrame *videoFrame = [[VeLiveVideoFrame alloc] init];
+      videoFrame.bufferType = VeLiveVideoBufferTypePixelBuffer;
+      videoFrame.pts = CMTimeMakeWithSeconds(CACurrentMediaTime(), 1000000000);
+      videoFrame.pixelBuffer = pixelBuffer;
+      
+      __block CVPixelBufferRef bufferToRelease = pixelBuffer;
+      [videoFrame setReleaseCallback:^{
+        @autoreleasepool {
+          if (bufferToRelease) {
+            CVPixelBufferRelease(bufferToRelease);
+            bufferToRelease = NULL;
+          }
+        }
+      }];
+      
+      [[self.pusher getMixerManager] sendCustomVideoFrame:videoFrame streamId:streamId];
+      
+      pixelBuffer = NULL;
+      
+    } @catch (NSException *exception) {
+      if (pixelBuffer) {
+        CVPixelBufferRelease(pixelBuffer);
+        pixelBuffer = NULL;
+      }
+    }
+  }
+}
+
+#pragma mark - Helper Methods
+
+- (CVPixelBufferRef)pixelBufferFromUIImage:(UIImage *)image {
+  if (!image) {
+    return NULL;
+  }
+  
+  CGImageRef cgImage = image.CGImage;
+  if (!cgImage) {
+    return NULL;
+  }
+  
+  CGFloat width = CGImageGetWidth(cgImage);
+  CGFloat height = CGImageGetHeight(cgImage);
+  
+  NSDictionary *options = @{
+    (NSString *)kCVPixelBufferCGImageCompatibilityKey: @YES,
+    (NSString *)kCVPixelBufferCGBitmapContextCompatibilityKey: @YES,
+    (NSString *)kCVPixelBufferIOSurfacePropertiesKey: @{}
+  };
+  
+  CVPixelBufferRef pixelBuffer = NULL;
+  CVReturn status = CVPixelBufferCreate(kCFAllocatorDefault,
+                                       width, height,
+                                       kCVPixelFormatType_32BGRA,
+                                       (__bridge CFDictionaryRef)options,
+                                       &pixelBuffer);
+  
+  if (status != kCVReturnSuccess || !pixelBuffer) {
+    return NULL;
+  }
+  
+  CVPixelBufferLockBaseAddress(pixelBuffer, 0);
+  
+  void *pixelData = CVPixelBufferGetBaseAddress(pixelBuffer);
+  size_t bytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer);
+  
+  CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+  CGContextRef context = CGBitmapContextCreate(pixelData, width, height,
+                                              8, bytesPerRow, colorSpace,
+                                              kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host);
+  
+  if (!context) {
+    CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+    CVPixelBufferRelease(pixelBuffer);
+    CGColorSpaceRelease(colorSpace);
+    return NULL;
+  }
+  
+  CGContextDrawImage(context, CGRectMake(0, 0, width, height), cgImage);
+  
+  CGContextRelease(context);
+  CGColorSpaceRelease(colorSpace);
+  CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
+  
+  return pixelBuffer;
+}
+
+@end
+
+#pragma mark - VeLiveMixerBitmapCallback Implementation
+
+@implementation VeLiveMixerBitmapCallback
+
+- (instancetype)initWithStreamId:(int)streamId {
+  self = [super init];
+  if (self) {
+    _streamId = streamId;
+  }
+  return self;
+}
+
+- (void)onBitmapCaptured:(UIImage *)bitmap {
+  if (bitmap != nil) {
+    [VeLiveMixerHelper sendBitmapToMixerStatic:self.streamId bitmap:bitmap];
+  }
+}
+
+- (void)onCaptureError:(NSString *)error {
+  // Ignore
+}
+
+@end

package/ios/VeLiveMixerView.h

@@ -0,0 +1,69 @@
+//
+//  VeLiveMixerView.h
+//  react-native-live-push
+//
+//  Created by ByteDance on 2025/06/09.
+//
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <React/RCTComponent.h>
+#import <CoreVideo/CoreVideo.h>
+#import <CoreMedia/CoreMedia.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// Bitmap捕获回调协议 - 对应Android的BitmapCaptureCallback
+@protocol VeLiveBitmapCaptureCallback <NSObject>
+- (void)onBitmapCaptured:(UIImage *)bitmap;
+- (void)onCaptureError:(NSString *)error;
+@end
+
+// MixerView代理协议
+@protocol VeLiveMixerViewDelegate <NSObject>
+- (void)onBitmapCaptured:(UIImage *)image viewId:(NSString *)viewId;
+- (void)onCaptureError:(NSString *)error viewId:(NSString *)viewId;
+@end
+
+@interface VeLiveMixerUIView : UIView
+
+// 视图标识
+@property (nonatomic, strong) NSString *viewId;
+
+// 混流配置属性
+@property (nonatomic, strong) NSNumber *x;
+@property (nonatomic, strong) NSNumber *y;
+@property (nonatomic, strong) NSNumber *width;
+@property (nonatomic, strong) NSNumber *height;
+@property (nonatomic, strong) NSNumber *zOrder;
+@property (nonatomic, strong) NSNumber *renderMode;
+@property (nonatomic, strong) NSString *captureMode;
+@property (nonatomic, strong) NSNumber *captureFramerate;
+@property (nonatomic, strong) NSNumber *autoSensitivity;
+
+// React Native 事件回调
+@property (nonatomic, copy) RCTBubblingEventBlock onBitmapCapture;
+@property (nonatomic, copy) RCTBubblingEventBlock onCaptureError;
+
+// 代理
+@property (nonatomic, weak) id<VeLiveMixerViewDelegate> delegate;
+
+// Bitmap捕获回调 - 用于与MixerManager集成
+@property (nonatomic, weak) id<VeLiveBitmapCaptureCallback> bitmapCaptureCallback;
+
+// 控制方法
+- (void)startCapture;
+- (void)stopCapture;
+- (void)performCaptureWithTrigger:(NSString *)trigger;
+
+// 设置bitmap捕获回调
+- (void)setBitmapCaptureCallback:(id<VeLiveBitmapCaptureCallback>)callback;
+
+// UIView转换方法
+- (UIImage *)snapshotIncludeSubviews;
+- (CVPixelBufferRef)createPixelBuffer;
+- (CMSampleBufferRef)createSampleBuffer;
+
+@end
+
+NS_ASSUME_NONNULL_END