@sbhjt-gr/react-native-webrtc 124.0.0

package/android/src/main/java/com/oney/WebRTCModule/webrtcutils/H264AndSoftwareVideoEncoderFactory.java

@@ -0,0 +1,73 @@
+package com.oney.WebRTCModule.webrtcutils;
+
+import androidx.annotation.Nullable;
+
+import org.webrtc.EglBase;
+import org.webrtc.HardwareVideoEncoderFactory;
+import org.webrtc.VideoCodecInfo;
+import org.webrtc.VideoEncoder;
+import org.webrtc.VideoEncoderFactory;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * This is a custom video encoder factory for WebRTC which behaves similarly
+ * to the default one in iOS. It supports the following codecs:
+ *
+ * - In hardware: H.264 (high, baseline)
+ * - In software: VP8, VP9, AV1
+ */
+public class H264AndSoftwareVideoEncoderFactory implements VideoEncoderFactory {
+    private final VideoEncoderFactory hardwareVideoEncoderFactory;
+    private final VideoEncoderFactory softwareVideoEncoderFactory;
+
+    public H264AndSoftwareVideoEncoderFactory(@Nullable EglBase.Context eglContext) {
+        this.hardwareVideoEncoderFactory = new HardwareVideoEncoderFactory(eglContext, false, true);
+        this.softwareVideoEncoderFactory = new SoftwareVideoEncoderFactoryProxy();
+    }
+
+    @Nullable
+    @Override
+    public VideoEncoder createEncoder(VideoCodecInfo codecInfo) {
+        if (codecInfo.name.equalsIgnoreCase("H264")) {
+            return this.hardwareVideoEncoderFactory.createEncoder(codecInfo);
+        }
+
+        return this.softwareVideoEncoderFactory.createEncoder(codecInfo);
+    }
+
+    @Override
+    public VideoCodecInfo[] getSupportedCodecs() {
+        List<VideoCodecInfo> codecs = new ArrayList<>();
+
+        VideoCodecInfo h264Baseline = null;
+        VideoCodecInfo h264High = null;
+
+        VideoCodecInfo[] hwCodecs = this.hardwareVideoEncoderFactory.getSupportedCodecs();
+        for (VideoCodecInfo hwCodec : hwCodecs) {
+            if (hwCodec.name.equalsIgnoreCase("H264")) {
+                String profileLevel = hwCodec.params.get(VideoCodecInfo.H264_FMTP_PROFILE_LEVEL_ID);
+                if (profileLevel == null) {
+                    continue;
+                }
+                if (profileLevel.equalsIgnoreCase(VideoCodecInfo.H264_CONSTRAINED_HIGH_3_1)) {
+                    h264High = hwCodec;
+                } else if (profileLevel.equalsIgnoreCase(VideoCodecInfo.H264_CONSTRAINED_BASELINE_3_1)) {
+                    h264Baseline = hwCodec;
+                }
+            }
+        }
+
+        if (h264High != null) {
+            codecs.add(h264High);
+        }
+        if (h264Baseline != null) {
+            codecs.add(h264Baseline);
+        }
+        codecs.addAll(Arrays.asList(this.softwareVideoEncoderFactory.getSupportedCodecs()));
+
+        return codecs.toArray(new VideoCodecInfo[codecs.size()]);
+    }
+}

package/android/src/main/java/com/oney/WebRTCModule/webrtcutils/SoftwareVideoDecoderFactoryProxy.java

