Pretty song output, if the media is a browser playing a video

.github/workflows/push.yml

@@ -84,7 +84,7 @@ jobs:
 
       - name: Get fastfetch version
         id: get_version_fastfetch
-        run: echo "::set-output name=release::$(./fastfetch --version)"
+        run: echo "::set-output name=release::$(./fastfetch --version-raw)"
 
       - name: Get latest release version
         id: get_version_release

CMakeLists.txt

@@ -1,10 +1,14 @@
 cmake_minimum_required(VERSION 3.1.0) # Threads::Threads
 
 project(fastfetch
-    VERSION 1.0.0
+    VERSION 1.2.0
     LANGUAGES C
 )
 
+#e.g. +1
+#This allows to track builds between versions, without GitHub creating a new release
+set(PROJECT_VERSION_EXTRA "")
+
 include(GNUInstallDirs)
 
 OPTION(ENABLE_LIBPCI "Enable libpci" ON)

packaging/deb/create.sh

@@ -22,7 +22,7 @@ fi
 # Populate the files
 cmake --install "${BUILD_DIR}" --prefix "${PACKAGE_DIR}/usr" || exit 5
 mkdir -p "${PACKAGE_DIR}/DEBIAN" || exit 6
-sed "s/<VERSION>/$("${BUILD_DIR}/fastfetch" --version)/g" "${ROOT_DIR}/packaging/deb/control-template" > "${PACKAGE_DIR}/DEBIAN/control" || exit 7
+sed "s/<VERSION>/$("${BUILD_DIR}/fastfetch" --version-raw)/g" "${ROOT_DIR}/packaging/deb/control-template" > "${PACKAGE_DIR}/DEBIAN/control" || exit 7
 
 # Create the package
 dpkg-deb --build "${PACKAGE_DIR}" || exit 8

src/common/io.c

@@ -246,9 +246,10 @@ void ffCacheValidate(FFinstance* instance)
     ffStrbufInit(&content);
     ffAppendFileContent(path.chars, &content);
 
-    if(ffStrbufCompS(&content, FASTFETCH_PROJECT_VERSION) == 0)
+    bool isSameVersion = ffStrbufCompS(&content, FASTFETCH_PROJECT_VERSION) == 0;
+    ffStrbufDestroy(&content);
+    if(isSameVersion)
     {
-        ffStrbufDestroy(&content);
         ffStrbufDestroy(&path);
         return;
     }
@@ -261,7 +262,6 @@ void ffCacheValidate(FFinstance* instance)
     ffWriteFileContent(path.chars, &version);
     ffStrbufDestroy(&version);
 
-    ffStrbufDestroy(&content);
     ffStrbufDestroy(&path);
 }
 
