Added grc, for trimming videos. Added appletCreateGameMovieTrimmer, appletReserveResourceForMovieOperation, and appletUnreserveResourceForMovieOperation. Added structs CapsAlbumFileDateTime/CapsAlbumEntryId and updated CapsAlbumEntry.

nx/include/switch.h

@@ -91,6 +91,7 @@ extern "C" {
 #include "switch/services/wlaninf.h"
 #include "switch/services/pctl.h"
 #include "switch/services/pdm.h"
+#include "switch/services/grc.h"
 
 #include "switch/display/binder.h"
 #include "switch/display/parcel.h"

nx/include/switch/services/applet.h

@@ -1913,6 +1913,27 @@ Result appletGetCurrentApplicationId(u64 *titleID);
  */
 Result appletRequestExitToSelf(void);
 
+/**
+ * @brief CreateGameMovieTrimmer. Do not use this directly, use \ref grcTrimGameMovie instead.
+ * @note Only available with AppletType_LibraryApplet on [4.0.0+].
+ * @note See also \ref appletReserveResourceForMovieOperation and \ref appletUnreserveResourceForMovieOperation.
+ * @param[out] srv_out Output Service for grc IGameMovieTrimmer.
+ * @param[in] tmem TransferMemory
+ */
+Result appletCreateGameMovieTrimmer(Service* srv_out, TransferMemory *tmem);
+
+/**
+ * @brief ReserveResourceForMovieOperation. Must be used at some point prior to \ref appletCreateGameMovieTrimmer.
+ * @note Only available with AppletType_LibraryApplet on [5.0.0+].
+ */
+Result appletReserveResourceForMovieOperation(void);
+
+/**
+ * @brief UnreserveResourceForMovieOperation. Must be used at some point after all finished with GameMovieTrimmer usage (\ref appletCreateGameMovieTrimmer).
+ * @note Only available with AppletType_LibraryApplet on [5.0.0+].
+ */
+Result appletUnreserveResourceForMovieOperation(void);
+
 /**
  * @brief Gets an array of userIDs for the MainApplet AvailableUsers.
  * @note Only available with AppletType_LibraryApplet on [6.0.0+].

nx/include/switch/services/caps.h

@@ -13,9 +13,30 @@ typedef struct {
     u8 unk_x4[0x3c];
 } CapsScreenShotAttribute;
 
+/// AlbumFileDateTime. This corresponds to each field in the Album entry filename, prior to the "-".
+typedef struct {
+    u16 year;                                    ///< Year.
+    u8 month;                                    ///< Month.
+    u8 day;                                      ///< Day.
+    u8 hour;                                     ///< Hour.
+    u8 minute;                                   ///< Minute.
+    u8 second;                                   ///< Second.
+    u8 unk_x7;                                   ///< Unknown.
+} CapsAlbumFileDateTime;
+
+/// AlbumEntryId
+typedef struct {
+    u64 titleID;                                 ///< titleID.
+    CapsAlbumFileDateTime datetime;              ///< \ref CapsAlbumFileDateTime
+    u8 unk_x10;                                  ///< Unknown.
+    u8 unk_x11;                                  ///< Unknown.
+    u8 pad[6];                                   ///< Padding?
+} CapsAlbumEntryId;
+
 /// AlbumEntry
 typedef struct {
-    u8 unk_x0[0x20];
+    u8 unk_x0[0x8];
+    CapsAlbumEntryId id;
 } CapsAlbumEntry;
 
 /// ApplicationAlbumEntry

nx/include/switch/services/grc.h

@@ -0,0 +1,38 @@
+/**
+ * @file grc.h
+ * @brief GRC Game Recording (grc:*) service IPC wrapper.
+ * @author yellows8
+ * @copyright libnx Authors
+ */
+#pragma once
+#include "../types.h"
+#include "../services/sm.h"
+#include "../services/caps.h"
+#include "../kernel/event.h"
+#include "../kernel/tmem.h"
+
+/// GameMovieTrimmer
+typedef struct {
+    Service s;              ///< IGameMovieTrimmer
+    TransferMemory tmem;    ///< TransferMemory
+} GrcGameMovieTrimmer;
+
+/// GameMovieId
+typedef struct {
+    CapsAlbumEntryId album_id;    ///< \ref CapsAlbumEntryId
+    u8 reserved[0x28];            ///< Unused, always zero.
+} GrcGameMovieId;
+
+/**
+ * @brief Creates a \ref GrcGameMovieTrimmer using \ref appletCreateGameMovieTrimmer, uses the cmds from it to trim the specified video, then closes it.
+ * @note See \ref appletCreateGameMovieTrimmer for the requirements for using this.
+ * @note This will block until video trimming finishes.
+ * @param[out] dst_movieid \ref GrcGameMovieTrimmer for the output video.
+ * @param[in] src_movieid \ref GrcGameMovieTrimmer for the input video.
+ * @param[in] tmem_size TransferMemory size. Official sw uses size 0x2000000.
+ * @param[in] thumbnail Optional, can be NULL. RGBA8 1280x720 thumbnail image data.
+ * @param[in] start Start timestamp in 0.5s units.
+ * @param[in] end End timestamp in 0.5s units.
+ */
+Result grcTrimGameMovie(GrcGameMovieId *dst_movieid, const GrcGameMovieId *src_movieid, size_t tmem_size, const void* thumbnail, s32 start, s32 end);
+

nx/source/services/applet.c

@@ -5283,6 +5283,69 @@ Result appletRequestExitToSelf(void) {
     return _appletCmdNoIO(&g_appletILibraryAppletSelfAccessor, 80);
 }
 
+Result appletCreateGameMovieTrimmer(Service* srv_out, TransferMemory *tmem) {
+    if (__nx_applet_type != AppletType_LibraryApplet)
+        return MAKERESULT(Module_Libnx, LibnxError_NotInitialized);
+    if (hosversionBefore(4,0,0))
+        return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
+
+    IpcCommand c;
+    ipcInitialize(&c);
+
+    ipcSendHandleCopy(&c, tmem->handle);
+
+    struct {
+        u64 magic;
+        u64 cmd_id;
+        u64 size;
+    } *raw;
+
+    raw = serviceIpcPrepareHeader(&g_appletILibraryAppletSelfAccessor, &c, sizeof(*raw));
+
+    raw->magic = SFCI_MAGIC;
+    raw->cmd_id = 100;
+    raw->size = tmem->size;
+
+    Result rc = serviceIpcDispatch(&g_appletILibraryAppletSelfAccessor);
+
+    if (R_SUCCEEDED(rc)) {
+        IpcParsedCommand r;
+        struct {
+            u64 magic;
+            u64 result;
+        } *resp;
+
+        serviceIpcParse(&g_appletILibraryAppletSelfAccessor, &r, sizeof(*resp));
+        resp = r.Raw;
+
+        rc = resp->result;
+
+        if (R_SUCCEEDED(rc) && srv_out) {
+            serviceCreateSubservice(srv_out, &g_appletILibraryAppletSelfAccessor, &r, 0);
+        }
+    }
+
+    return rc;
+}
+
+Result appletReserveResourceForMovieOperation(void) {
+    if (__nx_applet_type != AppletType_LibraryApplet)
+        return MAKERESULT(Module_Libnx, LibnxError_NotInitialized);
+    if (hosversionBefore(5,0,0))
+        return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
+
+    return _appletCmdNoIO(&g_appletILibraryAppletSelfAccessor, 101);
+}
+
+Result appletUnreserveResourceForMovieOperation(void) {
+    if (__nx_applet_type != AppletType_LibraryApplet)
+        return MAKERESULT(Module_Libnx, LibnxError_NotInitialized);
+    if (hosversionBefore(5,0,0))
+        return MAKERESULT(Module_Libnx, LibnxError_IncompatSysVer);
+
+    return _appletCmdNoIO(&g_appletILibraryAppletSelfAccessor, 102);
+}
+
 Result appletGetMainAppletAvailableUsers(u128 *userIDs, s32 count, bool *flag, s32 *total_out) {
     if (__nx_applet_type != AppletType_LibraryApplet)
         return MAKERESULT(Module_Libnx, LibnxError_NotInitialized);

nx/source/services/grc.c

@@ -0,0 +1,230 @@
+#include <string.h>
+#include "types.h"
+#include "result.h"
+#include "arm/atomics.h"
+#include "kernel/ipc.h"
+#include "kernel/event.h"
+#include "kernel/tmem.h"
+#include "services/sm.h"
+#include "services/grc.h"
+#include "services/applet.h"
+#include "runtime/hosversion.h"
+
+static void _grcGameMovieTrimmerClose(GrcGameMovieTrimmer *t);
+
+static Result _grcGetEvent(Service* srv, Event* out_event, u64 cmd_id, bool autoclear) {
+    IpcCommand c;
+    ipcInitialize(&c);
+
+    struct {
+        u64 magic;
+        u64 cmd_id;
+    } *raw;
+
+    raw = serviceIpcPrepareHeader(srv, &c, sizeof(*raw));
+
+    raw->magic = SFCI_MAGIC;
+    raw->cmd_id = cmd_id;
+
+    Result rc = serviceIpcDispatch(srv);
+
+    if (R_SUCCEEDED(rc)) {
+        IpcParsedCommand r;
+        struct {
+            u64 magic;
+            u64 result;
+        } *resp;
+
+        serviceIpcParse(srv, &r, sizeof(*resp));
+        resp = r.Raw;
+
+        rc = resp->result;
+
+        if (R_SUCCEEDED(rc)) {
+            eventLoadRemote(out_event, r.Handles[0], autoclear);
+        }
+    }
+
+    return rc;
+}
+
+static Result _grcCreateGameMovieTrimmer(GrcGameMovieTrimmer *t, size_t size) {
+    Result rc=0;
+    Result retryrc = MAKERESULT(212, 4);
+
+    memset(t, 0, sizeof(*t));
+
+    rc = tmemCreate(&t->tmem, size, Perm_None);
+    if (R_SUCCEEDED(rc)) {
+        rc = appletCreateGameMovieTrimmer(&t->s, &t->tmem);
+
+        while(rc == retryrc) {
+            svcSleepThread(100000000);
+            rc = appletCreateGameMovieTrimmer(&t->s, &t->tmem);
+        }
+    }
+
+    if (R_FAILED(rc)) _grcGameMovieTrimmerClose(t);
+
+    return rc;
+}
+
+// IGameMovieTrimmer
+
+static void _grcGameMovieTrimmerClose(GrcGameMovieTrimmer *t) {
+    serviceClose(&t->s);
+    tmemClose(&t->tmem);
+}
+
+static Result _grcGameMovieTrimmerBeginTrim(GrcGameMovieTrimmer *t, const GrcGameMovieId *id, s32 start, s32 end) {
+    if (!serviceIsActive(&t->s))
+        return MAKERESULT(Module_Libnx, LibnxError_NotInitialized);
+
+    IpcCommand c;
+    ipcInitialize(&c);
+
+    struct {
+        u64 magic;
+        u64 cmd_id;
+        s32 start;
+        s32 end;
+        GrcGameMovieId id;
+    } *raw;
+
+    raw = serviceIpcPrepareHeader(&t->s, &c, sizeof(*raw));
+
+    raw->magic = SFCI_MAGIC;
+    raw->cmd_id = 1;
+    raw->start = start;
+    raw->end = end;
+    memcpy(&raw->id, id, sizeof(GrcGameMovieId));
+
+    Result rc = serviceIpcDispatch(&t->s);
+
+    if (R_SUCCEEDED(rc)) {
+        IpcParsedCommand r;
+        struct {
+            u64 magic;
+            u64 result;
+        } *resp;
+
+        serviceIpcParse(&t->s, &r, sizeof(*resp));
+        resp = r.Raw;
+
+        rc = resp->result;
+    }
+
+    return rc;
+}
+
+static Result _grcGameMovieTrimmerEndTrim(GrcGameMovieTrimmer *t, GrcGameMovieId *id) {
+    if (!serviceIsActive(&t->s))
+        return MAKERESULT(Module_Libnx, LibnxError_NotInitialized);
+
+    IpcCommand c;
+    ipcInitialize(&c);
+
+    struct {
+        u64 magic;
+        u64 cmd_id;
+    } *raw;
+
+    raw = serviceIpcPrepareHeader(&t->s, &c, sizeof(*raw));
+
+    raw->magic = SFCI_MAGIC;
+    raw->cmd_id = 2;
+
+    Result rc = serviceIpcDispatch(&t->s);
+
+    if (R_SUCCEEDED(rc)) {
+        IpcParsedCommand r;
+        struct {
+            u64 magic;
+            u64 result;
+            GrcGameMovieId id;
+        } *resp;
+
+        serviceIpcParse(&t->s, &r, sizeof(*resp));
+        resp = r.Raw;
+
+        rc = resp->result;
+
+        if (R_SUCCEEDED(rc) && id) memcpy(id, &resp->id, sizeof(GrcGameMovieId));
+    }
+
+    return rc;
+}
+
+static Result _grcGameMovieTrimmerGetNotTrimmingEvent(GrcGameMovieTrimmer *t, Event *out_event) {
+    if (!serviceIsActive(&t->s))
+        return MAKERESULT(Module_Libnx, LibnxError_NotInitialized);
+
+    return _grcGetEvent(&t->s, out_event, 10, false);
+}
+
+static Result _grcGameMovieTrimmerSetThumbnailRgba(GrcGameMovieTrimmer *t, const void* buffer, size_t size, s32 width, s32 height) {
+    if (!serviceIsActive(&t->s))
+        return MAKERESULT(Module_Libnx, LibnxError_NotInitialized);
+
+    IpcCommand c;
+    ipcInitialize(&c);
+
+    ipcAddSendBuffer(&c, buffer, size, BufferType_Type1);
+
+    struct {
+        u64 magic;
+        u64 cmd_id;
+        s32 width;
+        s32 height;
+    } *raw;
+
+    raw = serviceIpcPrepareHeader(&t->s, &c, sizeof(*raw));
+
+    raw->magic = SFCI_MAGIC;
+    raw->cmd_id = 20;
+    raw->width = width;
+    raw->height = height;
+
+    Result rc = serviceIpcDispatch(&t->s);
+
+    if (R_SUCCEEDED(rc)) {
+        IpcParsedCommand r;
+        struct {
+            u64 magic;
+            u64 result;
+        } *resp;
+
+        serviceIpcParse(&t->s, &r, sizeof(*resp));
+        resp = r.Raw;
+
+        rc = resp->result;
+    }
+
+    return rc;
+}
+
+Result grcTrimGameMovie(GrcGameMovieId *dst_movieid, const GrcGameMovieId *src_movieid, size_t tmem_size, const void* thumbnail, s32 start, s32 end) {
+    Result rc=0;
+    GrcGameMovieTrimmer trimmer={0};
+    Event trimevent={0};
+
+    rc = _grcCreateGameMovieTrimmer(&trimmer, tmem_size);
+
+    if (R_SUCCEEDED(rc)) {
+        if (thumbnail) rc = _grcGameMovieTrimmerSetThumbnailRgba(&trimmer, thumbnail, 1280*720*4, 1280, 720);
+
+        if (R_SUCCEEDED(rc)) rc = _grcGameMovieTrimmerGetNotTrimmingEvent(&trimmer, &trimevent);
+
+        if (R_SUCCEEDED(rc)) rc = _grcGameMovieTrimmerBeginTrim(&trimmer, src_movieid, start, end);
+
+        if (R_SUCCEEDED(rc)) rc = eventWait(&trimevent, U64_MAX);
+
+        if (R_SUCCEEDED(rc)) rc = _grcGameMovieTrimmerEndTrim(&trimmer, dst_movieid);
+
+        eventClose(&trimevent);
+        _grcGameMovieTrimmerClose(&trimmer);
+    }
+
+    return rc;
+}
+