[MIN] ALPHA 2.1

Author: nots1dd

CHANGELOG.md

@@ -673,3 +673,26 @@ Small commit that adds a new dependency and a greatly needed feature of caching
 - Centering of the image_view
 
 ---
+
+## [ALPHA 2.1] --- 17-01-2025
+
+### Added
+- Added `src/arg-handler.hpp` and modified bash completions
+
+### Changed
+- Command line arguments setup with subsequent changes to `src/cmg-line-args.hpp` and `main.cpp`
+
+### Fixed
+- Issue with flac file thumbnail extraction
+
+### Removed
+**NIL**
+
+Small commit with some issues + cmd line args setup
+
+### Known Issues to fix in immediate commits
+- Runtime errors with respect to `PlayCurrentSong()` that may be due to detaching the audio thread
+
+- Centering of the image_view
+
+---

assets/completions/inLimbo-completions.bash

@@ -1,27 +1,17 @@
-# A very primitive and basic completion system for inLimbo for bash
+#!/bin/bash
 
 _inLimbo_completions() {
     local cur prev opts
-
-    # Get the current word being typed
+    COMPREPLY=()
     cur="${COMP_WORDS[COMP_CWORD]}"
     prev="${COMP_WORDS[COMP_CWORD-1]}"
+    opts="--help --version --clear-cache --show-config-file --show-log-dir --show-dbus-name"
 
-    # List of options for the music player
-    opts="--play --pause --stop --next --prev --shuffle --repeat --volume --help"
-
-    # If the previous word is an option, suggest further options
-    if [[ "$cur" == -* ]]; then
-        COMPREPLY=($(compgen -W "$opts" -- "$cur"))
-        return 0
-    fi
-
-    # If the previous word is a command that expects a file path, suggest file paths
-    if [[ "$prev" == "--play" || "$prev" == "--next" || "$prev" == "--prev" ]]; then
-        COMPREPLY=($(compgen -f -- "$cur"))
+    # Provide completion for options
+    if [[ ${cur} == -* ]]; then
+        COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
         return 0
     fi
 }
 
-# Attach the completion function to inLimbo
 complete -F _inLimbo_completions inLimbo

src/arg-handler.hpp

@@ -0,0 +1,89 @@
+#ifndef ARGUMENT_HANDLER_HPP
+#define ARGUMENT_HANDLER_HPP
+
+#include "./cmd-line-args.hpp"
+#include <iostream>
+#include <stdexcept>
+#include <filesystem>
+
+#define DBUS_SERVICE_NAME "org.mpris.MediaPlayer2.inLimbo"
+
+// ANSI color codes for output
+#define COLOR_RESET "\033[0m"
+#define COLOR_GREEN "\033[32m"
+#define COLOR_BLUE "\033[34m"
+#define COLOR_YELLOW "\033[33m"
+#define COLOR_RED "\033[31m"
+#define COLOR_CYAN "\033[36m"
+#define COLOR_MAGENTA "\033[35m"
+
+class ArgumentHandler
+{
+public:
+    static void handleArguments(const CommandLineArgs& cmdArgs, const std::string& programName, const std::string& configPath, const std::string& libBinPath, const std::string& cacheDir)
+    {
+        if (cmdArgs.hasFlag("--help"))
+        {
+            printUsage(cmdArgs, programName);
+            exit(0);
+        }
+
+        if (cmdArgs.hasFlag("--version"))
+        {
+            std::cout << COLOR_CYAN << "inLimbo version: ALPHA 2.0" << COLOR_RESET << "\n";
+            exit(0);
+        }
+
+        if (cmdArgs.hasFlag("--clear-cache"))
+        {
+            clearCache(libBinPath);
+            exit(0);
+        }
+
+        if (cmdArgs.hasFlag("--show-config-file"))
+        {
+            std::cout << COLOR_GREEN << "Config file location: " << COLOR_RESET << configPath << "\n";
+            exit(0);
+        }
+
+        if (cmdArgs.hasFlag("--show-log-dir"))
+        {
+            std::cout << COLOR_BLUE << "Log directory: " << COLOR_RESET << cacheDir << "\n";
+            exit(0);
+        }
+
+        if (cmdArgs.hasFlag("--show-dbus-name"))
+        {
+            std::cout << COLOR_MAGENTA << "DBus name: " << COLOR_RESET << DBUS_SERVICE_NAME << "\n";
+            exit(0);
+        }
+    }
+
+private:
+    static void printUsage(const CommandLineArgs& cmdArgs, const std::string& programName)
+    {
+        cmdArgs.printUsage(programName);
+    }
+
+    static void clearCache(const std::string& libBinPath)
+    {
+        try
+        {
+            if (std::filesystem::exists(libBinPath))
+            {
+                std::filesystem::remove(libBinPath);
+                std::cout << COLOR_GREEN << "Cache cleared successfully: " << COLOR_RESET << libBinPath << "\n";
+            }
+            else
+            {
+                std::cout << COLOR_YELLOW << "No cache file found to clear: " << COLOR_RESET << libBinPath << "\n";
+            }
+        }
+        catch (const std::filesystem::filesystem_error& e)
+        {
+            std::cerr << COLOR_RED << "Error clearing cache: " << COLOR_RESET << e.what() << "\n";
+        }
+    }
+};
+
+#endif // ARGUMENT_HANDLER_HPP

