RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-18 14:05:06 +00:00
Code Issues Activity Actions
serenity/Userland/Applications/SoundPlayer/SoundPlayerWidgetAdvancedView.cpp
sin-ack ca2c81251a Everywhere: Replace Model::update() with Model::invalidate() 
Most of the models were just calling did_update anyway, which is
pointless since it can be unified to the base Model class. Instead, code
calling update() will now call invalidate(), which functions identically
and is more obvious in what it does.

Additionally, a default implementation is provided, which removes the
need to add empty implementations of update() for each model subclass.

Co-Authored-By: Ali Mohammad Pur <ali.mpfard@gmail.com>
2021-08-06 19:14:31 +02:00

320 lines
12 KiB
C++
Raw Blame History

/*
* Copyright (c) 2021, Cesar Torres <shortanemoia@protonmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include "SoundPlayerWidgetAdvancedView.h"
#include "BarsVisualizationWidget.h"
#include "Common.h"
#include "M3UParser.h"
#include "PlaybackManager.h"
#include <AK/LexicalPath.h>
#include <AK/SIMD.h>
#include <LibGUI/Action.h>
#include <LibGUI/BoxLayout.h>
#include <LibGUI/Button.h>
#include <LibGUI/Label.h>
#include <LibGUI/MessageBox.h>
#include <LibGUI/Slider.h>
#include <LibGUI/Splitter.h>
#include <LibGUI/Toolbar.h>
#include <LibGUI/ToolbarContainer.h>
#include <LibGUI/Window.h>
#include <LibGfx/Bitmap.h>
SoundPlayerWidgetAdvancedView::SoundPlayerWidgetAdvancedView(GUI::Window& window, PlayerState& state)
: Player(state)
, m_window(window)
{
window.resize(455, 350);
window.set_minimum_size(600, 130);
window.set_resizable(true);
set_fill_with_background_color(true);
set_layout<GUI::VerticalBoxLayout>();
m_splitter = add<GUI::HorizontalSplitter>();
m_player_view = m_splitter->add<GUI::Widget>();
m_playlist_model = adopt_ref(*new PlaylistModel());
m_player_view->set_layout<GUI::VerticalBoxLayout>();
m_play_icon = Gfx::Bitmap::try_load_from_file("/res/icons/16x16/play.png");
m_pause_icon = Gfx::Bitmap::try_load_from_file("/res/icons/16x16/pause.png");
m_stop_icon = Gfx::Bitmap::try_load_from_file("/res/icons/16x16/stop.png");
m_back_icon = Gfx::Bitmap::try_load_from_file("/res/icons/16x16/go-back.png");
m_next_icon = Gfx::Bitmap::try_load_from_file("/res/icons/16x16/go-forward.png");
m_visualization = m_player_view->add<BarsVisualizationWidget>();
// Set a temporary value for total samples.
// This value will be set properly when we load a new file.
const int total_samples = this->manager().total_length() * this->manager().device_sample_rate();
m_playback_progress_slider = m_player_view->add<AutoSlider>(Orientation::Horizontal);
m_playback_progress_slider->set_fixed_height(20);
m_playback_progress_slider->set_jump_to_cursor(true);
m_playback_progress_slider->set_min(0);
m_playback_progress_slider->set_max(total_samples);
m_playback_progress_slider->set_page_step(total_samples / 10);
m_playback_progress_slider->on_knob_released = [&](int value) {
this->manager().seek(value);
};
auto& toolbar_container = m_player_view->add<GUI::ToolbarContainer>();
auto& menubar = toolbar_container.add<GUI::Toolbar>();
m_play_button = menubar.add<GUI::Button>();
m_play_button->set_icon(is_paused() ? (!has_loaded_file() ? *m_play_icon : *m_pause_icon) : *m_pause_icon);
m_play_button->set_fixed_width(50);
m_play_button->set_enabled(has_loaded_file());
m_play_button->on_click = [&](unsigned) {
bool paused = this->manager().toggle_pause();
set_paused(paused);
m_play_button->set_icon(paused ? *m_play_icon : *m_pause_icon);
m_stop_button->set_enabled(has_loaded_file());
};
m_stop_button = menubar.add<GUI::Button>();
m_stop_button->set_icon(*m_stop_icon);
m_stop_button->set_fixed_width(50);
m_stop_button->set_enabled(has_loaded_file());
m_stop_button->on_click = [&](unsigned) {
this->manager().stop();
set_stopped(true);
m_play_button->set_icon(*m_play_icon);
m_stop_button->set_enabled(false);
};
auto& timestamp_label = menubar.add<GUI::Label>();
timestamp_label.set_fixed_width(110);
timestamp_label.set_text("Elapsed: 00:00:00");
// filler_label
menubar.add<GUI::Label>();
m_back_button = menubar.add<GUI::Button>();
m_back_button->set_fixed_width(50);
m_back_button->set_icon(*m_back_icon);
m_back_button->set_enabled(has_loaded_file());
m_back_button->on_click = [&](unsigned) {
if (!m_playlist_model.is_null()) {
auto it = m_playlist_model->items().find_if([&](const M3UEntry& e) { return e.path == loaded_filename(); });
if (it.index() == 0) {
open_file(m_playlist_model->items().at(m_playlist_model->items().size() - 1).path);
} else
open_file((it - 1)->path);
play();
}
};
m_next_button = menubar.add<GUI::Button>();
m_next_button->set_fixed_width(50);
m_next_button->set_icon(*m_next_icon);
m_next_button->set_enabled(has_loaded_file());
m_next_button->on_click = [&](unsigned) {
if (!m_playlist_model.is_null()) {
auto it = m_playlist_model->items().find_if([&](const M3UEntry& e) { return e.path == loaded_filename(); });
if (it.index() + 1 == m_playlist_model->items().size()) {
open_file(m_playlist_model->items().at(0).path);
} else
open_file((it + 1)->path);
play();
}
};
m_volume_label = &menubar.add<GUI::Label>();
m_volume_label->set_fixed_width(30);
m_volume_label->set_text("100%");
auto& volume_slider = menubar.add<GUI::HorizontalSlider>();
volume_slider.set_fixed_width(95);
volume_slider.set_min(0);
volume_slider.set_max(150);
volume_slider.set_value(100);
volume_slider.on_change = [&](int value) {
double volume = m_nonlinear_volume_slider ? (double)(value * value) / (100 * 100) : value / 100.;
m_volume_label->set_text(String::formatted("{}%", (int)(volume * 100)));
set_volume(volume);
};
set_volume(1.);
set_nonlinear_volume_slider(false);
manager().on_update = [&]() {
// Determine how many of the source file samples have played.
int samples_played = client_connection().get_played_samples();
float source_to_dest_ratio = static_cast<float>(loaded_file_samplerate()) / manager().device_sample_rate();
samples_played *= source_to_dest_ratio;
samples_played += this->manager().last_seek();
int current_second = samples_played / loaded_file_samplerate();
timestamp_label.set_text(String::formatted("Elapsed: {:02}:{:02}:{:02}", current_second / 3600, current_second / 60, current_second % 60));
if (!m_playback_progress_slider->mouse_is_down()) {
m_playback_progress_slider->set_value(samples_played);
}
dynamic_cast<Visualization*>(m_visualization.ptr())->set_buffer(this->manager().current_buffer());
dynamic_cast<Visualization*>(m_visualization.ptr())->set_samplerate(manager().device_sample_rate());
};
manager().on_load_sample_buffer = [&](Audio::Buffer&) {
//TODO: Implement an equalizer
return;
};
manager().on_finished_playing = [&] {
m_play_button->set_icon(*m_play_icon);
if (looping()) {
open_file(loaded_filename());
return;
}
if (!m_playlist_model.is_null() && !m_playlist_model->items().is_empty()) {
auto it = m_playlist_model->items().find_if([&](const M3UEntry& e) { return e.path == loaded_filename(); });
if (it.index() + 1 == m_playlist_model->items().size()) {
if (looping_playlist()) {
open_file(m_playlist_model->items().at(0).path);
return;
}
} else
open_file((it + 1)->path);
}
m_stop_button->set_enabled(false);
};
}
void SoundPlayerWidgetAdvancedView::open_file(StringView path)
{
if (!Core::File::exists(path)) {
GUI::MessageBox::show(window(), String::formatted("File \"{}\" does not exist", path), "Error opening file", GUI::MessageBox::Type::Error);
return;
}
if (path.ends_with(".m3u", AK::CaseSensitivity::CaseInsensitive) || path.ends_with(".m3u8", AK::CaseSensitivity::CaseInsensitive)) {
read_playlist(path);
return;
}
NonnullRefPtr<Audio::Loader> loader = Audio::Loader::create(path);
if (loader->has_error() || !loader->sample_rate()) {
const String error_string = loader->error_string();
GUI::MessageBox::show(&m_window, String::formatted("Failed to load audio file: {} ({})", path, error_string.is_null() ? "Unknown error" : error_string),
"Filetype error", GUI::MessageBox::Type::Error);
return;
}
m_window.set_title(String::formatted("{} - Sound Player", loader->file()->filename()));
m_playback_progress_slider->set_max(loader->total_samples());
m_playback_progress_slider->set_page_step(loader->total_samples() / 10);
m_playback_progress_slider->set_enabled(true);
m_play_button->set_enabled(true);
m_play_button->set_icon(*m_pause_icon);
m_stop_button->set_enabled(true);
manager().set_loader(move(loader));
set_has_loaded_file(true);
set_loaded_file_samplerate(loader->sample_rate());
set_loaded_filename(path);
play();
}
void SoundPlayerWidgetAdvancedView::set_nonlinear_volume_slider(bool nonlinear)
{
m_nonlinear_volume_slider = nonlinear;
}
void SoundPlayerWidgetAdvancedView::drop_event(GUI::DropEvent& event)
{
event.accept();
if (event.mime_data().has_urls()) {
auto urls = event.mime_data().urls();
if (urls.is_empty())
return;
window()->move_to_front();
open_file(urls.first().path());
}
}
SoundPlayerWidgetAdvancedView::~SoundPlayerWidgetAdvancedView()
{
manager().on_load_sample_buffer = nullptr;
manager().on_update = nullptr;
}
void SoundPlayerWidgetAdvancedView::play()
{
manager().play();
set_paused(false);
set_stopped(false);
}
void SoundPlayerWidgetAdvancedView::read_playlist(StringView path)
{
auto parser = M3UParser::from_file(path);
auto items = parser->parse(true);
VERIFY(items->size() > 0);
try_fill_missing_info(*items, path);
for (auto& item : *items)
m_playlist_model->items().append(item);
set_playlist_visible(true);
m_playlist_model->invalidate();
open_file(items->at(0).path);
if (items->size() > 1) {
m_back_button->set_enabled(true);
m_next_button->set_enabled(true);
} else {
m_back_button->set_enabled(false);
m_next_button->set_enabled(false);
}
}
void SoundPlayerWidgetAdvancedView::set_playlist_visible(bool visible)
{
if (visible) {
m_playlist_widget = m_player_view->parent_widget()->add<PlaylistWidget>();
m_playlist_widget->set_data_model(m_playlist_model);
m_playlist_widget->set_fixed_width(150);
} else {
m_playlist_widget->remove_from_parent();
m_player_view->set_max_width(window()->width());
}
}
void SoundPlayerWidgetAdvancedView::try_fill_missing_info(Vector<M3UEntry>& entries, StringView playlist_p)
{
LexicalPath playlist_path(playlist_p);
Vector<M3UEntry*> to_delete;
for (auto& entry : entries) {
if (!LexicalPath(entry.path).is_absolute()) {
entry.path = String::formatted("{}/{}", playlist_path.dirname(), entry.path);
}
if (!Core::File::exists(entry.path)) {
GUI::MessageBox::show(window(), String::formatted("The file \"{}\" present in the playlist does not exist or was not found. This file will be ignored.", entry.path), "Error reading playlist", GUI::MessageBox::Type::Warning);
to_delete.append(&entry);
continue;
}
if (!entry.extended_info->track_display_title.has_value())
entry.extended_info->track_display_title = LexicalPath::title(entry.path);
if (!entry.extended_info->track_length_in_seconds.has_value()) {
if (auto reader = Audio::Loader::create(entry.path); !reader->has_error())
entry.extended_info->track_length_in_seconds = reader->total_samples() / reader->sample_rate();
//TODO: Implement embedded metadata extractor for other audio formats
}
//TODO: Implement a metadata parser for the uncomfortably numerous popular embedded metadata formats
if (!entry.extended_info->file_size_in_bytes.has_value()) {
FILE* f = fopen(entry.path.characters(), "r");
VERIFY(f != nullptr);
fseek(f, 0, SEEK_END);
entry.extended_info->file_size_in_bytes = ftell(f);
fclose(f);
}
}
for (M3UEntry* entry : to_delete)
entries.remove_first_matching([&](M3UEntry& e) { return &e == entry; });
}
Reference in a new issue View git blame Copy permalink