@szdziedzic/sim-on 0.1.0

package/vendor/helper/LiveKitWebRTC.framework/Versions/A/Headers/RTCAudioProcessingState.h

@@ -0,0 +1,137 @@
+/*
+ * Copyright 2026 LiveKit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef SDK_OBJC_API_PEERCONNECTION_RTCAUDIOPROCESSINGSTATE_H_
+#define SDK_OBJC_API_PEERCONNECTION_RTCAUDIOPROCESSINGSTATE_H_
+
+#import <Foundation/Foundation.h>
+
+#import <LiveKitWebRTC/RTCAudioTrack.h>
+#import <LiveKitWebRTC/RTCMacros.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** The implementation that is in effect for an audio processing component.
+ *
+ *  Values must match webrtc::AudioProcessingImplementation.
+ */
+typedef NS_ENUM(NSInteger, RTC_OBJC_TYPE(RTCAudioProcessingImplementation)) {
+  RTC_OBJC_TYPE(RTCAudioProcessingImplementationUnknown) = 0,
+  RTC_OBJC_TYPE(RTCAudioProcessingImplementationDisabled) = 1,
+  RTC_OBJC_TYPE(RTCAudioProcessingImplementationSoftware) = 2,
+  RTC_OBJC_TYPE(RTCAudioProcessingImplementationPlatform) = 3,
+  RTC_OBJC_TYPE(RTCAudioProcessingImplementationSoftwareAndPlatform) = 4,
+};
+
+/** Diagnostic state of one audio processing component (echo cancellation,
+ *  noise suppression, auto gain control or high-pass filter), observed at
+ *  three stages of one pipeline: requested (caller intent) -> resolved (the
+ *  engine's per-path decision) -> active (live truth), with `effective` as
+ *  the merged verdict.
+ *
+ *  Example: echo cancellation enabled with automatic mode on a device with
+ *  platform AEC reads requested={YES, automatic}, isSoftwareResolved=NO,
+ *  isPlatformResolved=YES, isPlatformActive=YES, effective=Platform. On a
+ *  device without platform AEC the same request reads isSoftwareResolved=YES,
+ *  isSoftwareActive=YES, effective=Software. isPlatformResolved=YES with
+ *  isPlatformActive=NO means the OS has not finished applying the request or
+ *  rejected it.
+ */
+RTC_OBJC_EXPORT
+@interface RTC_OBJC_TYPE (RTCAudioProcessingComponentState) : NSObject
+
+/** The caller's most recent request for this component, as passed to
+ *  -[RTCAudioTrack setAudioProcessingOptions:] - enabled flag plus
+ *  implementation mode. Nil when no audio processing options have ever been
+ *  applied, which distinguishes "nobody asked" from "asked for disabled".
+ *  The mode reads automatic when the request did not specify one.
+ */
+@property(nonatomic, readonly, nullable)
+    RTC_OBJC_TYPE(RTCAudioProcessingComponentOptions) *requested;
+
+/** Whether the resolver decided the WebRTC software (APM) implementation
+ *  should run for this component, after weighing the requested mode against
+ *  platform availability, coupling, and policy. Automatic mode resolves to
+ *  software exactly when the platform path is unavailable or disallowed.
+ *  NO also covers "the resolver has not run yet" - check `requested` to tell
+ *  the two apart.
+ */
+@property(nonatomic, readonly, getter=isSoftwareResolved) BOOL softwareResolved;
+
+/** Whether APM's live configuration currently has this component enabled.
+ *  Normally equals isSoftwareResolved once options are applied; differs while
+ *  an apply is in flight, if applying failed, or if something else has since
+ *  reconfigured the shared APM.
+ */
+@property(nonatomic, readonly, getter=isSoftwareActive) BOOL softwareActive;
+
+/** Whether this device/OS offers a built-in implementation of this component
+ *  at all (e.g. Apple Voice Processing I/O provides AEC and NS; no platform
+ *  implements the high-pass filter). Capability only - says nothing about
+ *  whether it is in use.
+ */
+@property(nonatomic, readonly, getter=isPlatformAvailable) BOOL platformAvailable;
+
+/** Whether the resolver decided the platform implementation should run, as
+ *  submitted to the OS. Unlike the software path, the OS owns the outcome:
+ *  it can decline, defer, or couple this with another component (Apple ties
+ *  AEC and NS through one Voice Processing switch).
+ */
+@property(nonatomic, readonly, getter=isPlatformResolved) BOOL platformResolved;
+
+/** Whether the device reports the platform implementation actually running
+ *  right now. Lags isPlatformResolved during engine transitions; stays NO if
+ *  the OS rejected the request or the input path is not configured.
+ */
+@property(nonatomic, readonly, getter=isPlatformActive) BOOL platformActive;
+
+/** The verdict: which implementation is in effect for this component right
+ *  now. Derived from the active states (active wins over resolved when they
+ *  disagree). Unknown when the pipeline state cannot be determined.
+ */
+@property(nonatomic, readonly) RTC_OBJC_TYPE(RTCAudioProcessingImplementation) effective;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+@end
+
+/** Diagnostic snapshot of the resolved audio processing state for the shared
+ *  audio processing module. The module is owned by the peer connection
+ *  factory and shared engine-wide, so this reflects factory-scoped state
+ *  rather than the state of a single track or peer connection.
+ *
+ *  Device-level platform processing detail - topology, raw per-effect
+ *  availability, Apple Voice Processing I/O state - is intentionally not
+ *  embedded here; read RTCAudioDeviceModule.platformAudioProcessingState
+ *  instead.
+ */
+RTC_OBJC_EXPORT
+@interface RTC_OBJC_TYPE (RTCAudioProcessingState) : NSObject
+
+@property(nonatomic, readonly) BOOL hasAudioProcessingModule;
+
+@property(nonatomic, readonly) RTC_OBJC_TYPE(RTCAudioProcessingComponentState) *echoCancellation;
+@property(nonatomic, readonly) RTC_OBJC_TYPE(RTCAudioProcessingComponentState) *noiseSuppression;
+@property(nonatomic, readonly) RTC_OBJC_TYPE(RTCAudioProcessingComponentState) *autoGainControl;
+@property(nonatomic, readonly) RTC_OBJC_TYPE(RTCAudioProcessingComponentState) *highPassFilter;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif  // SDK_OBJC_API_PEERCONNECTION_RTCAUDIOPROCESSINGSTATE_H_

