feat: waveform, start/end grabs, more stuff

Author: f0e

src/common/utils.cpp

@@ -359,6 +359,54 @@ u::VideoInfo u::get_video_info(const std::filesystem::path& path) {
 	return info;
 }
 
+std::vector<int16_t> u::get_video_waveform(const std::filesystem::path& path) {
+	namespace bp = boost::process;
+
+	bp::ipstream pipe_stream;
+	bp::child c(
+		boost::filesystem::path{ blur.ffmpeg_path },
+		"-v",
+		"error",
+		"-i",
+		path.string(),
+		"-f",
+		"s16le",
+		"-acodec",
+		"pcm_s16le",
+		"-ac",
+		"1",
+		"-ar",
+		"44100",
+		"-",
+		bp::std_out > pipe_stream,
+		bp::std_err.null()
+#ifdef _WIN32
+			,
+		bp::windows::create_no_window
+#endif
+	);
+
+	std::vector<int16_t> samples;
+	std::vector<char> buffer(4096);
+
+	while (pipe_stream.read(buffer.data(), buffer.size()) || pipe_stream.gcount() > 0) {
+		auto bytes_read = static_cast<std::size_t>(pipe_stream.gcount());
+
+		// Ensure we read full samples
+		if (bytes_read % 2 != 0)
+			--bytes_read;
+
+		std::vector<int16_t> chunk(bytes_read / 2);
+		std::memcpy(chunk.data(), buffer.data(), bytes_read);
+
+		samples.insert(samples.end(), chunk.begin(), chunk.end());
+	}
+
+	c.wait();
+
+	return samples;
+}
+
 bool u::test_hardware_device(const std::string& device_type) {
 	namespace bp = boost::process;
 

src/common/utils.h

@@ -370,6 +370,7 @@ namespace u {
 	};
 
 	VideoInfo get_video_info(const std::filesystem::path& path);
+	std::vector<int16_t> get_video_waveform(const std::filesystem::path& path);
 
 	struct EncodingDevice {
 		std::string type;   // "nvidia", "amd", "intel", "mac"

src/gui/components/main.cpp

@@ -223,13 +223,21 @@ void main::home_screen(ui::Container& container, float delta_time) {
 			"blur title text", container, title_pos, "blur", gfx::Color::white(), fonts::header_font, FONT_CENTERED_X
 		);
 
-		ui::add_video(
+		auto video = ui::add_video(
 			"test video",
 			container,
 			tasks::video_player_path,
 			gfx::Size(container.get_usable_rect().w, container.get_usable_rect().h / 2)
 		);
 
+		if (video) {
+			auto video_rect = (*video)->element->rect;
+
+			const auto& video_data = std::get<ui::VideoElementData>((*video)->element->data);
+
+			ui::add_video_track("test video track", container, video_rect.w, video_data);
+		}
+
 		if (!initialisation_res) {
 			ui::add_text(
 				"failed to initialise text",

src/gui/render/render.cpp

@@ -6,6 +6,8 @@
 #include <misc/freetype/imgui_freetype.h>
 #include <imgui_internal.h>
 
+#include <algorithm>
+
 #include "../fonts/dejavu_sans.h"
 #include "../fonts/eb_garamond.h"
 #include "../fonts/icons.h"
@@ -647,6 +649,84 @@ void render::loader(const gfx::Rect& rect, const gfx::Color& color) {
 	text(rect.center(), color, "loading...", fonts::dejavu, FONT_CENTERED_X | FONT_CENTERED_Y);
 }
 
+void render::waveform(
+	const gfx::Rect& rect,
+	const gfx::Rect& active_rect,
+	const gfx::Color& color,
+	const std::vector<int16_t>& samples,
+	bool filled
+) {
+	if (samples.empty())
+		return;
+
+	const size_t width = rect.w;
+	const size_t height = rect.h;
+
+	// Find max amplitude to normalize waveform
+	int16_t max_sample = 1;
+	for (auto s : samples) {
+		max_sample = std::max<int>(std::abs(s), max_sample);
+	}
+
+	for (size_t x = 0; x < width; ++x) {
+		// Map pixel x to corresponding sample index
+		float sample_pos = static_cast<float>(x) / width * samples.size();
+		auto idx_start = static_cast<size_t>(sample_pos);
+		size_t idx_end =
+			std::min(static_cast<size_t>(sample_pos + (samples.size() / static_cast<float>(width))), samples.size());
+
+		// Take max amplitude in this range
+		int16_t max_amp = 0;
+		for (size_t i = idx_start; i < idx_end; ++i) {
+			max_amp = std::max(max_amp, static_cast<int16_t>(std::abs(samples[i])));
+		}
+
+		// Normalize to [0,1]
+		float norm = static_cast<float>(max_amp) / max_sample;
+		int y_center = rect.y + (height / 2);
+		int y_half = static_cast<int>(norm * (height / 2.f));
+
+		auto x_color = color;
+		if (!active_rect.contains(gfx::Point(rect.x + x, y_center)))
+			x_color = color.adjust_alpha(0.5f);
+
+		if (filled) {
+			gfx::Rect r{ static_cast<int>(rect.x + x), y_center - y_half, 1, y_half * 2 };
+			rect_filled(r, x_color);
+		}
+		else {
+			gfx::Point p1{ static_cast<int>(rect.x + x), y_center - y_half };
+			gfx::Point p2{ static_cast<int>(rect.x + x), y_center + y_half };
+			line(p1, p2, x_color, true);
+		}
+	}
+}
+
+void render::rect_side(const gfx::Rect& rect, const gfx::Color& color, RectSide side, int thickness) {
+	switch (side) {
+		case RectSide::LEFT: {
+			// Top horizontal
+			rect_filled(gfx::Rect{ rect.x, rect.y - thickness, rect.w, thickness }, color);
+			// Vertical
+			rect_filled(
+				gfx::Rect{ rect.x - thickness, rect.y - thickness, thickness, rect.h + (thickness * 2) }, color
+			);
+			// Bottom horizontal
+			rect_filled(gfx::Rect{ rect.x, rect.y + rect.h, rect.w, thickness }, color);
+			break;
+		}
+		case RectSide::RIGHT: {
+			// Top horizontal
+			rect_filled(gfx::Rect{ rect.x, rect.y - thickness, rect.w, thickness }, color);
+			// Vertical
+			rect_filled(gfx::Rect{ rect.x + rect.w, rect.y - thickness, thickness, rect.h + (thickness * 2) }, color);
+			// Bottom horizontal
+			rect_filled(gfx::Rect{ rect.x, rect.y + rect.h, rect.w, thickness }, color);
+			break;
+		}
+	}
+}
+
 void render::push_clip_rect(const gfx::Rect& rect, bool intersect_clip_rect) {
 	imgui.drawlist->PushClipRect(rect.origin(), rect.max(), intersect_clip_rect);
 }

src/gui/render/render.h

@@ -241,6 +241,21 @@ namespace render {
 
 	void loader(const gfx::Rect& rect, const gfx::Color& color);
 
+	void waveform(
+		const gfx::Rect& rect,
+		const gfx::Rect& active_rect,
+		const gfx::Color& color,
+		const std::vector<int16_t>& samples,
+		bool filled = true
+	);
+
+	enum class RectSide {
+		LEFT,
+		RIGHT
+	};
+
+	void rect_side(const gfx::Rect& rect, const gfx::Color& color, RectSide side, int thickness = 1);
+
 	void push_clip_rect(const gfx::Rect& rect, bool intersect_clip_rect = false);
 	void push_clip_rect(int x1, int y1, int x2, int y2, bool intersect_clip_rect = false);
 	void push_fullscreen_clip_rect();

src/gui/ui/elements/video.cpp

@@ -1,3 +1,5 @@
+#include <algorithm>
+
 #include "../ui.h"
 #include "../../render/render.h"
 #include "../keys.h"
@@ -17,11 +19,11 @@ namespace {
 
 			if (it == video_players.end()) {
 				auto player = std::make_shared<VideoPlayer>();
-				player->load_file(key.c_str());
+				player->load_file(key);
 				u::log("loaded video from {}", key);
 
 				auto insert_result = video_players.insert({ key, player });
-				it = insert_result.first; // safe because insert always returns valid iterator
+				it = insert_result.first;
 			}
 
 			return it->second;
@@ -61,23 +63,6 @@ void ui::handle_videos_event(const SDL_Event& event, bool& to_render) {
 	}
 }
 
-void ui::render_video_track(
-	const Container& container, const AnimatedElement& element, std::optional<FrameData> frame_data
-) {
-	const auto& video_data = std::get<VideoElementData>(element.element->data);
-	float anim = element.animations.at(hasher("main")).current;
-
-	auto usable_rect = element.element->rect.expand(2);
-
-	render::line({ usable_rect.x, usable_rect.y2() }, { usable_rect.x2(), usable_rect.y2() }, gfx::Color::green());
-
-	if (frame_data) {
-		float perc = static_cast<float>(frame_data->current_frame) / static_cast<float>(frame_data->total_frames);
-		auto progress = perc * usable_rect.w;
-		render::circle_filled({ static_cast<int>(usable_rect.x + progress), usable_rect.y2() }, 99, gfx::Color::red());
-	}
-}
-
 void ui::render_video(const Container& container, const AnimatedElement& element) {
 	const auto& video_data = std::get<VideoElementData>(element.element->data);
 
@@ -94,7 +79,7 @@ void ui::render_video(const Container& container, const AnimatedElement& element
 		return;
 	}
 
-	auto usable_rect = element.element->rect.shrink(2); // account for border
+	auto usable_rect = element.element->rect.shrink(3); // account for border
 
 	// TODO: render::image
 	render::imgui.drawlist->AddImage(
@@ -106,18 +91,9 @@ void ui::render_video(const Container& container, const AnimatedElement& element
 		IM_COL32(255, 255, 255, alpha) // apply alpha for fade animations
 	);
 
-	auto frame_data = video_data.player->get_video_frame_data();
-
-	if (frame_data) {
-		render::text(
-			{ usable_rect.center().x + 30, usable_rect.y - fonts::dejavu.height() },
-			gfx::Color::white(),
-			std::format("{}/{}", frame_data->current_frame, frame_data->total_frames),
-			fonts::dejavu
-		);
-	}
-
-	render_video_track(container, element, frame_data);
+	render::borders(
+		element.element->rect, gfx::Color(155, 155, 155, stroke_alpha), gfx::Color(80, 80, 80, stroke_alpha)
+	);
 }
 
 bool ui::update_video(const Container& container, AnimatedElement& element) {