@@ -0,0 +1,36 @@
+package com.oney.WebRTCModule.webrtcutils;
+
+import androidx.annotation.Nullable;
+
+import org.webrtc.SoftwareVideoDecoderFactory;
+import org.webrtc.VideoCodecInfo;
+import org.webrtc.VideoDecoder;
+import org.webrtc.VideoDecoderFactory;
+
+/**
+ * Helper proxy factory for the software codecs. Starting with M111 SoftwareVideoDecoderFactory
+ * cannot be instantiated before the PeerConnectionFactory has been initialized because it
+ * relies on JNI. This proxy factory lazy initializes it.
+ */
+public class SoftwareVideoDecoderFactoryProxy implements VideoDecoderFactory {
+    private VideoDecoderFactory factory;
+
+    private synchronized VideoDecoderFactory getFactory() {
+        if (factory == null) {
+            factory = new SoftwareVideoDecoderFactory();
+        }
+
+        return factory;
+    }
+
+    @Nullable
+    @Override
+    public VideoDecoder createDecoder(VideoCodecInfo videoCodecInfo) {
+        return getFactory().createDecoder(videoCodecInfo);
+    }
+
+    @Override
+    public VideoCodecInfo[] getSupportedCodecs() {
+        return getFactory().getSupportedCodecs();
+    }
+}

package/android/src/main/java/com/oney/WebRTCModule/webrtcutils/SoftwareVideoEncoderFactoryProxy.java

@@ -0,0 +1,36 @@
+package com.oney.WebRTCModule.webrtcutils;
+
+import androidx.annotation.Nullable;
+
+import org.webrtc.SoftwareVideoEncoderFactory;
+import org.webrtc.VideoCodecInfo;
+import org.webrtc.VideoEncoder;
+import org.webrtc.VideoEncoderFactory;
+
+/**
+ * Helper proxy factory for the software codecs. Starting with M111 SoftwareVideoEncoderFactory
+ * cannot be instantiated before the PeerConnectionFactory has been initialized because it
+ * relies on JNI. This proxy factory lazy initializes it.
+ */
+public class SoftwareVideoEncoderFactoryProxy implements VideoEncoderFactory {
+    private VideoEncoderFactory factory;
+
+    private synchronized VideoEncoderFactory getFactory() {
+        if (factory == null) {
+            factory = new SoftwareVideoEncoderFactory();
+        }
+
+        return factory;
+    }
+
+    @Nullable
+    @Override
+    public VideoEncoder createEncoder(VideoCodecInfo videoCodecInfo) {
+        return getFactory().createEncoder(videoCodecInfo);
+    }
+
+    @Override
+    public VideoCodecInfo[] getSupportedCodecs() {
+        return getFactory().getSupportedCodecs();
+    }
+}

package/android/src/main/java/org/webrtc/Camera1Helper.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2023-2024 LiveKit, Inc.
+ *
+ * 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.
+ */
+
+package org.webrtc;
+
+import androidx.annotation.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A helper to access package-protected methods used in [Camera2Session]
+ * <p>
+ * Note: cameraId as used in the Camera1XXX classes refers to the index within the list of cameras.
+ *
+ * @suppress
+ */
+
+public class Camera1Helper {
+    public static int getCameraId(String deviceName) {
+        return Camera1Enumerator.getCameraIndex(deviceName);
+    }
+
+    @Nullable
+    public static List<CameraEnumerationAndroid.CaptureFormat> getSupportedFormats(int cameraId) {
+        return Camera1Enumerator.getSupportedFormats(cameraId);
+    }
+
+    public static Size findClosestCaptureFormat(int cameraId, int width, int height) {
+        List<CameraEnumerationAndroid.CaptureFormat> formats = getSupportedFormats(cameraId);
+
+        List<Size> sizes = new ArrayList<>();
+        if (formats != null) {
+            for (CameraEnumerationAndroid.CaptureFormat format : formats) {
+                sizes.add(new Size(format.width, format.height));
+            }
+        }
+
+        return CameraEnumerationAndroid.getClosestSupportedSize(sizes, width, height);
+    }
+}

