fix(VideoStreamNDI): Use Texture2DRD to support BGRA

Author: unvermuthet

build_profile.json

@@ -44,6 +44,7 @@
 		"OS",
 		"ProjectSettings",
 		"RDTextureFormat",
+		"RDTextureView",
 		"RenderingDevice",
 		"RenderingServer",
 		"Resource",
@@ -54,6 +55,7 @@
 		"Time",
 		"Timer",
 		"Texture",
+		"Texture2DRD",
 		"Viewport",
 		"ViewportTexture",
 		"VideoStream",

src/video_stream_playback_ndi.cpp

@@ -12,10 +12,14 @@ file, You can obtain one at https://mozilla.org/MPL/2.0/.
 #include <godot_cpp/classes/engine.hpp>
 #include <godot_cpp/classes/os.hpp>
 #include <godot_cpp/classes/project_settings.hpp>
+#include <godot_cpp/classes/rd_texture_format.hpp>
+#include <godot_cpp/classes/rd_texture_view.hpp>
+#include <godot_cpp/classes/rendering_server.hpp>
 
 using namespace godot;
 
 VideoStreamPlaybackNDI::VideoStreamPlaybackNDI() {
+	rd = RenderingServer::get_singleton()->get_rendering_device();
 	texture.instantiate();
 }
 