@@ -409,7 +409,7 @@ bool ffWriteFDContent(int fd, const FFstrbuf* content)
 
 void ffWriteFileContent(const char* fileName, const FFstrbuf* content)
 {
-    int fd = open(fileName, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+    int fd = open(fileName, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
     if(fd == -1)
         return;
 

src/detection/media.c

@@ -53,20 +53,25 @@ static bool getValue(DBusMessageIter* iter, FFstrbuf* result, DBusData* data)
         return true;
     }
 
-    if(argType != DBUS_TYPE_ARRAY)
+    if(argType != DBUS_TYPE_VARIANT && argType != DBUS_TYPE_ARRAY)
         return false;
 
-    DBusMessageIter arrayIter;
-    data->ffdbus_message_iter_recurse(iter, &arrayIter);
+    DBusMessageIter subIter;
+    data->ffdbus_message_iter_recurse(iter, &subIter);
+
+    if(argType == DBUS_TYPE_VARIANT)
+        return getValue(&subIter, result, data);
+
+    //At this point we have an array
 
     bool foundAValue = false;
 
     while(true)
     {
-        if((foundAValue = getValue(&arrayIter, result, data)))
+        if((foundAValue = getValue(&subIter, result, data)))
             ffStrbufAppendS(result, ", ");
 
-        FF_DBUS_ITER_CONTINUE(arrayIter);
+        FF_DBUS_ITER_CONTINUE(subIter);
     }
 
     if(foundAValue)
@@ -75,51 +80,90 @@ static bool getValue(DBusMessageIter* iter, FFstrbuf* result, DBusData* data)
     return foundAValue;
 }
 
-static bool detectSong(const char* player, FFMediaResult* result, DBusData* data)
+static DBusMessage* getReply(DBusMessage* request, DBusData* data)
 {
-    DBusMessage* message = data->ffdbus_message_new_method_call(player, "/org/mpris/MediaPlayer2", "org.freedesktop.DBus.Properties", "Get");
+    DBusPendingCall* pendingCall = NULL;
+    dbus_bool_t succesfull = data->ffdbus_connection_send_with_reply(data->connection, request, &pendingCall, DBUS_TIMEOUT_USE_DEFAULT);
+    data->ffdbus_message_unref(request);
+    if(!succesfull || pendingCall == NULL)
+        return NULL;
+
+    data->ffdbus_connection_flush(data->connection);
+    data->ffdbus_pending_call_block(pendingCall);
+
+    DBusMessage* reply = data->ffdbus_pending_call_steal_reply(pendingCall);
+    data->ffdbus_pending_call_unref(pendingCall);
+    return reply;
+}
+
+static DBusMessage* getProperty(const char* busName, const char* objectPath, const char* interface, const char* property, DBusData* data)
+{
+    DBusMessage* message = data->ffdbus_message_new_method_call(busName, objectPath, "org.freedesktop.DBus.Properties", "Get");
     if(message == NULL)
-        return false;
+        return NULL;
 
     DBusMessageIter requestIterator;
     data->ffdbus_message_iter_init_append(message, &requestIterator);
 
-    const char* arg1 = "org.mpris.MediaPlayer2.Player";
-    if(!data->ffdbus_message_iter_append_basic(&requestIterator, DBUS_TYPE_STRING, &arg1))
+    if(!data->ffdbus_message_iter_append_basic(&requestIterator, DBUS_TYPE_STRING, &interface))
     {
         data->ffdbus_message_unref(message);
-        return false;
+        return NULL;
     }
 
-    const char* arg2 = "Metadata";
-    if(!data->ffdbus_message_iter_append_basic(&requestIterator, DBUS_TYPE_STRING, &arg2))
+    if(!data->ffdbus_message_iter_append_basic(&requestIterator, DBUS_TYPE_STRING, &property))
     {
         data->ffdbus_message_unref(message);
-        return false;
+        return NULL;
     }
 
-    DBusPendingCall* pending;
-    bool sendSuccessfull = data->ffdbus_connection_send_with_reply(data->connection, message, &pending, DBUS_TIMEOUT_USE_DEFAULT);
-    data->ffdbus_message_unref(message);
-    if(pending == NULL || !sendSuccessfull)
-        return false;
+    return getReply(message, data);
+}
 
-    data->ffdbus_connection_flush(data->connection);
-    data->ffdbus_pending_call_block(pending);
+static void getPropertyString(const char* busName, const char* objectPath, const char* interface, const char* property, FFstrbuf* result, DBusData* data)
+{
+    DBusMessage* reply = getProperty(busName, objectPath, interface, property, data);
+    if(reply == NULL)
+        return;
 
-    DBusMessage* reply = data->ffdbus_pending_call_steal_reply(pending);
-    data->ffdbus_pending_call_unref(pending);
+    DBusMessageIter rootIterator;
+    if(!data->ffdbus_message_iter_init(reply, &rootIterator))
+    {
+        data->ffdbus_message_unref(reply);
+        return;
+    }
+
+    getValue(&rootIterator, result, data);
+
+    data->ffdbus_message_unref(reply);
+}
+
+static bool getBusProperties(const char* busName, FFMediaResult* result, DBusData* data)
+{
+    DBusMessage* reply = getProperty(busName, "/org/mpris/MediaPlayer2", "org.mpris.MediaPlayer2.Player", "Metadata", data);
     if(reply == NULL)
         return false;
 
     DBusMessageIter rootIterator;
-    if(!data->ffdbus_message_iter_init(reply, &rootIterator) || data->ffdbus_message_iter_get_arg_type(&rootIterator) != DBUS_TYPE_VARIANT)
+    if(!data->ffdbus_message_iter_init(reply, &rootIterator))
+    {
+        data->ffdbus_message_unref(reply);
         return false;
+    }
+
+    if(data->ffdbus_message_iter_get_arg_type(&rootIterator) != DBUS_TYPE_VARIANT)
+    {
+        data->ffdbus_message_unref(reply);
+        return false;
+    }
 
     DBusMessageIter variantIterator;
     data->ffdbus_message_iter_recurse(&rootIterator, &variantIterator);
     if(data->ffdbus_message_iter_get_arg_type(&variantIterator) != DBUS_TYPE_ARRAY)
+    {
+        data->ffdbus_message_unref(reply);
         return false;
+    }
 
     DBusMessageIter arrayIterator;
     data->ffdbus_message_iter_recurse(&variantIterator, &arrayIterator);
@@ -143,18 +187,14 @@ static bool detectSong(const char* player, FFMediaResult* result, DBusData* data
 
         data->ffdbus_message_iter_next(&dictIterator);
 
-        if(data->ffdbus_message_iter_get_arg_type(&dictIterator) != DBUS_TYPE_VARIANT)
-            FF_DBUS_ITER_CONTINUE(arrayIterator)
-
-        DBusMessageIter valueIter;
-        data->ffdbus_message_iter_recurse(&dictIterator, &valueIter);
-
         if(strcmp(key, "xesam:title") == 0)
-            getValue(&valueIter, &result->song, data);
+            getValue(&dictIterator, &result->song, data);
         else if(strcmp(key, "xesam:album") == 0)
-            getValue(&valueIter, &result->album, data);
+            getValue(&dictIterator, &result->album, data);
         else if(strcmp(key, "xesam:artist") == 0)
-            getValue(&valueIter, &result->artist, data);
+            getValue(&dictIterator, &result->artist, data);
+        else if(strcmp(key, "xesam:url") == 0)
+            getValue(&dictIterator, &result->url, data);
 
         if(result->song.length > 0 && result->artist.length > 0 && result->album.length > 0)
             break;
@@ -162,6 +202,8 @@ static bool detectSong(const char* player, FFMediaResult* result, DBusData* data
         FF_DBUS_ITER_CONTINUE(arrayIterator)
     }
 
+    data->ffdbus_message_unref(reply);
+
     if(result->song.length == 0)
     {
         ffStrbufClear(&result->artist);
@@ -169,45 +211,42 @@ static bool detectSong(const char* player, FFMediaResult* result, DBusData* data
         return false;
     }
 
+    //We found a song, get the player name
+
+    getPropertyString(busName, "/org/mpris/MediaPlayer2", "org.mpris.MediaPlayer2", "Identity", &result->player, data);
+
+    if(result->player.length == 0)
+        getPropertyString(busName, "/org/mpris/MediaPlayer2", "org.mpris.MediaPlayer2", "DesktopEntry", &result->player, data);
+
     return true;
 }
 
-static void getCustomPlayer(FFinstance* instance, FFMediaResult* result, DBusData* data)
+static void getCustomBus(FFinstance* instance, FFMediaResult* result, DBusData* data)
 {
     if(ffStrbufStartsWithS(&instance->config.playerName, FF_DBUS_MPRIS_PREFIX))
     {
-        detectSong(instance->config.playerName.chars, result, data);
-        ffStrbufAppendS(&result->player, instance->config.playerName.chars + sizeof(FF_DBUS_MPRIS_PREFIX) - 1);
+        ffStrbufAppendS(&result->busNameShort, instance->config.playerName.chars + sizeof(FF_DBUS_MPRIS_PREFIX) - 1);
+        getBusProperties(instance->config.playerName.chars, result, data);
         return;
     }
 
+    ffStrbufAppend(&result->busNameShort, &instance->config.playerName);
+
     FFstrbuf busName;
     ffStrbufInit(&busName);
     ffStrbufAppendS(&busName, FF_DBUS_MPRIS_PREFIX);
     ffStrbufAppend(&busName, &instance->config.playerName);
-    detectSong(busName.chars, result, data);
+    getBusProperties(busName.chars, result, data);
     ffStrbufDestroy(&busName);
-
-    ffStrbufAppend(&result->player, &instance->config.playerName);
 }
 
-static void getBestPlayer(FFMediaResult* result, DBusData* data)
+static void getBestBus(FFMediaResult* result, DBusData* data)
 {
     DBusMessage* message = data->ffdbus_message_new_method_call("org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "ListNames");
     if(message == NULL)
         return;
 
-    DBusPendingCall* pending;
-    bool sendSuccessfull = data->ffdbus_connection_send_with_reply(data->connection, message, &pending, DBUS_TIMEOUT_USE_DEFAULT);
-    data->ffdbus_message_unref(message);
-    if(pending == NULL || !sendSuccessfull)
-        return;
-
-    data->ffdbus_connection_flush(data->connection);
-    data->ffdbus_pending_call_block(pending);
-
-    DBusMessage* reply = data->ffdbus_pending_call_steal_reply(pending);
-    data->ffdbus_pending_call_unref(pending);
+    DBusMessage* reply = getReply(message, data);
     if(reply == NULL)
         return;
 
@@ -223,20 +262,22 @@ static void getBestPlayer(FFMediaResult* result, DBusData* data)
         if(data->ffdbus_message_iter_get_arg_type(&arrayIterator) != DBUS_TYPE_STRING)
             FF_DBUS_ITER_CONTINUE(arrayIterator)
 
-        const char* name;
-        data->ffdbus_message_iter_get_basic(&arrayIterator, &name);
+        const char* busName;
+        data->ffdbus_message_iter_get_basic(&arrayIterator, &busName);
 
-        if(strncmp(name, FF_DBUS_MPRIS_PREFIX, sizeof(FF_DBUS_MPRIS_PREFIX) - 1) != 0)
+        if(strncmp(busName, FF_DBUS_MPRIS_PREFIX, sizeof(FF_DBUS_MPRIS_PREFIX) - 1) != 0)
             FF_DBUS_ITER_CONTINUE(arrayIterator)
 
-        if(detectSong(name, result, data))
+        if(getBusProperties(busName, result, data))
         {
-            ffStrbufAppendS(&result->player, name + sizeof(FF_DBUS_MPRIS_PREFIX) - 1);
+            ffStrbufAppendS(&result->busNameShort, busName + sizeof(FF_DBUS_MPRIS_PREFIX) - 1);
             break;
         }
 
         FF_DBUS_ITER_CONTINUE(arrayIterator)
     }
+
+    data->ffdbus_message_unref(reply);
 }
 
 static void getMedia(FFinstance* instance, FFMediaResult* result)
@@ -269,9 +310,9 @@ static void getMedia(FFinstance* instance, FFMediaResult* result)
     }
 
     if(instance->config.playerName.length > 0)
-        getCustomPlayer(instance, result, &data);
+        getCustomBus(instance, result, &data);
     else
-        getBestPlayer(result, &data);
+        getBestBus(result, &data);
 
     dlclose(dbus);
 }
@@ -292,23 +333,30 @@ const FFMediaResult* ffDetectMedia(FFinstance* instance)
     }
     init = true;
 