package/android/src/main/java/org/webrtc/Camera2Helper.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2023-2024 LiveKit, Inc.
+ *
+ * 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.
+ */
+
+package org.webrtc;
+
+import android.hardware.camera2.CameraManager;
+
+import androidx.annotation.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A helper to access package-protected methods used in [Camera2Session]
+ * <p>
+ * Note: cameraId as used in the Camera2XXX classes refers to the id returned
+ * by [CameraManager.getCameraIdList].
+ */
+public class Camera2Helper {
+    @Nullable
+    public static List<CameraEnumerationAndroid.CaptureFormat> getSupportedFormats(
+            CameraManager cameraManager, @Nullable String cameraId) {
+        return Camera2Enumerator.getSupportedFormats(cameraManager, cameraId);
+    }
+
+    public static Size findClosestCaptureFormat(
+            CameraManager cameraManager, @Nullable String cameraId, int width, int height) {
+        List<CameraEnumerationAndroid.CaptureFormat> formats = getSupportedFormats(cameraManager, cameraId);
+
+        List<Size> sizes = new ArrayList<>();
+        if (formats != null) {
+            for (CameraEnumerationAndroid.CaptureFormat format : formats) {
+                sizes.add(new Size(format.width, format.height));
+            }
+        }
+
+        return CameraEnumerationAndroid.getClosestSupportedSize(sizes, width, height);
+    }
+}

package/android/src/main/res/values/strings.xml

@@ -0,0 +1,5 @@
+<resources>
+    <string name="media_projection_notification_title">Screen sharing</string>
+    <string name="media_projection_notification_text">You are currently sharing your screen.</string>
+    <string name="ongoing_notification_channel_name">Screen Sharing Notifications</string>
+</resources>

package/android/src/main/res/values/styles.xml

@@ -0,0 +1,8 @@
+<resources>
+
+    <!-- Base application theme. -->
+    <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
+        <!-- Customize your theme here. -->
+    </style>
+
+</resources>

package/ios/RCTWebRTC/CaptureController.h

@@ -0,0 +1,18 @@
+#import <Foundation/Foundation.h>
+#import "CapturerEventsDelegate.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface CaptureController : NSObject
+
+@property(nonatomic, strong) id<CapturerEventsDelegate> eventsDelegate;
+@property(nonatomic, copy, nullable) NSString *deviceId;
+
+- (void)startCapture;
+- (void)stopCapture;
+- (NSDictionary *)getSettings;
+- (void)applyConstraints:(NSDictionary *)constraints error:(NSError **)outError;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RCTWebRTC/CaptureController.m

@@ -0,0 +1,29 @@
+#if !TARGET_OS_TV
+
+#import "CaptureController.h"
+
+@implementation CaptureController
+
+- (void)startCapture {
+    // subclasses needs to override
+}
+
+- (void)stopCapture {
+    // subclasses needs to override
+}
+
+- (NSDictionary *)getSettings {
+    // subclasses needs to override
+    return @{@"deviceId" : self.deviceId};
+}
+
+- (void)applyConstraints:(NSDictionary *)constraints error:(NSError **)outError {
+    *outError =
+        [NSError errorWithDomain:@"react-native-webrtc"
+                            code:0
+                        userInfo:@{NSLocalizedDescriptionKey : @"This video track does not support applyConstraints."}];
+}
+
+@end
+
+#endif

package/ios/RCTWebRTC/CapturerEventsDelegate.h

@@ -0,0 +1,12 @@
+#import <WebRTC/RTCVideoCapturer.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol CapturerEventsDelegate
+
+/** Called when the capturer is ended and in an irrecoverable state. */
+- (void)capturerDidEnd:(RTCVideoCapturer *)capturer;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RCTWebRTC/DataChannelWrapper.h