@@ -26,6 +30,12 @@ VideoStreamPlaybackNDI::VideoStreamPlaybackNDI(NDIlib_recv_create_v3_t p_recv_de
 
 VideoStreamPlaybackNDI::~VideoStreamPlaybackNDI() {
 	_stop();
+
+	RID texture_rd_rid = texture->get_texture_rd_rid();
+	if (texture_rd_rid.is_valid()) {
+		rd->free_rid(texture_rd_rid);
+	}
+
 	texture.unref();
 }
 
@@ -114,50 +124,77 @@ void VideoStreamPlaybackNDI::_update(double p_delta) {
 
 void VideoStreamPlaybackNDI::_bind_methods() {}
 
+void VideoStreamPlaybackNDI::update_texture(NDIlib_video_frame_v2_t p_video_frame) {
+	Vector2i new_texture_size = Vector2i(p_video_frame.xres, p_video_frame.yres);
+
+	PackedByteArray data;
+	data.resize(p_video_frame.line_stride_in_bytes * p_video_frame.yres);
+	memcpy(data.ptrw(), p_video_frame.p_data, data.size());
+
+	RID texture_rd_rid = texture->get_texture_rd_rid();
+
+	if (new_texture_size == texture_size && texture_rd_rid.is_valid()) {
+		rd->texture_update(texture_rd_rid, 0, data);
+	} else {
+		if (texture_rd_rid.is_valid()) {
+			rd->free_rid(texture_rd_rid);
+		}
+
+		Ref<RDTextureFormat> tf;
+		tf.instantiate();
+		tf->set_format(RenderingDevice::DATA_FORMAT_B8G8R8A8_UNORM);
+		tf->set_width(new_texture_size.x);
+		tf->set_height(new_texture_size.y);
+		tf->set_usage_bits(RenderingDevice::TEXTURE_USAGE_SAMPLING_BIT | RenderingDevice::TEXTURE_USAGE_CAN_UPDATE_BIT);
+
+		// tf->set_depth(1);
+		// tf->set_array_layers(1);
+		// tf->set_mipmaps(1);
+		// tf->set_samples(RenderingDevice::TEXTURE_SAMPLES_1);
+		// tf->set_texture_type(RenderingDevice::TEXTURE_TYPE_2D);
+
+		Ref<RDTextureView> tv;
+		tv.instantiate();
+
+		Array texture_data = Array();
+		texture_data.append(data);
+
+		texture_rd_rid = rd->texture_create(tf, tv, texture_data);
+		tf.unref();
+		tv.unref();
+
+		texture->set_texture_rd_rid(texture_rd_rid);
+
+		texture_size = new_texture_size;
+	}
+}
+
 void VideoStreamPlaybackNDI::wait_for_non_empty_frame() {
 	for (size_t i = 0; i < 1000; i++) {
-		ndi->framesync_capture_video(sync, &video_frame, NDIlib_frame_format_type_progressive);
-		if (video_frame.xres != 0 && video_frame.yres != 0) {
-			texture->set_image(Image::create_empty(video_frame.xres, video_frame.yres, false, Image::FORMAT_RGBA8));
-			ndi->framesync_free_video(sync, &video_frame);
+		if (render_video()) {
 			return;
 		}
-		ndi->framesync_free_video(sync, &video_frame);
 		OS::get_singleton()->delay_msec(10);
 	}
 
 	// Fallback resolution
-	texture->set_image(Image::create_empty(1920, 1080, false, Image::FORMAT_RGBA8));
 	ERR_FAIL_MSG("NDI: Source not found at playback start. It will play at fallback resolution of 1920x1080 once discovered. See docs for NDIOutput.");
 }
 
-void VideoStreamPlaybackNDI::render_video() {
-	if (img.is_valid()) {
-		if (texture->get_width() == img->get_width() && texture->get_height() == img->get_height()) {
-			texture->update(img);
-		} else {
-			texture->set_image(img);
-		}
-	}
+bool VideoStreamPlaybackNDI::render_video() {
+	bool updated = false;
 
+	NDIlib_video_frame_v2_t video_frame;
 	ndi->framesync_capture_video(sync, &video_frame, NDIlib_frame_format_type_progressive);
 
-	if (video_frame.p_data != nullptr && (video_frame.FourCC == NDIlib_FourCC_type_RGBA || video_frame.FourCC == NDIlib_FourCC_type_RGBX)) {
-		video_buffer.resize(video_frame.xres * video_frame.yres * 4);
-
-		// memcpy(video_buffer.ptrw(), video_frame.p_data, video_buffer.size());
-
-		for (size_t i = 0; i < video_frame.xres * video_frame.yres; i++) {
-			video_buffer.set(i * 4 + 0, video_frame.p_data[i * 4 + 2]);
-			video_buffer.set(i * 4 + 1, video_frame.p_data[i * 4 + 1]);
-			video_buffer.set(i * 4 + 2, video_frame.p_data[i * 4 + 0]);
-			video_buffer.set(i * 4 + 3, video_frame.p_data[i * 4 + 3]);
-		}
-
-		img = Image::create_from_data(video_frame.xres, video_frame.yres, false, Image::Format::FORMAT_RGBA8, video_buffer);
+	if (video_frame.p_data != nullptr && video_frame.xres != 0 && video_frame.yres != 0 && (video_frame.FourCC == NDIlib_FourCC_type_BGRA || video_frame.FourCC == NDIlib_FourCC_type_BGRX)) {
+		update_texture(video_frame);
+		updated = true;
 	}
 
 	ndi->framesync_free_video(sync, &video_frame);
+
+	return updated;
 }
 
 void VideoStreamPlaybackNDI::render_audio(double p_delta) {

src/video_stream_playback_ndi.hpp

@@ -11,7 +11,8 @@ file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 #include "ndi.hpp"
 
-#include <godot_cpp/classes/image_texture.hpp>
+#include <godot_cpp/classes/rendering_device.hpp>
+#include <godot_cpp/classes/texture2drd.hpp>
 #include <godot_cpp/classes/video_stream_playback.hpp>
 
 using namespace godot;
@@ -48,12 +49,13 @@ class VideoStreamPlaybackNDI : public VideoStreamPlayback {
 	NDIlib_recv_instance_t recv = nullptr;
 	NDIlib_framesync_instance_t sync = nullptr;
 
-	Ref<ImageTexture> texture;
-	Ref<Image> img;
-	NDIlib_video_frame_v2_t video_frame;
-	PackedByteArray video_buffer;
+	RenderingDevice *rd;
+	Ref<Texture2DRD> texture;
+	Vector2i texture_size = Vector2i(0, 0);
+	void update_texture(NDIlib_video_frame_v2_t p_video_frame);
+
 	void wait_for_non_empty_frame();
-	void render_video();
+	bool render_video();
 
 	NDIlib_audio_frame_v3_t audio_frame;
 	PackedFloat32Array audio_buffer_planar;