You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
131 lines
3.4 KiB
131 lines
3.4 KiB
/*
|
|
* Copyright 2023 jacqueline <me@jacqueline.id.au>
|
|
*
|
|
* SPDX-License-Identifier: GPL-3.0-only
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <future>
|
|
#include <memory>
|
|
#include <string>
|
|
|
|
#include "ff.h"
|
|
|
|
#include "audio_source.hpp"
|
|
#include "freertos/portmacro.h"
|
|
#include "future_fetcher.hpp"
|
|
#include "stream_info.hpp"
|
|
#include "tag_parser.hpp"
|
|
#include "types.hpp"
|
|
|
|
namespace audio {
|
|
|
|
/*
|
|
* Handles coordination with a persistent background task to asynchronously
|
|
* read files from disk into a StreamBuffer.
|
|
*/
|
|
class FileStreamer {
|
|
public:
|
|
FileStreamer(StreamBufferHandle_t dest, SemaphoreHandle_t first_read);
|
|
~FileStreamer();
|
|
|
|
/*
|
|
* Continues reading data into the destination buffer until the destination
|
|
* is full.
|
|
*/
|
|
auto Fetch() -> void;
|
|
|
|
/* Returns true if the streamer has run out of data from the current file. */
|
|
auto HasFinished() -> bool;
|
|
|
|
/*
|
|
* Clears any remaining buffered data, and begins reading again from the
|
|
* given file. This function respects any seeking/reading that has already
|
|
* been done on the new source file.
|
|
*/
|
|
auto Restart(std::unique_ptr<FIL>) -> void;
|
|
|
|
FileStreamer(const FileStreamer&) = delete;
|
|
FileStreamer& operator=(const FileStreamer&) = delete;
|
|
|
|
private:
|
|
// Note: private methods here should only be called from the streamer's task.
|
|
|
|
auto Main() -> void;
|
|
auto CloseFile() -> void;
|
|
|
|
enum Command {
|
|
kRestart,
|
|
kRefillBuffer,
|
|
kQuit,
|
|
};
|
|
QueueHandle_t control_;
|
|
StreamBufferHandle_t destination_;
|
|
SemaphoreHandle_t data_was_read_;
|
|
|
|
std::atomic<bool> has_data_;
|
|
std::unique_ptr<FIL> file_;
|
|
std::unique_ptr<FIL> next_file_;
|
|
};
|
|
|
|
/*
|
|
* Audio source that fetches data from a FatFs (or exfat i guess) filesystem.
|
|
*
|
|
* All public methods are safe to call from any task.
|
|
*/
|
|
class FatfsAudioInput : public IAudioSource {
|
|
public:
|
|
explicit FatfsAudioInput(std::shared_ptr<database::ITagParser> tag_parser);
|
|
~FatfsAudioInput();
|
|
|
|
/*
|
|
* Immediately cease reading any current source, and begin reading from the
|
|
* given file path.
|
|
*/
|
|
auto SetPath(std::future<std::optional<std::string>>) -> void;
|
|
auto SetPath(const std::string&) -> void;
|
|
auto SetPath() -> void;
|
|
|
|
auto Read(std::function<void(Flags, InputStream&)>, TickType_t)
|
|
-> void override;
|
|
|
|
FatfsAudioInput(const FatfsAudioInput&) = delete;
|
|
FatfsAudioInput& operator=(const FatfsAudioInput&) = delete;
|
|
|
|
private:
|
|
// Note: private methods assume that the appropriate locks have already been
|
|
// acquired.
|
|
|
|
auto OpenFile(const std::string& path) -> void;
|
|
auto CloseCurrentFile() -> void;
|
|
auto HasDataRemaining() -> bool;
|
|
|
|
auto ContainerToStreamType(database::Encoding)
|
|
-> std::optional<codecs::StreamType>;
|
|
auto IsCurrentFormatMp3() -> bool;
|
|
|
|
std::shared_ptr<database::ITagParser> tag_parser_;
|
|
|
|
// Semaphore used to block when this source is out of data. This should be
|
|
// acquired before attempting to read data, and returned after each incomplete
|
|
// read.
|
|
SemaphoreHandle_t has_data_;
|
|
|
|
StreamBufferHandle_t streamer_buffer_;
|
|
std::unique_ptr<FileStreamer> streamer_;
|
|
|
|
std::unique_ptr<RawStream> input_buffer_;
|
|
|
|
// Mutex guarding the current file/stream associated with this source. Must be
|
|
// held during readings, and before altering the current file.
|
|
std::mutex source_mutex_;
|
|
|
|
std::unique_ptr<database::FutureFetcher<std::optional<std::string>>>
|
|
pending_path_;
|
|
bool is_first_read_;
|
|
};
|
|
|
|
} // namespace audio
|
|
|