src/cmd-line-args.hpp

@@ -6,17 +6,18 @@
 #include <string>
 #include <vector>
 #include <stdexcept>
+#include <algorithm>
 
 class CommandLineArgs
 {
 private:
     std::map<std::string, std::string> args;   // flag-value pairs
-    std::vector<std::string> positionalArgs;  // pos args
-    std::vector<std::string> validFlags;      // Valid flags for error checking
+    std::vector<std::string> positionalArgs;  // positional arguments
 
 public:
-    CommandLineArgs(int argc, char* argv[], const std::vector<std::string>& allowedFlags = {})
-        : validFlags(allowedFlags)
+    static const std::vector<std::string> validFlags; // Valid flags
+
+    CommandLineArgs(int argc, char* argv[])
     {
         parseArgs(argc, argv);
     }
@@ -43,7 +44,8 @@ class CommandLineArgs
 
     void printUsage(const std::string& programName) const
     {
-        std::cerr << "Usage: " << programName << " [options] [positional arguments]\n";
+        std::cerr << "Music player that keeps you in Limbo.\n";
+        std::cerr << "Usage: " << programName << " [options] [positional arguments]\n\n";
         if (!validFlags.empty())
         {
             std::cerr << "Valid options:\n";
@@ -72,8 +74,8 @@ class CommandLineArgs
                     value = argv[++i]; // Consume the next argument as the value
                 }
 
-                // Validate the flag if a list of valid flags is provided
-                if (!validFlags.empty() && std::find(validFlags.begin(), validFlags.end(), flag) == validFlags.end())
+                // Validate the flag
+                if (std::find(validFlags.begin(), validFlags.end(), flag) == validFlags.end())
                 {
                     throw std::invalid_argument("Invalid flag: " + flag);
                 }
@@ -88,4 +90,10 @@ class CommandLineArgs
     }
 };
 
+// Define valid flags globally
+const std::vector<std::string> CommandLineArgs::validFlags = {
+    "--help", "--show-dbus-name", "--version", "--clear-cache", 
+    "--show-config-file", "--show-log-dir"
+};
+
 #endif // COMMAND_LINE_ARGS_HPP

src/dirsort/taglib_parser.h

@@ -18,10 +18,12 @@
 #ifndef __EMSCRIPTEN__
 #include <taglib/fileref.h>
 #include <taglib/tag.h>
+#include <taglib/tag_c.h>
 #include <taglib/id3v2tag.h>
 #include <taglib/mpegfile.h>
 #include <taglib/attachedpictureframe.h>
 #include <taglib/tpropertymap.h>
+#include <taglib/flacfile.h>
 #include <png.h>
 #endif
 #include <unordered_map>
