Git-Mirrors/portapack-mayhem
1
0
Fork 0
mirror of https://github.com/eried/portapack-mayhem.git synced 2025-08-11 08:00:31 -04:00
Code Issues Projects Releases Packages Wiki Activity

Playlist cleanup (#1163)

Browse source 
* Functional rewrite of playlist
This commit is contained in:
Kyle Reed 2023-06-17 13:01:46 -07:00 • committed by GitHub
parent 7f1c0f6f7e
commit 5743d3a3b9
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
9 changed files with 304 additions and 296 deletions
Download patch file Download diff file Expand all files Collapse all files

122
firmware/application/apps/ui_playlist.hpp
View file

@ -1,6 +1,7 @@
/*
* Copyright (C) 2016 Jared Boone, ShareBrained Technology, Inc.
* Copyright (C) 2016 Furrtek
* Copyright (C) 2023 Kyle Reed, zxkmm
*
* This file is part of PortaPack.
*
@ -34,20 +35,21 @@
#include <string>
#include <memory>
#include <deque>
#include <vector>
namespace ui {
class PlaylistView : public View {
public:
PlaylistView(NavigationView& nav);
~PlaylistView();
// Disable copy to make -Weffc++ happy.
PlaylistView(const PlaylistView&) = delete;
PlaylistView& operator=(const PlaylistView&) = delete;
void set_parent_rect(Rect new_parent_rect) override;
void on_hide() override;
void set_parent_rect(const Rect new_parent_rect) override;
void focus() override;
std::string title() const override { return "Playlist"; };
@ -58,75 +60,73 @@ class PlaylistView : public View {
app_settings::SettingsManager settings_{
"tx_playlist", app_settings::Mode::TX};
// add or remove lines here to allow more header and less spectrum view, & vice versa
// More header == less spectrum view.
static constexpr ui::Dim header_height = 4 * 16;
static constexpr uint32_t baseband_bandwidth = 2500000;
struct playlist_entry {
rf::Frequency replay_frequency{0};
std::string replay_file{};
std::filesystem::path replay_file{};
uint32_t sample_rate{};
uint32_t next_delay{};
uint32_t initial_delay{};
};
std::deque<playlist_entry> playlist_db{};
std::deque<playlist_entry> playlist_masterdb{};
uint32_t sample_rate = 0;
int32_t tx_gain{47};
bool rf_amp{true}; // aux private var to store temporal, Replay App rf_amp user selection.
static constexpr uint32_t baseband_bandwidth = 2500000;
const size_t read_size{16384};
const size_t buffer_count{3};
void load_file(std::filesystem::path playlist_path);
void on_file_changed(std::filesystem::path new_file_path, rf::Frequency replay_frequency, uint32_t replay_sample_rate, uint32_t next_delay);
void on_tx_progress(const uint32_t progress);
void set_target_frequency(const rf::Frequency new_value);
rf::Frequency target_frequency() const;
void toggle();
void start();
void stop(const bool do_loop);
std::unique_ptr<ReplayThread> replay_thread_{};
bool ready_signal_{}; // Used to signal the ReplayThread.
size_t current_track_{0};
const playlist_entry* current_entry_{};
size_t current_entry_size_{0};
std::vector<playlist_entry> playlist_db_{};
std::filesystem::path playlist_path_{};
void load_file(const std::filesystem::path& path);
void on_file_changed(const std::filesystem::path& path);
void reset();
void show_file_error(
const std::filesystem::path& path,
const std::string& message);
bool is_active() const;
bool loop() const;
void set_ready();
void handle_replay_thread_done(const uint32_t return_code);
void file_error(std::string error_message);
void clean_playlist();
bool is_done() const;
std::filesystem::path file_path{};
std::unique_ptr<ReplayThread> replay_thread{};
bool ready_signal{false};
size_t track_number{0};
size_t total_tracks{0};
uint32_t now_delay{0};
std::filesystem::path now_play_list_file{};
void toggle();
void start();
bool next_track();
void send_current_track();
void stop();
void update_ui();
/* There are called by Message handlers. */
void on_tx_progress(uint32_t progress);
void handle_replay_thread_done(uint32_t return_code);
Button button_open{
{0 * 8, 0 * 16, 10 * 8, 2 * 16},
"Open file"};
"Open PPL"};
Text text_filename{
{11 * 8, 0 * 16, 12 * 8, 16},
"-"};
{11 * 8, 0 * 16, 12 * 8, 16}};
Text text_sample_rate{
{24 * 8, 0 * 16, 6 * 8, 16},
"-"};
{24 * 8, 0 * 16, 6 * 8, 16}};
Text text_duration{
{11 * 8, 1 * 16, 6 * 8, 16},
"-"};
ProgressBar tracks_progressbar{
{11 * 8, 1 * 16, 6 * 8, 16}};
ProgressBar progressbar_track{
{18 * 8, 1 * 16, 12 * 8, 8}};
ProgressBar on_track_progressbar{
ProgressBar progressbar_transmit{
{18 * 8, 3 * 8, 12 * 8, 8}};
FrequencyField field_frequency{
{0 * 8, 2 * 16},
};
Text text_frequency{
{0 * 8, 2 * 16, 9 * 8, 16}};
TransmitterView2 tx_view{
// new handling of NumberField field_rfgain, NumberField field_rfamp
74, 1 * 8, SHORT_UI // x(columns), y (line) position. (Used in Repay / GPS Simul / Play list App)
// 10*8, 2*8, NORMAL_UI // x(columns), y (line) position. (Used in Mic App)
74, 1 * 8, SHORT_UI // x(columns), y (line) position.
};
Checkbox check_loop{
@ -134,6 +134,7 @@ class PlaylistView : public View {
4,
"Loop",
true};
ImageButton button_play{
{28 * 8, 2 * 16, 2 * 8, 1 * 16},
&bitmap_play,
@ -141,32 +142,31 @@ class PlaylistView : public View {
Color::black()};
Text text_track{
{0 * 8, 3 * 16, 16 * 8, 16},
"0/0 no input playlist file"};
{0 * 8, 3 * 16, 30 * 8, 16}};
spectrum::WaterfallWidget waterfall{};
MessageHandlerRegistration message_handler_replay_thread_error{
Message::ID::ReplayThreadDone,
[this](const Message* const p) {
const auto message = *reinterpret_cast<const ReplayThreadDoneMessage*>(p);
this->handle_replay_thread_done(message.return_code);
[this](const Message* p) {
auto message = *reinterpret_cast<const ReplayThreadDoneMessage*>(p);
handle_replay_thread_done(message.return_code);
}};
MessageHandlerRegistration message_handler_fifo_signal{
Message::ID::RequestSignal,
[this](const Message* const p) {
const auto message = static_cast<const RequestSignalMessage*>(p);
[this](const Message* p) {
auto message = static_cast<const RequestSignalMessage*>(p);
if (message->signal == RequestSignalMessage::Signal::FillRequest) {
this->set_ready();
ready_signal_ = true;
}
}};
MessageHandlerRegistration message_handler_tx_progress{
Message::ID::TXProgress,
[this](const Message* const p) {
const auto message = *reinterpret_cast<const TXProgressMessage*>(p);
this->on_tx_progress(message.progress);
[this](const Message* p) {
auto message = *reinterpret_cast<const TXProgressMessage*>(p);
on_tx_progress(message.progress);
}};
};