@@ -0,0 +1,27 @@
+#import <Foundation/Foundation.h>
+#import <WebRTC/RTCDataChannel.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class DataChannelWrapper;
+
+@protocol DataChannelWrapperDelegate<NSObject>
+
+- (void)dataChannelDidChangeState:(DataChannelWrapper *)dataChannelWrapper;
+- (void)dataChannel:(DataChannelWrapper *)dataChannelWrapper didReceiveMessageWithBuffer:(RTCDataBuffer *)buffer;
+- (void)dataChannel:(DataChannelWrapper *)dataChannelWrapper didChangeBufferedAmount:(uint64_t)amount;
+
+@end
+
+@interface DataChannelWrapper : NSObject
+
+- (instancetype)initWithChannel:(RTCDataChannel *)channel reactTag:(NSString *)tag;
+
+@property(nonatomic, nonnull, copy) NSNumber *pcId;
+@property(nonatomic, nonnull, readonly) RTCDataChannel *channel;
+@property(nonatomic, nonnull, readonly) NSString *reactTag;
+@property(nonatomic, nullable, weak) id<DataChannelWrapperDelegate> delegate;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RCTWebRTC/DataChannelWrapper.m

@@ -0,0 +1,42 @@
+
+#import "DataChannelWrapper.h"
+
+#import <WebRTC/RTCDataChannel.h>
+
+@interface DataChannelWrapper ()<RTCDataChannelDelegate>
+@end
+
+@implementation DataChannelWrapper
+
+- (instancetype)initWithChannel:(RTCDataChannel *)channel reactTag:(NSString *)tag {
+    self = [super init];
+    if (self) {
+        _channel = channel;
+        _reactTag = tag;
+
+        // Set ourselves as the deletagate.
+        _channel.delegate = self;
+    }
+
+    return self;
+}
+
+- (void)dataChannel:(nonnull RTCDataChannel *)dataChannel didReceiveMessageWithBuffer:(nonnull RTCDataBuffer *)buffer {
+    if (_delegate) {
+        [_delegate dataChannel:self didReceiveMessageWithBuffer:buffer];
+    }
+}
+
+- (void)dataChannelDidChangeState:(nonnull RTCDataChannel *)dataChannel {
+    if (_delegate) {
+        [_delegate dataChannelDidChangeState:self];
+    }
+}
+
+- (void)dataChannel:(nonnull RTCDataChannel *)dataChannel didChangeBufferedAmount:(uint64_t)amount {
+    if (_delegate) {
+        [_delegate dataChannel:self didChangeBufferedAmount:amount];
+    }
+}
+
+@end

package/ios/RCTWebRTC/I420Converter.h

@@ -0,0 +1,22 @@
+//
+//  I420Converter.h
+//  VideoSampleCaptureRender
+//
+//  Adapted from:
+//  https://github.com/twilio/video-ios-affectiva/blob/ed2e864324c40ad25e5a06cc2b05298b03caed09/EmoCall/I420Converter.h
+//  Created by Boisy Pitre on 5/21/16.
+//  Copyright © 2016 Twilio. All rights reserved.
+//
+
+#import <Accelerate/Accelerate.h>
+#import <UIKit/UIKit.h>
+#import <WebRTC/WebRTC.h>
+
+@interface I420Converter : NSObject
+
+- (vImage_Error)prepareForAccelerateConversion;
+- (void)unprepareForAccelerateConversion;
+- (CVPixelBufferRef)convertI420ToPixelBuffer:(RTCI420Buffer *)buffer;
+- (void)createPixelBufferPoolWithWidth:(size_t)width height:(size_t)height;
+
+@end

package/ios/RCTWebRTC/I420Converter.m