+    ffStrbufInit(&result.busNameShort);
     ffStrbufInit(&result.player);
     ffStrbufInit(&result.song);
     ffStrbufInit(&result.artist);
     ffStrbufInit(&result.album);
+    ffStrbufInit(&result.url);
 
     #ifdef FF_HAVE_DBUS
         getMedia(instance, &result);
     #endif
 
-    if(instance->config.playerName.length > 0 && result.player.length == 0)
+    //Set busNameShort if a custom player was given, but loading dbus failed
+    if(instance->config.playerName.length > 0 && result.busNameShort.length == 0)
     {
         if(ffStrbufStartsWithS(&instance->config.playerName, FF_DBUS_MPRIS_PREFIX))
-            ffStrbufAppendS(&result.player, instance->config.playerName.chars + sizeof(FF_DBUS_MPRIS_PREFIX) - 1);
+            ffStrbufAppendS(&result.busNameShort, instance->config.playerName.chars + sizeof(FF_DBUS_MPRIS_PREFIX) - 1);
         else
-            ffStrbufAppend(&result.player, &instance->config.playerName);
+            ffStrbufAppend(&result.busNameShort, &instance->config.playerName);
     }
 
+    //Set player to busNameShort, if detection failed
+    if(result.player.length == 0)
+        ffStrbufAppend(&result.player, &result.busNameShort);
+
     pthread_mutex_unlock(&mutex);
     return &result;
 }