package/vendor/helper/LiveKitWebRTC.framework/Versions/A/Headers/RTCAudioRenderer.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2023 LiveKit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+#import <AVFoundation/AVFoundation.h>
+#import <CoreMedia/CoreMedia.h>
+
+#if TARGET_OS_IPHONE
+#import <UIKit/UIKit.h>
+#endif
+
+#import <LiveKitWebRTC/RTCMacros.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+RTC_OBJC_EXPORT @protocol RTC_OBJC_TYPE(RTCAudioRenderer)<NSObject>
+
+- (void)renderPCMBuffer: (AVAudioPCMBuffer *)pcmBuffer NS_SWIFT_NAME(render(pcmBuffer:));
+
+@end
+
+NS_ASSUME_NONNULL_END

package/vendor/helper/LiveKitWebRTC.framework/Versions/A/Headers/RTCAudioSource.h

@@ -0,0 +1,32 @@
+/*
+ *  Copyright 2016 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import <LiveKitWebRTC/RTCMediaSource.h>
+#import <LiveKitWebRTC/RTCMacros.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+RTC_OBJC_EXPORT
+@interface RTC_OBJC_TYPE (RTCAudioSource) : RTC_OBJC_TYPE(RTCMediaSource)
+
+- (instancetype)init NS_UNAVAILABLE;
+
+// Sets the volume for the RTCMediaSource. `volume` is a gain value in the range
+// [0, 10].
+// Temporary fix to be able to modify volume of remote audio tracks.
+// TODO(kthelgason): Property stays here temporarily until a proper volume-api
+// is available on the surface exposed by webrtc.
+@property(nonatomic, assign) double volume;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/vendor/helper/LiveKitWebRTC.framework/Versions/A/Headers/RTCAudioTrack.h

@@ -0,0 +1,150 @@
+/*
+ *  Copyright 2015 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#import <LiveKitWebRTC/RTCMediaStreamTrack.h>
+#import <LiveKitWebRTC/RTCMacros.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol RTC_OBJC_TYPE (RTCAudioRenderer);
+@class RTC_OBJC_TYPE(RTCAudioSource);
+
+/** Selects the implementation for one enabled audio processing component.
+ *
+ * Disabled components do not use platform or software processing regardless of
+ * mode. Automatic uses platform processing when available and otherwise falls
+ * back to WebRTC software processing. Platform uses only platform processing, so
+ * unavailable or physically impossible platform requests are rejected. Software
+ * disables the matching platform effect and uses WebRTC software processing.
+ * Some ADMs expose coupled platform effects, such as Apple Voice Processing I/O
+ * for AEC and NS. High-pass filter has no platform implementation today.
+ *
+ * Values must match webrtc::AudioProcessingMode.
+ */
+typedef NS_ENUM(NSInteger, RTC_OBJC_TYPE(RTCAudioProcessingMode)) {
+  RTC_OBJC_TYPE(RTCAudioProcessingModeAutomatic) = 0,
+  RTC_OBJC_TYPE(RTCAudioProcessingModePlatform) = 1,
+  RTC_OBJC_TYPE(RTCAudioProcessingModeSoftware) = 2,
+};
+
+// Values must match webrtc::AudioProcessingOptionsResultCode.
+typedef NS_ENUM(NSInteger, RTC_OBJC_TYPE(RTCAudioProcessingOptionsResultCode)) {
+  /** Options were applied immediately by the component handling the request. */
+  RTC_OBJC_TYPE(RTCAudioProcessingOptionsResultCodeApplied) = 0,
+  /** Options were accepted and stored. Active senders reapply them separately. */
+  RTC_OBJC_TYPE(RTCAudioProcessingOptionsResultCodeStored) = 1,
+  /** The track is remote; processing options only apply to local tracks. */
+  RTC_OBJC_TYPE(RTCAudioProcessingOptionsResultCodeRejectedRemoteTrack) = 2,
+  /** The per-component modes conflict, e.g. requesting platform for one of a
+   *  coupled AEC/NS pair while disabling or forcing software on the other. */
+  RTC_OBJC_TYPE(RTCAudioProcessingOptionsResultCodeRejectedInvalidCombination) = 3,
+  /** Platform mode was requested for a component this device cannot provide,
+   *  or platform voice processing is disallowed by policy. */
+  RTC_OBJC_TYPE(RTCAudioProcessingOptionsResultCodeRejectedPlatformUnavailable) = 4,
+  /** The request was valid but could not be applied. */
+  RTC_OBJC_TYPE(RTCAudioProcessingOptionsResultCodeApplyFailed) = 5,
+};
+
+RTC_OBJC_EXPORT
+@interface RTC_OBJC_TYPE (RTCAudioProcessingOptionsResult) : NSObject
+
+@property(nonatomic, readonly, getter=isSuccess) BOOL success;
+@property(nonatomic, readonly) RTC_OBJC_TYPE(RTCAudioProcessingOptionsResultCode) code;
+@property(nonatomic, readonly) NSString *message;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+@end
+
+/** Enabled flag and implementation mode for one audio processing component. */
+RTC_OBJC_EXPORT
+@interface RTC_OBJC_TYPE (RTCAudioProcessingComponentOptions) : NSObject
+
+@property(nonatomic, readonly, getter=isEnabled) BOOL enabled;
+@property(nonatomic, readonly) RTC_OBJC_TYPE(RTCAudioProcessingMode) mode;
+
+- (instancetype)initWithEnabled:(BOOL)enabled;
+
+- (instancetype)initWithEnabled:(BOOL)enabled
+                           mode:(RTC_OBJC_TYPE(RTCAudioProcessingMode))mode NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+@end
+
+RTC_OBJC_EXPORT
+@interface RTC_OBJC_TYPE (RTCAudioProcessingOptions) : NSObject
+
+@property(nonatomic, readonly) BOOL echoCancellation;
+@property(nonatomic, readonly) BOOL noiseSuppression;
+@property(nonatomic, readonly) BOOL autoGainControl;
+@property(nonatomic, readonly) BOOL highPassFilter;
+@property(nonatomic, readonly) RTC_OBJC_TYPE(RTCAudioProcessingMode) echoCancellationMode;
+@property(nonatomic, readonly) RTC_OBJC_TYPE(RTCAudioProcessingMode) noiseSuppressionMode;
+@property(nonatomic, readonly) RTC_OBJC_TYPE(RTCAudioProcessingMode) autoGainControlMode;
+@property(nonatomic, readonly) RTC_OBJC_TYPE(RTCAudioProcessingMode) highPassFilterMode;
+
+- (instancetype)initWithEchoCancellation:(BOOL)echoCancellation
+                        noiseSuppression:(BOOL)noiseSuppression
+                         autoGainControl:(BOOL)autoGainControl
+                          highPassFilter:(BOOL)highPassFilter;
+
+- (instancetype)
+    initWithEchoCancellationOptions:(RTC_OBJC_TYPE(RTCAudioProcessingComponentOptions) *)echoCancellationOptions
+            noiseSuppressionOptions:(RTC_OBJC_TYPE(RTCAudioProcessingComponentOptions) *)noiseSuppressionOptions
+             autoGainControlOptions:(RTC_OBJC_TYPE(RTCAudioProcessingComponentOptions) *)autoGainControlOptions
+              highPassFilterOptions:(RTC_OBJC_TYPE(RTCAudioProcessingComponentOptions) *)highPassFilterOptions
+    NS_DESIGNATED_INITIALIZER;
+
++ (instancetype)communicationOptions;
++ (instancetype)rawOptions;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+@end
+
+RTC_OBJC_EXPORT
+@interface RTC_OBJC_TYPE (RTCAudioTrack) : RTC_OBJC_TYPE(RTCMediaStreamTrack)
+
+- (instancetype)init NS_UNAVAILABLE;
+
+/** The audio source for this audio track. */
+@property(nonatomic, readonly) RTC_OBJC_TYPE(RTCAudioSource) * source;
+
+- (void)addRenderer:(id<RTC_OBJC_TYPE(RTCAudioRenderer)>)renderer;
+
+- (void)removeRenderer:(id<RTC_OBJC_TYPE(RTCAudioRenderer)>)renderer;
+
+- (void)removeAllRenderers;
+
+/** Updates local source audio processing options without restarting capture.
+ *
+ * Returns Stored when the request was accepted and stored on the local source.
+ * This validates static platform constraints, such as Apple AEC/NS coupling and
+ * simulator support. When the factory exposes its audio device module, this also
+ * validates app-level platform policy such as
+ * RTCAudioDeviceModule.platformVoiceProcessingAllowed. Factory paths without an
+ * exposed ADM still validate statically, and runtime platform policy can make a
+ * stored platform request resolve disabled when the voice engine applies it.
+ *
+ * If the track is already being sent, active senders observe the track update
+ * and reapply the updated options through the voice engine. Rejections mean
+ * the options were not stored. Use the peer connection factory's
+ * audioProcessingState to inspect the effective software/platform state after
+ * application. The audio processing module configuration is shared by the
+ * voice engine/channel, so conflicting updates from multiple local tracks are
+ * not isolated per track.
+ */
+- (RTC_OBJC_TYPE(RTCAudioProcessingOptionsResult) *)setAudioProcessingOptions:
+    (RTC_OBJC_TYPE(RTCAudioProcessingOptions) *)options;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/vendor/helper/LiveKitWebRTC.framework/Versions/A/Headers/RTCCVPixelBuffer.h