@@ -259,54 +261,78 @@ void printMetadata(const Metadata& metadata) {
 }
 
 /**
- * @brief Extracts the thumbnail (album art) from an audio file and saves it to an image file.
+ * @brief Extracts the thumbnail (album art) from an audio file and saves it to an image file. (Works for mp3 and flac)
  * @param audioFilePath The path to the audio file containing embedded album art.
  * @param outputImagePath The path where the extracted album art image will be saved.
  * @return `true` if the thumbnail was successfully extracted, `false` otherwise.
  */
 bool extractThumbnail(const std::string& audioFilePath, const std::string& outputImagePath) {
-    // Open the file using TagLib
-    TagLib::MPEG::File file(audioFilePath.c_str());
-    if (!file.isValid()) {
-        std::cerr << "Error: Could not open audio file." << std::endl;
-        return false;
-    }
+    // Determine the file type based on the extension
+    std::string extension = audioFilePath.substr(audioFilePath.find_last_of('.') + 1);
+
+    if (extension == "mp3") {
+        // Handle MP3 files (ID3v2 tag)
+        TagLib::MPEG::File mpegFile(audioFilePath.c_str());
+        if (!mpegFile.isValid()) {
+            std::cerr << "Error: Could not open MP3 file." << std::endl;
+            return false;
+        }
 
-    // Ensure the file has ID3v2 tags
-    TagLib::ID3v2::Tag* id3v2Tag = file.ID3v2Tag();
-    if (!id3v2Tag) {
-        std::cerr << "Error: No ID3v2 tags found in the audio file." << std::endl;
-        return false;
-    }
+        TagLib::ID3v2::Tag* id3v2Tag = mpegFile.ID3v2Tag();
+        if (!id3v2Tag) {
+            std::cerr << "Error: No ID3v2 tags found in the MP3 file." << std::endl;
+            return false;
+        }
 
-    // Search for the APIC (Attached Picture) frame
-    const TagLib::ID3v2::FrameList& frameList = id3v2Tag->frameListMap()["APIC"];
-    if (frameList.isEmpty()) {
-        std::cerr << "Error: No embedded album art found in the audio file." << std::endl;
-        return false;
-    }
+        const TagLib::ID3v2::FrameList& frameList = id3v2Tag->frameListMap()["APIC"];
+        if (frameList.isEmpty()) {
+            std::cerr << "Error: No embedded album art found in the MP3 file." << std::endl;
+            return false;
+        }
 
-    // Extract the first APIC frame (album art)
-    auto* apicFrame = dynamic_cast<TagLib::ID3v2::AttachedPictureFrame*>(frameList.front());
-    if (!apicFrame) {
-        std::cerr << "Error: Failed to retrieve album art." << std::endl;
-        return false;
-    }
+        auto* apicFrame = dynamic_cast<TagLib::ID3v2::AttachedPictureFrame*>(frameList.front());
+        if (!apicFrame) {
+            std::cerr << "Error: Failed to retrieve album art from MP3." << std::endl;
+            return false;
+        }
+
+        const auto& pictureData = apicFrame->picture();
+        std::ofstream outputFile(outputImagePath, std::ios::binary);
+        if (!outputFile) {
+            std::cerr << "Error: Could not create output image file." << std::endl;
+            return false;
+        }
+
+        outputFile.write(reinterpret_cast<const char*>(pictureData.data()), pictureData.size());
+        outputFile.close();
+    } else if (extension == "flac") {
+        // Handle FLAC files
+        TagLib::FLAC::File flacFile(audioFilePath.c_str(), true);
+        if (!flacFile.isValid()) {
+            std::cerr << "Error: Could not open FLAC file." << std::endl;
+            return false;
+        }
 
-    // Get the picture data and MIME type
-    const auto& pictureData = apicFrame->picture();
-    const std::string mimeType = apicFrame->mimeType().toCString(true);
+        const TagLib::List<TagLib::FLAC::Picture*>& pictureList = flacFile.pictureList();
+        if (pictureList.isEmpty()) {
+            std::cerr << "Error: No album art found in the FLAC file." << std::endl;
+            return false;
+        }
+
+        const auto& pictureData = pictureList.front()->data();
+        std::ofstream outputFile(outputImagePath, std::ios::binary);
+        if (!outputFile) {
+            std::cerr << "Error: Could not create output image file." << std::endl;
+            return false;
+        }
 
-    // Save the picture data to a file
-    std::ofstream outputFile(outputImagePath, std::ios::binary);
-    if (!outputFile) {
-        std::cerr << "Error: Could not create output image file." << std::endl;
+        outputFile.write(reinterpret_cast<const char*>(pictureData.data()), pictureData.size());
+        outputFile.close();
+    } else {
+        std::cerr << "Error: Unsupported file format. Only MP3 and FLAC are supported." << std::endl;
         return false;
     }
 
-    outputFile.write(reinterpret_cast<const char*>(pictureData.data()), pictureData.size());
-    outputFile.close();
-
     return true;
 }
 

src/main.cpp

@@ -1,6 +1,7 @@
 #include "dirsort/inode_mapper.hpp"
 #include "signal/signalHandler.hpp"
 #include "ui/ui_handler.hpp"
+#include "./arg-handler.hpp"
 #include <memory>
 #include <random>
 
@@ -9,7 +10,11 @@ int main(int argc, char* argv[])
   SignalHandler::getInstance().setup();
   auto            directoryPath = string(parseTOMLField(PARENT_LIB, PARENT_LIB_FIELD_DIR));
   string          libSyncPath  = getConfigPath(LIB_SYNC_NAME);
+  string          configPath   = getConfigPath("config.toml");
+  string          cacheDir     = getCachePath();
   string          libBinPath   = getConfigPath(LIB_BIN_NAME);
+  CommandLineArgs cmdArgs(argc, argv);
+  ArgumentHandler::handleArguments(cmdArgs, argv[0], configPath, libBinPath, cacheDir);
   RedBlackTree    rbt;
   InodeFileMapper mapper(libSyncPath, "false");
 
@@ -22,7 +27,7 @@ int main(int argc, char* argv[])
   try
   {
     song_tree.loadFromFile(libBinPath);
-    cout << "-- Successfully loaded song tree from file." << endl;
+    cout << "-- Successfully loaded song tree from cache file." << endl;
   }
   catch (const std::exception& e)
   {