@sbhjt-gr/react-native-webrtc 137.0.2

package/android/src/main/java/com/oney/WebRTCModule/videoEffects/VideoEffectProcessor.java

@@ -0,0 +1,59 @@
+package com.oney.WebRTCModule.videoEffects;
+
+import org.webrtc.SurfaceTextureHelper;
+import org.webrtc.VideoFrame;
+import org.webrtc.VideoProcessor;
+import org.webrtc.VideoSink;
+
+import java.util.List;
+
+/**
+ * Lightweight abstraction for an object that can receive video frames, process and add effects in
+ * them, and pass them on to another object.
+ */
+public class VideoEffectProcessor implements VideoProcessor {
+    private VideoSink mSink;
+    final private SurfaceTextureHelper textureHelper;
+    final private List<VideoFrameProcessor> videoFrameProcessors;
+
+    public VideoEffectProcessor(List<VideoFrameProcessor> processors, SurfaceTextureHelper textureHelper) {
+        this.textureHelper = textureHelper;
+        this.videoFrameProcessors = processors;
+    }
+
+    @Override
+    public void onCapturerStarted(boolean success) {}
+
+    @Override
+    public void onCapturerStopped() {}
+
+    @Override
+    public void setSink(VideoSink sink) {
+        mSink = sink;
+    }
+
+    /**
+     * Called just after the frame is captured.
+     * Will process the VideoFrame with the help of VideoFrameProcessor and send the processed
+     * VideoFrame back to webrtc using onFrame method in VideoSink.
+     * @param frame raw VideoFrame received from webrtc.
+     */
+    @Override
+    public void onFrameCaptured(VideoFrame frame) {
+        frame.retain();
+        VideoFrame outputFrame = frame;
+        for (VideoFrameProcessor processor : this.videoFrameProcessors) {
+            outputFrame = processor.process(outputFrame, textureHelper);
+
+            if (outputFrame == null) {
+                mSink.onFrame(frame);
+                frame.release();
+                return;
+            }
+        }
+
+        mSink.onFrame(outputFrame);
+        outputFrame.release();
+        frame.release();
+    }
+}

package/android/src/main/java/com/oney/WebRTCModule/videoEffects/VideoFrameProcessor.java

@@ -0,0 +1,19 @@
+package com.oney.WebRTCModule.videoEffects;
+
+import org.webrtc.SurfaceTextureHelper;
+import org.webrtc.VideoFrame;
+
+/**
+ * Interface contains process method to process VideoFrame.
+ * The caller takes ownership of the object.
+ */
+public interface VideoFrameProcessor {
+    /**
+     * Applies the image processing algorithms to the frame. Returns the processed frame.
+     * The caller is responsible for releasing the returned frame.
+     * @param frame raw videoframe which need to be processed
+     * @param textureHelper
+     * @return processed videoframe which will rendered
+     */
+    public VideoFrame process(VideoFrame frame, SurfaceTextureHelper textureHelper);
+}

package/android/src/main/java/com/oney/WebRTCModule/videoEffects/VideoFrameProcessorFactoryInterface.java

@@ -0,0 +1,12 @@
+package com.oney.WebRTCModule.videoEffects;
+
+/**
+ * Factory for creating VideoFrameProcessor instances.
+ */
+public interface VideoFrameProcessorFactoryInterface {
+    /**
+     * Dynamically allocates a VideoFrameProcessor instance and returns a pointer to it.
+     * The caller takes ownership of the object.
+     */
+    public VideoFrameProcessor build();
+}

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

@@ -0,0 +1,73 @@
+package com.oney.WebRTCModule.webrtcutils;
+
+import androidx.annotation.Nullable;
+
+import org.webrtc.EglBase;
+import org.webrtc.HardwareVideoDecoderFactory;
+import org.webrtc.VideoCodecInfo;
+import org.webrtc.VideoDecoder;
+import org.webrtc.VideoDecoderFactory;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * This is a custom video decoder 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 H264AndSoftwareVideoDecoderFactory implements VideoDecoderFactory {
+    private final VideoDecoderFactory hardwareVideoDecoderFactory;
+    private final VideoDecoderFactory softwareVideoDecoderFactory;
+
+    public H264AndSoftwareVideoDecoderFactory(@Nullable EglBase.Context eglContext) {
+        this.hardwareVideoDecoderFactory = new HardwareVideoDecoderFactory(eglContext);
+        this.softwareVideoDecoderFactory = new SoftwareVideoDecoderFactoryProxy();
+    }
+
+    @Nullable
+    @Override
+    public VideoDecoder createDecoder(VideoCodecInfo codecInfo) {
+        if (codecInfo.name.equalsIgnoreCase("H264")) {
+            return this.hardwareVideoDecoderFactory.createDecoder(codecInfo);
+        }
+
+        return this.softwareVideoDecoderFactory.createDecoder(codecInfo);
+    }
+
+    @Override
+    public VideoCodecInfo[] getSupportedCodecs() {
+        List<VideoCodecInfo> codecs = new ArrayList<>();
+
+        VideoCodecInfo h264Baseline = null;
+        VideoCodecInfo h264High = null;
+
+        VideoCodecInfo[] hwCodecs = this.hardwareVideoDecoderFactory.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.softwareVideoDecoderFactory.getSupportedCodecs()));
+
+        return codecs.toArray(new VideoCodecInfo[codecs.size()]);
+    }
+}

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