@@ -0,0 +1,164 @@
+//
+//  I420Converter.m
+//  VideoSampleCaptureRender
+//
+//  Adapted from:
+//  https://github.com/twilio/video-ios-affectiva/blob/ed2e864324c40ad25e5a06cc2b05298b03caed09/EmoCall/I420Converter.m
+//  Created by Boisy Pitre on 5/21/16.
+//  Copyright © 2016 Twilio. All rights reserved.
+//
+
+#import "I420Converter.h"
+
+@interface I420Converter ()
+
+@property(nonatomic, assign) vImage_YpCbCrToARGB *conversionInfo;
+@property(nonatomic, assign) CVPixelBufferPoolRef pixelBufferPool;
+@property(nonatomic, assign) size_t poolWidth;
+@property(nonatomic, assign) size_t poolHeight;
+@end
+
+@implementation I420Converter
+
+- (vImage_Error)prepareForAccelerateConversion {
+    // Setup the YpCbCr to ARGB conversion.
+    if (_conversionInfo != NULL) {
+        return kvImageNoError;
+    }
+
+    // I420 uses limited range.
+    vImage_YpCbCrPixelRange pixelRange = {16, 128, 235, 240, 255, 0, 255, 0};
+    vImage_YpCbCrToARGB *outInfo = malloc(sizeof(vImage_YpCbCrToARGB));
+    vImageYpCbCrType inType = kvImage420Yp8_Cb8_Cr8;
+    vImageARGBType outType = kvImageARGB8888;
+
+    vImage_Error error = vImageConvert_YpCbCrToARGB_GenerateConversion(kvImage_YpCbCrToARGBMatrix_ITU_R_601_4,
+                                                                       &pixelRange,
+                                                                       outInfo,
+                                                                       inType,
+                                                                       outType,
+                                                                       kvImagePrintDiagnosticsToConsole);
+
+    _conversionInfo = outInfo;
+
+    return error;
+}
+
+- (void)unprepareForAccelerateConversion {
+    if (_conversionInfo != NULL) {
+        free(_conversionInfo);
+        _conversionInfo = NULL;
+    }
+    if (_pixelBufferPool != NULL) {
+        CVPixelBufferPoolRelease(_pixelBufferPool);
+        _pixelBufferPool = NULL;
+    }
+}
+
+- (void)createPixelBufferPoolWithWidth:(size_t)width height:(size_t)height {
+    if (_pixelBufferPool != NULL) {
+        CVPixelBufferPoolRelease(_pixelBufferPool);
+    }
+
+    _poolWidth = width;
+    _poolHeight = height;
+    NSDictionary *pixelBufferAttributes = @{
+        (id)kCVPixelBufferPixelFormatTypeKey : @(kCVPixelFormatType_32BGRA),
+        (id)kCVPixelBufferWidthKey : @(width),
+        (id)kCVPixelBufferHeightKey : @(height),
+        (id)kCVPixelBufferIOSurfacePropertiesKey : @{}
+    };
+
+    CVReturn ret = CVPixelBufferPoolCreate(
+        kCFAllocatorDefault, NULL, (__bridge CFDictionaryRef)pixelBufferAttributes, &_pixelBufferPool);
+
+    if (ret != kCVReturnSuccess) {
+        NSLog(@"Error creating pixel buffer pool: %d", ret);
+        _pixelBufferPool = NULL;
+    }
+}
+
+- (CVPixelBufferRef)convertI420ToPixelBuffer:(RTCI420Buffer *)buffer {
+    if (_conversionInfo == nil) {
+        NSLog(@"%@: not prepared", NSStringFromSelector(_cmd));
+        return NULL;
+    }
+
+    if (_pixelBufferPool == NULL || _poolWidth != buffer.width || _poolHeight != buffer.height) {
+        [self createPixelBufferPoolWithWidth:buffer.width height:buffer.height];
+    }
+
+    CVPixelBufferRef pixelBuffer = NULL;
+    CVReturn status = CVPixelBufferPoolCreatePixelBuffer(kCFAllocatorDefault, _pixelBufferPool, &pixelBuffer);
+
+    if (status != kCVReturnSuccess) {
+        return NULL;
+    }
+
+    vImage_Error err = [self convertFrameVImageYUV:buffer toBuffer:pixelBuffer];
+
+    if (err != kvImageNoError) {
+        NSLog(@"%@: error during conversion: %ld", NSStringFromSelector(_cmd), err);
+        CVPixelBufferRelease(pixelBuffer);
+        return NULL;
+    }
+
+    return pixelBuffer;
+}
+
+- (vImage_Error)convertFrameVImageYUV:(RTCI420Buffer *)buffer toBuffer:(CVPixelBufferRef)pixelBufferRef {
+    if (pixelBufferRef == NULL) {
+        return kvImageInvalidParameter;
+    }
+
+    // Compute info for I420 source.
+    vImagePixelCount width = buffer.width;
+    vImagePixelCount height = buffer.height;
+    vImagePixelCount subsampledWidth = buffer.chromaWidth;
+    vImagePixelCount subsampledHeight = buffer.chromaHeight;
+
+    const uint8_t *yPlane = buffer.dataY;
+    const uint8_t *uPlane = buffer.dataU;
+    const uint8_t *vPlane = buffer.dataV;
+    size_t yStride = (size_t)buffer.strideY;
+    size_t uStride = (size_t)buffer.strideU;
+    size_t vStride = (size_t)buffer.strideV;
+
+    // Create vImage buffers to represent each of the Y, U, and V planes
+    vImage_Buffer yPlaneBuffer = {.data = (void *)yPlane, .height = height, .width = width, .rowBytes = yStride};
+    vImage_Buffer uPlaneBuffer = {
+        .data = (void *)uPlane, .height = subsampledHeight, .width = subsampledWidth, .rowBytes = uStride};
+    vImage_Buffer vPlaneBuffer = {
+        .data = (void *)vPlane, .height = subsampledHeight, .width = subsampledWidth, .rowBytes = vStride};
+
+    // Create a vImage buffer for the destination pixel buffer.
+    CVPixelBufferLockBaseAddress(pixelBufferRef, 0);
+
+    void *pixelBufferData = CVPixelBufferGetBaseAddress(pixelBufferRef);
+    size_t rowBytes = CVPixelBufferGetBytesPerRow(pixelBufferRef);
+    vImage_Buffer destinationImageBuffer = {
+        .data = pixelBufferData, .height = height, .width = width, .rowBytes = rowBytes};
+
+    // Do the conversion.
+
+    uint8_t permuteMap[4] = {3, 2, 1, 0};  // BGRA
+    vImage_Error convertError = vImageConvert_420Yp8_Cb8_Cr8ToARGB8888(&yPlaneBuffer,
+                                                                       &uPlaneBuffer,
+                                                                       &vPlaneBuffer,
+                                                                       &destinationImageBuffer,
+                                                                       self.conversionInfo,
+                                                                       permuteMap,
+                                                                       255,
+                                                                       kvImageNoFlags);
+
+    CVPixelBufferUnlockBaseAddress(pixelBufferRef, 0);
+
+    return convertError;
+}
+
+- (void)dealloc {
+    [self unprepareForAccelerateConversion];
+    CVPixelBufferPoolRelease(_pixelBufferPool);
+}
+
+@end

package/ios/RCTWebRTC/PIPController.h

@@ -0,0 +1,24 @@
+#import <AVKit/AVKit.h>
+#import <UIKit/UIKit.h>
+#import <WebRTC/RTCVideoTrack.h>
+
+#import "RTCVideoViewManager.h"
+
+API_AVAILABLE(ios(15.0))
+@interface PIPController : NSObject<AVPictureInPictureControllerDelegate>
+
+@property(nonatomic, weak) UIView *sourceView;
+@property(nonatomic, strong) RTCVideoTrack *videoTrack;
+
+@property(nonatomic, assign) BOOL startAutomatically;
+@property(nonatomic, assign) BOOL stopAutomatically;
+@property(nonatomic, assign) CGSize preferredSize;
+
+- (instancetype)initWithSourceView:(UIView *)sourceView;
+- (void)togglePIP;
+- (void)startPIP;
+- (void)stopPIP;
+- (void)insertFallbackView:(UIView *)subview;
+- (void)setObjectFit:(RTCVideoViewObjectFit)fit;
+
+@end