src/fastfetch.c

@@ -304,16 +304,20 @@ static inline void printCommandHelp(const char* command)
     }
     else if(strcasecmp(command, "player-format") == 0)
     {
-        constructAndPrintCommandHelpFormat("player", "{}", 1,
-            "Player name"
+        constructAndPrintCommandHelpFormat("player", "{}", 3,
+            "Pretty player name",
+            "Player name",
+            "DBus bus name"
         );
     }
     else if(strcasecmp(command, "song-format") == 0)
     {
-        constructAndPrintCommandHelpFormat("song", "{2} - {3} - {1}", 3,
+        constructAndPrintCommandHelpFormat("song", "{3} - {4} - {1}", 5,
+            "Song name pretty",
             "Song name",
             "Artist name",
-            "Album name"
+            "Album name",
+            "Song url"
         );
     }
     else if(strcasecmp(command, "datetime-format") == 0 || strcasecmp(command, "date-format") == 0 || strcasecmp(command, "time-format") == 0)
@@ -612,6 +616,11 @@ static void parseOption(FFinstance* instance, FFdata* data, const char* key, con
         exit(0);
     }
     else if(strcasecmp(key, "-v") == 0 || strcasecmp(key, "--version") == 0)
+    {
+        puts("fastfetch "FASTFETCH_PROJECT_VERSION""FASTFETCH_PROJECT_VERSION_EXTRA);
+        exit(0);
+    }
+    else if(strcasecmp(key, "--version-raw") == 0)
     {
         puts(FASTFETCH_PROJECT_VERSION);
         exit(0);

src/fastfetch.h

@@ -257,10 +257,12 @@ typedef struct FFTempsResult
 
 typedef struct FFMediaResult
 {
-    FFstrbuf player;
+    FFstrbuf busNameShort; //e.g. plasma-browser-integration
+    FFstrbuf player; // e.g. Google Chrome
     FFstrbuf song;
     FFstrbuf artist;
     FFstrbuf album;
+    FFstrbuf url;
 } FFMediaResult;
 
 typedef struct FFDateTimeResult

src/fastfetch_config.h.in

@@ -4,6 +4,7 @@
 #define FASTFETCH_PROJECT_NAME "@PROJECT_NAME@"
 #define FASTFETCH_PROJECT_VERSION "@PROJECT_VERSION@"
 #define FASTFETCH_PROJECT_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
+#define FASTFETCH_PROJECT_VERSION_EXTRA "@PROJECT_VERSION_EXTRA@"
 
 #define FASTFETCH_DATATEXT_STRUCTURE "@DATATEXT_STRUCTURE@"
 #define FASTFETCH_DATATEXT_CONFIG "@DATATEXT_CONFIG@" //Requires FASTFETCH_PROJECT_VERSION and FASTFETCH_DATATEXT_STRUCTURE to be set

src/modules/player.c

@@ -1,7 +1,9 @@
 #include "fastfetch.h"
 
+#include <ctype.h>
+
 #define FF_PLAYER_MODULE_NAME "Media Player"
-#define FF_PLAYER_NUM_FORMAT_ARGS 1
+#define FF_PLAYER_NUM_FORMAT_ARGS 3
 
 void ffPrintPlayer(FFinstance* instance)
 {
@@ -13,15 +15,52 @@ void ffPrintPlayer(FFinstance* instance)
         return;
     }
 
+    FFstrbuf playerPretty;
+    ffStrbufInit(&playerPretty);
+
+    //If we are on a website, prepend the website name
+    if(ffStrbufStartsWithS(&media->url, "https://www."))
+        ffStrbufAppendS(&playerPretty, media->url.chars + 12);
+    else if(ffStrbufStartsWithS(&media->url, "http://www."))
+        ffStrbufAppendS(&playerPretty, media->url.chars + 11);
+    else if(ffStrbufStartsWithS(&media->url, "https://"))
+        ffStrbufAppendS(&playerPretty, media->url.chars + 8);
+    else if(ffStrbufStartsWithS(&media->url, "http://"))
+        ffStrbufAppendS(&playerPretty, media->url.chars + 7);
+
+    //If we found a website name, make it more pretty
+    if(playerPretty.length > 0)
+    {
+        ffStrbufSubstrBeforeFirstC(&playerPretty, '/'); //Remove the path
+        ffStrbufSubstrBeforeLastC(&playerPretty, '.'); //Remove the TLD
+    }
+
+    //Check again for length, as we may have removed everything.
+    bool playerPrettyIsCustom = playerPretty.length > 0;
+
+    //If we don't have subdomains, it is usually more pretty to capitalize the first letter.
+    if(playerPrettyIsCustom && ffStrbufFirstIndexC(&playerPretty, '.') == playerPretty.length)
+        playerPretty.chars[0] = (char) toupper(playerPretty.chars[0]);
+
+    if(playerPrettyIsCustom)
+        ffStrbufAppendS(&playerPretty, " (");
+
+    ffStrbufAppend(&playerPretty, &media->player);
+
+    if(playerPrettyIsCustom)
+        ffStrbufAppendC(&playerPretty, ')');
+
     if(instance->config.playerFormat.length == 0)
     {
         ffPrintLogoAndKey(instance, FF_PLAYER_MODULE_NAME, 0, &instance->config.playerKey);
-        ffStrbufPutTo(&media->player, stdout);
+        ffStrbufPutTo(&playerPretty, stdout);
     }
     else
     {
         ffPrintFormatString(instance, FF_PLAYER_MODULE_NAME, 0, &instance->config.playerKey, &instance->config.playerFormat, NULL, FF_PLAYER_NUM_FORMAT_ARGS, (FFformatarg[]){
-            {FF_FORMAT_ARG_TYPE_STRBUF, &media->player}
+            {FF_FORMAT_ARG_TYPE_STRBUF, &playerPretty},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &media->player},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &media->busNameShort}
         });
     }
 }