@@ -0,0 +1,52 @@
+/*
+ *  Copyright 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#import <AVFoundation/AVFoundation.h>
+
+#import <LiveKitWebRTC/RTCVideoFrameBuffer.h>
+#import <LiveKitWebRTC/RTCMacros.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** RTCVideoFrameBuffer containing a CVPixelBufferRef */
+RTC_OBJC_EXPORT
+@interface RTC_OBJC_TYPE (RTCCVPixelBuffer) : NSObject <RTC_OBJC_TYPE(RTCVideoFrameBuffer)>
+
+@property(nonatomic, readonly) CVPixelBufferRef pixelBuffer;
+@property(nonatomic, readonly) int cropX;
+@property(nonatomic, readonly) int cropY;
+@property(nonatomic, readonly) int cropWidth;
+@property(nonatomic, readonly) int cropHeight;
+
++ (NSSet<NSNumber *> *)supportedPixelFormats;
+
+- (instancetype)initWithPixelBuffer:(CVPixelBufferRef)pixelBuffer;
+- (instancetype)initWithPixelBuffer:(CVPixelBufferRef)pixelBuffer
+                       adaptedWidth:(int)adaptedWidth
+                      adaptedHeight:(int)adaptedHeight
+                          cropWidth:(int)cropWidth
+                         cropHeight:(int)cropHeight
+                              cropX:(int)cropX
+                              cropY:(int)cropY;
+
+- (BOOL)requiresCropping;
+- (BOOL)requiresScalingToWidth:(int)width height:(int)height;
+- (int)bufferSizeForCroppingAndScalingToWidth:(int)width height:(int)height;
+
+/** The minimum size of the `tmpBuffer` must be the number of bytes returned
+ * from the bufferSizeForCroppingAndScalingToWidth:height: method. If that size
+ * is 0, the `tmpBuffer` may be nil.
+ */
+- (BOOL)cropAndScaleTo:(CVPixelBufferRef)outputPixelBuffer
+        withTempBuffer:(nullable uint8_t *)tmpBuffer;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/vendor/helper/LiveKitWebRTC.framework/Versions/A/Headers/RTCCallbackLogger.h

