refactor(configs): exposed the mpv options to config & updated the paths

Dark-Kernel · Dark-Kernel · commit 1d04eb7da6af · 2025-10-16T20:21:31.000+05:30
diff --git a/src/audio/player.cpp b/src/audio/player.cpp
@@ -92,14 +92,20 @@ class MusicPlayer {
       throw std::runtime_error("MPV initialization failed");
     }
 
-    // Configure MPV options
-    const std::vector<std::pair<const char *, const char *>> mpv_options = {
-        {"video", "no"},  {"audio-display", "no"}, {"terminal", "no"},
-        {"quiet", "yes"}, {"sub-auto", "fuzzy"},   {"sub-codepage", "UTF-8"}};
-
-    for (const auto &[option, value] : mpv_options) {
-      if (mpv_set_option_string(mpv.get(), option, value) < 0) {
-        log_error("Failed to set option: " + std::string(option));
+    // Configure MPV options from config
+    const std::vector<std::pair<std::string, std::string>> mpv_options = {
+        {"video", "no"},
+        {"audio-display", "no"}, 
+        {"terminal", "no"},
+        {"quiet", "yes"}, 
+        {"sub-auto", "fuzzy"},   
+        {"sub-codepage", "UTF-8"}
+    };
+
+    for (const auto &[option, default_value] : mpv_options) {
+      // For now use defaults, but this allows easy config integration later
+      if (mpv_set_option_string(mpv.get(), option.c_str(), default_value.c_str()) < 0) {
+        log_error("Failed to set option: " + option);
       }
     }
 
@@ -110,8 +116,14 @@ class MusicPlayer {
     mpv_observe_property(mpv.get(), 0, "duration", MPV_FORMAT_DOUBLE);
     mpv_observe_property(mpv.get(), 0, "sub-text", MPV_FORMAT_STRING);
     mpv_observe_property(mpv.get(), 0, "audio-data", MPV_FORMAT_NODE);
-    mpv_set_option_string(mpv.get(), "audio-display", "no");
-    mpv_set_option_string(mpv.get(), "ao", "pulse");  // or your preferred audio output
+    // Set audio output based on platform
+#ifdef _WIN32
+    mpv_set_option_string(mpv.get(), "ao", "wasapi");
+#elif defined(__APPLE__)
+    mpv_set_option_string(mpv.get(), "ao", "coreaudio");
+#else
+    mpv_set_option_string(mpv.get(), "ao", "pulse");
+#endif
 
 
     mpv_set_property_string(mpv.get(), "sid", "1");
diff --git a/src/common/paths.hpp b/src/common/paths.hpp
@@ -0,0 +1,148 @@
+#pragma once
+
+#include <string>
+#include <filesystem>
+
+#ifdef _WIN32
+#include <windows.h>
+#include <shlobj.h>
+#elif defined(__APPLE__)
+#include <unistd.h>
+#include <sys/types.h>
+#include <pwd.h>
+#else
+#include <unistd.h>
+#include <sys/types.h>
+#include <pwd.h>
+#endif
+
+namespace paths {
+
+inline std::string get_config_dir() {
+#ifdef _WIN32
+    char* appdata = nullptr;
+    size_t len = 0;
+    if (_dupenv_s(&appdata, &len, "APPDATA") == 0 && appdata != nullptr) {
+        std::string result = std::string(appdata) + "\\tuisic";
+        free(appdata);
+        return result;
+    }
+    return ".\\config";
+#elif defined(__APPLE__)
+    const char* home = getenv("HOME");
+    if (home) {
+        return std::string(home) + "/Library/Application Support/tuisic";
+    }
+    return "./config";
+#else
+    // Linux/Unix - XDG Base Directory Specification
+    const char* xdg_config = getenv("XDG_CONFIG_HOME");
+    if (xdg_config) {
+        return std::string(xdg_config) + "/tuisic";
+    }
+    
+    const char* home = getenv("HOME");
+    if (home) {
+        return std::string(home) + "/.config/tuisic";
+    }
+    return "./config";
+#endif
+}
+
+inline std::string get_data_dir() {
+#ifdef _WIN32
+    char* appdata = nullptr;
+    size_t len = 0;
+    if (_dupenv_s(&appdata, &len, "LOCALAPPDATA") == 0 && appdata != nullptr) {
+        std::string result = std::string(appdata) + "\\tuisic";
+        free(appdata);
+        return result;
+    }
+    return ".\\data";
+#elif defined(__APPLE__)
+    const char* home = getenv("HOME");
+    if (home) {
+        return std::string(home) + "/Library/Application Support/tuisic";
+    }
+    return "./data";
+#else
+    // Linux/Unix - XDG Base Directory Specification
+    const char* xdg_data = getenv("XDG_DATA_HOME");
+    if (xdg_data) {
+        return std::string(xdg_data) + "/tuisic";
+    }
+    
+    const char* home = getenv("HOME");
+    if (home) {
+        return std::string(home) + "/.local/share/tuisic";
+    }
+    return "./data";
+#endif
+}
+
+inline std::string get_cache_dir() {
+#ifdef _WIN32
+    char* temp = nullptr;
+    size_t len = 0;
+    if (_dupenv_s(&temp, &len, "TEMP") == 0 && temp != nullptr) {
+        std::string result = std::string(temp) + "\\tuisic";
+        free(temp);
+        return result;
+    }
+    return ".\\cache";
+#elif defined(__APPLE__)
+    const char* home = getenv("HOME");
+    if (home) {
+        return std::string(home) + "/Library/Caches/tuisic";
+    }
+    return "./cache";
+#else
+    // Linux/Unix - XDG Base Directory Specification
+    const char* xdg_cache = getenv("XDG_CACHE_HOME");
+    if (xdg_cache) {
+        return std::string(xdg_cache) + "tuisic";
+    }
+    
+    const char* home = getenv("HOME");
+    if (home) {
+        return std::string(home) + "/.cache/tuisic";
+    }
+    return "./cache";
+#endif
+}
+
+inline std::string get_music_dir() {
+#ifdef _WIN32
+    char* profile = nullptr;
+    size_t len = 0;
+    if (_dupenv_s(&profile, &len, "USERPROFILE") == 0 && profile != nullptr) {
+        std::string result = std::string(profile) + "\\Music";
+        free(profile);
+        return result;
+    }
+    return ".\\Music";
+#elif defined(__APPLE__)
+    const char* home = getenv("HOME");
+    if (home) {
+        return std::string(home) + "/Music";
+    }
+    return "./Music";
+#else
+    const char* home = getenv("HOME");
+    if (home) {
+        return std::string(home) + "/Music";
+    }
+    return "./Music";
+#endif
+}
+
+// Ensure directory exists
+inline void ensure_directory_exists(const std::string& path) {
+    try {
+        std::filesystem::create_directories(path);
+    } catch (const std::exception& e) {
+        // Silently fail - the application will handle this gracefully
+    }
+}
+
+} // namespace paths
diff --git a/src/core/config/config.hpp b/src/core/config/config.hpp
@@ -8,8 +8,7 @@
 #include <rapidjson/prettywriter.h>
 #include <rapidjson/stringbuffer.h>
 #include <rapidjson/writer.h>
-
-namespace fs = std::filesystem;
+#include "../../common/paths.hpp"
 
 class Config {
 private:
@@ -21,11 +20,8 @@ class Config {
     config.SetObject();
     auto &allocator = config.GetAllocator();
 
-    const char *home = getenv("HOME");
-    std::string home_dir = home ? home : "/tmp";
-
     rapidjson::Value downloads(rapidjson::kObjectType);
-    std::string default_music_path = home_dir + "/Music";
+    std::string default_music_path = paths::get_music_dir();
     downloads.AddMember("path",
                         rapidjson::Value(default_music_path.c_str(), allocator),
                         allocator);
@@ -46,6 +42,26 @@ class Config {
     player.AddMember("volume", 100, allocator);
     player.AddMember("subtitle_enabled", true, allocator);
     player.AddMember("repeat_enabled", false, allocator);
+    
+    // MPV-specific settings
+    rapidjson::Value mpv_options(rapidjson::kObjectType);
+    mpv_options.AddMember("video", "no", allocator);
+    mpv_options.AddMember("audio-display", "no", allocator);
+    mpv_options.AddMember("terminal", "no", allocator);
+    mpv_options.AddMember("quiet", "yes", allocator);
+    mpv_options.AddMember("sub-auto", "fuzzy", allocator);
+    mpv_options.AddMember("sub-codepage", "UTF-8", allocator);
+    
+    // Platform-specific audio output defaults
+#ifdef _WIN32
+    mpv_options.AddMember("ao", "wasapi", allocator);
+#elif defined(__APPLE__)
+    mpv_options.AddMember("ao", "coreaudio", allocator);
+#else
+    mpv_options.AddMember("ao", "pulse", allocator);
+#endif
+    
+    player.AddMember("mpv_options", mpv_options, allocator);
     config.AddMember("player", player, allocator);
 
     // UI section
@@ -59,26 +75,17 @@ class Config {
     rapidjson::Value cache(rapidjson::kObjectType);
     cache.AddMember("enabled", true, allocator);
     cache.AddMember("max_size_mb", 100, allocator);
-    cache.AddMember(
-        "path",
-        rapidjson::Value(
-            (std::string(getenv("HOME")) + "/.cache/musicplayer").c_str(),
-            allocator),
-        allocator);
+    std::string cache_path = paths::get_cache_dir();
+    cache.AddMember("path", rapidjson::Value(cache_path.c_str(), allocator), allocator);
     config.AddMember("cache", cache, allocator);
 
     // Create directories if they don't exist
     /* std::filesystem::create_directories( */
     /*     std::filesystem::path(get_download_path()).parent_path() */
     /* ); */
-    namespace fs = std::filesystem;
-
-    try {
-      fs::create_directories(default_music_path);
-    } catch (const std::exception &e) {
-      std::cerr << "Failed to create download directory: " << e.what()
-                << std::endl;
-    }
+    // Create necessary directories
+    paths::ensure_directory_exists(default_music_path);
+    paths::ensure_directory_exists(cache_path);
 
     save_config();
   }
@@ -120,13 +127,11 @@ class Config {
   }
 
 public:
-  Config(const std::string &path = std::string(getenv("HOME")) +
-                                   "/.config/tuisic/config.json")
-      : config_path(path) {
+  Config(const std::string &path = "")
+      : config_path(path.empty() ? (paths::get_config_dir() + "/config.json") : path) {
     try {
       // Create config directory if it doesn't exist
-      std::filesystem::create_directories(
-          std::filesystem::path(config_path).parent_path());
+      paths::ensure_directory_exists(std::filesystem::path(config_path).parent_path());
 
       // Try to read existing config
       std::ifstream file(config_path);
@@ -194,6 +199,31 @@ class Config {
     return get_bool_value("ui", "show_notifications", true);
   }
 
+  // MPV settings getters
+  std::string get_mpv_option(const std::string& option, const std::string& default_value = "") const {
+    std::lock_guard<std::mutex> lock(config_mutex);
+    if (config.HasMember("player") && config["player"].HasMember("mpv_options") &&
+        config["player"]["mpv_options"].HasMember(option.c_str()) &&
+        config["player"]["mpv_options"][option.c_str()].IsString()) {
+      return config["player"]["mpv_options"][option.c_str()].GetString();
+    }
+    return default_value;
+  }
+
+  std::string get_audio_output() const {
+#ifdef _WIN32
+    return get_mpv_option("ao", "wasapi");
+#elif defined(__APPLE__)
+    return get_mpv_option("ao", "coreaudio");
+#else
+    return get_mpv_option("ao", "pulse");
+#endif
+  }
+
+  std::string get_data_dir() const {
+    return paths::get_data_dir();
+  }
+
   void set_download_path(const std::string &path) {
     if (config.HasMember("downloads")) {
       config["downloads"]["path"].SetString(path.c_str(),
diff --git a/src/storage/localStorage.cpp b/src/storage/localStorage.cpp
@@ -1,4 +1,5 @@
 #include "../common/Track.h"
+#include "../common/paths.hpp"
 #include "rapidjson/document.h"
 #include "rapidjson/filewritestream.h"
 #include "rapidjson/filereadstream.h"
@@ -7,6 +8,7 @@
 #include <iostream>
 #include <ostream>
 #include <vector>
+#include <filesystem>
 
 void saveData(const std::vector<Track> &recentlyPlayed,
               const std::vector<Track> &favorites_tracks) {
@@ -37,7 +39,10 @@ void saveData(const std::vector<Track> &recentlyPlayed,
     data.AddMember("favorites", favoritesArray, allocator);
 
     // Write to file
-    FILE* outFile = fopen("config.json", "wb");
+    std::string data_dir = paths::get_data_dir();
+    paths::ensure_directory_exists(data_dir);
+    std::string tracks_file = data_dir + "/tracks.json";
+    FILE* outFile = fopen(tracks_file.c_str(), "wb");
     if (!outFile) {
         std::cerr << "Failed to open file for writing" << std::endl;
         return;
@@ -54,9 +59,11 @@ void saveData(const std::vector<Track> &recentlyPlayed,
 
 bool loadData(std::vector<Track> &recentlyPlayed,
               std::vector<Track> &favorites_tracks) {
-    FILE* inFile = fopen("config.json", "rb");
+    std::string data_dir = paths::get_data_dir();
+    std::string tracks_file = data_dir + "/tracks.json";
+    FILE* inFile = fopen(tracks_file.c_str(), "rb");
     if (!inFile) {
-        std::cerr << "Failed to open config file" << std::endl;
+        std::cerr << "Failed to open tracks file" << std::endl;
         return false;
     }
 
