decoder/psgplay: Fix file reading, max file size, tune prefix, seek

Author: frno7

src/decoder/plugins/PsgplayDecoderPlugin.cxx

@@ -13,8 +13,10 @@
 #include "lib/fmt/PathFormatter.hxx"
 #include "lib/fmt/RuntimeError.hxx"
 #include "io/FileReader.hxx"
+#include "util/AllocatedArray.hxx"
 #include "util/Domain.hxx"
 #include "util/ScopeExit.hxx"
+#include "util/StringCompare.hxx"
 
 extern "C" {
 #include <psgplay/psgplay.h>
@@ -24,13 +26,14 @@ extern "C" {
 
 #include <fmt/format.h>
 
-#include <fstream>
-#include <iterator>
-#include <string>
-#include <vector>
-
 #define SUBTUNE_PREFIX "tune_"
 
+/*
+ * The Atari ST family of computers has a 24-bit bus,
+ * so 16 MiB is more than enough for any SNDH file.
+ */
+#define MAX_SNDH_FILE_SIZE 0x1000000
+
 static constexpr Domain psgplay_domain("psgplay");
 
 struct PsgplayGlobal {
@@ -68,28 +71,34 @@ struct PsgplayContainerPath {
 	unsigned track;
 };
 
-static std::vector<uint8_t>
+static AllocatedArray<std::byte>
 psgplay_read_file(const Path &path_fs)
 {
-	std::ifstream stream(NarrowPath(path_fs).c_str(),
-			     std::ios::in | std::ios::binary);
+	FileReader file(path_fs);
+
+	const size_t size = file.GetSize();
+
+	if (size > MAX_SNDH_FILE_SIZE)
+		throw FmtRuntimeError("File larger than {} bytes: {}",
+				      MAX_SNDH_FILE_SIZE, path_fs);
+
+	AllocatedArray<std::byte> data(size);
 
-	if (!stream)
-		return { };
+	if (file.Read(data) != size)
+		throw FmtRuntimeError("Failed to read {} bytes: {}",
+				      size, path_fs);
 
-	return std::vector<uint8_t>((std::istreambuf_iterator<char>(stream)),
-				    std::istreambuf_iterator<char>());
+	return data;
 }
 
 [[gnu::pure]]
 static unsigned
 psgplay_subtune_track(const char *base) noexcept
 {
-	if (memcmp(base, SUBTUNE_PREFIX, sizeof(SUBTUNE_PREFIX) - 1) != 0)
+	base = StringAfterPrefix(base, SUBTUNE_PREFIX);
+	if (base == nullptr)
 		return 0;
 
-	base += sizeof(SUBTUNE_PREFIX) - 1;
-
 	char *endptr;
 	auto track = strtoul(base, &endptr, 10);
 	if (endptr == base || *endptr != '.')
@@ -114,7 +123,7 @@ psgplay_container_from_path(Path path_fs) noexcept
 }
 
 static SongTime
-psgplay_subtune_duration(int subtune, const std::vector<uint8_t> &tune) noexcept
+psgplay_subtune_duration(int subtune, const AllocatedArray<std::byte> &tune) noexcept
 {
 	float duration;
 
@@ -127,12 +136,12 @@ psgplay_subtune_duration(int subtune, const std::vector<uint8_t> &tune) noexcept
 static void
 psgplay_file_decode(DecoderClient &client, Path path_fs)
 {
-	const auto container = psgplay_container_from_path(path_fs);
-
-	const AudioFormat audio_format(44100, SampleFormat::S16, 2);
+	static constexpr AudioFormat audio_format(44100, SampleFormat::S16, 2);
 	assert(audio_format.IsValid());
 
-	const std::vector<uint8_t> tune = psgplay_read_file(container.path);
+	const auto container = psgplay_container_from_path(path_fs);
+
+	const AllocatedArray<std::byte> tune = psgplay_read_file(container.path);
 	if (tune.empty())
 		return;
 
@@ -151,27 +160,27 @@ psgplay_file_decode(DecoderClient &client, Path path_fs)
 
 	client.Ready(audio_format, true, duration);
 
-	size_t t_samples = 0;
+	size_t t_frames = 0;
 	DecoderCommand cmd;
 
 	do {
 		enum { N = 4096 };
 		struct psgplay_stereo buffer[N];
 
-		/* psgplay_read_stereo returns the number of samples */
-		const ssize_t n_samples = psgplay_read_stereo(pp, buffer, N);
-		if (n_samples <= 0)
+		/* psgplay_read_stereo returns the number of (stereo) frames */
+		const ssize_t n_frames = psgplay_read_stereo(pp, buffer, N);
+		if (n_frames <= 0)
 			break;
 
 		cmd = client.SubmitAudio(nullptr,
-					 std::span{buffer, (size_t)n_samples},
+					 std::span{buffer, (size_t)n_frames},
 					 0);
-		t_samples += n_samples;
+		t_frames += n_frames;
 
 		if (cmd == DecoderCommand::SEEK) {
-			const uint64_t s_samples = client.GetSeekFrame();
+			const uint64_t s_frames = client.GetSeekFrame();
 
-			if (s_samples < t_samples) {
+			if (s_frames < t_frames) {
 				psgplay_free(pp);
 
 				pp = psgplay_init(tune.data(), tune.size(),
@@ -181,17 +190,20 @@ psgplay_file_decode(DecoderClient &client, Path path_fs)
 					return;
 				psgplay_stop_at_time(pp, duration.ToDoubleS());
 
-				t_samples = 0;
+				t_frames = 0;
 			}
 
-			const ssize_t k_samples =
-				psgplay_read_stereo(pp, nullptr,
-						    s_samples - t_samples);
-			if (k_samples <= 0)
-				break;
-			t_samples += k_samples;
+			if (s_frames > t_frames) {
+				const ssize_t k_frames =
+					psgplay_read_stereo(pp, nullptr,
+							    s_frames -
+							    t_frames);
+				if (k_frames <= 0)
+					break;
+				t_frames += k_frames;
+			}
 
-			if (t_samples != s_samples)
+			if (t_frames != s_frames)
 				client.SeekError();
 
 			client.CommandFinished();
@@ -203,7 +215,7 @@ static void
 psgplay_tag(enum TagType tag_type, TagHandler &th,
 	    bool (*tag)(char *text, size_t length,
 			const void *data, const size_t size),
-	    const std::vector<uint8_t> &tune) noexcept
+	    const AllocatedArray<std::byte> &tune) noexcept
 {
 	char text[256];
 
@@ -212,14 +224,14 @@ psgplay_tag(enum TagType tag_type, TagHandler &th,
 }
 
 static void
-psgplay_tag_subtune_title(unsigned track, unsigned n_tracks,
+psgplay_tag_subtune_name(unsigned track, unsigned n_tracks,
 			  TagHandler &th,
-			  const std::vector<uint8_t> &tune) noexcept
+			  const AllocatedArray<std::byte> &tune) noexcept
 {
 	char text[256];
 
-	if (sndh_tag_subtune_title(text, sizeof(text), track,
-				    tune.data(), tune.size())) {
+	if (sndh_tag_subtune_name(text, sizeof(text), track,
+				  tune.data(), tune.size())) {
 		th.OnTag(TAG_TITLE, text);
 		return;
 	}
@@ -239,7 +251,7 @@ psgplay_tag_subtune_title(unsigned track, unsigned n_tracks,
 }
 
 static int
-psgplay_tracks(const std::vector<uint8_t> &tune) noexcept
+psgplay_tracks(const AllocatedArray<std::byte> &tune) noexcept
 {
 	int n_tracks;
 
@@ -251,10 +263,10 @@ psgplay_tracks(const std::vector<uint8_t> &tune) noexcept
 
 static void
 psgplay_on_tag(unsigned track, unsigned n_tracks, TagHandler &th,
-		const std::vector<uint8_t> &tune) noexcept
+		const AllocatedArray<std::byte> &tune) noexcept
 {
 	psgplay_tag(TAG_ALBUM, th, sndh_tag_title, tune);
-	psgplay_tag_subtune_title(track, n_tracks, th, tune);
+	psgplay_tag_subtune_name(track, n_tracks, th, tune);
 	psgplay_tag(TAG_ARTIST, th, sndh_tag_composer, tune);
 	psgplay_tag(TAG_DATE, th, sndh_tag_year, tune);
 
@@ -274,7 +286,7 @@ psgplay_scan_file(Path path_fs, TagHandler &th) noexcept
 {
 	const auto container = psgplay_container_from_path(path_fs);
 
-	const std::vector<uint8_t> tune = psgplay_read_file(container.path);
+	const AllocatedArray<std::byte> tune = psgplay_read_file(container.path);
 	if (tune.empty())
 		return false;
 
@@ -288,7 +300,7 @@ psgplay_container_scan(Path path_fs)
 {
 	std::forward_list<DetachedSong> list;
 
-	const std::vector<uint8_t> tune = psgplay_read_file(path_fs);
+	const AllocatedArray<std::byte> tune = psgplay_read_file(path_fs);
 
 	const int n_tracks = psgplay_tracks(tune);