@rejourneyco/react-native 1.0.0 → 1.0.2

package/ios/Capture/RJCaptureHeuristics.m

@@ -20,7 +20,7 @@ static const NSTimeInterval kRJQuietScrollSeconds = 0.2;
 static const NSTimeInterval kRJQuietBounceSeconds = 0.2;
 static const NSTimeInterval kRJQuietRefreshSeconds = 0.22;
 static const NSTimeInterval kRJQuietMapSeconds = 0.55;
-static const NSTimeInterval kRJQuietTransitionSeconds = 0.2;
+static const NSTimeInterval kRJQuietTransitionSeconds = 0.1;
 static const NSTimeInterval kRJQuietKeyboardSeconds = 0.25;
 static const NSTimeInterval kRJQuietAnimationSeconds = 0.25;
 
@@ -204,7 +204,8 @@ typedef struct {
 
 - (void)recordTouchEventAtTime:(NSTimeInterval)time {
   self.lastTouchTime = time;
-  [self scheduleBonusCaptureAfterDelay:kRJBonusInteractionDelaySeconds now:time];
+  [self scheduleBonusCaptureAfterDelay:kRJBonusInteractionDelaySeconds
+                                   now:time];
 }
 
 - (void)recordInteractionEventAtTime:(NSTimeInterval)time {
@@ -221,12 +222,11 @@ typedef struct {
 
 - (void)recordNavigationEventAtTime:(NSTimeInterval)time {
   self.lastTransitionTime = time;
-  [self scheduleBonusCaptureAfterDelay:kRJBonusTransitionDelaySeconds
-                                   now:time];
+  [self scheduleBonusCaptureAfterDelay:kRJBonusTransitionDelaySeconds now:time];
 }
 
 - (void)recordRenderedSignature:(nullable NSString *)signature
-                          atTime:(NSTimeInterval)time {
+                         atTime:(NSTimeInterval)time {
   self.lastRenderedSignature = signature.length > 0 ? signature : nil;
   self.lastRenderedTime = time;
   if (self.pendingKeyframes > 0) {
@@ -262,8 +262,8 @@ typedef struct {
     }
     self.lastObservedSignatureTime = now;
     self.lastSignatureChurnTime = now;
-    self.lastObservedSignature = currentSignature.length > 0 ? currentSignature
-                                                             : nil;
+    self.lastObservedSignature =
+        currentSignature.length > 0 ? currentSignature : nil;
   } else if (self.lastSignatureChurnTime > 0 &&
              (now - self.lastSignatureChurnTime) >
                  kRJSignatureChurnWindowSeconds) {
@@ -296,15 +296,15 @@ typedef struct {
   }
 
   [self updateScrollActiveState:scanResult.scrollActive
-                    refreshActive:scanResult.refreshActive
-                         mapActive:scanResult.mapActive
-                               now:now];
+                  refreshActive:scanResult.refreshActive
+                      mapActive:scanResult.mapActive
+                            now:now];
 
   BOOL blockingAnimation = NO;
   if (scanResult.hasAnyAnimations) {
     self.lastAnimationAreaRatio = scanResult.animationAreaRatio;
-    blockingAnimation = (scanResult.animationAreaRatio >=
-                         kRJAnimationSmallAreaAllowed);
+    blockingAnimation =
+        (scanResult.animationAreaRatio >= kRJAnimationSmallAreaAllowed);
   } else {
     self.lastAnimationAreaRatio = 0.0;
   }
@@ -335,88 +335,113 @@ typedef struct {
   [self probeAnimatedViewsAtTime:now];
 }
 
-- (RJCaptureHeuristicsDecision *)decisionForSignature:
-                                    (nullable NSString *)signature
-                                                 now:(NSTimeInterval)now
-                                         hasLastFrame:(BOOL)hasLastFrame {
+- (RJCaptureHeuristicsDecision *)
+    decisionForSignature:(nullable NSString *)signature
+                     now:(NSTimeInterval)now
+            hasLastFrame:(BOOL)hasLastFrame
+              importance:(RJCaptureImportance)importance {
   RJCaptureHeuristicsDecision *decision =
       [[RJCaptureHeuristicsDecision alloc] init];
 
   NSTimeInterval earliestSafeTime = now;
   RJCaptureHeuristicsReason blockerReason = RJCaptureHeuristicsReasonRenderNow;
 
+  // Check importance to potentially bypass heuristics
+  BOOL isUrgent = (importance == RJCaptureImportanceHigh ||
+                   importance == RJCaptureImportanceCritical);
+
   // Active touch/gesture input should be avoided to keep input latency smooth.
-  [self considerBlockerSince:self.lastTouchTime
-               quietInterval:kRJQuietTouchSeconds
-                         now:now
-                     reason:RJCaptureHeuristicsReasonDeferTouch
-               earliestTime:&earliestSafeTime
-               chosenReason:&blockerReason];
+  // CRITICAL updates bypass this.
+  if (!isUrgent) {
+    [self considerBlockerSince:self.lastTouchTime
+                 quietInterval:kRJQuietTouchSeconds
+                           now:now
+                        reason:RJCaptureHeuristicsReasonDeferTouch
+                  earliestTime:&earliestSafeTime
+                  chosenReason:&blockerReason];
+  }
 
   // Scroll motion (dragging or deceleration) is a high-jank period.
-  [self considerBlockerSince:self.lastScrollTime
-               quietInterval:kRJQuietScrollSeconds
-                         now:now
-                     reason:RJCaptureHeuristicsReasonDeferScroll
-               earliestTime:&earliestSafeTime
-               chosenReason:&blockerReason];
+  // Even urgent captures should respect scroll to avoid visible hitching,
+  // unless CRITICAL
+  if (importance != RJCaptureImportanceCritical) {
+    [self considerBlockerSince:self.lastScrollTime
+                 quietInterval:kRJQuietScrollSeconds
+                           now:now
+                        reason:RJCaptureHeuristicsReasonDeferScroll
+                  earliestTime:&earliestSafeTime
+                  chosenReason:&blockerReason];
+  }
 
   // Rubber-band bounce and inset animations are visually sensitive.
-  [self considerBlockerSince:self.lastBounceTime
-               quietInterval:kRJQuietBounceSeconds
-                         now:now
-                     reason:RJCaptureHeuristicsReasonDeferBounce
-               earliestTime:&earliestSafeTime
-               chosenReason:&blockerReason];
+  if (!isUrgent) {
+    [self considerBlockerSince:self.lastBounceTime
+                 quietInterval:kRJQuietBounceSeconds
+                           now:now
+                        reason:RJCaptureHeuristicsReasonDeferBounce
+                  earliestTime:&earliestSafeTime
+                  chosenReason:&blockerReason];
+  }
 
   // Pull-to-refresh animations should finish before rendering.
-  [self considerBlockerSince:self.lastRefreshTime
-               quietInterval:kRJQuietRefreshSeconds
-                         now:now
-                     reason:RJCaptureHeuristicsReasonDeferRefresh
-               earliestTime:&earliestSafeTime
-               chosenReason:&blockerReason];
+  if (!isUrgent) {
+    [self considerBlockerSince:self.lastRefreshTime
+                 quietInterval:kRJQuietRefreshSeconds
+                           now:now
+                        reason:RJCaptureHeuristicsReasonDeferRefresh
+                  earliestTime:&earliestSafeTime
+                  chosenReason:&blockerReason];
+  }
 
   // Interactive transitions (swipe back, drag-to-dismiss) are hitch-sensitive.
-  [self considerBlockerSince:self.lastTransitionTime
-               quietInterval:kRJQuietTransitionSeconds
-                         now:now
-                     reason:RJCaptureHeuristicsReasonDeferTransition
-               earliestTime:&earliestSafeTime
-               chosenReason:&blockerReason];
+  // KEY FIX: Urgent captures (NAVIGATION) must bypass this!
+  if (!isUrgent) {
+    [self considerBlockerSince:self.lastTransitionTime
+                 quietInterval:kRJQuietTransitionSeconds
+                           now:now
+                        reason:RJCaptureHeuristicsReasonDeferTransition
+                  earliestTime:&earliestSafeTime
+                  chosenReason:&blockerReason];
+  }
 
   // Keyboard frame animations can stutter; wait for settle.
   if (self.keyboardAnimating) {
     self.lastKeyboardTime = now;
   }
-  [self considerBlockerSince:self.lastKeyboardTime
-               quietInterval:kRJQuietKeyboardSeconds
-                         now:now
-                     reason:RJCaptureHeuristicsReasonDeferKeyboard
-               earliestTime:&earliestSafeTime
-               chosenReason:&blockerReason];
+  if (!isUrgent) {
+    [self considerBlockerSince:self.lastKeyboardTime
+                 quietInterval:kRJQuietKeyboardSeconds
+                           now:now
+                        reason:RJCaptureHeuristicsReasonDeferKeyboard
+                  earliestTime:&earliestSafeTime
+                  chosenReason:&blockerReason];
+  }
 
   // Map camera or tile motion is visually obvious; avoid rendering mid-flight.
-  [self considerBlockerSince:self.lastMapTime
-               quietInterval:kRJQuietMapSeconds
-                         now:now
-                     reason:RJCaptureHeuristicsReasonDeferMap
-               earliestTime:&earliestSafeTime
-               chosenReason:&blockerReason];
+  // Maps are special; even CRITICAL captures might want to wait for map settle
+  // if possible.
+  if (importance != RJCaptureImportanceCritical) {
+    [self considerBlockerSince:self.lastMapTime
+                 quietInterval:kRJQuietMapSeconds
+                           now:now
+                        reason:RJCaptureHeuristicsReasonDeferMap
+                  earliestTime:&earliestSafeTime
+                  chosenReason:&blockerReason];
 
-  if (self.mapSettleUntil > now && self.mapSettleUntil > earliestSafeTime) {
-    earliestSafeTime = self.mapSettleUntil;
-    blockerReason = RJCaptureHeuristicsReasonDeferMap;
+    if (self.mapSettleUntil > now && self.mapSettleUntil > earliestSafeTime) {
+      earliestSafeTime = self.mapSettleUntil;
+      blockerReason = RJCaptureHeuristicsReasonDeferMap;
+    }
   }
 
   // Large-area animations (Lottie, shimmer, etc.) are very noticeable.
-  if (self.animationBlocking) {
+  if (self.animationBlocking && !isUrgent) {
     [self considerBlockerSince:self.lastAnimationTime
                  quietInterval:kRJQuietAnimationSeconds
                            now:now
-                       reason:RJCaptureHeuristicsReasonDeferBigAnimation
-                 earliestTime:&earliestSafeTime
-                 chosenReason:&blockerReason];
+                        reason:RJCaptureHeuristicsReasonDeferBigAnimation
+                  earliestTime:&earliestSafeTime
+                  chosenReason:&blockerReason];
   }
 
   if (earliestSafeTime > now) {
@@ -426,26 +451,27 @@ typedef struct {
     return decision;
   }
 
-  BOOL signatureChanged = (signature.length == 0 ||
-                           ![signature isEqualToString:self.lastRenderedSignature]);
+  BOOL signatureChanged =
+      (signature.length == 0 ||
+       ![signature isEqualToString:self.lastRenderedSignature]);
   BOOL stale = (self.lastRenderedTime <= 0 ||
                 (now - self.lastRenderedTime) > self.maxStaleSeconds);
   BOOL bonusDue = (self.bonusCaptureTime > 0 && now >= self.bonusCaptureTime);
-  BOOL keyframeDue = bonusDue && self.pendingKeyframes > 0 &&
-                     (now - self.lastKeyframeRenderTime) >=
-                         kRJKeyframeSpacingSeconds;
+  BOOL keyframeDue =
+      bonusDue && self.pendingKeyframes > 0 &&
+      (now - self.lastKeyframeRenderTime) >= kRJKeyframeSpacingSeconds;
   BOOL staleOnly = stale && hasLastFrame && !signatureChanged && !keyframeDue;
   BOOL suppressStaleRender =
       staleOnly &&
       (self.hasVideoSurface || self.hasWebSurface || self.hasCameraSurface);
 
-  if (suppressStaleRender) {
+  if (suppressStaleRender && !isUrgent) {
     decision.action = RJCaptureHeuristicsActionReuseLast;
     decision.reason = RJCaptureHeuristicsReasonReuseSignatureUnchanged;
     return decision;
   }
 
-  if (!hasLastFrame || signatureChanged || stale || keyframeDue) {
+  if (!hasLastFrame || signatureChanged || stale || keyframeDue || isUrgent) {
     decision.action = RJCaptureHeuristicsActionRenderNow;
     decision.reason = RJCaptureHeuristicsReasonRenderNow;
     return decision;
@@ -516,7 +542,8 @@ typedef struct {
   UIViewController *topVC = [self topViewControllerForWindow:window];
   if (topVC != self.lastTopVC) {
     self.lastTransitionTime = now;
-    [self scheduleBonusCaptureAfterDelay:kRJBonusTransitionDelaySeconds now:now];
+    [self scheduleBonusCaptureAfterDelay:kRJBonusTransitionDelaySeconds
+                                     now:now];
     self.lastTopVC = topVC;
   }
   id<UIViewControllerTransitionCoordinator> coordinator =
@@ -552,7 +579,7 @@ typedef struct {
 #pragma mark - Scroll Tracking
 
 - (void)updateTrackedScrollViews:(NSArray<NSValue *> *)scrollViewPointers
-                              now:(NSTimeInterval)now {
+                             now:(NSTimeInterval)now {
   if (!scrollViewPointers) {
     return;
   }
@@ -563,18 +590,18 @@ typedef struct {
       continue;
     }
     [self evaluateScrollView:scrollView
-                        now:now
-                 scrollActive:NULL
-                refreshActive:NULL];
+                         now:now
+                scrollActive:NULL
+               refreshActive:NULL];
   }
-
 }
 
 - (void)probeScrollViewsAtTime:(NSTimeInterval)now {
   BOOL anyScrollActive = NO;
   BOOL anyRefreshActive = NO;
 
-  NSArray<UIScrollView *> *scrollViews = [[self.scrollSamples keyEnumerator] allObjects];
+  NSArray<UIScrollView *> *scrollViews =
+      [[self.scrollSamples keyEnumerator] allObjects];
   if (!scrollViews) {
     scrollViews = @[];
   }
@@ -583,21 +610,21 @@ typedef struct {
       continue;
     }
     [self evaluateScrollView:scrollView
-                        now:now
-                 scrollActive:&anyScrollActive
-                refreshActive:&anyRefreshActive];
+                         now:now
+                scrollActive:&anyScrollActive
+               refreshActive:&anyRefreshActive];
   }
 
   [self updateScrollActiveState:anyScrollActive
-                    refreshActive:anyRefreshActive
-                         mapActive:self.mapActive
-                               now:now];
+                  refreshActive:anyRefreshActive
+                      mapActive:self.mapActive
+                            now:now];
 }
 
 - (void)evaluateScrollView:(UIScrollView *)scrollView
                        now:(NSTimeInterval)now
-                scrollActive:(BOOL *)scrollActive
-               refreshActive:(BOOL *)refreshActive {
+              scrollActive:(BOOL *)scrollActive
+             refreshActive:(BOOL *)refreshActive {
   RJScrollViewSample *sample = [self.scrollSamples objectForKey:scrollView];
   if (!sample) {
     sample = [[RJScrollViewSample alloc] init];
@@ -609,8 +636,9 @@ typedef struct {
 
   BOOL tracking = scrollView.isTracking || scrollView.isDragging ||
                   scrollView.isDecelerating;
-  BOOL offsetMoved = (fabs(offset.x - sample.contentOffset.x) > kRJScrollEpsilon ||
-                      fabs(offset.y - sample.contentOffset.y) > kRJScrollEpsilon);
+  BOOL offsetMoved =
+      (fabs(offset.x - sample.contentOffset.x) > kRJScrollEpsilon ||
+       fabs(offset.y - sample.contentOffset.y) > kRJScrollEpsilon);
   BOOL zoomMoved = fabs(zoomScale - sample.zoomScale) > kRJZoomEpsilon;
   BOOL isScrolling = tracking || offsetMoved || zoomMoved;
 
@@ -635,8 +663,8 @@ typedef struct {
   }
 
   BOOL refreshVisible = [self isRefreshActiveForScrollView:scrollView
-                                                   offset:offset
-                                                    inset:inset];
+                                                    offset:offset
+                                                     inset:inset];
   if (refreshVisible) {
     // Pull-to-refresh is active or settling.
     self.lastRefreshTime = now;
@@ -660,8 +688,8 @@ typedef struct {
   }
   CGFloat topLimit = -inset.top - kRJScrollEpsilon;
   CGFloat bottomLimit = scrollView.contentSize.height -
-                        scrollView.bounds.size.height +
-                        inset.bottom + kRJScrollEpsilon;
+                        scrollView.bounds.size.height + inset.bottom +
+                        kRJScrollEpsilon;
 
   if (offset.y < topLimit || offset.y > bottomLimit) {
     return YES;
@@ -669,8 +697,8 @@ typedef struct {
 
   CGFloat leftLimit = -inset.left - kRJScrollEpsilon;
   CGFloat rightLimit = scrollView.contentSize.width -
-                       scrollView.bounds.size.width +
-                       inset.right + kRJScrollEpsilon;
+                       scrollView.bounds.size.width + inset.right +
+                       kRJScrollEpsilon;
   if (offset.x < leftLimit || offset.x > rightLimit) {
     return YES;
   }
@@ -690,8 +718,8 @@ typedef struct {
     return YES;
   }
 
-  CGFloat triggerOffset = -scrollView.adjustedContentInset.top -
-                          kRJScrollEpsilon;
+  CGFloat triggerOffset =
+      -scrollView.adjustedContentInset.top - kRJScrollEpsilon;
   if (offset.y < triggerOffset) {
     return YES;
   }
@@ -709,9 +737,9 @@ typedef struct {
 }
 
 - (void)updateScrollActiveState:(BOOL)scrollActive
-                    refreshActive:(BOOL)refreshActive
-                         mapActive:(BOOL)mapActive
-                               now:(NSTimeInterval)now {
+                  refreshActive:(BOOL)refreshActive
+                      mapActive:(BOOL)mapActive
+                            now:(NSTimeInterval)now {
   if (self.scrollActive && !scrollActive) {
     [self scheduleBonusCaptureAfterDelay:kRJBonusScrollDelaySeconds now:now];
   }
@@ -734,7 +762,7 @@ typedef struct {
 #pragma mark - Map Tracking
 
 - (void)updateTrackedMapViews:(NSArray<NSValue *> *)mapViewPointers
-                           now:(NSTimeInterval)now {
+                          now:(NSTimeInterval)now {
   if (!mapViewPointers) {
     return;
   }
@@ -763,9 +791,9 @@ typedef struct {
     self.lastMapTime = now;
   }
   [self updateScrollActiveState:self.scrollActive
-                    refreshActive:self.refreshActive
-                         mapActive:anyMapActive || self.mapActive
-                               now:now];
+                  refreshActive:self.refreshActive
+                      mapActive:anyMapActive || self.mapActive
+                            now:now];
 }
 
 - (BOOL)updateMapStateForView:(UIView *)view atTime:(NSTimeInterval)now {
@@ -836,8 +864,7 @@ typedef struct {
 
 - (void)probeAnimatedViewsAtTime:(NSTimeInterval)now {
   if (self.churnBlocking) {
-    if ((now - self.lastSignatureChurnTime) <
-        kRJSignatureChurnWindowSeconds) {
+    if ((now - self.lastSignatureChurnTime) < kRJSignatureChurnWindowSeconds) {
       self.lastAnimationTime = now;
       return;
     }
@@ -863,15 +890,14 @@ typedef struct {
     self.lastAnimationTime = now;
   } else {
     self.animationBlocking = NO;
-    [self scheduleBonusCaptureAfterDelay:kRJBonusAnimationDelaySeconds
-                                     now:now];
+    [self scheduleBonusCaptureAfterDelay:kRJBonusAnimationDelaySeconds now:now];
   }
 }
 
 #pragma mark - Bonus Capture
 
 - (void)scheduleBonusCaptureAfterDelay:(NSTimeInterval)delay
-                                    now:(NSTimeInterval)now {
+                                   now:(NSTimeInterval)now {
   if (self.pendingKeyframes < kRJMaxPendingKeyframes) {
     self.pendingKeyframes += 1;
   }
@@ -886,9 +912,9 @@ typedef struct {
 - (void)considerBlockerSince:(NSTimeInterval)timestamp
                quietInterval:(NSTimeInterval)quietInterval
                          now:(NSTimeInterval)now
-                     reason:(RJCaptureHeuristicsReason)reason
-               earliestTime:(NSTimeInterval *)earliestTime
-               chosenReason:(RJCaptureHeuristicsReason *)chosenReason {
+                      reason:(RJCaptureHeuristicsReason)reason
+                earliestTime:(NSTimeInterval *)earliestTime
+                chosenReason:(RJCaptureHeuristicsReason *)chosenReason {
   if (timestamp <= 0) {
     return;
   }

package/ios/Capture/RJVideoEncoder.m

@@ -520,16 +520,7 @@
 }
 
 - (void)cleanup {
-  // Only cancel the current in-progress segment, don't delete the entire temp
-  // directory. Completed segments may still be uploading and must not be
-  // deleted here. The RJSegmentUploader handles file cleanup after successful
-  // upload.
   [self cancelSegment];
-
-  // NOTE: Do NOT delete rj_segments directory here!
-  // Other segments may be in the middle of uploading.
-  // Old orphaned segments are cleaned up by
-  // RJSegmentUploader.cleanupOrphanedSegments()
 }
 
 #pragma mark - Private Methods
@@ -561,14 +552,9 @@
   size_t width = (size_t)self.currentFrameSize.width;
   size_t height = (size_t)self.currentFrameSize.height;
 
-  // CRITICAL FIX: Validate incoming image dimensions match expected size
-  // During keyboard/rotation transitions, image size may temporarily differ
-  // from currentFrameSize, causing CGBitmapContextCreate bytesPerRow mismatch
   size_t imageWidth = CGImageGetWidth(cgImage);
   size_t imageHeight = CGImageGetHeight(cgImage);
 
-  // Allow small variance (1-2 pixels) due to rounding, but reject major
-  // mismatches
   if (labs((long)imageWidth - (long)width) > 2 ||
       labs((long)imageHeight - (long)height) > 2) {
     RJLogDebug(@"Video encoder: Skipping frame - size mismatch (got %zux%zu, "
@@ -639,9 +625,6 @@
     colorSpace = CGColorSpaceCreateDeviceRGB();
   }
 
-  // CRITICAL: Validate bytesPerRow is sufficient for the target width
-  // Error "CGBitmapContextCreate: invalid data bytes/row" occurs when
-  // bytesPerRow < width * 4 (4 bytes per pixel for BGRA)
   size_t requiredBytesPerRow = width * 4;
   if (bytesPerRow < requiredBytesPerRow) {
     CVPixelBufferUnlockBaseAddress(pixelBuffer, 0);
@@ -663,7 +646,6 @@
     return NULL;
   }
 
-  // Use fastest interpolation for pixel buffer drawing
   CGContextSetInterpolationQuality(context, kCGInterpolationNone);
   CGContextDrawImage(context, CGRectMake(0, 0, width, height), cgImage);
   CGContextRelease(context);
@@ -681,14 +663,10 @@
 }
 
 - (void)prewarmPixelBufferPool {
-  // Pre-warm the VideoToolbox H.264 encoder by creating a minimal AVAssetWriter
-  // and encoding a single dummy frame. This eliminates the ~1.5s spike on first
-  // real frame encode by front-loading the hardware encoder initialization.
   dispatch_async(self.encodingQueue, ^{
     @autoreleasepool {
       NSTimeInterval startTime = CACurrentMediaTime();
 
-      // Use a small size for fast prewarm (H.264 requires even dimensions)
       CGSize warmupSize = CGSizeMake(100, 100);
 
       // Create temp file for dummy segment
@@ -808,15 +786,12 @@ static dispatch_once_t sPrewarmOnceToken;
       return;
     sEncoderPrewarmed = YES;
 
-    // Run prewarm on a low-priority background queue
     dispatch_async(dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
       @autoreleasepool {
         NSTimeInterval startTime = CACurrentMediaTime();
 
-        // Use a small size for fast prewarm (H.264 requires even dimensions)
         CGSize warmupSize = CGSizeMake(100, 100);
 
-        // Create temp file for dummy segment
         NSURL *tempDir = [NSURL fileURLWithPath:NSTemporaryDirectory()];
         NSURL *warmupURL =
             [tempDir URLByAppendingPathComponent:@"rj_encoder_prewarm.mp4"];
@@ -873,7 +848,6 @@ static dispatch_once_t sPrewarmOnceToken;
 
         [warmupWriter startSessionAtSourceTime:kCMTimeZero];
 
-        // Create and encode a single dummy frame to trigger H.264 encoder init
         CVPixelBufferRef dummyBuffer = NULL;
         NSDictionary *pixelBufferOpts = @{
           (id)kCVPixelBufferCGImageCompatibilityKey : @YES,