src/modules/song.c

@@ -1,7 +1,44 @@
 #include "fastfetch.h"
 
+#include <ctype.h>
+
 #define FF_SONG_MODULE_NAME "Song"
-#define FF_SONG_NUM_FORMAT_ARGS 3
+#define FF_SONG_NUM_FORMAT_ARGS 5
+
+static bool shouldIgoreChar(char c)
+{
+    return isblank(c) || c == '-' || c == '.';
+}
+
+static bool artistInSongTitle(const FFstrbuf* song, const FFstrbuf* artist)
+{
+    uint32_t artistIndex = 0;
+    uint32_t songIndex = 0;
+
+    while(true)
+    {
+        while(shouldIgoreChar(song->chars[songIndex]))
+            ++songIndex;
+
+        while(shouldIgoreChar(artist->chars[artistIndex]))
+            ++artistIndex;
+
+        if(artist->chars[artistIndex] == '\0')
+            return true;
+
+        if(song->chars[songIndex] == '\0')
+            return false;
+
+        if(tolower(song->chars[songIndex]) != tolower(artist->chars[artistIndex]))
+            return false;
+
+        ++artistIndex;
+        ++songIndex;
+    }
+
+    //Unreachable
+    return false;
+}
 
 void ffPrintSong(FFinstance* instance)
 {
@@ -13,13 +50,39 @@ void ffPrintSong(FFinstance* instance)
         return;
     }
 
