feat: add CustomVideoSource and related JNI bindings for video frame handling

Author: devopvoid

webrtc-jni/src/main/cpp/include/JNI_CustomAudioSource.h

@@ -19,6 +19,8 @@
 
 #include "media/audio/CustomAudioSource.h"
 
+#include "rtc_base/logging.h"
+
 JNIEXPORT void JNICALL Java_dev_onvoid_webrtc_media_audio_CustomAudioSource_initialize
 (JNIEnv * env, jobject caller)
 {
@@ -28,6 +30,23 @@ JNIEXPORT void JNICALL Java_dev_onvoid_webrtc_media_audio_CustomAudioSource_init
     SetHandle(env, caller, source.release());
 }
 
+JNIEXPORT void JNICALL Java_dev_onvoid_webrtc_media_audio_CustomAudioSource_dispose
+(JNIEnv * env, jobject caller)
+{
+    jni::CustomAudioSource * source = GetHandle<jni::CustomAudioSource>(env, caller);
+    CHECK_HANDLE(source);
+
+	webrtc::RefCountReleaseStatus status = source->Release();
+
+	if (status != webrtc::RefCountReleaseStatus::kDroppedLastRef) {
+		RTC_LOG(LS_WARNING) << "Native object was not deleted. A reference is still around somewhere.";
+	}
+
+	SetHandle<std::nullptr_t>(env, caller, nullptr);
+
+	source = nullptr;
+}
+
 JNIEXPORT void JNICALL Java_dev_onvoid_webrtc_media_audio_CustomAudioSource_pushAudio
 (JNIEnv * env, jobject caller, jbyteArray audioData, jint bits_per_sample, jint sampleRate, jint channels, jint frameCount)
 {

webrtc-jni/src/main/cpp/include/JNI_CustomVideoSource.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2019 Alex Andres
+ *
+ * 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.
+ */
+
+#include "JNI_CustomVideoSource.h"
+#include "JavaUtils.h"
+#include "api/VideoFrame.h"
+
+#include "media/video/CustomVideoSource.h"
+
+#include "rtc_base/logging.h"
+
+JNIEXPORT void JNICALL Java_dev_onvoid_webrtc_media_video_CustomVideoSource_initialize
+(JNIEnv * env, jobject caller)
+{
+    std::shared_ptr<jni::SyncClock> sync_clock = std::make_shared<jni::SyncClock>();
+    webrtc::scoped_refptr<jni::CustomVideoSource> source = webrtc::make_ref_counted<jni::CustomVideoSource>(sync_clock);
+
+    SetHandle(env, caller, source.release());
+}
+
+JNIEXPORT void JNICALL Java_dev_onvoid_webrtc_media_video_CustomVideoSource_dispose
+(JNIEnv * env, jobject caller)
+{
+    jni::CustomVideoSource * source = GetHandle<jni::CustomVideoSource>(env, caller);
+    CHECK_HANDLE(source);
+
+    webrtc::RefCountReleaseStatus status = source->Release();
+
+    if (status != webrtc::RefCountReleaseStatus::kDroppedLastRef) {
+        RTC_LOG(LS_WARNING) << "Native object was not deleted. A reference is still around somewhere.";
+    }
+
+    SetHandle<std::nullptr_t>(env, caller, nullptr);
+
+    source = nullptr;
+}
+
+JNIEXPORT void JNICALL Java_dev_onvoid_webrtc_media_video_CustomVideoSource_pushFrame
+(JNIEnv * env, jobject caller, jobject javaFrame)
+{
+    jni::CustomVideoSource * source = GetHandle<jni::CustomVideoSource>(env, caller);
+    CHECK_HANDLE(source);
+
+    if (javaFrame != nullptr) {
+        auto frame = jni::JavaLocalRef<jobject>(env, javaFrame);
+        webrtc::VideoFrame nativeFrame = jni::VideoFrame::toNative(env, frame);
+        
+        source->PushFrame(nativeFrame);
+    }
+}

webrtc-jni/src/main/cpp/src/JNI_CustomAudioSource.cpp

@@ -19,6 +19,7 @@
 #include "JavaUtils.h"
 #include "JNI_WebRTC.h"
 
+#include "api/video/i420_buffer.h"
 #include "rtc_base/time_utils.h"
 
 namespace jni
@@ -32,9 +33,39 @@ namespace jni
 
 			int rotation = obj.getInt(javaClass->rotation);
 			int64_t timestamp_ns = obj.getLong(javaClass->timestampNs);
+			JavaLocalRef<jobject> jBuffer = obj.getObject(javaClass->buffer);
+			
+			/*
+			// Get the I420Buffer properties
+			const auto i420Class = JavaClasses::get<JavaNativeI420BufferClass>(env);
+			JavaObject bufferObj(env, jBuffer);
+			
+			int width = bufferObj.getInt(i420Class->width);
+			int height = bufferObj.getInt(i420Class->height);
+			
+			JavaLocalRef<jobject> dataY = bufferObj.getObject(i420Class->dataY);
+			JavaLocalRef<jobject> dataU = bufferObj.getObject(i420Class->dataU);
+			JavaLocalRef<jobject> dataV = bufferObj.getObject(i420Class->dataV);
+			
+			int strideY = bufferObj.getInt(i420Class->strideY);
+			int strideU = bufferObj.getInt(i420Class->strideU);
+			int strideV = bufferObj.getInt(i420Class->strideV);
+			
+			// Get the direct buffer addresses
+			const uint8_t * y_data = static_cast<uint8_t*>(env->GetDirectBufferAddress(dataY.get()));
+			const uint8_t * u_data = static_cast<uint8_t*>(env->GetDirectBufferAddress(dataU.get()));
+			const uint8_t * v_data = static_cast<uint8_t*>(env->GetDirectBufferAddress(dataV.get()));
+			
+			// Create a native I420Buffer
+			webrtc::scoped_refptr<webrtc::I420Buffer> buffer = webrtc::I420Buffer::Copy(
+				width, height, y_data, strideY, u_data, strideU, v_data, strideV);
+			*/
+
+			webrtc::I420BufferInterface * i420Buffer = GetHandle<webrtc::I420BufferInterface>(env, jBuffer);
+			webrtc::scoped_refptr<webrtc::I420BufferInterface> buffer(i420Buffer);
 
 			return webrtc::VideoFrame::Builder()
-				//.set_video_frame_buffer(buffer)
+				.set_video_frame_buffer(buffer)
 				//.set_timestamp_rtp(timestamp_rtp)
 				.set_timestamp_ms(timestamp_ns / webrtc::kNumNanosecsPerMillisec)
 				.set_rotation(static_cast<webrtc::VideoRotation>(rotation))

webrtc-jni/src/main/cpp/src/JNI_CustomVideoSource.cpp

@@ -45,6 +45,13 @@ public CustomAudioSource() {
 	public native void pushAudio(byte[] audioData, int bits_per_sample,
 								 int sampleRate, int channels, int frameCount);
 
+	/**
+	 * Disposes of any native resources held by this audio source.
+	 * This method should be called when the audio source is no longer needed
+	 * to prevent memory leaks.
+	 */
+	public native void dispose();
+
 	/**
 	 * Initializes the native resources required by this audio source.
 	 */

webrtc-jni/src/main/cpp/src/api/VideoFrame.cpp

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2019 Alex Andres
+ *
+ * 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 dev.onvoid.webrtc.media.video;
+
+/**
+ * Custom implementation of a video source for WebRTC that allows pushing video frames
+ * from external sources directly to the WebRTC video pipeline.
+ *
+ * @author Alex Andres
+ */
+public class CustomVideoSource extends VideoTrackSource {
+
+	/**
+	 * Constructs a new CustomVideoSource instance.
+	 */
+	public CustomVideoSource() {
+		super();
+
+		initialize();
+	}
+
+	/**
+	 * Pushes audio data to be processed by this audio source.
+	 *
+	 * @param frame The video frame to be pushed to the source.
+	 */
+	public native void pushFrame(VideoFrame frame);
+
+	/**
+	 * Disposes of any native resources held by this video source.
+	 * This method should be called when the video source is no longer needed
+	 * to prevent memory leaks.
+	 */
+	public native void dispose();
+
+	/**
+	 * Initializes the native resources required by this video source.
+	 */
+	private native void initialize();
+
+}

webrtc/src/main/java/dev/onvoid/webrtc/media/audio/CustomAudioSource.java

@@ -19,12 +19,16 @@
 import dev.onvoid.webrtc.internal.RefCounted;
 
 /**
- * Represents a video frame with an associated frame buffer and metadata.
- * This class implements reference counting to manage memory for video frames.
- * Video frames contain buffer data along with rotation and timestamp information.
+ * Represents a video frame with an underlying buffer, rotation information, and timestamp.
+ * <p>
+ * A VideoFrame holds reference to its buffer data and implements the RefCounted
+ * interface to manage the lifecycle of native resources through reference counting.
+ * The frame includes a timestamp in nanoseconds for synchronization purposes.
+ *
+ * @author Alex Andres
  */
 public class VideoFrame implements RefCounted {
-	
+
 	/** The underlying frame buffer. */
 	public final VideoFrameBuffer buffer;
 
@@ -35,7 +39,28 @@ public class VideoFrame implements RefCounted {
 	public final long timestampNs;
 
 
-	private VideoFrame(VideoFrameBuffer buffer, int rotation, long timestampNs) {
+	/**
+	 * Creates a new VideoFrame with the specified buffer, rotation and timestamp.
+	 *
+	 * @param buffer      The video frame buffer containing the actual frame data.
+	 * @param timestampNs The timestamp of the frame in nanoseconds.
+	 *
+	 * @throws IllegalArgumentException If buffer is null.
+	 */
+	public VideoFrame(VideoFrameBuffer buffer, long timestampNs) {
+		this(buffer, 0, timestampNs);
+	}
+
+	/**
+	 * Creates a new VideoFrame with the specified buffer, rotation and timestamp.
+	 *
+	 * @param buffer      The video frame buffer containing the actual frame data.
+	 * @param rotation    The rotation of the frame in degrees (must be a multiple of 90).
+	 * @param timestampNs The timestamp of the frame in nanoseconds.
+	 *
+	 * @throws IllegalArgumentException If buffer is null or rotation is not a multiple of 90.
+	 */
+	public VideoFrame(VideoFrameBuffer buffer, int rotation, long timestampNs) {
 		if (buffer == null) {
 			throw new IllegalArgumentException("VideoFrameBuffer must not be null");
 		}