@@ -0,0 +1,41 @@
+/*
+ *  Copyright 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import <LiveKitWebRTC/RTCLogging.h>
+#import <LiveKitWebRTC/RTCMacros.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef void (^RTCCallbackLoggerMessageHandler)(NSString *message);
+typedef void (^RTCCallbackLoggerMessageAndSeverityHandler)(
+    NSString *message, RTC_OBJC_TYPE(RTCLoggingSeverity) severity);
+
+// This class intercepts WebRTC logs and forwards them to a registered block.
+// This class is not threadsafe.
+RTC_OBJC_EXPORT
+@interface RTC_OBJC_TYPE (RTCCallbackLogger) : NSObject
+
+// The severity level to capture. The default is kRTCLoggingSeverityInfo.
+@property(nonatomic, assign) RTC_OBJC_TYPE(RTCLoggingSeverity) severity;
+
+// The callback handler will be called on the same thread that does the
+// logging, so if the logging callback can be slow it may be a good idea
+// to implement dispatching to some other queue.
+- (void)start:(nullable RTCCallbackLoggerMessageHandler)handler;
+- (void)startWithMessageAndSeverityHandler:
+    (nullable RTCCallbackLoggerMessageAndSeverityHandler)handler;
+
+- (void)stop;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/vendor/helper/LiveKitWebRTC.framework/Versions/A/Headers/RTCCameraVideoCapturer.h

@@ -0,0 +1,71 @@
+/*
+ *  Copyright 2017 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+#import <LiveKitWebRTC/RTCVideoCapturer.h>
+#import <LiveKitWebRTC/RTCMacros.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// Camera capture that implements RTCVideoCapturer. Delivers frames to a
+// RTCVideoCapturerDelegate (usually RTCVideoSource).
+RTC_OBJC_EXPORT
+@interface RTC_OBJC_TYPE (RTCCameraVideoCapturer) : RTC_OBJC_TYPE(RTCVideoCapturer)
+
+// Capture session that is used for capturing. Valid from initialization to dealloc.
+@property(readonly, nonatomic) AVCaptureSession *captureSession;
+
+// Returns list of available capture devices that support video capture.
++ (NSArray<AVCaptureDevice *> *)captureDevices;
+
+// Returns list of formats that are supported by this class for this device.
++ (NSArray<AVCaptureDeviceFormat *> *)supportedFormatsForDevice:
+    (AVCaptureDevice *)device;
+
+#if !TARGET_OS_VISION
++ (CGFloat)defaultZoomFactorForDeviceType:(AVCaptureDeviceType)deviceType;
+#endif
+
+- (instancetype)initWithDelegate:
+    (nullable __weak id<RTC_OBJC_TYPE(RTCVideoCapturerDelegate)>)delegate;
+
+- (instancetype)initWithDelegate:
+                    (nullable __weak id<RTC_OBJC_TYPE(RTCVideoCapturerDelegate)>)delegate
+                  captureSession:(AVCaptureSession *)captureSession;
+
+// Returns the most efficient supported output pixel format for this capturer.
+- (FourCharCode)preferredOutputPixelFormat;
+
+// Starts the capture session asynchronously and notifies callback on
+// completion. The device will capture video in the format given in the `format`
+// parameter. If the pixel format in `format` is supported by the WebRTC
+// pipeline, the same pixel format will be used for the output. Otherwise, the
+// format returned by `preferredOutputPixelFormat` will be used.
+- (void)startCaptureWithDevice:(AVCaptureDevice *)device
+                        format:(AVCaptureDeviceFormat *)format
+                           fps:(NSInteger)fps
+             completionHandler:
+                 (nullable void (^)(NSError *_Nullable))completionHandler;
+// Stops the capture session asynchronously and notifies callback on completion.
+- (void)stopCaptureWithCompletionHandler:
+    (nullable void (^)(void))completionHandler;
+
+// Starts the capture session asynchronously.
+- (void)startCaptureWithDevice:(AVCaptureDevice *)device
+                        format:(AVCaptureDeviceFormat *)format
+                           fps:(NSInteger)fps;
+// Stops the capture session asynchronously.
+- (void)stopCapture;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/vendor/helper/LiveKitWebRTC.framework/Versions/A/Headers/RTCCertificate.h

@@ -0,0 +1,47 @@
+/*
+ *  Copyright 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import <LiveKitWebRTC/RTCMacros.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+RTC_OBJC_EXPORT
+@interface RTC_OBJC_TYPE (RTCCertificate) : NSObject <NSCopying>
+
+/** Private key in PEM. */
+@property(nonatomic, readonly, copy) NSString *private_key;
+
+/** Public key in an x509 cert encoded in PEM. */
+@property(nonatomic, readonly, copy) NSString *certificate;
+
+/**
+ * Initialize an RTCCertificate with PEM strings for private_key and
+ * certificate.
+ */
+- (instancetype)initWithPrivateKey:(NSString *)private_key
+                       certificate:(NSString *)certificate
+    NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+/** Generate a new certificate for 're' use.
+ *
+ *  Optional dictionary of parameters. Defaults to KeyType ECDSA if none are
+ *  provided.
+ *  - name: "ECDSA" or "RSASSA-PKCS1-v1_5"
+ */
++ (nullable RTC_OBJC_TYPE(RTCCertificate) *)generateCertificateWithParams:
+    (NSDictionary *)params;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/vendor/helper/LiveKitWebRTC.framework/Versions/A/Headers/RTCCodecSpecificInfo.h

