huge changes to everything (see below).

Changelog:
- re-enable use in release build.
- remove ftpsrv and untitled from builtin ghdl options, as both packages are available in the appstore.
- add image viewer (png, jpg, bmp)
- add music player (bfstm, bfwav, mp3, wav, ogg)
- add idv3 tag parsing support for mp3.
- add "decyption" of GTA Vice City mp3.
- add usbdvd support for music playback and file browsing.
- add nsz export support (solid, block, ldm).
- add xcz export support (same as above).
- add nro fs proper mount support (romfs, nacp, icon).
- add program nca fs support.
- add bfsar fs support.
- re-write the usb protocol, still wip. replaces tinfoil protocol.
- all threads are now create with pre-emptive support with the proper affinity mask set.
- fix oob crash in libpulsar when a bfwav was opened that had more than 2 channels.
- bump yyjson version.
- bump usbhsfs version.
- disable nvjpg.
- add support for theme music of any supported playback type (bfstm, bfwav, mp3, wav, ogg).
- add support for setting background music.
- add async exit to blocking threads (download, nxlink, ftpsrv) to reduce exit time.
- add support for dumping to pc via usb.
- add null, deflate, zstd hash options, mainly used for benchmarking.
- add sidebar slider (currently unused).
- file_viwer can now be used with any filesystem.
- filebrowser will only ever stat file once. previously it would keep stat'ing until it succeeded.
- disabled themezer due to the api breaking and i am not willing to keep maintaining it.
- disable zlt handling in usbds as it's not needed for my api's because the size is always known.
- remove usbds enums and GetSpeed() as i pr'd it to libnx.
- added support for mounting nca's from any source, including files, memory, nsps, xcis etc.
- split the lru cache into it's own header as it's now used in multiple places (nsz, all mounted options).
- add support for fetching and decrypting es personalised tickets.
- fix es common ticket converting where i forgot to also convert the cert chain as well.
- remove the download default music option.
- improve performance of libpulsar when opening a bfsar by remove the large setvbuf option. instead, use the default 1k buffer and handle large buffers manually in sphaira by using a lru cache (todo: just write my own bfsar parser).
- during app init and exit, load times have been halved as i now load/exit async. timestamps have also been added to measure how long everything takes.
- download now async loads / exits the etag json file to improve init times.
- add custom zip io to dumper to support writing a zip to any dest (such as usb).
- dumper now returns a proper error if the transfer was cancelled by the user.
- fatfs mount now sets the timestamp for files.
- fatfs mount handles folders with the archive bit by reporting them as a file.
- ftpsrv config is async loaded to speed up load times.
- nxlink now tries attempt to connect/accept by handling blocking rather than just bailing out.
- added support for minini floats.
- thread_file_transfer now spawns 3 threads rather than 2, to have the middle thread be a optional processor (mainly used for compressing/decompressing).
- added spinner to progress box, taken from nvg demo.
- progress box disables sleep mode on init.
- add gamecard detection to game menu to detect a refresh.
- handle xci that have the key area prepended.
- change gamecard mount fs to use the xci mount code instead of native fs, that way we can see all the partitions rather than just secure.
- reformat the ghdl entries to show the timestamp first.
- support for exporting saves to pc via usb.
- zip fs now uses lru cache.

tools/usb_common.py

@@ -0,0 +1,89 @@
+import struct
+import usb.core
+import usb.util
+import time
+
+# magic number (SPH0) for the script and switch.
+MAGIC = 0x53504830
+
+# commands
+CMD_QUIT = 0
+CMD_OPEN = 1
+CMD_EXPORT = 1
+
+# results
+RESULT_OK = 0
+RESULT_ERROR = 1
+
+# flags
+FLAG_NONE = 0
+FLAG_STREAM = 1 << 0
+
+# disabled, see usbds.cpp usbDsEndpoint_SetZlt
+ENABLE_ZLT = 0
+
+class Usb:
+    def __init__(self):
+        self.__out_ep = None
+        self.__in_ep = None
+        self.__packet_size = 0
+
+    def wait_for_connect(self) -> None:
+        print("waiting for switch")
+
+        dev = None
+        while (dev is None):
+            dev = usb.core.find(idVendor=0x057E, idProduct=0x3000)
+            if (dev is None):
+                time.sleep(0.5)
+
+        print("found the switch!\n")
+        cfg = None
+
+        try:
+            cfg = dev.get_active_configuration()
+            print("found active config")
+        except usb.core.USBError:
+            print("no currently active config")
+            cfg = None
+
+        if cfg is None:
+            dev.reset()
+            dev.set_configuration()
+            cfg = dev.get_active_configuration()
+
+        is_out_ep = lambda ep: usb.util.endpoint_direction(ep.bEndpointAddress) == usb.util.ENDPOINT_OUT
+        is_in_ep = lambda ep: usb.util.endpoint_direction(ep.bEndpointAddress) == usb.util.ENDPOINT_IN
+        self.__out_ep = usb.util.find_descriptor(cfg[(0,0)], custom_match=is_out_ep)
+        self.__in_ep = usb.util.find_descriptor(cfg[(0,0)], custom_match=is_in_ep)
+        assert self.__out_ep is not None
+        assert self.__in_ep is not None
+
+        print("iManufacturer: {} iProduct: {} iSerialNumber: {}".format(dev.manufacturer, dev.product, dev.serial_number))
+        print("bcdUSB: {} bMaxPacketSize0: {}".format(hex(dev.bcdUSB), dev.bMaxPacketSize0))
+        self.__packet_size = 1 << dev.bMaxPacketSize0
+
+    def read(self, size: int, timeout: int = 0) -> bytes:
+        if (ENABLE_ZLT and size and (size % self.__packet_size) == 0):
+            size += 1
+        return self.__in_ep.read(size, timeout)
+
+    def write(self, buf: bytes, timeout: int = 0) -> int:
+        return self.__out_ep.write(data=buf, timeout=timeout)
+
+    def get_send_header(self) -> tuple[int, int, int]:
+        header = self.read(16)
+        [magic, arg2, arg3, arg4] = struct.unpack('<IIII', header)
+
+        if magic != MAGIC:
+            raise Exception("Unexpected magic {}".format(magic))
+
+        return arg2, arg3, arg4
+
+    def get_send_data_header(self) -> tuple[int, int, int]:
+        header = self.read(16)
+        return struct.unpack('<QII', header)
+
+    def send_result(self, result: int, arg3: int = 0, arg4: int = 0) -> None:
+        send_data = struct.pack('<IIII', MAGIC, result, arg3, arg4)
+        self.write(send_data)