+    FFstrbuf songPretty;
+    ffStrbufInitCopy(&songPretty, &media->song);
+    const char* removeStrings[] = {
+        "(Official Music Video)", "(Official Video)", "(Music Video)",
+        "[Official Music Video]", "[Official Video]", "[Music Video]",
+        "| Official Music Video", "| Official Video", "| Music Video",
+        "[Official Audio]", "[Audio]", "(Audio)", "| Official Audio", "| Audio", "| OFFICIAL AUDIO",
+        "(Lyric Video)", "(Official Lyric Video)", "(Lyrics)",
+        "(dirty version)", "(dirty)", "(Clean)", "(Clean Version)",
+    };
+    ffStrbufRemoveStringsA(&songPretty, sizeof(removeStrings) / sizeof(removeStrings[0]), removeStrings);
+    ffStrbufTrimRight(&songPretty, ' ');
+
+    if(songPretty.length == 0)
+        ffStrbufAppend(&songPretty, &media->song);
+
     if(instance->config.songFormat.length == 0)
     {
+        //We don't expose artistPretty to the format, as it might be empty (when the think that the artist is already in the song title)
+        FFstrbuf artistPretty;
+        ffStrbufInitCopy(&artistPretty, &media->artist);
+        ffStrbufRemoveIgnCaseEndS(&artistPretty, " - Topic");
+        ffStrbufRemoveIgnCaseEndS(&artistPretty, "VEVO");
+        ffStrbufTrimRight(&artistPretty, ' ');
+
+        if(artistInSongTitle(&songPretty, &artistPretty))
+            ffStrbufClear(&artistPretty);
+
         ffPrintLogoAndKey(instance, FF_SONG_MODULE_NAME, 0, &instance->config.songKey);
 
-        if(media->artist.length > 0)
+        if(artistPretty.length > 0)
         {
-            ffStrbufWriteTo(&media->artist, stdout);
+            ffStrbufWriteTo(&artistPretty, stdout);
             fputs(" - ", stdout);
         }
 
@@ -29,14 +92,16 @@ void ffPrintSong(FFinstance* instance)
             fputs(" - ", stdout);
         }
 
-        ffStrbufPutTo(&media->song, stdout);
+        ffStrbufPutTo(&songPretty, stdout);
     }
     else
     {
         ffPrintFormatString(instance, FF_SONG_MODULE_NAME, 0, &instance->config.songKey, &instance->config.songFormat, NULL, FF_SONG_NUM_FORMAT_ARGS, (FFformatarg[]){
+            {FF_FORMAT_ARG_TYPE_STRBUF, &songPretty},
             {FF_FORMAT_ARG_TYPE_STRBUF, &media->song},
             {FF_FORMAT_ARG_TYPE_STRBUF, &media->artist},
-            {FF_FORMAT_ARG_TYPE_STRBUF, &media->album}
+            {FF_FORMAT_ARG_TYPE_STRBUF, &media->album},
+            {FF_FORMAT_ARG_TYPE_STRBUF, &media->url}
         });
     }
 }