@@ -0,0 +1,24 @@
+/*
+ *  Copyright 2017 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import <LiveKitWebRTC/RTCMacros.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/** Implement this protocol to pass codec specific info from the encoder.
+ *  Corresponds to webrtc::CodecSpecificInfo.
+ */
+RTC_OBJC_EXPORT
+@protocol RTC_OBJC_TYPE
+(RTCCodecSpecificInfo)<NSObject> @end
+
+NS_ASSUME_NONNULL_END

package/vendor/helper/LiveKitWebRTC.framework/Versions/A/Headers/RTCCodecSpecificInfoH264.h

@@ -0,0 +1,27 @@
+/*
+ *  Copyright 2017 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import <LiveKitWebRTC/RTCCodecSpecificInfo.h>
+#import <LiveKitWebRTC/RTCMacros.h>
+
+/** Class for H264 specific config. */
+typedef NS_ENUM(NSUInteger, RTC_OBJC_TYPE(RTCH264PacketizationMode)) {
+  RTC_OBJC_TYPE(RTCH264PacketizationModeNonInterleaved) = 0,  // Mode 1 - STAP-A, FU-A is allowed
+  RTC_OBJC_TYPE(RTCH264PacketizationModeSingleNalUnit)        // Mode 0 - only single NALU allowed
+};
+
+RTC_OBJC_EXPORT
+@interface RTC_OBJC_TYPE (RTCCodecSpecificInfoH264) : NSObject <RTC_OBJC_TYPE(RTCCodecSpecificInfo)>
+
+@property(nonatomic, assign) RTC_OBJC_TYPE(RTCH264PacketizationMode) packetizationMode;
+
+@end