@volcengine/react-native-live-push 1.1.3-rc.1 → 1.3.0-rc.0

package/ios/VeLiveMixerHelper.h

@@ -0,0 +1,49 @@
+//
+//  VeLiveMixerHelper.h
+//  react-native-live-push
+//
+//  Created by ByteDance on 2024/12/09.
+//
+
+#import "VeLiveMixerView.h"
+#import <CoreVideo/CoreVideo.h>
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// Forward declaration
+@class VeLivePusher;
+
+// Mixer helper class - fully aligned with Android MixerManager.java
+@interface VeLiveMixerHelper : NSObject <VeLiveBitmapCaptureCallback>
+
+// Aligned with Android's static cachedMixedViews
+@property(class, nonatomic, strong)
+    NSMutableDictionary<NSString *, VeLiveMixerUIView *> *cachedMixedViews;
+
+@property(nonatomic, weak) VeLivePusher *pusher;
+
+- (instancetype)initWithPusher:(VeLivePusher *)pusher;
+
+// Public methods - fully aligned with Android MixerManager's public interface
+- (void)setPusher:(VeLivePusher *)pusher;
+- (int)addView:(NSString *)viewId config:(NSDictionary *)viewInfo;
+- (BOOL)updateView:(NSString *)viewId config:(NSDictionary *)viewInfo;
+- (BOOL)removeView:(NSString *)viewId;
+- (void)captureView:(NSString *)viewId;
+
+// Static methods - for sending captured content to mixer
++ (void)setupCallbackForMixerView:(VeLiveMixerUIView *)mixerView
+                         streamId:(int)streamId;
++ (void)sendBitmapToMixerStatic:(int)streamId bitmap:(UIImage *)bitmap;
++ (void)sendPixelBufferToMixerStatic:(int)streamId
+                         pixelBuffer:(CVPixelBufferRef)pixelBuffer;
++ (VeLiveMixerHelper *)findActiveMixerManager;
++ (void)onViewReady:(NSString *)viewId mixerView:(VeLiveMixerUIView *)mixerView;
+
+// Resource cleanup
+- (void)cleanup;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/VeLiveMixerHelper.m

@@ -0,0 +1,646 @@
+//
+//  VeLiveMixerHelper.m
+//  react-native-live-push
+//
+//  Created by ByteDance on 2024/12/09.
+//
+
+#import "VeLiveMixerHelper.h"
+#import <TTSDKFramework/VeLivePusher.h>
+#import <UIKit/UIKit.h>
+#import <mach/mach.h>
+#import <mach/task_info.h>
+#include <objc/NSObjCRuntime.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
+
+// Aligned with Android's static cachedMixedViews
+static NSMutableDictionary<NSString *, VeLiveMixerUIView *> *_cachedMixedViews =
+    nil;
+static VeLiveMixerHelper *currentInstance =
+    nil; // Strong reference to prevent ARC deallocation
+
++ (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),
+      @"alpha" : viewInfo[@"alpha"] ?: @(1.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.alpha = [viewInfo[@"alpha"] floatValue] ?: 1.0;
+    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];
+
+      // Delayed capture execution to ensure view layout completion
+      dispatch_after(
+          dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.3 * NSEC_PER_SEC)),
+          dispatch_get_main_queue(), ^{
+            @try {
+              if (view && view.bitmapCaptureCallback) {
+                [view performCaptureWithTrigger:@"addView"];
+              }
+            } @catch (NSException *exception) {
+              // Ignore
+            }
+          });
+    } 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[@"alpha"] ?: layout[@"alpha"])
+                      forKey:@"alpha"];
+    [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.alpha = [updatedLayout[@"alpha"] 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];
+
+    // Delayed capture execution to ensure property updates completion
+    VeLiveMixerUIView *mixerView =
+        [[VeLiveMixerHelper cachedMixedViews] objectForKey:viewId];
+    if ([mixerView isKindOfClass:[VeLiveMixerUIView class]]) {
+      dispatch_after(
+          dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.3 * NSEC_PER_SEC)),
+          dispatch_get_main_queue(), ^{
+            @try {
+              [mixerView performCaptureWithTrigger:@"update"];
+            } @catch (NSException *exception) {
+              // Ignore
+            }
+          });
+    }
+
+    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.1 * 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.alpha = [layout[@"alpha"] floatValue];
+                  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];
+  }
+}
+
+// New: Send pixelBuffer directly to mixer, avoiding UIImage conversion overhead
++ (void)sendPixelBufferToMixerStatic:(int)streamId
+                         pixelBuffer:(CVPixelBufferRef)pixelBuffer {
+  VeLiveMixerHelper *instance = [VeLiveMixerHelper findActiveMixerManager];
+  if (instance && instance.pusher) {
+    [instance sendPixelBufferToMixer:streamId pixelBuffer:pixelBuffer];
+  }
+}
+
++ (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
+
+// Send UIImage to mixer (via pixelBuffer conversion)
+- (void)sendBitmapToMixer:(int)streamId bitmap:(UIImage *)bitmap {
+  @autoreleasepool {
+    if (!self.pusher || !bitmap) {
+      return;
+    }
+
+    CVPixelBufferRef pixelBuffer = NULL;
+
+    @try {
+      pixelBuffer = [self pixelBufferFromUIImage:bitmap];
+      if (!pixelBuffer) {
+        return;
+      }
+
+      // Use new pixelBuffer method
+      [self sendPixelBufferToMixer:streamId pixelBuffer:pixelBuffer];
+
+    } @finally {
+      if (pixelBuffer) {
+        CVPixelBufferRelease(pixelBuffer);
+        pixelBuffer = NULL;
+      }
+    }
+  }
+}
+
+// Send pixelBuffer directly to mixer, better performance
+- (void)sendPixelBufferToMixer:(int)streamId
+                   pixelBuffer:(CVPixelBufferRef)pixelBuffer {
+  @autoreleasepool {
+    if (!self.pusher || !pixelBuffer) {
+      return;
+    }
+
+    @try {
+      VeLiveVideoFrame *videoFrame = [[VeLiveVideoFrame alloc] init];
+      videoFrame.bufferType = VeLiveVideoBufferTypePixelBuffer;
+      videoFrame.pts = CMTimeMakeWithSeconds(CACurrentMediaTime(), 1000000000);
+      videoFrame.pixelBuffer = pixelBuffer;
+
+      [[self.pusher getMixerManager] sendCustomVideoFrame:videoFrame
+                                                 streamId:streamId];
+    } @catch (NSException *exception) {
+      // Handle exception silently
+    }
+  }
+}
+
+#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