summaryrefslogtreecommitdiffstats
path: root/src/detection/media
diff options
context:
space:
mode:
Diffstat (limited to 'src/detection/media')
-rw-r--r--src/detection/media/media.c45
-rw-r--r--src/detection/media/media.h21
-rw-r--r--src/detection/media/media_apple.m209
-rw-r--r--src/detection/media/media_linux.c288
-rw-r--r--src/detection/media/media_nosupport.c5
-rw-r--r--src/detection/media/media_windows.cpp421
6 files changed, 989 insertions, 0 deletions
diff --git a/src/detection/media/media.c b/src/detection/media/media.c
new file mode 100644
index 0000000..7adfb99
--- /dev/null
+++ b/src/detection/media/media.c
@@ -0,0 +1,45 @@
+#include "media.h"
+#include "common/io.h"
+
+void ffDetectMediaImpl(FFMediaResult* media, bool saveCover);
+
+static FFMediaResult result;
+
+static void removeMediaCoverFile(void) {
+ if (result.cover.length > 0) {
+ ffRemoveFile(result.cover.chars);
+ ffStrbufDestroy(&result.cover);
+ }
+}
+
+const FFMediaResult* ffDetectMedia(bool saveCover) {
+ if (result.error.chars == NULL) {
+ ffStrbufInit(&result.error);
+ ffStrbufInit(&result.playerId);
+ ffStrbufInit(&result.player);
+ ffStrbufInit(&result.song);
+ ffStrbufInit(&result.artist);
+ ffStrbufInit(&result.album);
+ ffStrbufInit(&result.url);
+ ffStrbufInit(&result.status);
+ ffStrbufInit(&result.cover);
+ result.length = 0;
+ result.position = 0;
+ result.removeCoverAfterUse = false;
+ ffDetectMediaImpl(&result, saveCover);
+
+ if (result.song.length == 0 && result.error.length == 0) {
+ ffStrbufAppendS(&result.error, "No media found");
+ }
+ ffStrbufTrimRightSpace(&result.song);
+ ffStrbufTrimRightSpace(&result.artist);
+ ffStrbufTrimRightSpace(&result.album);
+ ffStrbufTrimRightSpace(&result.player);
+
+ if (saveCover && result.removeCoverAfterUse) {
+ atexit(removeMediaCoverFile);
+ }
+ }
+
+ return &result;
+}
diff --git a/src/detection/media/media.h b/src/detection/media/media.h
new file mode 100644
index 0000000..ea241e6
--- /dev/null
+++ b/src/detection/media/media.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "fastfetch.h"
+#include "modules/media/option.h"
+
+typedef struct FFMediaResult {
+ FFstrbuf error;
+ FFstrbuf playerId; // Bus name on Linux, app bundle name on macOS. e.g. plasma-browser-integration
+ FFstrbuf player; // e.g. Google Chrome
+ FFstrbuf song;
+ FFstrbuf artist;
+ FFstrbuf album;
+ FFstrbuf url;
+ FFstrbuf status;
+ FFstrbuf cover;
+ uint32_t length; // In milliseconds
+ uint32_t position; // In milliseconds
+ bool removeCoverAfterUse;
+} FFMediaResult;
+
+const FFMediaResult* ffDetectMedia(bool saveCover);
diff --git a/src/detection/media/media_apple.m b/src/detection/media/media_apple.m
new file mode 100644
index 0000000..d9501d1
--- /dev/null
+++ b/src/detection/media/media_apple.m
@@ -0,0 +1,209 @@
+#include "fastfetch.h"
+#include "common/processing.h"
+#include "common/apple/cf_helpers.h"
+#include "common/time.h"
+#include "detection/media/media.h"
+
+#import <Foundation/Foundation.h>
+#import <CoreFoundation/CoreFoundation.h>
+#import <CoreServices/CoreServices.h>
+
+// https://github.com/andrewwiik/iOS-Blocks/blob/master/Widgets/Music/MediaRemote.h
+extern void MRMediaRemoteGetNowPlayingInfo(dispatch_queue_t dispatcher, void (^callback)(_Nullable CFDictionaryRef info)) FF_A_WEAK_IMPORT;
+extern void MRMediaRemoteGetNowPlayingApplicationIsPlaying(dispatch_queue_t queue, void (^callback)(BOOL playing)) FF_A_WEAK_IMPORT;
+extern void MRMediaRemoteGetNowPlayingApplicationDisplayID(dispatch_queue_t queue, void (^callback)(_Nullable CFStringRef displayID)) FF_A_WEAK_IMPORT;
+extern void MRMediaRemoteGetNowPlayingApplicationDisplayName(int unknown, dispatch_queue_t queue, void (^callback)(_Nullable CFStringRef name)) FF_A_WEAK_IMPORT;
+
+static uint32_t getTrueElapsedTime(CFDictionaryRef info) {
+ double elapsedTime;
+ if (ffCfDictGetDouble(info, CFSTR("kMRMediaRemoteNowPlayingInfoElapsedTime"), &elapsedTime) != NULL) {
+ return 0;
+ }
+
+ elapsedTime *= 1000;
+
+ double playbackRate;
+ uint64_t timestampEpoch;
+ if (ffCfDictGetDouble(info, CFSTR("kMRMediaRemoteNowPlayingInfoPlaybackRate"), &playbackRate) == NULL &&
+ ffCfDictGetDateAsEpoch(info, CFSTR("kMRMediaRemoteNowPlayingInfoTimestamp"), &timestampEpoch) == NULL) {
+ uint64_t timeDiff = ffTimeGetNow() - timestampEpoch;
+ elapsedTime += (double) timeDiff * playbackRate;
+ }
+
+ return (uint32_t) elapsedTime;
+}
+
+static const char* getMediaByMediaRemote(FFMediaResult* result, bool saveCover) {
+#define FF_TEST_FN_EXISTENCE(fn) \
+ if (!fn) return "MediaRemote function " #fn " is not available"
+ FF_TEST_FN_EXISTENCE(MRMediaRemoteGetNowPlayingInfo);
+ FF_TEST_FN_EXISTENCE(MRMediaRemoteGetNowPlayingApplicationIsPlaying);
+#undef FF_TEST_FN_EXISTENCE
+
+ dispatch_group_t group = dispatch_group_create();
+ dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
+
+ dispatch_group_enter(group);
+ __block const char* error = NULL;
+ MRMediaRemoteGetNowPlayingInfo(queue, ^(_Nullable CFDictionaryRef info) {
+ if (info != nil) {
+ ffCfDictGetString(info, CFSTR("kMRMediaRemoteNowPlayingInfoTitle"), &result->song);
+ ffCfDictGetString(info, CFSTR("kMRMediaRemoteNowPlayingInfoArtist"), &result->artist);
+ ffCfDictGetString(info, CFSTR("kMRMediaRemoteNowPlayingInfoAlbum"), &result->album);
+ double value;
+ if (ffCfDictGetDouble(info, CFSTR("kMRMediaRemoteNowPlayingInfoDuration"), &value) == NULL) {
+ result->length = (uint32_t) (value * 1000);
+ result->position = getTrueElapsedTime(info);
+ }
+
+ if (saveCover) {
+ NSData* artworkData = (__bridge NSData*) CFDictionaryGetValue(info, CFSTR("kMRMediaRemoteNowPlayingInfoArtworkData"));
+ if (artworkData) {
+ CFStringRef mime = (CFStringRef) CFDictionaryGetValue(info, CFSTR("kMRMediaRemoteNowPlayingInfoArtworkMIMEType"));
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+ FF_CFTYPE_AUTO_RELEASE CFStringRef uti = UTTypeCreatePreferredIdentifierForTag(kUTTagClassMIMEType, mime, NULL);
+ FF_CFTYPE_AUTO_RELEASE CFStringRef ext = UTTypeCopyPreferredTagWithClass(uti, kUTTagClassFilenameExtension);
+#pragma clang diagnostic pop
+ NSString* tmpDir = NSTemporaryDirectory();
+ NSString* uuid = NSUUID.UUID.UUIDString;
+ NSString* path = [tmpDir stringByAppendingPathComponent:[NSString stringWithFormat:@"ff_%@.%@", uuid, ext ? (__bridge NSString*) ext : @"img"]];
+ if ([artworkData writeToFile:path atomically:NO])
+ ffStrbufSetS(&result->cover, path.UTF8String);
+ }
+ }
+ } else
+ error = "MRMediaRemoteGetNowPlayingInfo() failed";
+
+ dispatch_group_leave(group);
+ });
+
+ dispatch_group_enter(group);
+ MRMediaRemoteGetNowPlayingApplicationIsPlaying(queue, ^(BOOL playing) {
+ ffStrbufSetStatic(&result->status, playing ? "Playing" : "Paused");
+ dispatch_group_leave(group);
+ });
+
+ if (MRMediaRemoteGetNowPlayingApplicationDisplayID) {
+ dispatch_group_enter(group);
+ MRMediaRemoteGetNowPlayingApplicationDisplayID(queue, ^(_Nullable CFStringRef displayID) {
+ ffCfStrGetString(displayID, &result->playerId);
+ dispatch_group_leave(group);
+ });
+ }
+
+ if (MRMediaRemoteGetNowPlayingApplicationDisplayName) {
+ dispatch_group_enter(group);
+ MRMediaRemoteGetNowPlayingApplicationDisplayName(0, queue, ^(_Nullable CFStringRef name) {
+ ffCfStrGetString(name, &result->player);
+ dispatch_group_leave(group);
+ });
+ }
+
+ dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
+ // Don't dispatch_release because we are using ARC
+
+ if (result->song.length > 0) {
+ return NULL;
+ }
+
+ return error;
+}
+
+#if !FF_MODULE_DISABLE_MEDIA
+__attribute__((visibility("default"), used))
+int ffPrintMediaByMediaRemote(bool saveCover) {
+ FFMediaResult media = {
+ .status = ffStrbufCreate(),
+ .song = ffStrbufCreate(),
+ .artist = ffStrbufCreate(),
+ .album = ffStrbufCreate(),
+ .playerId = ffStrbufCreate(),
+ .player = ffStrbufCreate(),
+ .cover = ffStrbufCreate(),
+ };
+ if (getMediaByMediaRemote(&media, saveCover) != NULL) {
+ return 1;
+ }
+ ffStrbufAppendC(&media.status, '\n');
+ ffStrbufAppend(&media.status, &media.song);
+ ffStrbufAppendC(&media.status, '\n');
+ ffStrbufAppend(&media.status, &media.artist);
+ ffStrbufAppendC(&media.status, '\n');
+ ffStrbufAppend(&media.status, &media.album);
+ ffStrbufAppendC(&media.status, '\n');
+ ffStrbufAppend(&media.status, &media.playerId);
+ ffStrbufAppendC(&media.status, '\n');
+ ffStrbufAppend(&media.status, &media.player);
+ ffStrbufAppendC(&media.status, '\n');
+ if (saveCover) {
+ ffStrbufAppend(&media.status, &media.cover);
+ }
+ ffStrbufAppendC(&media.status, '\n');
+ ffStrbufAppendUInt(&media.status, media.position);
+ ffStrbufAppendC(&media.status, '\n');
+ ffStrbufAppendUInt(&media.status, media.length);
+ write(STDOUT_FILENO, media.status.chars, media.status.length);
+ ffStrbufDestroy(&media.status);
+ ffStrbufDestroy(&media.song);
+ ffStrbufDestroy(&media.artist);
+ ffStrbufDestroy(&media.album);
+ ffStrbufDestroy(&media.playerId);
+ ffStrbufDestroy(&media.player);
+ ffStrbufDestroy(&media.cover);
+ return 0;
+}
+#endif
+
+static const char* getMediaByAuthorizedProcess(FFMediaResult* result, bool saveCover) {
+ // #1737
+ FF_STRBUF_AUTO_DESTROY script = ffStrbufCreateF("import ctypes;ctypes.CDLL('%s').ffPrintMediaByMediaRemote(%s)", instance.state.platform.exePath.chars, saveCover ? "True" : "False");
+ FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreate();
+
+ const char* error = ffProcessAppendStdOut(
+ &buffer,
+ (char* const[]) { "/usr/bin/python3", // Must be signed by Apple. Homebrew python doesn't work
+ "-c",
+ script.chars,
+ nil });
+ if (error) {
+ return error;
+ }
+ if (buffer.length == 0) {
+ return "No media found";
+ }
+
+ // status\ntitle\nartist\nalbum\nbundleName\nappName\ncoverPath\nelapsedTimeMS\ndurationMS
+ FFstrbuf* const strList[] = { &result->status, &result->song, &result->artist, &result->album, &result->playerId, &result->player, &result->cover };
+ char* line = NULL;
+ size_t len = 0;
+ for (uint32_t i = 0; i < ARRAY_SIZE(strList) && ffStrbufGetline(&line, &len, &buffer); ++i) {
+ ffStrbufSetS(strList[i], line);
+ }
+ uint32_t* const numList[] = { &result->position, &result->length };
+ for (uint32_t i = 0; i < ARRAY_SIZE(numList) && ffStrbufGetline(&line, &len, &buffer); ++i) {
+ *numList[i] = (uint32_t) strtoul(line, NULL, 10);
+ }
+ return NULL;
+}
+
+void ffDetectMediaImpl(FFMediaResult* media, bool saveCover) {
+ const char* error;
+ if (@available(macOS 15.4, *)) {
+ error = getMediaByAuthorizedProcess(media, saveCover);
+ } else {
+ error = getMediaByMediaRemote(media, saveCover);
+ }
+ if (error) {
+ ffStrbufAppendS(&media->error, error);
+ } else if (media->player.length == 0 && media->playerId.length > 0) {
+ ffStrbufSet(&media->player, &media->playerId);
+ if (ffStrbufStartsWithIgnCaseS(&media->player, "com.")) {
+ ffStrbufSubstrAfter(&media->player, strlen("com.") - 1);
+ }
+ ffStrbufReplaceAllC(&media->player, '.', ' ');
+ if (media->cover.length > 0) {
+ media->removeCoverAfterUse = true;
+ }
+ }
+}
diff --git a/src/detection/media/media_linux.c b/src/detection/media/media_linux.c
new file mode 100644
index 0000000..724e834
--- /dev/null
+++ b/src/detection/media/media_linux.c
@@ -0,0 +1,288 @@
+#include "fastfetch.h"
+#include "common/io.h"
+#include "common/strutil.h"
+#include "common/memrchr.h"
+#include "detection/media/media.h"
+
+#include <string.h>
+
+#define FF_DBUS_MPRIS_PREFIX "org.mpris.MediaPlayer2."
+
+#ifdef FF_HAVE_DBUS
+ #include "common/dbus.h"
+
+ #define FF_DBUS_ITER_CONTINUE(dbus, iterator) \
+ { \
+ if (!(dbus)->lib->ffdbus_message_iter_next(iterator)) \
+ break; \
+ continue; \
+ }
+
+static bool parseMprisMetadata(FFDBusData* data, DBusMessageIter* rootIterator, FFMediaResult* result) {
+ DBusMessageIter arrayIterator;
+
+ if (data->lib->ffdbus_message_iter_get_arg_type(rootIterator) == DBUS_TYPE_VARIANT) {
+ DBusMessageIter variantIterator;
+ data->lib->ffdbus_message_iter_recurse(rootIterator, &variantIterator);
+ if (data->lib->ffdbus_message_iter_get_arg_type(&variantIterator) != DBUS_TYPE_ARRAY) {
+ return false;
+ }
+ data->lib->ffdbus_message_iter_recurse(&variantIterator, &arrayIterator);
+ } else {
+ data->lib->ffdbus_message_iter_recurse(rootIterator, &arrayIterator);
+ }
+
+ while (true) {
+ if (data->lib->ffdbus_message_iter_get_arg_type(&arrayIterator) != DBUS_TYPE_DICT_ENTRY) {
+ FF_DBUS_ITER_CONTINUE(data, &arrayIterator)
+ }
+
+ DBusMessageIter dictIterator;
+ data->lib->ffdbus_message_iter_recurse(&arrayIterator, &dictIterator);
+
+ if (data->lib->ffdbus_message_iter_get_arg_type(&dictIterator) != DBUS_TYPE_STRING) {
+ FF_DBUS_ITER_CONTINUE(data, &arrayIterator)
+ }
+
+ if (!data->lib->ffdbus_message_iter_has_next(&dictIterator)) {
+ FF_DBUS_ITER_CONTINUE(data, &arrayIterator)
+ }
+
+ const char* key;
+ data->lib->ffdbus_message_iter_get_basic(&dictIterator, &key);
+
+ data->lib->ffdbus_message_iter_next(&dictIterator);
+
+ if (ffStrStartsWith(key, "xesam:")) {
+ const char* xesam = key + strlen("xesam:");
+ if (ffStrEquals(xesam, "title")) {
+ ffDBusGetString(data, &dictIterator, &result->song);
+ } else if (ffStrEquals(xesam, "album")) {
+ ffDBusGetString(data, &dictIterator, &result->album);
+ } else if (ffStrEquals(xesam, "artist")) {
+ ffDBusGetString(data, &dictIterator, &result->artist);
+ } else if (ffStrEquals(xesam, "url")) {
+ ffDBusGetString(data, &dictIterator, &result->url);
+ }
+
+ if (result->song.length > 0 && result->artist.length > 0 && result->album.length > 0 && result->url.length > 0) {
+ break;
+ }
+ } else if (ffStrStartsWith(key, "mpris:")) {
+ const char* mpris = key + strlen("mpris:");
+ if (ffStrEquals(mpris, "artUrl")) {
+ FF_STRBUF_AUTO_DESTROY path = ffStrbufCreate();
+ ffDBusGetString(data, &dictIterator, &path);
+ if (ffStrbufStartsWithS(&path, "file:///")) {
+ ffStrbufEnsureFree(&result->cover, path.length - (uint32_t) strlen("file://"));
+ for (uint32_t i = (uint32_t) strlen("file://"); i < path.length; ++i) {
+ if (path.chars[i] == '%') {
+ if (i + 2 >= path.length) {
+ break;
+ }
+ char str[] = { path.chars[i + 1], path.chars[i + 2], 0 };
+ char* end = NULL;
+ const char decodedChar = (char) strtoul(str, &end, 16);
+ if (end == &str[2]) {
+ i += 2;
+ ffStrbufAppendC(&result->cover, decodedChar);
+ } else {
+ ffStrbufAppendC(&result->cover, '%');
+ }
+ } else {
+ ffStrbufAppendC(&result->cover, path.chars[i]);
+ }
+ }
+ }
+ } else if (ffStrEquals(mpris, "length")) {
+ int64_t length = 0; // microseconds
+ if (ffDBusGetInt(data, &dictIterator, &length) && length > 0) {
+ result->length = (uint32_t) (length / 1000);
+ }
+ }
+ }
+
+ FF_DBUS_ITER_CONTINUE(data, &arrayIterator)
+ }
+
+ return true;
+}
+
+static bool getBusProperties(FFDBusData* data, const char* busName, FFMediaResult* result) {
+ // Get all properties at once to reduce the number of IPCs
+ DBusMessage* reply = ffDBusGetAllProperties(data, busName, "/org/mpris/MediaPlayer2", "org.mpris.MediaPlayer2.Player");
+ if (reply == NULL) {
+ return false;
+ }
+
+ DBusMessageIter rootIterator;
+ if (!data->lib->ffdbus_message_iter_init(reply, &rootIterator) &&
+ data->lib->ffdbus_message_iter_get_arg_type(&rootIterator) != DBUS_TYPE_ARRAY) {
+ data->lib->ffdbus_message_unref(reply);
+ return false;
+ }
+
+ DBusMessageIter arrayIterator;
+ data->lib->ffdbus_message_iter_recurse(&rootIterator, &arrayIterator);
+
+ while (true) {
+ if (data->lib->ffdbus_message_iter_get_arg_type(&arrayIterator) != DBUS_TYPE_DICT_ENTRY) {
+ FF_DBUS_ITER_CONTINUE(data, &arrayIterator)
+ }
+
+ DBusMessageIter dictIterator;
+ data->lib->ffdbus_message_iter_recurse(&arrayIterator, &dictIterator);
+
+ const char* key;
+ data->lib->ffdbus_message_iter_get_basic(&dictIterator, &key);
+
+ data->lib->ffdbus_message_iter_next(&dictIterator);
+
+ if (ffStrEquals(key, "Metadata")) {
+ parseMprisMetadata(data, &dictIterator, result);
+ } else if (ffStrEquals(key, "PlaybackStatus")) {
+ ffDBusGetString(data, &dictIterator, &result->status);
+ } else if (ffStrEquals(key, "Position")) {
+ int64_t position = 0; // microseconds
+ if (ffDBusGetInt(data, &dictIterator, &position) && position > 0) {
+ result->position = (uint32_t) (position / 1000);
+ }
+ }
+
+ FF_DBUS_ITER_CONTINUE(data, &arrayIterator)
+ }
+
+ if (result->song.length == 0) {
+ if (result->url.length) {
+ const char* fileName = memrchr(result->url.chars, '/', result->url.length);
+ assert(fileName);
+ ++fileName;
+ ffStrbufEnsureFixedLengthFree(&result->song, result->url.length - (uint32_t) (fileName - result->url.chars));
+ for (; *fileName && *fileName != '?'; ++fileName) {
+ if (*fileName != '%') {
+ ffStrbufAppendC(&result->song, *fileName);
+ } else {
+ if (fileName[1] == 0 || fileName[2] == 0) {
+ break;
+ }
+ char str[] = { fileName[1], fileName[2], 0 };
+ ffStrbufAppendC(&result->song, (char) strtoul(str, NULL, 16));
+ fileName += 2;
+ }
+ }
+ } else {
+ ffStrbufClear(&result->artist);
+ ffStrbufClear(&result->album);
+ ffStrbufClear(&result->url);
+ ffStrbufClear(&result->status);
+ data->lib->ffdbus_message_unref(reply);
+ return false;
+ }
+ }
+
+ // Set short bus name
+ ffStrbufAppendS(&result->playerId, busName + sizeof(FF_DBUS_MPRIS_PREFIX) - 1);
+
+ // We found a song, get the player name
+ if (ffStrbufStartsWithS(&result->playerId, "musikcube.instance")) {
+ // dbus calls are EXTREMELY slow on musikcube, so we set the player name manually
+ ffStrbufSetStatic(&result->player, "musikcube");
+ } else {
+ ffDBusGetPropertyString(data, busName, "/org/mpris/MediaPlayer2", "org.mpris.MediaPlayer2", "Identity", &result->player);
+ if (result->player.length == 0) {
+ ffDBusGetPropertyString(data, busName, "/org/mpris/MediaPlayer2", "org.mpris.MediaPlayer2", "DesktopEntry", &result->player);
+ }
+ if (result->player.length == 0) {
+ ffStrbufAppend(&result->player, &result->playerId);
+ }
+ }
+
+ data->lib->ffdbus_message_unref(reply);
+
+ return true;
+}
+
+static void getCustomBus(FFDBusData* data, const FFstrbuf* playerName, FFMediaResult* result) {
+ if (ffStrbufStartsWithS(playerName, FF_DBUS_MPRIS_PREFIX)) {
+ getBusProperties(data, playerName->chars, result);
+ return;
+ }
+
+ FF_STRBUF_AUTO_DESTROY busName = ffStrbufCreateS(FF_DBUS_MPRIS_PREFIX);
+ ffStrbufAppend(&busName, playerName);
+ getBusProperties(data, busName.chars, result);
+}
+
+static void getBestBus(FFDBusData* data, FFMediaResult* result) {
+ if (
+ getBusProperties(data, FF_DBUS_MPRIS_PREFIX "spotify", result) ||
+ getBusProperties(data, FF_DBUS_MPRIS_PREFIX "vlc", result) ||
+ getBusProperties(data, FF_DBUS_MPRIS_PREFIX "plasma-browser-integration", result)) {
+ return;
+ }
+
+ DBusMessage* reply = ffDBusGetMethodReply(data, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "ListNames", NULL, NULL);
+ if (reply == NULL) {
+ return;
+ }
+
+ DBusMessageIter rootIterator;
+ if (!data->lib->ffdbus_message_iter_init(reply, &rootIterator) || data->lib->ffdbus_message_iter_get_arg_type(&rootIterator) != DBUS_TYPE_ARRAY) {
+ return;
+ }
+
+ DBusMessageIter arrayIterator;
+ data->lib->ffdbus_message_iter_recurse(&rootIterator, &arrayIterator);
+
+ while (true) {
+ if (data->lib->ffdbus_message_iter_get_arg_type(&arrayIterator) != DBUS_TYPE_STRING) {
+ FF_DBUS_ITER_CONTINUE(data, &arrayIterator)
+ }
+
+ const char* busName;
+ data->lib->ffdbus_message_iter_get_basic(&arrayIterator, &busName);
+
+ if (!ffStrStartsWith(busName, FF_DBUS_MPRIS_PREFIX) ||
+ ffStrEquals(busName + strlen(FF_DBUS_MPRIS_PREFIX), "playerctld")) {
+ FF_DBUS_ITER_CONTINUE(data, &arrayIterator)
+ }
+
+ if (getBusProperties(data, busName, result)) {
+ break;
+ }
+
+ FF_DBUS_ITER_CONTINUE(data, &arrayIterator)
+ }
+
+ data->lib->ffdbus_message_unref(reply);
+}
+
+static const char* getMedia(FFMediaResult* result) {
+ FF_DBUS_AUTO_DESTROY_DATA FFDBusData data = {};
+ const char* error = ffDBusLoadData(DBUS_BUS_SESSION, &data);
+ if (error != NULL) {
+ return error;
+ }
+
+ // FIXME: This is shared for both player and media module.
+ // However it uses an option in one specific module
+ if (instance.config.general.playerName.length > 0) {
+ getCustomBus(&data, &instance.config.general.playerName, result);
+ } else {
+ getBestBus(&data, result);
+ }
+
+ return NULL;
+}
+
+#endif
+
+void ffDetectMediaImpl(FFMediaResult* media, bool saveCover) {
+ FF_UNUSED(saveCover); // We don't save the cover to a file for Mpris implementation
+#ifdef FF_HAVE_DBUS
+ const char* error = getMedia(media);
+ ffStrbufAppendS(&media->error, error);
+#else
+ ffStrbufAppendS(&media->error, "Fastfetch was compiled without DBus support");
+#endif
+}
diff --git a/src/detection/media/media_nosupport.c b/src/detection/media/media_nosupport.c
new file mode 100644
index 0000000..e7d1c0f
--- /dev/null
+++ b/src/detection/media/media_nosupport.c
@@ -0,0 +1,5 @@
+#include "media.h"
+
+void ffDetectMediaImpl(FFMediaResult* media) {
+ ffStrbufAppendS(&media->error, "Not supported on this platform");
+}
diff --git a/src/detection/media/media_windows.cpp b/src/detection/media/media_windows.cpp
new file mode 100644
index 0000000..f0ebd35
--- /dev/null
+++ b/src/detection/media/media_windows.cpp
@@ -0,0 +1,421 @@
+extern "C" {
+#include "media.h"
+#include "common/time.h"
+#include "common/windows/unicode.h"
+#include "common/windows/com.h"
+}
+
+#if FF_HAVE_WINRT
+ #include <roapi.h>
+ #include <robuffer.h>
+ #include <winstring.h>
+ #include <asyncinfo.h>
+
+ #include <winrt/Windows.ApplicationModel.h>
+ #include <winrt/Windows.Foundation.h>
+ #include <winrt/Windows.Media.Control.h>
+ #include <winrt/Windows.Storage.Streams.h>
+
+using winrt::impl::abi_t;
+using winrt::Windows::Foundation::IAsyncOperation;
+using winrt::Windows::Foundation::IAsyncOperationWithProgress;
+
+static inline void deleteHstring(HSTRING* pstr) {
+ if (*pstr) {
+ WindowsDeleteString(*pstr);
+ }
+}
+
+static inline void ffStrbufSetHstring(FFstrbuf* destination, HSTRING value) {
+ uint32_t length;
+ const wchar_t* raw = WindowsGetStringRawBuffer(value, &length);
+ ffStrbufSetNWS(destination, length, raw);
+}
+
+template <typename Interface>
+static inline HRESULT ffGetActivationFactory(const wchar_t* className, REFIID iid, Interface** factory) {
+ HSTRING_HEADER header;
+ HSTRING runtimeClass;
+ HRESULT hr = WindowsCreateStringReference(className, (UINT32)::wcslen(className), &header, &runtimeClass);
+ if (FAILED(hr)) {
+ return hr;
+ }
+
+ return RoGetActivationFactory(runtimeClass, iid, reinterpret_cast<void**>(factory));
+}
+
+template <typename TargetProjection, typename SourceAbi>
+static inline HRESULT ffQueryInterface(SourceAbi* source, abi_t<TargetProjection>** target) {
+ return source->QueryInterface(winrt::guid_of<TargetProjection>(), reinterpret_cast<void**>(target));
+}
+
+template <typename TOperationAbi, typename TResultAbi>
+static HRESULT ffWaitForAsyncOperation(TOperationAbi* operation, TResultAbi** result) {
+ IAsyncInfo* FF_AUTO_RELEASE_COM_OBJECT asyncInfo = NULL;
+ HRESULT hr = ffQueryInterface<IAsyncInfo>(operation, &asyncInfo);
+ if (FAILED(hr)) {
+ return hr;
+ }
+
+ AsyncStatus status = AsyncStatus::Started;
+
+ for (;;) {
+ hr = asyncInfo->get_Status(&status);
+ if (FAILED(hr)) {
+ return hr;
+ }
+ if (status == AsyncStatus::Started) {
+ ffTimeSleep(0);
+ } else {
+ break;
+ }
+ }
+
+ if (status != AsyncStatus::Completed) {
+ HRESULT errorCode = E_FAIL;
+ asyncInfo->get_ErrorCode(&errorCode);
+ return FAILED(errorCode) ? errorCode : E_FAIL;
+ }
+
+ return operation->GetResults((void**) result);
+}
+
+template <typename TResultProjection, typename TOperation>
+static HRESULT ffRunAndWait(TOperation&& operation, abi_t<TResultProjection>** result) {
+ abi_t<IAsyncOperation<TResultProjection>>* FF_AUTO_RELEASE_COM_OBJECT opResult = NULL;
+ HRESULT hr = operation(reinterpret_cast<void**>(&opResult));
+ if (FAILED(hr) || !opResult) {
+ return hr;
+ }
+
+ return ffWaitForAsyncOperation(opResult, result);
+}
+
+template <typename TResultProjection, typename TOperation>
+static HRESULT ffRunAndWait2(TOperation&& operation, abi_t<TResultProjection>** result) {
+ *result = NULL;
+
+ abi_t<IAsyncOperationWithProgress<TResultProjection, int32_t>>* FF_AUTO_RELEASE_COM_OBJECT opResult = NULL;
+ HRESULT hr = operation(reinterpret_cast<void**>(&opResult));
+ if (FAILED(hr) || !opResult) {
+ return hr;
+ }
+
+ return ffWaitForAsyncOperation(opResult, result);
+}
+
+static HRESULT ffSaveThumbnailToTempPath(
+ abi_t<winrt::Windows::Storage::Streams::IRandomAccessStreamReference>* thumbnail,
+ FFstrbuf* destination) {
+ abi_t<winrt::Windows::Storage::Streams::IRandomAccessStreamWithContentType>* FF_AUTO_RELEASE_COM_OBJECT contentStream = NULL;
+ HRESULT hr = ffRunAndWait<winrt::Windows::Storage::Streams::IRandomAccessStreamWithContentType>([=](void** result) {
+ return thumbnail->OpenReadAsync(result);
+ },
+ &contentStream);
+ if (FAILED(hr) || !contentStream) {
+ return FAILED(hr) ? hr : E_FAIL;
+ }
+
+ abi_t<winrt::Windows::Storage::Streams::IRandomAccessStream>* FF_AUTO_RELEASE_COM_OBJECT randomAccessStream = NULL;
+ hr = ffQueryInterface<winrt::Windows::Storage::Streams::IRandomAccessStream>(contentStream, &randomAccessStream);
+ if (FAILED(hr)) {
+ return hr;
+ }
+
+ UINT64 size = 0;
+ hr = randomAccessStream->get_Size(&size);
+ if (FAILED(hr) || size == 0) {
+ return FAILED(hr) ? hr : S_FALSE;
+ }
+
+ if (size > 0xFFFFFFFFu) {
+ return HRESULT_FROM_WIN32(ERROR_FILE_TOO_LARGE);
+ }
+
+ abi_t<winrt::Windows::Storage::Streams::IBufferFactory>* FF_AUTO_RELEASE_COM_OBJECT bufferFactory = NULL;
+ hr = ffGetActivationFactory(L"Windows.Storage.Streams.Buffer", winrt::guid_of<winrt::Windows::Storage::Streams::IBufferFactory>(), &bufferFactory);
+ if (FAILED(hr)) {
+ return hr;
+ }
+
+ abi_t<winrt::Windows::Storage::Streams::IBuffer>* FF_AUTO_RELEASE_COM_OBJECT buffer = NULL;
+ hr = bufferFactory->Create((UINT32) size, reinterpret_cast<void**>(&buffer));
+ if (FAILED(hr) || !buffer) {
+ return FAILED(hr) ? hr : E_FAIL;
+ }
+
+ abi_t<winrt::Windows::Storage::Streams::IInputStream>* FF_AUTO_RELEASE_COM_OBJECT inputStream = NULL;
+ hr = ffQueryInterface<winrt::Windows::Storage::Streams::IInputStream>(contentStream, &inputStream);
+ if (FAILED(hr)) {
+ return hr;
+ }
+
+ abi_t<winrt::Windows::Storage::Streams::IBuffer>* FF_AUTO_RELEASE_COM_OBJECT readBuffer = NULL;
+ hr = ffRunAndWait2<winrt::Windows::Storage::Streams::IBuffer>([=](void** result) {
+ return inputStream->ReadAsync(buffer, (uint32_t) size, (uint32_t) winrt::Windows::Storage::Streams::InputStreamOptions::None, result);
+ },
+ &readBuffer);
+ if (FAILED(hr) || !readBuffer) {
+ return FAILED(hr) ? hr : E_FAIL;
+ }
+
+ UINT32 length = 0;
+ hr = readBuffer->get_Length(&length);
+ if (FAILED(hr) || length == 0) {
+ return FAILED(hr) ? hr : S_FALSE;
+ }
+
+ Windows::Storage::Streams::IBufferByteAccess* FF_AUTO_RELEASE_COM_OBJECT byteAccess = NULL;
+ hr = readBuffer->QueryInterface(IID_PPV_ARGS(&byteAccess));
+ if (FAILED(hr)) {
+ return hr;
+ }
+
+ byte* bytes = NULL;
+ hr = byteAccess->Buffer(&bytes);
+ if (FAILED(hr) || !bytes) {
+ return FAILED(hr) ? hr : E_FAIL;
+ }
+
+ wchar_t tempDirectory[MAX_PATH];
+ DWORD tempLength = GetTempPathW(MAX_PATH, tempDirectory);
+ if (tempLength == 0 || tempLength >= MAX_PATH) {
+ return HRESULT_FROM_WIN32(GetLastError());
+ }
+
+ wchar_t tempFilePath[MAX_PATH];
+ if (!GetTempFileNameW(tempDirectory, L"fft", 0, tempFilePath)) {
+ return HRESULT_FROM_WIN32(GetLastError());
+ }
+
+ HANDLE file = CreateFileW(tempFilePath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+ if (file == INVALID_HANDLE_VALUE) {
+ DWORD writeError = GetLastError();
+ DeleteFileW(tempFilePath);
+ return HRESULT_FROM_WIN32(writeError);
+ }
+
+ DWORD written = 0;
+ BOOL writtenOk = WriteFile(file, bytes, length, &written, NULL);
+ NtClose(file);
+ file = NULL;
+
+ if (!writtenOk || written != length) {
+ DWORD writeError = GetLastError();
+ DeleteFileW(tempFilePath);
+ return HRESULT_FROM_WIN32(writtenOk ? ERROR_WRITE_FAULT : writeError);
+ }
+
+ ffStrbufSetWS(destination, tempFilePath);
+ return S_OK;
+}
+
+static const char* getMedia(FFMediaResult* result, bool saveCover) {
+ const char* error = ffInitCom();
+ if (error) {
+ return error;
+ }
+
+ do {
+ abi_t<winrt::Windows::Media::Control::IGlobalSystemMediaTransportControlsSessionManagerStatics>* FF_AUTO_RELEASE_COM_OBJECT managerStatics = NULL;
+ HRESULT hr = ffGetActivationFactory(L"Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager", winrt::guid_of<winrt::Windows::Media::Control::IGlobalSystemMediaTransportControlsSessionManagerStatics>(), &managerStatics);
+ if (FAILED(hr) || !managerStatics) {
+ error = "winrt: RoGetActivationFactory(GlobalSystemMediaTransportControlsSessionManager) failed";
+ break;
+ }
+
+ abi_t<winrt::Windows::Media::Control::IGlobalSystemMediaTransportControlsSessionManager>* FF_AUTO_RELEASE_COM_OBJECT manager = NULL;
+ hr = ffRunAndWait<winrt::Windows::Media::Control::IGlobalSystemMediaTransportControlsSessionManager>([=](void** result) {
+ return managerStatics->RequestAsync(result);
+ },
+ &manager);
+ if (FAILED(hr) || !manager) {
+ error = "winrt: RequestAsync().GetResults() failed";
+ break;
+ }
+
+ FF_A_CLEANUP(deleteHstring) HSTRING playerId = NULL;
+
+ abi_t<winrt::Windows::Media::Control::IGlobalSystemMediaTransportControlsSession>* FF_AUTO_RELEASE_COM_OBJECT session = NULL;
+ if (instance.config.general.playerName.length) {
+ abi_t<winrt::Windows::Foundation::Collections::IVectorView<winrt::Windows::Media::Control::GlobalSystemMediaTransportControlsSession>>* FF_AUTO_RELEASE_COM_OBJECT sessions = NULL;
+ hr = manager->GetSessions(reinterpret_cast<void**>(&sessions));
+ if (FAILED(hr) || !sessions) {
+ error = "winrt: GetSessions() failed";
+ break;
+ }
+ uint32_t sessionCount = 0;
+ hr = sessions->get_Size(&sessionCount);
+ if (FAILED(hr)) {
+ error = "winrt: GetSessions().get_Size() failed";
+ break;
+ }
+ for (uint32_t i = 0; i < sessionCount; i++) {
+ abi_t<winrt::Windows::Media::Control::IGlobalSystemMediaTransportControlsSession>* FF_AUTO_RELEASE_COM_OBJECT currentSession = NULL;
+ hr = sessions->GetAt(i, reinterpret_cast<void**>(&currentSession));
+ if (FAILED(hr) || !currentSession) {
+ continue;
+ }
+
+ hr = currentSession->get_SourceAppUserModelId(reinterpret_cast<void**>(&playerId));
+ if (FAILED(hr) || !playerId) {
+ continue;
+ }
+
+ ffStrbufSetHstring(&result->playerId, playerId);
+
+ if (ffStrbufContainIgnCase(&result->playerId, &instance.config.general.playerName)) {
+ session = currentSession;
+ currentSession = NULL; // Don't release the session object
+ break;
+ }
+ deleteHstring(&playerId);
+ ffStrbufClear(&result->playerId);
+ }
+
+ if (!session) {
+ error = "winrt: No media session found with the specified player name";
+ break;
+ }
+ } else {
+ hr = manager->GetCurrentSession(reinterpret_cast<void**>(&session));
+
+ if (FAILED(hr) || !session) {
+ error = "winrt: GetCurrentSession() failed";
+ break;
+ }
+
+ hr = session->get_SourceAppUserModelId(reinterpret_cast<void**>(&playerId));
+ if (FAILED(hr)) {
+ error = "winrt: get_SourceAppUserModelId() failed";
+ break;
+ }
+
+ ffStrbufSetHstring(&result->playerId, playerId);
+ }
+
+ abi_t<winrt::Windows::Media::Control::IGlobalSystemMediaTransportControlsSessionMediaProperties>* FF_AUTO_RELEASE_COM_OBJECT mediaProps = NULL;
+ hr = ffRunAndWait<winrt::Windows::Media::Control::IGlobalSystemMediaTransportControlsSessionMediaProperties>([=](void** result) {
+ return session->TryGetMediaPropertiesAsync(result);
+ },
+ &mediaProps);
+ if (FAILED(hr) || !mediaProps) {
+ error = "winrt: TryGetMediaPropertiesAsync().GetResults() failed";
+ break;
+ }
+
+ abi_t<winrt::Windows::Media::Control::IGlobalSystemMediaTransportControlsSessionPlaybackInfo>* FF_AUTO_RELEASE_COM_OBJECT playbackInfo = NULL;
+ hr = session->GetPlaybackInfo(reinterpret_cast<void**>(&playbackInfo));
+ bool isPlaying = false;
+ double playbackRate = 1.0;
+ if (SUCCEEDED(hr) && playbackInfo) {
+ int32_t playbackStatusValue = 0;
+ if (SUCCEEDED(playbackInfo->get_PlaybackStatus(&playbackStatusValue))) {
+ isPlaying = playbackStatusValue == static_cast<int32_t>(winrt::Windows::Media::Control::GlobalSystemMediaTransportControlsSessionPlaybackStatus::Playing);
+ switch (static_cast<winrt::Windows::Media::Control::GlobalSystemMediaTransportControlsSessionPlaybackStatus>(playbackStatusValue)) {
+ #define FF_MEDIA_SET_STATUS(status_code) \
+ case winrt::Windows::Media::Control::GlobalSystemMediaTransportControlsSessionPlaybackStatus::status_code: \
+ ffStrbufSetStatic(&result->status, #status_code); \
+ break;
+ FF_MEDIA_SET_STATUS(Closed)
+ FF_MEDIA_SET_STATUS(Opened)
+ FF_MEDIA_SET_STATUS(Changing)
+ FF_MEDIA_SET_STATUS(Stopped)
+ FF_MEDIA_SET_STATUS(Playing)
+ FF_MEDIA_SET_STATUS(Paused)
+ #undef FF_MEDIA_SET_STATUS
+ }
+ }
+
+ abi_t<winrt::Windows::Foundation::IReference<double>>* FF_AUTO_RELEASE_COM_OBJECT playbackRateRef = NULL;
+ if (SUCCEEDED(playbackInfo->get_PlaybackRate(reinterpret_cast<void**>(&playbackRateRef))) && playbackRateRef) {
+ if (SUCCEEDED(playbackRateRef->get_Value(&playbackRate)) && playbackRate < 0.0) {
+ playbackRate = 0.0;
+ }
+ }
+ }
+
+ FF_A_CLEANUP(deleteHstring) HSTRING title = NULL;
+ if (SUCCEEDED(mediaProps->get_Title(reinterpret_cast<void**>(&title)))) {
+ ffStrbufSetHstring(&result->song, title);
+ }
+
+ FF_A_CLEANUP(deleteHstring) HSTRING artist = NULL;
+ if (SUCCEEDED(mediaProps->get_Artist(reinterpret_cast<void**>(&artist)))) {
+ ffStrbufSetHstring(&result->artist, artist);
+ }
+
+ FF_A_CLEANUP(deleteHstring) HSTRING album = NULL;
+ if (SUCCEEDED(mediaProps->get_AlbumTitle(reinterpret_cast<void**>(&album)))) {
+ ffStrbufSetHstring(&result->album, album);
+ }
+
+ abi_t<winrt::Windows::Media::Control::IGlobalSystemMediaTransportControlsSessionTimelineProperties>* FF_AUTO_RELEASE_COM_OBJECT timelineProps = NULL;
+ hr = session->GetTimelineProperties(reinterpret_cast<void**>(&timelineProps));
+ if (SUCCEEDED(hr) && timelineProps) {
+ int64_t duration = 0;
+ if (SUCCEEDED(timelineProps->get_EndTime(&duration)) && duration > 0) {
+ result->length = (uint32_t) (duration / 10000); // Convert from 100-nanosecond units to milliseconds
+
+ int64_t position = 0;
+ if (SUCCEEDED(timelineProps->get_Position(&position))) {
+ result->position = (uint32_t) (position / 10000); // Convert from 100-nanosecond units to milliseconds
+
+ int64_t lastUpdatedTime = 0;
+ if (isPlaying && SUCCEEDED(timelineProps->get_LastUpdatedTime(&lastUpdatedTime)) && lastUpdatedTime > 0) {
+ uint64_t lastUpdatedTimeMs = ffFileTimeToUnixMs((uint64_t) lastUpdatedTime);
+ uint64_t nowMs = ffTimeGetNow();
+ if (nowMs > lastUpdatedTimeMs) {
+ result->position += (uint32_t) (((double) (nowMs - lastUpdatedTimeMs)) * playbackRate);
+ }
+ }
+ }
+ }
+ }
+
+ abi_t<winrt::Windows::ApplicationModel::IAppInfoStatics>* FF_AUTO_RELEASE_COM_OBJECT appInfoStatics = NULL;
+ hr = ffGetActivationFactory(L"Windows.ApplicationModel.AppInfo", winrt::guid_of<winrt::Windows::ApplicationModel::IAppInfoStatics>(), &appInfoStatics);
+ if (SUCCEEDED(hr) && appInfoStatics) {
+ abi_t<winrt::Windows::ApplicationModel::IAppInfo>* FF_AUTO_RELEASE_COM_OBJECT appInfo = NULL;
+ if (SUCCEEDED(appInfoStatics->GetFromAppUserModelId(reinterpret_cast<void*>(playerId), reinterpret_cast<void**>(&appInfo))) && appInfo) {
+ abi_t<winrt::Windows::ApplicationModel::IAppDisplayInfo>* FF_AUTO_RELEASE_COM_OBJECT displayInfo = NULL;
+ if (SUCCEEDED(appInfo->get_DisplayInfo(reinterpret_cast<void**>(&displayInfo))) && displayInfo) {
+ FF_A_CLEANUP(deleteHstring) HSTRING displayName = NULL;
+ if (SUCCEEDED(displayInfo->get_DisplayName(reinterpret_cast<void**>(&displayName)))) {
+ ffStrbufSetHstring(&result->player, displayName);
+ }
+ }
+ }
+ }
+
+ if (result->player.length == 0) {
+ ffStrbufSet(&result->player, &result->playerId);
+ if (ffStrbufEndsWithIgnCaseS(&result->player, ".exe")) {
+ ffStrbufSubstrBefore(&result->player, result->player.length - 4);
+ }
+ }
+
+ if (saveCover) {
+ abi_t<winrt::Windows::Storage::Streams::IRandomAccessStreamReference>* FF_AUTO_RELEASE_COM_OBJECT thumbnail = NULL;
+ hr = mediaProps->get_Thumbnail(reinterpret_cast<void**>(&thumbnail));
+ if (SUCCEEDED(hr) && thumbnail) {
+ if (SUCCEEDED(ffSaveThumbnailToTempPath(thumbnail, &result->cover)) && result->cover.length > 0) {
+ result->removeCoverAfterUse = true;
+ }
+ }
+ }
+ } while (false);
+
+ return error;
+}
+#else
+static const char* getMedia(FFMediaResult* media, bool saveCover) {
+ FF_UNUSED(media, saveCover);
+ return "Fastfetch is not compiled with WinRT support";
+}
+#endif // FF_HAVE_WINRT
+
+extern "C" void ffDetectMediaImpl(FFMediaResult* media, bool saveCover) {
+ const char* error = getMedia(media, saveCover);
+ ffStrbufAppendS(&media->error, error);
+}
generated by cgit v1.2.3 (git 2.46.0) at 2026-09-15 21:22:06 +0000